@poe-platform/safe-bash 0.1.809 → 0.1.811

package/dist/pdf-ast/index.js

@@ -5,9 +5,11 @@ import {
   transformBytes
 } from "../safe-bash/command-chunks/chunk-E6SK3OU2.js";
 import {
+  BackedJson,
   indexJsonObjects,
+  parseBackedJson,
   readJsonNumber
-} from "../safe-bash/command-chunks/chunk-LWZVDDJA.js";
+} from "../safe-bash/command-chunks/chunk-NUGQQDGE.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
 // packages/pdf-ast/src/source.ts
@@ -31439,6 +31441,39 @@ function parseCosDocument(bytes, options = {}) {
   return drainWork(parseCosDocumentSteps(bytes, options));
 }
 
+// packages/pdf-ast/src/content/array-cursor.ts
+var PdfArrayCursor = class {
+  constructor(array, state) {
+    this.array = array;
+    this.length = array.storedItems?.length ?? array.items.length;
+    if (!Number.isSafeInteger(this.length) || this.length < 0) throw new RangeError("Invalid stored array length");
+    this.position = state?.position ?? array.storedItems?.position ?? -1;
+    this.index = state?.index ?? 0;
+  }
+  array;
+  index = 0;
+  position;
+  length;
+  snapshot() {
+    return { array: this.array, index: this.index, position: this.position };
+  }
+  *next() {
+    if (this.index === this.length) {
+      if (this.array.storedItems && this.position !== -1) throw new Error("Invalid stored array terminator");
+      return { done: true, value: void 0 };
+    }
+    let node = this.array.items[this.index];
+    if (this.array.storedItems) {
+      const reply = yield { kind: "array-item", items: this.array.storedItems, position: this.position };
+      if (!reply || typeof reply !== "object" || reply.kind !== "array" || reply.items[0]?.kind !== "number" || !reply.items[1]) throw new TypeError("Expected a PDF array record");
+      this.position = reply.items[0].value;
+      node = reply.items[1];
+    }
+    this.index++;
+    return { done: false, value: node };
+  }
+};
+
 // packages/pdf-ast/src/content/sampled-vertices.ts
 function* sampledVertices(size, domain, encode3, inputs, sampleCount) {
   const dimensions = Math.max(1, size.length), axes = [];
@@ -31476,22 +31511,30 @@ function* sampledVertices(size, domain, encode3, inputs, sampleCount) {
 }
 
 // packages/pdf-ast/src/content/annotations.ts
-function* resolveNode(node) {
+function* resolveNode(node, arrayKey) {
   if (!node) return void 0;
-  const result = yield { kind: "resolve", node };
-  if (typeof result === "number" || typeof result === "boolean") throw new TypeError("Expected a PDF annotation object");
+  const result = yield { kind: "resolve", node, ...arrayKey ? { arrayKey } : {} };
+  if (typeof result === "number" || typeof result === "boolean" || result?.kind === "annotation-page-frame") throw new TypeError("Expected a PDF annotation object");
   return result;
 }
 function* resolveDict(node) {
   const result = yield* resolveNode(node);
   return result?.kind === "dict" ? result : void 0;
 }
-function* resolveArray(node) {
-  const result = yield* resolveNode(node);
+function* resolveArray(node, arrayKey) {
+  const result = yield* resolveNode(node, arrayKey);
   return result?.kind === "array" ? result : void 0;
 }
+function* visitChildren(array, visit) {
+  const cursor = new PdfArrayCursor(array);
+  for (let step = yield* cursor.next(); !step.done; step = yield* cursor.next()) {
+    const found = yield* visit(step.value);
+    if (found !== void 0) return found;
+  }
+  return void 0;
+}
 function* extractPageAnnotationSteps(pageDict, root, maxDepth = Infinity) {
-  const annotsArr = yield* resolveArray(dictGet(pageDict, "Annots"));
+  const annotsArr = yield* resolveArray(dictGet(pageDict, "Annots"), "Annots");
   if (!annotsArr) return;
   function* resolveDestToPageNum(destNode, depth = 0) {
     if (!destNode || depth > 4) return void 0;
@@ -31540,12 +31583,10 @@ function* extractPageAnnotationSteps(pageDict, root, maxDepth = Infinity) {
                 if (kStr === destName) return namesArr.items[i + 1];
               }
             }
-            const kidsArr = yield* resolveArray(dictGet(treeDict, "Kids"));
+            const kidsArr = yield* resolveArray(dictGet(treeDict, "Kids"), "Kids");
             if (kidsArr) {
-              for (const kid of kidsArr.items) {
-                const res = yield* searchNameTree(kid, depth2 + 1);
-                if (res) return res;
-              }
+              const found = yield* visitChildren(kidsArr, (kid) => searchNameTree(kid, depth2 + 1));
+              if (found) return found;
             }
             return void 0;
           } finally {
@@ -31558,7 +31599,9 @@ function* extractPageAnnotationSteps(pageDict, root, maxDepth = Infinity) {
     }
     return void 0;
   }
-  for (const item of annotsArr.items) {
+  const annotations = new PdfArrayCursor(annotsArr);
+  for (let step = yield* annotations.next(); !step.done; step = yield* annotations.next()) {
+    const item = step.value;
     const dict = yield* resolveDict(item);
     if (!dict) continue;
     const rectArr = yield* resolveArray(dictGet(dict, "Rect"));
@@ -31596,28 +31639,45 @@ function* extractPageAnnotationSteps(pageDict, root, maxDepth = Infinity) {
   }
 }
 function* annotationPageNumberSteps(root, reference, maxDepth = Infinity) {
-  let index2 = 0;
-  function* walk(node, depth = 0) {
-    if (!node) return void 0;
+  let index2 = 0, depth = 0;
+  const catalog = yield* resolveDict(root);
+  let node = catalog ? dictGet(catalog, "Pages") : void 0;
+  let cursor, cursorDepth = 0;
+  while (true) {
+    if (!node) {
+      if (!cursor) {
+        const frame = yield { kind: "pop-page-frame" };
+        if (frame === void 0) return void 0;
+        if (typeof frame !== "object" || frame.kind !== "annotation-page-frame") throw new TypeError("Expected an annotation page frame");
+        cursor = new PdfArrayCursor(frame.cursor.array, frame.cursor);
+        cursorDepth = frame.depth;
+      }
+      const step = yield* cursor.next();
+      if (step.done) {
+        cursor = void 0;
+        continue;
+      }
+      node = step.value;
+      depth = cursorDepth;
+      if (!node) continue;
+    }
+    const current = node;
+    node = void 0;
     if (depth > maxDepth) throw new PdfError("E_LIMIT", "PDF annotation page-tree depth limit exceeded");
-    if (node.kind === "ref" && !(yield { kind: "visit-page", reference: node })) return void 0;
-    const dict = yield* resolveDict(node);
-    if (!dict) return void 0;
+    if (current.kind === "ref" && !(yield { kind: "visit-page", reference: current })) continue;
+    const dict = yield* resolveDict(current);
+    if (!dict) continue;
     const type = yield* resolveNode(dictGet(dict, "Type"));
-    const kids = yield* resolveArray(dictGet(dict, "Kids"));
+    const kids = yield* resolveArray(dictGet(dict, "Kids"), "Kids");
     if (kids && (type?.kind !== "name" || type.decoded !== "Page")) {
-      for (const child of kids.items) {
-        const found = yield* walk(child, depth + 1);
-        if (found !== void 0) return found;
-      }
+      if (cursor) yield { kind: "push-page-frame", frame: { kind: "annotation-page-frame", cursor: cursor.snapshot(), depth: cursorDepth } };
+      cursor = new PdfArrayCursor(kids);
+      cursorDepth = depth + 1;
     } else {
       index2++;
-      if (node.kind === "ref" && node.objectNumber === reference.objectNumber) return index2;
+      if (current.kind === "ref" && current.objectNumber === reference.objectNumber) return index2;
     }
-    return void 0;
   }
-  const catalog = yield* resolveDict(root);
-  return yield* walk(catalog ? dictGet(catalog, "Pages") : void 0);
 }
 
 // packages/pdf-ast/src/fonts/stored-widths.ts
@@ -43877,11 +43937,16 @@ function evaluateContentStreamToDisplayList(params) {
 function extractPageAnnotations(cosDoc, pageDict) {
   function pageNumber(reference) {
     const visited = /* @__PURE__ */ new Set();
+    const frames = [];
     const work2 = annotationPageNumberSteps(cosDoc.rootRef, reference);
     let step2 = work2.next();
     while (!step2.done) {
       const request = step2.value;
       if (request.kind === "resolve") step2 = work2.next(cosDoc.resolve(request.node));
+      else if (request.kind === "push-page-frame") {
+        frames.push(request.frame);
+        step2 = work2.next();
+      } else if (request.kind === "pop-page-frame") step2 = work2.next(frames.pop());
       else if (request.kind === "visit-page") {
         const number = request.reference.objectNumber, added = !visited.has(number);
         visited.add(number);
@@ -43916,8 +43981,8 @@ function* resolveDict3(node, arrayPathPrefix) {
   const value = yield* resolveNode2(node, arrayPathPrefix);
   return value?.kind === "dict" ? value : void 0;
 }
-function* resolveArray3(node) {
-  const value = yield* resolveNode2(node);
+function* resolveArray3(node, arrayPathPrefix) {
+  const value = yield* resolveNode2(node, arrayPathPrefix);
   return value?.kind === "array" ? value : void 0;
 }
 function* visible(node) {
@@ -43948,9 +44013,11 @@ function* preparePageAppearanceSteps(pageDict, pageRes, evalResourcesDict, hideA
       dictSet(evalResourcesDict, entry.key.decoded, entry.value);
     }
   }
-  const annotsArr = yield* resolveArray3(dictGet(pageDict, "Annots"));
-  if (!hideAnnotations && annotsArr && annotsArr.items.length > 0) {
-    for (const item of annotsArr.items) {
+  const annotsArr = yield* resolveArray3(dictGet(pageDict, "Annots"), ["Annots"]);
+  if (!hideAnnotations && annotsArr) {
+    const annotations = new PdfArrayCursor(annotsArr);
+    for (let step = yield* annotations.next(); !step.done; step = yield* annotations.next()) {
+      const item = step.value;
       const annotDict = yield* resolveDict3(item);
       if (!annotDict) continue;
       const fNode = yield* resolveNode2(dictGet(annotDict, "F"));
@@ -57444,7 +57511,22 @@ var PdfMutableObjectStore = class {
     const parsed = await parseCosRangeValue(source, 0, { ...this.options, signal });
     if (!parsed.value) throw new PdfError("E_PARSE", "Missing mutable PDF value");
     const object = { objectNumber: number, generationNumber: generation, value: restoreStringFormats(parsed.value) };
-    if (!hasStream) return object;
+    const stream = hasStream ? this.streamSnapshot(at, streamAt, length, hasStream) : void 0;
+    return stream ? { ...object, stream } : object;
+  }
+  /** Borrow encoded stream bytes without parsing the object's dictionary. */
+  getStream(number) {
+    return this.operation(async () => {
+      if (!Number.isSafeInteger(number) || number < 1) throw new RangeError("Invalid PDF object number");
+      const at = await this.index.get(BigInt(number));
+      if (at === void 0 || at === DELETED_OBJECT) return void 0;
+      const bytes = await this.backing.read(Number(at), 64), record = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      const flag = record.getFloat64(40);
+      return flag ? this.streamSnapshot(Number(at), record.getFloat64(24), record.getFloat64(32), flag) : void 0;
+    });
+  }
+  streamSnapshot(at, streamAt, length, flag) {
+    const backing = this.backing, signal = this.signal;
     async function* chunks() {
       for (let offset = 0; offset < length; offset += 16384) {
         if (offset > 0 && offset % (16384 * 64) === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
@@ -57452,9 +57534,9 @@ var PdfMutableObjectStore = class {
         yield await backing.read(streamAt + offset, Math.min(16384, length - offset));
       }
     }
-    const stream = { length, chunks: { [Symbol.asyncIterator]: chunks }, decoded: hasStream === 2 };
+    const stream = { length, chunks: { [Symbol.asyncIterator]: chunks }, decoded: flag === 2 };
     this.receipts.set(stream, at);
-    return { ...object, stream };
+    return stream;
   }
   /** Remember successful decoding only while this stream snapshot is current. */
   markDecoded(object) {
@@ -59857,19 +59939,69 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
       ...arrayPathPrefix.length && arrays.storedStringKeys?.includes(arrayPathPrefix[arrayPathPrefix.length - 1]) ? { storeRootString: true } : {}
     };
     let reference;
-    const visited = /* @__PURE__ */ new Set();
+    const visited = new PdfReferenceSet(this.storage, this.options.maxTraversalStagingBytes, this.options.signal);
     const maximum10 = this.options.maxRecursionDepth ?? 100;
-    while (node?.kind === "ref") {
-      if (visited.size >= maximum10) throw new PdfError("E_LIMIT", "PDF reference depth limit exceeded");
-      if (visited.has(node.objectNumber)) throw new PdfError("E_PARSE", "Circular PDF indirect reference");
-      visited.add(node.objectNumber);
-      reference = node;
-      const object = await this.objects.get(node.objectNumber, node.generationNumber, arrays);
-      this.assertOpen();
-      if (object?.stream) return { value: object.value, reference, stream: object.stream };
-      node = object?.value;
+    let depth = 0, failed = false;
+    try {
+      while (node?.kind === "ref") {
+        if (depth >= maximum10) throw new PdfError("E_LIMIT", "PDF reference depth limit exceeded");
+        if (!await visited.add(node.objectNumber)) throw new PdfError("E_PARSE", "Circular PDF indirect reference");
+        if (++depth % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+        this.assertOpen();
+        reference = node;
+        const object = await this.objects.get(node.objectNumber, node.generationNumber, arrays);
+        this.assertOpen();
+        if (object?.stream) return { value: object.value, reference, stream: object.stream };
+        node = object?.value;
+      }
+      return node ? { value: node, ...reference ? { reference } : {} } : void 0;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      await visited.close().catch((error) => {
+        if (!failed) throw error;
+      });
+    }
+  }
+  /** Visit page dictionaries in inheritance order using caller-backed cycle state. */
+  pageAncestors(first) {
+    async function* visit(doc) {
+      doc.assertOpen();
+      doc.walks.add(work);
+      const visited = new PdfReferenceSet(doc.storage, doc.options.maxTraversalStagingBytes, doc.options.signal);
+      let current = first, depth = 0, failed = false;
+      try {
+        while (current) {
+          if (depth++ > doc.depthLimit) throw new PdfError("E_LIMIT", "PDF inherited page depth limit exceeded");
+          if (depth % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+          doc.assertOpen();
+          yield current;
+          doc.assertOpen();
+          const parent = dictGet(current, "Parent");
+          if (parent?.kind === "ref" && !await visited.add(parent.objectNumber)) break;
+          const resolved = (await doc.lookup(parent))?.value;
+          current = resolved?.kind === "dict" ? resolved : void 0;
+        }
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        doc.walks.delete(work);
+        await visited.close().catch((error) => {
+          if (!failed) throw error;
+        });
+      }
     }
-    return node ? { value: node, ...reference ? { reference } : {} } : void 0;
+    const work = visit(this);
+    return work;
+  }
+  /** Read one caller-backed array record with document cancellation and ownership. */
+  async readArrayItem(items, position) {
+    this.assertOpen();
+    const record = await readStoredRecord(items.storage, position, this.options.signal);
+    this.assertOpen();
+    return cosArray([cosNumber(record.next), record.value]);
   }
   async info() {
     const node = (await this.lookup(this.crossReference.infoRef))?.value;
@@ -59885,17 +60017,26 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
   async annotationPageNumber(reference) {
     this.assertOpen();
     const visited = new PdfReferenceSet(this.storage, this.options.maxTraversalStagingBytes, this.options.signal);
+    const backing = this.options.valueArrays?.storedArrayKeys?.includes("Kids") ? this.options.valueArrays.arrayStorage : void 0;
+    const frames = backing ? new StoredMetadataStack(backing, this.options.signal) : [];
     const work = annotationPageNumberSteps(this.crossReference.rootRef, reference, this.depthLimit);
     let failed = false;
     try {
-      let step = work.next();
+      let step = work.next(), turns = 0;
       while (!step.done) {
+        if (++turns % 256 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
         this.assertOpen();
         const request = step.value;
         if (request.kind === "resolve") {
-          const resolved = await this.lookup(request.node);
+          const resolved = await this.lookup(request.node, void 0, request.arrayKey ? [request.arrayKey] : void 0);
           step = work.next(resolved?.stream && resolved.value.kind === "dict" ? { kind: "stream", dict: resolved.value, rawBytes: new Uint8Array() } : resolved?.value);
-        } else if (request.kind === "visit-page") step = work.next(await visited.add(request.reference.objectNumber));
+        } else if (request.kind === "array-item") {
+          step = work.next(await this.readArrayItem(request.items, request.position));
+        } else if (request.kind === "push-page-frame") {
+          await frames.push(request.frame);
+          step = work.next();
+        } else if (request.kind === "pop-page-frame") step = work.next(await frames.pop());
+        else if (request.kind === "visit-page") step = work.next(await visited.add(request.reference.objectNumber));
         else throw new TypeError("Unexpected annotation page lookup request");
       }
       return step.value;
@@ -59916,21 +60057,50 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
       const visited = new PdfReferenceSet(doc.storage, doc.options.maxTraversalStagingBytes, doc.options.signal);
       let count = 0;
       let failed = false;
-      async function* walk(node, depth) {
-        doc.assertOpen();
-        if (!node) return;
-        if (depth > doc.depthLimit) throw new PdfError("E_LIMIT", "PDF page tree depth limit exceeded");
-        if (node.kind === "ref" && !await visited.add(node.objectNumber)) return;
-        const resolved = await doc.lookup(node);
-        if (resolved?.value.kind !== "dict") return;
-        const dict = resolved.value;
-        const type = (await doc.lookup(dictGet(dict, "Type")))?.value;
-        const kids = (await doc.lookup(dictGet(dict, "Kids")))?.value;
-        if (type?.kind === "name" && type.decoded === "Pages" || kids?.kind === "array") {
-          if (kids?.kind === "array") for (const kid of kids.items) yield* walk(kid, depth + 1);
-        } else if (type?.kind === "name" && type.decoded === "Page" || dictGet(dict, "MediaBox") || dictGet(dict, "Contents")) {
-          if (count >= Math.min(doc.options.maxPages, Number.MAX_SAFE_INTEGER)) throw new PdfError("E_LIMIT", "PDF page count limit exceeded");
-          yield new PdfRetainedPage(doc, count++, dict, node.kind === "ref" ? node : void 0);
+      async function* walk(first) {
+        const backing = doc.options.valueArrays?.storedArrayKeys?.includes("Kids") ? doc.options.valueArrays.arrayStorage : void 0;
+        const frames = backing ? new StoredMetadataStack(backing, doc.options.signal) : [];
+        let frame, node = first, depth = 0, turns = 0;
+        while (true) {
+          if (++turns % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+          doc.assertOpen();
+          if (!node) {
+            frame ??= await frames.pop();
+            if (!frame) return;
+            const stored = frame.kids.storedItems, length = stored?.length ?? frame.kids.items.length;
+            if (!Number.isSafeInteger(length) || length < 0) throw new RangeError("Invalid stored array length");
+            if (frame.index === length) {
+              if (stored && frame.position !== -1) throw new Error("Invalid stored array terminator");
+              frame = void 0;
+              continue;
+            }
+            if (stored) {
+              const record = await readStoredRecord(stored.storage, frame.position, doc.options.signal);
+              frame.position = record.next;
+              node = record.value;
+            } else node = frame.kids.items[frame.index];
+            frame.index++;
+            depth = frame.depth;
+            if (!node) continue;
+          }
+          const current = node;
+          node = void 0;
+          if (depth > doc.depthLimit) throw new PdfError("E_LIMIT", "PDF page tree depth limit exceeded");
+          if (current.kind === "ref" && !await visited.add(current.objectNumber)) continue;
+          const resolved = await doc.lookup(current);
+          if (resolved?.value.kind !== "dict") continue;
+          const dict = resolved.value;
+          const type = (await doc.lookup(dictGet(dict, "Type")))?.value;
+          const kids = (await doc.lookup(dictGet(dict, "Kids"), void 0, ["Kids"]))?.value;
+          if (type?.kind === "name" && type.decoded === "Pages" || kids?.kind === "array") {
+            if (kids?.kind === "array") {
+              if (frame) await frames.push(frame);
+              frame = { kids, index: 0, position: kids.storedItems?.position ?? -1, depth: depth + 1 };
+            }
+          } else if (type?.kind === "name" && type.decoded === "Page" || dictGet(dict, "MediaBox") || dictGet(dict, "Contents")) {
+            if (count >= Math.min(doc.options.maxPages, Number.MAX_SAFE_INTEGER)) throw new PdfError("E_LIMIT", "PDF page count limit exceeded");
+            yield new PdfRetainedPage(doc, count++, dict, current.kind === "ref" ? current : void 0);
+          }
         }
       }
       try {
@@ -59944,7 +60114,7 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
           }
         } else {
           const root = (await doc.lookup(doc.crossReference.rootRef))?.value;
-          if (root?.kind === "dict") yield* walk(dictGet(root, "Pages"), 0);
+          if (root?.kind === "dict") yield* walk(dictGet(root, "Pages"));
         }
       } catch (error) {
         failed = true;
@@ -60175,11 +60345,7 @@ var PdfRetainedPage = class {
     const values = /* @__PURE__ */ new Map();
     const boxes = /* @__PURE__ */ new Map();
     const keys = ["MediaBox", "CropBox", "BleedBox", "TrimBox", "ArtBox", "Rotate", "Resources"];
-    let current = this.dict;
-    const visited = /* @__PURE__ */ new Set();
-    let depth = 0;
-    while (current) {
-      if (depth++ > this.document.depthLimit) throw new PdfError("E_LIMIT", "PDF inherited page depth limit exceeded");
+    for await (const current of this.document.pageAncestors(this.dict)) {
       for (const key of keys) {
         const entry = dictGet(current, key);
         if (values.has(key) || !entry) continue;
@@ -60192,13 +60358,6 @@ var PdfRetainedPage = class {
         values.set(key, value);
       }
       if (values.size === keys.length) break;
-      const parent = dictGet(current, "Parent");
-      if (parent?.kind === "ref") {
-        if (visited.has(parent.objectNumber)) break;
-        visited.add(parent.objectNumber);
-      }
-      const resolved = (await this.document.lookup(parent))?.value;
-      current = resolved?.kind === "dict" ? resolved : void 0;
     }
     async function box(node, document2) {
       if (node?.kind !== "array" || node.items.length < 4) return void 0;
@@ -60301,14 +60460,17 @@ var PdfRetainedPage = class {
   async *annotations() {
     const work = extractPageAnnotationSteps(this.dict, this.document.crossReference.rootRef, this.document.depthLimit);
     try {
-      let step = work.next();
+      let step = work.next(), turns = 0;
       while (!step.done) {
+        if (++turns % 256 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
         const request = step.value;
         let result;
         if (request.kind === "annotation") yield request.annotation;
         else if (request.kind === "resolve") {
-          const resolved = await this.document.lookup(request.node);
+          const resolved = await this.document.lookup(request.node, void 0, request.arrayKey ? [request.arrayKey] : void 0);
           result = resolved?.stream && resolved.value.kind === "dict" ? { kind: "stream", dict: resolved.value, rawBytes: new Uint8Array() } : resolved?.value;
+        } else if (request.kind === "array-item") {
+          result = await this.document.readArrayItem(request.items, request.position);
         } else if (request.kind === "page-number") result = await this.document.annotationPageNumber(request.reference);
         else throw new TypeError("Unexpected annotation request");
         step = work.next(result);
@@ -60319,13 +60481,22 @@ var PdfRetainedPage = class {
   }
   /** Preserve the buffered page API's newline after each content-array stream. */
   async *streamContents() {
-    const content = await this.document.lookup(dictGet(this.dict, "Contents"));
+    const content = await this.document.lookup(dictGet(this.dict, "Contents"), void 0, ["Contents"]);
     if (content?.stream && content.reference) yield* this.document.objects.decodeStream(content.reference.objectNumber, content.reference.generationNumber);
-    else if (content?.value.kind === "array") for (const item of content.value.items) {
-      const stream = await this.document.lookup(item);
-      if (!stream?.stream || !stream.reference) continue;
-      yield* this.document.objects.decodeStream(stream.reference.objectNumber, stream.reference.generationNumber);
-      yield new Uint8Array([10]);
+    else if (content?.value.kind === "array") {
+      const cursor = new PdfArrayCursor(content.value);
+      let turns = 0;
+      while (true) {
+        if (++turns % 256 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+        const work = cursor.next();
+        let step = work.next();
+        while (!step.done) step = work.next(await this.document.readArrayItem(step.value.items, step.value.position));
+        if (step.value.done) break;
+        const stream = await this.document.lookup(step.value.value);
+        if (!stream?.stream || !stream.reference) continue;
+        yield* this.document.objects.decodeStream(stream.reference.objectNumber, stream.reference.generationNumber);
+        yield new Uint8Array([10]);
+      }
     }
   }
 };
@@ -63291,6 +63462,7 @@ var QpdfJsonValues = class _QpdfJsonValues {
   scratch;
   first;
   next;
+  sourceOrder;
   closed = false;
   work = 0;
   async cooperate(units = 1) {
@@ -63366,7 +63538,7 @@ var QpdfJsonValues = class _QpdfJsonValues {
     }
   }
   async index() {
-    const order = await indexJsonObjects(this.tree, this.scratch, (units) => this.cooperate(units));
+    const order = this.sourceOrder = await indexJsonObjects(this.tree, this.scratch, (units) => this.cooperate(units));
     const pointer = async (at) => {
       const bytes = await this.scratch.read(at, 8);
       return new DataView(bytes.buffer, bytes.byteOffset, bytes.length).getFloat64(0, true);
@@ -63541,7 +63713,102 @@ var QpdfJsonValues = class _QpdfJsonValues {
     }
     yield encoder.encode(utf16 ? ">" : ")");
   }
+  // JSON.parse removes duplicate JSON names before conversion, but decoded PDF
+  // name collisions happen after each value is converted. Validate the former
+  // view before emitting the latter so overwritten invalid numbers still fail.
+  async validate(root) {
+    let position = root;
+    for (; ; ) {
+      await this.cooperate();
+      let header2 = await this.tree.describe(position);
+      if (header2.kind === "object" || header2.kind === "array") {
+        const child = header2.kind === "object" ? await this.sourceOrder.first(position) : header2.children ? position + 32 : 0;
+        if (child) {
+          position = child;
+          continue;
+        }
+      } else if (header2.kind === "literal") {
+        const token2 = await this.tree.smallText(position, 5);
+        if (token2 !== "null" && token2 !== "true" && token2 !== "false") cosNumber(await readJsonNumber(this.text(position), (units) => this.cooperate(units), false));
+      }
+      for (; ; ) {
+        if (position === root) return;
+        await this.cooperate();
+        const parent = await this.tree.describe(header2.parent);
+        const next = parent.kind === "object" && header2.kind !== "key" ? await this.sourceOrder.next(position, header2.parent) : header2.end < parent.end ? header2.end : 0;
+        if (next) {
+          position = next;
+          break;
+        }
+        position = header2.parent;
+        header2 = parent;
+      }
+    }
+  }
+  /** Look up a converted PDF dictionary name, after prefix decoding/collisions. */
+  async property(root, name) {
+    if ((await this.tree.describe(root)).kind !== "object") return void 0;
+    for (let key = Number(await this.first.get(BigInt(root)) ?? 0n); key; ) {
+      await this.cooperate();
+      const value = (await this.tree.describe(key)).end;
+      if (await this.keyEquals(key, name)) return value;
+      key = Number(await this.next.get(BigInt(value)) ?? 0n);
+    }
+    return void 0;
+  }
+  async keyEquals(key, name) {
+    const text = await this.tree.smallText(key, name.length + 3);
+    return text !== void 0 && text.slice(text.startsWith("n:/") ? 3 : text.startsWith("/") ? 1 : 0) === name;
+  }
+  /** Stream an imported stream dictionary with legacy filter/length handling. */
+  async *streamDictionary(root, length) {
+    if (!Number.isSafeInteger(length) || length < 0) throw new RangeError("Invalid PDF stream length");
+    if (root !== void 0) await this.validate(root);
+    const encoder = new TextEncoder();
+    const object = root !== void 0 && (await this.tree.describe(root)).kind === "object";
+    let strip = false;
+    if (object) {
+      const filter = await this.property(root, "Filter");
+      const recognized = async (position) => {
+        if ((await this.tree.describe(position)).kind !== "string") return false;
+        const text = await this.tree.smallText(position, 32);
+        if (text === void 0) return false;
+        const skip = text.startsWith("n:/") ? 3 : text.startsWith("n:") ? 2 : text.startsWith("/") ? 1 : 0;
+        return skip > 0 && ["FlateDecode", "ASCIIHexDecode", "ASCII85Decode", "LZWDecode", "RunLengthDecode"].includes(text.slice(skip));
+      };
+      if (filter !== void 0) {
+        strip = await recognized(filter);
+        if ((await this.tree.describe(filter)).kind === "array") {
+          strip = true;
+          for await (const child of this.tree.children(filter)) if (!await recognized(child)) {
+            strip = false;
+            break;
+          }
+        }
+      }
+    }
+    yield encoder.encode("<<\n");
+    let hasLength = false;
+    for (let key = object ? Number(await this.first.get(BigInt(root)) ?? 0n) : 0; key; ) {
+      await this.cooperate();
+      const value = (await this.tree.describe(key)).end;
+      if (!strip || !await this.keyEquals(key, "Filter") && !await this.keyEquals(key, "DecodeParms")) {
+        yield* this.scalar(key, true);
+        yield encoder.encode(" ");
+        if (await this.keyEquals(key, "Length")) {
+          hasLength = true;
+          yield serializeCosNodeBytes(cosNumber(length));
+        } else yield* this.chunks(value);
+        yield encoder.encode("\n");
+      }
+      key = Number(await this.next.get(BigInt(value)) ?? 0n);
+    }
+    if (!hasLength) yield encoder.encode(`/Length ${length}
+`);
+    yield encoder.encode(">>");
+  }
   async *chunks(root) {
+    await this.validate(root);
     const encoder = new TextEncoder();
     let position = root, closing = false;
     while (position) {
@@ -63577,6 +63844,304 @@ var QpdfJsonValues = class _QpdfJsonValues {
     await this.scratch.close();
   }
 };
+
+// packages/pdf-ast/src/cos/qpdf-json-document.ts
+import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
+var QpdfJsonDocument = class _QpdfJsonDocument {
+  constructor(storage, options = {}) {
+    this.storage = storage;
+    this.signal = options.signal ? AbortSignal.any([options.signal, this.controller.signal]) : this.controller.signal;
+    this.store = new PdfMutableObjectStore(storage, { signal: this.signal });
+    this.backing = new PagedStorage25(
+      { fs: storage.fs, cwd: storage.directory, env: {}, signal: this.signal },
+      4
+    );
+    this.positions = new IntegerTable15(this.backing, 64);
+    this.order = new IntegerTable15(this.backing, 64);
+    this.catalogs = new IntegerTable15(this.backing, 64);
+  }
+  storage;
+  rootRef;
+  infoRef;
+  store;
+  backing;
+  positions;
+  order;
+  catalogs;
+  ordinal = 0;
+  controller = new AbortController();
+  signal;
+  pending = Promise.resolve();
+  closing;
+  async remember(number) {
+    if (!await this.positions.get(BigInt(number))) {
+      const ordinal = ++this.ordinal;
+      await this.positions.set(BigInt(number), BigInt(ordinal));
+      await this.order.set(BigInt(ordinal), BigInt(number));
+    }
+  }
+  static async fromDocument(document2, source, storage, options = {}) {
+    const owner = new _QpdfJsonDocument(storage, options);
+    try {
+      owner.rootRef = document2.crossReference.rootRef;
+      owner.infoRef = document2.crossReference.infoRef;
+      for await (const object of retainedCosObjects(document2, storage, { signal: owner.signal })) {
+        await owner.store.set(object);
+        const type = object.value.kind === "dict" && !object.stream ? dictGet(object.value, "Type") : void 0;
+        await owner.catalogs.set(
+          BigInt(object.objectNumber),
+          type?.kind === "name" && type.decoded === "Catalog" ? BigInt(object.generationNumber + 1) : 0n
+        );
+      }
+      for await (const number of retainedObjectOrder(document2, source, storage, owner.signal))
+        await owner.remember(number);
+      return owner;
+    } catch (error) {
+      try {
+        await owner.close();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  apply(input, options = {}) {
+    const task = this.pending.then(() => this.update(input, options));
+    this.pending = task.catch(() => {
+    });
+    return task;
+  }
+  async update(input, options) {
+    this.signal.throwIfAborted();
+    const maximum10 = options.maxInputBytes ?? Infinity;
+    if (maximum10 !== Infinity && (!Number.isSafeInteger(maximum10) || maximum10 < 0))
+      throw new RangeError("Invalid QPDF JSON input limit");
+    const context = {
+      fs: this.storage.fs,
+      cwd: this.storage.directory,
+      env: {},
+      signal: this.signal
+    };
+    const tape = new PagedStorage25(context, 4), scratch = new PagedStorage25(context, 4);
+    let values, failed = false, work = 0;
+    const cooperate = async (units = 1) => {
+      this.signal.throwIfAborted();
+      work += units;
+      if (work >= 4096) {
+        work = 0;
+        await new Promise((resolve2) => setTimeout(resolve2, 0));
+        this.signal.throwIfAborted();
+      }
+    };
+    const tree = new BackedJson(tape, cooperate);
+    async function* text() {
+      const decoder = new TextDecoder();
+      let total = 0;
+      for await (const bytes of input) {
+        if (bytes.length > maximum10 - total)
+          throw new PdfError("E_LIMIT", "QPDF JSON input byte limit exceeded");
+        total += bytes.length;
+        for (let at = 0; at < bytes.length; at += 16384) {
+          await cooperate(16384);
+          yield decoder.decode(bytes.subarray(at, at + 16384), { stream: true });
+        }
+      }
+      yield decoder.decode();
+    }
+    const isNull = async (position) => position !== void 0 && (await tree.describe(position)).kind === "literal" && await tree.smallText(position, 4) === "null";
+    try {
+      await parseBackedJson(
+        text(),
+        tree,
+        scratch,
+        cooperate,
+        options.syntaxError ?? ((offset, message) => {
+          throw new SyntaxError(`${message} at offset ${offset}`);
+        }),
+        void 0,
+        true
+      );
+      const order = await indexJsonObjects(tree, scratch, cooperate);
+      const property = async (position, name) => position !== void 0 && (await tree.describe(position)).kind === "object" ? order.property(position, name) : void 0;
+      const objectLike = async (position) => position !== void 0 && ["object", "array"].includes((await tree.describe(position)).kind);
+      const root = tree.rootPosition;
+      if (!await objectLike(root)) throw new Error("Invalid QPDF JSON root");
+      let section;
+      const qpdf = await property(root, "qpdf");
+      let selected = false;
+      if (qpdf !== void 0 && (await tree.describe(qpdf)).kind === "array") {
+        let index2 = 0;
+        for await (const child of tree.children(qpdf)) {
+          if (index2++ === 1) {
+            if (await objectLike(child) || await isNull(child)) {
+              section = child;
+              selected = true;
+            }
+            break;
+          }
+        }
+      }
+      if (!selected) {
+        const objects = await property(root, "objects");
+        if (await objectLike(objects)) section = objects;
+      }
+      if (section === void 0 || await isNull(section))
+        throw new Error("Missing QPDF JSON objects section");
+      values = await QpdfJsonValues.open(tree, this.storage, { signal: this.signal });
+      let rootRef, infoRef;
+      if ((await tree.describe(section)).kind === "object")
+        for await (const { key, value: entry } of order.entries(section)) {
+          await cooperate();
+          if (!await objectLike(entry)) continue;
+          const value = await property(entry, "value");
+          if (await tree.smallText(key, 7) === "trailer") {
+            if (value !== void 0) {
+              for await (const bytes of values.chunks(value)) void bytes;
+              const root2 = await values.property(value, "Root"), info3 = await values.property(value, "Info");
+              if (root2 !== void 0) rootRef = await values.reference(root2) ?? rootRef;
+              if (info3 !== void 0) infoRef = await values.reference(info3) ?? infoRef;
+            }
+            continue;
+          }
+          const ref = await values.reference(key);
+          if (!ref) continue;
+          const stream = await property(entry, "stream");
+          if (await objectLike(stream)) {
+            const dict = await property(stream, "dict"), data = await property(stream, "data"), datafile = await property(stream, "datafile");
+            if (dict !== void 0) await values.validate(dict);
+            let staged;
+            let streamFailed = false;
+            try {
+              let raw;
+              if (data !== void 0 && (await tree.describe(data)).kind === "string") {
+                const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+                async function* decoded() {
+                  let accumulator = 0, bits = 0, used = 0, buffer = new Uint8Array(8192);
+                  for await (const text2 of tree.scalarChunks(data)) {
+                    await cooperate(text2.length);
+                    for (const char of text2) {
+                      const code = alphabet.indexOf(char);
+                      if (code < 0) continue;
+                      accumulator = accumulator << 6 | code;
+                      bits += 6;
+                      if (bits >= 8) {
+                        bits -= 8;
+                        buffer[used++] = accumulator >>> bits & 255;
+                        accumulator &= (1 << bits) - 1;
+                        if (used === buffer.length) {
+                          yield buffer;
+                          buffer = new Uint8Array(8192);
+                          used = 0;
+                        }
+                      }
+                    }
+                  }
+                  if (used) yield buffer.subarray(0, used);
+                }
+                staged = await PdfFileSource.fromStream(
+                  this.storage.fs,
+                  this.storage.directory,
+                  decoded(),
+                  { signal: this.signal }
+                );
+                raw = { length: staged.size, chunks: staged.stream(0, staged.size, this.signal) };
+              } else if (datafile !== void 0 && (await tree.describe(datafile)).kind === "string") {
+                let path = "";
+                for await (const part of tree.scalarChunks(datafile)) {
+                  await cooperate(part.length);
+                  path += part;
+                }
+                const file = await options.dataFile?.(path);
+                if (!file) throw new Error(`cannot open stream datafile ${path}`);
+                raw = { length: file.size, chunks: file.stream(0, file.size, this.signal) };
+              } else
+                raw = await this.store.getStream(ref.objectNumber) ?? { length: 0, chunks: [] };
+              const dictionary = await isNull(dict) ? void 0 : dict;
+              let length = 0;
+              for await (const bytes of values.streamDictionary(dictionary, raw.length))
+                length += bytes.length;
+              await this.store.setSerializedValue({
+                ...ref,
+                body: { length, chunks: values.streamDictionary(dictionary, raw.length) },
+                stream: raw
+              });
+              await this.remember(ref.objectNumber);
+              await this.catalogs.set(BigInt(ref.objectNumber), 0n);
+            } catch (error) {
+              streamFailed = true;
+              throw error;
+            } finally {
+              await staged?.close().catch((error) => {
+                if (!streamFailed) throw error;
+              });
+            }
+          } else if (value !== void 0) {
+            if (await isNull(value)) {
+              await this.store.delete(ref.objectNumber);
+              await this.positions.set(BigInt(ref.objectNumber), 0n);
+              await this.catalogs.set(BigInt(ref.objectNumber), 0n);
+            } else {
+              let length = 0;
+              for await (const bytes of values.chunks(value)) length += bytes.length;
+              await this.store.setSerializedValue({
+                ...ref,
+                body: { length, chunks: values.chunks(value) }
+              });
+              await this.remember(ref.objectNumber);
+              const type = await values.property(value, "Type"), token2 = type === void 0 ? void 0 : await tree.smallText(type, 11);
+              await this.catalogs.set(
+                BigInt(ref.objectNumber),
+                token2 === "/Catalog" || token2 === "n:/Catalog" || token2 === "n:Catalog" ? BigInt(ref.generationNumber + 1) : 0n
+              );
+            }
+          }
+        }
+      if (!rootRef)
+        for await (const [ordinal, number] of this.order.entries()) {
+          await cooperate();
+          if (await this.positions.get(number) !== ordinal) continue;
+          const generation = await this.catalogs.get(number);
+          if (generation) {
+            rootRef = cosRef(Number(number), Number(generation) - 1);
+            break;
+          }
+        }
+      if (rootRef) this.rootRef = rootRef;
+      if (infoRef) this.infoRef = infoRef;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      const results = await Promise.allSettled([values?.close(), tape.close(), scratch.close()]);
+      if (!failed) {
+        for (const result of results)
+          if (result.status === "rejected") await Promise.reject(result.reason);
+      }
+    }
+  }
+  async *chunks(options = {}) {
+    await this.pending;
+    this.signal.throwIfAborted();
+    if (!this.rootRef) throw new Error("missing trailer /Root");
+    yield* serializeRetainedCosDocumentChunks(
+      {
+        ...options,
+        objects: this.store.outputObjects(),
+        rootRef: this.rootRef,
+        infoRef: this.infoRef,
+        signal: this.signal
+      },
+      this.storage
+    );
+  }
+  close() {
+    this.controller.abort(new PdfError("E_CANCELLED", "QPDF JSON document closed"));
+    return this.closing ??= (async () => {
+      await this.pending;
+      const results = await Promise.allSettled([this.store.close(), this.backing.close()]);
+      for (const result of results) if (result.status === "rejected") throw result.reason;
+    })();
+  }
+};
 export {
   CosByteLexer,
   CosRangeLexer,
@@ -63600,6 +64165,7 @@ export {
   PdfRetainedPage,
   PdfStagedOutputs,
   PdfStagingStorage,
+  QpdfJsonDocument,
   QpdfJsonValues,
   STANDARD_14_FONTS,
   appendIncrementalRevision,