@poe-platform/safe-bash 0.1.814 → 0.1.816

package/dist/pdf-ast/index.js

@@ -336,6 +336,157 @@ var PdfStagingStorage = class {
   }
 };
 
+// packages/pdf-ast/src/content/stored-path.ts
+var BLOCK_BYTES = 4096;
+var RECORD_BYTES = 56;
+var RECORDS = Math.floor((BLOCK_BYTES - 8) / RECORD_BYTES);
+var kinds = ["close", "move", "line", "cubic", "rect"];
+var StoredPathWriter = class {
+  constructor(storage, signal) {
+    this.storage = storage;
+    this.signal = signal;
+  }
+  storage;
+  signal;
+  bytes = new Uint8Array(BLOCK_BYTES);
+  view = new DataView(this.bytes.buffer);
+  first = -1;
+  position = -1;
+  used = 0;
+  count = 0;
+  finished = false;
+  bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  allocate() {
+    const at = this.storage.allocate(BLOCK_BYTES);
+    if (!Number.isSafeInteger(at) || at < 0 || !Number.isSafeInteger(at + BLOCK_BYTES)) throw new RangeError("Invalid PDF path allocation");
+    return at;
+  }
+  async append(segment) {
+    this.signal?.throwIfAborted();
+    if (this.finished) throw new Error("PDF path is already finished");
+    if (this.position === -1) this.first = this.position = this.allocate();
+    if (this.used === RECORDS) {
+      const next = this.allocate();
+      this.view.setFloat64(0, next, true);
+      await this.storage.write(this.position, this.bytes, this.signal ? { signal: this.signal } : void 0);
+      this.position = next;
+      this.used = 0;
+    }
+    const at = 8 + this.used++ * RECORD_BYTES;
+    this.view.setFloat64(at, kinds.indexOf(segment.kind), true);
+    const values = segment.kind === "close" ? [] : segment.kind === "cubic" ? [segment.x, segment.y, segment.x1, segment.y1, segment.x2, segment.y2] : segment.kind === "rect" ? [segment.x, segment.y, segment.width, segment.height] : [segment.x, segment.y];
+    for (let i = 0; i < values.length; i++) this.view.setFloat64(at + 8 + i * 8, values[i], true);
+    const include = (x, y) => {
+      this.bounds[0] = Math.min(this.bounds[0], x);
+      this.bounds[1] = Math.min(this.bounds[1], y);
+      this.bounds[2] = Math.max(this.bounds[2], x);
+      this.bounds[3] = Math.max(this.bounds[3], y);
+    };
+    if (segment.kind !== "close") include(segment.x, segment.y);
+    if (segment.kind === "cubic") {
+      include(segment.x1, segment.y1);
+      include(segment.x2, segment.y2);
+    }
+    if (segment.kind === "rect") include(segment.x + segment.width, segment.y + segment.height);
+    this.count++;
+  }
+  async finish() {
+    this.signal?.throwIfAborted();
+    if (this.finished) throw new Error("PDF path is already finished");
+    this.finished = true;
+    if (this.position !== -1) {
+      this.view.setFloat64(0, -1, true);
+      await this.storage.write(this.position, this.bytes.subarray(0, 8 + this.used * RECORD_BYTES), this.signal ? { signal: this.signal } : void 0);
+    }
+    return { kind: "stored-path", storage: this.storage, position: this.first, count: this.count, bounds: this.bounds };
+  }
+};
+async function* readStoredPath(path, signal) {
+  let position = path.position, remaining = path.count;
+  while (remaining > 0) {
+    signal?.throwIfAborted();
+    if (!Number.isSafeInteger(position) || position < 0) throw new Error("Invalid PDF path block");
+    const count = Math.min(RECORDS, remaining), length = 8 + count * RECORD_BYTES;
+    const bytes = (await path.storage.read(position, length, signal ? { signal } : void 0)).slice();
+    if (bytes.length !== length) throw new Error("Incomplete PDF path block");
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    position = view.getFloat64(0, true);
+    for (let i = 0; i < count; i++) {
+      signal?.throwIfAborted();
+      const at = 8 + i * RECORD_BYTES, kind = kinds[view.getFloat64(at, true)];
+      const value = (n) => view.getFloat64(at + 8 + n * 8, true);
+      if (kind === "close") yield { kind };
+      else if (kind === "move" || kind === "line") yield { kind, x: value(0), y: value(1) };
+      else if (kind === "rect") yield { kind, x: value(0), y: value(1), width: value(2), height: value(3) };
+      else if (kind === "cubic") yield { kind, x: value(0), y: value(1), x1: value(2), y1: value(3), x2: value(4), y2: value(5) };
+      else throw new Error("Invalid PDF path record");
+    }
+    remaining -= count;
+  }
+}
+
+// packages/pdf-ast/src/render/svg-path-stream.ts
+function svgPathSegment(segment, height, matrix2) {
+  const point = (x, y) => matrix2 ? `${matrix2[0] * x + matrix2[2] * y + matrix2[4]} ${height - matrix2[1] * x - matrix2[3] * y - matrix2[5]}` : `${x} ${height - y}`;
+  switch (segment.kind) {
+    case "move":
+      return `M ${point(segment.x, segment.y)}`;
+    case "line":
+      return `L ${point(segment.x, segment.y)}`;
+    case "cubic":
+      return `C ${point(segment.x1, segment.y1)} ${point(segment.x2, segment.y2)} ${point(segment.x, segment.y)}`;
+    case "rect":
+      return matrix2 ? `M ${point(segment.x, segment.y)} L ${point(segment.x + segment.width, segment.y)} L ${point(segment.x + segment.width, segment.y + segment.height)} L ${point(segment.x, segment.y + segment.height)} Z` : `M ${segment.x} ${height - segment.y} h ${segment.width} v ${-segment.height} h ${-segment.width} Z`;
+    case "close":
+      return "Z";
+  }
+}
+function limit(value) {
+  if (value === void 0 || value === Infinity) return Infinity;
+  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError("Invalid SVG path limit");
+  return value;
+}
+async function* encodeSvgPathDataChunks(input, height, options = {}) {
+  const { signal } = options;
+  signal?.throwIfAborted();
+  const chunkBytes = options.chunkBytes ?? 16384, maxSegments = limit(options.maxSegments), maximum10 = limit(options.maxOutputBytes);
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid SVG path chunk size");
+  const stored = "kind" in input && input.kind === "stored-path" ? input : void 0;
+  if (stored && (!Number.isSafeInteger(stored.count) || stored.count < 0)) throw new RangeError("Invalid stored SVG path count");
+  if (stored && stored.count > maxSegments) throw new PdfError("E_LIMIT", "SVG path segment limit exceeded");
+  const source = stored ? readStoredPath(stored, signal) : input;
+  const buffer = new Uint8Array(Math.min(16384, chunkBytes)), encoder = new TextEncoder();
+  let used = 0, count = 0, total = 0, first = true;
+  for await (const segment of source) {
+    signal?.throwIfAborted();
+    if (count >= maxSegments) throw new PdfError("E_LIMIT", "SVG path segment limit exceeded");
+    if (++count % 64 === 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      signal?.throwIfAborted();
+    }
+    const part = svgPathSegment(segment, height, options.matrix);
+    if (part === void 0) continue;
+    const text = (first ? "" : " ") + part;
+    first = false;
+    if (text.length > maximum10 - total || !Number.isSafeInteger(total + text.length)) throw new PdfError("E_LIMIT", "SVG path output byte limit exceeded");
+    total += text.length;
+    const bytes = encoder.encode(text);
+    for (let at = 0; at < bytes.length; ) {
+      signal?.throwIfAborted();
+      const take = Math.min(buffer.length - used, bytes.length - at);
+      buffer.set(bytes.subarray(at, at + take), used);
+      used += take;
+      at += take;
+      if (used === buffer.length) {
+        yield buffer.slice();
+        used = 0;
+      }
+    }
+  }
+  signal?.throwIfAborted();
+  if (used) yield buffer.slice(0, used);
+}
+
 // packages/pdf-ast/src/content/stored-record.ts
 function* encodeParts(value, storage, key, ancestors) {
   if (key === "storage") {
@@ -522,6 +673,87 @@ var RecordReader = class {
     }
     return result;
   }
+  async size(tag) {
+    const bytes = await this.take(8);
+    const size = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getFloat64(0, true);
+    if (!Number.isSafeInteger(size) || size < 0 || size > this.remaining || tag === 4 /* String */ && size * 2 > this.remaining) throw new Error("Invalid capture field length");
+    return size;
+  }
+  async discard(length) {
+    while (length) {
+      const count = Math.min(length, 4096);
+      await this.take(count);
+      length -= count;
+    }
+  }
+  async stringEquals(expected) {
+    const length = await this.size(4 /* String */);
+    let equal2 = length === expected.length;
+    for (let at = 0; at < length; at += 2048) {
+      const bytes = await this.take(Math.min(2048, length - at) * 2);
+      const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      if (equal2) for (let i = 0; i < bytes.length / 2; i++) {
+        if (view.getUint16(i * 2, true) !== expected.charCodeAt(at + i)) {
+          equal2 = false;
+          break;
+        }
+      }
+    }
+    return equal2;
+  }
+  /** Skip without constructing arrays, strings or byte payloads. Only 32
+   * container counters stay resident; deeper counters use caller backing. */
+  async skip(tag) {
+    const frames = [];
+    const spilled = new StoredMetadataStack(this.storage, this.signal);
+    let remaining = 1;
+    for (; ; ) {
+      if (remaining === 0) {
+        const parent = frames.pop() ?? await spilled.pop();
+        if (parent === void 0) return;
+        remaining = parent;
+        continue;
+      }
+      if (remaining === -1) {
+        const field2 = (await this.take(1))[0];
+        if (field2 === 9 /* End */) {
+          remaining = 0;
+          continue;
+        }
+        if (field2 !== 4 /* String */) throw new Error("Invalid capture key");
+        await this.discard(await this.size(4 /* String */) * 2);
+      } else remaining--;
+      const current = tag ?? (await this.take(1))[0];
+      tag = void 0;
+      if (current === 8 /* Object */ || current === 7 /* Array */) {
+        const children = current === 8 /* Object */ ? -1 : await this.size(7 /* Array */);
+        if (frames.length === 32) await spilled.push(frames.shift());
+        frames.push(remaining);
+        remaining = children;
+      } else if (current === 4 /* String */ || current === 5 /* Bytes */) {
+        await this.discard(await this.size(current) * (current === 4 /* String */ ? 2 : 1));
+      } else if (current === 3 /* Number */) await this.take(8);
+      else if (current !== 0 /* Null */ && current !== 1 /* False */ && current !== 2 /* True */ && current !== 6 /* Storage */) {
+        throw new Error("Invalid capture tag");
+      }
+    }
+  }
+  async matches(path, expected, depth = 0) {
+    const tag = (await this.take(1))[0];
+    if (depth === path.length && tag === 4 /* String */) return this.stringEquals(expected);
+    if (depth === path.length || tag !== 8 /* Object */) {
+      await this.skip(tag);
+      return false;
+    }
+    let matched = false;
+    for (; ; ) {
+      const field2 = (await this.take(1))[0];
+      if (field2 === 9 /* End */) return matched;
+      if (field2 !== 4 /* String */) throw new Error("Invalid capture key");
+      if (await this.stringEquals(path[depth])) matched = await this.matches(path, expected, depth + 1);
+      else await this.skip();
+    }
+  }
   async value(tag) {
     tag ??= (await this.take(1))[0];
     if (tag === 0 /* Null */) return null;
@@ -571,7 +803,7 @@ var RecordReader = class {
     return value;
   }
 };
-async function readStoredRecord(storage, position, signal) {
+async function openStoredRecord(storage, position, signal) {
   signal?.throwIfAborted();
   if (!Number.isSafeInteger(position) || position < 0)
     throw new RangeError("Invalid capture position");
@@ -581,11 +813,22 @@ async function readStoredRecord(storage, position, signal) {
   const view = new DataView(header2.buffer, header2.byteOffset, header2.byteLength), next = view.getFloat64(0, true), length = view.getFloat64(8, true);
   if (!Number.isSafeInteger(length) || length < 1 || !Number.isSafeInteger(position + 16 + length))
     throw new RangeError("Invalid capture length");
-  const reader = new RecordReader(storage, position + 16, length, signal), value = await reader.value();
+  return { reader: new RecordReader(storage, position + 16, length, signal), next };
+}
+async function readStoredRecord(storage, position, signal) {
+  const { reader, next } = await openStoredRecord(storage, position, signal);
+  const value = await reader.value();
   if (reader.remaining) throw new Error("Trailing capture bytes");
   signal?.throwIfAborted();
   return { value, next };
 }
+async function storedRecordMatches(storage, position, path, expected, signal) {
+  const { reader, next } = await openStoredRecord(storage, position, signal);
+  const matched = await reader.matches(path, expected);
+  if (reader.remaining) throw new Error("Trailing capture bytes");
+  signal?.throwIfAborted();
+  return { matched, next };
+}
 var StoredMetadataStack = class {
   constructor(storage, signal) {
     this.storage = storage;
@@ -699,95 +942,6 @@ async function* readStoredOperations(source, signal) {
   }
 }
 
-// packages/pdf-ast/src/content/stored-path.ts
-var BLOCK_BYTES = 4096;
-var RECORD_BYTES = 56;
-var RECORDS = Math.floor((BLOCK_BYTES - 8) / RECORD_BYTES);
-var kinds = ["close", "move", "line", "cubic", "rect"];
-var StoredPathWriter = class {
-  constructor(storage, signal) {
-    this.storage = storage;
-    this.signal = signal;
-  }
-  storage;
-  signal;
-  bytes = new Uint8Array(BLOCK_BYTES);
-  view = new DataView(this.bytes.buffer);
-  first = -1;
-  position = -1;
-  used = 0;
-  count = 0;
-  finished = false;
-  bounds = [Infinity, Infinity, -Infinity, -Infinity];
-  allocate() {
-    const at = this.storage.allocate(BLOCK_BYTES);
-    if (!Number.isSafeInteger(at) || at < 0 || !Number.isSafeInteger(at + BLOCK_BYTES)) throw new RangeError("Invalid PDF path allocation");
-    return at;
-  }
-  async append(segment) {
-    this.signal?.throwIfAborted();
-    if (this.finished) throw new Error("PDF path is already finished");
-    if (this.position === -1) this.first = this.position = this.allocate();
-    if (this.used === RECORDS) {
-      const next = this.allocate();
-      this.view.setFloat64(0, next, true);
-      await this.storage.write(this.position, this.bytes, this.signal ? { signal: this.signal } : void 0);
-      this.position = next;
-      this.used = 0;
-    }
-    const at = 8 + this.used++ * RECORD_BYTES;
-    this.view.setFloat64(at, kinds.indexOf(segment.kind), true);
-    const values = segment.kind === "close" ? [] : segment.kind === "cubic" ? [segment.x, segment.y, segment.x1, segment.y1, segment.x2, segment.y2] : segment.kind === "rect" ? [segment.x, segment.y, segment.width, segment.height] : [segment.x, segment.y];
-    for (let i = 0; i < values.length; i++) this.view.setFloat64(at + 8 + i * 8, values[i], true);
-    const include = (x, y) => {
-      this.bounds[0] = Math.min(this.bounds[0], x);
-      this.bounds[1] = Math.min(this.bounds[1], y);
-      this.bounds[2] = Math.max(this.bounds[2], x);
-      this.bounds[3] = Math.max(this.bounds[3], y);
-    };
-    if (segment.kind !== "close") include(segment.x, segment.y);
-    if (segment.kind === "cubic") {
-      include(segment.x1, segment.y1);
-      include(segment.x2, segment.y2);
-    }
-    if (segment.kind === "rect") include(segment.x + segment.width, segment.y + segment.height);
-    this.count++;
-  }
-  async finish() {
-    this.signal?.throwIfAborted();
-    if (this.finished) throw new Error("PDF path is already finished");
-    this.finished = true;
-    if (this.position !== -1) {
-      this.view.setFloat64(0, -1, true);
-      await this.storage.write(this.position, this.bytes.subarray(0, 8 + this.used * RECORD_BYTES), this.signal ? { signal: this.signal } : void 0);
-    }
-    return { kind: "stored-path", storage: this.storage, position: this.first, count: this.count, bounds: this.bounds };
-  }
-};
-async function* readStoredPath(path, signal) {
-  let position = path.position, remaining = path.count;
-  while (remaining > 0) {
-    signal?.throwIfAborted();
-    if (!Number.isSafeInteger(position) || position < 0) throw new Error("Invalid PDF path block");
-    const count = Math.min(RECORDS, remaining), length = 8 + count * RECORD_BYTES;
-    const bytes = (await path.storage.read(position, length, signal ? { signal } : void 0)).slice();
-    if (bytes.length !== length) throw new Error("Incomplete PDF path block");
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    position = view.getFloat64(0, true);
-    for (let i = 0; i < count; i++) {
-      signal?.throwIfAborted();
-      const at = 8 + i * RECORD_BYTES, kind = kinds[view.getFloat64(at, true)];
-      const value = (n) => view.getFloat64(at + 8 + n * 8, true);
-      if (kind === "close") yield { kind };
-      else if (kind === "move" || kind === "line") yield { kind, x: value(0), y: value(1) };
-      else if (kind === "rect") yield { kind, x: value(0), y: value(1), width: value(2), height: value(3) };
-      else if (kind === "cubic") yield { kind, x: value(0), y: value(1), x1: value(2), y1: value(3), x2: value(4), y2: value(5) };
-      else throw new Error("Invalid PDF path record");
-    }
-    remaining -= count;
-  }
-}
-
 // packages/pdf-ast/src/content/stored-clips.ts
 var PAGE_BYTES = 4096;
 var RECORD_BYTES2 = 64;
@@ -18715,14 +18869,14 @@ var FlateStream = class extends DecodeStream {
       throw new FormatError("Unknown block type in flate stream");
     }
     buffer = this.buffer;
-    let limit10 = buffer ? buffer.length : 0;
+    let limit11 = buffer ? buffer.length : 0;
     let pos = this.bufferLength;
     while (true) {
       let code1 = this.getCode(litCodeTable);
       if (code1 < 256) {
-        if (pos + 1 >= limit10) {
+        if (pos + 1 >= limit11) {
           buffer = this.ensureBuffer(pos + 1);
-          limit10 = buffer.length;
+          limit11 = buffer.length;
         }
         buffer[pos++] = code1;
         continue;
@@ -18745,9 +18899,9 @@ var FlateStream = class extends DecodeStream {
         code2 = this.getBits(code2);
       }
       const dist = (code1 & 65535) + code2;
-      if (pos + len >= limit10) {
+      if (pos + len >= limit11) {
         buffer = this.ensureBuffer(pos + len);
-        limit10 = buffer.length;
+        limit11 = buffer.length;
       }
       for (let k = 0; k < len; ++k, ++pos) {
         buffer[pos] = buffer[pos - dist];
@@ -28224,6 +28378,7 @@ function* repairCandidateSteps(size) {
 // packages/pdf-ast/src/cos/value-parser.ts
 function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity, options = {}) {
   yield;
+  if (options.deferDictionaryValues && (!options.dictionaryStorage || options.arrayStorage !== options.dictionaryStorage || options.stringStorage !== options.dictionaryStorage || options.containerStorage !== options.dictionaryStorage)) throw new TypeError("Deferred resource values require shared caller backing");
   let work = 0;
   let nodes = 0;
   const charge = () => {
@@ -28233,14 +28388,15 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
   const residentDepth = 32;
   const stack = [];
   let current, depth = 0;
-  const pathLength = (options.storedArrayPaths ?? []).reduce((length, path) => Math.max(length, path.length - 1), 0);
-  function matchesStoredPath(parent) {
-    return options.storedArrayPaths?.some((path) => {
-      const length = parent.path.length + 1;
+  const pathLength = [...options.storedArrayPaths ?? [], ...options.storedDictionaryPaths ?? []].reduce((length, path) => Math.max(length, path.length - 1), 0);
+  function matchesStoredPath(parent, paths) {
+    const currentPath = parent ? [...parent.path, parent.kind === "dict" ? parent.key?.decoded : null] : options.arrayPathPrefix ?? [];
+    return paths?.some((path) => {
+      const length = currentPath.length;
       if (!path.length || path.length > length) return false;
       for (let i = 0; i < path.length; i++) {
         const at = length - path.length + i;
-        const key = at === parent.path.length ? parent.kind === "dict" ? parent.key?.decoded : void 0 : parent.path[at];
+        const key = currentPath[at];
         if (key == null || path[i] !== "*" && path[i] !== key) return false;
       }
       return true;
@@ -28265,7 +28421,9 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
   while (true) {
     if (++work % 16 === 0) yield;
     const parent = current;
-    lexer.setStringStorage?.(options.stringStorage && (parent?.kind === "dict" && parent.key && options.storedStringKeys?.includes(parent.key.decoded) || !parent && options.storeRootString) ? options.stringStorage : void 0);
+    const deferred = options.deferDictionaryValues && (parent?.deferred || parent?.kind === "dict" && parent.storedEntries);
+    const selectedString = parent?.kind === "dict" && parent.key && options.storedStringKeys?.includes(parent.key.decoded) || !parent && options.storeRootString;
+    lexer.setStringStorage?.(options.stringStorage && (selectedString || deferred) ? options.stringStorage : void 0);
     const tok = yield "token";
     if (!tok) {
       if (!parent) return void 0;
@@ -28278,11 +28436,11 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
     let node;
     if (parent?.kind === "array" && tok.kind === "array-end") {
       yield* pop();
-      node = { kind: "array", items: parent.items, ...parent.storedItems ? { storedItems: parent.storedItems } : {}, span: { start: parent.start, end: tok.span.end } };
+      node = { kind: "array", items: parent.items, ...parent.deferred ? { deferred: true } : {}, ...parent.storedItems ? { storedItems: parent.storedItems } : {}, span: { start: parent.start, end: tok.span.end } };
     } else if (parent?.kind === "dict" && !parent.key) {
       if (tok.kind === "dict-end") {
         yield* pop();
-        node = yield { kind: "dict", entries: parent.entries, ...parent.storedEntries ? { storedEntries: parent.storedEntries } : {}, span: { start: parent.start, end: tok.span.end } };
+        node = yield { kind: "dict", entries: parent.entries, ...parent.deferred ? { deferred: true } : {}, ...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 };
@@ -28298,30 +28456,33 @@ function* parseValueSteps(lexer, maxDepth, repair = false, maxNodes = Infinity,
       charge();
       if (depth > maxDepth) throw new PdfError("E_LIMIT", "PDF syntax nesting limit exceeded");
       if (tok.kind === "array-start") {
-        const backed = options.arrayStorage && (parent?.kind === "array" && parent.storedItems || parent?.kind === "dict" && (options.storedArrayKeys?.includes(parent.key.decoded) || matchesStoredPath(parent)) || !parent && options.storeRootArray);
+        const backed = options.arrayStorage && (parent?.kind === "array" && parent.storedItems && !parent.deferred || parent?.kind === "dict" && (options.storedArrayKeys?.includes(parent.key.decoded) || matchesStoredPath(parent, options.storedArrayPaths)) || !parent && options.storeRootArray);
         yield* push({
           kind: "array",
           path: ancestorPath(parent),
           start: tok.span.start,
           items: [],
           tail: -1,
-          ...backed ? { storedItems: { storage: options.arrayStorage, position: -1, length: 0 } } : {}
+          ...deferred && !backed ? { deferred: true } : {},
+          ...backed || deferred ? { storedItems: { storage: options.arrayStorage, position: -1, length: 0 } } : {}
         });
         continue;
       }
       if (tok.kind === "dict-start") {
-        const backed = options.dictionaryStorage && (parent?.kind === "dict" && !parent.storedEntries && options.storedDictionaryKeys?.includes(parent.key.decoded) || !parent && options.storeRootDictionary);
+        const backed = options.dictionaryStorage && (parent?.kind === "dict" && (!parent.storedEntries || parent.deferred) && (options.storedDictionaryKeys?.includes(parent.key.decoded) || matchesStoredPath(parent, options.storedDictionaryPaths)) || !parent && (options.storeRootDictionary || matchesStoredPath(void 0, options.storedDictionaryPaths)));
         yield* push({
           kind: "dict",
           path: ancestorPath(parent),
           start: tok.span.start,
           entries: [],
           tail: -1,
-          ...backed ? { storedEntries: { storage: options.dictionaryStorage, position: -1, length: 0 } } : {}
+          ...deferred && !backed ? { deferred: true } : {},
+          ...backed || deferred ? { storedEntries: { storage: options.dictionaryStorage, position: -1, length: 0 } } : {}
         });
         continue;
       }
       node = yield* parseLeafFromToken(tok, lexer);
+      if (deferred && !selectedString && node.kind === "string") node = { ...node, deferred: true };
     }
     const container = current;
     if (!container) return node;
@@ -28680,8 +28841,8 @@ var PdfNameIndex = class {
     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");
+    const limit11 = typeof maximum10 === "function" ? maximum10() : maximum10;
+    if (limit11 !== Infinity && (!Number.isSafeInteger(limit11) || limit11 < 0)) throw new RangeError("Invalid name staging limit");
   }
   storage;
   maximum;
@@ -28720,8 +28881,8 @@ var PdfNameIndex = class {
       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;
+    const limit11 = typeof this.maximum === "function" ? this.maximum() : this.maximum;
+    const remaining = Math.min(limit11, 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,
@@ -28791,7 +28952,7 @@ var PdfNameIndex = class {
 };
 
 // packages/pdf-ast/src/content/stored-dictionary.ts
-async function* readPdfDictionaryEntries(dict, signal) {
+async function* readRawPdfDictionaryEntries(dict, signal) {
   signal?.throwIfAborted();
   if (dict.storedEntries) yield* readStoredItems(dict.storedEntries, signal);
   else for (const entry of dict.entries) {
@@ -28799,10 +28960,59 @@ async function* readPdfDictionaryEntries(dict, signal) {
     yield entry;
   }
 }
-async function readPdfDictionaryValue(dict, key, signal) {
+async function materializeResourceValue(node, signal) {
+  signal?.throwIfAborted();
+  if (node.kind === "dict" && node.deferred && node.storedEntries) {
+    const { deferred: ignoredDeferred, storedEntries: ignoredEntries, ...ordinary } = node;
+    const entries = [];
+    for await (const entry of readRawPdfDictionaryEntries(node, signal)) entries.push({ ...entry, value: await materializeResourceValue(entry.value, signal) });
+    return { ...ordinary, entries };
+  }
+  if (node.kind === "array" && node.deferred && node.storedItems) {
+    const { deferred: ignoredDeferred, storedItems: ignoredItems, ...ordinary } = node;
+    const items = [];
+    for await (const item of readStoredItems(node.storedItems, signal)) items.push(await materializeResourceValue(item, signal));
+    return { ...ordinary, items };
+  }
+  if (node.kind === "string" && node.deferred && node.storedBytes) {
+    const { deferred: ignoredDeferred, storedBytes, ...ordinary } = node;
+    if (!Number.isSafeInteger(storedBytes.byteLength) || storedBytes.byteLength < 0) throw new RangeError("Invalid deferred resource string length");
+    const bytes = new Uint8Array(storedBytes.byteLength);
+    for (let at = 0; at < bytes.length; at += 4096) {
+      if (at && at % 65536 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+      const length = Math.min(4096, bytes.length - at);
+      const chunk = await storedBytes.storage.read(storedBytes.position + at, length, signal ? { signal } : void 0);
+      signal?.throwIfAborted();
+      if (chunk.length !== length) throw new Error("Incomplete deferred resource string");
+      bytes.set(chunk, at);
+    }
+    return { ...ordinary, bytes };
+  }
+  return node;
+}
+async function* readPdfDictionaryEntries(dict, signal) {
+  for await (const entry of readRawPdfDictionaryEntries(dict, signal)) yield { ...entry, value: await materializeResourceValue(entry.value, signal) };
+}
+async function readPdfDictionaryValue(dict, key, signal, options = {}) {
+  if (dict.storedEntries) {
+    const { storage, length } = dict.storedEntries;
+    if (!Number.isSafeInteger(length) || length < 0) throw new RangeError("Invalid stored array length");
+    let position = dict.storedEntries.position, selected = -1;
+    for (let i = 0; i < length; i++) {
+      if (i && i % 256 === 0) await new Promise((resolve2) => setTimeout(resolve2, 0));
+      const record = await storedRecordMatches(storage, position, ["key", "decoded"], key, signal);
+      if (record.matched) selected = position;
+      position = record.next;
+    }
+    if (position !== -1) throw new Error("Invalid stored array terminator");
+    signal?.throwIfAborted();
+    if (selected === -1) return void 0;
+    const value2 = (await readStoredRecord(storage, selected, signal)).value.value;
+    return options.preserveDeferred ? value2 : materializeResourceValue(value2, signal);
+  }
   let value;
-  for await (const entry of readPdfDictionaryEntries(dict, signal)) if (entry.key.decoded === key) value = entry.value;
-  return value;
+  for await (const entry of readRawPdfDictionaryEntries(dict, signal)) if (entry.key.decoded === key) value = entry.value;
+  return value && !options.preserveDeferred ? materializeResourceValue(value, signal) : value;
 }
 async function mergePdfResourceDictionaries(destination, source, indexStorage, signal) {
   const storage = destination.storedEntries?.storage ?? source?.storedEntries?.storage;
@@ -28812,7 +29022,7 @@ async function mergePdfResourceDictionaries(destination, source, indexStorage, s
   async function* rows() {
     for (const [dict, replace] of [[destination, true], [source, false]]) {
       if (!dict) continue;
-      for await (const entry of readPdfDictionaryEntries(dict, signal)) {
+      for await (const entry of readRawPdfDictionaryEntries(dict, signal)) {
         const name = await names.intern(entry.key.decoded);
         if (!replace && !name.added) continue;
         const position = await writeStoredRecord(storage, entry, -1, signal);
@@ -30901,13 +31111,13 @@ async function decryptPdfObjectStrings(state, objectNumber, generationNumber, va
       let signatureDict = node;
       if (node.storedEntries) {
         signatureDict = { kind: "dict", entries: [] };
-        for await (const entry of readPdfDictionaryEntries(node, options.signal)) {
+        for await (const entry of readRawPdfDictionaryEntries(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)) {
+      for await (const entry of readRawPdfDictionaryEntries(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);
@@ -33259,13 +33469,13 @@ function embedTrueTypeFontInCos(doc, font, usedGlyphs) {
 }
 
 // packages/pdf-ast/src/fonts/resolve.ts
-function* resolve(node, storeRootArray = false, storeRootDictionary = false) {
-  const value = yield { kind: "resolve", node, storeRootArray, storeRootDictionary };
+function* resolve(node, storeRootArray = false, storeRootDictionary = false, arrayPathPrefix) {
+  const value = yield { kind: "resolve", node, storeRootArray, storeRootDictionary, ...arrayPathPrefix ? { arrayPathPrefix } : {} };
   if (value && !("kind" in value)) throw new TypeError("Font lookup returned stream bytes instead of a COS value");
   return value;
 }
-function* resolveDict2(node, backed = false) {
-  const value = yield* resolve(node, false, backed);
+function* resolveDict2(node, backed = false, path) {
+  const value = yield* resolve(node, false, backed, path);
   return value?.kind === "dict" ? value : value?.kind === "stream" ? value.dict : void 0;
 }
 function* resolveArray2(node, backed = false) {
@@ -33381,7 +33591,7 @@ function* resolvePageFontsSteps(rootRef, resourcesDict, selectedName, options =
           fontMatrix = [1e-3, 0, 0, 1e-3, 0, 0];
         }
         charProcs = yield* resolveDict2(dictGet(fObj, "CharProcs"));
-        fontResources = yield* resolveDict2(dictGet(fObj, "Resources"));
+        fontResources = yield* resolveDict2(dictGet(fObj, "Resources"), false, ["Resources"]);
       }
       const type3Scale1000 = subtype === "Type3" && fontMatrix ? Math.hypot(fontMatrix[0], fontMatrix[1]) * 1e3 : 1;
       if (subtype === "Type0") {
@@ -34479,8 +34689,8 @@ var CCITTFaxDecoder = class {
     }
     this.codingPos = codingPos;
   }
-  *_findTableCode(start, end, table, limit10) {
-    const limitValue = limit10 || 0;
+  *_findTableCode(start, end, table, limit11) {
+    const limitValue = limit11 || 0;
     for (let i = start; i <= end; ++i) {
       let code = yield* this._lookBits(i);
       if (code === ccittEOF) {
@@ -40622,8 +40832,8 @@ function* looksLikePostEiContentStream(size, posAfterEi) {
   let p = posAfterEi;
   while (p < size && isPdfWhitespace(yield* byte2(p))) p++;
   if (p >= size) return true;
-  const limit10 = Math.min(size, p + 16);
-  for (let i = p; i < limit10; i++) {
+  const limit11 = Math.min(size, p + 16);
+  for (let i = p; i < limit11; i++) {
     const b = yield* byte2(i);
     if (b === 40 || b === 60 || b === 37) break;
     if (!isPdfWhitespace(b) && (b < 32 || b > 126)) {
@@ -41188,6 +41398,11 @@ function* resolveColorSpaceInfoSteps(doc, node, resources) {
         case "resolve":
           result = doc.resolve(request.node);
           break;
+        case "resource": {
+          const map = doc.resolveDict(dictGet(request.resources, request.category));
+          result = map ? dictGet(map, request.name) : void 0;
+          break;
+        }
         case "palette":
           result = request.node.kind === "stream" ? doc.decodeStream(request.node) : request.node.bytes;
           break;
@@ -41228,9 +41443,7 @@ function* imageColorSpaceProgram(csNode, resourcesDict, maxDepth = Infinity, dep
     if (name === "DeviceRGB" || name === "RGB" || name === "CalRGB") {
       return { colorSpace: "rgb", colorSpaceLabel: name === "CalRGB" ? "cal-rgb" : "rgb", components: 3 };
     }
-    const csResources = resourcesDict ? yield { kind: "resolve", node: dictGet(resourcesDict, "ColorSpace") } : void 0;
-    const csResDict = csResources?.kind === "dict" ? csResources : void 0;
-    const mapped = csResDict ? dictGet(csResDict, name) : void 0;
+    const mapped = resourcesDict ? yield { kind: "resource", resources: resourcesDict, category: "ColorSpace", name } : void 0;
     if (mapped) {
       return yield* imageColorSpaceProgram(mapped, resourcesDict, maxDepth, depth + 1);
     }
@@ -42556,7 +42769,10 @@ function* runColorProgramSteps(doc, work, sources) {
     while (!step.done) {
       const request = step.value;
       if (request.kind === "resolve") step = work.next(doc?.resolve(request.node));
-      else {
+      else if (request.kind === "resource") {
+        const map = doc?.resolveDict(dictGet(request.resources, request.category));
+        step = work.next(map ? dictGet(map, request.name) : void 0);
+      } else {
         if (!doc) throw new PdfError("E_CAPABILITY", "PDF resource color requires a source driver");
         if (request.kind === "decode") {
           const bytes = doc.decodeStream(request.stream);
@@ -42581,8 +42797,7 @@ function* colorComponentCountSteps(hasDocument, csNode, activeResources, depth =
     if (name === "DeviceCMYK" || name === "CMYK") return 4;
     if (name === "DeviceRGB" || name === "RGB" || name === "CalRGB" || name === "Lab") return 3;
     if (hasDocument && activeResources) {
-      const csDict = yield* resolveColorNode(dictGet(activeResources, "ColorSpace"), "dict");
-      const mapped = csDict ? dictGet(csDict, name) : void 0;
+      const mapped = yield { kind: "resource", resources: activeResources, category: "ColorSpace", name };
       if (mapped) return yield* colorComponentCountSteps(hasDocument, mapped, activeResources, depth + 1);
     }
     return 3;
@@ -42613,8 +42828,7 @@ function* convertContentColorSteps(hasDocument, csNode, csNameFallback, comps, a
   if ((!resolved || resolved.kind === "name") && hasDocument && activeResources) {
     const lookupName = resolved?.kind === "name" ? resolved.decoded : csNameFallback;
     if (lookupName && lookupName !== "DeviceRGB" && lookupName !== "RGB" && lookupName !== "DeviceGray" && lookupName !== "G" && lookupName !== "DeviceCMYK" && lookupName !== "CMYK") {
-      const csDict = yield* resolveColorNode(dictGet(activeResources, "ColorSpace"), "dict");
-      const mapped = csDict ? dictGet(csDict, lookupName) : void 0;
+      const mapped = yield { kind: "resource", resources: activeResources, category: "ColorSpace", name: lookupName };
       if (mapped) {
         resolved = yield* resolveColorNode(mapped);
       }
@@ -42996,20 +43210,20 @@ function isOptionalContentVisible(doc, ocNode) {
   }
   return step.value;
 }
-function* resolveEvaluationNode(node, storeRootArray = false, arrayPathPrefix) {
+function* resolveEvaluationNode(node, storeRootArray = false, arrayPathPrefix, storeRootDictionary = false) {
   if (!node) return void 0;
-  const result = yield { kind: "resolve", node, ...storeRootArray ? { storeRootArray } : {}, ...arrayPathPrefix ? { arrayPathPrefix } : {} };
+  const result = yield { kind: "resolve", node, ...storeRootDictionary ? { storeRootDictionary } : {}, ...storeRootArray ? { storeRootArray } : {}, ...arrayPathPrefix ? { arrayPathPrefix } : {} };
   if (!result || !("kind" in result) || result.kind !== "resolved") throw new TypeError("Expected a resolved PDF object");
   return result.node;
 }
-function* resolveEvaluationDict(node, arrayPathPrefix) {
-  const resolved = yield* resolveEvaluationNode(node, false, arrayPathPrefix);
+function* resolveEvaluationDict(node, arrayPathPrefix, storeRootDictionary = false) {
+  const resolved = yield* resolveEvaluationNode(node, false, arrayPathPrefix, storeRootDictionary);
   return resolved?.kind === "dict" ? resolved : resolved?.kind === "stream" ? resolved.dict : void 0;
 }
-function* lookupEvaluationDictionary(dict, key) {
+function* lookupEvaluationDictionary(dict, key, preserveDeferred = false) {
   if (!dict) return void 0;
   if (!dict.storedEntries) return dictGet(dict, key);
-  const result = yield { kind: "dictionary-value", dict, key };
+  const result = yield { kind: "dictionary-value", dict, key, ...preserveDeferred ? { preserveDeferred } : {} };
   if (!result || !("kind" in result) || result.kind !== "resolved") throw new TypeError("Expected a PDF dictionary value");
   return result.node;
 }
@@ -43017,6 +43231,23 @@ function* resolveEvaluationArray(node, storeRootArray = false, arrayPathPrefix)
   const resolved = yield* resolveEvaluationNode(node, storeRootArray, arrayPathPrefix);
   return resolved?.kind === "array" ? resolved : void 0;
 }
+function* evaluationArrayPrefix(array, count) {
+  if (!array.storedItems) return array.items.slice(0, count);
+  const items = array.storedItems;
+  if (!Number.isSafeInteger(items.length) || items.length < 0) throw new RangeError("Invalid stored array length");
+  const prefix = [];
+  let position = items.position;
+  for (let i = 0; i < Math.min(count, items.length); i++) {
+    const reply = yield { kind: "array-item", items, position };
+    if (!reply || !("kind" in reply) || reply.kind !== "resolved" || reply.node?.kind !== "array") throw new TypeError("Expected stored array item");
+    const [next, value] = reply.node.items;
+    if (next?.kind !== "number" || !value) throw new TypeError("Expected stored array record");
+    position = next.value;
+    prefix.push(value);
+  }
+  if (items.length <= count && position !== -1) throw new PdfError("E_PARSE", "Invalid stored array terminator");
+  return prefix;
+}
 function* visitEvaluationArray(array, visit) {
   if (!array.storedItems) {
     for (const item of array.items) yield* visit(item);
@@ -43461,8 +43692,8 @@ function* evaluateContentSteps(params) {
         st.dashPhase = void 0;
       }
     } else if (operator === "sh" && activeResources && ops[0]?.kind === "name") {
-      const shMap = yield* resolveEvaluationDict(dictGet(activeResources, "Shading"));
-      const shNode = shMap ? yield* resolveEvaluationNode(dictGet(shMap, ops[0].decoded)) : void 0;
+      const shMap = yield* resolveEvaluationDict(dictGet(activeResources, "Shading"), ["Resources", "Shading"]);
+      const shNode = shMap ? yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(shMap, ops[0].decoded)) : void 0;
       const shDict = shNode?.kind === "dict" ? shNode : shNode?.kind === "stream" ? shNode.dict : void 0;
       const shStream = shNode?.kind === "stream" ? shNode : void 0;
       if (shDict) {
@@ -43513,10 +43744,10 @@ function* evaluateContentSteps(params) {
     } else if (operator === "K") {
       st.strokeColor = yield* resolveScColorOperands("DeviceCMYK", ops, activeResources);
     } else if (operator === "gs" && activeResources && ops[0]?.kind === "name") {
-      const extDict = yield* resolveEvaluationDict(dictGet(activeResources, "ExtGState"), ["ExtGState"]);
-      const gsDict = extDict ? yield* resolveEvaluationDict(dictGet(extDict, ops[0].decoded), ["ExtGState", ops[0].decoded]) : void 0;
+      const extDict = yield* resolveEvaluationDict(dictGet(activeResources, "ExtGState"), ["Resources", "ExtGState"]);
+      const gsDict = extDict ? yield* resolveEvaluationDict(yield* lookupEvaluationDictionary(extDict, ops[0].decoded, true), ["Resources", "ExtGState", ops[0].decoded], true) : void 0;
       if (gsDict) {
-        const mask = yield* resolveEvaluationNode(dictGet(gsDict, "SMask"));
+        const mask = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "SMask"));
         if (mask?.kind === "name" && mask.decoded === "None") {
           st.softMask = void 0;
         } else if (mask?.kind === "dict") {
@@ -43549,48 +43780,36 @@ function* evaluateContentSteps(params) {
             st.softMask = { subtype: subtype.decoded, operations: captured instanceof StoredOperationsWriter ? [] : captured, ...captured instanceof StoredOperationsWriter ? { storedOperations: captured.snapshot() } : {}, ...parameters.value };
           }
         }
-        const bmNode = yield* resolveEvaluationNode(dictGet(gsDict, "BM"));
+        const bmNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "BM", true), true);
         if (bmNode?.kind === "name") {
           st.blendMode = bmNode.decoded === "Compatible" ? "Normal" : bmNode.decoded;
-        } else if (bmNode?.kind === "array" && bmNode.items.length > 0) {
-          const firstBm = yield* resolveEvaluationNode(bmNode.items[0]);
+        } else if (bmNode?.kind === "array" && (bmNode.storedItems?.length ?? bmNode.items.length) > 0) {
+          const firstBm = yield* resolveEvaluationNode((yield* evaluationArrayPrefix(bmNode, 1))[0]);
           if (firstBm?.kind === "name") {
             st.blendMode = firstBm.decoded === "Compatible" ? "Normal" : firstBm.decoded;
           }
         }
-        const caNode = yield* resolveEvaluationNode(dictGet(gsDict, "ca"));
+        const caNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "ca", true), true);
         if (caNode?.kind === "number") st.fillAlpha = Math.max(0, Math.min(1, caNode.value));
-        const CANode = yield* resolveEvaluationNode(dictGet(gsDict, "CA"));
+        const CANode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "CA", true), true);
         if (CANode?.kind === "number") st.strokeAlpha = Math.max(0, Math.min(1, CANode.value));
-        const lwNode = yield* resolveEvaluationNode(dictGet(gsDict, "LW"));
+        const lwNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "LW", true), true);
         if (lwNode?.kind === "number") st.strokeWidth = Math.max(0, lwNode.value);
-        const lcNode = yield* resolveEvaluationNode(dictGet(gsDict, "LC"));
+        const lcNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "LC", true), true);
         if (lcNode?.kind === "number" && (lcNode.value === 0 || lcNode.value === 1 || lcNode.value === 2)) {
           st.lineCap = lcNode.value;
         }
-        const ljNode = yield* resolveEvaluationNode(dictGet(gsDict, "LJ"));
+        const ljNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "LJ", true), true);
         if (ljNode?.kind === "number" && (ljNode.value === 0 || ljNode.value === 1 || ljNode.value === 2)) {
           st.lineJoin = ljNode.value;
         }
-        const mlNode = yield* resolveEvaluationNode(dictGet(gsDict, "ML"));
+        const mlNode = yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(gsDict, "ML", true), true);
         if (mlNode?.kind === "number" && mlNode.value > 0) {
           st.miterLimit = mlNode.value;
         }
-        const dArr = yield* resolveEvaluationArray(dictGet(gsDict, "D"), true);
+        const dArr = yield* resolveEvaluationArray(yield* lookupEvaluationDictionary(gsDict, "D", true), true);
         if (dArr && (dArr.storedItems?.length ?? dArr.items.length) >= 2) {
-          let pair = dArr.items;
-          if (dArr.storedItems) {
-            pair = [];
-            let position = dArr.storedItems.position;
-            for (let i = 0; i < 2; i++) {
-              const reply = yield { kind: "array-item", items: dArr.storedItems, position };
-              if (!reply || !("kind" in reply) || reply.kind !== "resolved" || reply.node?.kind !== "array") throw new TypeError("Expected dash state record");
-              const [next, value] = reply.node.items;
-              if (next?.kind !== "number" || !value) throw new TypeError("Expected dash state value");
-              position = next.value;
-              pair.push(value);
-            }
-          }
+          const pair = yield* evaluationArrayPrefix(dArr, 2);
           const patArr = yield* resolveEvaluationArray(pair[0], true);
           const phaseNode = yield* resolveEvaluationNode(pair[1]);
           if (patArr && params.geometryStorage) {
@@ -43611,9 +43830,10 @@ function* evaluateContentSteps(params) {
             st.dashPhase = phaseNode?.kind === "number" ? phaseNode.value : 0;
           }
         }
-        const fontArr = yield* resolveEvaluationArray(dictGet(gsDict, "Font"));
-        if (fontArr && fontArr.items.length >= 2) {
-          const fSizeNode = yield* resolveEvaluationNode(fontArr.items[1]);
+        const fontArr = yield* resolveEvaluationArray(yield* lookupEvaluationDictionary(gsDict, "Font", true), true);
+        if (fontArr && (fontArr.storedItems?.length ?? fontArr.items.length) >= 2) {
+          const pair = yield* evaluationArrayPrefix(fontArr, 2);
+          const fSizeNode = yield* resolveEvaluationNode(pair[1]);
           if (fSizeNode?.kind === "number") st.fontSize = fSizeNode.value;
           const gsFontKey = `__ExtGS_Font_${ops[0].decoded}`;
           const gsFontResources = {
@@ -43626,7 +43846,7 @@ function* evaluateContentSteps(params) {
                   entries: [
                     {
                       key: { kind: "name", decoded: gsFontKey, rawBytes: new Uint8Array(0) },
-                      value: fontArr.items[0]
+                      value: pair[0]
                     }
                   ]
                 }
@@ -43665,8 +43885,8 @@ function* evaluateContentSteps(params) {
     const st = curState();
     if (!st.fillPatternName || !resources) return false;
     if (depth >= 8) throw new PdfError("E_LIMIT", "Pattern nesting exceeds the form depth limit");
-    const patterns = yield* resolveEvaluationDict(dictGet(resources, "Pattern"));
-    const pattern = patterns && (yield* resolveEvaluationNode(dictGet(patterns, st.fillPatternName)));
+    const patterns = yield* resolveEvaluationDict(dictGet(resources, "Pattern"), ["Resources", "Pattern"]);
+    const pattern = patterns && (yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(patterns, st.fillPatternName)));
     const dict = pattern?.kind === "stream" ? pattern.dict : pattern?.kind === "dict" ? pattern : void 0;
     if (!dict) return false;
     const nums = function* (key, fallback) {
@@ -43749,7 +43969,7 @@ function* evaluateContentSteps(params) {
       const iy1 = Math.ceil((Math.max(...corners.map((p) => p[1])) - box[1]) / yStep) - 1;
       if ((ix1 - ix0 + 1) * (iy1 - iy0 + 1) > 2e4) throw new PdfError("E_LIMIT", "Pattern tile count exceeds 20000");
       const nodes = { stream: pattern };
-      const patternResources = (yield* resolveEvaluationDict(dictGet(dict, "Resources"))) ?? resources;
+      const patternResources = (yield* resolveEvaluationDict(dictGet(dict, "Resources"), ["Resources"])) ?? resources;
       const patternFonts = [patternResources, ...activeFonts];
       for (let iy = iy0; iy <= iy1; iy++) {
         for (let ix = ix0; ix <= ix1; ix++) {
@@ -43783,7 +44003,7 @@ function* evaluateContentSteps(params) {
     const isolated = isolation?.kind === "boolean" && isolation.value;
     const compositeGroup = !maskGroup && groupType?.kind === "name" && groupType.decoded === "Transparency" && (isolated || st.fillAlpha !== 1 || !!st.softMask || !!st.blendMode && st.blendMode !== "Normal" && st.blendMode !== "Compatible");
     const formNodes = { stream: form };
-    const formResDict = (yield* resolveEvaluationDict(dictGet(form.dict, "Resources"))) ?? activeResources;
+    const formResDict = (yield* resolveEvaluationDict(dictGet(form.dict, "Resources"), ["Resources"])) ?? activeResources;
     const formFonts = [formResDict, ...activeFonts];
     let nextCtm = [...st.ctm];
     const matArr = yield* resolveEvaluationArray(dictGet(form.dict, "Matrix"));
@@ -43860,7 +44080,7 @@ function* evaluateContentSteps(params) {
     let resolvedMcid = node.mcid;
     let resolvedActualText = node.actualText ?? node.storedActualText;
     if (typeof node.properties === "string" && activeResources) {
-      const propsMap = yield* resolveEvaluationDict(dictGet(activeResources, "Properties"), ["Properties"]);
+      const propsMap = yield* resolveEvaluationDict(dictGet(activeResources, "Properties"), ["Resources", "Properties"]);
       const propRefOrNode = yield* lookupEvaluationDictionary(propsMap, node.properties);
       if (propRefOrNode) {
         const propDict = yield* resolveEvaluationDict(propRefOrNode);
@@ -44044,7 +44264,7 @@ function* evaluateContentSteps(params) {
           case "xobject": {
             const st = curState();
             if (activeResources) {
-              const xobjDict = yield* resolveEvaluationDict(dictGet(activeResources, "XObject"), ["XObject"]);
+              const xobjDict = yield* resolveEvaluationDict(dictGet(activeResources, "XObject"), ["Resources", "XObject"]);
               const xobjNode = xobjDict ? yield* resolveEvaluationNode(yield* lookupEvaluationDictionary(xobjDict, node.name)) : void 0;
               if (xobjNode?.kind === "stream") {
                 if (!(yield* optionalContentVisibilitySteps(dictGet(xobjNode.dict, "OC")))) {
@@ -44635,10 +44855,10 @@ function* visible(node) {
 function* preparePageAppearanceSteps(pageDict, pageRes, evalResourcesDict, hideAnnotations = false, onAllocation) {
   onAllocation?.(64 * pageRes.entries.length);
   for (const entry of pageRes.entries) {
-    const sub = yield* resolveDict3(entry.value, [entry.key.decoded]);
+    const sub = yield* resolveDict3(entry.value, ["Resources", entry.key.decoded]);
     if (sub) {
       onAllocation?.(64 + sub.entries.length * 64);
-      const shareBacking = entry.key.decoded === "XObject" || entry.key.decoded === "Properties";
+      const shareBacking = entry.key.decoded !== "Font";
       const clonedSub = sub.storedEntries ? shareBacking ? { ...sub, entries: [] } : yield { kind: "dictionary-merge", destination: sub } : cosDict({});
       if (!sub.storedEntries) for (const se of sub.entries) dictSet(clonedSub, se.key.decoded, se.value);
       dictSet(evalResourcesDict, entry.key.decoded, clonedSub);
@@ -44682,12 +44902,12 @@ function* preparePageAppearanceSteps(pageDict, pageRes, evalResourcesDict, hideA
         if (hasContent === true) {
           onAllocation?.(2048);
           renderedApStream = true;
-          const apRes = yield* resolveDict3(dictGet(apN.dict, "Resources"));
+          const apRes = yield* resolveDict3(dictGet(apN.dict, "Resources"), ["Resources"]);
           if (apRes) {
             for (const subKey of ["Font", "XObject", "ExtGState", "ColorSpace", "Pattern", "Shading"]) {
-              const srcSub = yield* resolveDict3(dictGet(apRes, subKey), [subKey]);
+              const srcSub = yield* resolveDict3(dictGet(apRes, subKey), ["Resources", subKey]);
               if (!srcSub) continue;
-              let dstSub = yield* resolveDict3(dictGet(evalResourcesDict, subKey), [subKey]);
+              let dstSub = yield* resolveDict3(dictGet(evalResourcesDict, subKey), ["Resources", subKey]);
               if (!dstSub) {
                 onAllocation?.(64);
                 dstSub = cosDict({});
@@ -48314,24 +48534,13 @@ function* svgImageSteps(image, pageHeight) {
 }
 function* svgPathDataSteps(segments, height, matrix2) {
   let work = 0;
-  const dParts = [];
-  const point = (x, y) => matrix2 ? `${matrix2[0] * x + matrix2[2] * y + matrix2[4]} ${height - matrix2[1] * x - matrix2[3] * y - matrix2[5]}` : `${x} ${height - y}`;
-  for (const seg of segments) {
+  const parts = [];
+  for (const segment of segments) {
     if (++work % 16384 === 0) yield;
-    if (seg.kind === "move") {
-      dParts.push(`M ${point(seg.x, seg.y)}`);
-    } else if (seg.kind === "line") {
-      dParts.push(`L ${point(seg.x, seg.y)}`);
-    } else if (seg.kind === "cubic") {
-      dParts.push(`C ${point(seg.x1, seg.y1)} ${point(seg.x2, seg.y2)} ${point(seg.x, seg.y)}`);
-    } else if (seg.kind === "rect") {
-      if (matrix2) dParts.push(`M ${point(seg.x, seg.y)} L ${point(seg.x + seg.width, seg.y)} L ${point(seg.x + seg.width, seg.y + seg.height)} L ${point(seg.x, seg.y + seg.height)} Z`);
-      else dParts.push(`M ${seg.x} ${height - seg.y} h ${seg.width} v ${-seg.height} h ${-seg.width} Z`);
-    } else if (seg.kind === "close") {
-      dParts.push("Z");
-    }
+    const part = svgPathSegment(segment, height, matrix2);
+    if (part !== void 0) parts.push(part);
   }
-  return dParts.join(" ");
+  return parts.join(" ");
 }
 function* renderDisplayListToSvgSteps(displayList, options = {}) {
   const baseScale = options.scale ?? (options.dpi ? options.dpi / 72 : 1);
@@ -48641,6 +48850,139 @@ function renderPdfPageToPng(pdfBytes, pageIndex = 0, options) {
   while (!next.done) next = steps.next();
   return next.value;
 }
+async function* encodeSvgPathPaintChunks(original, pageHeight, options = {}) {
+  const { signal } = options;
+  signal?.throwIfAborted();
+  const chunkBytes = options.chunkBytes ?? 16384, maximum10 = options.maxOutputBytes ?? Infinity, scale = options.scale ?? 1;
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid SVG paint chunk size");
+  for (const value of [maximum10, options.maxSegments ?? Infinity, options.maxDashEntries ?? Infinity]) if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) throw new RangeError("Invalid SVG paint limit");
+  if (!Number.isFinite(scale) || scale <= 0) throw new RangeError("Invalid SVG paint scale");
+  if (original.kind === "glyph" && (original.value.renderMode === 3 || !original.value.outline && !original.value.unicode.trim())) return;
+  const p = original.kind === "glyph" ? glyphPaint(original.value) : original.value;
+  const segmentCount = p.storedSegments?.count ?? p.segments.length, dashCount = p.storedDash?.length ?? p.dashArray?.length ?? 0;
+  if (!Number.isSafeInteger(segmentCount) || segmentCount < 0 || !Number.isSafeInteger(dashCount) || dashCount < 0) throw new RangeError("Invalid SVG paint record count");
+  if (segmentCount > (options.maxSegments ?? Infinity) || dashCount > (options.maxDashEntries ?? Infinity)) throw new PdfError("E_LIMIT", "SVG paint record limit exceeded");
+  if (!segmentCount) return;
+  let emitted = 0, work = 0;
+  const encoder = new TextEncoder();
+  function* bytes(bytes2) {
+    if (bytes2.length > maximum10 - emitted || !Number.isSafeInteger(emitted + bytes2.length)) throw new PdfError("E_LIMIT", "SVG paint output byte limit exceeded");
+    emitted += bytes2.length;
+    for (let at = 0; at < bytes2.length; at += chunkBytes) {
+      signal?.throwIfAborted();
+      yield bytes2.slice(at, at + chunkBytes);
+    }
+  }
+  function* text(value) {
+    for (let at = 0; at < value.length; ) {
+      let end = Math.min(at + 2048, value.length);
+      if (end < value.length && value.charCodeAt(end - 1) >= 55296 && value.charCodeAt(end - 1) <= 56319) end--;
+      yield* bytes(encoder.encode(value.slice(at, end)));
+      at = end;
+    }
+  }
+  async function checkpoint() {
+    signal?.throwIfAborted();
+    if (++work % 64 === 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      signal?.throwIfAborted();
+    }
+  }
+  async function* dashes(factor) {
+    if (!p.storedDash) {
+      for (const value of p.dashArray ?? []) {
+        await checkpoint();
+        yield value * factor;
+      }
+      return;
+    }
+    const source = p.storedDash;
+    if (!Number.isSafeInteger(source.position) || source.position < 0 || !Number.isSafeInteger(source.position + dashCount * 8)) throw new RangeError("Invalid SVG dash position");
+    for (let at = 0; at < dashCount; at += 512) {
+      await checkpoint();
+      const length = Math.min(512, dashCount - at) * 8, data = (await source.storage.read(source.position + at * 8, length, signal ? { signal } : void 0)).slice();
+      if (data.length !== length) throw new Error("Incomplete SVG dash pattern");
+      const view = new DataView(data.buffer, data.byteOffset, data.length);
+      for (let i = 0; i < length; i += 8) {
+        await checkpoint();
+        yield view.getFloat64(i, true) * factor;
+      }
+    }
+  }
+  const prepared = p.strokeColor ? prepareStroke(p, scale) : void 0;
+  let outlineStroke = false;
+  if (prepared) for await (const value of dashes(1)) {
+    if (value === 0) {
+      outlineStroke = true;
+      break;
+    }
+  }
+  const matrix2 = prepared && (prepared.matrix[0] !== 1 || prepared.matrix[1] !== 0 || prepared.matrix[2] !== 0 || prepared.matrix[3] !== 1) ? prepared.matrix : void 0, inverse = matrix2 ? inverseStrokeMatrix(matrix2) : void 0;
+  const transform = inverse && matrix2 ? ` transform="matrix(${matrix2[0]} ${-matrix2[1]} ${-matrix2[2]} ${matrix2[3]} ${matrix2[4]} ${pageHeight - matrix2[5]})"` : "";
+  const fill = p.fillColor ? `rgb(${Math.round(p.fillColor.r * 255)},${Math.round(p.fillColor.g * 255)},${Math.round(p.fillColor.b * 255)})` : "none", stroke = p.strokeColor && prepared ? `rgb(${Math.round(p.strokeColor.r * 255)},${Math.round(p.strokeColor.g * 255)},${Math.round(p.strokeColor.b * 255)})` : "none";
+  const label = original.kind === "glyph" ? ` aria-label="${escapeXmlText(original.value.unicode)}"` : "";
+  let painted = false;
+  if (!outlineStroke || p.fillColor) {
+    painted = true;
+    yield* text(`  <path${label}${transform} d="`);
+    for await (const chunk of encodeSvgPathDataChunks(p.storedSegments ?? p.segments, inverse ? 0 : pageHeight, { ...options, ...inverse ? { matrix: inverse } : {} })) yield* bytes(chunk);
+    yield* text(`" fill="${fill}"${p.fillRule === "evenodd" ? ' fill-rule="evenodd"' : ""}${p.fillAlpha !== void 0 && p.fillAlpha < 1 ? ` fill-opacity="${p.fillAlpha}"` : ""} stroke="${outlineStroke ? "none" : stroke}"${p.strokeAlpha !== void 0 && p.strokeAlpha < 1 ? ` stroke-opacity="${p.strokeAlpha}"` : ""}`);
+    yield* text(p.strokeWidth <= 0 && !matrix2 && !dashCount ? ' stroke-width="1" vector-effect="non-scaling-stroke"' : ` stroke-width="${prepared?.width ?? p.strokeWidth}"`);
+    yield* text(`${p.lineCap === 1 ? ' stroke-linecap="round"' : p.lineCap === 2 ? ' stroke-linecap="square"' : ""}${p.lineJoin === 1 ? ' stroke-linejoin="round"' : p.lineJoin === 2 ? ' stroke-linejoin="bevel"' : ""}${p.miterLimit !== void 0 && p.miterLimit !== 10 ? ` stroke-miterlimit="${p.miterLimit}"` : ""}`);
+    if (!outlineStroke && prepared && dashCount) {
+      yield* text(' stroke-dasharray="');
+      let first = true;
+      const factor = p.storedDash ? prepared.storedDashScale : 1;
+      if (p.storedDash) {
+        for await (const value of dashes(factor)) {
+          yield* text(`${first ? "" : " "}${value}`);
+          first = false;
+        }
+      } else for (const value of prepared.dashArray ?? []) {
+        await checkpoint();
+        yield* text(`${first ? "" : " "}${value}`);
+        first = false;
+      }
+      yield* text('"');
+    }
+    if (!outlineStroke && prepared?.dashPhase) yield* text(` stroke-dashoffset="${prepared.dashPhase}"`);
+    yield* text("/>");
+  }
+  if (outlineStroke) {
+    const io = { signal }, iterator = strokeContourPoints(p, pageHeight, scale, 0, 0, 0, 0, io)[Symbol.iterator]();
+    let firstPoint = true, started = false, contours = 0;
+    try {
+      for (; ; ) {
+        await checkpoint();
+        const next = iterator.next();
+        if (next.done) break;
+        if (io.pathRequest) {
+          const request = io.pathRequest;
+          io.pathRequest = void 0;
+          await request();
+        }
+        const point = next.value;
+        if (point === null) continue;
+        if (!started) {
+          yield* text(`${painted ? "\n" : ""}  <path${label} d="`);
+          started = true;
+        }
+        if (firstPoint && contours) yield* text(" ");
+        if (point) {
+          yield* text(`${firstPoint ? "M" : " L"} ${point[0] / scale} ${point[1] / scale}`);
+          firstPoint = false;
+        } else {
+          yield* text(" Z");
+          firstPoint = true;
+          contours++;
+        }
+      }
+    } finally {
+      iterator.return?.();
+    }
+    if (started) yield* text(`" fill="${stroke}" fill-opacity="${p.strokeAlpha ?? 1}"/>`);
+  }
+}
 
 // packages/pdf-ast/src/render/retained-page-pixels.ts
 async function renderRetainedPagePixels(page2, storage, options = {}) {
@@ -48728,7 +49070,7 @@ async function renderRetainedPagePixels(page2, storage, options = {}) {
 
 // packages/pdf-ast/src/cos/range-parser.ts
 import { listenForAbort as listenForAbort2 } from "@poe-platform/safe-fs/contracts";
-function limit(value, name) {
+function limit2(value, name) {
   const result = value ?? Infinity;
   if (result !== Infinity && (!Number.isSafeInteger(result) || result < 0)) throw new RangeError(`Invalid ${name}`);
   return result;
@@ -48832,16 +49174,16 @@ async function readValue(lexer, depth, nodes, options) {
   return value;
 }
 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 depth = limit2(options.maxRecursionDepth, "maxRecursionDepth");
+  const nodes = limit2(options.maxNodes, "maxNodes");
+  const maxTokenBytes = limit2(options.maxTokenBytes, "maxTokenBytes");
   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 = {}) {
-  const depth = limit(options.maxRecursionDepth, "maxRecursionDepth");
-  const nodes = limit(options.maxNodes, "maxNodes");
-  const tokenBytes = limit(options.maxTokenBytes, "maxTokenBytes");
+  const depth = limit2(options.maxRecursionDepth, "maxRecursionDepth");
+  const nodes = limit2(options.maxNodes, "maxNodes");
+  const tokenBytes = limit2(options.maxTokenBytes, "maxTokenBytes");
   const { signal } = options;
   signal?.throwIfAborted();
   const lexer = new CosRangeLexer(source, { compactNumbers: options.compactNumbers ?? false, compactKeywords: options.compactKeywords ?? false, ...options.onBackingError ? { onBackingError: options.onBackingError } : {}, start: offset, maxTokenBytes: tokenBytes, ...signal ? { signal } : {} });
@@ -48863,7 +49205,13 @@ async function parseCosRangeObject(source, offset, options = {}) {
       const first = await byteAt(source, start, signal);
       if (first === 13) start += await byteAt(source, start + 1, signal) === 10 ? 2 : 1;
       else if (first === 10) start++;
-      const entry = dictGet(value, "Length");
+      let entry;
+      try {
+        entry = value.storedEntries ? await readPdfDictionaryValue(value, "Length", signal, { preserveDeferred: true }) : dictGet(value, "Length");
+      } catch (error) {
+        options.onBackingError?.(error);
+        throw error;
+      }
       const length = await resolveStreamLength(entry, options);
       signal?.throwIfAborted();
       if (length !== void 0 && Number.isSafeInteger(length) && length >= 0 && length <= source.size - start) {
@@ -49365,45 +49713,73 @@ var PdfReferenceSet = class {
 // packages/pdf-ast/src/cos/filter-dictionary.ts
 async function resolvePdfStreamDictionary(dict, lookup, active, options) {
   let remaining = options.maxNodes ?? 65536;
-  const resolve2 = async (node, depth) => {
-    if (--remaining < 0 || depth >= (options.maxRecursionDepth ?? 100)) throw new PdfError("E_LIMIT", "PDF filter resolution limit exceeded");
-    if (node.kind === "ref") {
-      if (active.has(node.objectNumber)) throw new PdfError("E_PARSE", "PDF filter reference cycle");
-      const object = await lookup(node);
-      if (!object) throw new PdfError("E_PARSE", "Missing PDF filter reference");
-      active.add(node.objectNumber);
-      try {
-        return await resolve2(object.value, depth + 1);
-      } finally {
-        active.delete(node.objectNumber);
+  const resolve2 = async (node, depth, parent = options.referencePath) => {
+    let path = parent, owned, failed = false;
+    try {
+      for (; ; ) {
+        options.signal?.throwIfAborted();
+        if (--remaining < 0 || depth >= (options.maxRecursionDepth ?? 100)) throw new PdfError("E_LIMIT", "PDF filter resolution limit exceeded");
+        if (node.kind !== "ref") break;
+        if (active.has(node.objectNumber)) throw new PdfError("E_PARSE", "PDF filter reference cycle");
+        for (let ancestor = path; ancestor; ancestor = ancestor.parent) {
+          const seen = await ancestor.seen.has(node.objectNumber).catch((error) => {
+            options.onBackingError?.(error);
+            throw error;
+          });
+          if (seen) throw new PdfError("E_PARSE", "PDF filter reference cycle");
+        }
+        owned ??= { seen: new PdfReferenceSet(options.referenceStorage, options.maxTraversalStagingBytes, options.signal), parent, depth: 0 };
+        path = owned;
+        const object = await lookup(node, path);
+        if (!object) throw new PdfError("E_PARSE", "Missing PDF filter reference");
+        await path.seen.add(node.objectNumber).catch((error) => {
+          options.onBackingError?.(error);
+          throw error;
+        });
+        path.depth++;
+        depth++;
+        node = object.value;
+        if (path.depth % 256 === 0) await new Promise((resolve3) => setTimeout(resolve3, 0));
       }
-    }
-    if (node.kind === "array") {
-      const items = [];
-      const { storedItems, ...ordinary } = node;
-      if (storedItems) {
-        const reader = readStoredItems(storedItems, options.signal);
-        try {
-          for (; ; ) {
-            const item = await reader.next().catch((error) => {
-              options.onBackingError?.(error);
-              throw error;
-            });
-            if (item.done) break;
-            items.push(await resolve2(item.value, depth + 1));
+      if (node.kind === "array") {
+        const items = [];
+        const { storedItems, ...ordinary } = node;
+        if (storedItems) {
+          const reader = readStoredItems(storedItems, options.signal);
+          try {
+            for (; ; ) {
+              const item = await reader.next().catch((error) => {
+                options.onBackingError?.(error);
+                throw error;
+              });
+              if (item.done) break;
+              items.push(await resolve2(item.value, depth + 1, path));
+            }
+          } finally {
+            await reader.return();
           }
-        } finally {
-          await reader.return();
+        } else for (const item of node.items) items.push(await resolve2(item, depth + 1, path));
+        return { ...ordinary, items };
+      }
+      if (node.kind === "dict") {
+        const entries2 = [];
+        for (const entry of node.entries) entries2.push({ ...entry, value: await resolve2(entry.value, depth + 1, path) });
+        return { ...node, entries: entries2 };
+      }
+      return node;
+    } catch (error) {
+      failed = true;
+      throw error;
+    } finally {
+      try {
+        await owned?.seen.close();
+      } catch (error) {
+        if (!failed) {
+          options.onBackingError?.(error);
+          await Promise.reject(error);
         }
-      } else for (const item of node.items) items.push(await resolve2(item, depth + 1));
-      return { ...ordinary, items };
-    }
-    if (node.kind === "dict") {
-      const entries2 = [];
-      for (const entry of node.entries) entries2.push({ ...entry, value: await resolve2(entry.value, depth + 1) });
-      return { ...node, entries: entries2 };
+      }
     }
-    return node;
   };
   const entries = [];
   for (const entry of dict.entries) entries.push(["Filter", "F", "DecodeParms", "DP", "Type"].includes(entry.key.decoded) ? { ...entry, value: await resolve2(entry.value, 0) } : entry);
@@ -49556,7 +49932,7 @@ var PdfObjectReader = class {
   // Recursive length/object-stream lookups share one failure identity so an
   // outer recovery pass cannot mistake a caller-storage error for PDF syntax.
   backingFailures = /* @__PURE__ */ new WeakMap();
-  lengthPaths = /* @__PURE__ */ new WeakMap();
+  referencePaths = /* @__PURE__ */ new WeakMap();
   repairedOffsets = /* @__PURE__ */ new Map();
   options;
   capacity;
@@ -49586,10 +49962,7 @@ 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, onBackingError: (error) => {
-        this.backingFailures.set(active, { error });
-        this.options.onBackingError?.(error);
-      } }) };
+      return { object: object2, dict: await this.resolveStreamDictionary(object2.value, active) };
     });
     const span = object.stream;
     const input = () => this.source.stream(span.start, span.end - span.start, this.options.signal);
@@ -49597,16 +49970,36 @@ 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);
   }
+  resolveStreamDictionary(dict, active) {
+    return resolvePdfStreamDictionary(dict, async (ref, path) => {
+      const parent = this.referencePaths.get(active);
+      this.referencePaths.set(active, path);
+      try {
+        return await this.load(ref.objectNumber, ref.generationNumber, active);
+      } finally {
+        if (parent) this.referencePaths.set(active, parent);
+        else this.referencePaths.delete(active);
+      }
+    }, active, {
+      ...this.options,
+      referenceStorage: this.storage,
+      referencePath: this.referencePaths.get(active),
+      onBackingError: (error) => {
+        this.backingFailures.set(active, { error });
+        this.options.onBackingError?.(error);
+      }
+    });
+  }
   /** A stream-valued /Length is invalid as a length, but its references still
    * need cycle, admission and backing-error validation. Walk those discarded
    * values in source order instead of retaining one parser and AST per link. */
   async resolveLength(reference, active) {
     const path = {
       seen: new PdfReferenceSet(this.storage, this.options.maxTraversalStagingBytes, this.options.signal),
-      parent: this.lengthPaths.get(active),
+      parent: this.referencePaths.get(active),
       depth: 0
     };
-    this.lengthPaths.set(active, path);
+    this.referencePaths.set(active, path);
     let next = reference, result, failed = false;
     try {
       while (next) {
@@ -49637,8 +50030,8 @@ var PdfObjectReader = class {
       failed = true;
       throw error;
     } finally {
-      if (path.parent) this.lengthPaths.set(active, path.parent);
-      else this.lengthPaths.delete(active);
+      if (path.parent) this.referencePaths.set(active, path.parent);
+      else this.referencePaths.delete(active);
       try {
         await path.seen.close();
       } catch (error) {
@@ -49654,7 +50047,7 @@ var PdfObjectReader = class {
     this.options.signal?.throwIfAborted();
     if (active.has(objectNumber)) throw new PdfError("E_PARSE", "PDF indirect object cycle");
     let depth = active.size;
-    for (let path = this.lengthPaths.get(active); path; path = path.parent) {
+    for (let path = this.referencePaths.get(active); path; path = path.parent) {
       let seen;
       try {
         seen = await path.seen.has(objectNumber);
@@ -49717,7 +50110,15 @@ var PdfObjectReader = class {
         this.repairedOffsets.set(objectNumber, object.span.start);
       }
       if (this.options.encryption && objectNumber !== this.options.encryptionObjectNumber) {
-        let type = object.stream && object.value.kind === "dict" ? dictGet(object.value, "Type") : void 0;
+        let type;
+        if (object.stream && object.value.kind === "dict") {
+          try {
+            type = object.value.storedEntries ? await readPdfDictionaryValue(object.value, "Type", this.options.signal, { preserveDeferred: true }) : dictGet(object.value, "Type");
+          } catch (error) {
+            onBackingError(error);
+            throw error;
+          }
+        }
         if (type?.kind === "ref") type = (await this.load(type.objectNumber, type.generationNumber, active))?.value;
         const value = await decryptPdfObjectStrings(
           this.options.encryption,
@@ -49774,10 +50175,7 @@ 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, onBackingError: (error) => {
-        this.backingFailures.set(active, { error });
-        this.options.onBackingError?.(error);
-      } });
+      dict = await this.resolveStreamDictionary(object.value, active);
     } finally {
       active.delete(number);
     }
@@ -50774,16 +51172,16 @@ async function renderRetainedMesh(context, dict, type, input, settings, storage,
 
 // packages/pdf-ast/src/extract/retained-color.ts
 import { readBytes as readBytes14 } from "@poe-platform/safe-fs/contracts";
-function limit2(value, fallback, name) {
+function limit3(value, fallback, name) {
   const result = value ?? fallback;
   if (result !== Infinity && (!Number.isSafeInteger(result) || result < 0)) throw new RangeError(`Invalid ${name}`);
   return Math.min(result, Number.MAX_SAFE_INTEGER);
 }
 function createRetainedColorAccess(document2, storage, options, storedFunctions = false) {
-  const maximum10 = limit2(options.maxWorkingBytes, Infinity, "maxWorkingBytes");
-  const maxStaging = limit2(options.maxStagingBytes, Infinity, "maxStagingBytes");
-  const maxNodes = limit2(options.maxNodes, 65536, "maxNodes");
-  const maxDepth = limit2(options.maxDepth, document2.depthLimit, "maxDepth");
+  const maximum10 = limit3(options.maxWorkingBytes, Infinity, "maxWorkingBytes");
+  const maxStaging = limit3(options.maxStagingBytes, Infinity, "maxStagingBytes");
+  const maxNodes = limit3(options.maxNodes, 65536, "maxNodes");
+  const maxDepth = limit3(options.maxDepth, document2.depthLimit, "maxDepth");
   const chunkBytes = options.chunkBytes ?? 4096;
   if (!Number.isSafeInteger(chunkBytes) || chunkBytes <= 0) throw new RangeError("Invalid chunkBytes");
   let used = 0;
@@ -50833,11 +51231,11 @@ function createRetainedColorAccess(document2, storage, options, storedFunctions
     options.onAllocation?.(bytes);
     used += bytes;
   }
-  async function resolve2(value) {
+  async function resolve2(value, path) {
     options.signal?.throwIfAborted();
     if (++nodes > maxNodes) throw new PdfError("E_LIMIT", "PDF color node limit exceeded");
     charge(64);
-    const resolved = await document2.lookup(value);
+    const resolved = await document2.lookup(value, void 0, path);
     options.signal?.throwIfAborted();
     if (!resolved) return void 0;
     if (resolved.stream && resolved.reference && resolved.value.kind === "dict") {
@@ -50848,6 +51246,11 @@ function createRetainedColorAccess(document2, storage, options, storedFunctions
     if (resolved.value.kind === "name") charge(resolved.value.decoded.length * 2);
     return resolved.value;
   }
+  async function resource(request) {
+    const map = await resolve2(dictGet(request.resources, request.category), ["Resources", request.category]);
+    const dictionary = map?.kind === "stream" ? map.dict : map;
+    return dictionary?.kind === "dict" ? readPdfDictionaryValue(dictionary, request.name, options.signal) : void 0;
+  }
   function contents(stream) {
     const reference = streams.get(stream);
     return reference ? document2.objects.decodeStream(reference.objectNumber, reference.generationNumber) : decodePdfStreamChunks(stream.dict, async function* () {
@@ -51033,7 +51436,7 @@ function createRetainedColorAccess(document2, storage, options, storedFunctions
     maxRecursionDepth: maxDepth
   });
   options.signal?.throwIfAborted();
-  return { resolve: resolve2, decode: decode2, contents, snapshot, snapshotColor, snapshotFunction, charge, context, maxDepth, functionSources, storedFunctions, async close() {
+  return { resolve: resolve2, resource, decode: decode2, contents, snapshot, snapshotColor, snapshotFunction, charge, context, maxDepth, functionSources, storedFunctions, async close() {
     await functionBacking?.close();
   } };
 }
@@ -51052,7 +51455,7 @@ async function openRetainedImageColor(document2, node, resources, storage, optio
   }
 }
 async function resolveImageColor(access, node, resources, options) {
-  const { resolve: resolve2, decode: decode2, snapshot, snapshotFunction, charge, context, maxDepth, functionSources } = access;
+  const { resolve: resolve2, resource, decode: decode2, snapshot, snapshotFunction, charge, context, maxDepth, functionSources } = access;
   const work = imageColorSpaceProgram(node, resources, maxDepth);
   try {
     let step = work.next();
@@ -51064,6 +51467,9 @@ async function resolveImageColor(access, node, resources, options) {
         case "resolve":
           result = await resolve2(request.node);
           break;
+        case "resource":
+          result = await resource(request);
+          break;
         case "palette": {
           if (!Number.isSafeInteger(request.maxBytes) || request.maxBytes < 0) throw new PdfError("E_LIMIT", "PDF palette size limit exceeded");
           if (request.node.kind === "stream") result = await decode2(request.node, request.maxBytes);
@@ -51122,7 +51528,7 @@ async function runFunctionSteps(work, signal) {
   }
 }
 async function runRetainedColorProgram(document2, storage, options, work) {
-  const { resolve: resolve2, decode: decode2, snapshot, snapshotFunction, context, charge, functionSources, close } = createRetainedColorAccess(document2, storage, options, true);
+  const { resolve: resolve2, resource, decode: decode2, snapshot, snapshotFunction, context, charge, functionSources, close } = createRetainedColorAccess(document2, storage, options, true);
   let failed = false;
   try {
     let step = work.next();
@@ -51131,6 +51537,7 @@ async function runRetainedColorProgram(document2, storage, options, work) {
       const request = step.value;
       let result;
       if (request.kind === "resolve") result = await resolve2(request.node);
+      else if (request.kind === "resource") result = await resource(request);
       else if (request.kind === "decode") result = await decode2(request.stream, request.length, request.start);
       else if (request.kind === "calibrated") result = createCalibratedColorSpace(context, request.family, await snapshot(request.parameters));
       else if (request.kind === "transfer") {
@@ -51205,7 +51612,7 @@ async function renderRetainedShading(document2, node, settings, storage, options
 import { PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/extract/retained-jpeg.ts
-function limit3(value, name) {
+function limit4(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51230,8 +51637,8 @@ var PdfRetainedJpeg = class _PdfRetainedJpeg {
   static async open(source, options = {}) {
     const controller = new AbortController();
     options = { ...options, signal: options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal };
-    const maximum10 = limit3(options.maxWorkingBytes, "maxWorkingBytes");
-    const outputMaximum = limit3(options.maxOutputBytes, "maxOutputBytes");
+    const maximum10 = limit4(options.maxWorkingBytes, "maxWorkingBytes");
+    const outputMaximum = limit4(options.maxOutputBytes, "maxOutputBytes");
     let allocated = 0;
     let parsing = true;
     function charge(bytes) {
@@ -51421,7 +51828,7 @@ async function* tileDescriptors(tiles, storage, signal) {
     }
   }
 }
-function limit4(value, name) {
+function limit5(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51455,8 +51862,8 @@ var PdfRetainedJpx = class _PdfRetainedJpx {
       ...options,
       signal: options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal
     };
-    const maximum10 = limit4(options.maxWorkingBytes, "maxWorkingBytes");
-    const outputMaximum = limit4(options.maxOutputBytes, "maxOutputBytes");
+    const maximum10 = limit5(options.maxWorkingBytes, "maxWorkingBytes");
+    const outputMaximum = limit5(options.maxOutputBytes, "maxOutputBytes");
     let allocated = 0;
     let allocationFailure;
     function charge(bytes) {
@@ -51683,7 +52090,7 @@ var PdfRetainedJpx = class _PdfRetainedJpx {
 };
 
 // packages/pdf-ast/src/extract/retained-jbig2.ts
-function limit5(value, name) {
+function limit6(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51710,8 +52117,8 @@ var PdfRetainedJbig2 = class _PdfRetainedJbig2 {
   static async open(source, fallbackWidth, fallbackHeight, options = {}) {
     const controller = new AbortController();
     options = { ...options, signal: options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal };
-    const maximum10 = limit5(options.maxWorkingBytes, "maxWorkingBytes");
-    const outputMaximum = limit5(options.maxOutputBytes, "maxOutputBytes");
+    const maximum10 = limit6(options.maxWorkingBytes, "maxWorkingBytes");
+    const outputMaximum = limit6(options.maxOutputBytes, "maxOutputBytes");
     let allocated = 0;
     function charge(bytes) {
       if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > maximum10 - allocated) throw new PdfError("E_LIMIT", "JBIG2 working byte limit exceeded");
@@ -51880,7 +52287,7 @@ var PdfRetainedJbig2 = class _PdfRetainedJbig2 {
 
 // packages/pdf-ast/src/extract/retained-mask.ts
 import { readBytes as readBytes15 } from "@poe-platform/safe-fs/contracts";
-function limit6(value, name) {
+function limit7(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51890,8 +52297,8 @@ async function* applyRetainedImageMask(rows, width, height, mask, options) {
     if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`Invalid ${name}`);
   }
   if (options.mode !== "soft" && options.mode !== "explicit") throw new RangeError("Invalid mask mode");
-  const workingLimit = limit6(options.maxWorkingBytes, "maxWorkingBytes");
-  const outputLimit = limit6(options.maxOutputBytes, "maxOutputBytes");
+  const workingLimit = limit7(options.maxWorkingBytes, "maxWorkingBytes");
+  const outputLimit = limit7(options.maxOutputBytes, "maxOutputBytes");
   const pixels = width * height;
   const maskPixels = mask.width * mask.height;
   if (!Number.isSafeInteger(pixels) || pixels > Math.floor(outputLimit / 4)) throw new PdfError("E_LIMIT", "PDF masked output byte limit exceeded");
@@ -51933,7 +52340,7 @@ async function* applyRetainedImageMask(rows, width, height, mask, options) {
 }
 
 // packages/pdf-ast/src/extract/retained-samples.ts
-function limit7(value, name) {
+function limit8(value, name) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`Invalid ${name}`);
   return value;
@@ -51942,8 +52349,8 @@ async function* decodeRetainedSampleRows(source, width, height, bitsPerComponent
   for (const [name, value] of [["width", width], ["height", height], ["bitsPerComponent", bitsPerComponent], ["components", color.components]]) {
     if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`Invalid ${name}`);
   }
-  const workingLimit = limit7(options.maxWorkingBytes, "maxWorkingBytes");
-  const outputLimit = limit7(options.maxOutputBytes, "maxOutputBytes");
+  const workingLimit = limit8(options.maxWorkingBytes, "maxWorkingBytes");
+  const outputLimit = limit8(options.maxOutputBytes, "maxOutputBytes");
   const pixels = width * height;
   if (!Number.isSafeInteger(pixels) || pixels > Math.floor(outputLimit / 4)) throw new PdfError("E_LIMIT", "PDF sample output byte limit exceeded");
   options.signal?.throwIfAborted();
@@ -55030,8 +55437,8 @@ async function resolveRetainedFont(document2, storage, resources, name, options
       }
       let value;
       if (step.value.kind === "resolve") {
-        const retained = await document2.lookup(step.value.node, options.resourceStorage ? { dictionaryStorage: options.resourceStorage, storedDictionaryKeys: ["Font", "XObject", "Properties"], storeRootDictionary: step.value.storeRootDictionary ?? false, arrayStorage: options.resourceStorage, storedArrayKeys: ["Widths", "W", "Differences"], storeRootArray: step.value.storeRootArray ?? false } : {});
-        value = retained?.value;
+        const retained = await document2.lookup(step.value.node, options.resourceStorage ? { dictionaryStorage: options.resourceStorage, deferDictionaryValues: true, containerStorage: options.resourceStorage, stringStorage: options.resourceStorage, storedDictionaryKeys: ["Font", "XObject", "Properties"], storedDictionaryPaths: [["Resources", "*"]], storeRootDictionary: step.value.storeRootDictionary ?? false, arrayStorage: options.resourceStorage, storedArrayKeys: ["Widths", "W", "Differences"], storeRootArray: step.value.storeRootArray ?? false } : {}, step.value.arrayPathPrefix);
+        value = retained ? await materializeResourceValue(retained.value, signal) : void 0;
         if (retained?.stream) {
           if (retained.value.kind !== "dict" || !retained.reference) throw new PdfError("E_PARSE", "Font stream has no retained identity");
           allocation.admit(256);
@@ -55223,9 +55630,9 @@ async function* evaluateRetainedContentSteps(document2, content, params, storage
     admitted += bytes;
   }
   const identities = /* @__PURE__ */ new WeakMap();
-  async function resolve2(node, storeRootArray = false, arrayPathPrefix) {
+  async function resolve2(node, storeRootArray = false, arrayPathPrefix, storeRootDictionary = false) {
     charge(64);
-    const value = await document2.lookup(node, storeRootArray && options.imageStorage ? { arrayStorage: options.imageStorage, storeRootArray: true } : void 0, arrayPathPrefix);
+    const value = await document2.lookup(node, void 0, arrayPathPrefix, storeRootDictionary, storeRootArray ? options.imageStorage : void 0);
     signal?.throwIfAborted();
     if (value?.stream && value.reference && value.value.kind === "dict") {
       charge(128);
@@ -55364,14 +55771,14 @@ async function* evaluateRetainedContentSteps(document2, content, params, storage
         }
         case "resolve":
         case "catalog":
-          reply = { kind: "resolved", node: await resolve2(request.kind === "catalog" ? document2.crossReference.rootRef : request.node, request.kind === "resolve" && request.storeRootArray, request.kind === "resolve" ? request.arrayPathPrefix : void 0) };
+          reply = { kind: "resolved", node: await resolve2(request.kind === "catalog" ? document2.crossReference.rootRef : request.node, request.kind === "resolve" && request.storeRootArray, request.kind === "resolve" ? request.arrayPathPrefix : void 0, request.kind === "resolve" && request.storeRootDictionary) };
           break;
         case "dash-array": {
           reply = { kind: "dash-array", value: await storeDashArray(request.array, request.storage, request.resolveReferences ? resolve2 : async (node) => node, signal) };
           break;
         }
         case "dictionary-value":
-          reply = { kind: "resolved", node: await readPdfDictionaryValue(request.dict, request.key, signal) };
+          reply = { kind: "resolved", node: await readPdfDictionaryValue(request.dict, request.key, signal, request.preserveDeferred ? { preserveDeferred: true } : {}) };
           break;
         case "array-reference":
           reply = { kind: "resolved", node: cosBool(await memberships.has(request.items, request.objectNumber)) };
@@ -56189,7 +56596,7 @@ function* generateDocumentFormAppearancesSteps(doc) {
 function generateDocumentFormAppearances(doc) {
   return drainWork(generateDocumentFormAppearancesSteps(doc));
 }
-function decodeXmlEntities(text) {
+function decodeFormDataEntities(text) {
   let out = "";
   let i = 0;
   while (i < text.length) {
@@ -56253,7 +56660,7 @@ function extractAttributeValue(tagBody, attrName) {
   if (quote !== '"' && quote !== "'") return void 0;
   const end = tagBody.indexOf(quote, after + 1);
   if (end === -1) return void 0;
-  return decodeXmlEntities(tagBody.slice(after + 1, end));
+  return decodeFormDataEntities(tagBody.slice(after + 1, end));
 }
 function parseXfdfString(text, out) {
   const fieldStack = [];
@@ -56285,7 +56692,7 @@ function parseXfdfString(text, out) {
     } else if (tagName === "value" && !selfClosing && fieldStack.length > 0) {
       const closeVal = text.indexOf("</value>", pos);
       if (closeVal !== -1) {
-        const rawVal = decodeXmlEntities(text.slice(pos, closeVal));
+        const rawVal = decodeFormDataEntities(text.slice(pos, closeVal));
         const fullFieldName = fieldStack.filter(Boolean).join(".");
         if (fullFieldName) {
           if (rawVal === "Off") out.set(fullFieldName, false);
@@ -56493,9 +56900,9 @@ function parseFormDataBytes(bytes) {
       if (line.startsWith("FieldType:")) {
         curType = line.slice("FieldType:".length).trim();
       } else if (line.startsWith("FieldName:")) {
-        curName = decodeXmlEntities(line.slice("FieldName:".length).trim());
+        curName = decodeFormDataEntities(line.slice("FieldName:".length).trim());
       } else if (line.startsWith("FieldValue:") && curName) {
-        const val = decodeXmlEntities(line.slice("FieldValue:".length).trim());
+        const val = decodeFormDataEntities(line.slice("FieldValue:".length).trim());
         if (val === "Yes" || val === "On") {
           out.set(curName, true);
         } else if (val === "Off" || val === "false" || curType === "Button" && val === "") {
@@ -58655,7 +59062,7 @@ async function openStoredPdfObjectReader(store, storage, options) {
       validateIdentity(number, generation);
       const object = number === 0 ? void 0 : await store.get(number);
       if (object?.generationNumber !== generation || !object.stream || object.value.kind !== "dict") throw new PdfError("E_PARSE", "Expected an indexed PDF stream");
-      const dict = await resolvePdfStreamDictionary(object.value, (ref) => reader.get(ref.objectNumber, ref.generationNumber), /* @__PURE__ */ new Set([number]), options);
+      const dict = await resolvePdfStreamDictionary(object.value, (ref) => reader.get(ref.objectNumber, ref.generationNumber), /* @__PURE__ */ new Set([number]), { ...options, referenceStorage: storage });
       const snapshot = object.stream;
       async function* input() {
         for await (const bytes of snapshot.chunks) {
@@ -59079,10 +59486,10 @@ async function* streamRawTextChunks(glyphs, storage, options = {}) {
     }
   })();
   const encoder = new TextEncoder(), buffer = new Uint8Array(chunkBytes);
-  function* encode3(text, offset = 0, limit10 = text.length) {
-    while (offset < limit10) {
-      let end = Math.min(limit10, offset + Math.floor(chunkBytes / 3));
-      if (end < limit10 && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319 && text.charCodeAt(end) >= 56320 && text.charCodeAt(end) <= 57343) end--;
+  function* encode3(text, offset = 0, limit11 = text.length) {
+    while (offset < limit11) {
+      let end = Math.min(limit11, offset + Math.floor(chunkBytes / 3));
+      if (end < limit11 && text.charCodeAt(end - 1) >= 55296 && text.charCodeAt(end - 1) <= 56319 && text.charCodeAt(end) >= 56320 && text.charCodeAt(end) <= 57343) end--;
       const { read, written } = encoder.encodeInto(text.slice(offset, end), buffer);
       offset += read;
       yield buffer.subarray(0, written);
@@ -59471,15 +59878,15 @@ var PdfStagedOutputs = class _PdfStagedOutputs {
   static async create(storage, input, options = {}) {
     const chunkBytes = maximum7(options.chunkBytes, 65536);
     if (chunkBytes < 32 || chunkBytes === Number.MAX_SAFE_INTEGER) throw new RangeError("PDF output chunkBytes must be finite and at least 32");
-    const limit10 = maximum7(options.maxStagingBytes, Infinity);
+    const limit11 = maximum7(options.maxStagingBytes, Infinity);
     const nameLimit = maximum7(options.maxNameChars, 1048576);
     const { signal } = options;
     let written = 0;
-    const names = new PdfNameIndex(storage, () => limit10 - written, signal);
+    const names = new PdfNameIndex(storage, () => limit11 - written, signal);
     let data;
     let index2;
     const charge = (size) => {
-      if (size > limit10 - written - names.stagedBytes) throw new PdfError("E_LIMIT", "PDF output staging byte limit exceeded");
+      if (size > limit11 - written - names.stagedBytes) throw new PdfError("E_LIMIT", "PDF output staging byte limit exceeded");
       written += size;
     };
     async function* records2() {
@@ -59513,7 +59920,7 @@ var PdfStagedOutputs = class _PdfStagedOutputs {
       }
     }
     try {
-      data = await PdfFileSource.fromStream(storage.fs, storage.directory, records2(), { chunkBytes, cacheBytes: chunkBytes, maxInputBytes: limit10, ...signal ? { signal } : {} });
+      data = await PdfFileSource.fromStream(storage.fs, storage.directory, records2(), { chunkBytes, cacheBytes: chunkBytes, maxInputBytes: limit11, ...signal ? { signal } : {} });
       await names.close();
       const source = data;
       async function* rows() {
@@ -59530,7 +59937,7 @@ var PdfStagedOutputs = class _PdfStagedOutputs {
         runEntries: 64,
         chunkBytes: indexChunk,
         cacheBytes: indexChunk,
-        maxStagingBytes: limit10 - data.size,
+        maxStagingBytes: limit11 - data.size,
         ...signal ? { signal } : {}
       });
       return new _PdfStagedOutputs(data, index2, signal, nameLimit);
@@ -59624,7 +60031,7 @@ async function markedText(document2, page2, mcid, storage, options) {
     };
     var boundary = boundary2, scan = scan2;
     source = await PdfFileSource.fromStream(storage.fs, storage.directory, input(), { chunkBytes, cacheBytes: chunkBytes, maxInputBytes: maximum10, ...signal ? { signal } : {} });
-    const resources = (await document2.lookup(dictGet(page2, "Resources")))?.value;
+    const resources = (await document2.lookup(dictGet(page2, "Resources"), void 0, ["Resources"]))?.value;
     const properties = resources?.kind === "dict" ? (await document2.lookup(dictGet(resources, "Properties"), void 0, ["Properties"]))?.value : void 0;
     const operators2 = parseContentRangeOperators(source, storage, { chunkBytes, maxStagingBytes: maximum10 - source.size, ...signal ? { signal } : {} });
     let pending, matching = false, inText = false, part = 0, recorded = false;
@@ -60054,7 +60461,7 @@ async function* walkRetainedImages(document2, storage, options) {
   let imageIndex = 0;
   let stagedBytes = 0;
   async function dictionary(node, resourceKey) {
-    const value = await document2.lookup(node, void 0, resourceKey ? [resourceKey] : void 0);
+    const value = await document2.lookup(node, void 0, resourceKey ? resourceKey === "Resources" ? [resourceKey] : ["Resources", resourceKey] : void 0);
     return value?.value.kind === "dict" && !value.stream ? value.value : void 0;
   }
   async function number(node, fallback) {
@@ -60174,7 +60581,7 @@ async function* walkRetainedImages(document2, storage, options) {
               try {
                 yield* content(
                   document2.objects.decodeStream(ref.objectNumber, ref.generationNumber),
-                  await dictionary(dictGet(target.value, "Resources")) ?? activeResources,
+                  await dictionary(dictGet(target.value, "Resources"), "Resources") ?? activeResources,
                   transform,
                   active,
                   depth + 1
@@ -60204,7 +60611,7 @@ async function* walkRetainedImages(document2, storage, options) {
       if (value.stream && value.reference) {
         yield* content(
           document2.objects.decodeStream(value.reference.objectNumber, value.reference.generationNumber),
-          await dictionary(dictGet(value.value, "Resources")) ?? inherited,
+          await dictionary(dictGet(value.value, "Resources"), "Resources") ?? inherited,
           identity,
           /* @__PURE__ */ new Set([value.reference.objectNumber]),
           0
@@ -60213,8 +60620,8 @@ async function* walkRetainedImages(document2, storage, options) {
     }
     try {
       yield* content(page2.streamContents(), resources, identity, /* @__PURE__ */ new Set(), 0);
-      const patterns = await dictionary(dictGet(resources, "Pattern"));
-      if (patterns) for (const entry of patterns.entries) yield* auxiliary(entry.value, resources);
+      const patterns = await dictionary(dictGet(resources, "Pattern"), "Pattern");
+      if (patterns) for await (const entry of readPdfDictionaryEntries(patterns, options.signal)) yield* auxiliary(entry.value, resources);
       const fonts = await dictionary(dictGet(resources, "Font"), "Font");
       if (fonts) for await (const entry of readPdfDictionaryEntries(fonts, options.signal)) {
         const font = await dictionary(entry.value);
@@ -60222,7 +60629,7 @@ async function* walkRetainedImages(document2, storage, options) {
         const subtype = (await document2.lookup(dictGet(font, "Subtype")))?.value;
         if (subtype?.kind !== "name" || subtype.decoded !== "Type3") continue;
         const procedures = await dictionary(dictGet(font, "CharProcs"));
-        const inherited = await dictionary(dictGet(font, "Resources")) ?? resources;
+        const inherited = await dictionary(dictGet(font, "Resources"), "Resources") ?? resources;
         if (procedures) for (const entry2 of procedures.entries) yield* auxiliary(entry2.value, inherited);
       }
       const annotations = (await document2.lookup(dictGet(page2.dict, "Annots")))?.value;
@@ -60270,7 +60677,7 @@ async function* walkRetainedFonts(document2, storage, options) {
   if (!Number.isSafeInteger(first) || first < 1 || last !== Infinity && (!Number.isSafeInteger(last) || last < first)) throw new RangeError("Invalid PDF font page range");
   let failed = false;
   async function dictionary(node, resourceKey) {
-    const resolved = await document2.lookup(node, void 0, resourceKey ? [resourceKey] : void 0);
+    const resolved = await document2.lookup(node, void 0, resourceKey ? resourceKey === "Resources" ? [resourceKey] : ["Resources", resourceKey] : void 0);
     return resolved?.value.kind === "dict" && !resolved.stream ? resolved.value : void 0;
   }
   async function* font(node, key, depth) {
@@ -60300,7 +60707,7 @@ async function* walkRetainedFonts(document2, storage, options) {
     const enc = (await document2.lookup(dictGet(value, "Encoding")))?.value;
     const encoding = enc?.kind === "name" ? enc.decoded === "WinAnsiEncoding" ? "WinAnsi" : enc.decoded === "MacRomanEncoding" ? "MacRoman" : enc.decoded === "StandardEncoding" ? "Standard" : enc.decoded : enc?.kind === "dict" ? "Custom" : "Builtin";
     yield { name, type, encoding, embedded, unicode: Boolean(dictGet(value, "ToUnicode")), ...node.kind === "ref" ? { reference: node } : {} };
-    if (raw === "Type3") yield* resources(await dictionary(dictGet(value, "Resources")), depth + 1);
+    if (raw === "Type3") yield* resources(await dictionary(dictGet(value, "Resources"), "Resources"), depth + 1);
   }
   async function* resources(value, depth) {
     options.signal?.throwIfAborted();
@@ -60308,8 +60715,8 @@ async function* walkRetainedFonts(document2, storage, options) {
     if (depth > options.maxDepth) throw new PdfError("E_LIMIT", "PDF font resource depth limit exceeded");
     const fonts = await dictionary(dictGet(value, "Font"), "Font");
     if (fonts) for await (const entry of readPdfDictionaryEntries(fonts, options.signal)) yield* font(entry.value, entry.key.decoded, depth);
-    const states = await dictionary(dictGet(value, "ExtGState"));
-    if (states) for (const entry of states.entries) {
+    const states = await dictionary(dictGet(value, "ExtGState"), "ExtGState");
+    if (states) for await (const entry of readPdfDictionaryEntries(states, options.signal)) {
       const state = await dictionary(entry.value);
       const gsFont = state ? (await document2.lookup(dictGet(state, "Font")))?.value : void 0;
       if (gsFont?.kind === "array" && gsFont.items[0]) yield* font(gsFont.items[0], `ExtGS_${entry.key.decoded}`, depth);
@@ -60323,7 +60730,7 @@ async function* walkRetainedFonts(document2, storage, options) {
         if (!resolved?.stream || resolved.value.kind !== "dict") continue;
         const subtype = (await document2.lookup(dictGet(resolved.value, "Subtype")))?.value;
         if (key === "XObject" && !(subtype?.kind === "name" && subtype.decoded === "Form")) continue;
-        yield* resources(await dictionary(dictGet(resolved.value, "Resources")), depth + 1);
+        yield* resources(await dictionary(dictGet(resolved.value, "Resources"), "Resources"), depth + 1);
       }
     }
   }
@@ -60341,10 +60748,10 @@ async function* walkRetainedFonts(document2, storage, options) {
         for (const key of ["N", "R", "D"]) {
           const ap = await document2.lookup(dictGet(appearance, key));
           if (ap?.value.kind !== "dict") continue;
-          if (ap.stream) yield* resources(await dictionary(dictGet(ap.value, "Resources")), 0);
+          if (ap.stream) yield* resources(await dictionary(dictGet(ap.value, "Resources"), "Resources"), 0);
           else for (const entry of ap.value.entries) {
             const stream = await document2.lookup(entry.value);
-            if (stream?.stream && stream.value.kind === "dict") yield* resources(await dictionary(dictGet(stream.value, "Resources")), 0);
+            if (stream?.stream && stream.value.kind === "dict") yield* resources(await dictionary(dictGet(stream.value, "Resources"), "Resources"), 0);
           }
         }
       }
@@ -60432,7 +60839,7 @@ async function* walkRetainedAttachments(document2, storage, options) {
 }
 
 // packages/pdf-ast/src/retained-document.ts
-function limit8(value, name, fallback) {
+function limit9(value, name, fallback) {
   const result = value ?? fallback;
   if (result !== Infinity && (!Number.isSafeInteger(result) || result < 0)) throw new RangeError(`Invalid ${name}`);
   return result;
@@ -60461,9 +60868,9 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
   walks = /* @__PURE__ */ new Set();
   closing;
   static async open(source, storage, options = {}) {
-    const maxPages = limit8(options.maxPages, "maxPages", Infinity);
-    const maxPageTreeDepth = limit8(options.maxPageTreeDepth, "maxPageTreeDepth", 100);
-    const maxTraversalStagingBytes = limit8(options.maxTraversalStagingBytes, "maxTraversalStagingBytes", Infinity);
+    const maxPages = limit9(options.maxPages, "maxPages", Infinity);
+    const maxPageTreeDepth = limit9(options.maxPageTreeDepth, "maxPageTreeDepth", 100);
+    const maxTraversalStagingBytes = limit9(options.maxTraversalStagingBytes, "maxTraversalStagingBytes", Infinity);
     const controller = new AbortController();
     const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
     const configured = { ...options, signal, maxPages, maxPageTreeDepth, maxTraversalStagingBytes };
@@ -60473,9 +60880,9 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
   /** Read an editable caller-backed graph without normalizing it through a PDF
    * save. The caller retains ownership of the store and its object identities. */
   static async openStore(store, storage, options) {
-    const maxPages = limit8(options.maxPages, "maxPages", Infinity);
-    const maxPageTreeDepth = limit8(options.maxPageTreeDepth, "maxPageTreeDepth", 100);
-    const maxTraversalStagingBytes = limit8(options.maxTraversalStagingBytes, "maxTraversalStagingBytes", Infinity);
+    const maxPages = limit9(options.maxPages, "maxPages", Infinity);
+    const maxPageTreeDepth = limit9(options.maxPageTreeDepth, "maxPageTreeDepth", 100);
+    const maxTraversalStagingBytes = limit9(options.maxTraversalStagingBytes, "maxTraversalStagingBytes", Infinity);
     const controller = new AbortController();
     const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
     const configured = { ...options, signal, maxPages, maxPageTreeDepth, maxTraversalStagingBytes };
@@ -60487,8 +60894,10 @@ var PdfRetainedDocument = class _PdfRetainedDocument {
     this.options.signal?.throwIfAborted();
   }
   /** Resolve a bounded reference chain, retaining the final stream's identity. */
-  async lookup(node, arrays = this.options.valueArrays ?? {}, arrayPathPrefix) {
+  async lookup(node, arrays = this.options.valueArrays ?? {}, arrayPathPrefix, storeRootDictionary = false, rootArrayStorage) {
     this.assertOpen();
+    if (rootArrayStorage) arrays = { ...arrays, arrayStorage: arrays.arrayStorage ?? rootArrayStorage, storeRootArray: true };
+    if (storeRootDictionary && arrays.dictionaryStorage) arrays = { ...arrays, storeRootDictionary: true };
     if (arrayPathPrefix) arrays = {
       ...arrays,
       arrayPathPrefix,
@@ -61064,7 +61473,7 @@ var PdfRetainedPage = class {
       for (const key of keys) {
         const entry = dictGet(current, key);
         if (values.has(key) || !entry) continue;
-        const value = (await this.document.lookup(entry))?.value;
+        const value = (await this.document.lookup(entry, void 0, key === "Resources" ? ["Resources"] : void 0))?.value;
         if (key.endsWith("Box")) {
           const rectangle = await box(value, this.document);
           if (!rectangle) continue;
@@ -61281,6 +61690,82 @@ async function* encodeRetainedPng(width, height, input, storage, options = {}) {
   }
 }
 
+// packages/pdf-ast/src/render/svg-image-stream.ts
+async function* encodeSvgImageChunks(image, pageHeight, storage, options = {}) {
+  const { signal } = options;
+  signal?.throwIfAborted();
+  if (!image.decodedRgba && !image.storedRgba) return;
+  const { width, height } = image, chunkBytes = options.chunkBytes ?? 65536, maximum10 = options.maxOutputBytes ?? Infinity;
+  if (![width, height].every((value) => Number.isSafeInteger(value) && value > 0 && value <= 4294967295) || !Number.isSafeInteger(width * height * 4)) throw new PdfError("E_LIMIT", "SVG image dimension limit exceeded");
+  if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 1) throw new RangeError("Invalid SVG image chunk size");
+  if (maximum10 !== Infinity && (!Number.isSafeInteger(maximum10) || maximum10 < 0)) throw new RangeError("Invalid SVG output byte limit");
+  const [a, b, c, d, e, f] = image.matrix;
+  const prefix = `<image width="1" height="1" preserveAspectRatio="none" transform="matrix(${a} ${-b} ${-c} ${d} ${e + c} ${pageHeight - f - d})" href="data:image/png;base64,`, suffix = '"/>';
+  const encoder = new TextEncoder(), header2 = encoder.encode(prefix), tail = encoder.encode(suffix), available = maximum10 - header2.length - tail.length;
+  const pngMaximum = maximum10 === Infinity ? Infinity : Math.floor(available / 4) * 3;
+  if (pngMaximum < 57) throw new PdfError("E_LIMIT", "SVG image output byte limit exceeded");
+  let outputBytes = 0;
+  function* emit(bytes) {
+    if (bytes.length > maximum10 - outputBytes) throw new PdfError("E_LIMIT", "SVG image output byte limit exceeded");
+    outputBytes += bytes.length;
+    for (let at = 0; at < bytes.length; at += chunkBytes) {
+      signal?.throwIfAborted();
+      yield bytes.slice(at, at + chunkBytes);
+    }
+  }
+  async function* pixels() {
+    if (image.decodedRgba) {
+      for (let at = 0; at < image.decodedRgba.length; at += chunkBytes) {
+        signal?.throwIfAborted();
+        yield image.decodedRgba.subarray(at, at + chunkBytes);
+      }
+      return;
+    }
+    const source = image.storedRgba;
+    for (let at = 0; at < width * height * 4; ) {
+      signal?.throwIfAborted();
+      const count = Math.min(chunkBytes, width * height * 4 - at), bytes = await source.storage.read(source.position + at, count, signal ? { signal } : void 0);
+      if (bytes.length > count) throw new Error("Oversized SVG pixel read");
+      if (!bytes.length) return;
+      yield bytes;
+      at += bytes.length;
+    }
+  }
+  yield* emit(header2);
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const buffer = new Uint8Array(Math.min(8192, Math.max(4, chunkBytes))), triple = new Uint8Array(3);
+  let used = 0, pending = 0, work = 0;
+  function group(count) {
+    const n = triple[0] << 16 | triple[1] << 8 | triple[2];
+    buffer[used++] = alphabet.charCodeAt(n >>> 18);
+    buffer[used++] = alphabet.charCodeAt(n >>> 12 & 63);
+    buffer[used++] = count > 1 ? alphabet.charCodeAt(n >>> 6 & 63) : 61;
+    buffer[used++] = count > 2 ? alphabet.charCodeAt(n & 63) : 61;
+    triple.fill(0);
+    pending = 0;
+  }
+  const capacity = buffer.length - buffer.length % 4;
+  for await (const bytes of encodeRetainedPng(width, height, pixels(), storage, { ...options, alpha: "rgba", maxOutputBytes: pngMaximum })) {
+    for (const byte3 of bytes) {
+      triple[pending++] = byte3;
+      if (pending === 3) {
+        group(3);
+        if (used === capacity) {
+          yield* emit(buffer.subarray(0, used));
+          used = 0;
+        }
+        if (++work % 4096 === 0) {
+          await new Promise((resolve2) => setTimeout(resolve2, 0));
+          signal?.throwIfAborted();
+        }
+      }
+    }
+  }
+  if (pending) group(pending);
+  if (used) yield* emit(buffer.subarray(0, used));
+  yield* emit(tail);
+}
+
 // packages/pdf-ast/src/render/retained-tiff.ts
 function maximum9(value) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
@@ -61855,6 +62340,12 @@ async function createRetainedPageCopy(input, indicesOrStorage, storageOrOptions,
           const value = await box(key);
           if (value[0] !== 0 || value[1] !== 0 || value[2] !== width || value[3] !== height) dictSet(page2, key, cosArray(value.map((value2) => cosNumber(value2))));
         }
+        dictSet(page2, "Parent", cosRef(2));
+        const boxes = options.pageBoxes?.({ width, height }, selection.index);
+        for (const [key, value] of [["MediaBox", boxes?.mediaBox], ["CropBox", boxes?.cropBox]]) if (value) {
+          if (value.length !== 4 || !value.every(Number.isFinite)) throw new RangeError("Invalid copied page box");
+          dictSet(page2, key, cosArray(value.map((coordinate) => cosNumber(coordinate))));
+        }
         await store.set({ objectNumber: pageRef.objectNumber, generationNumber: 0, value: page2 });
       }
       const sourceCatalog = await sourceValue(document2.crossReference.rootRef), acro = sourceCatalog?.kind === "dict" ? await sourceValue(dictGet(sourceCatalog, "AcroForm")) : void 0;
@@ -62017,13 +62508,13 @@ async function* copyRetainedPagesChunks(input, indicesOrStorage, storageOrOption
 }
 
 // packages/pdf-ast/src/cos/retained-objects.ts
-function limit9(value) {
+function limit10(value) {
   if (value === void 0 || value === Infinity) return Number.MAX_SAFE_INTEGER;
   if (!Number.isSafeInteger(value) || value < 0) throw new RangeError("Invalid retained object limit");
   return value;
 }
 async function* retainedCosObjects(document2, storage, options = {}) {
-  const maxObjects = limit9(options.maxObjects), maxStreamBytes = limit9(options.maxStreamBytes), signal = options.signal;
+  const maxObjects = limit10(options.maxObjects), maxStreamBytes = limit10(options.maxStreamBytes), signal = options.signal;
   let count = 0;
   for await (const entry of document2.crossReference.index.entries(signal)) {
     signal?.throwIfAborted();
@@ -62389,16 +62880,329 @@ async function* saveRetainedDocumentChunks(document2, storage, options = {}) {
   }
 }
 
+// packages/pdf-ast/src/edit/retained-flatten-forms.ts
+import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
+async function flattenRetainedForms(document2, store, storage, signal) {
+  if (!document2.crossReference.rootRef) return;
+  const backing = new PagedStorage13({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), names = new PdfNameIndex(storage, Infinity, signal), baked = new IntegerTable8(backing), active = new IntegerTable8(backing), fields2 = new IntegerTable8(backing), pagesSeen = new IntegerTable8(backing), walkMarks = new IntegerTable8(backing);
+  let head = -1, fieldCount = 0, work = 0, walk = 0, failed = false;
+  async function checkpoint(depth = 0) {
+    signal.throwIfAborted();
+    if (depth > document2.depthLimit) throw new PdfError("E_LIMIT", "PDF form field depth limit exceeded");
+    if (++work % 64 === 0) {
+      await new Promise((resolve3) => setTimeout(resolve3, 0));
+      signal.throwIfAborted();
+    }
+  }
+  const child = (location, key) => ({ reference: location.reference, path: [...location.path, key] });
+  async function locate(location) {
+    let owner = await store.get(location.reference.objectNumber);
+    if (!owner || owner.generationNumber !== location.reference.generationNumber || owner.stream) return;
+    let value = owner.value, path = [], reference = location.reference, refs = 0;
+    for (let i = 0; i <= location.path.length; i++) {
+      while (value?.kind === "ref") {
+        await checkpoint(++refs);
+        reference = value;
+        owner = await store.get(value.objectNumber);
+        if (!owner || owner.generationNumber !== reference.generationNumber || owner.stream) return;
+        value = owner.value;
+        path = [];
+      }
+      if (!value) return;
+      if (i === location.path.length) return { value, owner, location: { reference, path } };
+      const key = location.path[i];
+      path.push(key);
+      value = typeof key === "number" ? value.kind === "array" ? value.items[key] : void 0 : value.kind === "dict" ? dictGet(value, key) : void 0;
+    }
+  }
+  async function identity(location) {
+    return (await names.intern(`${location.reference.objectNumber}:${location.reference.generationNumber}:${JSON.stringify(location.path)}`)).index;
+  }
+  async function resolve2(node) {
+    const found = await document2.lookup(node);
+    return found?.stream ? void 0 : found?.value;
+  }
+  async function number(node, fallback) {
+    const value = await resolve2(node);
+    return value?.kind === "number" ? value.value : fallback;
+  }
+  async function push(frame) {
+    head = await appendStoredRecord(backing, { frame, previous: head }, -1, signal);
+  }
+  async function set(location, key, value) {
+    const found = await locate(location);
+    if (found?.value.kind === "dict") {
+      dictSet(found.value, key, value);
+      await store.set(found.owner);
+    }
+  }
+  async function stream(dict, chunks) {
+    const source = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks, { signal });
+    let failed2 = false;
+    try {
+      dictSet(dict, "Length", cosNumber(source.size));
+      const ref = await store.allocate();
+      await store.set({ objectNumber: ref.objectNumber, generationNumber: 0, value: dict, stream: { length: source.size, chunks: source.stream(0, source.size, signal), decoded: true } });
+      return ref;
+    } catch (error) {
+      failed2 = true;
+      throw error;
+    } finally {
+      await source.close().catch((error) => {
+        if (!failed2) throw error;
+      });
+    }
+  }
+  async function append(page2, ref) {
+    const found = await locate(page2);
+    if (found?.value.kind !== "dict") return;
+    const existing = dictGet(found.value, "Contents");
+    if (!existing) {
+      dictSet(found.value, "Contents", ref);
+      await store.set(found.owner);
+      return;
+    }
+    const contents = await locate(child(page2, "Contents"));
+    if (contents?.value.kind === "array") {
+      contents.value.items.push(ref);
+      await store.set(contents.owner);
+    } else {
+      dictSet(found.value, "Contents", cosArray([existing, ref]));
+      await store.set(found.owner);
+    }
+  }
+  async function inheritedResources(page2) {
+    const mark = BigInt(++walk);
+    let location = page2;
+    while (location) {
+      await checkpoint();
+      const found = await locate(location);
+      if (found?.value.kind !== "dict") return;
+      const key = BigInt(await identity(found.location));
+      if (await walkMarks.get(key) === mark) return;
+      await walkMarks.set(key, mark);
+      const node = dictGet(found.value, "Resources");
+      if (node !== void 0) {
+        const value = await resolve2(node);
+        return value?.kind === "dict" ? value : void 0;
+      }
+      location = child(found.location, "Parent");
+    }
+  }
+  const encoder = new TextEncoder();
+  function* textChunks(text, x, y, font) {
+    yield encoder.encode(`
+q BT /${font} 11 Tf `);
+    const normalized = text.replaceAll("\r\n", "\n");
+    let offset = 0, line = 0;
+    while (offset <= normalized.length) {
+      signal.throwIfAborted();
+      const end = normalized.indexOf("\n", offset), part = normalized.slice(offset, end < 0 ? normalized.length : end);
+      yield encoder.encode(line++ ? " 0 -13 Td (" : `${Math.round(x)} ${Math.round(y)} Td (`);
+      let escaped = "";
+      for (const char of part) {
+        escaped += (char === "(" || char === ")" || char === "\\" ? "\\" : "") + char;
+        if (escaped.length >= 2048) {
+          yield encoder.encode(escaped);
+          escaped = "";
+        }
+      }
+      if (escaped) yield encoder.encode(escaped);
+      yield encoder.encode(") Tj");
+      if (end < 0) break;
+      offset = end + 1;
+    }
+    yield encoder.encode(" ET Q\n");
+  }
+  async function draw(page2, text, x, y) {
+    if (!text) return;
+    let resources = await locate(child(page2, "Resources"));
+    if (resources?.value.kind !== "dict") {
+      await set(page2, "Resources", cosDict({}));
+      resources = await locate(child(page2, "Resources"));
+    }
+    const resourceLocation = resources.location;
+    let fonts = await locate(child(resourceLocation, "Font"));
+    if (fonts?.value.kind !== "dict") {
+      await set(resourceLocation, "Font", cosDict({}));
+      fonts = await locate(child(resourceLocation, "Font"));
+    }
+    const font = fonts.value, key = dictGet(font, "F1") ? "F_AcroFlat" : "F1";
+    if (!dictGet(font, key)) {
+      dictSet(font, key, await store.allocate(cosDict({ Type: cosName("Font"), Subtype: cosName("Type1"), BaseFont: cosName("Helvetica") })));
+      await store.set(fonts.owner);
+    }
+    await append(page2, await stream(cosDict({}), textChunks(text, x, y, key)));
+  }
+  async function textValue(node, arrays) {
+    if (node?.kind === "string") return decodePdfString(node);
+    if (node?.kind === "name" && node.decoded !== "Off") return node.decoded;
+    if (node?.kind === "boolean" && node.value) return "Yes";
+    if (arrays && node?.kind === "array") {
+      let text = "", count = 0;
+      for (const item of node.items) {
+        await checkpoint();
+        const value = await resolve2(item);
+        if (value?.kind === "string" || value?.kind === "name") text += (count++ ? ", " : "") + (value.kind === "string" ? decodePdfString(value) : value.decoded);
+      }
+      return text;
+    }
+    return "";
+  }
+  const root = { reference: document2.crossReference.rootRef, path: [] }, form = child(root, "AcroForm");
+  try {
+    const fieldArray = await locate(child(form, "Fields"));
+    if (fieldArray?.value.kind === "array") for (let i = fieldArray.value.items.length - 1; i >= 0; i--) {
+      await checkpoint();
+      await push({ location: child(fieldArray.location, i), named: false, ft: "", depth: 0 });
+    }
+    while (head !== -1) {
+      const record = (await readStoredRecord(backing, head, signal)).value;
+      head = record.previous;
+      const frame = record.frame;
+      if ("exit" in frame) {
+        await active.set(BigInt(frame.exit), 0n);
+        continue;
+      }
+      await checkpoint(frame.depth);
+      const found = await locate(frame.location);
+      if (found?.value.kind !== "dict") continue;
+      const id = await identity(found.location);
+      if (await active.get(BigInt(id))) continue;
+      await active.set(BigInt(id), 1n);
+      await push({ exit: id });
+      const name = await resolve2(dictGet(found.value, "T")), type = await resolve2(dictGet(found.value, "FT")), named = frame.named || (name?.kind === "string" ? !!decodePdfString(name) : name?.kind === "name" ? !!name.decoded : false), ft = type?.kind === "name" ? type.decoded : frame.ft;
+      const kids = await locate(child(found.location, "Kids"));
+      let descend = false;
+      if (kids?.value.kind === "array" && kids.value.items.length) {
+        let namedKids = false;
+        for (let i = 0; i < kids.value.items.length; i++) {
+          await checkpoint();
+          const kid = await locate(child(kids.location, i));
+          if (kid?.value.kind === "dict" && dictGet(kid.value, "T")) {
+            namedKids = true;
+            break;
+          }
+        }
+        descend = namedKids || !ft || !named;
+        if (descend) for (let i = kids.value.items.length - 1; i >= 0; i--) {
+          await checkpoint();
+          await push({ location: child(kids.location, i), named, ft, depth: frame.depth + 1 });
+        }
+      }
+      if (!descend && named) {
+        const at = await appendStoredRecord(backing, found.location, -1, signal);
+        await fields2.set(BigInt(fieldCount++), BigInt(at));
+      }
+    }
+    let firstPage;
+    for await (const page2 of document2.pages()) {
+      await checkpoint();
+      if (!page2.reference) throw new PdfError("E_PARSE", "Expected retained form page reference");
+      const pageLocation = { reference: page2.reference, path: [] };
+      if (!firstPage) firstPage = pageLocation;
+      if (await pagesSeen.get(BigInt(page2.reference.objectNumber))) continue;
+      await pagesSeen.set(BigInt(page2.reference.objectNumber), 1n);
+      const annotations = await locate(child(pageLocation, "Annots"));
+      if (annotations?.value.kind !== "array") continue;
+      const survivors = [];
+      for (let i = 0; i < annotations.value.items.length; i++) {
+        await checkpoint();
+        const annotation = await locate(child(annotations.location, i));
+        if (annotation?.value.kind !== "dict") {
+          survivors.push(annotations.value.items[i]);
+          continue;
+        }
+        const subtype = await resolve2(dictGet(annotation.value, "Subtype"));
+        if (!(subtype?.kind === "name" && subtype.decoded === "Widget") && !dictGet(annotation.value, "FT") && !dictGet(annotation.value, "T")) {
+          survivors.push(annotations.value.items[i]);
+          continue;
+        }
+        await baked.set(BigInt(await identity(annotation.location)), 1n);
+        const parent = await locate(child(annotation.location, "Parent"));
+        if (parent?.value.kind === "dict") await baked.set(BigInt(await identity(parent.location)), 1n);
+        const rect = await resolve2(dictGet(annotation.value, "Rect")), items = rect?.kind === "array" ? rect.items : [];
+        const x = await number(items[0], 50), y = await number(items[1], 700), ownState = await resolve2(dictGet(annotation.value, "AS"));
+        const value = ownState ?? await resolve2(dictGet(annotation.value, "V") ?? (parent?.value.kind === "dict" ? dictGet(parent.value, "V") ?? dictGet(parent.value, "AS") : void 0));
+        const appearance = await locate(child(annotation.location, "AP"));
+        let normal = appearance?.value.kind === "dict" ? await document2.lookup(dictGet(appearance.value, "N")) : void 0;
+        if (normal?.value.kind === "dict" && !normal.stream && value?.kind === "name" && value.decoded !== "Off") normal = await document2.lookup(dictGet(normal.value, value.decoded));
+        if (normal?.stream && normal.reference && normal.value.kind === "dict") {
+          const inherited = await inheritedResources(pageLocation), resources = { kind: "dict", entries: [...inherited?.entries ?? []] };
+          const old = await resolve2(dictGet(resources, "XObject")), objects = { kind: "dict", entries: [...old?.kind === "dict" ? old.entries : []] };
+          let suffix = 1;
+          while (dictGet(objects, `AcroAppearance${suffix}`)) {
+            await checkpoint();
+            suffix++;
+          }
+          const name = `AcroAppearance${suffix}`, dict = { kind: "dict", entries: [...normal.value.entries] };
+          dictSet(dict, "Type", cosName("XObject"));
+          dictSet(dict, "Subtype", cosName("Form"));
+          const original = await store.get(normal.reference.objectNumber), ref = await store.allocate();
+          if (!original?.stream) throw new PdfError("E_PARSE", "Missing retained appearance stream");
+          await store.set({ ...original, objectNumber: ref.objectNumber, generationNumber: 0, value: dict });
+          dictSet(objects, name, ref);
+          dictSet(resources, "XObject", objects);
+          await set(pageLocation, "Resources", resources);
+          const r2 = await resolve2(items[2]), r3 = await resolve2(items[3]), width = r2?.kind === "number" ? Math.max(1, Math.abs(r2.value - x)) : 20, height = r3?.kind === "number" ? Math.max(1, Math.abs(r3.value - y)) : 20;
+          const bbox = await resolve2(dictGet(dict, "BBox"));
+          let bx0 = 0, by0 = 0, bx1 = width, by1 = height;
+          if (bbox?.kind === "array" && bbox.items.length >= 4) {
+            const b = await Promise.all(bbox.items.slice(0, 4).map(resolve2));
+            if (b.every((v) => v?.kind === "number")) {
+              const n = b;
+              bx0 = Math.min(n[0].value, n[2].value);
+              by0 = Math.min(n[1].value, n[3].value);
+              bx1 = Math.max(n[0].value, n[2].value);
+              by1 = Math.max(n[1].value, n[3].value);
+            }
+          }
+          const matrix2 = await resolve2(dictGet(dict, "Matrix")), values = matrix2?.kind === "array" && matrix2.items.length >= 6 ? await Promise.all(matrix2.items.slice(0, 6).map((v) => number(v, 0))) : [1, 0, 0, 1, 0, 0];
+          const [ma, mb, mc, md, me, mf] = values, corners = [[bx0 * ma + by0 * mc + me, bx0 * mb + by0 * md + mf], [bx1 * ma + by0 * mc + me, bx1 * mb + by0 * md + mf], [bx0 * ma + by1 * mc + me, bx0 * mb + by1 * md + mf], [bx1 * ma + by1 * mc + me, bx1 * mb + by1 * md + mf]];
+          const minX = Math.min(...corners.map((c) => c[0])), minY = Math.min(...corners.map((c) => c[1])), bw = Math.max(1, Math.max(...corners.map((c) => c[0])) - minX), bh = Math.max(1, Math.max(...corners.map((c) => c[1])) - minY);
+          const sx = Number((width / bw).toFixed(6)), sy = Number((height / bh).toFixed(6)), tx = Number((x - minX * sx).toFixed(6)), ty = Number((y - minY * sy).toFixed(6));
+          await append(pageLocation, await stream(cosDict({}), [encoder.encode(`
+q ${sx} 0 0 ${sy} ${tx} ${ty} cm /${name} Do Q
+`)]));
+        } else await draw(pageLocation, await textValue(value, true), x + 2, y + 4);
+      }
+      await set(pageLocation, "Annots", cosArray(survivors));
+    }
+    if (!firstPage) return;
+    for (let i = 0; i < fieldCount; i++) {
+      await checkpoint();
+      const location = (await readStoredRecord(backing, Number(await fields2.get(BigInt(i))), signal)).value, field2 = await locate(location);
+      if (field2?.value.kind !== "dict" || await baked.get(BigInt(await identity(field2.location)))) continue;
+      const rect = await resolve2(dictGet(field2.value, "Rect")), items = rect?.kind === "array" ? rect.items : [], x = await number(items[0], 50), y = await number(items[1], 700), value = await resolve2(dictGet(field2.value, "V") ?? dictGet(field2.value, "AS"));
+      await draw(firstPage, await textValue(value, false), x + 2, y + 4);
+    }
+    const latest = await locate(form);
+    if (latest?.value.kind === "dict") {
+      dictSet(latest.value, "Fields", cosArray([]));
+      dictSet(latest.value, "NeedAppearances", cosBool(false));
+      await store.set(latest.owner);
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([backing.close(), names.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
 // packages/pdf-ast/src/edit/retained-info-updates.ts
-import { PagedStorage as PagedStorage14 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/retained-bookmarks.ts
-import { PagedStorage as PagedStorage13 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage14 } 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 frames = new PagedStorage14({ 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) {
@@ -62471,7 +63275,7 @@ async function setRetainedBookmarks(store, storage, root, pageCount, pageReferen
 
 // packages/pdf-ast/src/edit/retained-info-updates.ts
 async function applyRetainedInfoUpdates(document2, store, storage, count, getPage, updates, signal, maxDepth) {
-  const pages = new PagedStorage14({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const pages = new PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const base = pages.allocate(count * 4 * 48), heads = [-1, -1, -1, -1], tails = [-1, -1, -1, -1];
   const labels = new PdfMutableObjectStore(storage, { signal }), bookmarks = new PdfMutableObjectStore(storage, { signal });
   let infoRef = document2.crossReference.infoRef, idArray = document2.crossReference.idArray, labelCount = 0, work = 0, failed = false;
@@ -62713,7 +63517,7 @@ async function appendRetainedAttachments(document2, target, storage, attachments
 }
 
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
-import { IntegerTable as IntegerTable8, PagedStorage as PagedStorage15 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage16 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/form-appearance-chunks.ts
 function* serializeFormAppearanceChunks(text, options) {
@@ -62801,7 +63605,7 @@ function* operators(text, options) {
 // packages/pdf-ast/src/edit/retained-form-appearances.ts
 async function generateRetainedFormAppearances(document2, store, storage, signal, update) {
   if (!document2.crossReference.rootRef) return;
-  const backing = new PagedStorage15({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable8(backing);
+  const backing = new PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), active = new IntegerTable9(backing);
   let head = -1, failed = false, work = 0;
   let matched = false;
   let defaultAppearance;
@@ -62848,6 +63652,7 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
     const source = await PdfFileSource.fromStream(storage.fs, storage.directory, chunks, { signal });
     let failed2 = false;
     try {
+      if (update && dict.kind === "dict") dictSet(dict, "Length", cosNumber(source.size));
       const ref = await store.allocate();
       await store.set({ objectNumber: ref.objectNumber, generationNumber: 0, value: dict, stream: { length: source.size, chunks: source.stream(0, source.size, signal), decoded: true } });
       return ref;
@@ -63099,17 +63904,17 @@ async function generateRetainedFormAppearances(document2, store, storage, signal
 }
 
 // packages/pdf-ast/src/edit/retained-flatten-annotations.ts
-import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage19 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
 
 // packages/pdf-ast/src/edit/retained-content-edit.ts
-import { IntegerTable as IntegerTable9, PagedStorage as PagedStorage16 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable10, PagedStorage as PagedStorage17 } 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 PagedStorage16({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-    this.counts = new IntegerTable9(this.backing);
+    this.backing = new PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+    this.counts = new IntegerTable10(this.backing);
     this.identities = new PdfNameIndex(storage, Infinity, signal);
   }
   store;
@@ -63180,14 +63985,14 @@ var RetainedContentEditor = class _RetainedContentEditor {
 };
 
 // packages/pdf-ast/src/edit/retained-name-replacement.ts
-import { PagedStorage as PagedStorage17 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage18 } 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 PagedStorage17({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), length = oldName.length + 1;
+  const table = new PagedStorage18({ 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;
@@ -63265,10 +64070,10 @@ async function* replaceRetainedPdfName(input, oldName, newName, storage, options
 }
 
 // packages/pdf-ast/src/edit/retained-draw-text.ts
-import { PagedStorage as PagedStorage18 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage19 } 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 PagedStorage18({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const backing = new PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   let failed = false;
   try {
     const name = await font(), position = backing.allocate(text.length);
@@ -63344,7 +64149,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 PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+      const survivorStorage = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
       const survivorBase = survivorStorage.allocate(0);
       let pageFailed = false;
       try {
@@ -63430,7 +64235,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 PagedStorage19({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable10(backing), names = new PdfNameIndex(storage, Infinity, signal);
+            const backing = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), renames = new IntegerTable11(backing), names = new PdfNameIndex(storage, Infinity, signal);
             let appearanceFailed = false, count = 0;
             try {
               if (content.size) {
@@ -63549,11 +64354,11 @@ q ${scaleX} 0 0 ${scaleY} ${tx} ${ty} cm${matSuffix}
 }
 
 // packages/pdf-ast/src/edit/retained-name-map.ts
-import { PagedStorage as PagedStorage20 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage21 } 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 PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pending = new PagedStorage20({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const trie = new PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), pending = new PagedStorage21({ 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);
@@ -63835,7 +64640,7 @@ async function preserveRetainedStamp(document2, source, page2, other, store, edi
 }
 
 // packages/pdf-ast/src/edit/retained-stamps.ts
-import { IntegerTable as IntegerTable11, PagedStorage as PagedStorage21 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage22 } 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;
@@ -63846,7 +64651,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 PagedStorage21({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable11(backing);
+      const backing = new PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), memo = new IntegerTable12(backing);
       let stampFailed = false;
       async function clone(node, depth = 0) {
         await checkpoint();
@@ -64032,12 +64837,12 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
 }
 
 // packages/pdf-ast/src/edit/retained-inline-images.ts
-import { PagedStorage as PagedStorage22 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage23 } 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 PagedStorage22({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const paths = new PagedStorage23({ 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" };
@@ -64129,7 +64934,7 @@ async function externalizeRetainedInlineImages(document2, store, storage, option
 }
 
 // packages/pdf-ast/src/edit/retained-resource-pruning.ts
-import { IntegerTable as IntegerTable12, PagedStorage as PagedStorage23 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage24 } 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;
@@ -64211,7 +65016,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 PagedStorage23({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable12(backing);
+    const backing = new PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), found = new IntegerTable13(backing);
     let failed = false;
     try {
       const referenced = async (name) => await found.get(BigInt((await names.intern(name)).index)) !== void 0;
@@ -64341,7 +65146,7 @@ async function flattenRetainedRotations(document2, store, storage, signal) {
 }
 
 // packages/pdf-ast/src/edit/retained-attachment-edits.ts
-import { IntegerTable as IntegerTable13, PagedStorage as PagedStorage24 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
 var PdfDuplicateAttachment = class extends PdfError {
   constructor(key) {
     super("E_CAPABILITY", `Duplicate attachment key: ${key}`);
@@ -64352,7 +65157,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 PagedStorage24({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable13(backing), removals = new IntegerTable13(backing);
+  const backing = new PagedStorage25({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), first = new IntegerTable14(backing), removals = new IntegerTable14(backing);
   let failed = false, count = 0, work = 0;
   async function checkpoint() {
     signal.throwIfAborted();
@@ -64554,13 +65359,13 @@ async function* retainedAttachmentNameTokens(document2, storage, root, signal, r
 }
 
 // packages/pdf-ast/src/edit/retained-graph.ts
-import { PagedStorage as PagedStorage25 } from "@poe-platform/safe-fs/storage";
+import { PagedStorage as PagedStorage26 } 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 PagedStorage25({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const pages = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const base = pages.allocate(0);
   let count = 0, document2;
   let closing;
@@ -64687,6 +65492,10 @@ async function editRetainedDocument(source, storage, options = {}) {
       await generateRetainedFormAppearances(document2, store, storage, signal);
       addedObjects = true;
     }
+    if (options.flattenForms) {
+      await flattenRetainedForms(document2, store, storage, signal);
+      addedObjects = true;
+    }
     if (options.removeInfo) {
       await removeRoot(["Metadata"]);
       const found = await document2.lookup(infoRef);
@@ -64794,10 +65603,10 @@ async function* copyRetainedAttachments(document2, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/retained-object-order.ts
-import { IntegerTable as IntegerTable14, PagedStorage as PagedStorage26 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
 async function* retainedObjectOrder(document2, source, storage, signal) {
-  const backing = new PagedStorage26({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-  const seen = new IntegerTable14(backing), streams = new IntegerTable14(backing);
+  const backing = new PagedStorage27({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const seen = new IntegerTable15(backing), streams = new IntegerTable15(backing);
   let failed = false, work = 0;
   async function candidate(number) {
     signal.throwIfAborted();
@@ -64811,7 +65620,7 @@ async function* retainedObjectOrder(document2, source, storage, signal) {
   try {
     if (document2.crossReference.revisionCount) {
       for (const kind of ["uncompressed", "compressed"]) {
-        const revisions = new IntegerTable14(backing);
+        const revisions = new IntegerTable15(backing);
         let offset = document2.crossReference.xrefOffset;
         while (offset !== void 0 && await revisions.get(BigInt(offset)) === void 0) {
           await revisions.set(BigInt(offset), 1n);
@@ -64933,14 +65742,14 @@ async function* encryptRetainedPdfChunks(source, storage, options = {}) {
 }
 
 // packages/pdf-ast/src/cos/qpdf-json-values.ts
-import { IntegerTable as IntegerTable15, PagedStorage as PagedStorage27 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage28 } from "@poe-platform/safe-fs/storage";
 var QpdfJsonValues = class _QpdfJsonValues {
   constructor(tree, storage, signal) {
     this.tree = tree;
     this.signal = signal;
-    this.scratch = new PagedStorage27({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-    this.first = new IntegerTable15(this.scratch, 64);
-    this.next = new IntegerTable15(this.scratch, 64);
+    this.scratch = new PagedStorage28({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+    this.first = new IntegerTable16(this.scratch, 64);
+    this.next = new IntegerTable16(this.scratch, 64);
   }
   tree;
   signal;
@@ -65038,7 +65847,7 @@ var QpdfJsonValues = class _QpdfJsonValues {
       await this.cooperate();
       const header2 = await this.tree.describe(position);
       if (header2.kind === "object") {
-        const hashes = new IntegerTable15(this.scratch, 64);
+        const hashes = new IntegerTable16(this.scratch, 64);
         let head = 0, tail = 0;
         for await (const { key } of order.entries(position)) {
           let hash2 = 0;
@@ -65331,19 +66140,19 @@ var QpdfJsonValues = class _QpdfJsonValues {
 };
 
 // packages/pdf-ast/src/cos/qpdf-json-document.ts
-import { IntegerTable as IntegerTable16, PagedStorage as PagedStorage28 } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable17, PagedStorage as PagedStorage29 } 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 PagedStorage28(
+    this.backing = new PagedStorage29(
       { fs: storage.fs, cwd: storage.directory, env: {}, signal: this.signal },
       4
     );
-    this.positions = new IntegerTable16(this.backing, 64);
-    this.order = new IntegerTable16(this.backing, 64);
-    this.catalogs = new IntegerTable16(this.backing, 64);
+    this.positions = new IntegerTable17(this.backing, 64);
+    this.order = new IntegerTable17(this.backing, 64);
+    this.catalogs = new IntegerTable17(this.backing, 64);
   }
   storage;
   rootRef;
@@ -65406,7 +66215,7 @@ var QpdfJsonDocument = class _QpdfJsonDocument {
       env: {},
       signal: this.signal
     };
-    const tape = new PagedStorage28(context, 4), scratch = new PagedStorage28(context, 4);
+    const tape = new PagedStorage29(context, 4), scratch = new PagedStorage29(context, 4);
     let values, failed = false, work = 0;
     const cooperate = async (units = 1) => {
       this.signal.throwIfAborted();
@@ -65627,6 +66436,382 @@ var QpdfJsonDocument = class _QpdfJsonDocument {
     })();
   }
 };
+
+// packages/pdf-ast/src/edit/retained-form-data.ts
+import { IntegerTable as IntegerTable19, PagedStorage as PagedStorage31 } from "@poe-platform/safe-fs/storage";
+
+// packages/pdf-ast/src/edit/retained-form-data-fdf.ts
+import { IntegerTable as IntegerTable18, PagedStorage as PagedStorage30 } from "@poe-platform/safe-fs/storage";
+async function parseRetainedFdf(source, storage, set, signal) {
+  const backing = new PagedStorage30({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), tokens = new IntegerTable18(backing), starts = new IntegerTable18(backing), children = new IntegerTable18(backing), visited = new IntegerTable18(backing), names = new PdfNameIndex(storage, Infinity, signal);
+  let count = 0, cursor = 0, head = -1, work = 0, failed = false;
+  const cache = /* @__PURE__ */ new Map();
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 128 === 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      signal.throwIfAborted();
+    }
+  }
+  async function token2(index2) {
+    if (index2 < 0 || index2 >= count) return;
+    const cached = cache.get(index2);
+    if (cached) return cached;
+    const at = Number(await tokens.get(BigInt(index2))) - 1, result = (await readStoredRecord(backing, at, signal)).value;
+    if (cache.size >= 8) cache.delete(cache.keys().next().value);
+    cache.set(index2, result);
+    return result;
+  }
+  async function objectKey(object) {
+    return BigInt((await names.intern(String(object))).index);
+  }
+  async function push(frame) {
+    head = await appendStoredRecord(backing, { frame, previous: head }, -1, signal);
+  }
+  function dict(prefix) {
+    return { kind: "dict", prefix, partial: "", value: "", hasValue: false, children: -1 };
+  }
+  function text(token3) {
+    return token3.kind === "name" ? token3.decoded : token3.kind === "string" || token3.kind === "hex-string" ? decodePdfString({ kind: "string", bytes: token3.bytes, encoding: token3.kind === "string" ? "literal" : "hex" }) : "";
+  }
+  async function reference(index2) {
+    const a = await token2(index2), b = await token2(index2 + 1), c = await token2(index2 + 2);
+    return a?.kind === "number" && b?.kind === "number" && c?.kind === "keyword" && c.value === "R" ? a.value : void 0;
+  }
+  try {
+    const lexer = new CosRangeLexer(source, { signal, compactNumbers: true });
+    for (let next = await lexer.nextToken(); next; next = await lexer.nextToken()) {
+      await checkpoint();
+      const at = await appendStoredRecord(backing, next, -1, signal);
+      await tokens.set(BigInt(count++), BigInt(at + 1));
+    }
+    for (let i = 0; i < count; i++) {
+      await checkpoint();
+      const a = await token2(i), b = await token2(i + 1), c = await token2(i + 2), d = await token2(i + 3);
+      if (a?.kind === "number" && b?.kind === "number" && c?.kind === "keyword" && c.value === "obj" && d?.kind === "dict-start") await starts.set(await objectKey(a.value), BigInt(i + 5));
+      if (a?.kind === "name" && a.decoded === "Kids" && b?.kind === "array-start") {
+        let depth = 1;
+        for (let k = i + 2; k < count && depth > 0; k++) {
+          await checkpoint();
+          const next = await token2(k);
+          if (next?.kind === "array-start") depth++;
+          else if (next?.kind === "array-end") depth--;
+          else if (depth === 1) {
+            const ref = await reference(k);
+            if (ref !== void 0) {
+              await children.set(await objectKey(ref), 1n);
+              k += 2;
+            }
+          }
+        }
+      }
+    }
+    await push({ kind: "scan" });
+    while (head !== -1) {
+      await checkpoint();
+      const record = await readStoredRecord(backing, head, signal);
+      head = record.value.previous;
+      const frame = record.value.frame;
+      if (frame.kind === "restore") {
+        cursor = frame.cursor;
+        continue;
+      }
+      if (frame.kind === "ref") {
+        const key = await objectKey(frame.object), start = await starts.get(key);
+        if (start && !await visited.get(key)) {
+          await visited.set(key, 1n);
+          cursor = Number(start) - 1;
+          await push(dict(frame.prefix));
+        }
+        continue;
+      }
+      if (frame.kind === "children") {
+        let ref = frame.refs;
+        while (ref !== -1) {
+          const row = await readStoredRecord(backing, ref, signal);
+          await push({ kind: "ref", object: row.value.object, prefix: frame.prefix });
+          ref = row.value.previous;
+        }
+        cursor = frame.start;
+        await push({ kind: "range", end: frame.end, prefix: frame.prefix });
+        continue;
+      }
+      if (frame.kind === "scan" || frame.kind === "range") {
+        const end = frame.kind === "range" ? frame.end : count;
+        while (cursor < end) {
+          await checkpoint();
+          const a = await token2(cursor);
+          if (frame.kind === "scan" && a?.kind === "number") {
+            const b = await token2(cursor + 1), c = await token2(cursor + 2);
+            if (b?.kind === "number" && c?.kind === "keyword" && c.value === "obj") {
+              const key = await objectKey(a.value);
+              if (await children.get(key) || await visited.get(key)) {
+                cursor += 3;
+                while (cursor < count) {
+                  await checkpoint();
+                  const t = await token2(cursor++);
+                  if (t?.kind === "keyword" && t.value === "endobj") break;
+                }
+                continue;
+              }
+            }
+          }
+          cursor++;
+          if (a?.kind === "dict-start") {
+            await push(frame);
+            await push(dict(frame.kind === "range" ? frame.prefix : ""));
+            break;
+          }
+        }
+        continue;
+      }
+      let nested = false;
+      while (cursor < count) {
+        await checkpoint();
+        const next = await token2(cursor++);
+        if (next?.kind === "dict-end") break;
+        if (next?.kind === "dict-start") {
+          await push(frame);
+          await push(dict(frame.prefix && frame.partial ? `${frame.prefix}.${frame.partial}` : frame.partial || frame.prefix));
+          nested = true;
+          break;
+        }
+        if (next?.kind !== "name") continue;
+        const value = await token2(cursor);
+        if (next.decoded === "T" && (value?.kind === "string" || value?.kind === "hex-string" || value?.kind === "name")) {
+          frame.partial = text(value);
+          cursor++;
+        } else if (next.decoded === "V" && value) {
+          if (value.kind === "string" || value.kind === "hex-string" || value.kind === "name") {
+            const decoded = text(value);
+            frame.value = value.kind === "name" ? decoded === "Off" ? false : decoded === "Yes" || decoded === "On" ? true : decoded : decoded;
+            frame.hasValue = true;
+            cursor++;
+          } else if (value.kind === "number" || value.kind === "boolean") {
+            frame.value = value.kind === "number" ? String(value.value) : value.value;
+            frame.hasValue = true;
+            cursor++;
+          } else if (value.kind === "array-start") {
+            cursor++;
+            let depth = 1, joined = "", items = 0;
+            while (cursor < count && depth > 0) {
+              await checkpoint();
+              const t = await token2(cursor++);
+              if (t?.kind === "array-start") depth++;
+              else if (t?.kind === "array-end") depth--;
+              else if (depth === 1 && t && (t.kind === "string" || t.kind === "hex-string" || t.kind === "name")) {
+                joined += (items++ ? "," : "") + text(t);
+              }
+            }
+            frame.value = joined;
+            frame.hasValue = true;
+          }
+        } else if ((next.decoded === "Kids" || next.decoded === "Fields") && value?.kind === "array-start") {
+          cursor++;
+          const start = cursor;
+          let depth = 1, refs = -1;
+          while (cursor < count && depth > 0) {
+            await checkpoint();
+            const t = await token2(cursor++);
+            if (t?.kind === "array-start") depth++;
+            else if (t?.kind === "array-end") depth--;
+            else if (depth === 1) {
+              const ref = await reference(cursor - 1);
+              if (ref !== void 0) {
+                refs = await appendStoredRecord(backing, { object: ref, previous: refs }, -1, signal);
+                cursor += 2;
+              }
+            }
+          }
+          frame.children = await appendStoredRecord(backing, { start, end: cursor - 1, refs, previous: frame.children }, -1, signal);
+        }
+      }
+      if (nested) continue;
+      const name = frame.prefix && frame.partial ? `${frame.prefix}.${frame.partial}` : frame.partial || frame.prefix;
+      if (name && frame.hasValue) await set(name, frame.value);
+      if (frame.children !== -1) {
+        await push({ kind: "restore", cursor });
+        let child = frame.children;
+        while (child !== -1) {
+          const row = (await readStoredRecord(backing, child, signal)).value;
+          await push({ kind: "children", start: row.start, end: row.end, refs: row.refs, prefix: name });
+          child = row.previous;
+        }
+      }
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([backing.close(), names.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/pdf-ast/src/edit/retained-form-data.ts
+var FormText = class {
+  constructor(backing, signal) {
+    this.backing = backing;
+    this.signal = signal;
+    this.base = backing.allocate(0);
+  }
+  backing;
+  signal;
+  length = 0;
+  base;
+  async load(source) {
+    const decoder = new TextDecoder();
+    const append = async (text) => {
+      for (let start = 0; start < text.length; start += 4096) {
+        this.signal.throwIfAborted();
+        const length = Math.min(4096, text.length - start), bytes = new Uint8Array(length * 2), view = new DataView(bytes.buffer);
+        for (let i = 0; i < length; i++) view.setUint16(i * 2, text.charCodeAt(start + i), true);
+        await this.backing.write(this.backing.allocate(bytes.length), bytes);
+        this.length += length;
+      }
+    };
+    for await (const chunk of source.stream(0, source.size, this.signal)) await append(decoder.decode(chunk, { stream: true }));
+    await append(decoder.decode());
+  }
+  async read(start, end) {
+    let result = "";
+    for (let at = start; at < end; at += 4096) {
+      this.signal.throwIfAborted();
+      const length = Math.min(4096, end - at), bytes = await this.backing.read(this.base + at * 2, length * 2), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+      const units = [];
+      for (let i = 0; i < length; i++) units.push(view.getUint16(i * 2, true));
+      result += String.fromCharCode(...units);
+    }
+    return result;
+  }
+  async indexOf(needle, start = 0) {
+    for (let at = start; at < this.length; at += 4096) {
+      const part = await this.read(at, Math.min(this.length, at + 4096 + needle.length - 1)), index2 = part.indexOf(needle);
+      if (index2 >= 0) return at + index2;
+    }
+    return -1;
+  }
+  async prefix() {
+    for (let at = 0; at < this.length; at += 4096) {
+      const part = await this.read(at, Math.min(this.length, at + 4096)), trimmed = part.trimStart();
+      if (trimmed) return this.read(at + part.length - trimmed.length, Math.min(this.length, at + part.length - trimmed.length + 5));
+    }
+    return "";
+  }
+};
+async function* parseRetainedFormData(source, storage, options = {}) {
+  const signal = options.signal ?? new AbortController().signal, context = { fs: storage.fs, cwd: storage.directory, env: {}, signal };
+  const textBacking = new PagedStorage31(context, 2), state = new PagedStorage31(context, 4), names = new PdfNameIndex(storage, Infinity, signal), values = new IntegerTable19(state);
+  const text = new FormText(textBacking, signal);
+  let count = 0, failed = false, work = 0;
+  async function checkpoint() {
+    signal.throwIfAborted();
+    if (++work % 64 === 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+      signal.throwIfAborted();
+    }
+  }
+  async function set(name, value, append = false) {
+    await checkpoint();
+    const key = await names.intern(name), at = await values.get(BigInt(key.index));
+    if (key.added) count++;
+    if (append && typeof value === "string" && at) {
+      const previous = (await readStoredRecord(state, Number(at) - 1, signal)).value.value;
+      if (typeof previous === "string" && previous.length) value = `${previous},${value}`;
+    }
+    const offset = await appendStoredRecord(state, { name, value }, -1, signal);
+    await values.set(BigInt(key.index), BigInt(offset + 1));
+  }
+  try {
+    await text.load(source);
+    const prefix = await text.prefix();
+    if (prefix === "%FDF-" || await text.indexOf("/FDF") >= 0 && await text.indexOf("/Fields") >= 0) await parseRetainedFdf(source, storage, set, signal);
+    else if (prefix === "<?xml" || prefix === "<xfdf" || await text.indexOf("<fields") >= 0) {
+      let position = 0, head = -1, field2 = "";
+      while (position < text.length) {
+        await checkpoint();
+        const lt = await text.indexOf("<", position);
+        if (lt < 0) break;
+        const gt = await text.indexOf(">", lt + 1);
+        if (gt < 0) break;
+        const raw = (await text.read(lt + 1, gt)).trim();
+        position = gt + 1;
+        if (raw.startsWith("?") || raw.startsWith("!")) continue;
+        if (raw.startsWith("/")) {
+          if (raw.slice(1).trim().toLowerCase() === "field" && head !== -1) {
+            const row = (await readStoredRecord(state, head, signal)).value;
+            field2 = row.field;
+            head = row.previous;
+          }
+          continue;
+        }
+        const selfClosing = raw.endsWith("/"), tag = selfClosing ? raw.slice(0, -1).trim() : raw, space = tag.indexOf(" "), name = (space < 0 ? tag : tag.slice(0, space)).toLowerCase();
+        if (name === "field") {
+          let part = "";
+          const at = tag.indexOf("name=");
+          if (at >= 0) {
+            const quote = tag[at + 5];
+            if (quote === '"' || quote === "'") {
+              const end = tag.indexOf(quote, at + 6);
+              if (end >= 0) part = decodeFormDataEntities(tag.slice(at + 6, end));
+            }
+          }
+          if (!selfClosing) {
+            head = await appendStoredRecord(state, { field: field2, previous: head }, -1, signal);
+            field2 = field2 && part ? `${field2}.${part}` : field2 || part;
+          }
+        } else if (name === "value" && !selfClosing && head !== -1) {
+          const close = await text.indexOf("</value>", position);
+          if (close >= 0) {
+            const value = decodeFormDataEntities(await text.read(position, close));
+            if (field2) await set(field2, value === "Off" ? false : value === "Yes" || value === "On" ? true : value, true);
+            position = close + 8;
+          }
+        }
+      }
+    } else {
+      const report = await text.indexOf("FieldName:") >= 0;
+      let position = 0, name = "", type = "";
+      while (position < text.length) {
+        await checkpoint();
+        const newline = await text.indexOf("\n", position), end = newline < 0 ? text.length : newline, line = (await text.read(position, end)).trim();
+        position = end + 1;
+        if (report) {
+          if (line === "---") {
+            name = "";
+            type = "";
+          } else if (line.startsWith("FieldType:")) type = line.slice(10).trim();
+          else if (line.startsWith("FieldName:")) name = decodeFormDataEntities(line.slice(10).trim());
+          else if (line.startsWith("FieldValue:") && name) {
+            const value = decodeFormDataEntities(line.slice(11).trim());
+            await set(name, value === "Yes" || value === "On" ? true : value === "Off" || value === "false" || type === "Button" && value === "" ? false : value, true);
+          }
+        } else {
+          if (!line || line.startsWith("#")) continue;
+          const equals = line.indexOf("="), colon = line.indexOf(":"), separator = equals >= 0 ? equals : colon;
+          if (separator > 0) {
+            const name2 = line.slice(0, separator).trim(), value = line.slice(separator + 1).trim();
+            await set(name2, value === "true" || value === "Yes" || value === "On" ? true : value === "false" || value === "Off" ? false : value);
+          }
+        }
+      }
+    }
+    for (let index2 = 0; index2 < count; index2++) {
+      await checkpoint();
+      yield (await readStoredRecord(state, Number(await values.get(BigInt(index2))) - 1, signal)).value;
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([textBacking.close(), state.close(), names.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
 export {
   CosByteLexer,
   CosRangeLexer,
@@ -65692,6 +66877,7 @@ export {
   decodeCcittFax,
   decodeCcittFaxChunks,
   decodeFlate,
+  decodeFormDataEntities,
   decodeInlineImageNodeToRgba,
   decodeInlineImageNodeToRgbaSteps,
   decodeJbig2ToRgba,
@@ -65753,6 +66939,9 @@ export {
   encodeRgbaToPng,
   encodeRgbaToPngSteps,
   encodeRunLength,
+  encodeSvgImageChunks,
+  encodeSvgPathDataChunks,
+  encodeSvgPathPaintChunks,
   encodeTiff,
   encodeTiffSteps,
   encodeWinAnsiBytes,
@@ -65815,6 +67004,7 @@ export {
   parseCosRangeObject,
   parseCosRangeValue,
   parseFormDataBytes,
+  parseRetainedFormData,
   parseToUnicodeCMap,
   parseToUnicodeCMapSteps,
   parseTrueTypeFont,