improvement(files): simplify the archive route and stop buffering real uploads

Four review passes over the branch converged on the same points.

Routing every office extension through the buffered path held an entire selection
of genuinely uploaded documents in memory — for a check the resolver settles on
the first few magic bytes. Only files stored under a generator-source content
type need resolving; a real .docx serves what is stored and now streams like
anything else, which is what the change was for.

With resolution sequential, the AbortController cancelled nothing (its signal
never reached the storage read), the success-path over-limit branch was
unreachable, and the cancellation guard in the catch could not fire. A plain loop
that returns at the point of failure replaces the outcome record, the sentinel,
the fan-out helper at limit 1, and four post-hoc scans. ZIP_MATERIALIZE_CONCURRENCY
was dead, and the aggregate over-limit message reported a byte count that was by
construction under the limit.

lazystream and its types are gone: Readable.from over an async generator defers
the open the same way and propagates source errors natively, so the PassThrough
relay went with them. The client uses requestRaw with the existing binary
contract instead of a hand-built query string and a re-typed error extractor, and
both archive call sites share one callback. The render headroom moves beside
isRenderableDocumentName, the servable reader stops minting a request id per
file, and the v1 download returns a view rather than a second full copy.

Author: waleedlatif1

apps/sim/app/api/v1/files/[fileId]/route.ts

@@ -79,20 +79,24 @@ export const GET = withRouteHandler(async (request: NextRequest, context: FileRo
       { groups: { workspace: workspaceId } }
     )
 
-    return new Response(new Uint8Array(buffer), {
-      status: 200,
-      headers: {
-        'Content-Type': contentType || fileRecord.type || 'application/octet-stream',
-        'Content-Disposition': `attachment; filename="${fileRecord.name.replace(/[^\w.-]/g, '_')}"; filename*=UTF-8''${encodeURIComponent(fileRecord.name)}`,
-        'Content-Length': String(buffer.length),
-        'X-File-Id': fileRecord.id,
-        'X-File-Name': encodeURIComponent(fileRecord.name),
-        'X-Uploaded-At':
-          fileRecord.uploadedAt instanceof Date
-            ? fileRecord.uploadedAt.toISOString()
-            : String(fileRecord.uploadedAt),
-      },
-    })
+    // View, not copy — a second full copy would double peak memory for a large file.
+    return new Response(
+      new Uint8Array(buffer.buffer as ArrayBuffer, buffer.byteOffset, buffer.byteLength),
+      {
+        status: 200,
+        headers: {
+          'Content-Type': contentType || fileRecord.type || 'application/octet-stream',
+          'Content-Disposition': `attachment; filename="${fileRecord.name.replace(/[^\w.-]/g, '_')}"; filename*=UTF-8''${encodeURIComponent(fileRecord.name)}`,
+          'Content-Length': String(buffer.length),
+          'X-File-Id': fileRecord.id,
+          'X-File-Name': encodeURIComponent(fileRecord.name),
+          'X-Uploaded-At':
+            fileRecord.uploadedAt instanceof Date
+              ? fileRecord.uploadedAt.toISOString()
+              : String(fileRecord.uploadedAt),
+        },
+      }
+    )
   } catch (error) {
     // A generated doc whose artifact is still compiling is retryable, not a fault:
     // without this the caller sees a 500 and has no reason to try again.

apps/sim/app/api/workspaces/[id]/files/download/route.test.ts

@@ -71,6 +71,11 @@ function workspaceFile(id: string, name: string, folderId: string | null = 'fold
   }
 }
 
+/** A file whose stored bytes are a generator source, so it must be resolved. */
+function generatedDocument(id: string, name: string, folderId: string | null = 'folder-1') {
+  return { ...workspaceFile(id, name, folderId), type: 'text/x-docxjs' }
+}
+
 function requestFor(query: string) {
   return createMockRequest(
     'GET',
@@ -96,7 +101,7 @@ describe('workspace files download route', () => {
   })
 
   it('zips the rendered bytes for a generated doc, not its stored source', async () => {
-    mockListWorkspaceFiles.mockResolvedValue([workspaceFile('f1', 'overview.docx')])
+    mockListWorkspaceFiles.mockResolvedValue([generatedDocument('f1', 'overview.docx')])
     // A real .docx is a ZIP; the stored source would be plain JS text.
     const rendered = Buffer.from('PKrendered-docx')
     mockFetchServableWorkspaceFileBuffer.mockResolvedValue({
@@ -139,7 +144,7 @@ describe('workspace files download route', () => {
       { id: 'folder-2', name: 'visuals', parentId: 'folder-1' },
     ])
     mockListWorkspaceFiles.mockResolvedValue([
-      workspaceFile('f1', 'summary.docx', 'folder-1'),
+      generatedDocument('f1', 'summary.docx', 'folder-1'),
       workspaceFile('f2', 'hero.png', 'folder-2'),
     ])
     mockFetchServableWorkspaceFileBuffer.mockResolvedValue({
@@ -155,8 +160,8 @@ describe('workspace files download route', () => {
 
   it('returns 409 naming the documents whose artifacts are still compiling', async () => {
     mockListWorkspaceFiles.mockResolvedValue([
-      workspaceFile('f1', 'ready.docx'),
-      workspaceFile('f2', 'pending.docx'),
+      generatedDocument('f1', 'ready.docx'),
+      generatedDocument('f2', 'pending.docx'),
     ])
     mockFetchServableWorkspaceFileBuffer.mockImplementation(async (file: { name: string }) => {
       if (file.name === 'pending.docx')
@@ -173,7 +178,7 @@ describe('workspace files download route', () => {
   })
 
   it('rejects with 400, not 500, when a document blows its own allowance', async () => {
-    mockListWorkspaceFiles.mockResolvedValue([workspaceFile('f1', 'huge.docx')])
+    mockListWorkspaceFiles.mockResolvedValue([generatedDocument('f1', 'huge.docx')])
     mockFetchServableWorkspaceFileBuffer.mockRejectedValue(
       new PayloadSizeLimitError({ label: 'servable file download', maxBytes: 1 })
     )
@@ -188,8 +193,8 @@ describe('workspace files download route', () => {
 
   it('blames the shared budget once earlier documents have consumed it', async () => {
     mockListWorkspaceFiles.mockResolvedValue([
-      workspaceFile('f1', 'first.docx'),
-      workspaceFile('f2', 'second.docx'),
+      generatedDocument('f1', 'first.docx'),
+      generatedDocument('f2', 'second.docx'),
     ])
     mockFetchServableWorkspaceFileBuffer.mockImplementation(async (file: { name: string }) => {
       // The first document eats the whole budget, so the second's cap is the remainder.
@@ -207,25 +212,40 @@ describe('workspace files download route', () => {
     expect(body.error).not.toContain('second.docx')
   })
 
-  it('lets an uploaded office file larger than the render headroom through', async () => {
-    const big = { ...workspaceFile('f1', 'deck.pptx'), size: 80 * MB }
-    mockListWorkspaceFiles.mockResolvedValue([big])
-    mockFetchServableWorkspaceFileBuffer.mockResolvedValue({
-      buffer: Buffer.from('PKdeck'),
-      contentType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-    })
+  it('streams an uploaded office file rather than resolving it', async () => {
+    // A real upload serves exactly its stored bytes, so it must not take the buffered
+    // path — otherwise a selection of large decks is held in memory for nothing.
+    const upload = {
+      ...workspaceFile('f1', 'deck.pptx'),
+      size: 80 * MB,
+      type: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    }
+    mockListWorkspaceFiles.mockResolvedValue([upload])
 
     const response = await GET(requestFor('fileIds=f1'), context)
+    await zipFrom(response)
 
     expect(response.status).toBe(200)
-    // Capped at the declared size, not the smaller render headroom.
-    expect(mockFetchServableWorkspaceFileBuffer.mock.calls[0][1].maxBytes).toBe(80 * MB)
+    expect(mockFetchServableWorkspaceFileBuffer).not.toHaveBeenCalled()
+    expect(mockDownloadFileStream).toHaveBeenCalledTimes(1)
+  })
+
+  it('caps a generated document at the render headroom', async () => {
+    mockListWorkspaceFiles.mockResolvedValue([generatedDocument('f1', 'report.docx')])
+    mockFetchServableWorkspaceFileBuffer.mockResolvedValue({
+      buffer: Buffer.from('PKdoc'),
+      contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    })
+
+    await GET(requestFor('fileIds=f1'), context)
+
+    expect(mockFetchServableWorkspaceFileBuffer.mock.calls[0][1].maxBytes).toBe(50 * MB)
   })
 
   it('surfaces a storage failure as a 500 even when another document is pending', async () => {
     mockListWorkspaceFiles.mockResolvedValue([
-      workspaceFile('f1', 'pending.docx'),
-      workspaceFile('f2', 'broken.docx'),
+      generatedDocument('f1', 'pending.docx'),
+      generatedDocument('f2', 'broken.docx'),
     ])
     mockFetchServableWorkspaceFileBuffer.mockImplementation(async (file: { name: string }) => {
       if (file.name === 'pending.docx')
@@ -241,7 +261,7 @@ describe('workspace files download route', () => {
 
   it('stops resolving documents once one hard-fails', async () => {
     const files = Array.from({ length: 20 }, (_, index) =>
-      workspaceFile(`f${index}`, `doc${index}.docx`)
+      generatedDocument(`f${index}`, `doc${index}.docx`)
     )
     mockListWorkspaceFiles.mockResolvedValue(files)
     mockFetchServableWorkspaceFileBuffer.mockImplementation(async (file: { name: string }) => {