fix(files): only remap the deadline abort itself, and stop overclaiming rollback

Two follow-ups on the budget deadline, both reported by Cursor Bugbot:

`deadline.aborted` stays true for the rest of the request once the timer fires, so
it cannot decide whether *this* error was the abort. An `ArchiveError` or storage
failure thrown mid-entry after the timer fired was being relabelled as a timeout
and returned as a 413, hiding the real cause. The catch now matches the thrown
value against `deadline.reason` — `throwIfAborted()` throws exactly that object,
so the check is identity-exact and cannot capture an unrelated failure.

The message also claimed a rollback that has not necessarily happened: the budget
covers the archive download too, so it can fire before the first write, when there
is nothing to roll back. It now says the unzip was cancelled and claims nothing
about what was written. Including the download in the budget is deliberate — the
lease it has to fit inside starts earlier still — so the TSDoc says that rather
than "the extraction itself".

Author: waleedlatif1

apps/sim/lib/workspace-files/application/extract-workspace-file.test.ts

@@ -286,13 +286,18 @@ describe('extractWorkspaceFile', () => {
     expect(mocks.notify).toHaveBeenCalledWith('workspace-1')
   })
 
+  /** Fires the deadline the way `AbortSignal.timeout` does: `reason` is what gets thrown. */
+  function expireDeadline(signal: AbortSignal): unknown {
+    const reason = new DOMException('The operation was aborted due to timeout', 'TimeoutError')
+    Object.defineProperty(signal, 'aborted', { value: true })
+    Object.defineProperty(signal, 'reason', { value: reason })
+    return reason
+  }
+
   it('reports a budget overrun as a caller-fixable error, not the raw abort', async () => {
     mocks.decompress.mockImplementationOnce(async (_content, options) => {
       await options.prepareRootFolder()
-      // Stand in for the deadline firing mid-write: the extractor aborts, rolls back, and
-      // rethrows the DOMException, which must not reach the caller as an opaque 500.
-      Object.defineProperty(options.signal, 'aborted', { value: true })
-      throw Object.assign(new Error('The operation was aborted'), { name: 'TimeoutError' })
+      throw expireDeadline(options.signal)
     })
 
     await expect(
@@ -302,12 +307,35 @@ describe('extractWorkspaceFile', () => {
       })
     ).rejects.toMatchObject({
       code: 'payload_too_large',
-      message: expect.stringContaining('took too long and was rolled back'),
+      message: expect.stringContaining('took too long and was cancelled'),
     })
 
     expect(mocks.archiveFolderIfEmpty).toHaveBeenCalledOnce()
   })
 
+  it('keeps the real cause when a failure races the deadline', async () => {
+    // The signal stays aborted for the rest of the request, so an unrelated mid-entry
+    // failure after the timer fires must not be relabelled as a timeout.
+    mocks.decompress.mockImplementationOnce(async (_content, options) => {
+      await options.prepareRootFolder()
+      expireDeadline(options.signal)
+      throw Object.assign(new Error('Archive entry "a.txt" could not be decompressed'), {
+        name: 'ArchiveError',
+        reason: 'invalid',
+      })
+    })
+
+    await expect(
+      extractWorkspaceFile.execute({
+        principal,
+        input: { fileId: 'file-1', assertedWorkspaceId: 'workspace-1' },
+      })
+    ).rejects.toMatchObject({
+      name: 'ArchiveError',
+      message: expect.stringContaining('could not be decompressed'),
+    })
+  })
+
   it('leaves a destination folder that gained collaborators content during rollback', async () => {
     mocks.decompress.mockImplementationOnce(async (_content, options) => {
       await options.prepareRootFolder()

apps/sim/lib/workspace-files/application/extract-workspace-file.ts

@@ -25,11 +25,12 @@ import { parseWorkspaceFileFolderDisplayPath } from '@/lib/workspace-files/folde
 
 const logger = createLogger('ExtractWorkspaceFile')
 /**
- * Wall-clock budget for the extraction itself, deliberately shorter than the route's
- * `maxDuration` so the work stops on our terms — with the all-or-nothing rollback still
- * able to run — rather than the platform killing the process mid-write and stranding a
- * partial tree. Self-hosted deployments do not enforce `maxDuration` at all, so this is
- * the only thing bounding the write loop there.
+ * Wall-clock budget for the whole operation — archive download included, because the lease
+ * this must fit inside starts earlier still. Deliberately shorter than the route's
+ * `maxDuration` so the work stops on our terms, with the all-or-nothing rollback still able
+ * to run, rather than the platform killing the process mid-write and stranding a partial
+ * tree. Self-hosted deployments do not enforce `maxDuration` at all, so this is the only
+ * thing bounding the write loop there.
  */
 const EXTRACTION_BUDGET_MS = 180 * 1000
 /**
@@ -198,15 +199,16 @@ async function extractWorkspaceFileContents({
       }
       await notifyWorkspaceFilesChanged(context.workspaceId)
     }
-    if (deadline.aborted && !(error instanceof OrchestrationError)) {
-      logger.warn('Archive extraction exceeded its budget and was rolled back', {
+    if (deadline.aborted && error === deadline.reason) {
+      logger.warn('Archive extraction exceeded its budget', {
         workspaceId: context.workspaceId,
         fileId: file.id,
         budgetMs: EXTRACTION_BUDGET_MS,
+        wroteAnything: Boolean(rootFolder),
       })
       throw new OrchestrationError(
         'payload_too_large',
-        `Unzipping "${file.name}" took too long and was rolled back. Try a smaller archive.`
+        `Unzipping "${file.name}" took too long and was cancelled. Try a smaller archive.`
       )
     }
     throw error