@poe-platform/safe-bash 0.1.812 → 0.1.813

package/dist/pdf-ast/index.js

@@ -26870,6 +26870,7 @@ function cosStream(dataOrDict, optionsOrData = {}, span) {
   };
 }
 function dictGet(dict, key) {
+  if (dict.storedEntries) throw new TypeError("Stored dictionary requires asynchronous access");
   for (let i = dict.entries.length - 1; i >= 0; i--) {
     if (dict.entries[i].key.decoded === key) {
       return dict.entries[i].value;
@@ -26878,6 +26879,7 @@ function dictGet(dict, key) {
   return void 0;
 }
 function dictSet(dict, key, value) {
+  if (dict.storedEntries) throw new TypeError("Stored dictionary requires asynchronous access");
   for (let i = dict.entries.length - 1; i >= 0; i--) {
     if (dict.entries[i].key.decoded === key) {
       dict.entries[i] = { key: cosName(key), value };
@@ -26887,6 +26889,7 @@ function dictSet(dict, key, value) {
   dict.entries.push({ key: cosName(key), value });
 }
 function dictDelete(dict, key) {
+  if (dict.storedEntries) throw new TypeError("Stored dictionary requires asynchronous access");
   for (let i = dict.entries.length - 1; i >= 0; i--) {
     if (dict.entries[i].key.decoded === key) {
       dict.entries.splice(i, 1);
@@ -27536,6 +27539,60 @@ function getStandardFontOutlines(name, options = {}) {
   return font;
 }
 
+// packages/pdf-ast/src/cos/compact-number.ts
+var CompactPdfNumber = class {
+  original = "";
+  sign = "";
+  digits = "";
+  significant = 0;
+  fractional = 0;
+  decimal = false;
+  exponent = false;
+  exponentNegative = false;
+  power = 0n;
+  sticky = false;
+  append(character) {
+    const text = String.fromCharCode(character);
+    if (this.original !== void 0) this.original = this.original.length < 2048 ? this.original + text : void 0;
+    if (character === 69 || character === 101) {
+      this.exponent = true;
+      return;
+    }
+    if (character === 43 || character === 45) {
+      if (this.exponent) this.exponentNegative = character === 45;
+      else this.sign = text;
+      return;
+    }
+    if (character === 46) {
+      this.decimal = true;
+      return;
+    }
+    const digit2 = character - 48;
+    if (this.exponent) {
+      const maximum10 = 2n * BigInt(Number.MAX_SAFE_INTEGER);
+      if (this.power < maximum10) {
+        this.power = this.power * 10n + BigInt(digit2);
+        if (this.power > maximum10) this.power = maximum10;
+      }
+      return;
+    }
+    if (this.decimal) this.fractional++;
+    if (!this.significant && digit2 === 0) return;
+    this.significant++;
+    if (this.digits.length < 2048) this.digits += text;
+    else if (digit2 !== 0) this.sticky = true;
+  }
+  get spelling() {
+    if (this.original !== void 0) return this.original;
+    const digits = (this.digits || "0") + (this.sticky ? "1" : "");
+    const power = (this.exponentNegative ? -this.power : this.power) + BigInt(this.significant - this.digits.length - this.fractional) - (this.sticky ? 1n : 0n);
+    return `${this.sign}${digits}e${power}`;
+  }
+  get shortened() {
+    return this.original === void 0;
+  }
+};
+
 // packages/pdf-ast/src/cos/lexer.ts
 function isPdfWhitespace(byte3) {
   return byte3 === 0 || byte3 === 9 || byte3 === 10 || byte3 === 12 || byte3 === 13 || byte3 === 32;
@@ -27594,23 +27651,29 @@ var StringOutput = class {
   }
 };
 var CosLexerState = class {
-  constructor(bytes, start = 0, end = bytes.length, maxTokenBytes = Infinity, knownCommands, onTokenAllocation, stringMode = "buffer") {
+  constructor(bytes, start = 0, end = bytes.length, maxTokenBytes = Infinity, knownCommands, onTokenAllocation, stringMode = "buffer", compactNumbers = false, compactKeywords = false) {
     this.knownCommands = knownCommands;
     this.onTokenAllocation = onTokenAllocation;
     this.stringMode = stringMode;
+    this.compactNumbers = compactNumbers;
     this.window = bytes;
     this.pos = start;
     this.end = end;
     this.maxTokenBytes = maxTokenBytes;
+    let keywordLimit = compactKeywords ? 64 : Infinity;
+    if (compactKeywords) for (const command of knownCommands ?? []) keywordLimit = Math.max(keywordLimit, command.length);
+    this.keywordLimit = keywordLimit;
   }
   knownCommands;
   onTokenAllocation;
   stringMode;
+  compactNumbers;
   window;
   windowStart = 0;
   pos;
   end;
   maxTokenBytes;
+  keywordLimit;
   *byte(position) {
     if (position < 0 || position >= this.end) return void 0;
     if (position < this.windowStart || position >= this.windowStart + this.window.length) {
@@ -27694,14 +27757,17 @@ var CosLexerState = class {
       this.pos++;
       return { kind: "keyword", value: String.fromCharCode(b), span: { start, end: this.pos } };
     }
-    let raw = "";
+    let raw = "", truncated = false;
     while (this.pos < this.end) {
-      const cur = yield* this.byte(this.pos);
+      const cur = this.window[this.pos - this.windowStart] ?? (yield* this.byte(this.pos));
       if (isPdfWhitespace(cur) || isPdfDelimiter(cur)) break;
-      this.onTokenAllocation?.(32);
-      const next = raw + String.fromCharCode(cur);
-      if (this.knownCommands?.has(raw) && !this.knownCommands.has(next)) break;
-      raw = next;
+      if (!truncated) {
+        this.onTokenAllocation?.(32);
+        const next = raw + String.fromCharCode(cur);
+        if (this.knownCommands?.has(raw) && !this.knownCommands.has(next)) break;
+        if (next.length > this.keywordLimit) truncated = true;
+        else raw = next;
+      }
       this.pos++;
       if (this.pos - start > this.maxTokenBytes) {
         throw new PdfError("E_LIMIT", "PDF token exceeds maximum byte length");
@@ -27711,13 +27777,18 @@ var CosLexerState = class {
     if (raw === "true") return { kind: "boolean", value: true, span };
     if (raw === "false") return { kind: "boolean", value: false, span };
     if (raw === "null") return { kind: "null", span };
-    return { kind: "keyword", value: raw, span };
+    return { kind: "keyword", value: truncated ? raw + "\u2026" : raw, ...truncated ? { truncated: true } : {}, span };
   }
   *readNumber() {
     const start = this.pos;
+    const compact = this.compactNumbers ? new CompactPdfNumber() : void 0;
+    if (compact) this.onTokenAllocation?.(16384);
     const advance = (character) => {
-      this.onTokenAllocation?.(32);
-      if (character !== void 0) normalized += String.fromCharCode(character);
+      if (!compact) this.onTokenAllocation?.(32);
+      if (character !== void 0) {
+        if (compact) compact.append(character);
+        else normalized += String.fromCharCode(character);
+      }
       this.pos++;
       if (this.pos - start > this.maxTokenBytes) {
         throw new PdfError("E_LIMIT", "PDF token exceeds maximum byte length");
@@ -27751,7 +27822,7 @@ var CosLexerState = class {
       throw new PdfError("E_PARSE", "Invalid PDF number prefix");
     }
     while (this.pos < this.end) {
-      const b = yield* this.byte(this.pos);
+      const b = this.window[this.pos - this.windowStart] ?? (yield* this.byte(this.pos));
       if (b >= 48 && b <= 57) {
         advance(b);
       } else if (b === 46 && !decimal) {
@@ -27776,6 +27847,7 @@ var CosLexerState = class {
         }
       }
     }
+    if (compact) normalized = compact.spelling;
     const value = Number(normalized);
     if (!Number.isFinite(value)) {
       throw new PdfError("E_CAPABILITY", `Non-finite PDF number: ${normalized}`);
@@ -27783,7 +27855,7 @@ var CosLexerState = class {
     return {
       kind: "number",
       value,
-      raw: exponent ? formatPdfNumber(value) : normalized,
+      raw: exponent ? formatPdfNumber(value) : compact?.shortened ? `${Object.is(value, -0) ? "-0" : formatPdfNumber(value)}${decimal && Number.isInteger(value) ? ".0" : ""}` : normalized,
       isInteger: Number.isInteger(value) && !decimal && !exponent,
       span: { start, end: this.pos }
     };
@@ -27962,7 +28034,9 @@ var CosRangeLexer = class {
       maximum10,
       options.knownCommands,
       options.onTokenAllocation,
-      options.stringStorage ? "count" : "buffer"
+      options.stringStorage ? "count" : "buffer",
+      options.compactNumbers,
+      options.compactKeywords
     );
     this.onBackingError = options.onBackingError;
     this.onTokenAllocation = options.onTokenAllocation;
@@ -28208,7 +28282,7 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
     } else if (parent?.kind === "dict" && !parent.key) {
       if (tok.kind === "dict-end") {
         yield* pop();
-        node = yield { kind: "dict", entries: parent.entries, span: { start: parent.start, end: tok.span.end } };
+        node = yield { kind: "dict", entries: parent.entries, ...parent.storedEntries ? { storedEntries: parent.storedEntries } : {}, span: { start: parent.start, end: tok.span.end } };
       } else if (tok.kind === "name") {
         charge();
         parent.key = { kind: "name", rawBytes: tok.rawBytes, decoded: tok.decoded, span: tok.span };
@@ -28236,7 +28310,15 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
         continue;
       }
       if (tok.kind === "dict-start") {
-        yield* push({ kind: "dict", path: ancestorPath(parent), start: tok.span.start, entries: [] });
+        const backed = options.dictionaryStorage && (parent?.kind === "dict" && options.storedDictionaryKeys?.includes(parent.key.decoded) || !parent && options.storeRootDictionary);
+        yield* push({
+          kind: "dict",
+          path: ancestorPath(parent),
+          start: tok.span.start,
+          entries: [],
+          tail: -1,
+          ...backed ? { storedEntries: { storage: options.dictionaryStorage, position: -1, length: 0 } } : {}
+        });
         continue;
       }
       node = yield* parseLeafFromToken(tok, lexer);
@@ -28250,7 +28332,12 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
         container.tail = position;
       } else container.items.push(node);
     } else {
-      container.entries.push({ key: container.key, value: node });
+      const entry = { key: container.key, value: node };
+      if (container.storedEntries) {
+        const position = yield { kind: "dictionary-append", entry, previous: container.tail };
+        container.storedEntries = { ...container.storedEntries, position: container.tail === -1 ? position : container.storedEntries.position, length: container.storedEntries.length + 1 };
+        container.tail = position;
+      } else container.entries.push(entry);
       delete container.key;
     }
   }
@@ -28322,6 +28409,442 @@ function assertDecodedByteBudget(byteLength, maxBytes = Infinity) {
   }
 }
 
+// packages/pdf-ast/src/cos/object-index.ts
+import { listenForAbort } from "@poe-platform/safe-fs/contracts";
+var recordBytes = 32;
+function integer(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
+  return value;
+}
+function budget(value, name) {
+  return value === void 0 || value === Infinity ? Infinity : integer(value, name);
+}
+function fields(entry) {
+  const key = integer(entry.objectNumber, "PDF object number");
+  if (entry.type === "free") return [key, integer(entry.nextFreeObjectNumber ?? 0, "free object number"), integer(entry.generationNumber ?? 0, "generation number"), 0];
+  if (entry.type === "uncompressed") return [key, integer(entry.offset, "object offset"), integer(entry.generationNumber ?? 0, "generation number"), 1];
+  if (entry.type === "compressed") return [key, integer(entry.objectStreamNumber, "object stream number"), integer(entry.indexInStream ?? entry.indexInObjectStream, "object stream index"), 2];
+  throw new PdfError("E_PARSE", "Invalid PDF cross-reference entry type");
+}
+function decode(bytes, offset = 0) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset + offset, recordBytes);
+  const objectNumber = view.getFloat64(0);
+  const first = view.getFloat64(8);
+  const second = view.getFloat64(16);
+  const type = view.getFloat64(24);
+  if (type === 0) return { objectNumber, type: "free", nextFreeObjectNumber: first, generationNumber: second };
+  if (type === 1) return { objectNumber, type: "uncompressed", offset: first, generationNumber: second };
+  if (type === 2) return { objectNumber, type: "compressed", objectStreamNumber: first, indexInStream: second };
+  throw new PdfError("E_PARSE", "Invalid staged PDF index record");
+}
+async function* encode2(entries, chunkBytes) {
+  let bytes = new Uint8Array(chunkBytes);
+  let offset = 0;
+  for await (const entry of entries) {
+    const view = new DataView(bytes.buffer, offset, recordBytes);
+    const values = fields(entry);
+    for (let i = 0; i < values.length; i++) view.setFloat64(i * 8, values[i]);
+    offset += recordBytes;
+    if (offset === bytes.length) {
+      yield bytes;
+      bytes = new Uint8Array(chunkBytes);
+      offset = 0;
+    }
+  }
+  if (offset) yield bytes.subarray(0, offset);
+}
+async function* records(source, signal) {
+  for await (const bytes of source.stream(0, source.size, signal)) {
+    if (bytes.length % recordBytes !== 0) throw new PdfError("E_PARSE", "Truncated staged PDF index");
+    for (let offset = 0; offset < bytes.length; offset += recordBytes) {
+      signal?.throwIfAborted();
+      yield decode(bytes, offset);
+    }
+  }
+}
+async function* merge(first, second, duplicate, signal) {
+  const left = records(first, signal);
+  const right = records(second, signal);
+  try {
+    let a = await left.next();
+    let b = await right.next();
+    let turns = 0;
+    while (!a.done || !b.done) {
+      signal?.throwIfAborted();
+      if (!a.done && (b.done || a.value.objectNumber <= b.value.objectNumber)) {
+        const equal2 = !b.done && a.value.objectNumber === b.value.objectNumber;
+        yield equal2 && duplicate === "last" && !b.done ? b.value : a.value;
+        if (equal2) b = await right.next();
+        a = await left.next();
+      } else if (!b.done) {
+        yield b.value;
+        b = await right.next();
+      }
+      if (++turns % 1024 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+    }
+  } finally {
+    await left.return(void 0);
+    await right.return(void 0);
+  }
+}
+var PdfObjectIndex = class _PdfObjectIndex {
+  constructor(source, signal) {
+    this.source = source;
+    this.signal = signal;
+  }
+  source;
+  signal;
+  closing;
+  get size() {
+    return this.source.size / recordBytes;
+  }
+  static async build(input, storage, options = {}) {
+    const duplicate = options.duplicate ?? "first";
+    if (duplicate !== "first" && duplicate !== "last") throw new RangeError("Invalid PDF index duplicate policy");
+    const runEntries = integer(options.runEntries ?? 2048, "runEntries");
+    const chunkBytes = integer(options.chunkBytes ?? 64 * 1024, "chunkBytes");
+    const cacheBytes = integer(options.cacheBytes ?? 256 * 1024, "cacheBytes");
+    if (!runEntries || chunkBytes < recordBytes || chunkBytes % recordBytes !== 0 || cacheBytes < chunkBytes) throw new RangeError("Invalid PDF index batch/cache sizes");
+    const maxEntries = budget(options.maxEntries, "maxEntries");
+    const maxStagingBytes = budget(options.maxStagingBytes, "maxStagingBytes");
+    const { signal } = options;
+    signal?.throwIfAborted();
+    const owned = /* @__PURE__ */ new Set();
+    const levels = [];
+    let stagedBytes = 0;
+    let admitted = 0;
+    let batch = [];
+    const dispose = async (source) => {
+      try {
+        await source.close();
+      } finally {
+        owned.delete(source);
+        stagedBytes -= source.size;
+      }
+    };
+    const stage = async (entries) => {
+      let reserved = 0;
+      async function* chunks() {
+        for await (const bytes of encode2(entries, chunkBytes)) {
+          signal?.throwIfAborted();
+          if (bytes.length > Math.min(maxStagingBytes, Number.MAX_SAFE_INTEGER) - stagedBytes) throw new PdfError("E_LIMIT", "PDF index staging byte limit exceeded");
+          stagedBytes += bytes.length;
+          reserved += bytes.length;
+          yield bytes;
+        }
+      }
+      try {
+        const source = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks(), { chunkBytes, cacheBytes, ...signal ? { signal } : {} });
+        owned.add(source);
+        return source;
+      } catch (error) {
+        stagedBytes -= reserved;
+        throw error;
+      }
+    };
+    const flush = async () => {
+      if (duplicate === "last") batch.reverse();
+      batch.sort((a, b) => a.objectNumber - b.objectNumber);
+      const sorted = batch;
+      batch = [];
+      function* unique() {
+        let previous = -1;
+        for (const entry of sorted) if (entry.objectNumber !== previous) {
+          previous = entry.objectNumber;
+          yield entry;
+        }
+      }
+      let run = await stage(unique());
+      let level = 0;
+      while (levels[level]) {
+        const earlier = levels[level];
+        const combined = await stage(merge(earlier, run, duplicate, signal));
+        await dispose(earlier);
+        await dispose(run);
+        levels[level++] = void 0;
+        run = combined;
+      }
+      levels[level] = run;
+    };
+    const iterator = Symbol.asyncIterator in input ? input[Symbol.asyncIterator]() : input[Symbol.iterator]();
+    let ended = false;
+    const next = async () => {
+      signal?.throwIfAborted();
+      if (!signal) return iterator.next();
+      let dispose2 = () => {
+      };
+      const cancelled = new Promise((ignored, reject) => {
+        dispose2 = listenForAbort(signal, () => reject(signal.reason));
+      });
+      const pending = Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return iterator.next();
+      });
+      try {
+        return await Promise.race([pending, cancelled]);
+      } finally {
+        dispose2();
+      }
+    };
+    try {
+      while (true) {
+        const step = await next();
+        signal?.throwIfAborted();
+        if (step.done) {
+          ended = true;
+          break;
+        }
+        if (admitted >= Math.min(maxEntries, Number.MAX_SAFE_INTEGER)) throw new PdfError("E_LIMIT", "PDF index entry limit exceeded");
+        admitted++;
+        const values = fields(step.value);
+        const entry = step.value.type === "compressed" ? { objectNumber: values[0], type: "compressed", objectStreamNumber: values[1], indexInStream: values[2] } : step.value.type === "free" ? { objectNumber: values[0], type: "free", nextFreeObjectNumber: values[1], generationNumber: values[2] } : { objectNumber: values[0], type: "uncompressed", offset: values[1], generationNumber: values[2] };
+        batch.push(entry);
+        if (batch.length === runEntries) await flush();
+        if (admitted % 1024 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+      }
+      if (batch.length) await flush();
+      let result;
+      for (let level = levels.length - 1; level >= 0; level--) {
+        const run = levels[level];
+        if (!run) continue;
+        if (!result) result = run;
+        else {
+          const combined = await stage(merge(result, run, duplicate, signal));
+          await dispose(result);
+          await dispose(run);
+          result = combined;
+        }
+      }
+      result ??= await stage([]);
+      signal?.throwIfAborted();
+      owned.delete(result);
+      return new _PdfObjectIndex(result, signal);
+    } catch (error) {
+      for (const source of owned) {
+        try {
+          await source.close();
+        } catch {
+        }
+      }
+      throw error;
+    } finally {
+      if (!ended) {
+        try {
+          const returning = iterator.return?.();
+          if (returning) {
+            if (signal?.aborted) void Promise.resolve(returning).catch(() => {
+            });
+            else await returning;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  async get(objectNumber, signal) {
+    integer(objectNumber, "PDF object number");
+    this.assertOpen(signal);
+    let low = 0;
+    let high = this.size;
+    while (low < high) {
+      const middle = low + Math.floor((high - low) / 2);
+      const entry = decode(await this.source.read(middle * recordBytes, recordBytes, signal));
+      this.assertOpen(signal);
+      if (entry.objectNumber === objectNumber) return entry;
+      if (entry.objectNumber < objectNumber) low = middle + 1;
+      else high = middle;
+    }
+    return void 0;
+  }
+  assertOpen(signal) {
+    this.signal?.throwIfAborted();
+    signal?.throwIfAborted();
+    if (this.closing) throw new PdfError("E_CAPABILITY", "PDF object index is closed");
+  }
+  async *entries(signal) {
+    this.assertOpen(signal);
+    for await (const entry of records(this.source, signal)) {
+      this.assertOpen(signal);
+      yield entry;
+    }
+  }
+  close() {
+    this.closing ??= this.source.close();
+    return this.closing;
+  }
+};
+
+// 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/content/stored-dictionary.ts
+async function* readPdfDictionaryEntries(dict, signal) {
+  signal?.throwIfAborted();
+  if (dict.storedEntries) yield* readStoredItems(dict.storedEntries, signal);
+  else for (const entry of dict.entries) {
+    signal?.throwIfAborted();
+    yield entry;
+  }
+}
+async function readPdfDictionaryValue(dict, key, signal) {
+  let value;
+  for await (const entry of readPdfDictionaryEntries(dict, signal)) if (entry.key.decoded === key) value = entry.value;
+  return value;
+}
+async function mergePdfResourceDictionaries(destination, source, indexStorage, signal) {
+  const storage = destination.storedEntries?.storage ?? source?.storedEntries?.storage;
+  if (!storage) throw new TypeError("Resource merge requires caller-backed entries");
+  const names = new PdfNameIndex(indexStorage, Infinity, signal);
+  let index2, failed = false;
+  async function* rows() {
+    for (const [dict, replace] of [[destination, true], [source, false]]) {
+      if (!dict) continue;
+      for await (const entry of readPdfDictionaryEntries(dict, signal)) {
+        const name = await names.intern(entry.key.decoded);
+        if (!replace && !name.added) continue;
+        const position = await writeStoredRecord(storage, entry, -1, signal);
+        yield { objectNumber: name.index, type: "uncompressed", offset: position };
+      }
+    }
+  }
+  try {
+    index2 = await PdfObjectIndex.build(rows(), indexStorage, { duplicate: "last", runEntries: 64, chunkBytes: 2048, cacheBytes: 2048, ...signal ? { signal } : {} });
+    let position = -1, previous = -1, length = 0;
+    const link2 = new Uint8Array(8), view = new DataView(link2.buffer);
+    for await (const row of index2.entries(signal)) {
+      if (previous !== -1) {
+        view.setFloat64(0, row.offset, true);
+        await storage.write(previous, link2, signal ? { signal } : void 0);
+        signal?.throwIfAborted();
+      } else position = row.offset;
+      previous = row.offset;
+      length++;
+    }
+    return { kind: "dict", entries: [], storedEntries: { storage, position, length } };
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([index2?.close(), names.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
 // packages/pdf-ast/src/cos/security.ts
 import { readBytes as readBytes11 } from "@poe-platform/safe-fs/contracts";
 
@@ -30375,9 +30898,23 @@ async function decryptPdfObjectStrings(state, objectNumber, generationNumber, va
     }
     if (node.kind === "dict") {
       const entries = [];
-      const signature = isSignatureDictionary(node);
-      for (const entry of node.entries) entries.push({ key: entry.key, value: signature && entry.key.decoded === "Contents" ? entry.value : await transform(entry.value) });
-      return { ...node, entries };
+      let signatureDict = node;
+      if (node.storedEntries) {
+        signatureDict = { kind: "dict", entries: [] };
+        for await (const entry of readPdfDictionaryEntries(node, options.signal)) {
+          if (["Type", "FT", "ByteRange", "Filter"].includes(entry.key.decoded)) dictSet(signatureDict, entry.key.decoded, entry.value);
+        }
+      }
+      const signature = isSignatureDictionary(signatureDict);
+      let position = -1, tail = -1;
+      for await (const entry of readPdfDictionaryEntries(node, options.signal)) {
+        const transformed = { key: entry.key, value: signature && entry.key.decoded === "Contents" ? entry.value : await transform(entry.value) };
+        if (node.storedEntries) {
+          tail = await appendStoredRecord(node.storedEntries.storage, transformed, tail, options.signal);
+          if (position === -1) position = tail;
+        } else entries.push(transformed);
+      }
+      return { ...node, entries, ...node.storedEntries ? { storedEntries: { ...node.storedEntries, position } } : {} };
     }
     return drainWorkAsync(transformNodeStringsAndStreamsSteps(node, (bytes) => decryptPdfBuffer(state, objectNumber, generationNumber, bytes)), options.signal);
   }
@@ -31707,6 +32244,35 @@ function* annotationNameDestinationSteps(first, name, maxDepth = Infinity) {
   }
 }
 
+// packages/pdf-ast/src/content/dictionary-cursor.ts
+var PdfDictionaryCursor = class {
+  constructor(dict) {
+    this.dict = dict;
+    this.length = dict.storedEntries?.length ?? dict.entries.length;
+    if (!Number.isSafeInteger(this.length) || this.length < 0) throw new RangeError("Invalid stored dictionary length");
+    this.position = dict.storedEntries?.position ?? -1;
+  }
+  dict;
+  index = 0;
+  position;
+  length;
+  *next() {
+    if (this.index === this.length) {
+      if (this.dict.storedEntries && this.position !== -1) throw new Error("Invalid stored dictionary terminator");
+      return { done: true, value: void 0 };
+    }
+    let entry = this.dict.entries[this.index];
+    if (this.dict.storedEntries) {
+      const reply = yield { kind: "dictionary-entry", entries: this.dict.storedEntries, position: this.position };
+      if (reply?.kind !== "array" || reply.items[0]?.kind !== "name" || !reply.items[1] || reply.items[2]?.kind !== "number") throw new TypeError("Expected a PDF dictionary record");
+      entry = { key: reply.items[0], value: reply.items[1] };
+      this.position = reply.items[2].value;
+    }
+    this.index++;
+    return { done: false, value: entry };
+  }
+};
+
 // packages/pdf-ast/src/fonts/stored-widths.ts
 import { IntegerTable } from "@poe-platform/safe-fs/storage";
 var StoredFontWidths = class {
@@ -32693,13 +33259,13 @@ function embedTrueTypeFontInCos(doc, font, usedGlyphs) {
 }
 
 // packages/pdf-ast/src/fonts/resolve.ts
-function* resolve(node, storeRootArray = false) {
-  const value = yield { kind: "resolve", node, storeRootArray };
+function* resolve(node, storeRootArray = false, storeRootDictionary = false) {
+  const value = yield { kind: "resolve", node, storeRootArray, storeRootDictionary };
   if (value && !("kind" in value)) throw new TypeError("Font lookup returned stream bytes instead of a COS value");
   return value;
 }
-function* resolveDict2(node) {
-  const value = yield* resolve(node);
+function* resolveDict2(node, backed = false) {
+  const value = yield* resolve(node, false, backed);
   return value?.kind === "dict" ? value : value?.kind === "stream" ? value.dict : void 0;
 }
 function* resolveArray2(node, backed = false) {
@@ -32732,287 +33298,288 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
   const catalog = yield* resolveDict2(rootRef);
   const acroForm = catalog ? yield* resolveDict2(dictGet(catalog, "AcroForm")) : void 0;
   const drDict = acroForm ? yield* resolveDict2(dictGet(acroForm, "DR")) : void 0;
-  const drFontDict = drDict ? yield* resolveDict2(dictGet(drDict, "Font")) : void 0;
-  const pageFontDict = resourcesDict ? yield* resolveDict2(dictGet(resourcesDict, "Font")) : void 0;
-  function* entries() {
-    if (drFontDict)
-      yield* drFontDict.entries;
-    if (pageFontDict)
-      yield* pageFontDict.entries;
-  }
-  for (const entry of entries()) {
-    const fName = entry.key.decoded;
-    if (selectedName !== void 0 && fName !== selectedName)
-      continue;
-    const fObj = yield* resolveDict2(entry.value);
-    if (!fObj)
-      continue;
-    allocation.admit(1024);
-    const subtypeNode = yield* resolve(dictGet(fObj, "Subtype"));
-    const subtype = subtypeNode?.kind === "name" ? subtypeNode.decoded : "Type1";
-    const baseFontNode = yield* resolve(dictGet(fObj, "BaseFont"));
-    const baseFont = baseFontNode?.kind === "name" ? baseFontNode.decoded : "Helvetica";
-    let cmap;
-    let storedCMap;
-    const toUniNode = yield* resolve(dictGet(fObj, "ToUnicode"));
-    if (toUniNode?.kind === "stream") {
-      try {
-        const value = yield { kind: "decode", stream: toUniNode, purpose: "unicode-cmap" };
-        if (value instanceof Uint8Array) cmap = parseToUnicodeCMap(value, allocationOptions);
-        else if (value && "storedCMap" in value) storedCMap = value;
-        else if (value && "iterateBytes" in value) cmap = value;
-        else throw new TypeError("Font decoder did not return a Unicode CMap");
-      } catch (error) {
-        allocation.rethrowAllocationFailure(error);
-        if (error instanceof PdfError && error.code === "E_LIMIT")
-          throw error;
+  const drFontDict = drDict ? yield* resolveDict2(dictGet(drDict, "Font"), true) : void 0;
+  const pageFontDict = resourcesDict ? yield* resolveDict2(dictGet(resourcesDict, "Font"), true) : void 0;
+  for (const dictionary of [drFontDict, pageFontDict]) {
+    if (!dictionary) continue;
+    const cursor = new PdfDictionaryCursor(dictionary);
+    for (; ; ) {
+      const item = yield* cursor.next();
+      if (item.done) break;
+      const entry = item.value;
+      const fName = entry.key.decoded;
+      if (selectedName !== void 0 && fName !== selectedName)
+        continue;
+      const fObj = yield* resolveDict2(entry.value);
+      if (!fObj)
+        continue;
+      allocation.admit(1024);
+      const subtypeNode = yield* resolve(dictGet(fObj, "Subtype"));
+      const subtype = subtypeNode?.kind === "name" ? subtypeNode.decoded : "Type1";
+      const baseFontNode = yield* resolve(dictGet(fObj, "BaseFont"));
+      const baseFont = baseFontNode?.kind === "name" ? baseFontNode.decoded : "Helvetica";
+      let cmap;
+      let storedCMap;
+      const toUniNode = yield* resolve(dictGet(fObj, "ToUnicode"));
+      if (toUniNode?.kind === "stream") {
+        try {
+          const value = yield { kind: "decode", stream: toUniNode, purpose: "unicode-cmap" };
+          if (value instanceof Uint8Array) cmap = parseToUnicodeCMap(value, allocationOptions);
+          else if (value && "storedCMap" in value) storedCMap = value;
+          else if (value && "iterateBytes" in value) cmap = value;
+          else throw new TypeError("Font decoder did not return a Unicode CMap");
+        } catch (error) {
+          allocation.rethrowAllocationFailure(error);
+          if (error instanceof PdfError && error.code === "E_LIMIT")
+            throw error;
+        }
       }
-    }
-    const encNode = yield* resolve(dictGet(fObj, "Encoding"));
-    if (encNode?.kind === "dict") {
-      const diffRef = dictGet(encNode, "Differences");
-      if (diffRef?.kind === "ref") {
-        const resolvedDiff = yield* resolve(diffRef, true);
-        if (resolvedDiff?.kind === "array") {
-          dictSet(encNode, "Differences", resolvedDiff);
-        }
-      }
-    }
-    const differenceArray = encNode?.kind === "dict" ? dictGet(encNode, "Differences") : void 0;
-    let storedEncoding;
-    if (options.resourceStorage && differenceArray?.kind === "array") {
-      const value = yield { kind: "font-encoding", array: differenceArray };
-      if (!value || !("storedEncoding" in value)) throw new TypeError("Expected stored font encoding");
-      storedEncoding = value;
-    }
-    allocation.admit(32768 + (!storedEncoding && differenceArray?.kind === "array" ? differenceArray.items.length * 128 : 0));
-    const differences = storedEncoding ? /* @__PURE__ */ new Map() : buildFontEncodingDifferencesMap(encNode);
-    const glyphNames = storedEncoding ? /* @__PURE__ */ new Map() : buildFontEncodingGlyphNamesMap(encNode);
-    function* glyphName(code) {
-      if (!storedEncoding) return glyphNames.get(code);
-      const result = yield { kind: "font-label", lookup: storedEncoding.glyphName, code };
-      return result && "kind" in result && result.kind === "name" ? result.decoded : void 0;
-    }
-    const widths = options.resourceStorage ? new StoredFontWidths(options.resourceStorage, { ...allocationOptions, ...options.signal ? { signal: options.signal } : {} }) : new FontWidths(allocation);
-    function* setWidth(first, width, last = first) {
-      if (widths instanceof StoredFontWidths) yield { kind: "font-width-set", widths, first, width, last };
-      else widths.set(first, width, last);
-    }
-    let defaultWidth = 556;
-    const isTwoByteCid = subtype === "Type0";
-    let fontMatrix;
-    let charProcs;
-    let fontResources;
-    if (subtype === "Type3") {
-      const fmArr = yield* resolveArray2(dictGet(fObj, "FontMatrix"));
-      if (fmArr && fmArr.items.length >= 6) {
-        const mn = function* (idx, fb = 0) {
-          const r = yield* resolve(fmArr.items[idx]);
-          return r?.kind === "number" ? r.value : fb;
-        };
-        fontMatrix = [yield* mn(0, 1e-3), yield* mn(1, 0), yield* mn(2, 0), yield* mn(3, 1e-3), yield* mn(4, 0), yield* mn(5, 0)];
-      } else {
-        fontMatrix = [1e-3, 0, 0, 1e-3, 0, 0];
-      }
-      charProcs = yield* resolveDict2(dictGet(fObj, "CharProcs"));
-      fontResources = yield* resolveDict2(dictGet(fObj, "Resources"));
-    }
-    const type3Scale1000 = subtype === "Type3" && fontMatrix ? Math.hypot(fontMatrix[0], fontMatrix[1]) * 1e3 : 1;
-    if (subtype === "Type0") {
-      const descArr = yield* resolveArray2(dictGet(fObj, "DescendantFonts"));
-      const cidDict = descArr && descArr.items[0] ? yield* resolveDict2(descArr.items[0]) : void 0;
-      if (cidDict) {
-        const dwNode = yield* resolve(dictGet(cidDict, "DW"));
-        if (dwNode?.kind === "number")
-          defaultWidth = dwNode.value;
-        const wArr = yield* resolveArray2(dictGet(cidDict, "W"), true);
-        if (wArr) {
-          const cursor = arrayCursor(wArr);
-          while (cursor.remaining) {
-            const first = yield* resolve(yield* cursor.next(), true);
-            const second = yield* resolve(yield* cursor.next(), true);
-            if (first?.kind === "number" && second?.kind === "array") {
-              const nested = arrayCursor(second);
-              for (let k = 0; nested.remaining; k++) {
-                const wItem = yield* resolve(yield* nested.next());
-                if (wItem?.kind === "number") {
-                  yield* setWidth(first.value + k, wItem.value);
-                }
-              }
-            } else if (first?.kind === "number" && second?.kind === "number") {
-              const third = yield* resolve(yield* cursor.next(), true);
-              if (third?.kind === "number") {
-                if (!Number.isSafeInteger(first.value) || !Number.isSafeInteger(second.value))
-                  throw new PdfError("E_LIMIT", "Unsafe PDF font width range");
-                yield* setWidth(first.value, third.value, second.value);
-              }
-            }
+      const encNode = yield* resolve(dictGet(fObj, "Encoding"));
+      if (encNode?.kind === "dict") {
+        const diffRef = dictGet(encNode, "Differences");
+        if (diffRef?.kind === "ref") {
+          const resolvedDiff = yield* resolve(diffRef, true);
+          if (resolvedDiff?.kind === "array") {
+            dictSet(encNode, "Differences", resolvedDiff);
           }
         }
       }
-    } else {
-      const firstCharNode = yield* resolve(dictGet(fObj, "FirstChar"));
-      const widthsArr = yield* resolveArray2(dictGet(fObj, "Widths"), true);
-      if (widthsArr) {
-        const descriptor = yield* resolveDict2(dictGet(fObj, "FontDescriptor"));
-        const missingWidth = descriptor ? yield* resolve(dictGet(descriptor, "MissingWidth")) : void 0;
-        defaultWidth = (missingWidth?.kind === "number" ? missingWidth.value : 0) * type3Scale1000;
-        const firstChar = firstCharNode?.kind === "number" ? firstCharNode.value : 0;
-        const cursor = arrayCursor(widthsArr);
-        for (let k = 0; cursor.remaining; k++) {
-          const wItem = yield* resolve(yield* cursor.next());
-          if (wItem?.kind === "number") {
-            yield* setWidth(firstChar + k, wItem.value * type3Scale1000);
+      const differenceArray = encNode?.kind === "dict" ? dictGet(encNode, "Differences") : void 0;
+      let storedEncoding;
+      if (options.resourceStorage && differenceArray?.kind === "array") {
+        const value = yield { kind: "font-encoding", array: differenceArray };
+        if (!value || !("storedEncoding" in value)) throw new TypeError("Expected stored font encoding");
+        storedEncoding = value;
+      }
+      allocation.admit(32768 + (!storedEncoding && differenceArray?.kind === "array" ? differenceArray.items.length * 128 : 0));
+      const differences = storedEncoding ? /* @__PURE__ */ new Map() : buildFontEncodingDifferencesMap(encNode);
+      const glyphNames = storedEncoding ? /* @__PURE__ */ new Map() : buildFontEncodingGlyphNamesMap(encNode);
+      function* glyphName(code) {
+        if (!storedEncoding) return glyphNames.get(code);
+        const result = yield { kind: "font-label", lookup: storedEncoding.glyphName, code };
+        return result && "kind" in result && result.kind === "name" ? result.decoded : void 0;
+      }
+      const widths = options.resourceStorage ? new StoredFontWidths(options.resourceStorage, { ...allocationOptions, ...options.signal ? { signal: options.signal } : {} }) : new FontWidths(allocation);
+      function* setWidth(first, width, last = first) {
+        if (widths instanceof StoredFontWidths) yield { kind: "font-width-set", widths, first, width, last };
+        else widths.set(first, width, last);
+      }
+      let defaultWidth = 556;
+      const isTwoByteCid = subtype === "Type0";
+      let fontMatrix;
+      let charProcs;
+      let fontResources;
+      if (subtype === "Type3") {
+        const fmArr = yield* resolveArray2(dictGet(fObj, "FontMatrix"));
+        if (fmArr && fmArr.items.length >= 6) {
+          const mn = function* (idx, fb = 0) {
+            const r = yield* resolve(fmArr.items[idx]);
+            return r?.kind === "number" ? r.value : fb;
+          };
+          fontMatrix = [yield* mn(0, 1e-3), yield* mn(1, 0), yield* mn(2, 0), yield* mn(3, 1e-3), yield* mn(4, 0), yield* mn(5, 0)];
+        } else {
+          fontMatrix = [1e-3, 0, 0, 1e-3, 0, 0];
+        }
+        charProcs = yield* resolveDict2(dictGet(fObj, "CharProcs"));
+        fontResources = yield* resolveDict2(dictGet(fObj, "Resources"));
+      }
+      const type3Scale1000 = subtype === "Type3" && fontMatrix ? Math.hypot(fontMatrix[0], fontMatrix[1]) * 1e3 : 1;
+      if (subtype === "Type0") {
+        const descArr = yield* resolveArray2(dictGet(fObj, "DescendantFonts"));
+        const cidDict = descArr && descArr.items[0] ? yield* resolveDict2(descArr.items[0]) : void 0;
+        if (cidDict) {
+          const dwNode = yield* resolve(dictGet(cidDict, "DW"));
+          if (dwNode?.kind === "number")
+            defaultWidth = dwNode.value;
+          const wArr = yield* resolveArray2(dictGet(cidDict, "W"), true);
+          if (wArr) {
+            const cursor2 = arrayCursor(wArr);
+            while (cursor2.remaining) {
+              const first = yield* resolve(yield* cursor2.next(), true);
+              const second = yield* resolve(yield* cursor2.next(), true);
+              if (first?.kind === "number" && second?.kind === "array") {
+                const nested = arrayCursor(second);
+                for (let k = 0; nested.remaining; k++) {
+                  const wItem = yield* resolve(yield* nested.next());
+                  if (wItem?.kind === "number") {
+                    yield* setWidth(first.value + k, wItem.value);
+                  }
+                }
+              } else if (first?.kind === "number" && second?.kind === "number") {
+                const third = yield* resolve(yield* cursor2.next(), true);
+                if (third?.kind === "number") {
+                  if (!Number.isSafeInteger(first.value) || !Number.isSafeInteger(second.value))
+                    throw new PdfError("E_LIMIT", "Unsafe PDF font width range");
+                  yield* setWidth(first.value, third.value, second.value);
+                }
+              }
+            }
           }
         }
       } else {
-        const stdMetrics = STANDARD_14_FONTS[normalizeStandard14FontName(baseFont)];
-        defaultWidth = stdMetrics.defaultWidth;
-        if (widths instanceof StoredFontWidths) widths.setDefaults(stdMetrics.widthsByCode);
-        else for (const [codeStr, wVal] of Object.entries(stdMetrics.widthsByCode)) {
-          yield* setWidth(Number(codeStr), wVal);
-        }
-      }
-    }
-    let embeddedCff;
-    let storedTrueType;
-    let embeddedTrueType;
-    let simpleToGid;
-    const fDescDirect = yield* resolveDict2(dictGet(fObj, "FontDescriptor"));
-    const descArrForTt = subtype === "Type0" ? yield* resolveArray2(dictGet(fObj, "DescendantFonts")) : void 0;
-    const cidDictForTt = descArrForTt && descArrForTt.items[0] ? yield* resolveDict2(descArrForTt.items[0]) : void 0;
-    const fDesc = fDescDirect ?? (cidDictForTt ? yield* resolveDict2(dictGet(cidDictForTt, "FontDescriptor")) : void 0);
-    let cidToGid;
-    let storedCidToGid;
-    const cidMap = cidDictForTt ? yield* resolve(dictGet(cidDictForTt, "CIDToGIDMap")) : void 0;
-    if (cidMap?.kind === "stream") {
-      const bytes = yield { kind: "decode", stream: cidMap, purpose: "cid-map" };
-      if (bytes && "byteLength" in bytes && "storage" in bytes) storedCidToGid = bytes;
-      else if (bytes instanceof Uint8Array) {
-        allocation.admit(Math.ceil(bytes.length / 2) * 2);
-        cidToGid = new Uint16Array(Math.ceil(bytes.length / 2));
-        for (let i = 0; i < bytes.length; i += 2)
-          cidToGid[i / 2] = bytes[i] << 8 | (bytes[i + 1] ?? 0);
-      } else throw new TypeError("Font decoder did not return CID map bytes");
-    }
-    if (fDesc) {
-      const type1Program = yield* resolve(dictGet(fDesc, "FontFile"));
-      const program = (yield* resolve(dictGet(fDesc, "FontFile2"))) ?? (yield* resolve(dictGet(fDesc, "FontFile3"))) ?? type1Program;
-      if (program?.kind === "stream") {
-        const programType = yield* resolve(dictGet(program.dict, "Subtype"));
-        const baseEncoding = encNode?.kind === "dict" ? yield* resolve(dictGet(encNode, "BaseEncoding")) : encNode;
-        if (program === type1Program) {
-          const length1 = yield* resolve(dictGet(program.dict, "Length1"));
-          const length2 = yield* resolve(dictGet(program.dict, "Length2"));
-          const flags = yield* resolve(dictGet(fDesc, "Flags"));
-          const type1Properties = {
-            length1: length1?.kind === "number" ? length1.value : 0,
-            length2: length2?.kind === "number" ? length2.value : 0,
-            flags: flags?.kind === "number" ? flags.value : 0,
-            fontMatrix: [1e-3, 0, 0, 1e-3, 0, 0],
-            bbox: [0, 0, 0, 0],
-            baseEncodingName: baseEncoding?.kind === "name" ? baseEncoding.decoded : void 0,
-            differences: glyphNames,
-            overridableEncoding: true,
-            widths: widths instanceof FontWidths ? widths.createType1View() : {},
-            composite: subtype === "Type0",
-            cMap: { charCodeOf: (cid) => cid }
-          };
-          const decoded = yield { kind: "decode", stream: program, purpose: "type1", type1Properties, ...storedEncoding ? { storedEncoding } : {} };
-          if (decoded && "storedCff" in decoded) embeddedCff = decoded;
-          else if (decoded instanceof Uint8Array) embeddedCff = parseEmbeddedType1Font(decoded, type1Properties, allocationOptions);
-          else throw new TypeError("Font decoder did not return a Type1 font");
-        } else if (programType?.kind === "name" && (programType.decoded === "Type1C" || programType.decoded === "CIDFontType0C")) {
-          const encodingName = baseEncoding?.kind === "name" ? baseEncoding.decoded : void 0;
-          const decoded = yield { kind: "decode", stream: program, purpose: "cff", encodingName, differences: glyphNames, ...storedEncoding ? { storedEncoding } : {} };
-          if (decoded && "storedCff" in decoded) embeddedCff = decoded;
-          else if (decoded instanceof Uint8Array) embeddedCff = parseEmbeddedCffFont(decoded, encodingName, glyphNames, allocationOptions);
-          else throw new TypeError("Font decoder did not return a CFF font");
+        const firstCharNode = yield* resolve(dictGet(fObj, "FirstChar"));
+        const widthsArr = yield* resolveArray2(dictGet(fObj, "Widths"), true);
+        if (widthsArr) {
+          const descriptor = yield* resolveDict2(dictGet(fObj, "FontDescriptor"));
+          const missingWidth = descriptor ? yield* resolve(dictGet(descriptor, "MissingWidth")) : void 0;
+          defaultWidth = (missingWidth?.kind === "number" ? missingWidth.value : 0) * type3Scale1000;
+          const firstChar = firstCharNode?.kind === "number" ? firstCharNode.value : 0;
+          const cursor2 = arrayCursor(widthsArr);
+          for (let k = 0; cursor2.remaining; k++) {
+            const wItem = yield* resolve(yield* cursor2.next());
+            if (wItem?.kind === "number") {
+              yield* setWidth(firstChar + k, wItem.value * type3Scale1000);
+            }
+          }
         } else {
-          const decoded = yield { kind: "decode", stream: program, purpose: "truetype" };
-          if (decoded && "getGlyphId" in decoded) storedTrueType = decoded;
-          else if (decoded instanceof Uint8Array) embeddedTrueType = parseTrueTypeFont(decoded, allocationOptions);
-          else throw new TypeError("Font decoder did not return a TrueType font");
-          if (storedTrueType && subtype !== "Type0" && (storedTrueType.isSymbolicCmap || !storedTrueType.hasCmap)) {
-            simpleToGid = /* @__PURE__ */ new Map();
-            const encoding = baseEncoding?.kind === "name" ? getEncoding(baseEncoding.decoded) : void 0;
-            for (let code = 0; code < 256; code++) {
-              let result;
-              if (storedTrueType.isSymbolicCmap) {
-                result = yield { kind: "truetype-map", font: storedTrueType, code: 61440 + code };
-                if (result && "kind" in result && result.kind === "number" && result.value === 0) result = yield { kind: "truetype-map", font: storedTrueType, code };
-              } else {
+          const stdMetrics = STANDARD_14_FONTS[normalizeStandard14FontName(baseFont)];
+          defaultWidth = stdMetrics.defaultWidth;
+          if (widths instanceof StoredFontWidths) widths.setDefaults(stdMetrics.widthsByCode);
+          else for (const [codeStr, wVal] of Object.entries(stdMetrics.widthsByCode)) {
+            yield* setWidth(Number(codeStr), wVal);
+          }
+        }
+      }
+      let embeddedCff;
+      let storedTrueType;
+      let embeddedTrueType;
+      let simpleToGid;
+      const fDescDirect = yield* resolveDict2(dictGet(fObj, "FontDescriptor"));
+      const descArrForTt = subtype === "Type0" ? yield* resolveArray2(dictGet(fObj, "DescendantFonts")) : void 0;
+      const cidDictForTt = descArrForTt && descArrForTt.items[0] ? yield* resolveDict2(descArrForTt.items[0]) : void 0;
+      const fDesc = fDescDirect ?? (cidDictForTt ? yield* resolveDict2(dictGet(cidDictForTt, "FontDescriptor")) : void 0);
+      let cidToGid;
+      let storedCidToGid;
+      const cidMap = cidDictForTt ? yield* resolve(dictGet(cidDictForTt, "CIDToGIDMap")) : void 0;
+      if (cidMap?.kind === "stream") {
+        const bytes = yield { kind: "decode", stream: cidMap, purpose: "cid-map" };
+        if (bytes && "byteLength" in bytes && "storage" in bytes) storedCidToGid = bytes;
+        else if (bytes instanceof Uint8Array) {
+          allocation.admit(Math.ceil(bytes.length / 2) * 2);
+          cidToGid = new Uint16Array(Math.ceil(bytes.length / 2));
+          for (let i = 0; i < bytes.length; i += 2)
+            cidToGid[i / 2] = bytes[i] << 8 | (bytes[i + 1] ?? 0);
+        } else throw new TypeError("Font decoder did not return CID map bytes");
+      }
+      if (fDesc) {
+        const type1Program = yield* resolve(dictGet(fDesc, "FontFile"));
+        const program = (yield* resolve(dictGet(fDesc, "FontFile2"))) ?? (yield* resolve(dictGet(fDesc, "FontFile3"))) ?? type1Program;
+        if (program?.kind === "stream") {
+          const programType = yield* resolve(dictGet(program.dict, "Subtype"));
+          const baseEncoding = encNode?.kind === "dict" ? yield* resolve(dictGet(encNode, "BaseEncoding")) : encNode;
+          if (program === type1Program) {
+            const length1 = yield* resolve(dictGet(program.dict, "Length1"));
+            const length2 = yield* resolve(dictGet(program.dict, "Length2"));
+            const flags = yield* resolve(dictGet(fDesc, "Flags"));
+            const type1Properties = {
+              length1: length1?.kind === "number" ? length1.value : 0,
+              length2: length2?.kind === "number" ? length2.value : 0,
+              flags: flags?.kind === "number" ? flags.value : 0,
+              fontMatrix: [1e-3, 0, 0, 1e-3, 0, 0],
+              bbox: [0, 0, 0, 0],
+              baseEncodingName: baseEncoding?.kind === "name" ? baseEncoding.decoded : void 0,
+              differences: glyphNames,
+              overridableEncoding: true,
+              widths: widths instanceof FontWidths ? widths.createType1View() : {},
+              composite: subtype === "Type0",
+              cMap: { charCodeOf: (cid) => cid }
+            };
+            const decoded = yield { kind: "decode", stream: program, purpose: "type1", type1Properties, ...storedEncoding ? { storedEncoding } : {} };
+            if (decoded && "storedCff" in decoded) embeddedCff = decoded;
+            else if (decoded instanceof Uint8Array) embeddedCff = parseEmbeddedType1Font(decoded, type1Properties, allocationOptions);
+            else throw new TypeError("Font decoder did not return a Type1 font");
+          } else if (programType?.kind === "name" && (programType.decoded === "Type1C" || programType.decoded === "CIDFontType0C")) {
+            const encodingName = baseEncoding?.kind === "name" ? baseEncoding.decoded : void 0;
+            const decoded = yield { kind: "decode", stream: program, purpose: "cff", encodingName, differences: glyphNames, ...storedEncoding ? { storedEncoding } : {} };
+            if (decoded && "storedCff" in decoded) embeddedCff = decoded;
+            else if (decoded instanceof Uint8Array) embeddedCff = parseEmbeddedCffFont(decoded, encodingName, glyphNames, allocationOptions);
+            else throw new TypeError("Font decoder did not return a CFF font");
+          } else {
+            const decoded = yield { kind: "decode", stream: program, purpose: "truetype" };
+            if (decoded && "getGlyphId" in decoded) storedTrueType = decoded;
+            else if (decoded instanceof Uint8Array) embeddedTrueType = parseTrueTypeFont(decoded, allocationOptions);
+            else throw new TypeError("Font decoder did not return a TrueType font");
+            if (storedTrueType && subtype !== "Type0" && (storedTrueType.isSymbolicCmap || !storedTrueType.hasCmap)) {
+              simpleToGid = /* @__PURE__ */ new Map();
+              const encoding = baseEncoding?.kind === "name" ? getEncoding(baseEncoding.decoded) : void 0;
+              for (let code = 0; code < 256; code++) {
+                let result;
+                if (storedTrueType.isSymbolicCmap) {
+                  result = yield { kind: "truetype-map", font: storedTrueType, code: 61440 + code };
+                  if (result && "kind" in result && result.kind === "number" && result.value === 0) result = yield { kind: "truetype-map", font: storedTrueType, code };
+                } else {
+                  const name = (yield* glyphName(code)) || encoding?.[code];
+                  if (!name) continue;
+                  result = yield { kind: "truetype-map", font: storedTrueType, name };
+                }
+                if (!result || !("kind" in result) || result.kind !== "number") throw new TypeError("Expected TrueType glyph ID");
+                if (result.value > 0) simpleToGid.set(code, result.value);
+              }
+            }
+            if (subtype !== "Type0" && embeddedTrueType?.isSymbolicCmap) {
+              simpleToGid = /* @__PURE__ */ new Map();
+              for (let code = 0; code < 256; code++) {
+                const gid = embeddedTrueType.getGlyphId(61440 + code) || embeddedTrueType.getGlyphId(code);
+                if (gid > 0)
+                  simpleToGid.set(code, gid);
+              }
+            } else if (subtype !== "Type0" && embeddedTrueType && !embeddedTrueType.hasCmap) {
+              simpleToGid = /* @__PURE__ */ new Map();
+              const encoding = baseEncoding?.kind === "name" ? getEncoding(baseEncoding.decoded) : void 0;
+              for (let code = 0; code < 256; code++) {
                 const name = (yield* glyphName(code)) || encoding?.[code];
-                if (!name) continue;
-                result = yield { kind: "truetype-map", font: storedTrueType, name };
+                const gid = name ? embeddedTrueType.glyphNames.indexOf(name) : -1;
+                if (gid > 0)
+                  simpleToGid.set(code, gid);
               }
-              if (!result || !("kind" in result) || result.kind !== "number") throw new TypeError("Expected TrueType glyph ID");
-              if (result.value > 0) simpleToGid.set(code, result.value);
             }
           }
-          if (subtype !== "Type0" && embeddedTrueType?.isSymbolicCmap) {
-            simpleToGid = /* @__PURE__ */ new Map();
-            for (let code = 0; code < 256; code++) {
-              const gid = embeddedTrueType.getGlyphId(61440 + code) || embeddedTrueType.getGlyphId(code);
-              if (gid > 0)
-                simpleToGid.set(code, gid);
-            }
-          } else if (subtype !== "Type0" && embeddedTrueType && !embeddedTrueType.hasCmap) {
-            simpleToGid = /* @__PURE__ */ new Map();
-            const encoding = baseEncoding?.kind === "name" ? getEncoding(baseEncoding.decoded) : void 0;
-            for (let code = 0; code < 256; code++) {
-              const name = (yield* glyphName(code)) || encoding?.[code];
-              const gid = name ? embeddedTrueType.glyphNames.indexOf(name) : -1;
-              if (gid > 0)
-                simpleToGid.set(code, gid);
-            }
+          for (const [code, unicode] of embeddedCff?.unicodeByCode ?? []) {
+            if (!differences.has(code))
+              differences.set(code, unicode);
           }
         }
-        for (const [code, unicode] of embeddedCff?.unicodeByCode ?? []) {
-          if (!differences.has(code))
-            differences.set(code, unicode);
-        }
-      }
-    }
-    const standardOutlines = !embeddedTrueType && !storedTrueType && !embeddedCff && subtype !== "Type3" ? getStandardFontOutlines(baseFont, options.onAllocation ? allocationOptions : {}) : void 0;
-    for (const [code, unicode] of standardOutlines?.defaultUnicode ?? []) {
-      if (!differences.has(code))
-        differences.set(code, unicode);
-    }
-    let encodingCMap;
-    let storedEncodingCMap;
-    if (subtype === "Type0" && encNode?.kind === "stream") {
-      const value = yield { kind: "decode", stream: encNode, purpose: "encoding-cmap" };
-      if (value instanceof Uint8Array) encodingCMap = parseCharacterCMap(value, allocationOptions);
-      else if (value && "storedCMap" in value) storedEncodingCMap = value;
-      else if (value && "lookup" in value) encodingCMap = value;
-      else throw new TypeError("Font decoder did not return an encoding CMap");
-    }
-    fonts.set(fName, {
-      name: fName,
-      baseFont,
-      subtype,
-      isTwoByteCid,
-      cmap,
-      encodingCMap,
-      storedCMap,
-      storedEncodingCMap,
-      differences,
-      glyphNames,
-      widths,
-      defaultWidth,
-      fontMatrix,
-      charProcs,
-      fontResources,
-      embeddedTrueType,
-      storedTrueType,
-      cidToGid,
-      storedCidToGid,
-      ...storedEncoding ? { storedEncoding } : {},
-      simpleToGid,
-      embeddedCff,
-      standardOutlines
-    });
+      }
+      const standardOutlines = !embeddedTrueType && !storedTrueType && !embeddedCff && subtype !== "Type3" ? getStandardFontOutlines(baseFont, options.onAllocation ? allocationOptions : {}) : void 0;
+      for (const [code, unicode] of standardOutlines?.defaultUnicode ?? []) {
+        if (!differences.has(code))
+          differences.set(code, unicode);
+      }
+      let encodingCMap;
+      let storedEncodingCMap;
+      if (subtype === "Type0" && encNode?.kind === "stream") {
+        const value = yield { kind: "decode", stream: encNode, purpose: "encoding-cmap" };
+        if (value instanceof Uint8Array) encodingCMap = parseCharacterCMap(value, allocationOptions);
+        else if (value && "storedCMap" in value) storedEncodingCMap = value;
+        else if (value && "lookup" in value) encodingCMap = value;
+        else throw new TypeError("Font decoder did not return an encoding CMap");
+      }
+      fonts.set(fName, {
+        name: fName,
+        baseFont,
+        subtype,
+        isTwoByteCid,
+        cmap,
+        encodingCMap,
+        storedCMap,
+        storedEncodingCMap,
+        differences,
+        glyphNames,
+        widths,
+        defaultWidth,
+        fontMatrix,
+        charProcs,
+        fontResources,
+        embeddedTrueType,
+        storedTrueType,
+        cidToGid,
+        storedCidToGid,
+        ...storedEncoding ? { storedEncoding } : {},
+        simpleToGid,
+        embeddedCff,
+        standardOutlines
+      });
+    }
   }
   return fonts;
 }
@@ -33023,7 +33590,7 @@ function resolvePageFonts(doc, resourcesDict, selectedName) {
   while (!step.done) {
     let value;
     try {
-      if (step.value.kind === "font-encoding" || step.value.kind === "font-label" || step.value.kind === "array-item" || step.value.kind === "truetype-map" || step.value.kind === "font-width-set") throw new TypeError("Stored font requires asynchronous evaluation");
+      if (step.value.kind === "dictionary-entry" || step.value.kind === "font-encoding" || step.value.kind === "font-label" || step.value.kind === "array-item" || step.value.kind === "truetype-map" || step.value.kind === "font-width-set") throw new TypeError("Stored font requires asynchronous evaluation");
       value = step.value.kind === "resolve" ? doc.resolve(step.value.node) : doc.decodeStream(step.value.stream);
     } catch (error) {
       step = steps.throw(error);
@@ -44064,8 +44631,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 = cosDict({});
-      for (const se of sub.entries) dictSet(clonedSub, se.key.decoded, se.value);
+      const clonedSub = sub.storedEntries ? 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 {
       dictSet(evalResourcesDict, entry.key.decoded, entry.value);
@@ -44118,6 +44685,11 @@ function* preparePageAppearanceSteps(pageDict, pageRes, evalResourcesDict, hideA
                 dstSub = cosDict({});
                 dictSet(evalResourcesDict, subKey, dstSub);
               }
+              if (srcSub.storedEntries || dstSub.storedEntries) {
+                const merged = yield { kind: "dictionary-merge", destination: dstSub, source: srcSub };
+                dictSet(evalResourcesDict, subKey, merged);
+                continue;
+              }
               for (const se of srcSub.entries) {
                 if (!dictGet(dstSub, se.key.decoded)) {
                   onAllocation?.(64);
@@ -45870,7 +46442,7 @@ var PdfPage = class {
       const request = step.value;
       if (request.kind === "resolve" || request.kind === "catalog") {
         step = work.next(this.cosDoc.resolve(request.kind === "catalog" ? this.cosDoc.rootRef : request.node));
-      } else if (request.kind === "array-reference" || request.kind === "array-item") throw new TypeError("Stored visibility requires asynchronous evaluation");
+      } else if (request.kind === "dictionary-merge" || request.kind === "array-reference" || request.kind === "array-item") throw new TypeError("Stored visibility requires asynchronous evaluation");
       else if (request.kind === "appearance-content") {
         appearance = parseContentStream(this.cosDoc.decodeStream(request.stream));
         step = work.next(appearance.length > 0);
@@ -48147,7 +48719,7 @@ async function renderRetainedPagePixels(page2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/range-parser.ts
-import { listenForAbort } from "@poe-platform/safe-fs/contracts";
+import { listenForAbort as listenForAbort2 } from "@poe-platform/safe-fs/contracts";
 function limit(value, name) {
   const result = value ?? Infinity;
   if (result !== Infinity && (!Number.isSafeInteger(result) || result < 0)) throw new RangeError(`Invalid ${name}`);
@@ -48199,7 +48771,7 @@ async function resolveStreamLength(entry, options) {
   let dispose = () => {
   };
   const cancelled = new Promise((ignored, reject) => {
-    dispose = listenForAbort(signal, () => reject(signal.reason));
+    dispose = listenForAbort2(signal, () => reject(signal.reason));
   });
   const pending = Promise.resolve().then(() => {
     signal.throwIfAborted();
@@ -48222,10 +48794,10 @@ async function readValue(lexer, depth, nodes, options) {
     while (!step.done) {
       signal?.throwIfAborted();
       const request = step.value;
-      if (request && request !== "token" && request.kind === "array-append") {
+      if (request && request !== "token" && (request.kind === "array-append" || request.kind === "dictionary-append")) {
         let position;
         try {
-          position = await appendStoredRecord(options.arrayStorage, request.node, request.previous, signal);
+          position = await appendStoredRecord(request.kind === "array-append" ? options.arrayStorage : options.dictionaryStorage, request.kind === "array-append" ? request.node : request.entry, request.previous, signal);
         } catch (error) {
           options.onBackingError?.(error);
           throw error;
@@ -48255,7 +48827,7 @@ async function parseCosRangeValue(source, offset, options = {}) {
   const depth = limit(options.maxRecursionDepth, "maxRecursionDepth");
   const nodes = limit(options.maxNodes, "maxNodes");
   const maxTokenBytes = limit(options.maxTokenBytes, "maxTokenBytes");
-  const lexer = new CosRangeLexer(source, { ...options.onBackingError ? { onBackingError: options.onBackingError } : {}, start: offset, ...options.end === void 0 ? {} : { end: options.end }, maxTokenBytes, ...options.signal ? { signal: options.signal } : {} });
+  const lexer = new CosRangeLexer(source, { compactNumbers: options.compactNumbers ?? false, compactKeywords: options.compactKeywords ?? false, ...options.onBackingError ? { onBackingError: options.onBackingError } : {}, start: offset, ...options.end === void 0 ? {} : { end: options.end }, maxTokenBytes, ...options.signal ? { signal: options.signal } : {} });
   return { value: await readValue(lexer, depth, nodes, options), offset: lexer.offset };
 }
 async function parseCosRangeObject(source, offset, options = {}) {
@@ -48264,7 +48836,7 @@ async function parseCosRangeObject(source, offset, options = {}) {
   const tokenBytes = limit(options.maxTokenBytes, "maxTokenBytes");
   const { signal } = options;
   signal?.throwIfAborted();
-  const lexer = new CosRangeLexer(source, { ...options.onBackingError ? { onBackingError: options.onBackingError } : {}, start: offset, maxTokenBytes: tokenBytes, ...signal ? { signal } : {} });
+  const lexer = new CosRangeLexer(source, { compactNumbers: options.compactNumbers ?? false, compactKeywords: options.compactKeywords ?? false, ...options.onBackingError ? { onBackingError: options.onBackingError } : {}, start: offset, maxTokenBytes: tokenBytes, ...signal ? { signal } : {} });
   const object = await lexer.nextToken();
   const generation = await lexer.nextToken();
   const keyword = await lexer.nextToken();
@@ -48373,7 +48945,7 @@ async function* scanCosRangeObjects(source, options = {}) {
 
 // packages/pdf-ast/src/cos/range-xref.ts
 import { readBytes as readBytes12 } from "@poe-platform/safe-fs/contracts";
-function budget(value, name) {
+function budget2(value, name) {
   if (value === void 0 || value === Infinity) return Infinity;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -48432,12 +49004,12 @@ var DecodedFields = class {
   }
 };
 async function* readCosXrefRevision(source, offset, options = {}) {
-  const maximum10 = budget(options.maxEntries, "maxEntries");
-  const maxDecoded = budget(options.maxDecodedBytes, "maxDecodedBytes");
+  const maximum10 = budget2(options.maxEntries, "maxEntries");
+  const maxDecoded = budget2(options.maxDecodedBytes, "maxDecodedBytes");
   const { signal } = options;
   signal?.throwIfAborted();
   if (!Number.isSafeInteger(offset) || offset < 0 || offset >= source.size) throw new PdfError("E_PARSE", `Invalid xref offset: ${offset}`);
-  const lexer = new CosRangeLexer(source, { start: offset, ...signal ? { signal } : {}, ...options.maxTokenBytes === void 0 ? {} : { maxTokenBytes: options.maxTokenBytes } });
+  const lexer = new CosRangeLexer(source, { compactNumbers: options.compactNumbers ?? false, compactKeywords: options.compactKeywords ?? false, start: offset, ...signal ? { signal } : {}, ...options.maxTokenBytes === void 0 ? {} : { maxTokenBytes: options.maxTokenBytes } });
   const first = await lexer.nextToken();
   let admitted = 0;
   const admit2 = (count) => {
@@ -48552,271 +49124,6 @@ async function* readCosXrefRevision(source, offset, options = {}) {
   }
 }
 
-// packages/pdf-ast/src/cos/object-index.ts
-import { listenForAbort as listenForAbort2 } from "@poe-platform/safe-fs/contracts";
-var recordBytes = 32;
-function integer(value, name) {
-  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
-  return value;
-}
-function budget2(value, name) {
-  return value === void 0 || value === Infinity ? Infinity : integer(value, name);
-}
-function fields(entry) {
-  const key = integer(entry.objectNumber, "PDF object number");
-  if (entry.type === "free") return [key, integer(entry.nextFreeObjectNumber ?? 0, "free object number"), integer(entry.generationNumber ?? 0, "generation number"), 0];
-  if (entry.type === "uncompressed") return [key, integer(entry.offset, "object offset"), integer(entry.generationNumber ?? 0, "generation number"), 1];
-  if (entry.type === "compressed") return [key, integer(entry.objectStreamNumber, "object stream number"), integer(entry.indexInStream ?? entry.indexInObjectStream, "object stream index"), 2];
-  throw new PdfError("E_PARSE", "Invalid PDF cross-reference entry type");
-}
-function decode(bytes, offset = 0) {
-  const view = new DataView(bytes.buffer, bytes.byteOffset + offset, recordBytes);
-  const objectNumber = view.getFloat64(0);
-  const first = view.getFloat64(8);
-  const second = view.getFloat64(16);
-  const type = view.getFloat64(24);
-  if (type === 0) return { objectNumber, type: "free", nextFreeObjectNumber: first, generationNumber: second };
-  if (type === 1) return { objectNumber, type: "uncompressed", offset: first, generationNumber: second };
-  if (type === 2) return { objectNumber, type: "compressed", objectStreamNumber: first, indexInStream: second };
-  throw new PdfError("E_PARSE", "Invalid staged PDF index record");
-}
-async function* encode2(entries, chunkBytes) {
-  let bytes = new Uint8Array(chunkBytes);
-  let offset = 0;
-  for await (const entry of entries) {
-    const view = new DataView(bytes.buffer, offset, recordBytes);
-    const values = fields(entry);
-    for (let i = 0; i < values.length; i++) view.setFloat64(i * 8, values[i]);
-    offset += recordBytes;
-    if (offset === bytes.length) {
-      yield bytes;
-      bytes = new Uint8Array(chunkBytes);
-      offset = 0;
-    }
-  }
-  if (offset) yield bytes.subarray(0, offset);
-}
-async function* records(source, signal) {
-  for await (const bytes of source.stream(0, source.size, signal)) {
-    if (bytes.length % recordBytes !== 0) throw new PdfError("E_PARSE", "Truncated staged PDF index");
-    for (let offset = 0; offset < bytes.length; offset += recordBytes) {
-      signal?.throwIfAborted();
-      yield decode(bytes, offset);
-    }
-  }
-}
-async function* merge(first, second, duplicate, signal) {
-  const left = records(first, signal);
-  const right = records(second, signal);
-  try {
-    let a = await left.next();
-    let b = await right.next();
-    let turns = 0;
-    while (!a.done || !b.done) {
-      signal?.throwIfAborted();
-      if (!a.done && (b.done || a.value.objectNumber <= b.value.objectNumber)) {
-        const equal2 = !b.done && a.value.objectNumber === b.value.objectNumber;
-        yield equal2 && duplicate === "last" && !b.done ? b.value : a.value;
-        if (equal2) b = await right.next();
-        a = await left.next();
-      } else if (!b.done) {
-        yield b.value;
-        b = await right.next();
-      }
-      if (++turns % 1024 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
-    }
-  } finally {
-    await left.return(void 0);
-    await right.return(void 0);
-  }
-}
-var PdfObjectIndex = class _PdfObjectIndex {
-  constructor(source, signal) {
-    this.source = source;
-    this.signal = signal;
-  }
-  source;
-  signal;
-  closing;
-  get size() {
-    return this.source.size / recordBytes;
-  }
-  static async build(input, storage, options = {}) {
-    const duplicate = options.duplicate ?? "first";
-    if (duplicate !== "first" && duplicate !== "last") throw new RangeError("Invalid PDF index duplicate policy");
-    const runEntries = integer(options.runEntries ?? 2048, "runEntries");
-    const chunkBytes = integer(options.chunkBytes ?? 64 * 1024, "chunkBytes");
-    const cacheBytes = integer(options.cacheBytes ?? 256 * 1024, "cacheBytes");
-    if (!runEntries || chunkBytes < recordBytes || chunkBytes % recordBytes !== 0 || cacheBytes < chunkBytes) throw new RangeError("Invalid PDF index batch/cache sizes");
-    const maxEntries = budget2(options.maxEntries, "maxEntries");
-    const maxStagingBytes = budget2(options.maxStagingBytes, "maxStagingBytes");
-    const { signal } = options;
-    signal?.throwIfAborted();
-    const owned = /* @__PURE__ */ new Set();
-    const levels = [];
-    let stagedBytes = 0;
-    let admitted = 0;
-    let batch = [];
-    const dispose = async (source) => {
-      try {
-        await source.close();
-      } finally {
-        owned.delete(source);
-        stagedBytes -= source.size;
-      }
-    };
-    const stage = async (entries) => {
-      let reserved = 0;
-      async function* chunks() {
-        for await (const bytes of encode2(entries, chunkBytes)) {
-          signal?.throwIfAborted();
-          if (bytes.length > Math.min(maxStagingBytes, Number.MAX_SAFE_INTEGER) - stagedBytes) throw new PdfError("E_LIMIT", "PDF index staging byte limit exceeded");
-          stagedBytes += bytes.length;
-          reserved += bytes.length;
-          yield bytes;
-        }
-      }
-      try {
-        const source = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks(), { chunkBytes, cacheBytes, ...signal ? { signal } : {} });
-        owned.add(source);
-        return source;
-      } catch (error) {
-        stagedBytes -= reserved;
-        throw error;
-      }
-    };
-    const flush = async () => {
-      if (duplicate === "last") batch.reverse();
-      batch.sort((a, b) => a.objectNumber - b.objectNumber);
-      const sorted = batch;
-      batch = [];
-      function* unique() {
-        let previous = -1;
-        for (const entry of sorted) if (entry.objectNumber !== previous) {
-          previous = entry.objectNumber;
-          yield entry;
-        }
-      }
-      let run = await stage(unique());
-      let level = 0;
-      while (levels[level]) {
-        const earlier = levels[level];
-        const combined = await stage(merge(earlier, run, duplicate, signal));
-        await dispose(earlier);
-        await dispose(run);
-        levels[level++] = void 0;
-        run = combined;
-      }
-      levels[level] = run;
-    };
-    const iterator = Symbol.asyncIterator in input ? input[Symbol.asyncIterator]() : input[Symbol.iterator]();
-    let ended = false;
-    const next = async () => {
-      signal?.throwIfAborted();
-      if (!signal) return iterator.next();
-      let dispose2 = () => {
-      };
-      const cancelled = new Promise((ignored, reject) => {
-        dispose2 = listenForAbort2(signal, () => reject(signal.reason));
-      });
-      const pending = Promise.resolve().then(() => {
-        signal.throwIfAborted();
-        return iterator.next();
-      });
-      try {
-        return await Promise.race([pending, cancelled]);
-      } finally {
-        dispose2();
-      }
-    };
-    try {
-      while (true) {
-        const step = await next();
-        signal?.throwIfAborted();
-        if (step.done) {
-          ended = true;
-          break;
-        }
-        if (admitted >= Math.min(maxEntries, Number.MAX_SAFE_INTEGER)) throw new PdfError("E_LIMIT", "PDF index entry limit exceeded");
-        admitted++;
-        const values = fields(step.value);
-        const entry = step.value.type === "compressed" ? { objectNumber: values[0], type: "compressed", objectStreamNumber: values[1], indexInStream: values[2] } : step.value.type === "free" ? { objectNumber: values[0], type: "free", nextFreeObjectNumber: values[1], generationNumber: values[2] } : { objectNumber: values[0], type: "uncompressed", offset: values[1], generationNumber: values[2] };
-        batch.push(entry);
-        if (batch.length === runEntries) await flush();
-        if (admitted % 1024 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
-      }
-      if (batch.length) await flush();
-      let result;
-      for (let level = levels.length - 1; level >= 0; level--) {
-        const run = levels[level];
-        if (!run) continue;
-        if (!result) result = run;
-        else {
-          const combined = await stage(merge(result, run, duplicate, signal));
-          await dispose(result);
-          await dispose(run);
-          result = combined;
-        }
-      }
-      result ??= await stage([]);
-      signal?.throwIfAborted();
-      owned.delete(result);
-      return new _PdfObjectIndex(result, signal);
-    } catch (error) {
-      for (const source of owned) {
-        try {
-          await source.close();
-        } catch {
-        }
-      }
-      throw error;
-    } finally {
-      if (!ended) {
-        try {
-          const returning = iterator.return?.();
-          if (returning) {
-            if (signal?.aborted) void Promise.resolve(returning).catch(() => {
-            });
-            else await returning;
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  async get(objectNumber, signal) {
-    integer(objectNumber, "PDF object number");
-    this.assertOpen(signal);
-    let low = 0;
-    let high = this.size;
-    while (low < high) {
-      const middle = low + Math.floor((high - low) / 2);
-      const entry = decode(await this.source.read(middle * recordBytes, recordBytes, signal));
-      this.assertOpen(signal);
-      if (entry.objectNumber === objectNumber) return entry;
-      if (entry.objectNumber < objectNumber) low = middle + 1;
-      else high = middle;
-    }
-    return void 0;
-  }
-  assertOpen(signal) {
-    this.signal?.throwIfAborted();
-    signal?.throwIfAborted();
-    if (this.closing) throw new PdfError("E_CAPABILITY", "PDF object index is closed");
-  }
-  async *entries(signal) {
-    this.assertOpen(signal);
-    for await (const entry of records(this.source, signal)) {
-      this.assertOpen(signal);
-      yield entry;
-    }
-  }
-  close() {
-    this.closing ??= this.source.close();
-    return this.closing;
-  }
-};
-
 // packages/pdf-ast/src/cos/cross-reference.ts
 var marker = new TextEncoder().encode("startxref");
 async function header(source, signal) {
@@ -48851,6 +49158,8 @@ async function findPdfStartXref(source, options = {}) {
       if (!matched) continue;
       const lexer = new CosRangeLexer(source, {
         start: start + i + marker.length,
+        compactNumbers: options.compactNumbers ?? false,
+        compactKeywords: options.compactKeywords ?? false,
         ...options.maxTokenBytes === void 0 ? {} : { maxTokenBytes: options.maxTokenBytes },
         ...options.signal ? { signal: options.signal } : {}
       });
@@ -48992,8 +49301,23 @@ async function resolvePdfStreamDictionary(dict, lookup, active, options) {
     }
     if (node.kind === "array") {
       const items = [];
-      for (const item of node.items) items.push(await resolve2(item, depth + 1));
-      return { ...node, 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 = [];
@@ -49216,6 +49540,9 @@ var PdfObjectReader = class {
   index;
   storage;
   streams = /* @__PURE__ */ new Map();
+  // 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();
   repairedOffsets = /* @__PURE__ */ new Map();
   options;
   capacity;
@@ -49245,7 +49572,10 @@ var PdfObjectReader = class {
       const object2 = await this.load(objectNumber, generationNumber, /* @__PURE__ */ new Set());
       if (object2?.value.kind !== "dict" || !object2.stream) throw new PdfError("E_PARSE", "Expected an indexed PDF stream");
       const active = /* @__PURE__ */ new Set([objectNumber]);
-      return { object: object2, dict: await resolvePdfStreamDictionary(object2.value, (ref) => this.load(ref.objectNumber, ref.generationNumber, active), active, this.options) };
+      return { object: object2, dict: await resolvePdfStreamDictionary(object2.value, (ref) => this.load(ref.objectNumber, ref.generationNumber, active), active, { ...this.options, onBackingError: (error) => {
+        this.backingFailures.set(active, { error });
+        this.options.onBackingError?.(error);
+      } }) };
     });
     const span = object.stream;
     const input = () => this.source.stream(span.start, span.end - span.start, this.options.signal);
@@ -49253,13 +49583,17 @@ 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 = {}) {
+  async load(objectNumber, generationNumber, active, arrays = this.options.valueArrays ?? {}) {
     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");
     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);
+    const onBackingError = (error) => {
+      this.backingFailures.set(active, { error });
+      this.options.onBackingError?.(error);
+    };
     try {
       if (entry.type === "compressed") {
         const container = entry.objectStreamNumber;
@@ -49272,15 +49606,11 @@ var PdfObjectReader = class {
         if (row.number !== objectNumber) throw new PdfError("E_PARSE", "Compressed object identity does not match xref");
         const end = ordinal + 1 === stream.count ? stream.data.size : stream.first + (await this.headerRow(stream.header, ordinal + 1)).offset;
         const start = stream.first + row.offset;
-        const parsed = await parseCosRangeValue(stream.data, start, { ...this.options, ...arrays, end });
+        const parsed = await parseCosRangeValue(stream.data, start, { ...this.options, ...arrays, end, onBackingError });
         if (!parsed.value) throw new PdfError("E_PARSE", "Empty compressed object");
         return { objectNumber, generationNumber, value: parsed.value, span: { start, end: parsed.offset } };
       }
       let object;
-      let backingFailure;
-      const onBackingError = (error) => {
-        backingFailure = { error };
-      };
       try {
         object = await parseCosRangeObject(this.source, this.repairedOffsets.get(objectNumber) ?? entry.offset, {
           ...this.options,
@@ -49294,10 +49624,11 @@ var PdfObjectReader = class {
         if (object.objectNumber !== objectNumber || object.generationNumber !== generationNumber) throw new PdfError("E_PARSE", "Indirect object identity does not match xref");
       } catch (error) {
         this.options.signal?.throwIfAborted();
+        const backingFailure = this.backingFailures.get(active);
         if (backingFailure && Object.is(backingFailure.error, error)) throw error;
         if (this.options.recovery !== "repair" || !(error instanceof PdfError) || error.code !== "E_PARSE") throw error;
         let recovered;
-        for await (const event of scanCosRangeObjects(this.source, { ...this.options, ...arrays })) {
+        for await (const event of scanCosRangeObjects(this.source, { ...this.options, ...arrays, onBackingError })) {
           if (event.kind === "object" && event.object.objectNumber === objectNumber && event.object.generationNumber === generationNumber) recovered = event.object;
         }
         if (!recovered) throw error;
@@ -49363,7 +49694,10 @@ var PdfObjectReader = class {
     active.add(number);
     let dict;
     try {
-      dict = await resolvePdfStreamDictionary(object.value, (ref) => this.load(ref.objectNumber, ref.generationNumber, active), active, this.options);
+      dict = await resolvePdfStreamDictionary(object.value, (ref) => this.load(ref.objectNumber, ref.generationNumber, active), active, { ...this.options, onBackingError: (error) => {
+        this.backingFailures.set(active, { error });
+        this.options.onBackingError?.(error);
+      } });
     } finally {
       active.delete(number);
     }
@@ -49449,14 +49783,33 @@ var PdfObjectReader = class {
   }
 };
 async function openPdfObjectReader(source, storage, options = {}) {
-  const xrefOptions = { maxNodes: 65536, maxTokenBytes: 1048576, maxRecursionDepth: 100, ...options, ...options.xref };
+  let backingFailure;
+  const callerBackingError = options.onBackingError;
+  const xrefBackingError = options.xref?.onBackingError;
+  const onBackingError = (error) => {
+    backingFailure = { error };
+    callerBackingError?.(error);
+  };
+  options = { ...options, onBackingError };
+  const canRepair = (error) => !(backingFailure && Object.is(backingFailure.error, error)) && error instanceof PdfError && error.code === "E_PARSE";
+  const xrefOptions = {
+    maxNodes: 65536,
+    maxTokenBytes: 1048576,
+    maxRecursionDepth: 100,
+    ...options,
+    ...options.xref,
+    onBackingError(error) {
+      onBackingError(error);
+      if (xrefBackingError !== callerBackingError) xrefBackingError?.(error);
+    }
+  };
   let crossReference;
   let repaired = false;
   try {
     crossReference = await openPdfCrossReference(source, storage, xrefOptions);
   } catch (error) {
     options.signal?.throwIfAborted();
-    if (options.recovery !== "repair" || !(error instanceof PdfError) || error.code !== "E_PARSE") throw error;
+    if (options.recovery !== "repair" || !canRepair(error)) throw error;
     crossReference = await recoverPdfReferences(source, storage, xrefOptions);
     repaired = true;
   }
@@ -49471,7 +49824,7 @@ async function openPdfObjectReader(source, storage, options = {}) {
         const pages = root?.value.kind === "dict" && !root.stream ? dictGet(root.value, "Pages") : void 0;
         valid = pages?.kind === "ref" || pages?.kind === "dict";
       } catch (error) {
-        if (!(error instanceof PdfError) || error.code !== "E_PARSE") throw error;
+        if (!canRepair(error)) throw error;
       }
       if (!valid) {
         await reader.close();
@@ -49534,7 +49887,7 @@ async function openPdfObjectReader(source, storage, options = {}) {
           try {
             yield* currentReader.objectStreamEntries(object.objectNumber, object.generationNumber);
           } catch (error) {
-            if (!(error instanceof PdfError) || error.code !== "E_PARSE") throw error;
+            if (!canRepair(error)) throw error;
           }
         }
       }
@@ -49557,7 +49910,7 @@ async function openPdfObjectReader(source, storage, options = {}) {
           try {
             object = await reader.get(entry.objectNumber, entry.generationNumber ?? 0);
           } catch (error) {
-            if (error instanceof PdfError && error.code === "E_PARSE") continue;
+            if (canRepair(error)) continue;
             throw error;
           }
           if (object?.value.kind !== "dict") continue;
@@ -49711,7 +50064,7 @@ async function* parseContentRangeOperators(source, storage, options = {}) {
   }
   if (!Number.isSafeInteger(limits.chunkBytes) || limits.chunkBytes < 8) throw new RangeError("chunkBytes must be at least 8");
   const { signal } = options;
-  const lexer = new CosRangeLexer(source, { maxTokenBytes: limits.maxTokenBytes, knownCommands: PDF_KNOWN_COMMANDS, ...options.pathStorage ? { stringStorage: options.pathStorage } : {}, ...signal ? { signal } : {} });
+  const lexer = new CosRangeLexer(source, { compactNumbers: options.compactNumbers ?? false, compactKeywords: options.compactKeywords ?? false, maxTokenBytes: limits.maxTokenBytes, knownCommands: PDF_KNOWN_COMMANDS, ...options.pathStorage ? { stringStorage: options.pathStorage } : {}, ...signal ? { signal } : {} });
   const stack = new PdfOperandStack(storage, limits);
   const backedStack = options.pathStorage ? new StoredMetadataStack(options.pathStorage, signal) : void 0;
   const operands = backedStack ?? stack;
@@ -54597,7 +54950,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 ? { 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"], 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");
@@ -54606,6 +54959,9 @@ async function resolveRetainedFont(document2, storage, resources, name, options
           identities.set(stream, retained.reference);
           value = stream;
         }
+      } else if (step.value.kind === "dictionary-entry") {
+        const record = await readStoredRecord(step.value.entries.storage, step.value.position, signal);
+        value = cosArray([record.value.key, record.value.value, cosNumber(record.next)]);
       } else if (step.value.kind === "font-encoding") {
         const array = step.value.array;
         value = await StoredFontEncoding.create(() => array.storedItems ? readStoredItems(array.storedItems, signal) : array.items, options.resourceStorage, { onAllocation: (bytes) => allocation.admit(bytes), ...signal ? { signal } : {} });
@@ -57151,122 +57507,6 @@ function resolveDestinationPageIndex(doc, destOrActionNode) {
   return void 0;
 }
 
-// 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";
 
@@ -59009,6 +59249,7 @@ async function prepareRetainedPageContent(document2, page2, pageResources, stora
         const request = step.value;
         let result;
         if (request.kind === "resolve" || request.kind === "catalog") result = await resolve2(request.kind === "catalog" ? document2.crossReference.rootRef : request.node, request.kind === "resolve" ? request.arrayPathPrefix : void 0);
+        else if (request.kind === "dictionary-merge") result = await mergePdfResourceDictionaries(request.destination, request.source, storage, options.signal);
         else if (request.kind === "array-reference") result = cosBool(await memberships.has(request.items, request.objectNumber));
         else if (request.kind === "array-item") {
           const record = await readStoredRecord(request.items.storage, request.position, options.signal);
@@ -60165,6 +60406,7 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
     if (arrayPathPrefix) arrays = {
       ...arrays,
       arrayPathPrefix,
+      ...arrayPathPrefix.length && arrays.storedDictionaryKeys?.includes(arrayPathPrefix[arrayPathPrefix.length - 1]) ? { storeRootDictionary: true } : {},
       ...arrayPathPrefix.length && arrays.storedArrayKeys?.includes(arrayPathPrefix[arrayPathPrefix.length - 1]) ? { storeRootArray: true } : {},
       ...arrayPathPrefix.length && arrays.storedStringKeys?.includes(arrayPathPrefix[arrayPathPrefix.length - 1]) ? { storeRootString: true } : {}
     };
@@ -61688,6 +61930,26 @@ async function* retainedCosObjects(document2, storage, options = {}) {
       yield identity;
       continue;
     }
+    if (options.streamMode && options.streamMode !== "preserve" && object.value.kind === "dict") {
+      const activeSignal = signal ?? new AbortController().signal;
+      const input = document2.objects.decodeStream(entry.objectNumber, generationNumber);
+      const staged2 = options.streamMode === "compress" ? await stageDeflatedPdf(input, storage, activeSignal, maxStreamBytes) : await PdfFileSource.fromStream(storage.fs, storage.directory, input, { signal: activeSignal, maxInputBytes: maxStreamBytes });
+      let failed2 = false;
+      try {
+        const value = { ...object.value, entries: object.value.entries.filter((item) => item.key.decoded !== "Filter" && item.key.decoded !== "DecodeParms") };
+        if (options.streamMode === "compress") dictSet(value, "Filter", cosName("FlateDecode"));
+        dictSet(value, "Length", cosNumber(staged2.size));
+        yield { ...identity, value, stream: { decoded: true, length: staged2.size, chunks: staged2.stream(0, staged2.size, activeSignal) } };
+      } catch (error) {
+        failed2 = true;
+        throw error;
+      } finally {
+        await staged2.close().catch((error) => {
+          if (!failed2) throw error;
+        });
+      }
+      continue;
+    }
     if (options.normalizeContent && object.decoded && object.value.kind === "dict") {
       const decoded2 = await PdfFileSource.fromStream(storage.fs, storage.directory, document2.objects.decodeStream(entry.objectNumber, generationNumber), { ...signal ? { signal } : {}, maxInputBytes: maxStreamBytes });
       let failed2 = false;
@@ -61906,7 +62168,7 @@ async function* saveRetainedDocumentChunks(document2, storage, options = {}) {
     }
   }
   try {
-    for await (const object of retainedCosObjects(document2, storage, { ...options.normalizeContent ? { normalizeContent: true } : {}, ...options.maxObjects === void 0 ? {} : { maxObjects: options.maxObjects }, ...options.maxOutputBytes === void 0 ? {} : { maxStreamBytes: options.maxOutputBytes }, signal })) {
+    for await (const object of retainedCosObjects(document2, storage, { ...options.streamMode ? { streamMode: options.streamMode } : {}, ...options.normalizeContent ? { normalizeContent: true } : {}, ...options.maxObjects === void 0 ? {} : { maxObjects: options.maxObjects }, ...options.maxOutputBytes === void 0 ? {} : { maxStreamBytes: options.maxOutputBytes }, signal })) {
       if (!object.stream && object.value.kind === "dict" && dictGet(object.value, "Linearized") !== void 0) mayLinearize = true;
       await objects.set(object);
     }
@@ -62018,8 +62280,208 @@ async function* saveRetainedDocumentChunks(document2, storage, options = {}) {
   }
 }
 
+// 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) {
+  if (!pageCount) return;
+  const catalog = await store.get(root.objectNumber);
+  if (catalog?.value.kind !== "dict") return;
+  const frames = new PagedStorage13({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const base = frames.allocate(0);
+  let depth = 0, capacity = 0, failed = false, work = 0;
+  async function write(index2, frame) {
+    if (index2 >= capacity) {
+      frames.allocate(24);
+      capacity++;
+    }
+    const bytes = new Uint8Array(24), view = new DataView(bytes.buffer);
+    view.setFloat64(0, frame.number);
+    view.setFloat64(8, frame.last);
+    view.setFloat64(16, frame.count);
+    await frames.write(base + index2 * 24, bytes);
+  }
+  async function read(index2) {
+    const bytes = await frames.read(base + index2 * 24, 24), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+    return { number: view.getFloat64(0), last: view.getFloat64(8), count: view.getFloat64(16) };
+  }
+  try {
+    for await (const bookmark of bookmarks) {
+      signal.throwIfAborted();
+      if (++work % 64 === 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, 0));
+        signal.throwIfAborted();
+      }
+      if (!Number.isSafeInteger(bookmark.level) || !Number.isSafeInteger(bookmark.pageNumber)) throw new RangeError("Bookmark level and page number must be safe integers");
+      if (!depth) {
+        const outlines = await store.allocate(cosDict({ Type: cosName("Outlines") }));
+        dictSet(catalog.value, "Outlines", outlines);
+        await store.set(catalog);
+        await write(0, { number: outlines.objectNumber, last: 0, count: 0 });
+        depth = 1;
+      }
+      const target = Math.max(1, bookmark.level);
+      depth = Math.min(depth, target);
+      while (depth < target) {
+        const parent2 = await read(depth - 1);
+        if (!parent2.last) break;
+        if (depth >= maxDepth) throw new PdfError("E_LIMIT", "PDF bookmark depth limit exceeded");
+        await write(depth, { number: parent2.last, last: 0, count: 0 });
+        depth++;
+      }
+      const frame = await read(depth - 1), parent = await store.get(frame.number);
+      if (parent.value.kind !== "dict") throw new PdfError("E_PARSE", "Expected outline parent dictionary");
+      const page2 = await pageReference(Math.max(0, Math.min(pageCount - 1, bookmark.pageNumber - 1)));
+      const value = cosDict({ Title: cosString(bookmark.title), Parent: cosRef(frame.number), Dest: cosArray([page2, cosName("XYZ"), { kind: "null" }, { kind: "null" }, { kind: "null" }]) });
+      const item = await store.allocate(value);
+      if (frame.last) {
+        const previous = await store.get(frame.last);
+        if (previous.value.kind !== "dict") throw new PdfError("E_PARSE", "Expected outline sibling dictionary");
+        dictSet(previous.value, "Next", item);
+        await store.set(previous);
+        dictSet(value, "Prev", cosRef(frame.last));
+        await store.set({ objectNumber: item.objectNumber, generationNumber: item.generationNumber, value });
+      } else dictSet(parent.value, "First", item);
+      dictSet(parent.value, "Last", item);
+      dictSet(parent.value, "Count", cosNumber(++frame.count));
+      await store.set(parent);
+      frame.last = item.objectNumber;
+      await write(depth - 1, frame);
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await frames.close().catch((error) => {
+      if (!failed) throw error;
+    });
+  }
+}
+
+// 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 });
+  let failed = false, count = 0;
+  async function resolve2(node) {
+    const found = await document2.lookup(node);
+    return found?.stream ? void 0 : found;
+  }
+  async function save(reference, value) {
+    await target.set({ objectNumber: reference.objectNumber, generationNumber: reference.generationNumber, value });
+  }
+  try {
+    const root = await resolve2(document2.crossReference.rootRef);
+    if (root?.value.kind !== "dict" || !root.reference) return;
+    let owner = root;
+    let names = await resolve2(dictGet(root.value, "Names"));
+    if (names?.value.kind !== "dict") {
+      const value = cosDict({}), reference = await target.allocate(value);
+      names = { value, reference };
+      dictSet(root.value, "Names", reference);
+      await save(root.reference, root.value);
+    }
+    if (names.value.kind !== "dict") throw new Error("Invalid attachment names");
+    if (names.reference) owner = names;
+    let tree = await resolve2(dictGet(names.value, "EmbeddedFiles"));
+    if (tree?.value.kind !== "dict") {
+      const value = cosDict({ Names: cosArray([]) }), reference = await target.allocate(value);
+      tree = { value, reference };
+      dictSet(names.value, "EmbeddedFiles", reference);
+      await save(owner.reference, owner.value);
+    }
+    if (tree.value.kind !== "dict") throw new Error("Invalid attachment tree");
+    if (tree.reference) owner = tree;
+    const existing = await resolve2(dictGet(tree.value, "Names")), namesMarker = cosArray([]);
+    if (existing?.value.kind === "array" && existing.reference) owner = { value: namesMarker, reference: existing.reference };
+    else dictSet(tree.value, "Names", namesMarker);
+    let pageOwner, previousAnnots;
+    const annotsMarker = cosArray([]);
+    if (options.pageIndex !== void 0) for await (const page2 of document2.pages()) {
+      if (page2.index !== options.pageIndex) continue;
+      if (page2.reference) {
+        const annots = await resolve2(dictGet(page2.dict, "Annots"));
+        previousAnnots = annots?.value.kind === "array" ? annots.value : void 0;
+        if (annots?.value.kind === "array" && annots.reference) pageOwner = { value: annotsMarker, reference: annots.reference };
+        else {
+          dictSet(page2.dict, "Annots", annotsMarker);
+          pageOwner = { value: page2.dict, reference: page2.reference };
+        }
+      }
+      break;
+    }
+    for await (const attachment of attachments) {
+      signal.throwIfAborted();
+      const compressed = await stageDeflatedPdf(attachment.chunks, storage, signal);
+      let itemFailed = false;
+      try {
+        const embedded = await target.allocate();
+        await target.set({ objectNumber: embedded.objectNumber, generationNumber: 0, value: cosDict({ Type: cosName("EmbeddedFile"), Filter: cosName("FlateDecode"), Length: cosNumber(compressed.size) }), stream: { decoded: true, length: compressed.size, chunks: compressed.stream(0, compressed.size, signal) } });
+        const reference = await target.allocate(cosDict({ Type: cosName("Filespec"), F: cosString(attachment.filename), UF: cosString(attachment.filename), EF: cosDict({ F: embedded }) }));
+        let annotation;
+        if (pageOwner) annotation = await target.allocate(cosDict({ Type: cosName("Annot"), Subtype: cosName("FileAttachment"), Name: cosName("PushPin"), Contents: cosString(attachment.filename), FS: reference, Rect: cosArray([20, 20, 40, 40].map((value) => cosNumber(value))) }));
+        await appended.set({ objectNumber: ++count, generationNumber: 0, value: cosArray([cosString(attachment.filename), reference, ...annotation ? [annotation] : []]) });
+      } catch (error) {
+        itemFailed = true;
+        throw error;
+      } finally {
+        await compressed.close().catch((error) => {
+          if (!itemFailed) throw error;
+        });
+      }
+    }
+    const encoder = new TextEncoder();
+    async function* serialized(node) {
+      signal.throwIfAborted();
+      if (node === namesMarker || node === annotsMarker) {
+        yield encoder.encode("[ ");
+        const old = node === namesMarker ? existing?.value : previousAnnots;
+        if (old?.kind === "array") for (const item of old.items) {
+          yield* serializeCosNodeChunks(item, { signal });
+          yield encoder.encode(" ");
+        }
+        for await (const pair of appended.objects()) {
+          if (pair.value.kind !== "array") throw new Error("Invalid attachment pair");
+          const items = node === namesMarker ? pair.value.items.slice(0, 2) : pair.value.items.slice(2);
+          for (const item of items) {
+            yield* serializeCosNodeChunks(item, { signal });
+            yield encoder.encode(" ");
+          }
+        }
+        yield encoder.encode("]");
+      } else if (node.kind === "dict") {
+        yield encoder.encode("<<\n");
+        for (const entry of node.entries) {
+          yield* serializeCosNodeChunks(entry.key, { signal });
+          yield encoder.encode(" ");
+          yield* serialized(entry.value);
+          yield encoder.encode("\n");
+        }
+        yield encoder.encode(">>");
+      } else if (node.kind === "array") {
+        yield encoder.encode("[ ");
+        for (const item of node.items) {
+          yield* serialized(item);
+          yield encoder.encode(" ");
+        }
+        yield encoder.encode("]");
+      } else yield* serializeCosNodeChunks(node, { signal });
+    }
+    for (const edited of [owner, ...pageOwner && count ? [pageOwner] : []]) {
+      let length = 0;
+      for await (const bytes of serialized(edited.value)) length += bytes.length;
+      await target.setSerializedValue({ objectNumber: edited.reference.objectNumber, generationNumber: edited.reference.generationNumber, body: { length, chunks: serialized(edited.value) } });
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await appended.close().catch((error) => {
+      if (!failed) throw error;
+    });
+  }
+}
+
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
-import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/form-appearance-chunks.ts
 function* serializeFormAppearanceChunks(text, options) {
@@ -62107,7 +62569,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 IntegerTable8(backing);
+  const backing = new PagedStorage14({ 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) {
@@ -62314,16 +62776,16 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
 }
 
 // packages/pdf-ast/src/edit/retained-flatten-annotations.ts
-import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/retained-content-edit.ts
-import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage15 } 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.backing = new PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
     this.counts = new IntegerTable9(this.backing);
     this.identities = new PdfNameIndex(storage, Infinity, signal);
   }
@@ -62364,6 +62826,12 @@ var RetainedContentEditor = class _RetainedContentEditor {
     await this.count(value, 1n);
     await this.store.set({ objectNumber: reference.objectNumber, generationNumber: reference.generationNumber, value, ...stream ? { stream } : {} });
   }
+  async setSerialized(reference, body, values) {
+    const old = await this.store.get(reference.objectNumber);
+    if (old) await this.count(old.value, -1n);
+    for await (const node of values) await this.count(node, 1n);
+    await this.store.setSerializedValue({ objectNumber: reference.objectNumber, generationNumber: reference.generationNumber, body });
+  }
   async replace(page2, chunks, compress = true) {
     const source = compress ? await stageDeflatedPdf(chunks, this.storage, this.signal) : await PdfFileSource.fromStream(this.storage.fs, this.storage.directory, chunks, { signal: this.signal });
     let failed = false;
@@ -62389,14 +62857,14 @@ var RetainedContentEditor = class _RetainedContentEditor {
 };
 
 // packages/pdf-ast/src/edit/retained-name-replacement.ts
-import { PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage16 } 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 PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), length = oldName.length + 1;
+  const table = new PagedStorage16({ 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;
@@ -62474,10 +62942,10 @@ async function* replaceRetainedPdfName(input, oldName, newName, storage, options
 }
 
 // packages/pdf-ast/src/edit/retained-draw-text.ts
-import { PagedStorage as PagedStorage16 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage17 } 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 PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const backing = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   let failed = false;
   try {
     const name = await font(), position = backing.allocate(text.length);
@@ -62553,7 +63021,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 PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+      const survivorStorage = new PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
       const survivorBase = survivorStorage.allocate(0);
       let pageFailed = false;
       try {
@@ -62639,7 +63107,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 IntegerTable10(backing), names = new PdfNameIndex(storage, Infinity, signal);
+            const backing = new PagedStorage18({ 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) {
@@ -62757,8 +63225,294 @@ 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";
+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 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);
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 16384 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+  }
+  async function get(at) {
+    const bytes = await trie.read(at, 40);
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+  }
+  async function put(at, row) {
+    await trie.write(at, new Uint8Array(row.buffer, row.byteOffset, row.byteLength));
+  }
+  async function child(at, byte3, create) {
+    const parent = await get(at);
+    let current = parent.getFloat64(0);
+    while (current) {
+      const row2 = await get(current);
+      if (row2.getFloat64(16) === byte3) return current;
+      current = row2.getFloat64(8);
+    }
+    if (!create) return;
+    const next = trie.allocate(40), row = new DataView(new ArrayBuffer(40));
+    row.setFloat64(8, parent.getFloat64(0));
+    row.setFloat64(16, byte3);
+    await put(next, row);
+    parent.setFloat64(0, next);
+    await put(at, parent);
+    return next;
+  }
+  function emit(byte3) {
+    output[used++] = byte3;
+    if (used === size) {
+      const full = output;
+      output = new Uint8Array(size);
+      used = 0;
+      return full;
+    }
+  }
+  async function* replay(store, start, length) {
+    for (let at = 0; at < length; at += size) for (const byte3 of await store.read(start + at, Math.min(size, length - at))) {
+      await checkpoint();
+      const full = emit(byte3);
+      if (full) yield full;
+    }
+  }
+  try {
+    for await (const [name, replacement] of names) {
+      let node2 = root, valid = true;
+      for (let i = 0; i < name.length; i++) {
+        await checkpoint();
+        if (!body(name.charCodeAt(i))) {
+          valid = false;
+          break;
+        }
+        node2 = await child(node2, name.charCodeAt(i), true);
+      }
+      if (!valid) continue;
+      const start = trie.allocate(replacement.length), row = await get(node2);
+      row.setFloat64(24, start + 1);
+      row.setFloat64(32, replacement.length);
+      await put(node2, row);
+      for (let at = 0; at < replacement.length; at += size) {
+        const bytes = new Uint8Array(Math.min(size, replacement.length - at));
+        for (let i = 0; i < bytes.length; i++) bytes[i] = replacement.charCodeAt(at + i);
+        await trie.write(start + at, bytes);
+      }
+    }
+    let matching = false, node = root, length = 0, capacity = 0, buffered = 0;
+    const prefix = new Uint8Array(size);
+    async function flushPrefix() {
+      if (buffered) {
+        if (length > capacity) {
+          pending.allocate(length - capacity);
+          capacity = length;
+        }
+        await pending.write(prefixBase + length - buffered, prefix.subarray(0, buffered));
+        buffered = 0;
+      }
+    }
+    async function* finish() {
+      await flushPrefix();
+      const row = await get(node), replacement = row.getFloat64(24);
+      const slash = emit(47);
+      if (slash) yield slash;
+      if (replacement) yield* replay(trie, replacement - 1, row.getFloat64(32));
+      else yield* replay(pending, prefixBase, length);
+      matching = false;
+    }
+    for await (const bytes of input) for (const byte3 of bytes) {
+      await checkpoint();
+      if (matching && body(byte3)) {
+        const next = await child(node, byte3, false);
+        if (next !== void 0) {
+          node = next;
+          prefix[buffered++] = byte3;
+          length++;
+          if (buffered === size) await flushPrefix();
+          continue;
+        }
+        await flushPrefix();
+        const slash = emit(47);
+        if (slash) yield slash;
+        yield* replay(pending, prefixBase, length);
+        matching = false;
+      } else if (matching) yield* finish();
+      if (byte3 === 47) {
+        matching = true;
+        node = root;
+        length = 0;
+        buffered = 0;
+      } else {
+        const full = emit(byte3);
+        if (full) yield full;
+      }
+    }
+    if (matching) yield* finish();
+    if (used) yield output.subarray(0, used);
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([trie.close(), pending.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/pdf-ast/src/edit/retained-preserve-stamp.ts
+async function preserveRetainedStamp(document2, source, page2, other, store, editor, storage, clone, mode, signal) {
+  const renames = new PdfMutableObjectStore(storage, { signal }), additions = new PdfMutableObjectStore(storage, { signal });
+  let addedCount = 0, count = 0, failed = false, work = 0;
+  const owners = /* @__PURE__ */ new Map();
+  const key = (ref) => `${ref.objectNumber}:${ref.generationNumber}`;
+  if (page2.reference) owners.set(key(page2.reference), { reference: page2.reference, value: page2.dict });
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+  }
+  async function dictionary(node) {
+    const cached = node?.kind === "ref" ? owners.get(key(node)) : void 0;
+    if (cached) return cached;
+    const found = await document2.lookup(node);
+    if (found?.stream || found?.value.kind !== "dict") return;
+    const result = { ...found, value: found.value };
+    if (result.reference) owners.set(key(result.reference), { reference: result.reference, value: result.value });
+    return result;
+  }
+  async function stream(chunks) {
+    const staged = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks, { signal });
+    let failed2 = false;
+    try {
+      const reference = await store.allocate();
+      await editor.set(reference, cosDict({ Length: cosNumber(staged.size) }), { decoded: true, length: staged.size, chunks: staged.stream(0, staged.size, signal) });
+      return reference;
+    } catch (error) {
+      failed2 = true;
+      throw error;
+    } finally {
+      await staged.close().catch((error) => {
+        if (!failed2) throw error;
+      });
+    }
+  }
+  async function* mappings() {
+    for await (const object of renames.objects()) if (object.value.kind === "array" && object.value.items[0]?.kind === "string" && object.value.items[1]?.kind === "string") {
+      const [name, replacement] = object.value.items;
+      yield [decodePdfString(name), decodePdfString(replacement)];
+    }
+  }
+  try {
+    const dstAttributes = await page2.attributes(), srcAttributes = await other.attributes();
+    let resources = await dictionary(dictGet(page2.dict, "Resources"));
+    if (!resources) {
+      const entries = [];
+      for (const entry of dstAttributes.resources.entries) {
+        const sub = await document2.lookup(entry.value);
+        entries.push({ key: { ...entry.key }, value: sub?.value.kind === "dict" && !sub.stream ? cosDict(Object.fromEntries(sub.value.entries.map((item) => [item.key.decoded, item.value]))) : entry.value });
+      }
+      resources = { value: { kind: "dict", entries } };
+      dictSet(page2.dict, "Resources", resources.value);
+    }
+    for (const category of ["Font", "XObject", "ExtGState", "ColorSpace", "Pattern", "Shading", "Properties"]) {
+      const src = await source.lookup(dictGet(srcAttributes.resources, category));
+      if (src?.stream || src?.value.kind !== "dict") continue;
+      let dst = await dictionary(dictGet(resources.value, category));
+      if (!dst) {
+        dst = { value: cosDict({}) };
+        dictSet(resources.value, category, dst.value);
+      }
+      for (const entry of src.value.entries) {
+        await checkpoint();
+        const value = await clone(entry.value), original = entry.key.decoded;
+        let name = original;
+        if (dictGet(dst.value, original)) {
+          name = `Ov_${page2.index}_${original}`;
+          let suffix = 1;
+          while (dictGet(dst.value, name)) {
+            await checkpoint();
+            name = `Ov_${page2.index}_${suffix++}_${original}`;
+          }
+          await renames.set({ objectNumber: ++count, generationNumber: 0, value: cosArray([cosString(original), cosString(name)]) });
+        }
+        dictSet(dst.value, name, value);
+      }
+    }
+    for (const owner of owners.values()) await editor.set(owner.reference, owner.value);
+    const contents = dictGet(other.dict, "Contents");
+    if (!contents) return;
+    const resolved = await source.lookup(contents), nodes = resolved?.value.kind === "array" && !resolved.stream ? resolved.value.items : [contents];
+    for (const node of nodes) {
+      await checkpoint();
+      const found = await source.lookup(node);
+      const added = found?.stream && found.reference && count ? await stream(replaceRetainedPdfNames(source.objects.decodeStream(found.reference.objectNumber, found.reference.generationNumber), mappings(), storage, { signal })) : await clone(node);
+      await additions.set({ objectNumber: ++addedCount, generationNumber: 0, value: added });
+    }
+    if (!addedCount) return;
+    const previous = dictGet(page2.dict, "Contents"), resolvedPrevious = previous && await document2.lookup(previous);
+    const before = resolvedPrevious?.value.kind === "array" && !resolvedPrevious.stream ? resolvedPrevious.value.items : previous ? [previous] : [];
+    const encoder = new TextEncoder();
+    async function* text(value) {
+      yield encoder.encode(value);
+    }
+    const openTarget = await stream(text("q\n")), openSource = await stream(text(retainedStampTransform(dstAttributes, srcAttributes))), close = await stream(text("\nQ\n"));
+    const marker2 = cosArray([]);
+    dictSet(page2.dict, "Contents", marker2);
+    async function* contentNodes() {
+      for (const overlay of mode === "underlay" ? [true, false] : [false, true]) {
+        yield overlay ? openSource : openTarget;
+        if (overlay) {
+          for await (const object of additions.objects()) {
+            await checkpoint();
+            yield object.value;
+          }
+        } else for (const node of before) {
+          await checkpoint();
+          yield node;
+        }
+        yield close;
+      }
+    }
+    async function* body() {
+      yield encoder.encode("<<\n");
+      for (const entry of page2.dict.entries) {
+        yield* serializeCosNodeChunks(entry.key, { signal });
+        yield encoder.encode(" ");
+        if (entry.value === marker2) {
+          yield encoder.encode("[ ");
+          for await (const node of contentNodes()) {
+            yield* serializeCosNodeChunks(node, { signal });
+            yield encoder.encode(" ");
+          }
+          yield encoder.encode("]");
+        } else yield* serializeCosNodeChunks(entry.value, { signal });
+        yield encoder.encode("\n");
+      }
+      yield encoder.encode(">>");
+    }
+    async function* values() {
+      yield page2.dict;
+      yield* contentNodes();
+    }
+    if (page2.reference) {
+      let length = 0;
+      for await (const bytes of body()) length += bytes.length;
+      await editor.setSerialized(page2.reference, { length, chunks: body() }, values());
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([renames.close(), additions.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
 // packages/pdf-ast/src/edit/retained-stamps.ts
-import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage20 } 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;
@@ -62769,7 +63523,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 IntegerTable11(backing);
+      const backing = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable11(backing);
       let stampFailed = false;
       async function clone(node, depth = 0) {
         await checkpoint();
@@ -62779,7 +63533,12 @@ async function stampRetainedPages(document2, store, storage, getPage, stamps, si
           if (found !== void 0) return cosRef(Number(found));
           const identity = await source.document.crossReference.index.get(node.objectNumber, signal);
           const object = identity ? await source.document.objects.get(node.objectNumber, identity.generationNumber ?? 0) : void 0;
-          if (!object) return { kind: "null" };
+          if (!object) {
+            if (!stamp.preserveStreams) return { kind: "null" };
+            const reference2 = await store.allocate(cosDict({}));
+            await memo.set(BigInt(node.objectNumber), BigInt(reference2.objectNumber));
+            return reference2;
+          }
           const reference = await store.allocate({ kind: "null" });
           await memo.set(BigInt(node.objectNumber), BigInt(reference.objectNumber));
           const value = await clone(object.value, depth + 1);
@@ -62798,6 +63557,11 @@ async function stampRetainedPages(document2, store, storage, getPage, stamps, si
         if (node.kind === "dict") {
           const entries = [];
           for (const entry of node.entries) if (entry.key.decoded !== "Parent") entries.push({ key: { ...entry.key }, value: await clone(entry.value, depth + 1) });
+          if (stamp.preserveStreams) {
+            const dict = cosDict({});
+            for (const entry of entries) dictSet(dict, entry.key.decoded, entry.value);
+            return dict;
+          }
           return { kind: "dict", entries };
         }
         return node;
@@ -62806,6 +63570,10 @@ async function stampRetainedPages(document2, store, storage, getPage, stamps, si
         for await (const pair of stamp.pages) {
           await checkpoint();
           const page2 = await getPage(pair.targetIndex), other = await source.getPage(pair.sourceIndex);
+          if (stamp.preserveStreams) {
+            await preserveRetainedStamp(document2, source.document, page2, other, store, editor, storage, clone, stamp.mode, signal);
+            continue;
+          }
           const target = await PdfFileSource.fromStream(storage.fs, storage.directory, page2.streamContents(), { signal });
           let content, pageFailed = false;
           try {
@@ -62859,43 +63627,7 @@ async function stampRetainedPages(document2, store, storage, getPage, stamps, si
               }
             }
             for (const owner of owners.values()) await editor.set(owner.reference, owner.value);
-            const dstSize = { width: Math.abs(dstAttributes.mediaBox[2] - dstAttributes.mediaBox[0]), height: Math.abs(dstAttributes.mediaBox[3] - dstAttributes.mediaBox[1]) };
-            const srcSize = { width: Math.abs(srcAttributes.mediaBox[2] - srcAttributes.mediaBox[0]), height: Math.abs(srcAttributes.mediaBox[3] - srcAttributes.mediaBox[1]) };
-            const rotDiff = ((dstAttributes.rotation - srcAttributes.rotation) % 360 + 360) % 360;
-            let stampOpenStr = "q\n";
-            if (srcSize.width > 0 && srcSize.height > 0) {
-              const fmt6 = (n) => Number(n.toFixed(6));
-              const fmt4 = (n) => Number(n.toFixed(4));
-              if (rotDiff === 90) {
-                const s = Math.min(dstSize.height / srcSize.width, dstSize.width / srcSize.height);
-                const ox = (dstSize.height - srcSize.width * s) / 2;
-                const oy = (dstSize.width - srcSize.height * s) / 2;
-                stampOpenStr = `q
-0 ${fmt6(s)} ${fmt6(-s)} 0 ${fmt4(dstSize.width - oy)} ${fmt4(ox)} cm
-`;
-              } else if (rotDiff === 180) {
-                const s = Math.min(dstSize.width / srcSize.width, dstSize.height / srcSize.height);
-                const ox = (dstSize.width - srcSize.width * s) / 2;
-                const oy = (dstSize.height - srcSize.height * s) / 2;
-                stampOpenStr = `q
-${fmt6(-s)} 0 0 ${fmt6(-s)} ${fmt4(dstSize.width - ox)} ${fmt4(dstSize.height - oy)} cm
-`;
-              } else if (rotDiff === 270) {
-                const s = Math.min(dstSize.height / srcSize.width, dstSize.width / srcSize.height);
-                const ox = (dstSize.height - srcSize.width * s) / 2;
-                const oy = (dstSize.width - srcSize.height * s) / 2;
-                stampOpenStr = `q
-0 ${fmt6(-s)} ${fmt6(s)} 0 ${fmt4(oy)} ${fmt4(dstSize.height - ox)} cm
-`;
-              } else if (Math.abs(srcSize.width - dstSize.width) > 0.5 || Math.abs(srcSize.height - dstSize.height) > 0.5) {
-                const s = Math.min(dstSize.width / srcSize.width, dstSize.height / srcSize.height);
-                const tx = (dstSize.width - srcSize.width * s) / 2;
-                const ty = (dstSize.height - srcSize.height * s) / 2;
-                stampOpenStr = `q
-${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
-`;
-              }
-            }
+            const stampOpenStr = retainedStampTransform(dstAttributes, srcAttributes);
             const encoder = new TextEncoder(), stamped = content;
             async function* contents() {
               for (const isStamp of stamp.mode === "underlay" ? [true, false] : [false, true]) {
@@ -62935,14 +63667,54 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
     });
   }
 }
+function retainedStampTransform(dstAttributes, srcAttributes) {
+  const dstSize = { width: Math.abs(dstAttributes.mediaBox[2] - dstAttributes.mediaBox[0]), height: Math.abs(dstAttributes.mediaBox[3] - dstAttributes.mediaBox[1]) };
+  const srcSize = { width: Math.abs(srcAttributes.mediaBox[2] - srcAttributes.mediaBox[0]), height: Math.abs(srcAttributes.mediaBox[3] - srcAttributes.mediaBox[1]) };
+  const rotDiff = ((dstAttributes.rotation - srcAttributes.rotation) % 360 + 360) % 360;
+  let stampOpenStr = "q\n";
+  if (srcSize.width > 0 && srcSize.height > 0) {
+    const fmt6 = (n) => Number(n.toFixed(6));
+    const fmt4 = (n) => Number(n.toFixed(4));
+    if (rotDiff === 90) {
+      const s = Math.min(dstSize.height / srcSize.width, dstSize.width / srcSize.height);
+      const ox = (dstSize.height - srcSize.width * s) / 2;
+      const oy = (dstSize.width - srcSize.height * s) / 2;
+      stampOpenStr = `q
+0 ${fmt6(s)} ${fmt6(-s)} 0 ${fmt4(dstSize.width - oy)} ${fmt4(ox)} cm
+`;
+    } else if (rotDiff === 180) {
+      const s = Math.min(dstSize.width / srcSize.width, dstSize.height / srcSize.height);
+      const ox = (dstSize.width - srcSize.width * s) / 2;
+      const oy = (dstSize.height - srcSize.height * s) / 2;
+      stampOpenStr = `q
+${fmt6(-s)} 0 0 ${fmt6(-s)} ${fmt4(dstSize.width - ox)} ${fmt4(dstSize.height - oy)} cm
+`;
+    } else if (rotDiff === 270) {
+      const s = Math.min(dstSize.height / srcSize.width, dstSize.width / srcSize.height);
+      const ox = (dstSize.height - srcSize.width * s) / 2;
+      const oy = (dstSize.width - srcSize.height * s) / 2;
+      stampOpenStr = `q
+0 ${fmt6(-s)} ${fmt6(s)} 0 ${fmt4(oy)} ${fmt4(dstSize.height - ox)} cm
+`;
+    } else if (Math.abs(srcSize.width - dstSize.width) > 0.5 || Math.abs(srcSize.height - dstSize.height) > 0.5) {
+      const s = Math.min(dstSize.width / srcSize.width, dstSize.height / srcSize.height);
+      const tx = (dstSize.width - srcSize.width * s) / 2;
+      const ty = (dstSize.height - srcSize.height * s) / 2;
+      stampOpenStr = `q
+${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
+`;
+    }
+  }
+  return stampOpenStr;
+}
 
 // packages/pdf-ast/src/edit/retained-inline-images.ts
-import { PagedStorage as PagedStorage19 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage21 } 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 PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const paths = new PagedStorage21({ 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" };
@@ -63034,7 +63806,7 @@ async function externalizeRetainedInlineImages(document2, store, storage, option
 }
 
 // packages/pdf-ast/src/edit/retained-resource-pruning.ts
-import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage22 } 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;
@@ -63116,7 +63888,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 IntegerTable12(backing);
+    const backing = new PagedStorage22({ 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;
@@ -63246,7 +64018,7 @@ async function flattenRetainedRotations(document2, store, storage, signal) {
 }
 
 // packages/pdf-ast/src/edit/retained-attachment-edits.ts
-import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage21 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
 var PdfDuplicateAttachment = class extends PdfError {
   constructor(key) {
     super("E_CAPABILITY", `Duplicate attachment key: ${key}`);
@@ -63257,7 +64029,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 IntegerTable13(backing), removals = new IntegerTable13(backing);
+  const backing = new PagedStorage23({ 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();
@@ -63459,13 +64231,13 @@ async function* retainedAttachmentNameTokens(document2, storage, root, signal, r
 }
 
 // packages/pdf-ast/src/edit/retained-graph.ts
-import { PagedStorage as PagedStorage22 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage24 } 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 PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const pages = new PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const base = pages.allocate(0);
   let count = 0, document2;
   let closing;
@@ -63572,6 +64344,10 @@ async function editRetainedDocument(source, storage, options = {}) {
         }
       }
     } else if (options.removePageLabels) await removeRoot(["PageLabels"]);
+    if (options.bookmarks) {
+      await setRetainedBookmarks(store, storage, source.crossReference.rootRef, count, reference, options.bookmarks, signal, options.maxRecursionDepth);
+      addedObjects = true;
+    }
     if (options.generateAppearances && !options.removeAcroform) {
       await generateRetainedFormAppearances(document2, store, storage, signal);
       addedObjects = true;
@@ -63617,6 +64393,15 @@ async function editRetainedDocument(source, storage, options = {}) {
       await editRetainedAttachments(document2, store, storage, options.removeAttachments ?? [], options.attachments ?? [], signal);
       addedObjects = true;
     }
+    if (options.appendAttachments) {
+      if (options.attachmentPageIndex !== void 0 && (!Number.isSafeInteger(options.attachmentPageIndex) || options.attachmentPageIndex < 0 || options.attachmentPageIndex >= count)) throw new RangeError("Attachment page index out of bounds");
+      if (addedObjects) {
+        await document2.close();
+        document2 = await PdfRetainedDocument.openStore(store, storage, { ...configured, ...infoRef ? { infoRef } : {} });
+      }
+      await appendRetainedAttachments(document2, store, storage, options.appendAttachments, { signal, ...options.attachmentPageIndex !== void 0 ? { pageIndex: options.attachmentPageIndex } : {} });
+      addedObjects = true;
+    }
     if (addedObjects || infoRef !== source.crossReference.infoRef) {
       await document2.close();
       document2 = await PdfRetainedDocument.openStore(store, storage, { ...configured, ...infoRef ? { infoRef } : {} });
@@ -63674,9 +64459,9 @@ async function* copyRetainedAttachments(document2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/retained-object-order.ts
-import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage25 } 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 backing = new PagedStorage25({ 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) {
@@ -63813,12 +64598,12 @@ async function* encryptRetainedPdfChunks(source, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/qpdf-json-values.ts
-import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage26 } 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.scratch = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
     this.first = new IntegerTable15(this.scratch, 64);
     this.next = new IntegerTable15(this.scratch, 64);
   }
@@ -64211,13 +64996,13 @@ var QpdfJsonValues = class _QpdfJsonValues {
 };
 
 // packages/pdf-ast/src/cos/qpdf-json-document.ts
-import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
 var QpdfJsonDocument = class _QpdfJsonDocument {
   constructor(storage, options = {}) {
     this.storage = storage;
     this.signal = options.signal ? AbortSignal.any([options.signal, this.controller.signal]) : this.controller.signal;
     this.store = new PdfMutableObjectStore(storage, { signal: this.signal });
-    this.backing = new PagedStorage25(
+    this.backing = new PagedStorage27(
       { fs: storage.fs, cwd: storage.directory, env: {}, signal: this.signal },
       4
     );
@@ -64286,7 +65071,7 @@ var QpdfJsonDocument = class _QpdfJsonDocument {
       env: {},
       signal: this.signal
     };
-    const tape = new PagedStorage25(context, 4), scratch = new PagedStorage25(context, 4);
+    const tape = new PagedStorage27(context, 4), scratch = new PagedStorage27(context, 4);
     let values, failed = false, work = 0;
     const cooperate = async (units = 1) => {
       this.signal.throwIfAborted();
@@ -64703,6 +65488,8 @@ export {
   rc4Transform,
   readCMapCharacters,
   readCosXrefRevision,
+  readPdfDictionaryEntries,
+  readPdfDictionaryValue,
   readStoredItems,
   redactPageContentAst,
   renderDisplayListToBitmap,