@poe-platform/safe-bash 0.1.810 → 0.1.812

package/dist/pdf-ast/index.js

@@ -9,7 +9,7 @@ import {
   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
@@ -28156,28 +28156,41 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
     if (nodes >= maxNodes) throw new PdfError("E_LIMIT", "PDF value node limit exceeded");
     nodes++;
   };
+  const residentDepth = 32;
   const stack = [];
-  function matchesStoredPath() {
+  let current, depth = 0;
+  const pathLength = (options.storedArrayPaths ?? []).reduce((length, path) => Math.max(length, path.length - 1), 0);
+  function matchesStoredPath(parent) {
     return options.storedArrayPaths?.some((path) => {
-      const prefix = options.arrayPathPrefix ?? [], length = prefix.length + stack.length;
+      const length = parent.path.length + 1;
       if (!path.length || path.length > length) return false;
       for (let i = 0; i < path.length; i++) {
         const at = length - path.length + i;
-        let key;
-        if (at < prefix.length) key = prefix[at];
-        else {
-          const parent = stack[at - prefix.length];
-          if (parent.kind !== "dict") return false;
-          key = parent.key?.decoded;
-        }
-        if (key === void 0 || path[i] !== "*" && path[i] !== key) return false;
+        const key = at === parent.path.length ? parent.kind === "dict" ? parent.key?.decoded : void 0 : parent.path[at];
+        if (key == null || path[i] !== "*" && path[i] !== key) return false;
       }
       return true;
     }) ?? false;
   }
+  function ancestorPath(parent) {
+    if (!pathLength) return [];
+    return parent ? [...parent.path, parent.kind === "dict" ? parent.key?.decoded ?? null : null].slice(-pathLength) : options.arrayPathPrefix?.slice(-pathLength) ?? [];
+  }
+  function* push(container) {
+    if (current) {
+      if (options.containerStorage && depth > residentDepth) yield { kind: "container-push", container: current };
+      else stack.push(current);
+    }
+    current = container;
+    depth++;
+  }
+  function* pop() {
+    depth--;
+    current = options.containerStorage && depth > residentDepth ? yield { kind: "container-pop" } : stack.pop();
+  }
   while (true) {
     if (++work % 16 === 0) yield;
-    const parent = stack.at(-1);
+    const parent = current;
     lexer.setStringStorage?.(options.stringStorage && (parent?.kind === "dict" && parent.key && options.storedStringKeys?.includes(parent.key.decoded) || !parent && options.storeRootString) ? options.stringStorage : void 0);
     const tok = yield "token";
     if (!tok) {
@@ -28190,11 +28203,11 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
     }
     let node;
     if (parent?.kind === "array" && tok.kind === "array-end") {
-      stack.pop();
+      yield* pop();
       node = { kind: "array", items: parent.items, ...parent.storedItems ? { storedItems: parent.storedItems } : {}, span: { start: parent.start, end: tok.span.end } };
     } else if (parent?.kind === "dict" && !parent.key) {
       if (tok.kind === "dict-end") {
-        stack.pop();
+        yield* pop();
         node = yield { kind: "dict", entries: parent.entries, span: { start: parent.start, end: tok.span.end } };
       } else if (tok.kind === "name") {
         charge();
@@ -28209,11 +28222,12 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
         throw new PdfError("E_PARSE", `Missing value for dictionary key /${parent.key.decoded}`);
       }
       charge();
-      if (stack.length > maxDepth) throw new PdfError("E_LIMIT", "PDF syntax nesting limit exceeded");
+      if (depth > maxDepth) throw new PdfError("E_LIMIT", "PDF syntax nesting limit exceeded");
       if (tok.kind === "array-start") {
-        const backed = options.arrayStorage && (parent?.kind === "array" && parent.storedItems || parent?.kind === "dict" && (options.storedArrayKeys?.includes(parent.key.decoded) || matchesStoredPath()) || !parent && options.storeRootArray);
-        stack.push({
+        const backed = options.arrayStorage && (parent?.kind === "array" && parent.storedItems || parent?.kind === "dict" && (options.storedArrayKeys?.includes(parent.key.decoded) || matchesStoredPath(parent)) || !parent && options.storeRootArray);
+        yield* push({
           kind: "array",
+          path: ancestorPath(parent),
           start: tok.span.start,
           items: [],
           tail: -1,
@@ -28222,12 +28236,12 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
         continue;
       }
       if (tok.kind === "dict-start") {
-        stack.push({ kind: "dict", start: tok.span.start, entries: [] });
+        yield* push({ kind: "dict", path: ancestorPath(parent), start: tok.span.start, entries: [] });
         continue;
       }
       node = yield* parseLeafFromToken(tok, lexer);
     }
-    const container = stack.at(-1);
+    const container = current;
     if (!container) return node;
     if (container.kind === "array") {
       if (container.storedItems) {
@@ -30819,7 +30833,7 @@ function* parseNodeFromLexerSteps(lexer, bytes, maxDepth, repair = false) {
         yield;
         step = work.next();
       } else {
-        if (step.value !== "token" && step.value.kind === "array-append") throw new TypeError("Stored arrays require asynchronous parsing");
+        if (step.value !== "token" && step.value.kind !== "dict") throw new TypeError("Stored values require asynchronous parsing");
         step = work.next(step.value === "token" ? lexer.nextToken() : parseDictionaryStream(step.value, lexer, bytes));
       }
     }
@@ -31443,16 +31457,20 @@ function parseCosDocument(bytes, options = {}) {
 
 // packages/pdf-ast/src/content/array-cursor.ts
 var PdfArrayCursor = class {
-  constructor(array) {
+  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 = array.storedItems?.position ?? -1;
+    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");
@@ -31510,7 +31528,7 @@ function* sampledVertices(size, domain, encode3, inputs, sampleCount) {
 function* resolveNode(node, arrayKey) {
   if (!node) return void 0;
   const result = yield { kind: "resolve", node, ...arrayKey ? { arrayKey } : {} };
-  if (typeof result === "number" || typeof result === "boolean") throw new TypeError("Expected a PDF annotation object");
+  if (typeof result === "number" || typeof result === "boolean" || result?.kind === "annotation-frame") throw new TypeError("Expected a PDF annotation object");
   return result;
 }
 function* resolveDict(node) {
@@ -31521,15 +31539,7 @@ 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) {
+function* extractPageAnnotationSteps(pageDict, root) {
   const annotsArr = yield* resolveArray(dictGet(pageDict, "Annots"), "Annots");
   if (!annotsArr) return;
   function* resolveDestToPageNum(destNode, depth = 0) {
@@ -31561,35 +31571,8 @@ function* extractPageAnnotationSteps(pageDict, root, maxDepth = Infinity) {
         }
         const namesDict = yield* resolveDict(dictGet(catalog, "Names"));
         const destsTree = namesDict ? dictGet(namesDict, "Dests") : void 0;
-        const active = /* @__PURE__ */ new Set();
-        function* searchNameTree(node, depth2 = 0) {
-          if (!node) return void 0;
-          if (depth2 > maxDepth) throw new PdfError("E_LIMIT", "PDF annotation name-tree depth limit exceeded");
-          const identity = node.kind === "ref" ? `${node.objectNumber}:${node.generationNumber}` : node;
-          if (active.has(identity)) return void 0;
-          active.add(identity);
-          try {
-            const treeDict = yield* resolveDict(node);
-            if (!treeDict) return void 0;
-            const namesArr = yield* resolveArray(dictGet(treeDict, "Names"));
-            if (namesArr) {
-              for (let i = 0; i + 1 < namesArr.items.length; i += 2) {
-                const kNode = yield* resolveNode(namesArr.items[i]);
-                const kStr = kNode?.kind === "string" ? decodePdfString(kNode) : kNode?.kind === "name" ? kNode.decoded : "";
-                if (kStr === destName) return namesArr.items[i + 1];
-              }
-            }
-            const kidsArr = yield* resolveArray(dictGet(treeDict, "Kids"), "Kids");
-            if (kidsArr) {
-              const found = yield* visitChildren(kidsArr, (kid) => searchNameTree(kid, depth2 + 1));
-              if (found) return found;
-            }
-            return void 0;
-          } finally {
-            active.delete(identity);
-          }
-        }
-        const treeFound = yield* searchNameTree(destsTree);
+        const treeFound = yield { kind: "named-destination", node: destsTree, name: destName };
+        if (typeof treeFound === "number" || typeof treeFound === "boolean" || treeFound?.kind === "annotation-frame") throw new TypeError("Expected a named destination object");
         if (treeFound) return yield* resolveDestToPageNum(treeFound, depth + 1);
       }
     }
@@ -31635,26 +31618,93 @@ 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-traversal-frame" };
+        if (frame === void 0) return void 0;
+        if (typeof frame !== "object" || frame.kind !== "annotation-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"), "Kids");
     if (kids && (type?.kind !== "name" || type.decoded !== "Page")) {
-      const found = yield* visitChildren(kids, (child) => walk(child, depth + 1));
-      if (found !== void 0) return found;
+      if (cursor) yield { kind: "push-traversal-frame", frame: { kind: "annotation-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);
+}
+function* annotationNameDestinationSteps(first, name, maxDepth = Infinity) {
+  let node = first, depth = 0, cursor, cursorDepth = 0, identity;
+  while (true) {
+    if (!node) {
+      if (!cursor) {
+        const frame = yield { kind: "pop-traversal-frame" };
+        if (frame === void 0) return void 0;
+        if (typeof frame !== "object" || frame.kind !== "annotation-frame" || frame.identity === void 0) throw new TypeError("Expected an annotation name frame");
+        cursor = new PdfArrayCursor(frame.cursor.array, frame.cursor);
+        cursorDepth = frame.depth;
+        identity = frame.identity;
+      }
+      const step = yield* cursor.next();
+      if (step.done) {
+        yield { kind: "leave-name-node", identity };
+        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 name-tree depth limit exceeded");
+    const entered = yield { kind: "enter-name-node", node: current };
+    if (entered === void 0) continue;
+    if (typeof entered !== "number") throw new TypeError("Expected an annotation node identity");
+    const dict = yield* resolveDict(current);
+    if (dict) {
+      const names = yield* resolveArray(dictGet(dict, "Names"));
+      if (names) for (let i = 0; i + 1 < names.items.length; i += 2) {
+        const key = yield* resolveNode(names.items[i]);
+        const decoded = key?.kind === "string" ? decodePdfString(key) : key?.kind === "name" ? key.decoded : "";
+        if (decoded === name) return names.items[i + 1];
+      }
+      const kids = yield* resolveArray(dictGet(dict, "Kids"), "Kids");
+      if (kids) {
+        if (cursor) yield { kind: "push-traversal-frame", frame: { kind: "annotation-frame", cursor: cursor.snapshot(), depth: cursorDepth, identity } };
+        cursor = new PdfArrayCursor(kids);
+        cursorDepth = depth + 1;
+        identity = entered;
+        continue;
+      }
+    }
+    yield { kind: "leave-name-node", identity: entered };
+  }
 }
 
 // packages/pdf-ast/src/fonts/stored-widths.ts
@@ -43914,11 +43964,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-traversal-frame") {
+        frames.push(request.frame);
+        step2 = work2.next();
+      } else if (request.kind === "pop-traversal-frame") step2 = work2.next(frames.pop());
       else if (request.kind === "visit-page") {
         const number = request.reference.objectNumber, added = !visited.has(number);
         visited.add(number);
@@ -43927,6 +43982,36 @@ function extractPageAnnotations(cosDoc, pageDict) {
     }
     return step2.value;
   }
+  function namedDestination(node, name) {
+    const identities = /* @__PURE__ */ new Map(), active = /* @__PURE__ */ new Set(), frames = [];
+    const work2 = annotationNameDestinationSteps(node, name);
+    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-traversal-frame") {
+        frames.push(request.frame);
+        step2 = work2.next();
+      } else if (request.kind === "pop-traversal-frame") step2 = work2.next(frames.pop());
+      else if (request.kind === "enter-name-node") {
+        const node2 = request.node, key = node2.kind === "ref" ? `${node2.objectNumber}:${node2.generationNumber}` : node2;
+        let id = identities.get(key);
+        if (id === void 0) {
+          id = identities.size;
+          identities.set(key, id);
+        }
+        if (active.has(id)) step2 = work2.next();
+        else {
+          active.add(id);
+          step2 = work2.next(id);
+        }
+      } else if (request.kind === "leave-name-node") {
+        active.delete(request.identity);
+        step2 = work2.next();
+      } else throw new TypeError("Unexpected annotation name lookup request");
+    }
+    return step2.value;
+  }
   const output = [];
   const work = extractPageAnnotationSteps(pageDict, cosDoc.rootRef);
   let step = work.next();
@@ -43937,6 +44022,7 @@ function extractPageAnnotations(cosDoc, pageDict) {
       step = work.next();
     } else if (request.kind === "resolve") step = work.next(cosDoc.resolve(request.node));
     else if (request.kind === "page-number") step = work.next(pageNumber(request.reference));
+    else if (request.kind === "named-destination") step = work.next(namedDestination(request.node, request.name));
     else throw new TypeError("Unexpected annotation request");
   }
   return output;
@@ -48128,6 +48214,7 @@ async function resolveStreamLength(entry, options) {
 async function readValue(lexer, depth, nodes, options) {
   const { signal } = options;
   const work = parseValueSteps(lexer, depth, options.recovery === "repair", nodes, options);
+  const containers = options.containerStorage ? new StoredMetadataStack(options.containerStorage, signal) : void 0;
   let value;
   let turns = 0;
   try {
@@ -48144,6 +48231,16 @@ async function readValue(lexer, depth, nodes, options) {
           throw error;
         }
         step = work.next(position);
+      } else if (request && request !== "token" && (request.kind === "container-push" || request.kind === "container-pop")) {
+        let container;
+        try {
+          if (request.kind === "container-push") await containers.push(request.container);
+          else container = await containers.pop();
+        } catch (error) {
+          options.onBackingError?.(error);
+          throw error;
+        }
+        step = work.next(container);
       } else step = request === void 0 ? work.next() : work.next(request === "token" ? await lexer.nextToken() : request);
       if (++turns % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
     }
@@ -57054,8 +57151,124 @@ function resolveDestinationPageIndex(doc, destOrActionNode) {
   return void 0;
 }
 
-// packages/pdf-ast/src/retained-document.ts
-import { PagedStorage as PagedStorage8 } from "@poe-platform/safe-fs/storage";
+// packages/pdf-ast/src/cos/name-index.ts
+var PdfNameIndex = class {
+  constructor(storage, maximum10 = Infinity, signal) {
+    this.storage = storage;
+    this.maximum = maximum10;
+    this.signal = signal;
+    const limit10 = typeof maximum10 === "function" ? maximum10() : maximum10;
+    if (limit10 !== Infinity && (!Number.isSafeInteger(limit10) || limit10 < 0)) throw new RangeError("Invalid name staging limit");
+  }
+  storage;
+  maximum;
+  signal;
+  tail = /* @__PURE__ */ new Map();
+  hot = /* @__PURE__ */ new Map();
+  levels = [];
+  nextNode = 2;
+  nextName = 0;
+  closed = false;
+  get stagedBytes() {
+    return this.levels.reduce((sum, index2) => sum + (index2?.size ?? 0) * 32, 0);
+  }
+  async get(edge) {
+    if (this.tail.has(edge)) return this.tail.get(edge);
+    if (this.hot.has(edge)) return this.hot.get(edge);
+    for (const level of this.levels) {
+      const entry = await level?.get(edge, this.signal);
+      if (entry) {
+        if (this.hot.size < 256) this.hot.set(edge, entry.offset);
+        return entry.offset;
+      }
+    }
+    return void 0;
+  }
+  async insert(edge, node) {
+    this.tail.set(edge, node);
+    if (this.hot.size < 256) this.hot.set(edge, node);
+    if (this.tail.size < 64) return;
+    let level = 0;
+    while (this.levels[level]) level++;
+    const inputs = this.levels.slice(0, level);
+    const tail = this.tail;
+    const signal = this.signal;
+    async function* rows() {
+      for (const [objectNumber, offset] of tail) yield { objectNumber, offset, type: "uncompressed" };
+      for (const index2 of inputs) yield* index2.entries(signal);
+    }
+    const limit10 = typeof this.maximum === "function" ? this.maximum() : this.maximum;
+    const remaining = Math.min(limit10, Number.MAX_SAFE_INTEGER) - this.stagedBytes;
+    if (remaining < 0) throw new PdfError("E_LIMIT", "PDF name staging byte limit exceeded");
+    const combined = await PdfObjectIndex.build(rows(), this.storage, {
+      runEntries: 64,
+      chunkBytes: 2048,
+      cacheBytes: 2048,
+      maxStagingBytes: remaining,
+      ...signal ? { signal } : {}
+    });
+    try {
+      for (let i = 0; i < level; i++) {
+        await this.levels[i].close();
+        this.levels[i] = void 0;
+      }
+      this.levels[level] = combined;
+      this.tail.clear();
+    } catch (error) {
+      try {
+        await combined.close();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  async intern(value) {
+    if (this.closed) throw new PdfError("E_CAPABILITY", "PDF name index is closed");
+    this.signal?.throwIfAborted();
+    let node = 1, newPath = false;
+    const units = typeof value === "string" ? (function* () {
+      for (let i = 0; i < value.length; i++) yield value.charCodeAt(i);
+    })() : value;
+    let work = 0;
+    for await (const code of units) {
+      this.signal?.throwIfAborted();
+      if (!Number.isInteger(code) || code < 0 || code > 65535) throw new RangeError("Invalid PDF name code unit");
+      if (++work % 512 === 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, 0));
+        this.signal?.throwIfAborted();
+      }
+      for (const unit of [code & 255, code >>> 8]) {
+        const edge = node * 257 + unit + 1;
+        let child = newPath ? void 0 : await this.get(edge);
+        if (child === void 0) {
+          if (this.nextNode > Math.floor(Number.MAX_SAFE_INTEGER / 257) - 1) throw new PdfError("E_LIMIT", "PDF name index address limit exceeded");
+          child = this.nextNode++;
+          await this.insert(edge, child);
+          newPath = true;
+        }
+        node = child;
+      }
+    }
+    const terminal = node * 257;
+    const existing = newPath ? void 0 : await this.get(terminal);
+    if (existing !== void 0) return { index: existing, added: false };
+    const index2 = this.nextName++;
+    await this.insert(terminal, index2);
+    return { index: index2, added: true };
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const results = await Promise.allSettled(this.levels.map((index2) => index2?.close()));
+    this.tail.clear();
+    this.hot.clear();
+    this.levels.length = 0;
+    for (const result of results) if (result.status === "rejected") throw result.reason;
+  }
+};
+
+// packages/pdf-ast/src/extract/retained-form-fields.ts
+import { IntegerTable as IntegerTable4, PagedStorage as PagedStorage6 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/cos/mutable-object-store.ts
 import { IntegerTable as IntegerTable3, PagedStorage as PagedStorage5 } from "@poe-platform/safe-fs/storage";
@@ -57585,6 +57798,290 @@ var PdfMutableObjectStore = class {
   }
 };
 
+// packages/pdf-ast/src/extract/retained-form-fields.ts
+async function inheritedRetainedFieldEntry(document2, storage, dict, key, options) {
+  const seen = new PdfReferenceSet(storage, options.maxStagingBytes, options.signal);
+  let current = dict, depth = 0, failed = false;
+  try {
+    while (current) {
+      options.signal?.throwIfAborted();
+      if (++depth > (options.maxDepth ?? document2.depthLimit)) throw new PdfError("E_LIMIT", "PDF form field depth limit exceeded");
+      if (depth % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+      const value = dictGet(current, key);
+      if (value !== void 0) return (await document2.lookup(value))?.value;
+      const parent = dictGet(current, "Parent");
+      if (parent?.kind === "ref" && !await seen.add(parent.objectNumber)) return;
+      const found = await document2.lookup(parent);
+      current = !found?.stream && found?.value.kind === "dict" ? found.value : void 0;
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await seen.close().catch((error) => {
+      if (!failed) throw error;
+    });
+  }
+}
+async function* walkRetainedFieldEntries(document2, storage, options = {}) {
+  const signal = options.signal ?? new AbortController().signal, maxDepth = options.maxDepth ?? document2.depthLimit;
+  signal.throwIfAborted();
+  const frames = new PdfMutableObjectStore(storage, { signal, ...options.maxStagingBytes === void 0 ? {} : { maxStagingBytes: options.maxStagingBytes } });
+  const backing = new PagedStorage6({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable4(backing, 64);
+  let pending = 0, work = 0, failed = false;
+  async function checkpoint(depth = 0) {
+    signal.throwIfAborted();
+    if (depth > maxDepth) throw new PdfError("E_LIMIT", "PDF form field depth limit exceeded");
+    if (++work % 64 === 0) await new Promise((resolve3) => setTimeout(resolve3, 0));
+    signal.throwIfAborted();
+  }
+  async function resolve2(node) {
+    const found = await document2.lookup(node);
+    return found?.stream ? void 0 : found?.value;
+  }
+  async function push(node, prefix, ft, depth, flags = 0, justification = 0, maxLength) {
+    await frames.set({ objectNumber: ++pending, generationNumber: 0, value: cosArray([node, cosString(prefix), cosString(ft), cosNumber(depth), cosNumber(flags), cosNumber(justification), maxLength === void 0 ? cosNull() : cosNumber(maxLength)]) });
+  }
+  try {
+    const root = await resolve2(document2.crossReference.rootRef), form = root?.kind === "dict" ? await resolve2(dictGet(root, "AcroForm")) : void 0;
+    const fields2 = form?.kind === "dict" ? await resolve2(dictGet(form, "Fields")) : void 0;
+    if (fields2?.kind !== "array") return;
+    for (let i = fields2.items.length - 1; i >= 0; i--) {
+      await checkpoint();
+      await push(fields2.items[i], "", "", 0);
+    }
+    while (pending) {
+      const frame = (await frames.get(pending--)).value;
+      if (frame.kind !== "array") throw new PdfError("E_PARSE", "Invalid form traversal frame");
+      const [node, prefixNode, ftNode, depthNode, flagsNode, qNode, maxNode] = frame.items;
+      if (frame.items.length === 1 && node?.kind === "number") {
+        await active.set(BigInt(node.value), 0n);
+        continue;
+      }
+      if (!node || prefixNode?.kind !== "string" || ftNode?.kind !== "string" || depthNode?.kind !== "number") throw new PdfError("E_PARSE", "Invalid form traversal frame");
+      await checkpoint(depthNode.value);
+      if (node.kind === "ref") {
+        if (await active.get(BigInt(node.objectNumber)) === 1n) continue;
+        await active.set(BigInt(node.objectNumber), 1n);
+        await frames.set({ objectNumber: ++pending, generationNumber: 0, value: cosArray([cosNumber(node.objectNumber)]) });
+      }
+      const dict = await resolve2(node);
+      if (dict?.kind !== "dict") continue;
+      const named = await resolve2(dictGet(dict, "T")), ownFt = await resolve2(dictGet(dict, "FT"));
+      const partial = named?.kind === "string" ? decodePdfString(named) : named?.kind === "name" ? named.decoded : "", prefix = decodePdfString(prefixNode);
+      const name = prefix && partial ? `${prefix}.${partial}` : partial || prefix, ft = ownFt?.kind === "name" ? ownFt.decoded : decodePdfString(ftNode);
+      const ownFlags = await resolve2(dictGet(dict, "Ff")), ownQ = await resolve2(dictGet(dict, "Q")), ownMax = await resolve2(dictGet(dict, "MaxLen"));
+      const flags = ownFlags?.kind === "number" ? ownFlags.value : flagsNode?.kind === "number" ? flagsNode.value : 0;
+      const justification = ownQ?.kind === "number" ? ownQ.value : qNode?.kind === "number" ? qNode.value : 0;
+      const maxLength = ownMax?.kind === "number" ? ownMax.value : maxNode?.kind === "number" ? maxNode.value : void 0;
+      const kids = await resolve2(dictGet(dict, "Kids"));
+      if (kids?.kind === "array" && kids.items.length) {
+        let namedKids = false;
+        for (const kid of kids.items) {
+          await checkpoint();
+          const value = await resolve2(kid);
+          if (value?.kind === "dict" && dictGet(value, "T")) {
+            namedKids = true;
+            break;
+          }
+        }
+        if (namedKids || !ft || !name) {
+          for (let i = kids.items.length - 1; i >= 0; i--) {
+            await checkpoint();
+            await push(kids.items[i], name, ft, depthNode.value + 1, flags, justification, maxLength);
+          }
+          continue;
+        }
+      }
+      if (!name) continue;
+      yield { name, dict, ft, flags, justification, maxLength };
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([frames.close(), backing.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+async function* walkRetainedFormFields(document2, storage, options = {}) {
+  let work = 0;
+  async function resolve2(node) {
+    if (++work % 64 === 0) await new Promise((resolve3) => setTimeout(resolve3, 0));
+    const found = await document2.lookup(node);
+    return found?.stream ? void 0 : found?.value;
+  }
+  for await (const { name, dict, ft } of walkRetainedFieldEntries(document2, storage, options)) {
+    const value = await inheritedRetainedFieldEntry(document2, storage, dict, "V", options);
+    if (ft === "Btn") {
+      yield { name, type: "checkbox", value: value?.kind === "name" ? value.decoded !== "Off" : value?.kind === "boolean" ? value.value : false };
+      continue;
+    }
+    let text = value?.kind === "string" ? decodePdfString(value) : value?.kind === "name" ? value.decoded : "";
+    if (value?.kind === "array") {
+      let first = true;
+      for (const item of value.items) {
+        options.signal?.throwIfAborted();
+        const found = await resolve2(item);
+        if (found?.kind === "string" || found?.kind === "name") {
+          text += `${first ? "" : ", "}${found.kind === "string" ? decodePdfString(found) : found.decoded}`;
+          first = false;
+        }
+      }
+    }
+    yield { name, type: ft === "Tx" ? "text" : ft === "Ch" ? "choice" : "unknown", value: text };
+  }
+}
+
+// packages/pdf-ast/src/extract/retained-form-field-details.ts
+async function* walkRetainedFormFieldDetails(document2, storage, options = {}) {
+  let work = 0;
+  async function checkpoint() {
+    options.signal?.throwIfAborted();
+    if (++work % 64 === 0) await new Promise((resolve3) => setTimeout(resolve3, 0));
+    options.signal?.throwIfAborted();
+  }
+  async function resolve2(node) {
+    await checkpoint();
+    const found = await document2.lookup(node);
+    return found?.stream ? void 0 : found?.value;
+  }
+  const text = (node) => node?.kind === "string" ? decodePdfString(node) : node?.kind === "name" ? node.decoded : void 0;
+  for await (const entry of walkRetainedFieldEntries(document2, storage, options)) {
+    let owned2 = function(producer) {
+      async function* visit() {
+        assertActive();
+        readers.add(reader);
+        try {
+          for await (const value2 of producer()) {
+            assertActive();
+            yield value2;
+          }
+        } finally {
+          readers.delete(reader);
+        }
+      }
+      const reader = visit();
+      return reader;
+    };
+    var owned = owned2;
+    const { dict, ft } = entry;
+    let active = true;
+    const readers = /* @__PURE__ */ new Set();
+    const assertActive = () => {
+      options.signal?.throwIfAborted();
+      if (!active) throw new PdfError("E_CAPABILITY", "Retained form field is no longer active");
+    };
+    async function* stateOptions() {
+      const seen = new PdfNameIndex(storage, options.maxStagingBytes, options.signal);
+      let count = 0, failed2 = false;
+      async function* unique(value2) {
+        assertActive();
+        if (value2 && (await seen.intern(value2)).added) {
+          count++;
+          yield value2;
+        }
+      }
+      async function* appearances(field2) {
+        const appearance = await resolve2(dictGet(field2, "AP"));
+        const normal = appearance?.kind === "dict" ? await resolve2(dictGet(appearance, "N")) : void 0;
+        if (normal?.kind === "dict") for (const pair of normal.entries) {
+          await checkpoint();
+          yield* unique(pair.key.decoded);
+        }
+      }
+      try {
+        if (ft === "Btn") {
+          yield* unique("Off");
+          yield* appearances(dict);
+          const kids = await resolve2(dictGet(dict, "Kids"));
+          if (kids?.kind === "array") for (const kid of kids.items) {
+            const field2 = await resolve2(kid);
+            if (field2?.kind === "dict") yield* appearances(field2);
+          }
+          if (count === 1) yield* unique("Yes");
+        }
+        const choices = await inheritedRetainedFieldEntry(document2, storage, dict, "Opt", options);
+        if (choices?.kind === "array") for (const item of choices.items) {
+          let value2 = await resolve2(item);
+          if (value2?.kind === "array" && value2.items.length) value2 = await resolve2(value2.items[value2.items.length - 1]);
+          yield* unique(text(value2));
+        }
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        await seen.close().catch((error) => {
+          if (!failed2) throw error;
+        });
+      }
+    }
+    const value = await inheritedRetainedFieldEntry(document2, storage, dict, "V", options);
+    const defaultValue = text(await inheritedRetainedFieldEntry(document2, storage, dict, "DV", options));
+    const altName = text(await inheritedRetainedFieldEntry(document2, storage, dict, "TU", options));
+    const checked = ft === "Btn" ? value?.kind === "name" ? value.decoded !== "Off" : value?.kind === "boolean" ? value.value : false : void 0;
+    let stateValue;
+    if (ft === "Btn") {
+      stateValue = value?.kind === "name" ? value.decoded : checked ? "Yes" : "Off";
+      if (checked && value?.kind !== "name") {
+        for await (const option of stateOptions()) if (option !== "Off") {
+          stateValue = option;
+          break;
+        }
+      }
+    }
+    async function* values() {
+      if (stateValue !== void 0) {
+        yield stateValue;
+        return;
+      }
+      if (value?.kind !== "array") {
+        yield text(value) ?? "";
+        return;
+      }
+      let any = false;
+      for (const item of value.items) {
+        const selected = text(await resolve2(item));
+        if (selected !== void 0) {
+          any = true;
+          yield selected;
+        }
+      }
+      if (!any) yield "";
+    }
+    let failed = false;
+    try {
+      yield {
+        name: entry.name,
+        type: ft === "Btn" ? "checkbox" : ft === "Ch" ? "choice" : ft === "Tx" ? "text" : "unknown",
+        flags: entry.flags,
+        justification: entry.justification === 1 ? "Centered" : entry.justification === 2 ? "Right" : "Left",
+        maxLength: entry.maxLength,
+        altName,
+        defaultValue,
+        checked,
+        stateValue,
+        values: () => owned2(values),
+        options: () => owned2(stateOptions)
+      };
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      active = false;
+      const results = await Promise.allSettled([...readers].map((reader) => reader.return()));
+      if (!failed) {
+        for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+      }
+    }
+  }
+}
+
+// packages/pdf-ast/src/retained-document.ts
+import { IntegerTable as IntegerTable5, PagedStorage as PagedStorage8 } from "@poe-platform/safe-fs/storage";
+
 // packages/pdf-ast/src/edit/retained-merge-outlines.ts
 var PdfMergeOutlines = class {
   constructor(storage, signal, maxDepth = Infinity) {
@@ -57792,127 +58289,6 @@ async function* walkRetainedPageLabels(document2, storage, options = {}) {
   }
 }
 
-// packages/pdf-ast/src/extract/retained-form-fields.ts
-import { IntegerTable as IntegerTable4, PagedStorage as PagedStorage6 } from "@poe-platform/safe-fs/storage";
-async function* walkRetainedFormFields(document2, storage, options = {}) {
-  const signal = options.signal ?? new AbortController().signal, maxDepth = options.maxDepth ?? document2.depthLimit;
-  signal.throwIfAborted();
-  const frames = new PdfMutableObjectStore(storage, { signal, ...options.maxStagingBytes === void 0 ? {} : { maxStagingBytes: options.maxStagingBytes } });
-  const backing = new PagedStorage6({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable4(backing, 64);
-  let pending = 0, work = 0, failed = false;
-  async function checkpoint(depth = 0) {
-    signal.throwIfAborted();
-    if (depth > maxDepth) throw new PdfError("E_LIMIT", "PDF form field depth limit exceeded");
-    if (++work % 64 === 0) await new Promise((resolve3) => setTimeout(resolve3, 0));
-    signal.throwIfAborted();
-  }
-  async function resolve2(node) {
-    const found = await document2.lookup(node);
-    return found?.stream ? void 0 : found?.value;
-  }
-  async function push(node, prefix, ft, depth) {
-    await frames.set({ objectNumber: ++pending, generationNumber: 0, value: cosArray([node, cosString(prefix), cosString(ft), cosNumber(depth)]) });
-  }
-  async function inheritedValue(dict) {
-    const seen = new PdfReferenceSet(storage, options.maxStagingBytes, signal);
-    let current = dict, depth = 0, failed2 = false;
-    try {
-      while (current) {
-        await checkpoint(++depth);
-        const value = dictGet(current, "V");
-        if (value !== void 0) return await resolve2(value);
-        const parent = dictGet(current, "Parent");
-        if (parent?.kind === "ref" && !await seen.add(parent.objectNumber)) return;
-        const found = await resolve2(parent);
-        current = found?.kind === "dict" ? found : void 0;
-      }
-    } catch (error) {
-      failed2 = true;
-      throw error;
-    } finally {
-      await seen.close().catch((error) => {
-        if (!failed2) throw error;
-      });
-    }
-  }
-  try {
-    const root = await resolve2(document2.crossReference.rootRef), form = root?.kind === "dict" ? await resolve2(dictGet(root, "AcroForm")) : void 0;
-    const fields2 = form?.kind === "dict" ? await resolve2(dictGet(form, "Fields")) : void 0;
-    if (fields2?.kind !== "array") return;
-    for (let i = fields2.items.length - 1; i >= 0; i--) {
-      await checkpoint();
-      await push(fields2.items[i], "", "", 0);
-    }
-    while (pending) {
-      const frame = (await frames.get(pending--)).value;
-      if (frame.kind !== "array") throw new PdfError("E_PARSE", "Invalid form traversal frame");
-      const [node, prefixNode, ftNode, depthNode] = frame.items;
-      if (frame.items.length === 1 && node?.kind === "number") {
-        await active.set(BigInt(node.value), 0n);
-        continue;
-      }
-      if (!node || prefixNode?.kind !== "string" || ftNode?.kind !== "string" || depthNode?.kind !== "number") throw new PdfError("E_PARSE", "Invalid form traversal frame");
-      await checkpoint(depthNode.value);
-      if (node.kind === "ref") {
-        if (await active.get(BigInt(node.objectNumber)) === 1n) continue;
-        await active.set(BigInt(node.objectNumber), 1n);
-        await frames.set({ objectNumber: ++pending, generationNumber: 0, value: cosArray([cosNumber(node.objectNumber)]) });
-      }
-      const dict = await resolve2(node);
-      if (dict?.kind !== "dict") continue;
-      const named = await resolve2(dictGet(dict, "T")), ownFt = await resolve2(dictGet(dict, "FT"));
-      const partial = named?.kind === "string" ? decodePdfString(named) : named?.kind === "name" ? named.decoded : "", prefix = decodePdfString(prefixNode);
-      const name = prefix && partial ? `${prefix}.${partial}` : partial || prefix, ft = ownFt?.kind === "name" ? ownFt.decoded : decodePdfString(ftNode);
-      const kids = await resolve2(dictGet(dict, "Kids"));
-      if (kids?.kind === "array" && kids.items.length) {
-        let namedKids = false;
-        for (const kid of kids.items) {
-          await checkpoint();
-          const value2 = await resolve2(kid);
-          if (value2?.kind === "dict" && dictGet(value2, "T")) {
-            namedKids = true;
-            break;
-          }
-        }
-        if (namedKids || !ft || !name) {
-          for (let i = kids.items.length - 1; i >= 0; i--) {
-            await checkpoint();
-            await push(kids.items[i], name, ft, depthNode.value + 1);
-          }
-          continue;
-        }
-      }
-      if (!name) continue;
-      const value = await inheritedValue(dict);
-      if (ft === "Btn") {
-        yield { name, type: "checkbox", value: value?.kind === "name" ? value.decoded !== "Off" : value?.kind === "boolean" ? value.value : false };
-        continue;
-      }
-      let text = value?.kind === "string" ? decodePdfString(value) : value?.kind === "name" ? value.decoded : "";
-      if (value?.kind === "array") {
-        let first = true;
-        for (const item of value.items) {
-          await checkpoint();
-          const found = await resolve2(item);
-          if (found?.kind === "string" || found?.kind === "name") {
-            text += `${first ? "" : ", "}${found.kind === "string" ? decodePdfString(found) : found.decoded}`;
-            first = false;
-          }
-        }
-      }
-      yield { name, type: ft === "Tx" ? "text" : ft === "Ch" ? "choice" : "unknown", value: text };
-    }
-  } catch (error) {
-    failed = true;
-    throw error;
-  } finally {
-    const results = await Promise.allSettled([frames.close(), backing.close()]);
-    if (!failed) {
-      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
-    }
-  }
-}
-
 // packages/pdf-ast/src/cos/stored-object-reader.ts
 async function openStoredPdfObjectReader(store, storage, options) {
   let maximum10 = 0, closed = false;
@@ -58684,124 +59060,6 @@ async function prepareRetainedPageContent(document2, page2, pageResources, stora
 
 // packages/pdf-ast/src/staged-outputs.ts
 import { listenForAbort as listenForAbort3 } from "@poe-platform/safe-fs/contracts";
-
-// packages/pdf-ast/src/cos/name-index.ts
-var PdfNameIndex = class {
-  constructor(storage, maximum10 = Infinity, signal) {
-    this.storage = storage;
-    this.maximum = maximum10;
-    this.signal = signal;
-    const limit10 = typeof maximum10 === "function" ? maximum10() : maximum10;
-    if (limit10 !== Infinity && (!Number.isSafeInteger(limit10) || limit10 < 0)) throw new RangeError("Invalid name staging limit");
-  }
-  storage;
-  maximum;
-  signal;
-  tail = /* @__PURE__ */ new Map();
-  hot = /* @__PURE__ */ new Map();
-  levels = [];
-  nextNode = 2;
-  nextName = 0;
-  closed = false;
-  get stagedBytes() {
-    return this.levels.reduce((sum, index2) => sum + (index2?.size ?? 0) * 32, 0);
-  }
-  async get(edge) {
-    if (this.tail.has(edge)) return this.tail.get(edge);
-    if (this.hot.has(edge)) return this.hot.get(edge);
-    for (const level of this.levels) {
-      const entry = await level?.get(edge, this.signal);
-      if (entry) {
-        if (this.hot.size < 256) this.hot.set(edge, entry.offset);
-        return entry.offset;
-      }
-    }
-    return void 0;
-  }
-  async insert(edge, node) {
-    this.tail.set(edge, node);
-    if (this.hot.size < 256) this.hot.set(edge, node);
-    if (this.tail.size < 64) return;
-    let level = 0;
-    while (this.levels[level]) level++;
-    const inputs = this.levels.slice(0, level);
-    const tail = this.tail;
-    const signal = this.signal;
-    async function* rows() {
-      for (const [objectNumber, offset] of tail) yield { objectNumber, offset, type: "uncompressed" };
-      for (const index2 of inputs) yield* index2.entries(signal);
-    }
-    const limit10 = typeof this.maximum === "function" ? this.maximum() : this.maximum;
-    const remaining = Math.min(limit10, Number.MAX_SAFE_INTEGER) - this.stagedBytes;
-    if (remaining < 0) throw new PdfError("E_LIMIT", "PDF name staging byte limit exceeded");
-    const combined = await PdfObjectIndex.build(rows(), this.storage, {
-      runEntries: 64,
-      chunkBytes: 2048,
-      cacheBytes: 2048,
-      maxStagingBytes: remaining,
-      ...signal ? { signal } : {}
-    });
-    try {
-      for (let i = 0; i < level; i++) {
-        await this.levels[i].close();
-        this.levels[i] = void 0;
-      }
-      this.levels[level] = combined;
-      this.tail.clear();
-    } catch (error) {
-      try {
-        await combined.close();
-      } catch {
-      }
-      throw error;
-    }
-  }
-  async intern(value) {
-    if (this.closed) throw new PdfError("E_CAPABILITY", "PDF name index is closed");
-    this.signal?.throwIfAborted();
-    let node = 1, newPath = false;
-    const units = typeof value === "string" ? (function* () {
-      for (let i = 0; i < value.length; i++) yield value.charCodeAt(i);
-    })() : value;
-    let work = 0;
-    for await (const code of units) {
-      this.signal?.throwIfAborted();
-      if (!Number.isInteger(code) || code < 0 || code > 65535) throw new RangeError("Invalid PDF name code unit");
-      if (++work % 512 === 0) {
-        await new Promise((resolve2) => setTimeout(resolve2, 0));
-        this.signal?.throwIfAborted();
-      }
-      for (const unit of [code & 255, code >>> 8]) {
-        const edge = node * 257 + unit + 1;
-        let child = newPath ? void 0 : await this.get(edge);
-        if (child === void 0) {
-          if (this.nextNode > Math.floor(Number.MAX_SAFE_INTEGER / 257) - 1) throw new PdfError("E_LIMIT", "PDF name index address limit exceeded");
-          child = this.nextNode++;
-          await this.insert(edge, child);
-          newPath = true;
-        }
-        node = child;
-      }
-    }
-    const terminal = node * 257;
-    const existing = newPath ? void 0 : await this.get(terminal);
-    if (existing !== void 0) return { index: existing, added: false };
-    const index2 = this.nextName++;
-    await this.insert(terminal, index2);
-    return { index: index2, added: true };
-  }
-  async close() {
-    if (this.closed) return;
-    this.closed = true;
-    const results = await Promise.allSettled(this.levels.map((index2) => index2?.close()));
-    this.tail.clear();
-    this.hot.clear();
-    this.levels.length = 0;
-    for (const result of results) if (result.status === "rejected") throw result.reason;
-  }
-};
-
-// packages/pdf-ast/src/staged-outputs.ts
 function maximum7(value, fallback) {
   const result = value ?? fallback;
   if (result !== Infinity && (!Number.isSafeInteger(result) || result < 0)) throw new RangeError("Invalid PDF output limit");
@@ -59911,19 +60169,62 @@ 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) {
@@ -59946,6 +60247,8 @@ 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 {
@@ -59959,7 +60262,11 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
           step = work.next(resolved?.stream && resolved.value.kind === "dict" ? { kind: "stream", dict: resolved.value, rawBytes: new Uint8Array() } : resolved?.value);
         } else if (request.kind === "array-item") {
           step = work.next(await this.readArrayItem(request.items, request.position));
-        } else if (request.kind === "visit-page") step = work.next(await visited.add(request.reference.objectNumber));
+        } else if (request.kind === "push-traversal-frame") {
+          await frames.push(request.frame);
+          step = work.next();
+        } else if (request.kind === "pop-traversal-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;
@@ -59973,6 +60280,123 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
       });
     }
   }
+  /** Resolve a named annotation destination with caller-backed path state. */
+  async annotationNamedDestination(node, name) {
+    this.assertOpen();
+    const storage = new PdfStagingStorage(this.storage, this.options.maxTraversalStagingBytes);
+    let names;
+    const flags = this.options.valueArrays?.arrayStorage;
+    const pending = [];
+    const signal = this.options.signal;
+    async function initialize() {
+      while (pending.length) {
+        const { at, length } = pending.shift();
+        signal?.throwIfAborted();
+        await flags.write(at, new Uint8Array(length), signal ? { signal } : void 0);
+        signal?.throwIfAborted();
+      }
+    }
+    const indexStorage = flags ? {
+      allocate(length) {
+        const at = flags.allocate(length);
+        pending.push({ at, length });
+        return at;
+      },
+      async read(at, length) {
+        await initialize();
+        signal?.throwIfAborted();
+        const bytes = await flags.read(at, length, signal ? { signal } : void 0);
+        signal?.throwIfAborted();
+        return bytes.slice();
+      },
+      async write(at, bytes) {
+        await initialize();
+        signal?.throwIfAborted();
+        await flags.write(at, bytes, signal ? { signal } : void 0);
+        signal?.throwIfAborted();
+      }
+    } : void 0;
+    const references = indexStorage ? new IntegerTable5(indexStorage, 64) : void 0;
+    const unusualReferences = indexStorage ? new IntegerTable5(indexStorage, 64) : void 0;
+    const backing = this.options.valueArrays?.storedArrayKeys?.includes("Kids") ? flags : void 0;
+    const frames = backing ? new StoredMetadataStack(backing, this.options.signal) : [];
+    const buffered = /* @__PURE__ */ new Map(), active = /* @__PURE__ */ new Set();
+    const direct = /* @__PURE__ */ new WeakMap();
+    let failed = false;
+    const work = annotationNameDestinationSteps(node, name, this.depthLimit);
+    try {
+      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;
+        let result;
+        if (request.kind === "resolve") {
+          const resolved = await this.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.readArrayItem(request.items, request.position);
+        else if (request.kind === "push-traversal-frame") await frames.push(request.frame);
+        else if (request.kind === "pop-traversal-frame") result = await frames.pop();
+        else if (request.kind === "enter-name-node") {
+          const node2 = request.node;
+          if (!flags) {
+            const key = node2.kind === "ref" ? `${node2.objectNumber}:${node2.generationNumber}` : node2;
+            let id2 = buffered.get(key);
+            if (id2 === void 0) {
+              id2 = buffered.size;
+              buffered.set(key, id2);
+            }
+            if (!active.has(id2)) {
+              active.add(id2);
+              result = id2;
+            }
+            step = work.next(result);
+            continue;
+          }
+          let id = node2.kind === "ref" ? void 0 : direct.get(node2);
+          if (node2.kind === "ref") {
+            const packed = Number.isSafeInteger(node2.objectNumber) && node2.objectNumber >= 0 && node2.objectNumber <= 281474976710655 && Number.isInteger(node2.generationNumber) && node2.generationNumber >= 0 && node2.generationNumber <= 65535;
+            let key;
+            const table = packed ? references : unusualReferences;
+            if (packed) key = BigInt(node2.objectNumber) << 16n | BigInt(node2.generationNumber);
+            else {
+              names ??= new PdfNameIndex(storage, Infinity, this.options.signal);
+              key = BigInt((await names.intern(`${node2.objectNumber}:${node2.generationNumber}`)).index);
+            }
+            const found = await table.get(key);
+            if (found !== void 0) id = Number(found);
+            else {
+              id = flags.allocate(1);
+              await flags.write(id, Uint8Array.of(0), signal ? { signal } : void 0);
+              await table.set(key, BigInt(id));
+            }
+          } else if (id === void 0) {
+            id = flags.allocate(1);
+            await flags.write(id, Uint8Array.of(0), signal ? { signal } : void 0);
+            direct.set(node2, id);
+          }
+          if ((await flags.read(id, 1, signal ? { signal } : void 0))[0] === 0) {
+            await flags.write(id, Uint8Array.of(1), signal ? { signal } : void 0);
+            result = id;
+          }
+        } else if (request.kind === "leave-name-node") {
+          if (flags) await flags.write(request.identity, Uint8Array.of(0), signal ? { signal } : void 0);
+          else active.delete(request.identity);
+        } else throw new TypeError("Unexpected annotation name lookup request");
+        step = work.next(result);
+      }
+      return step.value;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      work.return(void 0);
+      const results = await Promise.allSettled([names?.close()]);
+      if (!failed) {
+        for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+      }
+    }
+  }
   pages() {
     async function* visit(doc) {
       doc.assertOpen();
@@ -59980,21 +60404,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"), void 0, ["Kids"]))?.value;
-        if (type?.kind === "name" && type.decoded === "Pages" || kids?.kind === "array") {
-          if (kids?.kind === "array") for await (const kid of kids.storedItems ? readStoredItems(kids.storedItems, doc.options.signal) : 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 {
@@ -60008,7 +60461,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;
@@ -60153,6 +60606,23 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
     const work = visit(this);
     return work;
   }
+  formFieldDetails() {
+    async function* visit(doc) {
+      doc.assertOpen();
+      doc.walks.add(work);
+      try {
+        yield* walkRetainedFormFieldDetails(doc, doc.storage, {
+          maxDepth: doc.depthLimit,
+          ...doc.options.maxTraversalStagingBytes === void 0 ? {} : { maxStagingBytes: doc.options.maxTraversalStagingBytes },
+          ...doc.options.signal ? { signal: doc.options.signal } : {}
+        });
+      } finally {
+        doc.walks.delete(work);
+      }
+    }
+    const work = visit(this);
+    return work;
+  }
   attachments() {
     async function* visit(doc) {
       doc.assertOpen();
@@ -60239,11 +60709,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;
@@ -60256,13 +60722,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;
@@ -60363,7 +60822,7 @@ var PdfRetainedPage = class {
   /** Pull one annotation at a time. Destination page lookup uses the document's
    * caller-backed traversal index, without retaining a document-wide page map. */
   async *annotations() {
-    const work = extractPageAnnotationSteps(this.dict, this.document.crossReference.rootRef, this.document.depthLimit);
+    const work = extractPageAnnotationSteps(this.dict, this.document.crossReference.rootRef);
     try {
       let step = work.next(), turns = 0;
       while (!step.done) {
@@ -60377,6 +60836,7 @@ var PdfRetainedPage = class {
         } 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 if (request.kind === "named-destination") result = await this.document.annotationNamedDestination(request.node, request.name);
         else throw new TypeError("Unexpected annotation request");
         step = work.next(result);
       }
@@ -60806,7 +61266,7 @@ var PdfMergeAttachments = class {
 };
 
 // packages/pdf-ast/src/edit/retained-page-copy.ts
-import { IntegerTable as IntegerTable5, PagedStorage as PagedStorage10 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable6, PagedStorage as PagedStorage10 } from "@poe-platform/safe-fs/storage";
 async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions, singleOptions = {}) {
   const single = "pages" in input;
   const storage = single ? storageOrOptions : indicesOrStorage;
@@ -60820,7 +61280,7 @@ async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions,
   const attachments = options.includeAttachments ? new PdfMergeAttachments(storage, signal) : void 0;
   const labels = options.includePageLabels ? new PdfMergeLabels(storage, signal, maximumDepth) : void 0;
   const outlines = options.includeOutlines ? new PdfMergeOutlines(storage, signal, maximumDepth) : void 0;
-  const pageReferences = outlines ? new IntegerTable5(lists, 64) : void 0;
+  const pageReferences = outlines ? new IntegerTable6(lists, 64) : void 0;
   const catalog = cosDict({ Type: cosName("Catalog"), Pages: cosRef(2) });
   const pages = { first: 0, last: 0, count: 0 }, formFields = { first: 0, last: 0, count: 0 };
   let mayLinearize = false;
@@ -60870,7 +61330,7 @@ async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions,
   async function append(document2, pageIndices, resourceState) {
     const backing = new PagedStorage10({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
     const sourcePages = new PdfMutableObjectStore(storage, { maxRecursionDepth: maximumDepth, signal });
-    const memo = new IntegerTable5(backing, 64), wanted = new IntegerTable5(backing, 64), sourceReferences = new IntegerTable5(backing, 64);
+    const memo = new IntegerTable6(backing, 64), wanted = new IntegerTable6(backing, 64), sourceReferences = new IntegerTable6(backing, 64);
     let firstSelection = 0, lastSelection = 0, sourceFailed = false;
     async function* selections() {
       let position = firstSelection;
@@ -61078,7 +61538,7 @@ async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions,
       }
       if (fields2?.kind === "array" && acro?.kind === "dict") {
         let addedFields = false;
-        const rootNumbers = new IntegerTable5(backing, 64);
+        const rootNumbers = new IntegerTable6(backing, 64);
         for (const field2 of fields2.items) {
           if (!await hasCloned(field2)) continue;
           const cloned = await clone(field2);
@@ -61285,10 +61745,10 @@ async function* retainedCosObjects(document2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/retained-object-streams.ts
-import { IntegerTable as IntegerTable6, PagedStorage as PagedStorage11 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable7, PagedStorage as PagedStorage11 } from "@poe-platform/safe-fs/storage";
 async function* serializeRetainedObjectStreams(store, storage, options, objects, fallback) {
   const signal = options.signal ?? new AbortController().signal;
-  const backing = new PagedStorage11({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), packed = new IntegerTable6(backing);
+  const backing = new PagedStorage11({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), packed = new IntegerTable7(backing);
   let count = 0, highest = 0, failed = false, compressed;
   try {
     for await (const identity of store.identities()) {
@@ -61559,7 +62019,7 @@ async function* saveRetainedDocumentChunks(document2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
-import { IntegerTable as IntegerTable7, PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/form-appearance-chunks.ts
 function* serializeFormAppearanceChunks(text, options) {
@@ -61647,7 +62107,7 @@ function* operators(text, options) {
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
 async function generateRetainedFormAppearances(document2, store, storage, signal) {
   if (!document2.crossReference.rootRef) return;
-  const backing = new PagedStorage13({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable7(backing);
+  const backing = new PagedStorage13({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable8(backing);
   let head = -1, failed = false, work = 0;
   let defaultAppearance;
   async function checkpoint(depth = 0) {
@@ -61854,17 +62314,17 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
 }
 
 // packages/pdf-ast/src/edit/retained-flatten-annotations.ts
-import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/retained-content-edit.ts
-import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
 var RetainedContentEditor = class _RetainedContentEditor {
   constructor(store, storage, signal) {
     this.store = store;
     this.storage = storage;
     this.signal = signal;
     this.backing = new PagedStorage14({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-    this.counts = new IntegerTable8(this.backing);
+    this.counts = new IntegerTable9(this.backing);
     this.identities = new PdfNameIndex(storage, Infinity, signal);
   }
   store;
@@ -62179,7 +62639,7 @@ async function flattenRetainedAnnotations(document2, store, storage, mode, signa
           }
           if (normal?.stream && normal.reference && normal.value.kind === "dict") {
             let content = await PdfFileSource.fromStream(storage.fs, storage.directory, document2.objects.decodeStream(normal.reference.objectNumber, normal.reference.generationNumber), { signal });
-            const backing = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable9(backing), names = new PdfNameIndex(storage, Infinity, signal);
+            const backing = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable10(backing), names = new PdfNameIndex(storage, Infinity, signal);
             let appearanceFailed = false, count = 0;
             try {
               if (content.size) {
@@ -62298,7 +62758,7 @@ q ${scaleX} 0 0 ${scaleY} ${tx} ${ty} cm${matSuffix}
 }
 
 // packages/pdf-ast/src/edit/retained-stamps.ts
-import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
 async function stampRetainedPages(document2, store, storage, getPage, stamps, signal) {
   const editor = await RetainedContentEditor.open(store, storage, signal);
   let counter = 1, failed = false, work = 0;
@@ -62309,7 +62769,7 @@ async function stampRetainedPages(document2, store, storage, getPage, stamps, si
   try {
     for await (const stamp of stamps) {
       const source = await editRetainedDocument(stamp.source, storage, { signal });
-      const backing = new PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable10(backing);
+      const backing = new PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable11(backing);
       let stampFailed = false;
       async function clone(node, depth = 0) {
         await checkpoint();
@@ -62574,7 +63034,7 @@ async function externalizeRetainedInlineImages(document2, store, storage, option
 }
 
 // packages/pdf-ast/src/edit/retained-resource-pruning.ts
-import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
 async function collectNames(input, names, found, signal) {
   const iterator = input[Symbol.asyncIterator](), pending = [];
   let chunk = new Uint8Array(), at = 0, ended = false, changed = false, work = 0, failed = false;
@@ -62656,7 +63116,7 @@ async function pruneRetainedResources(document2, store, storage, signal) {
       return { ...found2, value: same(page2.reference) ? page2.dict : same(resources?.reference) ? resources.value : found2.value };
     }
     const names = new PdfNameIndex(storage, Infinity, signal), visitedNames = new PdfNameIndex(storage, Infinity, signal);
-    const backing = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable11(backing);
+    const backing = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable12(backing);
     let failed = false;
     try {
       const referenced = async (name) => await found.get(BigInt((await names.intern(name)).index)) !== void 0;
@@ -62786,7 +63246,7 @@ async function flattenRetainedRotations(document2, store, storage, signal) {
 }
 
 // packages/pdf-ast/src/edit/retained-attachment-edits.ts
-import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage21 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage21 } from "@poe-platform/safe-fs/storage";
 var PdfDuplicateAttachment = class extends PdfError {
   constructor(key) {
     super("E_CAPABILITY", `Duplicate attachment key: ${key}`);
@@ -62797,7 +63257,7 @@ var PdfDuplicateAttachment = class extends PdfError {
 async function editRetainedAttachments(document2, target, storage, remove, additions, signal, preserveTree = false) {
   const pairs = new PdfMutableObjectStore(storage, { signal });
   const names = new PdfNameIndex(storage, Infinity, signal), removed = new PdfNameIndex(storage, Infinity, signal);
-  const backing = new PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable12(backing), removals = new IntegerTable12(backing);
+  const backing = new PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable13(backing), removals = new IntegerTable13(backing);
   let failed = false, count = 0, work = 0;
   async function checkpoint() {
     signal.throwIfAborted();
@@ -63214,10 +63674,10 @@ async function* copyRetainedAttachments(document2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/retained-object-order.ts
-import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
 async function* retainedObjectOrder(document2, source, storage, signal) {
   const backing = new PagedStorage23({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-  const seen = new IntegerTable13(backing), streams = new IntegerTable13(backing);
+  const seen = new IntegerTable14(backing), streams = new IntegerTable14(backing);
   let failed = false, work = 0;
   async function candidate(number) {
     signal.throwIfAborted();
@@ -63231,7 +63691,7 @@ async function* retainedObjectOrder(document2, source, storage, signal) {
   try {
     if (document2.crossReference.revisionCount) {
       for (const kind of ["uncompressed", "compressed"]) {
-        const revisions = new IntegerTable13(backing);
+        const revisions = new IntegerTable14(backing);
         let offset = document2.crossReference.xrefOffset;
         while (offset !== void 0 && await revisions.get(BigInt(offset)) === void 0) {
           await revisions.set(BigInt(offset), 1n);
@@ -63353,14 +63813,14 @@ async function* encryptRetainedPdfChunks(source, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/qpdf-json-values.ts
-import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
 var QpdfJsonValues = class _QpdfJsonValues {
   constructor(tree, storage, signal) {
     this.tree = tree;
     this.signal = signal;
     this.scratch = new PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-    this.first = new IntegerTable14(this.scratch, 64);
-    this.next = new IntegerTable14(this.scratch, 64);
+    this.first = new IntegerTable15(this.scratch, 64);
+    this.next = new IntegerTable15(this.scratch, 64);
   }
   tree;
   signal;
@@ -63458,7 +63918,7 @@ var QpdfJsonValues = class _QpdfJsonValues {
       await this.cooperate();
       const header2 = await this.tree.describe(position);
       if (header2.kind === "object") {
-        const hashes = new IntegerTable14(this.scratch, 64);
+        const hashes = new IntegerTable15(this.scratch, 64);
         let head = 0, tail = 0;
         for await (const { key } of order.entries(position)) {
           let hash2 = 0;
@@ -63751,7 +64211,7 @@ var QpdfJsonValues = class _QpdfJsonValues {
 };
 
 // packages/pdf-ast/src/cos/qpdf-json-document.ts
-import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
 var QpdfJsonDocument = class _QpdfJsonDocument {
   constructor(storage, options = {}) {
     this.storage = storage;
@@ -63761,9 +64221,9 @@ var QpdfJsonDocument = class _QpdfJsonDocument {
       { 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);
+    this.positions = new IntegerTable16(this.backing, 64);
+    this.order = new IntegerTable16(this.backing, 64);
+    this.catalogs = new IntegerTable16(this.backing, 64);
   }
   storage;
   rootRef;