@@ -20,7 +20,6 @@ import {
   getErrorMessage,
   getPostgresConstraintName,
   getPostgresErrorCode,
-  isPostgresCommitRejection,
 } from '@sim/utils/errors'
 import { generateShortId } from '@sim/utils/id'
 import { omit } from '@sim/utils/object'
@@ -582,6 +581,30 @@ async function discardStagedFileContent(staged: StagedFileContent): Promise<void
   })
 }
 
+const POSTGRES_COMMIT_REJECTION_CODES = new Set([
+  '23000',
+  '23001',
+  '23502',
+  '23503',
+  '23505',
+  '23514',
+  '23P01',
+  '40000',
+  '40001',
+  '40002',
+  '40P01',
+])
+
+/**
+ * Recognizes explicit PostgreSQL constraint/rollback rejections at COMMIT. Use only on the
+ * transaction's rejection after its callback completed, never on errors from post-commit work.
+ * Unknown outcomes, including 40003 and connection failures, are not safe cleanup authority.
+ */
+function isPostgresCommitRejection(error: unknown): boolean {
+  const code = getPostgresErrorCode(error)
+  return code !== undefined && POSTGRES_COMMIT_REJECTION_CODES.has(code)
+}
+
 /** Discards known rollbacks while retaining bytes whose COMMIT outcome is uncertain. */
 async function finalizeStagedFileContent<T>(
   staged: StagedFileContent,
 
@@ -1,4 +1,4 @@
-import { tokenizer } from 'acorn'
+import ts from '@typescript/typescript6'
 import { DocCompileUserError } from '@/lib/uploads/documents/compile-error'
 
 export type DocumentSourceLanguage = 'javascript' | 'python'
@@ -18,31 +18,55 @@ interface SourceToken {
 const FILE_HELPERS = new Set(['getFileBase64', 'addImage', 'drawImage', 'input_path'])
 
 function* javascriptTokens(source: string): Generator<SourceToken> {
-  try {
-    const tokens = tokenizer(source, { ecmaVersion: 'latest', allowHashBang: true })
-    for (let token = tokens.getToken(); token.type.label !== 'eof'; token = tokens.getToken()) {
-      const label = token.type.label
-      if (label === 'string') {
-        yield {
-          kind: 'string',
-          value: source.slice(token.start + 1, token.end - 1),
-          start: token.start + 1,
-        }
-      } else if (label === 'template') {
-        if (source[token.start - 1] === '`' && source[token.end] === '`') {
-          yield { kind: 'string', value: source.slice(token.start, token.end), start: token.start }
-        }
-      } else {
-        yield {
-          kind: label === 'name' ? 'word' : 'punctuation',
-          value: source.slice(token.start, token.end),
-          start: token.start,
-        }
+  const fileName = 'document.js'
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.JS
+  )
+  const program = ts.createProgram(
+    [fileName],
+    { allowJs: true, noLib: true, noResolve: true },
+    {
+      getSourceFile: (name) => (name === fileName ? sourceFile : undefined),
+      getDefaultLibFileName: () => '',
+      writeFile: () => {},
+      getCurrentDirectory: () => '',
+      getDirectories: () => [],
+      fileExists: (name) => name === fileName,
+      readFile: (name) => (name === fileName ? source : undefined),
+      getCanonicalFileName: (name) => name,
+      useCaseSensitiveFileNames: () => true,
+      getNewLine: () => '\n',
+    }
+  )
+  const diagnostic = program.getSyntacticDiagnostics(sourceFile)[0]
+  if (diagnostic) {
+    throw new DocCompileUserError(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'))
+  }
+
+  const pending: ts.Node[] = [sourceFile]
+  while (pending.length > 0) {
+    const node = pending.pop()
+    if (!node) break
+    if (ts.isStringLiteralLike(node)) {
+      const start = node.getStart(sourceFile) + 1
+      yield { kind: 'string', value: source.slice(start, node.end - 1), start }
+      continue
+    }
+    const children = node.getChildren(sourceFile)
+    if (children.length > 0) {
+      for (let index = children.length - 1; index >= 0; index--) pending.push(children[index])
+    } else {
+      const start = node.getStart(sourceFile)
+      yield {
+        kind: ts.isIdentifier(node) ? 'word' : 'punctuation',
+        value: source.slice(start, node.end),
+        start,
       }
     }
-  } catch (error) {
-    if (error instanceof SyntaxError) throw new DocCompileUserError(error.message)
-    throw error
   }
 }
 
 
@@ -51,11 +51,18 @@ export async function markFileSearchArtifactReadyInTx(
   const [state] = await tx.select().from(workspaceFileSearchRevision).where(predicate).limit(1)
   if (state?.buildId) {
     const [build] = await tx
-      .select({ artifactKey: workspaceFileSearchBuild.artifactKey })
+      .select({
+        artifactKey: workspaceFileSearchBuild.artifactKey,
+        live: sql<boolean>`${workspaceFileSearchBuild.expiresAt} > clock_timestamp()`,
+      })
       .from(workspaceFileSearchBuild)
       .where(eq(workspaceFileSearchBuild.id, state.buildId))
       .for('update')
-    if (state.status === 'ready' && build?.artifactKey === input.artifactKey) return false
+    if (
+      build?.artifactKey === input.artifactKey &&
+      (state.status === 'ready' || (state.status === 'pending' && build.live))
+    )
+      return false
     await tx
       .update(workspaceFileSearchBuild)
       .set({ expiresAt: sql`clock_timestamp()` })
 
@@ -201,6 +201,24 @@ export async function beginFileSearchBuild(
   })
 }
 
+/** Records the selected artifact before extraction so repeated render receipts preserve this build. */
+export async function bindFileSearchBuildArtifact(
+  build: FileSearchBuild,
+  artifactKey: string,
+  dependencies: readonly FileSearchDependencyIdentity[]
+): Promise<boolean> {
+  return db.transaction(async (tx) => {
+    await configureFileSearchTransaction(tx, FILE_SEARCH_INDEX_TRANSACTION_LIMITS)
+    if (!(await lockFileSearchInputs(tx, build, dependencies)) || !(await lockBuild(tx, build)))
+      return false
+    await tx
+      .update(workspaceFileSearchBuild)
+      .set({ artifactKey })
+      .where(eq(workspaceFileSearchBuild.id, build.id))
+    return true
+  })
+}
+
 /** Each batch is fenced and work-bounded; no file or parser work runs inside this transaction. */
 export async function appendFileSearchChunks(
   build: FileSearchBuild,
 
@@ -28,6 +28,7 @@ import {
 import {
   appendFileSearchChunks,
   beginFileSearchBuild,
+  bindFileSearchBuildArtifact,
   type FileSearchBuild,
   type FileSearchRevision,
   failFileSearchRevision,
@@ -117,6 +118,8 @@ export async function indexWorkspaceFileForSearch(
     const source = await loadFileSearchSource(revision, signal)
     if (!source) return
     const { file, bytes, dependencies, artifactKey } = source
+    if (artifactKey && !(await bindFileSearchBuildArtifact(build, artifactKey, dependencies)))
+      return
     const extracted = await extractIndexText(bytes, file.originalName, signal)
     if (!extracted) {
       await publishFileSearchBuild(
 
@@ -324,7 +324,38 @@ describe('owner-scoped indexed file search on PostgreSQL and stored bytes', () =
         })
         expect(served.buffer).toEqual(artifact)
         expect(served.contributingFiles?.map((file) => file.context)).toEqual([context])
-        await indexWorkspaceFileForSearch({ owner, ...(await claim(generated.id)) }, signal)
+        const extraction = await import('@/lib/workspace-files/search/extract')
+        const extract = extraction.extractIndexText
+        const entered = createDeferred<void>()
+        const release = createDeferred<void>()
+        const pause = vi
+          .spyOn(extraction, 'extractIndexText')
+          .mockImplementationOnce(async (...args) => {
+            entered.resolve()
+            await release.promise
+            return extract(...args)
+          })
+        const indexing = indexWorkspaceFileForSearch(
+          { owner, ...(await claim(generated.id)) },
+          signal
+        )
+        await entered.promise
+        try {
+          for (let repeat = 0; repeat < 2; repeat++) {
+            const cached = await fetchAuthorizedServableWorkspaceFileBuffer(
+              generated,
+              f.principal,
+              {
+                maxBytes: 1024 * 1024,
+              }
+            )
+            expect(cached.buffer).toEqual(artifact)
+          }
+        } finally {
+          release.resolve()
+          await indexing
+          pause.mockRestore()
+        }
         const read = () =>
           searchWorkspaceFileContent.execute({
             principal: f.principal,
 
@@ -168,7 +168,6 @@
     "@xterm/addon-webgl": "0.19.0",
     "@xterm/xterm": "6.0.0",
     "@xyflow/react": "12.11.3",
-    "acorn": "8.17.0",
     "ajv": "8.18.0",
     "archiver": "8.0.0",
     "better-auth": "1.6.27",
 
@@ -4,7 +4,6 @@ import {
   getPostgresCancellationReason,
   getPostgresErrorCode,
   getTransientDatabaseFailure,
-  isPostgresCommitRejection,
 } from '@sim/utils/errors'
 import { describe, expect, it } from 'vitest'
 
@@ -237,28 +236,3 @@ describe('describeError', () => {
     expect(described?.causeChain?.length).toBeLessThanOrEqual(10)
   })
 })
-
-describe('isPostgresCommitRejection', () => {
-  it('recognizes a deferred constraint rejection through a transaction wrapper', () => {
-    const rejection = Object.assign(new Error('deferred constraint failed'), { code: '23514' })
-    expect(isPostgresCommitRejection(new Error('transaction failed', { cause: rejection }))).toBe(
-      true
-    )
-  })
-
-  it.each(['40003', '08007', 'CONNECTION_CLOSED', 'ECONNRESET', undefined])(
-    'does not treat uncertain outcome %s as permission to discard staged data',
-    (code) => {
-      const error = Object.assign(new Error('commit outcome unavailable'), { code })
-      expect(isPostgresCommitRejection(error)).toBe(false)
-    }
-  )
-
-  it('does not replace an outer connection failure with a nested rejection code', () => {
-    const rejection = Object.assign(new Error('earlier constraint failure'), { code: '23514' })
-    const connection = Object.assign(new Error('connection lost', { cause: rejection }), {
-      code: 'CONNECTION_CLOSED',
-    })
-    expect(isPostgresCommitRejection(connection)).toBe(false)
-  })
-})
@@ -30,30 +30,6 @@ export function getPostgresErrorCode(error: unknown): string | undefined {
   return readPgErrorField(error, 'code')
 }
 
-const POSTGRES_COMMIT_REJECTION_CODES = new Set([
-  '23000',
-  '23001',
-  '23502',
-  '23503',
-  '23505',
-  '23514',
-  '23P01',
-  '40000',
-  '40001',
-  '40002',
-  '40P01',
-])
-
-/**
- * Recognizes explicit PostgreSQL constraint/rollback rejections at COMMIT. Use only on the
- * transaction's rejection after its callback completed, never on errors from post-commit work.
- * Unknown outcomes, including 40003 and connection failures, are not safe cleanup authority.
- */
-export function isPostgresCommitRejection(error: unknown): boolean {
-  const code = getPostgresErrorCode(error)
-  return code !== undefined && POSTGRES_COMMIT_REJECTION_CODES.has(code)
-}
-
 const POSTGRES_CANCELLATION_REASONS = [
   ['57014', 'canceling statement due to statement timeout', 'statement_timeout'],
   ['57014', 'canceling statement due to user request', 'user_cancel'],