fix(parser): resolve stream /Length from object streams

Stream /Length values stored as indirect references to objects inside
object streams would fail with 'Could not resolve /Length reference'.
The lengthResolver now handles compressed objects by loading from the
object stream, using the existing objectStreamCache for efficiency.

Author: Mythie

fixtures/xref/length-in-object-stream.pdf

@@ -1,6 +1,7 @@
 import { Scanner } from "#src/io/scanner";
 import { PdfDict } from "#src/objects/pdf-dict.ts";
 import { PdfRef } from "#src/objects/pdf-ref";
+import { PdfStream } from "#src/objects/pdf-stream";
 import { loadFixture } from "#src/test-utils";
 import { describe, expect, it } from "vitest";
 
@@ -1033,5 +1034,37 @@ describe("DocumentParser", () => {
       // PDFBox: assertEquals(1, doc.getNumberOfPages())
       expect(doc.getPageCount()).toBe(1);
     });
+
+    // Stream /Length as indirect reference to object in object stream.
+    // The stream dict has /Length 6 0 R, but object 6 is stored compressed
+    // in object stream 10, not as a standalone object. This tests that the
+    // lengthResolver can handle compressed objects.
+    // Note: This is valid PDF per spec - only object stream's own /Length
+    // cannot be in an object stream (section 7.5.7).
+    it("resolves stream /Length from object inside object stream", async () => {
+      const bytes = await loadFixture("xref", "length-in-object-stream.pdf");
+      const scanner = new Scanner(bytes);
+      const parser = new DocumentParser(scanner);
+
+      const doc = parser.parse();
+
+      expect(doc.version).toBe("1.7");
+      expect(doc.warnings).toHaveLength(0); // Should parse cleanly, no brute-force
+
+      const catalog = doc.getCatalog();
+      expect(catalog).not.toBeNull();
+
+      expect(doc.getPageCount()).toBe(1);
+
+      // Load the content stream (object 5) which has /Length 6 0 R,
+      // where object 6 is compressed in object stream 10
+      const contentsStream = doc.getObject(PdfRef.of(5, 0));
+      expect(contentsStream).not.toBeNull();
+      expect(contentsStream).toBeInstanceOf(PdfStream);
+
+      // Verify stream data was correctly read using the resolved length
+      const stream = contentsStream as PdfStream;
+      expect(stream.data.length).toBe(43); // "BT /F1 12 Tf 100 700 Td (Hello World) Tj ET"
+    });
   });
 });

src/parser/document-parser.test.ts

@@ -466,40 +466,65 @@ export class DocumentParser {
 
     // Create length resolver for stream objects with indirect /Length
     const lengthResolver: LengthResolver = (ref: PdfRef) => {
-      // Synchronous lookup in cache only - can't do async here
-      const key = `${ref.objectNumber} ${ref.generation}`;
-
-      const cached = cache.get(key);
+      // Check object cache first
+      const cacheKey = `${ref.objectNumber} ${ref.generation}`;
+      const cached = cache.get(cacheKey);
 
-      if (cached && cached.type === "number") {
+      if (cached instanceof PdfNumber) {
         return cached.value;
       }
 
-      // Try to parse synchronously if it's a simple uncompressed object
       const entry = xref.get(ref.objectNumber);
 
-      if (entry?.type === "uncompressed") {
-        // Save scanner position - we must restore it after parsing the length
-        // because we're in the middle of parsing a stream
-        const savedPosition = this.scanner.position;
+      if (!entry || entry.type === "free") {
+        return null;
+      }
+
+      // Save scanner position - we must restore it after parsing
+      // because we're in the middle of parsing a stream
+      const savedPosition = this.scanner.position;
 
-        try {
+      try {
+        let lengthObj: PdfObject | null = null;
+
+        if (entry.type === "uncompressed") {
           const parser = new IndirectObjectParser(this.scanner);
+          lengthObj = parser.parseObjectAt(entry.offset).value;
+        } else {
+          // Compressed: load from object stream
+          // Object streams themselves must be uncompressed (per PDF spec 7.5.7)
+          const streamEntry = xref.get(entry.streamObjNum);
 
-          const result = parser.parseObjectAt(entry.offset);
+          if (streamEntry?.type === "uncompressed") {
+            // Use cached object stream parser if available
+            let objStreamParser = objectStreamCache.get(entry.streamObjNum);
 
-          if (result.value.type === "number") {
-            cache.set(key, result.value);
+            if (!objStreamParser) {
+              const parser = new IndirectObjectParser(this.scanner);
+              const streamResult = parser.parseObjectAt(streamEntry.offset);
 
-            // Restore scanner position before returning
-            this.scanner.moveTo(savedPosition);
+              if (streamResult.value instanceof PdfStream) {
+                objStreamParser = new ObjectStreamParser(streamResult.value);
 
-            return result.value.value;
+                objectStreamCache.set(entry.streamObjNum, objStreamParser);
+              }
+            }
+
+            if (objStreamParser) {
+              lengthObj = objStreamParser.getObject(entry.indexInStream);
+            }
           }
-        } catch {
-          // Restore scanner position and fall through to return null
-          this.scanner.moveTo(savedPosition);
         }
+
+        this.scanner.moveTo(savedPosition);
+
+        if (lengthObj instanceof PdfNumber) {
+          cache.set(cacheKey, lengthObj);
+
+          return lengthObj.value;
+        }
+      } catch {
+        this.scanner.moveTo(savedPosition);
       }
 
       return null;