perf(files): coalesce concurrent renders of the same missing artifact

An artifact miss is identical for every concurrent reader — a freshly forked
workspace whose document several viewers open at once, or one request whose
blocks read the same file — and each was paying for its own compile of the same
bytes. Share one in-flight render per (workspace, source, ext) key and drop the
entry as soon as it settles, so a later read still re-renders normally.

Author: j15z

apps/sim/lib/copilot/tools/server/files/doc-compile.ts

@@ -502,6 +502,27 @@ function compiledCacheSet(key: string, buffer: Buffer): void {
  */
 const unrenderableSources = new Set<string>()
 
+/**
+ * Renders in flight, keyed identically to {@link compiledDocCache}. An artifact
+ * miss is the same for every concurrent reader — a freshly forked workspace whose
+ * document several viewers open at once, or one request whose blocks read the same
+ * file — and rendering is the expensive step, so they share one run instead of each
+ * paying for it. The entry is dropped as soon as the render settles, so a later read
+ * re-renders normally rather than replaying a stale result.
+ */
+const inFlightRenders = new Map<string, Promise<{ buffer: Buffer; contentType: string }>>()
+
+function coalesceRender(
+  key: string,
+  run: () => Promise<{ buffer: Buffer; contentType: string }>
+): Promise<{ buffer: Buffer; contentType: string }> {
+  const existing = inFlightRenders.get(key)
+  if (existing) return existing
+  const started = run().finally(() => inFlightRenders.delete(key))
+  inFlightRenders.set(key, started)
+  return started
+}
+
 function markUnrenderable(key: string): void {
   if (unrenderableSources.size >= MAX_COMPILED_DOC_CACHE) {
     unrenderableSources.delete(unrenderableSources.values().next().value as string)
@@ -624,7 +645,7 @@ export async function resolveServableDocBytes(args: {
     // (content-addressed), so racing a still-running write-time compile is wasteful
     // but correct.
     try {
-      return await compileDoc({ source, fileName, workspaceId })
+      return await coalesceRender(renderKey, () => compileDoc({ source, fileName, workspaceId }))
     } catch (error) {
       // Only a script error is deterministic — the same bytes will never render, so
       // remembering that is safe. Infra failures (sandbox create/timeout, S3, an
@@ -646,13 +667,15 @@ export async function resolveServableDocBytes(args: {
   }
 
   try {
-    const compiled = await runSandboxTask(
-      format.taskId,
-      { code: source, workspaceId: workspaceId || '' },
-      { ownerKey, signal }
-    )
-    compiledCacheSet(renderKey, compiled)
-    return { buffer: compiled, contentType: format.contentType }
+    return await coalesceRender(renderKey, async () => {
+      const compiled = await runSandboxTask(
+        format.taskId,
+        { code: source, workspaceId: workspaceId || '' },
+        { ownerKey, signal }
+      )
+      compiledCacheSet(renderKey, compiled)
+      return { buffer: compiled, contentType: format.contentType }
+    })
   } catch (error) {
     // Unlike the E2B engine, the isolated-vm task does not distinguish a script
     // error from an infra one, so the only signal available here is cancellation —

apps/sim/lib/copilot/tools/server/files/doc-servable.test.ts

@@ -137,6 +137,35 @@ describe('resolveServableDocBytes', () => {
     expect(result.contentType).toBe('application/octet-stream')
   })
 
+  it('coalesces concurrent reads of the same missing artifact into one render', async () => {
+    // A freshly forked workspace can have several viewers open the same document at
+    // once; each would otherwise pay for its own compile of identical bytes.
+    const source = uniqueSource('from reportlab.pdfgen import canvas')
+    mockLoadCompiledDoc.mockResolvedValue(null)
+    setEnvFlags({ isDocSandboxEnabled: true })
+    mockExecuteInSandbox.mockImplementation(
+      () =>
+        new Promise((resolve) =>
+          setTimeout(
+            () => resolve({ exportedFileContent: Buffer.from('%PDF-once').toString('base64') }),
+            5
+          )
+        )
+    )
+
+    const args = { rawBuffer: source, fileName: 'report.pdf', workspaceId: WORKSPACE_ID }
+    const [a, b, c] = await Promise.all([
+      resolveServableDocBytes(args),
+      resolveServableDocBytes(args),
+      resolveServableDocBytes(args),
+    ])
+
+    expect(mockExecuteInSandbox).toHaveBeenCalledTimes(1)
+    expect(a.buffer.toString()).toBe('%PDF-once')
+    expect(b.buffer.toString()).toBe('%PDF-once')
+    expect(c.buffer.toString()).toBe('%PDF-once')
+  })
+
   it('does not re-run the sandbox for bytes that already failed to render', async () => {
     const notReallyAPdf = uniqueSource('<html>still not a pdf</html>')
     mockLoadCompiledDoc.mockResolvedValue(null)