@@ -19,6 +19,8 @@ import {
   loadPublishedCompiledDoc,
   storeCompiledDoc,
 } from '@/lib/copilot/tools/server/files/doc-compiled-store'
+import { PayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
+import { MAX_RENDERED_DOCUMENT_BYTES } from '@/lib/uploads/utils/file-utils'
 
 describe('compiled document publication', () => {
   beforeEach(() => {
@@ -67,6 +69,54 @@ describe('compiled document publication', () => {
     )
   })
 
+  it('bounds the artifact read so an oversized artifact is never materialized', async () => {
+    mockHeadObject.mockResolvedValue({ size: 1 })
+    mockDownloadFile.mockResolvedValueOnce(
+      Buffer.from(JSON.stringify({ version: 1, referencedInputIdentity: 'dependency-identity' }))
+    )
+    mockDownloadFile.mockResolvedValueOnce(Buffer.from('%PDF-artifact'))
+
+    await loadPublishedCompiledDoc('workspace-1', 'source', 'pdf')
+
+    // The artifact is fetched separately from the source that names it, so a source
+    // that cleared its own ceiling says nothing about how large this is.
+    expect(mockDownloadFile.mock.calls[1]?.[0]).toEqual(
+      expect.objectContaining({ maxBytes: MAX_RENDERED_DOCUMENT_BYTES })
+    )
+  })
+
+  it('surfaces an oversized artifact instead of reporting it as not yet built', async () => {
+    // `null` means "still compiling", which callers answer with a retry — an artifact
+    // that is too large would sit behind that answer forever.
+    mockHeadObject.mockResolvedValue({ size: 1 })
+    mockDownloadFile.mockResolvedValueOnce(
+      Buffer.from(JSON.stringify({ version: 1, referencedInputIdentity: 'dependency-identity' }))
+    )
+    mockDownloadFile.mockRejectedValueOnce(
+      new PayloadSizeLimitError({
+        label: 'storage download',
+        maxBytes: MAX_RENDERED_DOCUMENT_BYTES,
+        observedBytes: MAX_RENDERED_DOCUMENT_BYTES + 1,
+      })
+    )
+
+    await expect(loadPublishedCompiledDoc('workspace-1', 'source', 'pdf')).rejects.toThrow(
+      PayloadSizeLimitError
+    )
+  })
+
+  it('still reports a missing artifact as not yet built', async () => {
+    mockHeadObject.mockResolvedValue({ size: 1 })
+    mockDownloadFile.mockResolvedValueOnce(
+      Buffer.from(JSON.stringify({ version: 1, referencedInputIdentity: 'dependency-identity' }))
+    )
+    mockDownloadFile.mockRejectedValueOnce(new Error('NoSuchKey'))
+
+    await expect(loadPublishedCompiledDoc('workspace-1', 'source', 'pdf')).rejects.toThrow(
+      'Published compiled document artifact is missing'
+    )
+  })
+
   it('fails fast on a malformed published pointer', async () => {
     mockHeadObject.mockResolvedValue({ size: 1 })
     mockDownloadFile.mockResolvedValueOnce(Buffer.from('{not-json'))
 
@@ -1,7 +1,9 @@
 import { createHash } from 'node:crypto'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage, toError } from '@sim/utils/errors'
+import { isPayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
 import { downloadFile, headObject, uploadFile } from '@/lib/uploads/core/storage-service'
+import { MAX_RENDERED_DOCUMENT_BYTES } from '@/lib/uploads/utils/file-utils'
 
 const logger = createLogger('CopilotDocCompiledStore')
 
@@ -65,7 +67,18 @@ async function loadPublishedArtifactPointer(key: string): Promise<PublishedArtif
   return { version: 1, referencedInputIdentity: decoded.referencedInputIdentity }
 }
 
-/** Loads the compiled binary for the current source, or null if not yet built. */
+/**
+ * Loads the compiled binary for the current source, or null if not yet built.
+ *
+ * The artifact is what a download or a public share actually serves, and it is read
+ * separately from the source — so a source that cleared its own ceiling says nothing
+ * about the size of this. Bounding it here rather than on the finished response is
+ * what keeps an oversized artifact from being materialized before it is refused.
+ *
+ * A size breach is rethrown rather than folded into `null`: null means "not built
+ * yet", which callers answer with "still being prepared, try again", and an artifact
+ * that is too large would retry forever behind that.
+ */
 export async function loadCompiledDoc(
   workspaceId: string,
   source: string,
@@ -74,8 +87,9 @@ export async function loadCompiledDoc(
 ): Promise<Buffer | null> {
   const key = compiledArtifactKey(workspaceId, source, ext, referencedInputIdentity)
   try {
-    return await downloadFile({ key, context: 'copilot' })
-  } catch {
+    return await downloadFile({ key, context: 'copilot', maxBytes: MAX_RENDERED_DOCUMENT_BYTES })
+  } catch (error) {
+    if (isPayloadSizeLimitError(error)) throw error
     return null
   }
 }
 
@@ -80,6 +80,19 @@ describe('measureYamlExpansion', () => {
     expect(measureYamlExpansion(longNumbers, byteCap).within).toBe(false)
   })
 
+  it('charges a Date its quoted ISO length, not the flat allowance', () => {
+    // The default js-yaml schema turns `!!timestamp` into a Date, and JSON.stringify
+    // emits it as a 26-character quoted string — an aliased list of them would
+    // otherwise be charged 16 apiece and slip past the byte cap.
+    const dates = Array.from({ length: 200 }, () => new Date('2026-08-31T00:00:00.000Z'))
+    const booleans = Array.from({ length: 200 }, () => true)
+
+    const byteCap = limits({ maxSerializedBytes: 5000 })
+
+    expect(measureYamlExpansion(booleans, byteCap).within).toBe(true)
+    expect(measureYamlExpansion(dates, byteCap).within).toBe(false)
+  })
+
   it('charges object keys, so an aliased object with long keys cannot bypass the cap', () => {
     const key = 'k'.repeat(500)
     const shared = { [key]: 1 }
 
@@ -91,6 +91,9 @@ function serializedStringLength(value: string): number {
  */
 const NON_STRING_NODE_BYTES = 16
 
+/** `"2026-08-31T00:00:00.000Z"` — 24 characters of ISO 8601 plus its two quotes. */
+const SERIALIZED_DATE_BYTES = 26
+
 /**
  * Estimate the pretty-printed (`JSON.stringify(value, null, 2)`) size a single
  * value node contributes, including the indentation/newline overhead that
@@ -99,13 +102,18 @@ const NON_STRING_NODE_BYTES = 16
 function estimateNodeBytes(value: unknown, depth: number): number {
   const indentOverhead = depth * 2 + 4
   if (typeof value === 'string') return indentOverhead + serializedStringLength(value)
-  // A double can serialize to 24 characters (`-1.2345678901234567e-308`), so a
-  // number is the one non-string value that outgrows the flat allowance — charging
-  // it the allowance would let a document of them exceed the byte cap by half again.
-  // Taking the larger of the two never charges less than before.
+  // Two non-string values outgrow the flat allowance, and charging them the allowance
+  // would let a document of them exceed the byte cap by half again: a double serializes
+  // to as many as 24 characters (`-1.2345678901234567e-308`), and a `Date` — which the
+  // default js-yaml schema produces for a `!!timestamp`, so the file parser sees them —
+  // serializes to a 26-character quoted ISO string. Taking the larger of the two never
+  // charges less than the flat allowance did.
   if (typeof value === 'number') {
     return indentOverhead + Math.max(NON_STRING_NODE_BYTES, String(value).length)
   }
+  if (value instanceof Date) {
+    return indentOverhead + Math.max(NON_STRING_NODE_BYTES, SERIALIZED_DATE_BYTES)
+  }
   return indentOverhead + NON_STRING_NODE_BYTES
 }
 
 
@@ -0,0 +1,85 @@
+/**
+ * @vitest-environment node
+ */
+import { Readable } from 'node:stream'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockCreateReadStream, mockReadFile, mockStat } = vi.hoisted(() => ({
+  mockCreateReadStream: vi.fn(),
+  mockReadFile: vi.fn(),
+  mockStat: vi.fn(),
+}))
+
+vi.mock('fs', () => ({ createReadStream: mockCreateReadStream }))
+vi.mock('fs/promises', () => ({ readFile: mockReadFile, stat: mockStat }))
+
+vi.mock('@/lib/uploads/config', () => ({
+  USE_S3_STORAGE: false,
+  USE_BLOB_STORAGE: false,
+  USE_GCS_STORAGE: false,
+  getStorageConfig: () => ({ bucket: 'b', region: 'r' }),
+}))
+
+vi.mock('@/lib/uploads/core/setup.server', () => ({ UPLOAD_DIR_SERVER: '/uploads' }))
+
+vi.mock('@/lib/uploads/server/metadata', () => ({ insertFileMetadata: vi.fn() }))
+
+import { isPayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
+import { downloadFile } from '@/lib/uploads/core/storage-service'
+
+/** A stream that delivers `bytes`, whatever a prior `stat` would have claimed. */
+function streamOf(bytes: number) {
+  const stream = Readable.from([Buffer.alloc(bytes)]) as Readable & { destroy: () => void }
+  vi.spyOn(stream, 'destroy')
+  return stream
+}
+
+describe('downloadFile on local storage', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockReadFile.mockResolvedValue(Buffer.alloc(10))
+  })
+
+  it('reads without a ceiling when the caller asks for none', async () => {
+    const buffer = await downloadFile({ key: 'workspace/ws/file.bin', context: 'workspace' })
+
+    expect(buffer.length).toBe(10)
+    expect(mockReadFile).toHaveBeenCalled()
+    expect(mockCreateReadStream).not.toHaveBeenCalled()
+  })
+
+  it('enforces the ceiling on the bytes as they arrive, not on a prior stat', async () => {
+    // The file grew (or was replaced) after any size a caller could have measured:
+    // the stream delivers more than the ceiling allows, and a stat-then-read
+    // implementation would have admitted it.
+    mockCreateReadStream.mockReturnValue(streamOf(500))
+
+    await expect(
+      downloadFile({ key: 'workspace/ws/file.bin', context: 'workspace', maxBytes: 100 })
+    ).rejects.toSatisfy(isPayloadSizeLimitError)
+
+    expect(mockStat).not.toHaveBeenCalled()
+    expect(mockReadFile).not.toHaveBeenCalled()
+  })
+
+  it('returns the bytes when they fit the ceiling', async () => {
+    mockCreateReadStream.mockReturnValue(streamOf(50))
+
+    const buffer = await downloadFile({
+      key: 'workspace/ws/file.bin',
+      context: 'workspace',
+      maxBytes: 100,
+    })
+
+    expect(buffer.length).toBe(50)
+  })
+
+  it('destroys the stream once the read settles', async () => {
+    const stream = streamOf(50)
+    mockCreateReadStream.mockReturnValue(stream)
+
+    await downloadFile({ key: 'workspace/ws/file.bin', context: 'workspace', maxBytes: 100 })
+
+    expect(stream.destroy).toHaveBeenCalled()
+  })
+})
@@ -1,7 +1,7 @@
 import type { Readable } from 'node:stream'
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
-import { assertKnownSizeWithinLimit } from '@/lib/core/utils/stream-limits'
+import { readNodeStreamToBufferWithLimit } from '@/lib/core/utils/stream-limits'
 import {
   getStorageConfig,
   USE_BLOB_STORAGE,
@@ -507,16 +507,30 @@ export async function downloadFile(options: DownloadFileOptions): Promise<Buffer
     }
   }
 
-  const { readFile, stat } = await import('fs/promises')
+  const { readFile } = await import('fs/promises')
   const { join } = await import('path')
   const { UPLOAD_DIR_SERVER } = await import('./setup.server')
 
   const safeKey = sanitizeFileKey(key)
   const filePath = join(UPLOAD_DIR_SERVER, safeKey)
 
   if (maxBytes !== undefined) {
-    const fileStats = await stat(filePath)
-    assertKnownSizeWithinLimit(fileStats.size, maxBytes, 'storage download')
+    // Bounded as the bytes arrive, the way every cloud provider branch above reads.
+    // Checking `stat` and then calling `readFile` describes the file only as of the
+    // stat, so a caller that asked for a ceiling would still get whatever the file
+    // became in between — and on a self-hosted deployment this is the same anonymous
+    // share path the cloud branches serve.
+    const { createReadStream } = await import('fs')
+    const stream = createReadStream(filePath, signal ? { signal } : undefined)
+    try {
+      return await readNodeStreamToBufferWithLimit(stream, {
+        maxBytes,
+        label: 'storage download',
+        signal,
+      })
+    } finally {
+      stream.destroy()
+    }
   }
 
   return readFile(filePath, signal ? { signal } : undefined)
 
@@ -3,6 +3,7 @@ import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { downloadFile, uploadFile } from '@/lib/uploads/core/storage-service'
 import { isHevcHeifContainer, transcodeHeicToJpeg } from '@/lib/uploads/server/heic'
+import { MAX_RENDERED_DOCUMENT_BYTES } from '@/lib/uploads/utils/file-utils'
 
 const logger = createLogger('ImageDerivative')
 
@@ -16,9 +17,18 @@ function derivativeKey(storageKey: string): string {
   return `image-derivative/${hash}.jpg`
 }
 
+/**
+ * A cache miss here is recoverable, so unlike the compiled-doc store this swallows a
+ * size breach too: falling through re-transcodes the original, and the transcode is
+ * bounded by the source read that produced its input.
+ */
 async function loadDerivative(storageKey: string): Promise<Buffer | null> {
   try {
-    return await downloadFile({ key: derivativeKey(storageKey), context: 'copilot' })
+    return await downloadFile({
+      key: derivativeKey(storageKey),
+      context: 'copilot',
+      maxBytes: MAX_RENDERED_DOCUMENT_BYTES,
+    })
   } catch {
     return null
   }