@poe-platform/safe-bash 0.1.813 → 0.1.814

package/dist/pdf-ast/index.js

@@ -28310,7 +28310,7 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
         continue;
       }
       if (tok.kind === "dict-start") {
-        const backed = options.dictionaryStorage && (parent?.kind === "dict" && options.storedDictionaryKeys?.includes(parent.key.decoded) || !parent && options.storeRootDictionary);
+        const backed = options.dictionaryStorage && (parent?.kind === "dict" && !parent.storedEntries && options.storedDictionaryKeys?.includes(parent.key.decoded) || !parent && options.storeRootDictionary);
         yield* push({
           kind: "dict",
           path: ancestorPath(parent),
@@ -43006,6 +43006,13 @@ function* resolveEvaluationDict(node, arrayPathPrefix) {
   const resolved = yield* resolveEvaluationNode(node, false, arrayPathPrefix);
   return resolved?.kind === "dict" ? resolved : resolved?.kind === "stream" ? resolved.dict : void 0;
 }
+function* lookupEvaluationDictionary(dict, key) {
+  if (!dict) return void 0;
+  if (!dict.storedEntries) return dictGet(dict, key);
+  const result = yield { kind: "dictionary-value", dict, key };
+  if (!result || !("kind" in result) || result.kind !== "resolved") throw new TypeError("Expected a PDF dictionary value");
+  return result.node;
+}
 function* resolveEvaluationArray(node, storeRootArray = false, arrayPathPrefix) {
   const resolved = yield* resolveEvaluationNode(node, storeRootArray, arrayPathPrefix);
   return resolved?.kind === "array" ? resolved : void 0;
@@ -43853,8 +43860,8 @@ function* evaluateContentSteps(params) {
     let resolvedMcid = node.mcid;
     let resolvedActualText = node.actualText ?? node.storedActualText;
     if (typeof node.properties === "string" && activeResources) {
-      const propsMap = yield* resolveEvaluationDict(dictGet(activeResources, "Properties"));
-      const propRefOrNode = propsMap ? dictGet(propsMap, node.properties) : void 0;
+      const propsMap = yield* resolveEvaluationDict(dictGet(activeResources, "Properties"), ["Properties"]);
+      const propRefOrNode = yield* lookupEvaluationDictionary(propsMap, node.properties);
       if (propRefOrNode) {
         const propDict = yield* resolveEvaluationDict(propRefOrNode);
         const propType = propDict ? yield* resolveEvaluationNode(dictGet(propDict, "Type")) : void 0;
@@ -44037,8 +44044,8 @@ function* evaluateContentSteps(params) {
           case "xobject": {
             const st = curState();
             if (activeResources) {
-              const xobjDict = yield* resolveEvaluationDict(dictGet(activeResources, "XObject"));
-              const xobjNode = xobjDict ? yield* resolveEvaluationNode(dictGet(xobjDict, node.name)) : void 0;
+              const xobjDict = yield* resolveEvaluationDict(dictGet(activeResources, "XObject"), ["XObject"]);
+              const xobjNode = xobjDict ? yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(xobjDict, node.name)) : void 0;
               if (xobjNode?.kind === "stream") {
                 if (!(yield* optionalContentVisibilitySteps(dictGet(xobjNode.dict, "OC")))) {
                   break;
@@ -44439,7 +44446,7 @@ function* evaluateContentStreamSteps(params) {
           else exhausted = true;
         }
         step = work.next(next.done ? void 0 : next.value);
-      } else if (step.value.kind === "dash-array" || step.value.kind === "array-reference" || step.value.kind === "array-item" || step.value.kind === "string-bytes" || step.value.kind === "font-width" || step.value.kind === "font-unicode" || step.value.kind === "cmap-lookup" || step.value.kind === "cmap-character" || step.value.kind === "truetype-number" || step.value.kind === "truetype-path" || step.value.kind === "cid-gid" || step.value.kind === "frame-push" || step.value.kind === "frame-pop" || step.value.kind === "capture-append" || step.value.kind === "transform-path" || step.value.kind === "append-clip" || step.value.kind === "path-append" || step.value.kind === "path-finish") {
+      } else if (step.value.kind === "dictionary-value" || step.value.kind === "dash-array" || step.value.kind === "array-reference" || step.value.kind === "array-item" || step.value.kind === "string-bytes" || step.value.kind === "font-width" || step.value.kind === "font-unicode" || step.value.kind === "cmap-lookup" || step.value.kind === "cmap-character" || step.value.kind === "truetype-number" || step.value.kind === "truetype-path" || step.value.kind === "cid-gid" || step.value.kind === "frame-push" || step.value.kind === "frame-pop" || step.value.kind === "capture-append" || step.value.kind === "transform-path" || step.value.kind === "append-clip" || step.value.kind === "path-append" || step.value.kind === "path-finish") {
         throw new PdfError("E_CAPABILITY", "Stored PDF paths require an asynchronous source driver");
       } else if (step.value.kind === "shading") {
         if (!params.cosDoc) throw new PdfError("E_CAPABILITY", "PDF shading requires a source driver");
@@ -44631,7 +44638,8 @@ function* preparePageAppearanceSteps(pageDict, pageRes, evalResourcesDict, hideA
     const sub = yield* resolveDict3(entry.value, [entry.key.decoded]);
     if (sub) {
       onAllocation?.(64 + sub.entries.length * 64);
-      const clonedSub = sub.storedEntries ? yield { kind: "dictionary-merge", destination: sub } : cosDict({});
+      const shareBacking = entry.key.decoded === "XObject" || entry.key.decoded === "Properties";
+      const clonedSub = sub.storedEntries ? shareBacking ? { ...sub, entries: [] } : yield { kind: "dictionary-merge", destination: sub } : cosDict({});
       if (!sub.storedEntries) for (const se of sub.entries) dictSet(clonedSub, se.key.decoded, se.value);
       dictSet(evalResourcesDict, entry.key.decoded, clonedSub);
     } else {
@@ -49283,54 +49291,6 @@ async function openPdfCrossReference(source, storage, options = {}) {
   }
 }
 
-// packages/pdf-ast/src/cos/filter-dictionary.ts
-async function resolvePdfStreamDictionary(dict, lookup, active, options) {
-  let remaining = options.maxNodes ?? 65536;
-  const resolve2 = async (node, depth) => {
-    if (--remaining < 0 || depth >= (options.maxRecursionDepth ?? 100)) throw new PdfError("E_LIMIT", "PDF filter resolution limit exceeded");
-    if (node.kind === "ref") {
-      if (active.has(node.objectNumber)) throw new PdfError("E_PARSE", "PDF filter reference cycle");
-      const object = await lookup(node);
-      if (!object) throw new PdfError("E_PARSE", "Missing PDF filter reference");
-      active.add(node.objectNumber);
-      try {
-        return await resolve2(object.value, depth + 1);
-      } finally {
-        active.delete(node.objectNumber);
-      }
-    }
-    if (node.kind === "array") {
-      const items = [];
-      const { storedItems, ...ordinary } = node;
-      if (storedItems) {
-        const reader = readStoredItems(storedItems, options.signal);
-        try {
-          for (; ; ) {
-            const item = await reader.next().catch((error) => {
-              options.onBackingError?.(error);
-              throw error;
-            });
-            if (item.done) break;
-            items.push(await resolve2(item.value, depth + 1));
-          }
-        } finally {
-          await reader.return();
-        }
-      } else for (const item of node.items) items.push(await resolve2(item, depth + 1));
-      return { ...ordinary, items };
-    }
-    if (node.kind === "dict") {
-      const entries2 = [];
-      for (const entry of node.entries) entries2.push({ ...entry, value: await resolve2(entry.value, depth + 1) });
-      return { ...node, entries: entries2 };
-    }
-    return node;
-  };
-  const entries = [];
-  for (const entry of dict.entries) entries.push(["Filter", "F", "DecodeParms", "DP", "Type"].includes(entry.key.decoded) ? { ...entry, value: await resolve2(entry.value, 0) } : entry);
-  return { ...dict, entries };
-}
-
 // packages/pdf-ast/src/cos/reference-set.ts
 var PdfReferenceSet = class {
   constructor(storage, maximum10 = Infinity, signal) {
@@ -49345,12 +49305,16 @@ var PdfReferenceSet = class {
   tail = /* @__PURE__ */ new Set();
   levels = [];
   closed = false;
-  async add(number) {
+  async has(number) {
     if (this.closed) throw new PdfError("E_CAPABILITY", "PDF reference set is closed");
     this.signal?.throwIfAborted();
     if (!Number.isSafeInteger(number) || number < 0) throw new RangeError("Invalid PDF reference number");
-    if (this.tail.has(number)) return false;
-    for (const level2 of this.levels) if (await level2?.get(number, this.signal)) return false;
+    if (this.tail.has(number)) return true;
+    for (const level of this.levels) if (await level?.get(number, this.signal)) return true;
+    return false;
+  }
+  async add(number) {
+    if (await this.has(number)) return false;
     this.tail.add(number);
     if (this.tail.size < 64) return true;
     let level = 0;
@@ -49398,6 +49362,54 @@ var PdfReferenceSet = class {
   }
 };
 
+// packages/pdf-ast/src/cos/filter-dictionary.ts
+async function resolvePdfStreamDictionary(dict, lookup, active, options) {
+  let remaining = options.maxNodes ?? 65536;
+  const resolve2 = async (node, depth) => {
+    if (--remaining < 0 || depth >= (options.maxRecursionDepth ?? 100)) throw new PdfError("E_LIMIT", "PDF filter resolution limit exceeded");
+    if (node.kind === "ref") {
+      if (active.has(node.objectNumber)) throw new PdfError("E_PARSE", "PDF filter reference cycle");
+      const object = await lookup(node);
+      if (!object) throw new PdfError("E_PARSE", "Missing PDF filter reference");
+      active.add(node.objectNumber);
+      try {
+        return await resolve2(object.value, depth + 1);
+      } finally {
+        active.delete(node.objectNumber);
+      }
+    }
+    if (node.kind === "array") {
+      const items = [];
+      const { storedItems, ...ordinary } = node;
+      if (storedItems) {
+        const reader = readStoredItems(storedItems, options.signal);
+        try {
+          for (; ; ) {
+            const item = await reader.next().catch((error) => {
+              options.onBackingError?.(error);
+              throw error;
+            });
+            if (item.done) break;
+            items.push(await resolve2(item.value, depth + 1));
+          }
+        } finally {
+          await reader.return();
+        }
+      } else for (const item of node.items) items.push(await resolve2(item, depth + 1));
+      return { ...ordinary, items };
+    }
+    if (node.kind === "dict") {
+      const entries2 = [];
+      for (const entry of node.entries) entries2.push({ ...entry, value: await resolve2(entry.value, depth + 1) });
+      return { ...node, entries: entries2 };
+    }
+    return node;
+  };
+  const entries = [];
+  for (const entry of dict.entries) entries.push(["Filter", "F", "DecodeParms", "DP", "Type"].includes(entry.key.decoded) ? { ...entry, value: await resolve2(entry.value, 0) } : entry);
+  return { ...dict, entries };
+}
+
 // packages/pdf-ast/src/cos/recovered-reference.ts
 async function* recoveredBodies(source, index2, storage, options) {
   const visited = new PdfReferenceSet(storage, options.index?.maxStagingBytes, options.signal);
@@ -49527,6 +49539,7 @@ var PdfObjectReader = class {
     this.capacity = integer2(options.objectStreamCacheEntries ?? 2, "objectStreamCacheEntries", 1);
     this.stagingLimit = maximum2(options.maxStagingBytes, "maxStagingBytes");
     maximum2(options.maxObjectStreamMembers, "maxObjectStreamMembers");
+    maximum2(options.maxTraversalStagingBytes, "maxTraversalStagingBytes");
     this.options = {
       maxNodes: 65536,
       maxTokenBytes: 1048576,
@@ -49543,6 +49556,7 @@ var PdfObjectReader = class {
   // Recursive length/object-stream lookups share one failure identity so an
   // outer recovery pass cannot mistake a caller-storage error for PDF syntax.
   backingFailures = /* @__PURE__ */ new WeakMap();
+  lengthPaths = /* @__PURE__ */ new WeakMap();
   repairedOffsets = /* @__PURE__ */ new Map();
   options;
   capacity;
@@ -49583,10 +49597,76 @@ var PdfObjectReader = class {
     const decodeOptions = { ...this.options, stopBeforeImageCodec: options.stopBeforeImageCodec ?? false, raw: options.raw ?? false };
     yield* security ? decodePdfEncryptedStreamChunks(security, objectNumber, generationNumber, dict, input, decodeOptions) : decodePdfStreamChunks(dict, input, decodeOptions);
   }
-  async load(objectNumber, generationNumber, active, arrays = this.options.valueArrays ?? {}) {
+  /** A stream-valued /Length is invalid as a length, but its references still
+   * need cycle, admission and backing-error validation. Walk those discarded
+   * values in source order instead of retaining one parser and AST per link. */
+  async resolveLength(reference, active) {
+    const path = {
+      seen: new PdfReferenceSet(this.storage, this.options.maxTraversalStagingBytes, this.options.signal),
+      parent: this.lengthPaths.get(active),
+      depth: 0
+    };
+    this.lengthPaths.set(active, path);
+    let next = reference, result, failed = false;
+    try {
+      while (next) {
+        const current = next;
+        next = void 0;
+        const object = await this.load(
+          current.objectNumber,
+          current.generationNumber,
+          active,
+          this.options.valueArrays ?? {},
+          async (child) => {
+            next = child;
+            return void 0;
+          }
+        );
+        if (path.depth === 0 && object?.value.kind === "number") result = object.value.value;
+        try {
+          await path.seen.add(current.objectNumber);
+        } catch (error) {
+          this.backingFailures.set(active, { error });
+          this.options.onBackingError?.(error);
+          throw error;
+        }
+        path.depth++;
+      }
+      return result;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      if (path.parent) this.lengthPaths.set(active, path.parent);
+      else this.lengthPaths.delete(active);
+      try {
+        await path.seen.close();
+      } catch (error) {
+        if (!failed) {
+          this.backingFailures.set(active, { error });
+          this.options.onBackingError?.(error);
+          await Promise.reject(error);
+        }
+      }
+    }
+  }
+  async load(objectNumber, generationNumber, active, arrays = this.options.valueArrays ?? {}, resolveLength) {
     this.options.signal?.throwIfAborted();
     if (active.has(objectNumber)) throw new PdfError("E_PARSE", "PDF indirect object cycle");
-    if (active.size >= this.options.maxRecursionDepth) throw new PdfError("E_LIMIT", "PDF object resolution depth limit exceeded");
+    let depth = active.size;
+    for (let path = this.lengthPaths.get(active); path; path = path.parent) {
+      let seen;
+      try {
+        seen = await path.seen.has(objectNumber);
+      } catch (error) {
+        this.backingFailures.set(active, { error });
+        this.options.onBackingError?.(error);
+        throw error;
+      }
+      if (seen) throw new PdfError("E_PARSE", "PDF indirect object cycle");
+      depth += path.depth;
+    }
+    if (depth >= this.options.maxRecursionDepth) throw new PdfError("E_LIMIT", "PDF object resolution depth limit exceeded");
     const entry = await this.index.get(objectNumber, this.options.signal);
     if (!entry || entry.type === "free" || generationNumber !== (entry.generationNumber ?? 0)) return void 0;
     active.add(objectNumber);
@@ -49611,18 +49691,18 @@ var PdfObjectReader = class {
         return { objectNumber, generationNumber, value: parsed.value, span: { start, end: parsed.offset } };
       }
       let object;
+      let pendingLength;
       try {
         object = await parseCosRangeObject(this.source, this.repairedOffsets.get(objectNumber) ?? entry.offset, {
           ...this.options,
           ...arrays,
           onBackingError,
-          resolveLength: async (reference) => {
-            const resolved = await this.load(reference.objectNumber, reference.generationNumber, active);
-            return resolved?.value.kind === "number" ? resolved.value.value : void 0;
-          }
+          resolveLength: (reference) => pendingLength = resolveLength ? resolveLength(reference) : this.resolveLength(reference, active)
         });
         if (object.objectNumber !== objectNumber || object.generationNumber !== generationNumber) throw new PdfError("E_PARSE", "Indirect object identity does not match xref");
       } catch (error) {
+        await pendingLength?.catch(() => {
+        });
         this.options.signal?.throwIfAborted();
         const backingFailure = this.backingFailures.get(active);
         if (backingFailure && Object.is(backingFailure.error, error)) throw error;
@@ -54950,7 +55030,7 @@ async function resolveRetainedFont(document2, storage, resources, name, options
       }
       let value;
       if (step.value.kind === "resolve") {
-        const retained = await document2.lookup(step.value.node, options.resourceStorage ? { dictionaryStorage: options.resourceStorage, storedDictionaryKeys: ["Font"], storeRootDictionary: step.value.storeRootDictionary ?? false, arrayStorage: options.resourceStorage, storedArrayKeys: ["Widths", "W", "Differences"], storeRootArray: step.value.storeRootArray ?? false } : {});
+        const retained = await document2.lookup(step.value.node, options.resourceStorage ? { dictionaryStorage: options.resourceStorage, storedDictionaryKeys: ["Font", "XObject", "Properties"], storeRootDictionary: step.value.storeRootDictionary ?? false, arrayStorage: options.resourceStorage, storedArrayKeys: ["Widths", "W", "Differences"], storeRootArray: step.value.storeRootArray ?? false } : {});
         value = retained?.value;
         if (retained?.stream) {
           if (retained.value.kind !== "dict" || !retained.reference) throw new PdfError("E_PARSE", "Font stream has no retained identity");
@@ -55290,6 +55370,9 @@ async function* evaluateRetainedContentSteps(document2, content, params, storage
           reply = { kind: "dash-array", value: await storeDashArray(request.array, request.storage, request.resolveReferences ? resolve2 : async (node) => node, signal) };
           break;
         }
+        case "dictionary-value":
+          reply = { kind: "resolved", node: await readPdfDictionaryValue(request.dict, request.key, signal) };
+          break;
         case "array-reference":
           reply = { kind: "resolved", node: cosBool(await memberships.has(request.items, request.objectNumber)) };
           break;
@@ -58358,7 +58441,7 @@ var PdfMergeOutlines = class {
         if (node.kind === "ref" && !await seen.add(node.objectNumber)) continue;
         const dict = (await document2.lookup(node))?.value;
         if (dict?.kind !== "dict") continue;
-        yield dict;
+        yield { dict, level: depth + 1 };
         if (outlines) {
           await push(dictGet(dict, "Next"), depth);
           await push(dictGet(dict, "First"), depth + 1);
@@ -58380,7 +58463,7 @@ var PdfMergeOutlines = class {
       }
     }
   }
-  async append(document2, pageOffset, includeUntitled = false) {
+  async append(document2, pageOffset, includeUntitled = false, includeNameTitles = false) {
     const resolve2 = async (node) => (await document2.lookup(node))?.value;
     const catalog = await resolve2(document2.crossReference.rootRef);
     if (catalog?.kind !== "dict") return;
@@ -58391,7 +58474,7 @@ var PdfMergeOutlines = class {
       const legacy = await resolve2(dictGet(catalog, "Dests")), direct = legacy?.kind === "dict" ? dictGet(legacy, name) : void 0;
       if (direct) return direct;
       const names = await resolve2(dictGet(catalog, "Names"));
-      if (names?.kind === "dict") for await (const tree of this.walk(document2, dictGet(names, "Dests"), false)) {
+      if (names?.kind === "dict") for await (const { dict: tree } of this.walk(document2, dictGet(names, "Dests"), false)) {
         const pairs = await resolve2(dictGet(tree, "Names"));
         if (pairs?.kind === "array") for (let i = 0; i + 1 < pairs.items.length; i += 2) {
           await this.checkpoint();
@@ -58424,10 +58507,10 @@ var PdfMergeOutlines = class {
       return number?.kind === "number" && number.value >= 0 && number.value < pageCount ? Math.round(number.value) : 0;
     };
     try {
-      for await (const outline of this.walk(document2, dictGet(outlines, "First"), true)) {
-        const title = await resolve2(dictGet(outline, "Title")), text = title?.kind === "string" ? decodePdfString(title) : "";
+      for await (const { dict: outline, level } of this.walk(document2, dictGet(outlines, "First"), true)) {
+        const title = await resolve2(dictGet(outline, "Title")), text = title?.kind === "string" ? decodePdfString(title) : includeNameTitles && title?.kind === "name" ? title.decoded : "";
         const index2 = await destination(dictGet(outline, "Dest") ?? dictGet(outline, "A"));
-        if (text || includeUntitled) await this.objects.set({ objectNumber: ++this.count, generationNumber: 0, value: cosDict({ Title: cosString(text), Page: cosNumber(pageOffset + index2) }) });
+        if (text || includeUntitled) await this.objects.set({ objectNumber: ++this.count, generationNumber: 0, value: cosDict({ Title: cosString(text), Page: cosNumber(pageOffset + index2), Level: cosNumber(level) }) });
       }
     } catch (error) {
       failed = true;
@@ -58439,11 +58522,14 @@ var PdfMergeOutlines = class {
     }
   }
   async *entries() {
+    for await (const { title, pageIndex } of this.details()) yield { title, pageIndex };
+  }
+  async *details() {
     for await (const object of this.objects.objects()) {
       await this.checkpoint();
-      const row = object.value, title = dictGet(row, "Title"), index2 = dictGet(row, "Page");
+      const row = object.value, title = dictGet(row, "Title"), index2 = dictGet(row, "Page"), level = dictGet(row, "Level");
       if (title?.kind !== "string" || index2?.kind !== "number") throw new PdfError("E_PARSE", "Invalid staged outline summary");
-      yield { title: decodePdfString(title), pageIndex: index2.value };
+      yield { title: decodePdfString(title), pageIndex: index2.value, level: level?.kind === "number" ? level.value : 1 };
     }
   }
   async finish(target, catalog, pageCount, page2) {
@@ -59539,7 +59625,7 @@ async function markedText(document2, page2, mcid, storage, options) {
     var boundary = boundary2, scan = scan2;
     source = await PdfFileSource.fromStream(storage.fs, storage.directory, input(), { chunkBytes, cacheBytes: chunkBytes, maxInputBytes: maximum10, ...signal ? { signal } : {} });
     const resources = (await document2.lookup(dictGet(page2, "Resources")))?.value;
-    const properties = resources?.kind === "dict" ? (await document2.lookup(dictGet(resources, "Properties")))?.value : void 0;
+    const properties = resources?.kind === "dict" ? (await document2.lookup(dictGet(resources, "Properties"), void 0, ["Properties"]))?.value : void 0;
     const operators2 = parseContentRangeOperators(source, storage, { chunkBytes, maxStagingBytes: maximum10 - source.size, ...signal ? { signal } : {} });
     let pending, matching = false, inText = false, part = 0, recorded = false;
     async function* fragments(command) {
@@ -59568,7 +59654,7 @@ async function markedText(document2, page2, mcid, storage, options) {
               await marks.push({ kind: "boolean", value: matching });
               if (operator !== "q") {
                 const property = operands[1];
-                const dict = property?.kind === "name" && properties?.kind === "dict" ? (await document2.lookup(dictGet(properties, property.decoded)))?.value : property;
+                const dict = property?.kind === "name" && properties?.kind === "dict" ? (await document2.lookup(await readPdfDictionaryValue(properties, property.decoded, signal)))?.value : property;
                 const number = dict?.kind === "dict" ? (await document2.lookup(dictGet(dict, "MCID")))?.value : void 0;
                 if (number?.kind === "number") matching = number.value === mcid;
               }
@@ -59967,8 +60053,8 @@ async function* walkRetainedImages(document2, storage, options) {
   const decodeOptions = { chunkBytes, ...options.maxDecodedBytes === void 0 ? {} : { maxDecodedBytes: options.maxDecodedBytes }, ...options.signal ? { signal: options.signal } : {} };
   let imageIndex = 0;
   let stagedBytes = 0;
-  async function dictionary(node) {
-    const value = await document2.lookup(node);
+  async function dictionary(node, resourceKey) {
+    const value = await document2.lookup(node, void 0, resourceKey ? [resourceKey] : void 0);
     return value?.value.kind === "dict" && !value.stream ? value.value : void 0;
   }
   async function number(node, fallback) {
@@ -60067,8 +60153,8 @@ async function* walkRetainedImages(document2, storage, options) {
           } else if (op.operator === "Do") {
             const name = op.operands[0];
             if (name?.kind !== "name") continue;
-            const objects = await dictionary(dictGet(activeResources, "XObject"));
-            const target = await document2.lookup(objects ? dictGet(objects, name.decoded) : void 0);
+            const objects = await dictionary(dictGet(activeResources, "XObject"), "XObject");
+            const target = await document2.lookup(objects ? await readPdfDictionaryValue(objects, name.decoded, options.signal) : void 0);
             if (target?.value.kind !== "dict" || !target.stream || !target.reference) continue;
             const subtype = (await document2.lookup(dictGet(target.value, "Subtype")))?.value;
             if (subtype?.kind !== "name") continue;
@@ -60129,8 +60215,8 @@ async function* walkRetainedImages(document2, storage, options) {
       yield* content(page2.streamContents(), resources, identity, /* @__PURE__ */ new Set(), 0);
       const patterns = await dictionary(dictGet(resources, "Pattern"));
       if (patterns) for (const entry of patterns.entries) yield* auxiliary(entry.value, resources);
-      const fonts = await dictionary(dictGet(resources, "Font"));
-      if (fonts) for (const entry of fonts.entries) {
+      const fonts = await dictionary(dictGet(resources, "Font"), "Font");
+      if (fonts) for await (const entry of readPdfDictionaryEntries(fonts, options.signal)) {
         const font = await dictionary(entry.value);
         if (!font) continue;
         const subtype = (await document2.lookup(dictGet(font, "Subtype")))?.value;
@@ -60145,8 +60231,8 @@ async function* walkRetainedImages(document2, storage, options) {
         const appearance = annotation ? await dictionary(dictGet(annotation, "AP")) : void 0;
         if (appearance) yield* auxiliary(dictGet(appearance, "N"), resources);
       }
-      const objects = await dictionary(dictGet(resources, "XObject"));
-      if (objects) for (const entry of objects.entries) {
+      const objects = await dictionary(dictGet(resources, "XObject"), "XObject");
+      if (objects) for await (const entry of readPdfDictionaryEntries(objects, options.signal)) {
         const ref = entry.value;
         if (ref.kind === "ref" && !(await seen.intern(`${ref.objectNumber}:${ref.generationNumber}`)).added) continue;
         const target = await document2.lookup(ref);
@@ -60183,8 +60269,8 @@ async function* walkRetainedFonts(document2, storage, options) {
   const last = options.lastPage ?? Infinity;
   if (!Number.isSafeInteger(first) || first < 1 || last !== Infinity && (!Number.isSafeInteger(last) || last < first)) throw new RangeError("Invalid PDF font page range");
   let failed = false;
-  async function dictionary(node) {
-    const resolved = await document2.lookup(node);
+  async function dictionary(node, resourceKey) {
+    const resolved = await document2.lookup(node, void 0, resourceKey ? [resourceKey] : void 0);
     return resolved?.value.kind === "dict" && !resolved.stream ? resolved.value : void 0;
   }
   async function* font(node, key, depth) {
@@ -60220,8 +60306,8 @@ async function* walkRetainedFonts(document2, storage, options) {
     options.signal?.throwIfAborted();
     if (!value) return;
     if (depth > options.maxDepth) throw new PdfError("E_LIMIT", "PDF font resource depth limit exceeded");
-    const fonts = await dictionary(dictGet(value, "Font"));
-    if (fonts) for (const entry of fonts.entries) yield* font(entry.value, entry.key.decoded, depth);
+    const fonts = await dictionary(dictGet(value, "Font"), "Font");
+    if (fonts) for await (const entry of readPdfDictionaryEntries(fonts, options.signal)) yield* font(entry.value, entry.key.decoded, depth);
     const states = await dictionary(dictGet(value, "ExtGState"));
     if (states) for (const entry of states.entries) {
       const state = await dictionary(entry.value);
@@ -60229,9 +60315,9 @@ async function* walkRetainedFonts(document2, storage, options) {
       if (gsFont?.kind === "array" && gsFont.items[0]) yield* font(gsFont.items[0], `ExtGS_${entry.key.decoded}`, depth);
     }
     for (const key of ["XObject", "Pattern"]) {
-      const objects = await dictionary(dictGet(value, key));
+      const objects = await dictionary(dictGet(value, key), key);
       if (!objects) continue;
-      for (const entry of objects.entries) {
+      for await (const entry of readPdfDictionaryEntries(objects, options.signal)) {
         if (entry.value.kind === "ref" && !(await names.intern(`form:${entry.value.objectNumber}`)).added) continue;
         const resolved = await document2.lookup(entry.value);
         if (!resolved?.stream || resolved.value.kind !== "dict") continue;
@@ -60815,6 +60901,29 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
     const work = visit(this);
     return work;
   }
+  outlineDetails() {
+    async function* visit(doc) {
+      doc.assertOpen();
+      doc.walks.add(work);
+      const storage = new PdfStagingStorage(doc.storage, doc.options.maxTraversalStagingBytes);
+      const outlines = new PdfMergeOutlines(storage, doc.options.signal, Infinity);
+      let failed = false;
+      try {
+        await outlines.append(doc, 0, false, true);
+        yield* outlines.details();
+      } catch (error) {
+        failed = true;
+        throw error;
+      } finally {
+        doc.walks.delete(work);
+        await outlines.close().catch((error) => {
+          if (!failed) throw error;
+        });
+      }
+    }
+    const work = visit(this);
+    return work;
+  }
   pageLabels() {
     async function* visit(doc) {
       doc.assertOpen();
@@ -62280,6 +62389,9 @@ async function* saveRetainedDocumentChunks(document2, storage, options = {}) {
   }
 }
 
+// packages/pdf-ast/src/edit/retained-info-updates.ts
+import { PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
+
 // packages/pdf-ast/src/edit/retained-bookmarks.ts
 import { PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
 async function setRetainedBookmarks(store, storage, root, pageCount, pageReference, bookmarks, signal, maxDepth = Infinity) {
@@ -62357,6 +62469,126 @@ async function setRetainedBookmarks(store, storage, root, pageCount, pageReferen
   }
 }
 
+// packages/pdf-ast/src/edit/retained-info-updates.ts
+async function applyRetainedInfoUpdates(document2, store, storage, count, getPage, updates, signal, maxDepth) {
+  const pages = new PagedStorage14({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const base = pages.allocate(count * 4 * 48), heads = [-1, -1, -1, -1], tails = [-1, -1, -1, -1];
+  const labels = new PdfMutableObjectStore(storage, { signal }), bookmarks = new PdfMutableObjectStore(storage, { signal });
+  let infoRef = document2.crossReference.infoRef, idArray = document2.crossReference.idArray, labelCount = 0, work = 0, failed = false;
+  const rootRef = document2.crossReference.rootRef;
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+    signal.throwIfAborted();
+  }
+  const position = (group, index2) => base + (group * count + index2) * 48;
+  try {
+    for await (const update of updates) {
+      await checkpoint();
+      if (update.kind === "info") {
+        const standard = ["Title", "Author", "Subject", "Keywords", "Creator", "Producer"].includes(update.key);
+        let info3 = infoRef ? await store.get(infoRef.objectNumber) : void 0;
+        if (infoRef && info3?.value.kind !== "dict") {
+          const resolved = await document2.lookup(infoRef);
+          if (resolved?.value.kind === "dict" && resolved.reference) info3 = await store.get(resolved.reference.objectNumber);
+        }
+        if (!infoRef || standard && info3?.value.kind !== "dict") {
+          infoRef = await store.allocate(cosDict(!standard ? { Title: cosString("") } : {}));
+          info3 = await store.get(infoRef.objectNumber);
+        }
+        if (info3?.value.kind === "dict") {
+          dictSet(info3.value, update.key, cosString(update.value));
+          await store.set(info3);
+        }
+      } else if (update.kind === "id") {
+        if (idArray === document2.crossReference.idArray) {
+          const first = await document2.lookup(idArray?.items[0]), second = await document2.lookup(idArray?.items[1]);
+          const a = first?.value.kind === "string" ? first.value.bytes : new Uint8Array(16), b = second?.value.kind === "string" ? second.value.bytes : a;
+          idArray = cosArray([cosHexString(a), cosHexString(b)]);
+        }
+        idArray.items[update.index] = cosHexString(new Uint8Array(update.bytes));
+      } else if (update.kind === "page") {
+        const index2 = update.pageNumber - 1;
+        if (!Number.isSafeInteger(index2) || index2 < 0 || index2 >= count) continue;
+        const group = ["rotation", "dimensions", "media", "crop"].indexOf(update.property), size = group === 0 ? 1 : group === 1 ? 2 : 4;
+        if (update.values.length !== size || !update.values.every(Number.isFinite)) throw new RangeError("Invalid page property values");
+        const offset = position(group, index2), bytes = await pages.read(offset, 48), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+        if (!view.getFloat64(0)) {
+          view.setFloat64(0, 1);
+          view.setFloat64(8, -1);
+          if (tails[group] >= 0) {
+            const link2 = new Uint8Array(8);
+            new DataView(link2.buffer).setFloat64(0, index2);
+            await pages.write(position(group, tails[group]) + 8, link2);
+          } else heads[group] = index2;
+          tails[group] = index2;
+        }
+        for (let i = 0; i < size; i++) view.setFloat64(16 + i * 8, update.values[i]);
+        await pages.write(offset, bytes);
+      } else if (update.kind === "label") {
+        const value = cosDict({ St: cosNumber(update.start) });
+        if (update.prefix) dictSet(value, "P", cosString(update.prefix));
+        if (update.style) dictSet(value, "S", cosName(update.style));
+        await labels.allocate(cosArray([cosNumber(update.index), value]));
+        labelCount++;
+      } else await bookmarks.allocate(cosArray([cosString(update.title), cosNumber(update.level), cosNumber(update.pageNumber)]));
+    }
+    for (let group = 0; group < 4; group++) for (let index2 = heads[group]; index2 >= 0; ) {
+      await checkpoint();
+      const bytes = await pages.read(position(group, index2), 48), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length), page2 = await getPage(index2);
+      if (group === 0) dictSet(page2.dict, "Rotate", cosNumber((Math.round(view.getFloat64(16) / 90) * 90 % 360 + 360) % 360));
+      else {
+        const values = group === 1 ? [0, 0, view.getFloat64(16), view.getFloat64(24)] : [16, 24, 32, 40].map((offset) => view.getFloat64(offset));
+        dictSet(page2.dict, group === 3 ? "CropBox" : "MediaBox", cosArray(values.map((value) => cosNumber(value))));
+      }
+      await store.set({ objectNumber: page2.reference.objectNumber, generationNumber: page2.reference.generationNumber, value: page2.dict });
+      index2 = view.getFloat64(8);
+    }
+    if (labelCount) {
+      const root = await store.get(rootRef.objectNumber);
+      if (root?.value.kind === "dict") {
+        const ref = await store.allocate(cosDict({}));
+        dictSet(root.value, "PageLabels", ref);
+        await store.set(root);
+        async function* chunks() {
+          const encoder = new TextEncoder();
+          yield encoder.encode("<<\n/Nums [ ");
+          for await (const object of labels.objects()) {
+            await checkpoint();
+            if (object.value.kind !== "array") throw new Error("Invalid label record");
+            for (const node of object.value.items) {
+              yield* serializeCosNodeChunks(node, { signal });
+              yield encoder.encode(" ");
+            }
+          }
+          yield encoder.encode("]\n>>");
+        }
+        let length = 0;
+        for await (const bytes of chunks()) length += bytes.length;
+        await store.setSerializedValue({ objectNumber: ref.objectNumber, generationNumber: 0, body: { length, chunks: chunks() } });
+      }
+    }
+    async function* outlineUpdates() {
+      for await (const object of bookmarks.objects()) {
+        await checkpoint();
+        const value = object.value;
+        if (value.kind !== "array" || value.items[0]?.kind !== "string" || value.items[1]?.kind !== "number" || value.items[2]?.kind !== "number") throw new Error("Invalid bookmark record");
+        yield { title: decodePdfString(value.items[0]), level: value.items[1].value, pageNumber: value.items[2].value };
+      }
+    }
+    await setRetainedBookmarks(store, storage, rootRef, count, async (index2) => (await getPage(index2)).reference, outlineUpdates(), signal, maxDepth);
+    return { infoRef, idArray };
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([pages.close(), labels.close(), bookmarks.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
 // packages/pdf-ast/src/edit/retained-append-attachments.ts
 async function appendRetainedAttachments(document2, target, storage, attachments, options = {}) {
   const signal = options.signal ?? new AbortController().signal, appended = new PdfMutableObjectStore(storage, { signal });
@@ -62481,7 +62713,7 @@ async function appendRetainedAttachments(document2, target, storage, attachments
 }
 
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
-import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/form-appearance-chunks.ts
 function* serializeFormAppearanceChunks(text, options) {
@@ -62567,10 +62799,11 @@ function* operators(text, options) {
 }
 
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
-async function generateRetainedFormAppearances(document2, store, storage, signal) {
+async function generateRetainedFormAppearances(document2, store, storage, signal, update) {
   if (!document2.crossReference.rootRef) return;
-  const backing = new PagedStorage14({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable8(backing);
+  const backing = new PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable8(backing);
   let head = -1, failed = false, work = 0;
+  let matched = false;
   let defaultAppearance;
   async function checkpoint(depth = 0) {
     signal.throwIfAborted();
@@ -62672,14 +62905,30 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
     return "Yes";
   }
   try {
-    const form = await locate(formLocation);
+    let form = await locate(formLocation);
+    if (update && form?.value.kind !== "dict") {
+      const catalog = await locate(root);
+      if (catalog?.value.kind !== "dict") return;
+      dictSet(catalog.value, "AcroForm", await store.allocate(cosDict({ Fields: cosArray([]), NeedAppearances: cosBool(true) })));
+      await store.set(catalog.owner);
+      form = await locate(formLocation);
+    }
     if (form?.value.kind !== "dict") return;
+    if (update) {
+      dictSet(form.value, "NeedAppearances", cosBool(true));
+      await store.set(form.owner);
+      const fields3 = await locate(child(form.location, "Fields"));
+      if (fields3?.value.kind !== "array") {
+        dictSet(form.value, "Fields", cosArray([]));
+        await store.set(form.owner);
+      }
+    }
     defaultAppearance = dictGet(form.value, "DA");
     const need = await resolve2(dictGet(form.value, "NeedAppearances")), force = need?.kind === "boolean" && need.value;
     const fields2 = await locate(child(form.location, "Fields"));
     if (fields2?.value.kind === "array") for (let i = fields2.value.items.length - 1; i >= 0; i--) {
       await checkpoint();
-      await push({ location: itemLocation(fields2.location, i, fields2.value.items[i]), named: false, ft: "", ff: 0, q: 0, depth: 0 });
+      await push({ location: itemLocation(fields2.location, i, fields2.value.items[i]), named: "", ft: "", ff: 0, q: 0, depth: 0 });
     }
     while (head !== -1) {
       const record = await readStoredRecord(backing, head, signal);
@@ -62699,7 +62948,8 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         await push({ exit: id });
       }
       const name = await resolve2(dictGet(field2.value, "T")), ft = await resolve2(dictGet(field2.value, "FT"));
-      const named = frame.named || (name?.kind === "name" ? !!name.decoded : name?.kind === "string" ? !!decodePdfString(name) : false);
+      const partial = name?.kind === "name" ? name.decoded : name?.kind === "string" ? decodePdfString(name) : "";
+      const named = update ? frame.named && partial ? `${frame.named}.${partial}` : partial || frame.named : frame.named || partial ? "1" : "";
       const inherited = { ...frame, named, ft: ft?.kind === "name" ? ft.decoded : frame.ft, ff: await number(dictGet(field2.value, "Ff"), frame.ff), q: await number(dictGet(field2.value, "Q"), frame.q) };
       const maxLen = await resolve2(dictGet(field2.value, "MaxLen"));
       if (maxLen?.kind === "number") inherited.maxLen = maxLen.value;
@@ -62723,6 +62973,70 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         }
       }
       if (!named) continue;
+      if (update) {
+        if (named !== update.name) continue;
+        matched = true;
+        const value2 = update.value;
+        if (typeof value2 === "boolean" || inherited.ft === "Btn") {
+          const on = await onValue(field2.location);
+          const checked = typeof value2 === "boolean" ? value2 : value2 !== "Off" && value2 !== "false" && value2 !== "0" && value2 !== "";
+          const chosen = typeof value2 === "string" && value2 !== "true" && value2 !== "false" && value2 !== "Off" ? value2 : on;
+          const state = cosName(checked ? chosen : "Off");
+          dictSet(field2.value, "FT", cosName("Btn"));
+          dictSet(field2.value, "V", state);
+          dictSet(field2.value, "AS", state);
+          await store.set(field2.owner);
+          if (kids?.value.kind === "array") for (let i = 0; i < kids.value.items.length; i++) {
+            await checkpoint();
+            const kid = await locate(itemLocation(kids.location, i, kids.value.items[i]));
+            if (kid?.value.kind !== "dict") continue;
+            const normal = await locate(child(child(kid.location, "AP"), "N"));
+            const selected2 = normal?.value.kind === "dict" && normal.value.entries.length ? cosName(checked && dictGet(normal.value, chosen) !== void 0 ? chosen : "Off") : state;
+            dictSet(kid.value, "AS", selected2);
+            await store.set(kid.owner);
+          }
+          continue;
+        }
+        if (!inherited.ft) dictSet(field2.value, "FT", cosName("Tx"));
+        let text2 = String(value2);
+        const multi = inherited.ft === "Ch" && !!(inherited.ff & 1 << 21) && text2.includes(",");
+        const selected = multi ? text2.split(",").map((value3) => value3.trim()).filter(Boolean) : [text2];
+        dictSet(field2.value, "V", multi ? cosArray(selected.map((value3) => cosString(value3))) : cosString(text2));
+        if (inherited.ft === "Ch") {
+          const choices = await resolve2(dictGet(field2.value, "Opt")), indices = [];
+          if (choices?.kind === "array") for (let i = 0; i < choices.items.length; i++) {
+            await checkpoint();
+            const option = await resolve2(choices.items[i]);
+            let exported = "", label = "", valid = false;
+            if (option?.kind === "string") {
+              exported = decodePdfString(option);
+              label = exported;
+              valid = true;
+            } else if (option?.kind === "array" && option.items.length >= 2) {
+              const first = await resolve2(option.items[0]), second = await resolve2(option.items[1]);
+              exported = first?.kind === "string" ? decodePdfString(first) : "";
+              label = second?.kind === "string" ? decodePdfString(second) : "";
+              valid = true;
+            }
+            if (valid && (selected.includes(exported) || selected.includes(label))) {
+              indices.push(i);
+              if (!multi) {
+                if (label) text2 = label;
+                break;
+              }
+            }
+          }
+          if (indices.length) dictSet(field2.value, "I", cosArray(indices.map((value3) => cosNumber(value3))));
+        }
+        await store.set(field2.owner);
+        await synthesize(field2.location, text2, inherited);
+        if (kids?.value.kind === "array") for (let i = 0; i < kids.value.items.length; i++) {
+          await checkpoint();
+          const kid = await locate(itemLocation(kids.location, i, kids.value.items[i]));
+          if (kid?.value.kind === "dict" && !dictGet(kid.value, "T")) await synthesize(kid.location, text2, inherited);
+        }
+        continue;
+      }
       const value = await resolve2(dictGet(field2.value, "V"));
       if (!value) continue;
       const appearance = await resolve2(dictGet(field2.value, "AP")), hasNormal = appearance?.kind === "dict" && dictGet(appearance, "N") !== void 0;
@@ -62760,9 +63074,18 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
         if (kid?.value.kind === "dict" && !dictGet(kid.value, "T")) await synthesize(kid.location, text, inherited);
       }
     }
+    if (update && !matched) {
+      const fields3 = await locate(child(formLocation, "Fields"));
+      if (fields3?.value.kind === "array") {
+        const value = update.value;
+        const field2 = typeof value === "boolean" ? cosDict({ FT: cosName("Btn"), T: cosString(update.name), V: cosName(value ? "Yes" : "Off"), AS: cosName(value ? "Yes" : "Off") }) : cosDict({ FT: cosName("Tx"), T: cosString(update.name), V: cosString(value) });
+        fields3.value.items.push(await store.allocate(field2));
+        await store.set(fields3.owner);
+      }
+    }
     const latest = await locate(formLocation);
     if (latest?.value.kind === "dict") {
-      dictSet(latest.value, "NeedAppearances", cosBool(false));
+      dictSet(latest.value, "NeedAppearances", cosBool(!!update));
       await store.set(latest.owner);
     }
   } catch (error) {
@@ -62776,16 +63099,16 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
 }
 
 // packages/pdf-ast/src/edit/retained-flatten-annotations.ts
-import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage19 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/retained-content-edit.ts
-import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage16 } 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 PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+    this.backing = new PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
     this.counts = new IntegerTable9(this.backing);
     this.identities = new PdfNameIndex(storage, Infinity, signal);
   }
@@ -62857,14 +63180,14 @@ var RetainedContentEditor = class _RetainedContentEditor {
 };
 
 // packages/pdf-ast/src/edit/retained-name-replacement.ts
-import { PagedStorage as PagedStorage16 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
 async function* replaceRetainedPdfName(input, oldName, newName, storage, options = {}) {
   const chunkBytes = options.chunkBytes ?? 16384, maximum10 = options.maxOutputBytes ?? Infinity;
   if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid name replacement chunk size");
   if (maximum10 !== Infinity && (!Number.isSafeInteger(maximum10) || maximum10 < 0)) throw new RangeError("Invalid name replacement output limit");
   const signal = options.signal ?? new AbortController().signal;
   signal.throwIfAborted();
-  const table = new PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), length = oldName.length + 1;
+  const table = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), length = oldName.length + 1;
   const base = table.allocate(length * 8), record = new Uint8Array(8), view = new DataView(record.buffer);
   const pattern = (at) => at ? oldName.charCodeAt(at - 1) : 47;
   let buffer = new Uint8Array(chunkBytes), used = 0, total = 0, work = 0, failed = false;
@@ -62942,10 +63265,10 @@ async function* replaceRetainedPdfName(input, oldName, newName, storage, options
 }
 
 // packages/pdf-ast/src/edit/retained-draw-text.ts
-import { PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
 async function drawRetainedAnnotationText(page2, editor, storage, text, x, y, isolated, font, signal) {
   const source = await PdfFileSource.fromStream(storage.fs, storage.directory, page2.streamContents(), { signal });
-  const backing = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const backing = new PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   let failed = false;
   try {
     const name = await font(), position = backing.allocate(text.length);
@@ -63021,7 +63344,7 @@ async function flattenRetainedAnnotations(document2, store, storage, mode, signa
     for await (const page2 of document2.pages()) {
       const annotations = await array(dictGet(page2.dict, "Annots"));
       if (!annotations) continue;
-      const survivorStorage = new PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+      const survivorStorage = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
       const survivorBase = survivorStorage.allocate(0);
       let pageFailed = false;
       try {
@@ -63107,7 +63430,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 PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable10(backing), names = new PdfNameIndex(storage, Infinity, signal);
+            const backing = new PagedStorage19({ 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) {
@@ -63226,11 +63549,11 @@ q ${scaleX} 0 0 ${scaleY} ${tx} ${ty} cm${matSuffix}
 }
 
 // packages/pdf-ast/src/edit/retained-name-map.ts
-import { PagedStorage as PagedStorage19 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
 async function* replaceRetainedPdfNames(input, names, storage, options = {}) {
   const signal = options.signal ?? new AbortController().signal, size = options.chunkBytes ?? 16384;
   if (!Number.isSafeInteger(size) || size < 1) throw new RangeError("Invalid name replacement chunk size");
-  const trie = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pending = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const trie = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pending = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const root = trie.allocate(40), prefixBase = pending.allocate(0);
   let output = new Uint8Array(size), used = 0, failed = false, work = 0;
   const body = (byte3) => byte3 >= 48 && byte3 <= 57 || byte3 >= 65 && byte3 <= 90 || byte3 >= 97 && byte3 <= 122 || [95, 46, 43, 45].includes(byte3);
@@ -63512,7 +63835,7 @@ async function preserveRetainedStamp(document2, source, page2, other, store, edi
 }
 
 // packages/pdf-ast/src/edit/retained-stamps.ts
-import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage21 } 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;
@@ -63523,7 +63846,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 PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable11(backing);
+      const backing = new PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable11(backing);
       let stampFailed = false;
       async function clone(node, depth = 0) {
         await checkpoint();
@@ -63709,12 +64032,12 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
 }
 
 // packages/pdf-ast/src/edit/retained-inline-images.ts
-import { PagedStorage as PagedStorage21 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage22 } from "@poe-platform/safe-fs/storage";
 async function externalizeRetainedInlineImages(document2, store, storage, options, signal) {
   const minimum = options.minBytes ?? 1024;
   if (!Number.isSafeInteger(minimum) || minimum < 0) throw new RangeError("Invalid inline-image minimum size");
   const editor = await RetainedContentEditor.open(store, storage, signal);
-  const paths = new PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const paths = new PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const keys = { BPC: "BitsPerComponent", CS: "ColorSpace", D: "Decode", DP: "DecodeParms", F: "Filter", H: "Height", IM: "ImageMask", I: "Interpolate", W: "Width" };
   const colors = { G: "DeviceGray", RGB: "DeviceRGB", CMYK: "DeviceCMYK", I: "Indexed" };
   const filters = { AHx: "ASCIIHexDecode", A85: "ASCII85Decode", LZW: "LZWDecode", Fl: "FlateDecode", RL: "RunLengthDecode", CCF: "CCITTFaxDecode", DCT: "DCTDecode" };
@@ -63806,7 +64129,7 @@ async function externalizeRetainedInlineImages(document2, store, storage, option
 }
 
 // packages/pdf-ast/src/edit/retained-resource-pruning.ts
-import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage22 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage23 } 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;
@@ -63888,7 +64211,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 PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable12(backing);
+    const backing = new PagedStorage23({ 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;
@@ -64018,7 +64341,7 @@ async function flattenRetainedRotations(document2, store, storage, signal) {
 }
 
 // packages/pdf-ast/src/edit/retained-attachment-edits.ts
-import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
 var PdfDuplicateAttachment = class extends PdfError {
   constructor(key) {
     super("E_CAPABILITY", `Duplicate attachment key: ${key}`);
@@ -64029,7 +64352,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 PagedStorage23({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable13(backing), removals = new IntegerTable13(backing);
+  const backing = new PagedStorage24({ 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();
@@ -64231,13 +64554,13 @@ async function* retainedAttachmentNameTokens(document2, storage, root, signal, r
 }
 
 // packages/pdf-ast/src/edit/retained-graph.ts
-import { PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
 async function editRetainedDocument(source, storage, options = {}) {
   if (options.maxPages !== void 0 && options.maxPages !== Infinity && (!Number.isSafeInteger(options.maxPages) || options.maxPages < 0)) throw new RangeError("Invalid page limit");
   if (options.maxRecursionDepth !== void 0 && options.maxRecursionDepth !== Infinity && (!Number.isSafeInteger(options.maxRecursionDepth) || options.maxRecursionDepth < 1)) throw new RangeError("Invalid edit depth");
   const signal = options.signal ?? new AbortController().signal;
   const store = new PdfMutableObjectStore(storage, { ...options, signal });
-  const pages = new PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const pages = new PagedStorage25({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const base = pages.allocate(0);
   let count = 0, document2;
   let closing;
@@ -64286,6 +64609,14 @@ async function editRetainedDocument(source, storage, options = {}) {
       ...options.maxRecursionDepth === void 0 ? {} : { maxRecursionDepth: options.maxRecursionDepth }
     };
     document2 = await PdfRetainedDocument.openStore(store, storage, { ...configured, ...infoRef ? { infoRef } : {} });
+    if (options.infoUpdates) {
+      const updated = await applyRetainedInfoUpdates(document2, store, storage, count, getPage, options.infoUpdates, signal, options.maxRecursionDepth);
+      infoRef = updated.infoRef;
+      if (updated.idArray) configured.idArray = updated.idArray;
+      await document2.close();
+      document2 = await PdfRetainedDocument.openStore(store, storage, { ...configured, ...infoRef ? { infoRef } : {} });
+      addedObjects = true;
+    }
     for await (const edit of options.rotations ?? []) {
       signal.throwIfAborted();
       if (!Number.isSafeInteger(edit.pageIndex) || edit.pageIndex < 0 || edit.pageIndex >= count) throw new RangeError("Page index out of bounds");
@@ -64348,13 +64679,17 @@ async function editRetainedDocument(source, storage, options = {}) {
       await setRetainedBookmarks(store, storage, source.crossReference.rootRef, count, reference, options.bookmarks, signal, options.maxRecursionDepth);
       addedObjects = true;
     }
+    for await (const update of options.formUpdates ?? []) {
+      await generateRetainedFormAppearances(document2, store, storage, signal, update);
+      addedObjects = true;
+    }
     if (options.generateAppearances && !options.removeAcroform) {
       await generateRetainedFormAppearances(document2, store, storage, signal);
       addedObjects = true;
     }
     if (options.removeInfo) {
       await removeRoot(["Metadata"]);
-      const found = await document2.lookup(source.crossReference.infoRef);
+      const found = await document2.lookup(infoRef);
       if (found?.value.kind === "dict" && !found.stream && found.reference) {
         const date = dictGet(found.value, "ModDate");
         found.value.entries.length = 0;
@@ -64459,9 +64794,9 @@ async function* copyRetainedAttachments(document2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/retained-object-order.ts
-import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage26 } from "@poe-platform/safe-fs/storage";
 async function* retainedObjectOrder(document2, source, storage, signal) {
-  const backing = new PagedStorage25({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const backing = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const seen = new IntegerTable14(backing), streams = new IntegerTable14(backing);
   let failed = false, work = 0;
   async function candidate(number) {
@@ -64598,12 +64933,12 @@ async function* encryptRetainedPdfChunks(source, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/qpdf-json-values.ts
-import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage26 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
 var QpdfJsonValues = class _QpdfJsonValues {
   constructor(tree, storage, signal) {
     this.tree = tree;
     this.signal = signal;
-    this.scratch = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+    this.scratch = new PagedStorage27({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
     this.first = new IntegerTable15(this.scratch, 64);
     this.next = new IntegerTable15(this.scratch, 64);
   }
@@ -64996,13 +65331,13 @@ var QpdfJsonValues = class _QpdfJsonValues {
 };
 
 // packages/pdf-ast/src/cos/qpdf-json-document.ts
-import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage28 } 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 PagedStorage27(
+    this.backing = new PagedStorage28(
       { fs: storage.fs, cwd: storage.directory, env: {}, signal: this.signal },
       4
     );
@@ -65071,7 +65406,7 @@ var QpdfJsonDocument = class _QpdfJsonDocument {
       env: {},
       signal: this.signal
     };
-    const tape = new PagedStorage27(context, 4), scratch = new PagedStorage27(context, 4);
+    const tape = new PagedStorage28(context, 4), scratch = new PagedStorage28(context, 4);
     let values, failed = false, work = 0;
     const cooperate = async (units = 1) => {
       this.signal.throwIfAborted();