@@ -11,6 +11,7 @@ import { deleteWorkspaceFixture, insertWorkspaceFixture } from '@sim/db/testing/
 import { generateId } from '@sim/utils/id'
 import { eq, inArray, sql } from 'drizzle-orm'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { MAX_FOLDERS_PER_WORKSPACE } from '@/lib/folders/constants'
 import { workspaceFileVfsPath } from '@/lib/uploads/contexts/workspace/file-manager'
 import { deleteWorkspaceFileOperation } from '@/lib/workspace-files/application/delete-workspace-file'
 import { readWorkspaceFileMetadataWithVersion } from '@/lib/workspace-files/application/read-workspace-file-metadata'
@@ -21,6 +22,7 @@ const bob = generateId()
 const carol = generateId()
 const workspaceId = generateId()
 const otherWorkspaceId = generateId()
+const overLimitWorkspaceId = generateId()
 const folders = { docs: generateId(), media: generateId(), foreign: generateId() }
 const session = (userId: string) => ({ kind: 'session' as const, userId, sessionId: generateId() })
 
@@ -163,7 +165,10 @@ describe('single-file operations addressed by VFS path', () => {
   })
 
   afterAll(async () => {
-    await deleteWorkspaceFixture(db, inArray(workspace.id, [workspaceId, otherWorkspaceId]))
+    await deleteWorkspaceFixture(
+      db,
+      inArray(workspace.id, [workspaceId, otherWorkspaceId, overLimitWorkspaceId])
+    )
     await db.delete(user).where(inArray(user.id, [alice, bob, carol]))
   })
 
@@ -321,6 +326,37 @@ describe('single-file operations addressed by VFS path', () => {
     }
   })
 
+  it('answers a non-member the same for a workspace whose folder tree is too large to read', async () => {
+    await insertWorkspaceFixture(db, [
+      { id: overLimitWorkspaceId, name: 'Over limit', ownerId: alice, billedAccountUserId: alice },
+    ])
+    await db.insert(permissions).values({
+      id: generateId(),
+      userId: alice,
+      entityType: 'workspace',
+      entityId: overLimitWorkspaceId,
+      permissionType: 'admin',
+    })
+    await db.execute(sql`
+      INSERT INTO folder (id, name, user_id, workspace_id, resource_type, parent_id)
+      SELECT ${generateId()} || '-' || g, 'Folder ' || g, ${alice}, ${overLimitWorkspaceId}, 'file', NULL
+      FROM generate_series(1, ${MAX_FOLDERS_PER_WORKSPACE + 1}) AS g`)
+    const answer = (userId: string, fileId: string) =>
+      describeFile(fileId, userId, overLimitWorkspaceId).then(
+        () => null,
+        (error: { code?: string; message?: string }) => ({
+          code: error.code,
+          message: error.message,
+        })
+      )
+    const nested = await answer(carol, 'files/Folder 1/report.csv')
+    expect(nested).toMatchObject({ code: 'forbidden' })
+    expect(await answer(carol, 'files/missing.csv')).toEqual(nested)
+    expect(await answer(alice, 'files/Folder 1/report.csv')).toMatchObject({
+      code: 'payload_too_large',
+    })
+  })
+
   it('resolves no path for a caller that did not opt in', async () => {
     await expect(
       deleteWorkspaceFileOperation.execute({
 
@@ -93,9 +93,10 @@ function namesVfsPath(input: WorkspaceFileTargetInput): boolean {
 
 /**
  * A path becomes an id first, so the canonical load and every authorization check run unchanged.
- * A malformed path is refused before any read and says nothing about the workspace. A path that
- * names no single live file does, so it leaves as an {@link UnresolvedWorkspaceFileVfsPathError},
- * which only a caller the operation admits to the workspace gets to see.
+ * The resolver's `validation` is decided from the reference alone, before any read, and says
+ * nothing about the workspace. Every other refusal it raises was read from the workspace, as is a
+ * path that names no single live file, so each leaves as an
+ * {@link UnresolvedWorkspaceFileVfsPathError} that only a caller the operation admits sees.
  */
 async function resolveFileId(input: WorkspaceFileContextInput): Promise<string> {
   if (!namesVfsPath(input)) return input.fileId
@@ -107,14 +108,15 @@ async function resolveFileId(input: WorkspaceFileContextInput): Promise<string>
     { entityType: 'workspace', entityId: workspaceId },
     input.fileId
   ).catch((error: unknown) => {
-    if (error instanceof OrchestrationError && error.code === 'conflict') {
+    if (!(error instanceof OrchestrationError) || error.code === 'validation') throw error
+    if (error.code === 'conflict') {
       throw new UnresolvedWorkspaceFileVfsPathError(
         workspaceId,
         'validation',
         `"${input.fileId}" names more than one file whose names display alike; pass the file id instead`
       )
     }
-    throw error
+    throw new UnresolvedWorkspaceFileVfsPathError(workspaceId, error.code, error.message)
   })
   if (!file) {
     throw new UnresolvedWorkspaceFileVfsPathError(workspaceId, 'not_found', 'File not found')
 
@@ -1,14 +1,15 @@
-import { OrchestrationError } from '@/lib/core/orchestration/types'
+import { OrchestrationError, type OrchestrationErrorCode } from '@/lib/core/orchestration/types'
 
 /**
- * A `files/…` path that names no single live file in the asserted workspace. Whether it is missing
- * or names two files whose names display alike describes that workspace's contents, so
- * `defineAuthorizedWorkspaceFileUseCase` admits the caller to the workspace before letting it out.
+ * A `files/…` path that names no single live file in the asserted workspace, or a refusal its
+ * lookup read from the workspace (two names that display alike, a folder tree too large to read).
+ * Each describes that workspace's contents, so `defineAuthorizedWorkspaceFileUseCase` admits the
+ * caller to the workspace before letting it out.
  */
 export class UnresolvedWorkspaceFileVfsPathError extends OrchestrationError {
   constructor(
     readonly workspaceId: string,
-    code: 'not_found' | 'validation',
+    code: OrchestrationErrorCode,
     message: string
   ) {
     super(code, message)