fix(file-parsers): charge hidden central-directory entries against the cap

sumDeclaredUncompressedSize walked only the entry count the EOCD declares,
while verification walks the contiguous run of records. JSZip's readCentralDir
loops on the record signature and keeps every entry it finds — a count
mismatch is explicitly not an error there — so an archive that under-reported
its count could hide honestly-large entries from the total-size cap and still
have the parser expand them.

The sum now walks the same contiguous run as the verification pass and
readZipCentralDirectoryStats, and fails closed when the run is shorter than
the declared count.

Caught by Cursor Bugbot review.

Author: waleedlatif1

apps/sim/lib/file-parsers/zip-guard.test.ts

@@ -231,6 +231,29 @@ describe('assertOoxmlArchiveWithinLimits', () => {
     )
   })
 
+  it('charges entries hidden behind an under-reported EOCD count against the cap', async () => {
+    // JSZip's readCentralDir loops on the record signature and keeps every
+    // entry it finds — a count mismatch is explicitly not an error there — so
+    // entries past the declared count must still be charged against the cap.
+    const buffer = await buildZip({
+      'a.xml': 'A'.repeat(60_000),
+      'b.xml': 'B'.repeat(60_000),
+      'c.xml': 'C'.repeat(60_000),
+    })
+    const eocdOffset = buffer.length - 22
+    expect(buffer.readUInt32LE(eocdOffset)).toBe(0x06054b50)
+    buffer.writeUInt16LE(1, eocdOffset + 8) // entries on this disk
+    buffer.writeUInt16LE(1, eocdOffset + 10) // total entries
+
+    expect(() =>
+      assertOoxmlArchiveWithinLimits(buffer, {
+        maxTotalUncompressedBytes: 100_000,
+        maxCompressionRatio: 10_000,
+        ratioCheckFloorBytes: 1024 * 1024 * 1024,
+      })
+    ).toThrow(/exceeds the maximum allowed/)
+  })
+
   it('accepts a multi-entry archive whose entries all inflate to what they declare', async () => {
     const buffer = await buildZip({
       '[Content_Types].xml': '<?xml version="1.0"?><Types/>',

apps/sim/lib/file-parsers/zip-guard.ts

@@ -217,6 +217,13 @@ function readCentralDirectoryEntry(
  * `null` when the buffer is not a parseable ZIP archive (e.g. legacy binary
  * `.xls`/`.doc`, or a misidentified plaintext file) so the caller can defer to
  * the downstream parser. Stops early once the running total exceeds the limit.
+ *
+ * Like {@link readZipCentralDirectoryStats}, this charges the CONTIGUOUS run of
+ * records rather than the EOCD's declared count. JSZip's `readCentralDir` loops
+ * on the record signature and keeps every entry it finds — a count mismatch is
+ * explicitly not an error there — so an archive that under-reports its count
+ * would otherwise hide honestly-large entries from this cap while the parser
+ * still expanded them.
  */
 function sumDeclaredUncompressedSize(buffer: Buffer, abortAboveBytes: number): number | null {
   if (buffer.length < EOCD_MIN_SIZE) {
@@ -234,15 +241,12 @@ function sumDeclaredUncompressedSize(buffer: Buffer, abortAboveBytes: number): n
   }
 
   let total = 0
+  let counted = 0
   let cursor = location.offset
-  for (let entry = 0; entry < location.entryCount; entry++) {
-    if (cursor + CENTRAL_DIRECTORY_HEADER_MIN_SIZE > buffer.length) {
-      return null
-    }
-    if (buffer.readUInt32LE(cursor) !== CENTRAL_DIRECTORY_HEADER_SIGNATURE) {
-      return null
-    }
-
+  while (
+    cursor + CENTRAL_DIRECTORY_HEADER_MIN_SIZE <= buffer.length &&
+    buffer.readUInt32LE(cursor) === CENTRAL_DIRECTORY_HEADER_SIGNATURE
+  ) {
     const fileNameLength = buffer.readUInt16LE(cursor + 28)
     const extraFieldLength = buffer.readUInt16LE(cursor + 30)
     const commentLength = buffer.readUInt16LE(cursor + 32)
@@ -257,9 +261,16 @@ function sumDeclaredUncompressedSize(buffer: Buffer, abortAboveBytes: number): n
       return total
     }
 
+    counted += 1
     cursor += CENTRAL_DIRECTORY_HEADER_MIN_SIZE + fileNameLength + extraFieldLength + commentLength
   }
 
+  // Fewer records than the archive claims means the directory is malformed;
+  // fail closed rather than charging a partial total against the cap.
+  if (counted < location.entryCount) {
+    return null
+  }
+
   return total
 }