fix(files): put streamed files and rendered documents on one byte budget

The budget only counted rendered documents, so streamed entries never reserved
their declared bytes. A mixed selection could clear the up-front declared-size
gate and still ship close to two full limits: ordinary files up to the cap, plus
documents drawing a fresh cap of their own.

Streamed entries ship exactly what they declared, so their share is known before
anything is read and is now reserved up front; documents draw from what is left.

The budget-exhausted rejection also quoted declared sizes, which for a selection
of small sources reads as a tiny total exceeding the limit. That case has no
knowable byte count — the documents have not been rendered — so it now says what
happened without inventing a number.

Author: waleedlatif1

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

@@ -191,6 +191,42 @@ describe('workspace files download route', () => {
     expect(body.error).not.toContain('Selected files total')
   })
 
+  it('counts streamed files against the same budget as rendered documents', async () => {
+    // 200 MB of ordinary files leaves 50 MB of the 250 MB budget for documents.
+    mockListWorkspaceFiles.mockResolvedValue([
+      { ...workspaceFile('f1', 'clip.mp4'), size: 200 * MB },
+      generatedDocument('f2', 'report.docx'),
+    ])
+    mockFetchServableWorkspaceFileBuffer.mockResolvedValue({
+      buffer: Buffer.from('PKdoc'),
+      contentType: 'application/octet-stream',
+    })
+
+    await zipFrom(await GET(requestFor('fileIds=f1&fileIds=f2'), context))
+
+    // Without reserving the streamed bytes the document would get the full 50 MB
+    // ceiling, letting the archive ship 250 MB of documents on top of 200 MB of video.
+    expect(mockFetchServableWorkspaceFileBuffer.mock.calls[0][1].maxBytes).toBe(50 * MB)
+  })
+
+  it('rejects when streamed files leave no budget for a document', async () => {
+    mockListWorkspaceFiles.mockResolvedValue([
+      { ...workspaceFile('f1', 'clip.mp4'), size: 249 * MB },
+      generatedDocument('f2', 'report.docx'),
+    ])
+    mockFetchServableWorkspaceFileBuffer.mockRejectedValue(
+      new PayloadSizeLimitError({ label: 'servable file download', maxBytes: 1 })
+    )
+
+    const response = await GET(requestFor('fileIds=f1&fileIds=f2'), context)
+
+    expect(response.status).toBe(400)
+    const body = await response.json()
+    expect(body.error).toContain('once documents are rendered')
+    // No byte count: the rendered total is not knowable, so quoting one would mislead.
+    expect(body.error).not.toContain('Selected files total')
+  })
+
   it('blames the shared budget once earlier documents have consumed it', async () => {
     mockListWorkspaceFiles.mockResolvedValue([
       generatedDocument('f1', 'first.docx'),
@@ -208,7 +244,7 @@ describe('workspace files download route', () => {
 
     expect(response.status).toBe(400)
     const body = await response.json()
-    expect(body.error).toContain('Selected files total')
+    expect(body.error).toContain('once documents are rendered')
     expect(body.error).not.toContain('second.docx')
   })
 
@@ -237,7 +273,7 @@ describe('workspace files download route', () => {
       contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
     })
 
-    await GET(requestFor('fileIds=f1'), context)
+    await zipFrom(await GET(requestFor('fileIds=f1'), context))
 
     expect(mockFetchServableWorkspaceFileBuffer.mock.calls[0][1].maxBytes).toBe(50 * MB)
   })

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

@@ -87,6 +87,20 @@ function selectionTooLargeResponse(bytes: number): NextResponse {
   )
 }
 
+/**
+ * The rendered archive would exceed the limit even though the declared sizes did not —
+ * generated documents render to more than the source they declared, so no accurate byte
+ * count exists to quote here.
+ */
+function archiveTooLargeResponse(): NextResponse {
+  return NextResponse.json(
+    {
+      error: `The selected files exceed the ${formatFileSize(MAX_ZIP_DOWNLOAD_BYTES)} download limit once documents are rendered. Select fewer files.`,
+    },
+    { status: 400 }
+  )
+}
+
 function collectDescendantFolderIds(
   selectedFolderIds: string[],
   folders: Array<{ id: string; parentId: string | null }>
@@ -153,6 +167,13 @@ export const GET = withRouteHandler(
         return selectionTooLargeResponse(declaredBytes)
       }
 
+      // Streamed entries ship exactly what they declared, so their share of the budget is
+      // known up front and is reserved here. Documents then draw from what is left —
+      // one budget across both kinds, or the archive could ship two full limits' worth.
+      const reservedForStreamed = filesToZip
+        .filter((file) => !needsRendering(file))
+        .reduce((sum, file) => sum + file.size, 0)
+
       // Generated documents are resolved before the archive starts: once the first byte
       // is written the status code is committed, so anything that can still fail the
       // request has to fail here. Their buffers are held until the archive is assembled,
@@ -164,7 +185,7 @@ export const GET = withRouteHandler(
       for (const file of filesToZip) {
         if (!needsRendering(file)) continue
 
-        const remaining = MAX_ZIP_DOWNLOAD_BYTES - renderedBytes
+        const remaining = Math.max(0, MAX_ZIP_DOWNLOAD_BYTES - reservedForStreamed - renderedBytes)
         // A source's declared size says nothing about what it renders to, so the cap is
         // the per-document ceiling, bounded by what is left of the budget.
         const allowance = Math.min(remaining, MAX_RENDERED_DOCUMENT_BYTES)
@@ -184,7 +205,7 @@ export const GET = withRouteHandler(
                   },
                   { status: 400 }
                 )
-              : selectionTooLargeResponse(declaredBytes)
+              : archiveTooLargeResponse()
           }
           // Pending artifacts are collected so the 409 can name all of them; anything
           // else dooms the request and waiting cannot fix it.