@poe-platform/safe-bash 0.1.839 → 0.1.840

package/dist/safe-bash-command-qpdf/index.js

@@ -1,21 +1,504 @@
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
+// packages/safe-bash-command-qpdf/src/linearization-report.ts
+import { PdfError } from "../pdf-ast/index.js";
+var HintBits = class _HintBits {
+  constructor(size, offset = 0) {
+    this.size = size;
+    this.position = offset * 8;
+  }
+  size;
+  position;
+  bytes = new Uint8Array(0);
+  start = 0;
+  *read(width) {
+    if (!Number.isInteger(width) || width < 0 || width > 32 || this.position + width > this.size * 8) throw new PdfError("E_PARSE", "Invalid linearization hint table");
+    let value = 0;
+    for (let bit = 0; bit < width; bit++, this.position++) {
+      const offset = Math.floor(this.position / 8);
+      if (offset < this.start || offset >= this.start + this.bytes.length) {
+        this.start = offset;
+        this.bytes = yield { offset, length: Math.min(4096, this.size - offset) };
+        if (!this.bytes.length) throw new PdfError("E_PARSE", "Truncated linearization hint table");
+      }
+      value = value * 2 + (this.bytes[offset - this.start] >> 7 - this.position % 8 & 1);
+    }
+    return value;
+  }
+  column(count, width) {
+    const cursor = new _HintBits(this.size, this.position / 8);
+    const end = this.position + count * width;
+    if (!Number.isSafeInteger(end) || end > this.size * 8) throw new PdfError("E_PARSE", "Truncated linearization hint table");
+    this.position = Math.ceil(end / 8) * 8;
+    return cursor;
+  }
+};
+function* linearizationReport(filename, values, size, sharedOffset, outlineOffset) {
+  const adjusted = (offset) => offset >= values.H_offset ? offset + values.H_length : offset;
+  yield `${filename}: linearization data:
+
+`;
+  for (const key of ["file_size", "first_page_object", "first_page_end", "npages", "xref_zero_offset", "first_page", "H_offset", "H_length"]) yield `${key}: ${values[key]}
+`;
+  if (!size) return;
+  yield "\nPage Offsets Hint Table\n\n";
+  const page = new HintBits(size), header = {};
+  for (const [key, width] of [
+    ["min_nobjects", 32],
+    ["first_page_offset", 32],
+    ["nbits_delta_nobjects", 16],
+    ["min_page_length", 32],
+    ["nbits_delta_page_length", 16],
+    ["min_content_offset", 32],
+    ["nbits_delta_content_offset", 16],
+    ["min_content_length", 32],
+    ["nbits_delta_content_length", 16],
+    ["nbits_nshared_objects", 16],
+    ["nbits_shared_identifier", 16],
+    ["nbits_shared_numerator", 16],
+    ["shared_denominator", 16]
+  ]) {
+    header[key] = yield* page.read(width);
+    yield `${key}: ${key === "first_page_offset" ? adjusted(header[key]) : header[key]}
+`;
+  }
+  const n = values.npages, objects = page.column(n, header.nbits_delta_nobjects), lengths = page.column(n, header.nbits_delta_page_length);
+  const counts = page.column(n, header.nbits_nshared_objects);
+  const countScan = new HintBits(size, counts.position / 8);
+  let total = 0;
+  for (let i = 0; i < n; i++) total += yield* countScan.read(header.nbits_nshared_objects);
+  const identifiers = page.column(total, header.nbits_shared_identifier), numerators = page.column(total, header.nbits_shared_numerator);
+  const contentOffsets = page.column(n, header.nbits_delta_content_offset), contentLengths = page.column(n, header.nbits_delta_content_length);
+  for (let i = 0; i < n; i++) {
+    yield `Page ${i}:
+  nobjects: ${header.min_nobjects + (yield* objects.read(header.nbits_delta_nobjects))}
+`;
+    yield `  length: ${header.min_page_length + (yield* lengths.read(header.nbits_delta_page_length))}
+`;
+    yield `  content_offset: ${header.min_content_offset + (yield* contentOffsets.read(header.nbits_delta_content_offset))}
+`;
+    yield `  content_length: ${header.min_content_length + (yield* contentLengths.read(header.nbits_delta_content_length))}
+`;
+    const count = yield* counts.read(header.nbits_nshared_objects);
+    yield `  nshared_objects: ${count}
+`;
+    for (let j = 0; j < count; j++) yield `    identifier ${j}: ${yield* identifiers.read(header.nbits_shared_identifier)}
+    numerator ${j}: ${yield* numerators.read(header.nbits_shared_numerator)}
+`;
+  }
+  yield "\nShared Objects Hint Table\n\n";
+  const shared = new HintBits(size, sharedOffset), fields = {};
+  for (const [key, width] of [["first_shared_obj", 32], ["first_shared_offset", 32], ["nshared_first_page", 32], ["nshared_total", 32], ["nbits_nobjects", 16], ["min_group_length", 32], ["nbits_delta_group_length", 16]]) {
+    fields[key] = yield* shared.read(width);
+    yield `${key}: ${key === "first_shared_offset" ? adjusted(fields[key]) : fields[key]}
+`;
+  }
+  const groups = fields.nshared_total, groupLengths = shared.column(groups, fields.nbits_delta_group_length), signatures = shared.column(groups, 1);
+  const signatureScan = new HintBits(size, signatures.position / 8);
+  for (let i = 0; i < groups; i++) if (yield* signatureScan.read(1)) shared.column(4, 32);
+  const groupCounts = shared.column(groups, fields.nbits_nobjects);
+  for (let i = 0; i < groups; i++) {
+    yield `Shared Object ${i}:
+  group length: ${fields.min_group_length + (yield* groupLengths.read(fields.nbits_delta_group_length))}
+`;
+    if (yield* signatures.read(1)) yield "  signature present\n";
+    const count = yield* groupCounts.read(fields.nbits_nobjects);
+    if (count) yield `  nobjects: ${count + 1}
+`;
+  }
+  if (outlineOffset !== void 0) {
+    const outline = new HintBits(size, outlineOffset);
+    const first = yield* outline.read(32), offset = yield* outline.read(32), count = yield* outline.read(32), length = yield* outline.read(32);
+    if (count) yield `
+Outlines Hint Table
+
+first_object: ${first}
+first_object_offset: ${adjusted(offset)}
+nobjects: ${count}
+group_length: ${length}
+`;
+  }
+}
+
+// packages/safe-bash-command-qpdf/src/encryption-report.ts
+import { getPdfEncryptionInfo } from "../pdf-ast/index.js";
+function encryptionReport(encryption) {
+  if (!encryption) return "File is not encrypted\n";
+  const info = getPdfEncryptionInfo(encryption), p = encryption.permissions;
+  const legacy = encryption.revision === 2;
+  const assembly = legacy ? p.modify : p.assemble;
+  const forms = legacy ? p.addNotes : p.fillForms;
+  const permissions = [
+    ["extract for accessibility", legacy ? p.copy : encryption.revision >= 5 || p.extractAccessibility],
+    ["extract for any purpose", p.copy],
+    ["print low resolution", p.print],
+    ["print high resolution", p.print && (legacy || p.printHighRes)],
+    ["modify document assembly", assembly],
+    ["modify forms", forms],
+    ["modify annotations", p.addNotes],
+    ["modify other", p.modify],
+    ["modify anything", assembly && forms && p.addNotes && p.modify]
+  ];
+  const lines = [`R = ${encryption.revision}`, `P = ${info.permissionsMask}`, `User password = ${info.userPassword}`];
+  if (info.ownerPasswordMatched) lines.push("Supplied password is owner password");
+  if (info.userPasswordMatched) lines.push("Supplied password is user password");
+  for (const [name, allowed] of permissions) lines.push(`${name}: ${allowed ? "allowed" : "not allowed"}`);
+  if (encryption.version >= 4) lines.push(`stream encryption method: ${info.streamMethod}`, `string encryption method: ${info.stringMethod}`, `file encryption method: ${info.fileMethod}`);
+  return lines.join("\n") + "\n";
+}
+
+// packages/safe-bash-command-qpdf/src/json-pages.ts
+import { cosDict, cosNumber, decodePdfString as decodePdfString2, dictGet } from "../pdf-ast/index.js";
+
+// packages/safe-bash-command-qpdf/src/json-output.ts
+import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
+import { PdfNameIndex, decodePdfString } from "../pdf-ast/index.js";
+function jsonRecord(record) {
+  return { kind: "object", entries: Object.entries(record) };
+}
+function cosJson(node, storage, signal) {
+  if (!node) return null;
+  switch (node.kind) {
+    case "null":
+      return null;
+    case "boolean":
+    case "number":
+      return node.value;
+    case "name":
+      return `/${node.decoded}`;
+    case "string":
+      return `u:${decodePdfString(node)}`;
+    case "ref":
+      return `${node.objectNumber} ${node.generationNumber} R`;
+    case "array":
+      return { kind: "array", values: (function* () {
+        for (const item of node.items) yield cosJson(item, storage, signal);
+      })() };
+    case "dict":
+      return { kind: "object", entries: (async function* () {
+        if (node.entries.length > 64) {
+          const names = new PdfNameIndex(storage, Infinity, signal), backing = new PagedStorage({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), latest = new IntegerTable(backing);
+          let failed = false;
+          try {
+            for (let index = 0; index < node.entries.length; index++) {
+              signal.throwIfAborted();
+              const name = await names.intern(node.entries[index].key.decoded);
+              await latest.set(BigInt(name.index), BigInt(index));
+            }
+            for await (const [, index] of latest.entries()) {
+              const entry = node.entries[Number(index)];
+              yield [`/${entry.key.decoded}`, cosJson(entry.value, storage, signal)];
+            }
+          } catch (error) {
+            failed = true;
+            throw error;
+          } finally {
+            const results = await Promise.allSettled([names.close(), backing.close()]);
+            if (!failed) {
+              for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
+            }
+          }
+          return;
+        }
+        for (let i = 0; i < node.entries.length; i++) {
+          const entry = node.entries[i], key = entry.key.decoded;
+          if (node.entries.findIndex((pair) => pair.key.decoded === key) !== i) continue;
+          let value = entry.value;
+          for (let j = node.entries.length - 1; j > i; j--) if (node.entries[j].key.decoded === key) {
+            value = node.entries[j].value;
+            break;
+          }
+          yield [`/${key}`, cosJson(value, storage, signal)];
+        }
+      })() };
+    case "stream":
+      return jsonRecord({ dict: cosJson(node.dict, storage, signal), length: node.rawBytes.length });
+  }
+}
+async function* jsonChunks(value, signal) {
+  async function* string(parts2) {
+    yield '"';
+    for await (const part of parts2) for (let at = 0; at < part.length; ) {
+      signal.throwIfAborted();
+      let end = Math.min(part.length, at + 4096);
+      const last = part.charCodeAt(end - 1), next = part.charCodeAt(end);
+      if (last >= 55296 && last <= 56319 && next >= 56320 && next <= 57343) end--;
+      yield JSON.stringify(part.slice(at, end)).slice(1, -1);
+      at = end;
+    }
+    yield '"';
+  }
+  async function* parts(node, depth = 0) {
+    signal.throwIfAborted();
+    if (typeof node === "string") {
+      yield* string([node]);
+      return;
+    }
+    if (node === null || typeof node !== "object") {
+      yield JSON.stringify(node);
+      return;
+    }
+    if (node.kind === "text") {
+      yield* string(node.parts);
+      return;
+    }
+    if (node.kind === "formatted") {
+      const decoder = new TextDecoder(), chunks = node.chunks;
+      let newline = false;
+      async function* text() {
+        for await (const bytes of chunks) yield decoder.decode(bytes, { stream: true });
+        yield decoder.decode();
+      }
+      for await (const part of text()) {
+        signal.throwIfAborted();
+        let at = 0;
+        while (at < part.length) {
+          if (newline) {
+            yield "\n";
+            yield "  ".repeat(depth);
+            newline = false;
+          }
+          const end = part.indexOf("\n", at);
+          if (end < 0) {
+            yield part.slice(at);
+            break;
+          }
+          yield part.slice(at, end);
+          newline = true;
+          at = end + 1;
+        }
+      }
+      return;
+    }
+    const object = node.kind === "object";
+    yield object ? "{" : "[";
+    let first = true;
+    if (node.kind === "object") for await (const [key, child] of node.entries) {
+      yield first ? "\n" : ",\n";
+      first = false;
+      yield "  ".repeat(depth + 1);
+      yield* string([key]);
+      yield ": ";
+      yield* parts(child, depth + 1);
+    }
+    else for await (const child of node.values) {
+      yield first ? "\n" : ",\n";
+      first = false;
+      yield "  ".repeat(depth + 1);
+      yield* parts(child, depth + 1);
+    }
+    if (!first) {
+      yield "\n";
+      yield "  ".repeat(depth);
+    }
+    yield object ? "}" : "]";
+  }
+  const encoder = new TextEncoder();
+  let buffer = new Uint8Array(16384), used = 0, work = 0;
+  for await (const part of parts(value)) {
+    if (++work % 256 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+    signal.throwIfAborted();
+    for (let at = 0; at < part.length; ) {
+      const result = encoder.encodeInto(part.slice(at), buffer.subarray(used));
+      used += result.written;
+      at += result.read;
+      if (buffer.length - used < 4) {
+        yield buffer.subarray(0, used);
+        buffer = new Uint8Array(16384);
+        used = 0;
+      }
+    }
+  }
+  if (used === buffer.length) {
+    yield buffer;
+    buffer = new Uint8Array(16384);
+    used = 0;
+  }
+  buffer[used++] = 10;
+  yield buffer.subarray(0, used);
+}
+async function* base64Parts(bytes, signal) {
+  let pending = 0, count = 0, output = "";
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  for await (const chunk of bytes) for (const byte of chunk) {
+    pending = pending << 8 | byte;
+    if (++count === 3) {
+      output += alphabet[pending >>> 18 & 63] + alphabet[pending >>> 12 & 63] + alphabet[pending >>> 6 & 63] + alphabet[pending & 63];
+      pending = 0;
+      count = 0;
+    }
+    if (output.length >= 4096) {
+      signal.throwIfAborted();
+      yield output;
+      output = "";
+    }
+  }
+  if (count) {
+    pending <<= (3 - count) * 8;
+    output += alphabet[pending >>> 18 & 63] + alphabet[pending >>> 12 & 63] + (count === 2 ? alphabet[pending >>> 6 & 63] : "=") + "=";
+  }
+  if (output) yield output;
+}
+
+// packages/safe-bash-command-qpdf/src/json-pages.ts
+function* qpdfJsonPage(page, reference, index, root, version) {
+  function json(node2) {
+    if (!node2 || node2.kind === "null") return null;
+    switch (node2.kind) {
+      case "string":
+        return `${version === 1 ? "" : "u:"}${decodePdfString2(node2)}`;
+      case "name":
+        return `/${node2.decoded}`;
+      case "ref":
+        return referenceText(node2);
+      case "number":
+      case "boolean":
+        return node2.value;
+      case "array":
+        return { kind: "array", values: node2.items.map(json) };
+      case "dict":
+        return jsonRecord(Object.fromEntries(node2.entries.map((entry) => [`/${entry.key.decoded}`, json(entry.value)])));
+      case "stream":
+        return json(node2.dict);
+    }
+  }
+  const referenceText = (ref) => `${ref.objectNumber} ${ref.generationNumber} R`;
+  function* dict(node2) {
+    const value2 = yield node2;
+    return value2?.kind === "stream" ? value2.dict : value2?.kind === "dict" ? value2 : void 0;
+  }
+  function* tree(node2, children, visit, ancestors = /* @__PURE__ */ new Set()) {
+    if (!node2) return;
+    const key = node2.kind === "ref" ? referenceText(node2) : void 0;
+    if (key && ancestors.has(key)) return;
+    if (key) ancestors.add(key);
+    try {
+      const value2 = yield* dict(node2);
+      if (!value2) return;
+      yield* visit(node2, value2);
+      const child = dictGet(value2, children);
+      if (children === "Kids") {
+        const kids = yield child;
+        if (kids?.kind === "array") for (const item of kids.items) yield* tree(item, children, visit, ancestors);
+      } else {
+        yield* tree(child, children, visit, ancestors);
+        yield* tree(dictGet(value2, "Next"), children, visit, ancestors);
+      }
+    } finally {
+      if (key) ancestors.delete(key);
+    }
+  }
+  const contents = [], images = [], outlines = [];
+  const node = dictGet(page, "Contents"), value = yield node;
+  for (const item of value?.kind === "array" ? value.items : node ? [node] : []) if (item.kind === "ref") contents.push(referenceText(item));
+  let resources = dictGet(page, "Resources"), parent = dictGet(page, "Parent");
+  const parents = /* @__PURE__ */ new Set();
+  while (!resources && parent) {
+    if (parent.kind === "ref") {
+      const key = referenceText(parent);
+      if (parents.has(key)) break;
+      parents.add(key);
+    }
+    const value2 = yield* dict(parent);
+    if (!value2) break;
+    resources = dictGet(value2, "Resources");
+    parent = dictGet(value2, "Parent");
+  }
+  let label, labelIndex = -1;
+  yield* tree(root && dictGet(root, "PageLabels"), "Kids", function* (_node, value2) {
+    const nums = yield dictGet(value2, "Nums");
+    if (nums?.kind !== "array") return;
+    for (let at = 0; at + 1 < nums.items.length; at += 2) {
+      const start = yield nums.items[at];
+      if (start?.kind === "number" && start.value <= index && start.value >= labelIndex) {
+        label = yield* dict(nums.items[at + 1]);
+        labelIndex = start.value;
+      }
+    }
+  });
+  if (label) {
+    const start = yield dictGet(label, "St");
+    label = cosDict({ ...Object.fromEntries(label.entries.map((entry) => [entry.key.decoded, entry.value])), St: cosNumber((start?.kind === "number" ? start.value : 1) + index - labelIndex) });
+  }
+  const resource = yield* dict(resources), objects = resource && (yield* dict(dictGet(resource, "XObject")));
+  for (const entry of objects?.entries.slice().sort((a, b) => a.key.decoded < b.key.decoded ? -1 : a.key.decoded > b.key.decoded ? 1 : 0) ?? []) {
+    const image = yield* dict(entry.value), subtype = image && (yield dictGet(image, "Subtype"));
+    if (!image || subtype?.kind !== "name" || subtype.decoded !== "Image") continue;
+    const mask = yield dictGet(image, "ImageMask");
+    if (mask?.kind === "boolean" && mask.value) continue;
+    const filter = yield dictGet(image, "Filter"), parms = yield dictGet(image, "DecodeParms");
+    const filters = filter?.kind === "array" ? filter.items : [filter];
+    const parameters = parms?.kind === "array" ? parms.items : filters.map(() => parms);
+    images.push(jsonRecord({
+      bitspercomponent: json(yield dictGet(image, "BitsPerComponent")),
+      colorspace: json(yield dictGet(image, "ColorSpace")),
+      decodeparms: { kind: "array", values: parameters.map(json) },
+      filter: { kind: "array", values: filters.map(json) },
+      filterable: filters.every((item) => !item || item.kind === "null" || item.kind === "name" && ["FlateDecode", "Fl", "LZWDecode", "LZW", "ASCII85Decode", "A85", "ASCIIHexDecode", "AHx", "RunLengthDecode", "RL"].includes(item.decoded)),
+      height: json(yield dictGet(image, "Height")),
+      name: `/${entry.key.decoded}`,
+      object: json(entry.value),
+      width: json(yield dictGet(image, "Width"))
+    }));
+  }
+  const outlineRoot = root && (yield* dict(dictGet(root, "Outlines")));
+  yield* tree(outlineRoot && dictGet(outlineRoot, "First"), "First", function* (node2, value2) {
+    const action = yield* dict(dictGet(value2, "A"));
+    let dest = yield dictGet(value2, "Dest") ?? (action && dictGet(action, "D"));
+    if (dest?.kind === "name" || dest?.kind === "string") {
+      const name = dest.kind === "name" ? dest.decoded : decodePdfString2(dest), old = root && (yield* dict(dictGet(root, "Dests")));
+      let found = dest.kind === "name" && old ? dictGet(old, name) : void 0;
+      const names = root && (yield* dict(dictGet(root, "Names")));
+      if (dest.kind === "string") yield* tree(names && dictGet(names, "Dests"), "Kids", function* (_node, value3) {
+        const pairs = yield dictGet(value3, "Names");
+        if (pairs?.kind === "array") for (let at = 0; at + 1 < pairs.items.length; at += 2) {
+          const key = yield pairs.items[at];
+          if (key?.kind === "string" && decodePdfString2(key) === name) found = pairs.items[at + 1];
+        }
+      });
+      dest = yield found;
+    }
+    if (dest?.kind === "dict") dest = yield dictGet(dest, "D");
+    const target = dest?.kind === "array" ? dest.items[0] : void 0;
+    if (target?.kind !== "ref" || referenceText(target) !== referenceText(reference)) return;
+    const title = yield dictGet(value2, "Title");
+    outlines.push(jsonRecord({ dest: json(dest), object: json(node2), title: title?.kind === "string" ? decodePdfString2(title) : "" }));
+  });
+  return jsonRecord({ contents: { kind: "array", values: contents }, images: { kind: "array", values: images }, label: json(label), object: referenceText(reference), outlines: { kind: "array", values: outlines }, pageposfrom1: index + 1 });
+}
+
 // packages/safe-bash-command-qpdf/src/page-labels.ts
-function* parseQpdfPageLabels(specs) {
+function parseQpdfPageLabels(specs, pageCount) {
+  const labels = [];
   for (const spec of specs) {
     const colon = spec.indexOf(":");
-    if (colon <= 0) continue;
-    const index = Math.max(1, Number.parseInt(spec.slice(0, colon), 10) || 1) - 1;
-    const parts = spec.slice(colon + 1).split("/"), style = parts[0] ?? "D";
-    const parsed = parts[1] !== void 0 && parts[1].length > 0 ? Number.parseInt(parts[1], 10) : Number.NaN;
-    const start = Number.isFinite(parsed) ? parsed || 1 : 1;
-    const prefix = parts.length >= 3 ? parts[2] ?? "" : !Number.isFinite(parsed) ? parts[1] ?? "" : "";
-    yield { index, start, prefix, ...style === "n" ? {} : { style } };
+    const page = spec.slice(0, colon);
+    const digits = page === "z" ? "1" : page.startsWith("r") ? page.slice(1) : page;
+    const parts = spec.slice(colon + 1).split("/");
+    const style = parts[0] ?? "";
+    const number = parts[1] ?? "";
+    if (colon <= 0 || digits.length === 0 || [...digits, ...number].some((char) => char < "0" || char > "9") || !["", "D", "a", "A", "r", "R"].includes(style)) {
+      throw new Error("page label spec must be n:[D|a|A|r|R][/start[/prefix]]");
+    }
+    for (const operand of [digits, number]) {
+      if (operand !== "" && BigInt(operand) > 9223372036854775807n) {
+        throw new Error(`overflow/underflow converting ${operand} to 64-bit integer`);
+      }
+    }
+    const index = page === "z" ? pageCount - 1 : page.startsWith("r") ? pageCount - Number(digits) : Number(page) - 1;
+    const start = number === "" ? 1 : Number(number);
+    if (labels.length === 0 && index !== 0) throw new Error("the first page label specification must start with page 1");
+    if (start < 1) throw new Error("starting page number must be >= 1");
+    if (labels.length > 0 && index <= labels[labels.length - 1].index) {
+      throw new Error("page label specifications must be in order by first page");
+    }
+    labels.push({ index, start, prefix: parts.slice(2).join("/"), ...style === "" ? {} : { style } });
   }
+  return labels;
 }
 
 // packages/safe-bash-command-qpdf/src/split.ts
-import { IntegerTable, PagedStorage } from "@poe-platform/safe-fs/storage";
+import { IntegerTable as IntegerTable2, PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
 
 // packages/safe-bash-command-qpdf/src/page-range.ts
 function parseSingleTokenPageNumber(tok, totalPages) {
@@ -34,7 +517,13 @@ function parseSingleTokenPageNumber(tok, totalPages) {
   }
   return num;
 }
+var QpdfPageRangeError = class extends Error {
+};
 function* iterateQpdfPageRange(rangeSpec, totalPages) {
+  const suffix = rangeSpec.indexOf(":");
+  if (suffix !== -1 && rangeSpec.includes(",", suffix)) {
+    throw new QpdfPageRangeError(`error at * in numeric range ${rangeSpec.slice(0, suffix)}*${rangeSpec.slice(suffix)}: expected :even or :odd`);
+  }
   const ranges = [];
   let groupParity;
   for (const raw of rangeSpec.trim().split(",").filter((part) => part.length > 0)) {
@@ -126,8 +615,8 @@ function formatSplitName(template, total, group, start, end) {
   return `${stem}-${group === 1 ? first : `${first}-${last}`}.pdf`;
 }
 async function* splitPageOutputs(document, storage, target, group, edits, signal, normalizeContent = false) {
-  const backing = edits.length ? new PagedStorage({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4) : void 0;
-  const rotations = backing ? new IntegerTable(backing) : void 0;
+  const backing = edits.length ? new PagedStorage2({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4) : void 0;
+  const rotations = backing ? new IntegerTable2(backing) : void 0;
   let failed = false;
   try {
     let count = 0;
@@ -166,7 +655,7 @@ async function* splitPageOutputs(document, storage, target, group, edits, signal
 }
 
 // packages/safe-bash-command-qpdf/src/display.ts
-import { decodePdfString } from "../pdf-ast/index.js";
+import { decodePdfString as decodePdfString3 } from "../pdf-ast/index.js";
 function* displayNodeParts(node) {
   if (!node) {
     yield "null";
@@ -188,7 +677,7 @@ function* displayNodeParts(node) {
       return;
     case "string":
       yield "(";
-      yield decodePdfString(node);
+      yield decodePdfString3(node);
       yield ")";
       return;
     case "ref":
@@ -305,324 +794,134 @@ async function applyJsonInput(owner, source, options, signal) {
 
 // packages/safe-bash-command-qpdf/src/json.ts
 import { IntegerTable as IntegerTable4, PagedStorage as PagedStorage4 } from "@poe-platform/safe-fs/storage";
-import { PdfError as PdfError2, PdfFileSource, PdfMutableObjectStore as PdfMutableObjectStore2, PdfStagedOutputs, cosArray, cosDict, cosNumber, cosString, decodePdfString as decodePdfString4, dictGet as dictGet2 } from "../pdf-ast/index.js";
+import { PdfError as PdfError3, PdfFileSource, PdfMutableObjectStore as PdfMutableObjectStore2, PdfStagedOutputs, cosArray, cosDict as cosDict2, cosNumber as cosNumber2, cosString, decodePdfString as decodePdfString5, dictGet as dictGet3 } from "../pdf-ast/index.js";
 
 // packages/safe-bash-command-qpdf/src/attachments.ts
-import { IntegerTable as IntegerTable2, PagedStorage as PagedStorage2 } from "@poe-platform/safe-fs/storage";
-import { PdfError, PdfMutableObjectStore, PdfNameIndex, decodePdfString as decodePdfString2, dictGet } from "../pdf-ast/index.js";
+import { IntegerTable as IntegerTable3, PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
+import { PdfError as PdfError2, PdfMutableObjectStore, PdfNameIndex as PdfNameIndex2, decodePdfString as decodePdfString4, dictGet as dictGet2 } from "../pdf-ast/index.js";
 var QpdfMissingAttachment = class extends Error {
   constructor(key) {
     super(`qpdf: attachment ${key} not found
-`);
-  }
-};
-async function* retainedAttachments(document, storage, signal) {
-  const values = new PdfMutableObjectStore(storage, { signal }), names = new PdfNameIndex(storage, Infinity, signal);
-  const backing = new PagedStorage2({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
-  const visited = new IntegerTable2(backing), accepted = new IntegerTable2(backing);
-  let failed = false, top = -1, work = 0;
-  async function dictionary(node) {
-    const resolved = await document.lookup(node);
-    return resolved?.value.kind === "dict" && !resolved.stream ? resolved.value : void 0;
-  }
-  async function* specifications() {
-    const root = await dictionary(document.crossReference.rootRef), nameRoot = await dictionary(root && dictGet(root, "Names"));
-    let node = nameRoot && dictGet(nameRoot, "EmbeddedFiles");
-    for (; ; ) {
-      signal.throwIfAborted();
-      if (++work % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
-      const dict = await dictionary(node);
-      if (dict) {
-        const entries = (await document.lookup(dictGet(dict, "Names")))?.value;
-        if (entries?.kind === "array") for (let index = 0; index + 1 < entries.items.length; index += 2) {
-          const label = (await document.lookup(entries.items[index]))?.value;
-          yield { node: entries.items[index + 1], fallback: label?.kind === "string" ? decodePdfString2(label) : `att_${index}` };
-        }
-        const kids = (await document.lookup(dictGet(dict, "Kids")))?.value;
-        if (kids?.kind === "array" && kids.items.length) {
-          const ref = await values.allocate(kids), bytes = new Uint8Array(24), view = new DataView(bytes.buffer);
-          view.setFloat64(0, top);
-          view.setFloat64(8, ref.objectNumber);
-          const position = backing.allocate(24);
-          await backing.write(position, bytes);
-          top = position;
-        }
-      }
-      node = void 0;
-      while (top >= 0) {
-        const bytes = await backing.read(top, 24), frame = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        const kids = (await values.get(frame.getFloat64(8))).value;
-        if (kids.kind !== "array") throw new Error("Invalid retained attachment traversal frame");
-        const index = frame.getFloat64(16), child = kids.items[index];
-        if (!child) {
-          top = frame.getFloat64(0);
-          continue;
-        }
-        frame.setFloat64(16, index + 1);
-        await backing.write(top, bytes);
-        if (child.kind === "ref") {
-          if (await visited.get(BigInt(child.objectNumber)) !== void 0) continue;
-          await visited.set(BigInt(child.objectNumber), 1n);
-        }
-        node = child;
-        break;
-      }
-      if (!node) break;
-    }
-    const associated = (await document.lookup(root && dictGet(root, "AF")))?.value;
-    if (associated?.kind === "array") for (const item of associated.items) yield { node: item, fallback: "" };
-    for await (const page of document.pages()) {
-      const annotations = (await document.lookup(dictGet(page.dict, "Annots")))?.value;
-      if (annotations?.kind !== "array") continue;
-      for (const item of annotations.items) {
-        const annotation = await dictionary(item), subtype = annotation && dictGet(annotation, "Subtype");
-        if (subtype?.kind !== "name" || subtype.decoded !== "FileAttachment") continue;
-        const file = dictGet(annotation, "FS");
-        if (file) yield { node: file, fallback: "" };
-      }
-    }
-  }
-  try {
-    for await (const spec of specifications()) {
-      const dict = await dictionary(spec.node);
-      if (!dict) continue;
-      const filenameNode = (await document.lookup(dictGet(dict, "UF") ?? dictGet(dict, "F")))?.value;
-      const filename = filenameNode?.kind === "string" ? decodePdfString2(filenameNode) : spec.fallback, name = spec.fallback || filename;
-      const identity = (await names.intern(name)).index;
-      if (await accepted.get(BigInt(identity)) !== void 0) continue;
-      const embedded = await dictionary(dictGet(dict, "EF"));
-      const stream = embedded && await document.lookup(dictGet(embedded, "UF") ?? dictGet(embedded, "F") ?? dictGet(embedded, "DOS") ?? dictGet(embedded, "Mac") ?? dictGet(embedded, "Unix"));
-      if (!stream?.stream || !stream.reference) continue;
-      await accepted.set(BigInt(identity), 1n);
-      yield { key: name, filename, reference: stream.reference };
-    }
-  } catch (error) {
-    failed = true;
-    if (error instanceof PdfError && error.message.startsWith("Unsupported streaming PDF filter: ")) {
-      throw new PdfError(error.code, `Unsupported PDF filter: ${error.message.slice("Unsupported streaming PDF filter: ".length)}`);
-    }
-    throw error;
-  } finally {
-    const results = await Promise.allSettled([values.close(), names.close(), backing.close()]);
-    if (!failed) {
-      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
-    }
-  }
-}
-async function* attachmentChunks(document, storage, key, signal) {
-  let found = false;
-  try {
-    for await (const attachment of retainedAttachments(document, storage, signal)) {
-      const selected = key !== void 0 && !found && (attachment.key === key || attachment.filename === key);
-      if (selected) found = true;
-      for await (const bytes of document.objects.decodeStream(attachment.reference.objectNumber, attachment.reference.generationNumber)) {
-        signal.throwIfAborted();
-        if (selected) yield bytes;
-      }
-      if (key === void 0) yield* encodeDisplayParts([attachment.key, " -> ", attachment.filename, "\n"], signal);
-    }
-    if (key !== void 0 && !found) throw new QpdfMissingAttachment(key);
-  } catch (error) {
-    if (error instanceof PdfError && error.message.startsWith("Unsupported streaming PDF filter: ")) {
-      throw new PdfError(error.code, `Unsupported PDF filter: ${error.message.slice("Unsupported streaming PDF filter: ".length)}`);
-    }
-    throw error;
-  }
-}
-
-// packages/safe-bash-command-qpdf/src/object-order.ts
-import { retainedObjectOrder } from "../pdf-ast/index.js";
-
-// packages/safe-bash-command-qpdf/src/json-output.ts
-import { IntegerTable as IntegerTable3, PagedStorage as PagedStorage3 } from "@poe-platform/safe-fs/storage";
-import { PdfNameIndex as PdfNameIndex2, decodePdfString as decodePdfString3 } from "../pdf-ast/index.js";
-function jsonRecord(record) {
-  return { kind: "object", entries: Object.entries(record) };
-}
-function cosJson(node, storage, signal) {
-  if (!node) return null;
-  switch (node.kind) {
-    case "null":
-      return null;
-    case "boolean":
-    case "number":
-      return node.value;
-    case "name":
-      return `/${node.decoded}`;
-    case "string":
-      return `u:${decodePdfString3(node)}`;
-    case "ref":
-      return `${node.objectNumber} ${node.generationNumber} R`;
-    case "array":
-      return { kind: "array", values: (function* () {
-        for (const item of node.items) yield cosJson(item, storage, signal);
-      })() };
-    case "dict":
-      return { kind: "object", entries: (async function* () {
-        if (node.entries.length > 64) {
-          const names = new PdfNameIndex2(storage, Infinity, signal), backing = new PagedStorage3({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4), latest = new IntegerTable3(backing);
-          let failed = false;
-          try {
-            for (let index = 0; index < node.entries.length; index++) {
-              signal.throwIfAborted();
-              const name = await names.intern(node.entries[index].key.decoded);
-              await latest.set(BigInt(name.index), BigInt(index));
-            }
-            for await (const [, index] of latest.entries()) {
-              const entry = node.entries[Number(index)];
-              yield [`/${entry.key.decoded}`, cosJson(entry.value, storage, signal)];
-            }
-          } catch (error) {
-            failed = true;
-            throw error;
-          } finally {
-            const results = await Promise.allSettled([names.close(), backing.close()]);
-            if (!failed) {
-              for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
-            }
-          }
-          return;
-        }
-        for (let i = 0; i < node.entries.length; i++) {
-          const entry = node.entries[i], key = entry.key.decoded;
-          if (node.entries.findIndex((pair) => pair.key.decoded === key) !== i) continue;
-          let value = entry.value;
-          for (let j = node.entries.length - 1; j > i; j--) if (node.entries[j].key.decoded === key) {
-            value = node.entries[j].value;
-            break;
-          }
-          yield [`/${key}`, cosJson(value, storage, signal)];
-        }
-      })() };
-    case "stream":
-      return jsonRecord({ dict: cosJson(node.dict, storage, signal), length: node.rawBytes.length });
-  }
-}
-async function* jsonChunks(value, signal) {
-  async function* string(parts2) {
-    yield '"';
-    for await (const part of parts2) for (let at = 0; at < part.length; ) {
-      signal.throwIfAborted();
-      let end = Math.min(part.length, at + 4096);
-      const last = part.charCodeAt(end - 1), next = part.charCodeAt(end);
-      if (last >= 55296 && last <= 56319 && next >= 56320 && next <= 57343) end--;
-      yield JSON.stringify(part.slice(at, end)).slice(1, -1);
-      at = end;
-    }
-    yield '"';
-  }
-  async function* parts(node, depth = 0) {
-    signal.throwIfAborted();
-    if (typeof node === "string") {
-      yield* string([node]);
-      return;
-    }
-    if (node === null || typeof node !== "object") {
-      yield JSON.stringify(node);
-      return;
-    }
-    if (node.kind === "text") {
-      yield* string(node.parts);
-      return;
-    }
-    if (node.kind === "formatted") {
-      const decoder = new TextDecoder(), chunks = node.chunks;
-      let newline = false;
-      async function* text() {
-        for await (const bytes of chunks) yield decoder.decode(bytes, { stream: true });
-        yield decoder.decode();
+`);
+  }
+};
+async function* retainedAttachments(document, storage, signal) {
+  const values = new PdfMutableObjectStore(storage, { signal }), names = new PdfNameIndex2(storage, Infinity, signal);
+  const backing = new PagedStorage3({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
+  const visited = new IntegerTable3(backing), accepted = new IntegerTable3(backing);
+  let failed = false, top = -1, work = 0;
+  async function dictionary(node) {
+    const resolved = await document.lookup(node);
+    return resolved?.value.kind === "dict" && !resolved.stream ? resolved.value : void 0;
+  }
+  async function* specifications() {
+    const root = await dictionary(document.crossReference.rootRef), nameRoot = await dictionary(root && dictGet2(root, "Names"));
+    let node = nameRoot && dictGet2(nameRoot, "EmbeddedFiles");
+    for (; ; ) {
+      signal.throwIfAborted();
+      if (++work % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+      const dict = await dictionary(node);
+      if (dict) {
+        const entries = (await document.lookup(dictGet2(dict, "Names")))?.value;
+        if (entries?.kind === "array") for (let index = 0; index + 1 < entries.items.length; index += 2) {
+          const label = (await document.lookup(entries.items[index]))?.value;
+          yield { node: entries.items[index + 1], fallback: label?.kind === "string" ? decodePdfString4(label) : `att_${index}` };
+        }
+        const kids = (await document.lookup(dictGet2(dict, "Kids")))?.value;
+        if (kids?.kind === "array" && kids.items.length) {
+          const ref = await values.allocate(kids), bytes = new Uint8Array(24), view = new DataView(bytes.buffer);
+          view.setFloat64(0, top);
+          view.setFloat64(8, ref.objectNumber);
+          const position = backing.allocate(24);
+          await backing.write(position, bytes);
+          top = position;
+        }
       }
-      for await (const part of text()) {
-        signal.throwIfAborted();
-        let at = 0;
-        while (at < part.length) {
-          if (newline) {
-            yield "\n";
-            yield "  ".repeat(depth);
-            newline = false;
-          }
-          const end = part.indexOf("\n", at);
-          if (end < 0) {
-            yield part.slice(at);
-            break;
-          }
-          yield part.slice(at, end);
-          newline = true;
-          at = end + 1;
+      node = void 0;
+      while (top >= 0) {
+        const bytes = await backing.read(top, 24), frame = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        const kids = (await values.get(frame.getFloat64(8))).value;
+        if (kids.kind !== "array") throw new Error("Invalid retained attachment traversal frame");
+        const index = frame.getFloat64(16), child = kids.items[index];
+        if (!child) {
+          top = frame.getFloat64(0);
+          continue;
+        }
+        frame.setFloat64(16, index + 1);
+        await backing.write(top, bytes);
+        if (child.kind === "ref") {
+          if (await visited.get(BigInt(child.objectNumber)) !== void 0) continue;
+          await visited.set(BigInt(child.objectNumber), 1n);
         }
+        node = child;
+        break;
       }
-      return;
+      if (!node) break;
     }
-    const object = node.kind === "object";
-    yield object ? "{" : "[";
-    let first = true;
-    if (node.kind === "object") for await (const [key, child] of node.entries) {
-      yield first ? "\n" : ",\n";
-      first = false;
-      yield "  ".repeat(depth + 1);
-      yield* string([key]);
-      yield ": ";
-      yield* parts(child, depth + 1);
+    const associated = (await document.lookup(root && dictGet2(root, "AF")))?.value;
+    if (associated?.kind === "array") for (const item of associated.items) yield { node: item, fallback: "" };
+    for await (const page of document.pages()) {
+      const annotations = (await document.lookup(dictGet2(page.dict, "Annots")))?.value;
+      if (annotations?.kind !== "array") continue;
+      for (const item of annotations.items) {
+        const annotation = await dictionary(item), subtype = annotation && dictGet2(annotation, "Subtype");
+        if (subtype?.kind !== "name" || subtype.decoded !== "FileAttachment") continue;
+        const file = dictGet2(annotation, "FS");
+        if (file) yield { node: file, fallback: "" };
+      }
     }
-    else for await (const child of node.values) {
-      yield first ? "\n" : ",\n";
-      first = false;
-      yield "  ".repeat(depth + 1);
-      yield* parts(child, depth + 1);
+  }
+  try {
+    for await (const spec of specifications()) {
+      const dict = await dictionary(spec.node);
+      if (!dict) continue;
+      const filenameNode = (await document.lookup(dictGet2(dict, "UF") ?? dictGet2(dict, "F")))?.value;
+      const filename = filenameNode?.kind === "string" ? decodePdfString4(filenameNode) : spec.fallback, name = spec.fallback || filename;
+      const identity = (await names.intern(name)).index;
+      if (await accepted.get(BigInt(identity)) !== void 0) continue;
+      const embedded = await dictionary(dictGet2(dict, "EF"));
+      const stream = embedded && await document.lookup(dictGet2(embedded, "UF") ?? dictGet2(embedded, "F") ?? dictGet2(embedded, "DOS") ?? dictGet2(embedded, "Mac") ?? dictGet2(embedded, "Unix"));
+      if (!stream?.stream || !stream.reference) continue;
+      await accepted.set(BigInt(identity), 1n);
+      yield { key: name, filename, reference: stream.reference };
     }
-    if (!first) {
-      yield "\n";
-      yield "  ".repeat(depth);
+  } catch (error) {
+    failed = true;
+    if (error instanceof PdfError2 && error.message.startsWith("Unsupported streaming PDF filter: ")) {
+      throw new PdfError2(error.code, `Unsupported PDF filter: ${error.message.slice("Unsupported streaming PDF filter: ".length)}`);
     }
-    yield object ? "}" : "]";
-  }
-  const encoder = new TextEncoder();
-  let buffer = new Uint8Array(16384), used = 0, work = 0;
-  for await (const part of parts(value)) {
-    if (++work % 256 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
-    signal.throwIfAborted();
-    for (let at = 0; at < part.length; ) {
-      const result = encoder.encodeInto(part.slice(at), buffer.subarray(used));
-      used += result.written;
-      at += result.read;
-      if (buffer.length - used < 4) {
-        yield buffer.subarray(0, used);
-        buffer = new Uint8Array(16384);
-        used = 0;
-      }
+    throw error;
+  } finally {
+    const results = await Promise.allSettled([values.close(), names.close(), backing.close()]);
+    if (!failed) {
+      for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
     }
   }
-  if (used === buffer.length) {
-    yield buffer;
-    buffer = new Uint8Array(16384);
-    used = 0;
-  }
-  buffer[used++] = 10;
-  yield buffer.subarray(0, used);
 }
-async function* base64Parts(bytes, signal) {
-  let pending = 0, count = 0, output = "";
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  for await (const chunk of bytes) for (const byte of chunk) {
-    pending = pending << 8 | byte;
-    if (++count === 3) {
-      output += alphabet[pending >>> 18 & 63] + alphabet[pending >>> 12 & 63] + alphabet[pending >>> 6 & 63] + alphabet[pending & 63];
-      pending = 0;
-      count = 0;
+async function* attachmentChunks(document, storage, key, signal) {
+  let found = false;
+  try {
+    for await (const attachment of retainedAttachments(document, storage, signal)) {
+      const selected = key !== void 0 && !found && (attachment.key === key || attachment.filename === key);
+      if (selected) found = true;
+      for await (const bytes of document.objects.decodeStream(attachment.reference.objectNumber, attachment.reference.generationNumber)) {
+        signal.throwIfAborted();
+        if (selected) yield bytes;
+      }
+      if (key === void 0) yield* encodeDisplayParts([attachment.key, " -> ", attachment.filename, "\n"], signal);
     }
-    if (output.length >= 4096) {
-      signal.throwIfAborted();
-      yield output;
-      output = "";
+    if (key !== void 0 && !found) throw new QpdfMissingAttachment(key);
+  } catch (error) {
+    if (error instanceof PdfError2 && error.message.startsWith("Unsupported streaming PDF filter: ")) {
+      throw new PdfError2(error.code, `Unsupported PDF filter: ${error.message.slice("Unsupported streaming PDF filter: ".length)}`);
     }
+    throw error;
   }
-  if (count) {
-    pending <<= (3 - count) * 8;
-    output += alphabet[pending >>> 18 & 63] + alphabet[pending >>> 12 & 63] + (count === 2 ? alphabet[pending >>> 6 & 63] : "=") + "=";
-  }
-  if (output) yield output;
 }
 
+// packages/safe-bash-command-qpdf/src/object-order.ts
+import { retainedObjectOrder } from "../pdf-ast/index.js";
+
 // packages/safe-bash-command-qpdf/src/json.ts
 async function createQpdfJson(sourceDocument, document, source, storage, options, inputNames, maxOutputBytes, signal) {
   const pages = new PagedStorage4({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
@@ -638,6 +937,8 @@ async function createQpdfJson(sourceDocument, document, source, storage, options
       for (const result of results) if (result.status === "rejected") await Promise.reject(result.reason);
     })();
   }
+  const include = (key) => !options.jsonKeys.length || options.jsonKeys.includes(key);
+  const includeObjects = include(options.jsonVersion === 1 ? "objects" : "qpdf");
   const selected = (number, generation) => !options.jsonObjectSelectors.length || options.jsonObjectSelectors.some((item) => item.kind === "obj" && item.objNum === number && item.genNum === generation);
   async function* objects() {
     for await (const number of retainedObjectOrder(sourceDocument, source, storage, signal)) {
@@ -663,16 +964,38 @@ async function createQpdfJson(sourceDocument, document, source, storage, options
       } else value = jsonRecord({ value: cosJson(object.value, storage, signal) });
       yield [`obj:${object.objectNumber} ${object.generationNumber} R`, value];
     }
-    if (!options.jsonObjectSelectors.length || options.jsonObjectSelectors.some((item) => item.kind === "trailer")) yield ["trailer", jsonRecord({ value: cosJson(cosDict({ Root: document.crossReference.rootRef, ...document.crossReference.infoRef ? { Info: document.crossReference.infoRef } : {}, Size: cosNumber(maximum + 1) }), storage, signal) })];
+    if (!options.jsonObjectSelectors.length || options.jsonObjectSelectors.some((item) => item.kind === "trailer")) yield ["trailer", jsonRecord({ value: cosJson(cosDict2({ Root: document.crossReference.rootRef, ...document.crossReference.infoRef ? { Info: document.crossReference.infoRef } : {}, Size: cosNumber2(maximum + 1) }), storage, signal) })];
+  }
+  async function* objectInfoEntries() {
+    for await (const object of objects()) {
+      if (!selected(object.objectNumber, object.generationNumber)) continue;
+      const dict = object.stream && object.value.kind === "dict" ? object.value : void 0;
+      const filter = dict && dictGet3(dict, "Filter"), length = dict && dictGet3(dict, "Length");
+      yield [`${object.objectNumber} ${object.generationNumber} R`, jsonRecord({ stream: jsonRecord({
+        filter: filter ? cosJson(filter, storage, signal) : null,
+        is: Boolean(dict),
+        length: length ? cosJson(length, storage, signal) : null
+      }) })];
+    }
   }
   async function pageObject(index) {
     if (!count) return "obj:0 0 R";
-    if (index >= count) throw new PdfError2("E_CAPABILITY", `Page index out of bounds: ${index}`);
+    if (index >= count) throw new PdfError3("E_CAPABILITY", `Page index out of bounds: ${index}`);
     const bytes = await pages.read(pageBase + index * 16, 16), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
     return `obj:${view.getFloat64(0)} ${view.getFloat64(8)} R`;
   }
   async function* pageValues() {
-    for (let index = 0; index < count; index++) yield jsonRecord({ object: await pageObject(index), pageposfrom1: index + 1 });
+    const root = (await document.lookup(document.crossReference.rootRef))?.value;
+    let index = 0;
+    for await (const page of document.pages()) {
+      const steps = qpdfJsonPage(page.dict, page.reference, index++, root?.kind === "dict" ? root : void 0, options.jsonVersion ?? 2);
+      let step = steps.next();
+      while (!step.done) {
+        signal.throwIfAborted();
+        step = steps.next((await document.lookup(step.value))?.value);
+      }
+      yield step.value;
+    }
   }
   async function* outlines() {
     for await (const outline of document.outlines()) {
@@ -699,7 +1022,7 @@ async function createQpdfJson(sourceDocument, document, source, storage, options
     async function row(number) {
       const node = (await values.get(number)).value;
       if (node.kind !== "array" || node.items[0]?.kind !== "string" || node.items[1]?.kind !== "string") throw new Error("Invalid JSON attachment record");
-      return [decodePdfString4(node.items[0]), jsonRecord({ filename: decodePdfString4(node.items[1]) })];
+      return [decodePdfString5(node.items[0]), jsonRecord({ filename: decodePdfString5(node.items[1]) })];
     }
     try {
       for await (const attachment of retainedAttachments(document, storage, signal)) {
@@ -739,14 +1062,14 @@ async function createQpdfJson(sourceDocument, document, source, storage, options
           yield { name, chunks: [] };
           continue;
         }
-        if (options.jsonStreamDataMode !== "file" || !name.startsWith(prefix)) continue;
+        if (!includeObjects || options.jsonStreamDataMode !== "file" || !name.startsWith(prefix)) continue;
         const number = Number(name.slice(prefix.length));
         if (!Number.isSafeInteger(number) || number < 1 || String(number) !== name.slice(prefix.length)) continue;
         const entry = await document.crossReference.index.get(number, signal);
         if (!entry || !selected(number, entry.generationNumber ?? 0)) continue;
         if ((await document.objects.get(number, entry.generationNumber ?? 0))?.stream) yield { name, chunks: [] };
       }
-      if (options.jsonStreamDataMode !== "file") return;
+      if (!includeObjects || options.jsonStreamDataMode !== "file") return;
       for await (const object of objects()) if (object.stream && selected(object.objectNumber, object.generationNumber)) {
         async function* admitted() {
           let size = 0;
@@ -760,20 +1083,20 @@ async function createQpdfJson(sourceDocument, document, source, storage, options
       }
     }
     files = await PdfStagedOutputs.create(storage, fileEntries(), { signal, maxNameChars: Infinity });
-    objectJson = await PdfFileSource.fromStream(storage.fs, storage.directory, jsonChunks({ kind: "object", entries: objectEntries() }, signal), { signal, maxInputBytes: maxOutputBytes });
-    const objectValue = { kind: "formatted", chunks: objectJson.stream(0, objectJson.size, signal) };
+    if (includeObjects) objectJson = await PdfFileSource.fromStream(storage.fs, storage.directory, jsonChunks({ kind: "object", entries: objectEntries() }, signal), { signal, maxInputBytes: maxOutputBytes });
+    const objectValue = objectJson ? { kind: "formatted", chunks: objectJson.stream(0, objectJson.size, signal) } : jsonRecord({});
     async function summary(value) {
       const source2 = await PdfFileSource.fromStream(storage.fs, storage.directory, jsonChunks(value, signal), { signal, maxInputBytes: maxOutputBytes });
       summaries.push(source2);
       return { kind: "formatted", chunks: source2.stream(0, source2.size, signal) };
     }
-    const attachmentValue = await summary({ kind: "object", entries: attachments() });
+    const attachmentValue = include("attachments") ? await summary({ kind: "object", entries: attachments() }) : jsonRecord({});
     const root = (await document.lookup(document.crossReference.rootRef))?.value;
-    const form = root?.kind === "dict" ? (await document.lookup(dictGet2(root, "AcroForm")))?.value : void 0;
-    const appearances = form?.kind === "dict" ? (await document.lookup(dictGet2(form, "NeedAppearances")))?.value : void 0;
-    const fieldValue = await summary({ kind: "array", values: fields() });
-    const outlineValue = await summary({ kind: "array", values: outlines() });
-    const labelValue = await summary({ kind: "array", values: labels() });
+    const form = root?.kind === "dict" ? (await document.lookup(dictGet3(root, "AcroForm")))?.value : void 0;
+    const appearances = form?.kind === "dict" ? (await document.lookup(dictGet3(form, "NeedAppearances")))?.value : void 0;
+    const fieldValue = await summary({ kind: "array", values: include("acroform") ? fields() : [] });
+    const outlineValue = await summary({ kind: "array", values: include("outlines") ? outlines() : [] });
+    const labelValue = await summary({ kind: "array", values: include("pagelabels") ? labels() : [] });
     const metadata = {
       pdfversion: document.crossReference.version,
       ...options.jsonVersion === 2 ? { maxobjectid: maximum } : {},
@@ -785,7 +1108,15 @@ async function createQpdfJson(sourceDocument, document, source, storage, options
       attachments: attachmentValue
     };
     const payload = options.jsonVersion === 1 ? jsonRecord({ version: 1, ...metadata, objects: objectValue }) : jsonRecord({ version: 2, qpdf: { kind: "array", values: [jsonRecord(metadata), objectValue] } });
-    json = await PdfFileSource.fromStream(storage.fs, storage.directory, jsonChunks(payload, signal), { signal, maxInputBytes: maxOutputBytes });
+    const sections = {
+      ...metadata,
+      objects: objectValue,
+      objectinfo: { kind: "object", entries: objectInfoEntries() },
+      qpdf: { kind: "array", values: [jsonRecord({ jsonversion: 2, pdfversion: document.crossReference.version, maxobjectid: maximum }), objectValue] }
+    };
+    const selectedPayload = { version: options.jsonVersion ?? 2, parameters: jsonRecord({ decodelevel: "generalized" }) };
+    for (const key of options.jsonKeys) selectedPayload[key] = sections[key];
+    json = await PdfFileSource.fromStream(storage.fs, storage.directory, jsonChunks(options.jsonKeys.length ? jsonRecord(selectedPayload) : payload, signal), { signal, maxInputBytes: maxOutputBytes });
     let total = json.size;
     for await (const entry of files.entries()) {
       if (entry.name === options.outputFile && options.outputFile !== "-") continue;
@@ -796,14 +1127,14 @@ async function createQpdfJson(sourceDocument, document, source, storage, options
   } catch (error) {
     await close().catch(() => {
     });
-    if (error instanceof PdfError2 && error.message.startsWith("Unsupported streaming PDF filter: ")) throw new PdfError2(error.code, `Unsupported PDF filter: ${error.message.slice("Unsupported streaming PDF filter: ".length)}`);
+    if (error instanceof PdfError3 && error.message.startsWith("Unsupported streaming PDF filter: ")) throw new PdfError3(error.code, `Unsupported PDF filter: ${error.message.slice("Unsupported streaming PDF filter: ".length)}`);
     throw error;
   }
 }
 
 // packages/safe-bash-command-qpdf/src/linearization.ts
 import { IntegerTable as IntegerTable5, PagedStorage as PagedStorage5 } from "@poe-platform/safe-fs/storage";
-import { PdfError as PdfError3, cosDict as cosDict2, dictGet as dictGet3, readCosXrefRevision, scanCosRangeObjects } from "../pdf-ast/index.js";
+import { PdfError as PdfError4, cosDict as cosDict3, dictGet as dictGet4, readCosXrefRevision, scanCosRangeObjects, PdfFileSource as PdfFileSource2 } from "../pdf-ast/index.js";
 async function firstDictionary(document, source, storage, signal) {
   const backing = new PagedStorage5({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const seen = new IntegerTable5(backing), revisions = new IntegerTable5(backing), streams = new IntegerTable5(backing);
@@ -814,7 +1145,7 @@ async function firstDictionary(document, source, storage, signal) {
     const entry = await document.crossReference.index.get(number, signal);
     if (!entry || entry.type === "free") return;
     const object = await document.objects.get(number, entry.generationNumber ?? 0);
-    if (!object?.stream && object?.value.kind === "dict" && dictGet3(object.value, "Linearized") !== void 0) return { dict: object.value, type: entry.type };
+    if (!object?.stream && object?.value.kind === "dict" && dictGet4(object.value, "Linearized") !== void 0) return { dict: object.value, type: entry.type };
     return;
   }
   try {
@@ -831,10 +1162,10 @@ async function firstDictionary(document, source, storage, signal) {
             if (match && !compressed) compressed = match.dict;
             step = await revision.next();
           }
-          const previous = dictGet3(step.value, "Prev");
+          const previous = dictGet4(step.value, "Prev");
           offset = previous?.kind === "number" ? previous.value : void 0;
         } finally {
-          await revision.return(cosDict2({}));
+          await revision.return(cosDict3({}));
         }
       }
       if (compressed) return compressed;
@@ -850,7 +1181,7 @@ async function firstDictionary(document, source, storage, signal) {
         await streams.set(BigInt(number), 1n);
         const entry = await document.crossReference.index.get(number, signal);
         if (!entry || entry.type !== "uncompressed") continue;
-        const object = await document.objects.get(number, entry.generationNumber ?? 0), type = object?.value.kind === "dict" ? dictGet3(object.value, "Type") : void 0;
+        const object = await document.objects.get(number, entry.generationNumber ?? 0), type = object?.value.kind === "dict" ? dictGet4(object.value, "Type") : void 0;
         if (!object?.stream || type?.kind !== "name" || type.decoded !== "ObjStm") continue;
         try {
           for await (const member of document.objects.objectStreamEntries(number, entry.generationNumber ?? 0)) {
@@ -858,11 +1189,11 @@ async function firstDictionary(document, source, storage, signal) {
             if (match) return match.dict;
           }
         } catch (error) {
-          if (!(error instanceof PdfError3) || error.code !== "E_PARSE") throw error;
+          if (!(error instanceof PdfError4) || error.code !== "E_PARSE") throw error;
         }
       }
     }
-    for await (const page of document.pages()) if (!page.reference && dictGet3(page.dict, "Linearized") !== void 0) return page.dict;
+    for await (const page of document.pages()) if (!page.reference && dictGet4(page.dict, "Linearized") !== void 0) return page.dict;
     return void 0;
   } catch (error) {
     failed = true;
@@ -873,31 +1204,57 @@ async function firstDictionary(document, source, storage, signal) {
     });
   }
 }
-async function* linearizationParts(document, source, storage, filename, pageCount, signal) {
+async function* linearizationParts(document, source, storage, filename, pageCount, signal, mode) {
   const dict = await firstDictionary(document, source, storage, signal);
-  yield filename ?? "empty";
   if (!dict) {
-    yield ": not linearized\n";
+    yield `${filename ?? "empty"} is not linearized
+`.repeat(mode === "both" ? 2 : 1);
     return;
   }
+  if (mode !== "show") {
+    yield `${filename ?? "empty"}: no linearization errors
+`;
+    if (mode === "check") return;
+  }
   async function number(key, fallback = 0) {
-    const node = (await document.lookup(dictGet3(dict, key)))?.value;
+    const node = (await document.lookup(dictGet4(dict, key)))?.value;
     return node?.kind === "number" ? node.value : fallback;
   }
-  const hints = (await document.lookup(dictGet3(dict, "H")))?.value;
+  const hints = (await document.lookup(dictGet4(dict, "H")))?.value;
   async function hint(index) {
     const node = hints?.kind === "array" ? (await document.lookup(hints.items[index]))?.value : void 0;
-    return node && "value" in node ? node.value ?? 0 : 0;
+    return node?.kind === "number" ? node.value : 0;
+  }
+  const values = { file_size: await number("L"), first_page_object: await number("O"), first_page_end: await number("E"), npages: pageCount, xref_zero_offset: await number("T"), first_page: await number("P"), H_offset: await hint(0), H_length: await hint(1) };
+  let decoded, sharedOffset = 0, outlineOffset;
+  try {
+    for await (const entry of document.crossReference.index.entries(signal)) {
+      if (entry.type !== "uncompressed" || entry.offset !== values.H_offset) continue;
+      const object = await document.objects.get(entry.objectNumber, entry.generationNumber ?? 0);
+      if (!object?.stream || object.value.kind !== "dict") break;
+      const shared = (await document.lookup(dictGet4(object.value, "S")))?.value, outline = (await document.lookup(dictGet4(object.value, "O")))?.value;
+      sharedOffset = shared?.kind === "number" ? shared.value : 0;
+      outlineOffset = outline?.kind === "number" ? outline.value : void 0;
+      decoded = await PdfFileSource2.fromStream(storage.fs, storage.directory, document.objects.decodeStream(entry.objectNumber, entry.generationNumber ?? 0), { signal });
+      break;
+    }
+    const report = linearizationReport(filename ?? "empty", values, decoded?.size ?? 0, sharedOffset, outlineOffset);
+    let step = report.next();
+    while (!step.done) {
+      signal.throwIfAborted();
+      if (typeof step.value === "string") {
+        yield step.value;
+        step = report.next(new Uint8Array());
+      } else step = report.next(await decoded.read(step.value.offset, step.value.length, signal));
+    }
+  } finally {
+    await decoded?.close();
   }
-  yield `: linearized
-Linearization dictionary: L=${await number("L")} H=[${await hint(0)} ${await hint(1)}] O=${await number("O")} E=${await number("E")} N=${await number("N", pageCount)} T=${await number("T")}
-no linearization errors
-`;
 }
 
 // packages/safe-bash-command-qpdf/src/selection.ts
 import { IntegerTable as IntegerTable6, PagedStorage as PagedStorage6 } from "@poe-platform/safe-fs/storage";
-import { PdfRetainedDocument, createRetainedPageCopy, retainedCosObjects, decodePdfString as decodePdfString5, dictGet as dictGet4 } from "../pdf-ast/index.js";
+import { PdfRetainedDocument, createRetainedPageCopy, retainedCosObjects, decodePdfString as decodePdfString6, dictGet as dictGet5 } from "../pdf-ast/index.js";
 var QpdfMissingInput = class extends Error {
   constructor(file) {
     super(`qpdf: cannot open ${file}
@@ -921,8 +1278,8 @@ async function copyQpdfSelections(base, source, inputs, storage, options, signal
   if (!options.emptyInput) {
     const info = (await base.lookup(base.crossReference.infoRef))?.value;
     if (info?.kind === "dict") for (const key of ["Title", "Author"]) {
-      const value = (await base.lookup(dictGet4(info, key)))?.value;
-      const text = value?.kind === "string" ? decodePdfString5(value) : value?.kind === "name" ? value.decoded : void 0;
+      const value = (await base.lookup(dictGet5(info, key)))?.value;
+      const text = value?.kind === "string" ? decodePdfString6(value) : value?.kind === "name" ? value.decoded : void 0;
       if (text) metadata[key] = text;
     }
   }
@@ -1026,67 +1383,50 @@ async function* collatedSelections(inputs, storage, options, signal) {
 }
 
 // packages/safe-bash-command-qpdf/src/xref-display.ts
-import { PdfError as PdfError4, PdfObjectIndex, findPdfStartXref, readCosXrefRevision as readCosXrefRevision2 } from "../pdf-ast/index.js";
-async function* xrefDisplayParts(document, source, storage, highest, signal) {
-  let latest, failed = false;
-  try {
-    try {
-      const offset = await findPdfStartXref(source, { signal });
-      latest = await PdfObjectIndex.build(readCosXrefRevision2(source, offset, { signal }), storage, { signal, duplicate: "last" });
-    } catch (error) {
-      signal.throwIfAborted();
-      if (!(error instanceof PdfError4) || error.code !== "E_PARSE") throw error;
-    }
-    let count = 0;
-    for await (const entry of document.crossReference.index.entries(signal)) {
-      if (entry.type === "free") continue;
-      const number = entry.objectNumber, generation = entry.generationNumber ?? 0;
+async function* xrefDisplayParts(document, highest, signal) {
+  let count = 0;
+  for await (const entry of document.crossReference.index.entries(signal)) {
+    if (entry.type === "free") continue;
+    const number = entry.objectNumber, generation = entry.generationNumber ?? 0;
+    if (entry.type === "compressed" && document.crossReference.revisionCount === 0) {
       const object = await document.objects.get(number, generation);
-      if (!object) throw new PdfError4("E_PARSE", "Missing indexed PDF object");
-      const type = object.stream ? "stream" : object.value.kind, revision = await latest?.get(number, signal);
-      yield revision?.type === "compressed" ? `${number}/0: compressed; stream = ${revision.objectStreamNumber}; index = ${revision.indexInObjectStream}; type = ${type}
-` : `${number}/${generation}: uncompressed; type = ${type}
+      yield `${number}/${generation}: uncompressed; type = ${object.value.kind}
 `;
-      if (++count % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
-    }
-    for await (const page of document.pages()) if (!page.reference) {
-      yield `${++highest}/0: uncompressed; type = dict
+    } else yield entry.type === "compressed" ? `${number}/0: compressed; stream = ${entry.objectStreamNumber}, index = ${entry.indexInStream ?? entry.indexInObjectStream}
+` : `${number}/${generation}: uncompressed; offset = ${entry.offset}
 `;
-      count++;
-    }
-    if (!count) yield "\n";
-  } catch (error) {
-    failed = true;
-    throw error;
-  } finally {
-    await latest?.close().catch((error) => {
-      if (!failed) return Promise.reject(error);
-    });
+    if (++count % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+  for await (const page of document.pages()) if (!page.reference) {
+    yield `${++highest}/0: uncompressed; type = dict
+`;
+    count++;
   }
+  if (!count) yield "\n";
 }
 
 // packages/safe-bash-command-qpdf/src/page-display.ts
 import { IntegerTable as IntegerTable7, PagedStorage as PagedStorage7 } from "@poe-platform/safe-fs/storage";
-import { PdfMutableObjectStore as PdfMutableObjectStore3, cosDict as cosDict3, dictGet as dictGet5 } from "../pdf-ast/index.js";
+import { PdfMutableObjectStore as PdfMutableObjectStore3, cosDict as cosDict4, dictGet as dictGet6 } from "../pdf-ast/index.js";
 async function* imageParts(document, page, storage, signal) {
   const values = new PdfMutableObjectStore3(storage, { signal });
   const backing = new PagedStorage7({ fs: storage.fs, cwd: storage.directory, env: {}, signal }, 4);
   const visited = new IntegerTable7(backing, 64);
-  let top = -1, failed = false, work = 0;
+  let top = -1, failed = false, work = 0, hasImages = false;
   async function pageResources() {
-    const direct = await document.lookup(dictGet5(page, "Resources"));
+    const direct = await document.lookup(dictGet6(page, "Resources"));
     if (direct?.value.kind === "dict") return { value: direct.value, inherited: false };
     const parents = new IntegerTable7(backing, 64);
     let current = page;
     while (current) {
       signal.throwIfAborted();
       if (++work % 64 === 0) await new Promise((resolve) => setTimeout(resolve, 0));
-      const node = dictGet5(current, "Resources");
+      const node = dictGet6(current, "Resources");
       if (node) {
         const found2 = await document.lookup(node);
         return found2?.value.kind === "dict" && !found2.stream ? { value: found2.value, inherited: true } : void 0;
       }
-      const parent = dictGet5(current, "Parent");
+      const parent = dictGet6(current, "Parent");
       if (parent?.kind === "ref") {
         if (await parents.get(BigInt(parent.objectNumber)) !== void 0) break;
         await parents.set(BigInt(parent.objectNumber), 1n);
@@ -1099,9 +1439,9 @@ async function* imageParts(document, page, storage, signal) {
   async function push(node, inherited = false) {
     const resource = await document.lookup(node);
     if (resource?.value.kind !== "dict" || resource.stream) return;
-    const found = await document.lookup(dictGet5(resource.value, "XObject"));
+    const found = await document.lookup(dictGet6(resource.value, "XObject"));
     if (found?.value.kind !== "dict" || found.stream && !inherited) return;
-    const objects = inherited ? cosDict3(Object.fromEntries(found.value.entries.map((entry) => [entry.key.decoded, entry.value]))) : found.value;
+    const objects = inherited ? cosDict4(Object.fromEntries(found.value.entries.map((entry) => [entry.key.decoded, entry.value]))) : found.value;
     const ref = await values.allocate(objects), bytes = new Uint8Array(24), view = new DataView(bytes.buffer);
     view.setFloat64(0, top);
     view.setFloat64(8, ref.objectNumber);
@@ -1128,20 +1468,24 @@ async function* imageParts(document, page, storage, signal) {
       const reference = entry.value.kind === "ref" ? entry.value : void 0;
       const value = (await document.lookup(entry.value))?.value;
       if (value?.kind !== "dict") continue;
-      const subtype = dictGet5(value, "Subtype");
+      const subtype = dictGet6(value, "Subtype");
       if (subtype?.kind !== "name") continue;
       if (subtype.decoded === "Image") {
-        const width = dictGet5(value, "Width"), height = dictGet5(value, "Height");
+        const width = dictGet6(value, "Width"), height = dictGet6(value, "Height");
+        if (!hasImages) {
+          yield "  images:\n";
+          hasImages = true;
+        }
         yield "    /";
         yield entry.key.decoded;
-        yield `: ${reference ? `${reference.objectNumber} ${reference.generationNumber} R` : "inline"} (${width?.kind === "number" ? width.value : 0} x ${height?.kind === "number" ? height.value : 0})
+        yield `: ${reference ? `${reference.objectNumber} ${reference.generationNumber} R` : "inline"}, ${width?.kind === "number" ? width.value : 0} x ${height?.kind === "number" ? height.value : 0}
 `;
       } else if (subtype.decoded === "Form") {
         if (reference) {
           if (await visited.get(BigInt(reference.objectNumber)) !== void 0) continue;
           await visited.set(BigInt(reference.objectNumber), 1n);
         }
-        await push(dictGet5(value, "Resources"));
+        await push(dictGet6(value, "Resources"));
       }
     }
   } catch (error) {
@@ -1160,12 +1504,9 @@ async function* pageDisplayParts(document, storage, highest, withImages, signal)
     const ref = page.reference ?? { objectNumber: ++highest, generationNumber: 0 };
     yield `page ${++count}: ${ref.objectNumber} ${ref.generationNumber} R
 `;
-    if (withImages) {
-      yield "  images:\n";
-      yield* imageParts(document, page.dict, storage, signal);
-    }
+    if (withImages) yield* imageParts(document, page.dict, storage, signal);
     yield "  content:\n";
-    const contents = dictGet5(page.dict, "Contents");
+    const contents = dictGet6(page.dict, "Contents");
     for (const node of contents?.kind === "array" ? contents.items : contents ? [contents] : []) {
       if (node.kind === "ref") yield `    ${node.objectNumber} ${node.generationNumber} R
 `;
@@ -1175,7 +1516,7 @@ async function* pageDisplayParts(document, storage, highest, withImages, signal)
 }
 
 // packages/safe-bash-command-qpdf/src/retained.ts
-import { QpdfJsonDocument, encryptRetainedPdfChunks, copyRetainedAttachments, editRetainedDocument, PdfDuplicateAttachment, PdfError as PdfError5, PdfFileSource as PdfFileSource2, PdfRetainedDocument as PdfRetainedDocument2, PdfStagedOutputs as PdfStagedOutputs2, saveRetainedDocumentChunks, retainedCosObjects as retainedCosObjects2, serializeRetainedCosDocumentChunks, cosArray as cosArray2, cosDict as cosDict4, cosName, cosNumber as cosNumber2, cosRef, cosString as cosString2, dictGet as dictGet6 } from "../pdf-ast/index.js";
+import { QpdfJsonDocument, encryptRetainedPdfChunks, copyRetainedAttachments, editRetainedDocument, PdfDuplicateAttachment, PdfMissingAttachment, PdfError as PdfError5, PdfFileSource as PdfFileSource3, PdfRetainedDocument as PdfRetainedDocument2, PdfStagedOutputs as PdfStagedOutputs2, saveRetainedDocumentChunks, retainedCosObjects as retainedCosObjects2, serializeRetainedCosDocumentChunks, cosArray as cosArray2, cosDict as cosDict5, cosName, cosNumber as cosNumber3, cosRef, cosString as cosString2, dictGet as dictGet7 } from "../pdf-ast/index.js";
 import { FsError } from "../safe-bash-contracts/errors.js";
 import { writeBytes } from "../safe-bash-contracts/io.js";
 import { resolvePath } from "../safe-bash-contracts/path.js";
@@ -1205,7 +1546,7 @@ async function executeRetainedQpdf(context, options, limits, signal, inputBytes
         yield bytes;
       }
     }
-    output = await PdfFileSource2.fromStream(context.fs, storage.directory, admitted(), { signal, maxInputBytes: limits.maxOutputBytes });
+    output = await PdfFileSource3.fromStream(context.fs, storage.directory, admitted(), { signal, maxInputBytes: limits.maxOutputBytes });
     for await (const bytes of output.stream(0, output.size, signal)) await writeBytes(context.stdout, bytes, signal);
   }
   try {
@@ -1215,7 +1556,7 @@ async function executeRetainedQpdf(context, options, limits, signal, inputBytes
       if (inputs.has(candidate)) return inputs.get(candidate);
       let acquired;
       try {
-        acquired = await PdfFileSource2.open(context.fs, resolvePath(context.cwd, candidate), { signal, maxInputBytes: maximum - inputBytes });
+        acquired = await PdfFileSource3.open(context.fs, resolvePath(context.cwd, candidate), { signal, maxInputBytes: maximum - inputBytes });
       } catch (error) {
         signal.throwIfAborted();
         if (error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR", "EACCES", "EISDIR"].includes(String(error.code)) || error instanceof PdfError5 && error.message === "PDF source must be a regular file") {
@@ -1230,7 +1571,7 @@ async function executeRetainedQpdf(context, options, limits, signal, inputBytes
       return acquired;
     };
     const reconstruct = async () => {
-      const next = await PdfFileSource2.fromStream(context.fs, storage.directory, jsonDocument.chunks(), { signal });
+      const next = await PdfFileSource3.fromStream(context.fs, storage.directory, jsonDocument.chunks(), { signal });
       rebuilt.push(next);
       await document?.close();
       document = void 0;
@@ -1245,14 +1586,14 @@ async function executeRetainedQpdf(context, options, limits, signal, inputBytes
       await acquire(candidate);
     }
     if (inputName === "-" || options.updateFromJsonFiles.includes("-") || [...options.pageSpecs, ...options.addAttachmentSpecs, ...options.copyAttachmentsSpecs, ...options.stampSpecs].some((spec) => spec.file === "-")) {
-      const acquired = await PdfFileSource2.fromStream(context.fs, storage.directory, context.stdin, { signal, maxInputBytes: maximum - inputBytes });
+      const acquired = await PdfFileSource3.fromStream(context.fs, storage.directory, context.stdin, { signal, maxInputBytes: maximum - inputBytes });
       inputs.set("-", acquired);
       inputBytes += acquired.size;
       context.inputBudget?.check(inputBytes);
     }
     if (useEmpty) {
-      const objects = [cosDict4({ Type: cosName("Catalog"), Pages: cosRef(2) }), cosDict4({ Type: cosName("Pages"), Count: cosNumber2(0), Kids: cosArray2([]) }), cosDict4({ Producer: cosString2("@poe-code/pdf-ast") })];
-      source = await PdfFileSource2.fromStream(context.fs, storage.directory, serializeRetainedCosDocumentChunks({
+      const objects = [cosDict5({ Type: cosName("Catalog"), Pages: cosRef(2) }), cosDict5({ Type: cosName("Pages"), Count: cosNumber3(0), Kids: cosArray2([]) }), cosDict5({ Producer: cosString2("@poe-code/pdf-ast") })];
+      source = await PdfFileSource3.fromStream(context.fs, storage.directory, serializeRetainedCosDocumentChunks({
         objects: objects.map((value, index) => ({ objectNumber: index + 1, generationNumber: 0, value })),
         rootRef: cosRef(1),
         infoRef: cosRef(3),
@@ -1339,7 +1680,7 @@ async function executeRetainedQpdf(context, options, limits, signal, inputBytes
             selectedValue = object.value;
             selectedLength = object.stream?.length;
           }
-          if (!object.stream && object.value.kind === "dict" && dictGet6(object.value, "Linearized") !== void 0) linearized = true;
+          if (!object.stream && object.value.kind === "dict" && dictGet7(object.value, "Linearized") !== void 0) linearized = true;
           if (object.stream) for await (const ignored of object.stream.chunks) void ignored;
         }
         for await (const page of document.pages()) {
@@ -1353,7 +1694,7 @@ async function executeRetainedQpdf(context, options, limits, signal, inputBytes
 `);
       }
       if (options.showLinearization) {
-        const parts = linearizationParts(document, source, storage, inputName, count, signal);
+        const parts = linearizationParts(document, source, storage, inputName, count, signal, options.showLinearization);
         await publishInspection((async function* () {
           for await (const part of parts) yield* encodeDisplayParts([part], signal);
         })());
@@ -1368,7 +1709,7 @@ async function executeRetainedQpdf(context, options, limits, signal, inputBytes
             for await (const part of parts) yield* encodeDisplayParts([part], signal);
           })();
         } else if (options.showXref) {
-          const parts = xrefDisplayParts(document, source, storage, highest, signal);
+          const parts = xrefDisplayParts(document, highest, signal);
           chunks = (async function* () {
             for await (const part of parts) yield* encodeDisplayParts([part], signal);
           })();
@@ -1400,13 +1741,7 @@ File is ${count === 0 ? "empty" : linearized ? "linearized" : "not linearized"}
 No syntax or stream encoding errors found; the file may still contain
 errors that qpdf cannot detect
 ` : options.showNpages ? `${count}
-` : encryption ? `R = ${encryption.revision}
-V = ${encryption.version}
-Length = ${encryption.keyLengthBits}
-print: ${encryption.permissions.print ? "allowed" : "not allowed"}
-modify: ${encryption.permissions.modify ? "allowed" : "not allowed"}
-extract for accessibility: ${encryption.permissions.copy ? "allowed" : "not allowed"}
-` : "File is not encrypted\n";
+` : encryptionReport(encryption);
       const bytes = new TextEncoder().encode(message);
       if (bytes.length > limits.maxOutputBytes) throw new RangeError("Output byte limit exceeded");
       await writeBytes(context.stdout, bytes, signal);
@@ -1466,6 +1801,18 @@ extract for accessibility: ${encryption.permissions.copy ? "allowed" : "not allo
       selectionGraph = await copyQpdfSelections(document, source, inputs, storage, options, signal);
       document = await selectionGraph.openDocument();
     }
+    let pageCount = 0;
+    if (options.pageLabelSpecs.length) for await (const page of document.pages()) {
+      void page;
+      pageCount++;
+    }
+    let pageLabels;
+    try {
+      pageLabels = parseQpdfPageLabels(options.pageLabelSpecs, pageCount);
+    } catch (error) {
+      return await diagnostic(`qpdf: ${error.message}
+`);
+    }
     const destination = options.replaceInput ? inputName : options.outputFile;
     const { removeInfo, removeMetadata, removeStructure, removeAcroform, removePageLabels } = options;
     async function* rotations() {
@@ -1570,8 +1917,8 @@ extract for accessibility: ${encryption.permissions.copy ? "allowed" : "not allo
         yield { ...spec, length: input.size, chunks: input.stream(0, input.size, signal) };
       }
     }
-    if (options.generateAppearances || options.flattenAnnotations || options.stampSpecs.length || options.externalizeInlineImages || options.removeUnreferencedResources !== "no" || options.flattenRotation || options.copyAttachmentsSpecs.length || options.addAttachmentSpecs.length || options.removeAttachmentKeys.length || options.linearize || options.pageLabelSpecs.length > 0 || options.splitPagesGroup !== void 0 && (removeInfo || removeMetadata || removeStructure || removeAcroform || removePageLabels)) {
-      editedGraph = await editRetainedDocument(document, storage, { generateAppearances: options.generateAppearances, ...options.flattenAnnotations ? { flattenAnnotations: options.flattenAnnotations === true ? "all" : options.flattenAnnotations } : {}, ...options.stampSpecs.length ? { stamps: stamps() } : {}, ...options.externalizeInlineImages ? { externalizeInlineImages: { minBytes: options.iiMinBytes, compress: options.streamDataMode !== "uncompress" } } : {}, removeUnreferencedResources: options.removeUnreferencedResources !== "no", flattenRotation: options.flattenRotation, ...options.copyAttachmentsSpecs.length ? { attachmentCopies: attachmentCopies() } : {}, ...options.removeAttachmentKeys.length ? { removeAttachments: options.removeAttachmentKeys } : {}, ...options.addAttachmentSpecs.length ? { attachments: attachments() } : {}, ...options.pageLabelSpecs.length ? { pageLabels: parseQpdfPageLabels(options.pageLabelSpecs) } : {}, linearize: options.linearize, removeInfo, removeMetadata, removeStructure, removeAcroform, removePageLabels, rotations: rotations(), signal });
+    if (options.generateAppearances || options.flattenAnnotations || options.stampSpecs.length || options.externalizeInlineImages || options.removeUnreferencedResources !== "no" || options.flattenRotation || options.copyAttachmentsSpecs.length || options.addAttachmentSpecs.length || options.removeAttachmentKeys.length || options.linearize || pageLabels.length > 0 || options.splitPagesGroup !== void 0 && (removeInfo || removeMetadata || removeStructure || removeAcroform || removePageLabels)) {
+      editedGraph = await editRetainedDocument(document, storage, { generateAppearances: options.generateAppearances, ...options.flattenAnnotations ? { flattenAnnotations: options.flattenAnnotations === true ? "all" : options.flattenAnnotations } : {}, ...options.stampSpecs.length ? { stamps: stamps() } : {}, ...options.externalizeInlineImages ? { externalizeInlineImages: { minBytes: options.iiMinBytes, compress: options.streamDataMode !== "uncompress" } } : {}, removeUnreferencedResources: options.removeUnreferencedResources !== "no", flattenRotation: options.flattenRotation, ...options.copyAttachmentsSpecs.length ? { attachmentCopies: attachmentCopies() } : {}, ...options.removeAttachmentKeys.length ? { removeAttachments: options.removeAttachmentKeys } : {}, ...options.addAttachmentSpecs.length ? { attachments: attachments() } : {}, ...pageLabels.length ? { pageLabels } : {}, linearize: options.linearize, removeInfo, removeMetadata, removeStructure, removeAcroform, removePageLabels, rotations: rotations(), signal });
     }
     if (!destination) return await diagnostic("qpdf: an output file is required\n");
     if (!options.replaceInput && inputName !== "-" && destination === inputName) return await diagnostic("qpdf: output file may not be the same as the input file (use --replace-input)\n");
@@ -1613,7 +1960,7 @@ extract for accessibility: ${encryption.permissions.copy ? "allowed" : "not allo
     const normalizeContent = options.normalizeContentFlag ?? (options.qdf || options.streamDataMode === "uncompress");
     const producer = saveRetainedDocumentChunks(editedGraph?.document ?? document, storage, { ...editedGraph ? {} : { removeInfo, removeMetadata, removeStructure, removeAcroform, removePageLabels, rotations: rotations() }, signal, normalizeContent, objectStreams: options.decrypt && document.encryption ? "preserve" : options.objectStreamsMode, maxOutputBytes: limits.maxOutputBytes, ...options.decrypt && document.encryption ? { version: "1.7", omitId: true } : {} });
     try {
-      output = await PdfFileSource2.fromStream(context.fs, storage.directory, producer, { signal, maxInputBytes: limits.maxOutputBytes });
+      output = await PdfFileSource3.fromStream(context.fs, storage.directory, producer, { signal, maxInputBytes: limits.maxOutputBytes });
     } finally {
       await producer.return(void 0);
     }
@@ -1621,7 +1968,7 @@ extract for accessibility: ${encryption.permissions.copy ? "allowed" : "not allo
       const plaintext = output, config = options.encryptConfig;
       let encryptionFailed = false;
       try {
-        output = await PdfFileSource2.fromStream(context.fs, storage.directory, encryptRetainedPdfChunks(plaintext, storage, { userPassword: config.userPassword, ownerPassword: config.ownerPassword, permissions: { print: config.print, modify: config.modify, copy: config.copy, addNotes: config.addNotes }, signal, maxOutputBytes: limits.maxOutputBytes }), { signal, maxInputBytes: limits.maxOutputBytes });
+        output = await PdfFileSource3.fromStream(context.fs, storage.directory, encryptRetainedPdfChunks(plaintext, storage, { ...config, signal, maxOutputBytes: limits.maxOutputBytes }), { signal, maxInputBytes: limits.maxOutputBytes });
       } catch (error) {
         encryptionFailed = true;
         throw error;
@@ -1651,6 +1998,8 @@ extract for accessibility: ${encryption.permissions.copy ? "allowed" : "not allo
     if (error instanceof PdfError5 && error.message.startsWith("Unsupported streaming PDF filter: ")) {
       throw new PdfError5(error.code, `Unsupported PDF filter: ${error.message.slice("Unsupported streaming PDF filter: ".length)}`);
     }
+    if (error instanceof PdfMissingAttachment) return await diagnostic(`qpdf: attachment ${error.key} not found
+`);
     if (error instanceof PdfDuplicateAttachment) return await diagnostic(`qpdf: duplicate attachment key ${error.key}
 `);
     if (error instanceof QpdfMissingInput || error instanceof QpdfMissingAttachment) return await diagnostic(error.message);
@@ -1715,21 +2064,23 @@ import { readBytes, writeBytes as writeBytes2 } from "../safe-bash-contracts/io.
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
 import {
   PdfDocument,
-  PdfFileSource as PdfFileSource3,
+  retainedStampTransform,
+  PdfFileSource as PdfFileSource4,
   parseCosDocumentSteps,
   serializeCosDocumentSteps,
   encryptCosDocumentSteps,
   generateDocumentFormAppearancesSteps,
   resolveDestinationPageIndex,
-  decodePdfString as decodePdfString6,
-  cosDict as cosDict5,
-  cosNumber as cosNumber3,
+  decodePdfString as decodePdfString7,
+  cosDict as cosDict6,
+  cosNumber as cosNumber4,
+  cosNull,
   cosArray as cosArray3,
   cosName as cosName2,
   cosString as cosString3,
   cosHexString,
   cosStream,
-  dictGet as dictGet7,
+  dictGet as dictGet8,
   dictSet,
   dictDelete
 } from "../pdf-ast/index.js";
@@ -1796,7 +2147,7 @@ function cosNodeToJson(node) {
     case "name":
       return `/${node.decoded}`;
     case "string":
-      return `u:${decodePdfString6(node)}`;
+      return `u:${decodePdfString7(node)}`;
     case "ref":
       return `${node.objectNumber} ${node.generationNumber} R`;
     case "array":
@@ -1876,7 +2227,7 @@ function parseJsonRefToken(raw) {
 function jsonToCosNode(val) {
   if (val === null || val === void 0) return { kind: "null" };
   if (typeof val === "boolean") return { kind: "boolean", value: val };
-  if (typeof val === "number") return cosNumber3(val);
+  if (typeof val === "number") return cosNumber4(val);
   if (typeof val === "string") {
     if (val.startsWith("n:/")) return cosName2(val.slice(3));
     if (val.startsWith("n:")) return cosName2(val.slice(2));
@@ -1891,7 +2242,7 @@ function jsonToCosNode(val) {
     return cosArray3(val.map(jsonToCosNode));
   }
   if (typeof val === "object") {
-    const d = cosDict5({});
+    const d = cosDict6({});
     for (const [k, v] of Object.entries(val)) {
       const keyName = k.startsWith("n:/") ? k.slice(3) : k.startsWith("/") ? k.slice(1) : k;
       dictSet(d, keyName, jsonToCosNode(v));
@@ -1929,9 +2280,9 @@ function applyQpdfJsonObjects(targetObjects, parsedJson, files) {
     if (objKey === "trailer") {
       const trVal = jsonToCosNode(entry.value);
       if (trVal.kind === "dict") {
-        const rNode = dictGet7(trVal, "Root");
+        const rNode = dictGet8(trVal, "Root");
         if (rNode?.kind === "ref") rootRef = rNode;
-        const iNode = dictGet7(trVal, "Info");
+        const iNode = dictGet8(trVal, "Info");
         if (iNode?.kind === "ref") infoRef = iNode;
       }
       continue;
@@ -1941,7 +2292,7 @@ function applyQpdfJsonObjects(targetObjects, parsedJson, files) {
     if ("stream" in entry && typeof entry.stream === "object" && entry.stream !== null) {
       const stObj = entry.stream;
       const dictConverted = jsonToCosNode(stObj.dict ?? {});
-      const stDict = dictConverted.kind === "dict" ? dictConverted : cosDict5({});
+      const stDict = dictConverted.kind === "dict" ? dictConverted : cosDict6({});
       let streamBytes;
       if (typeof stObj.data === "string") {
         streamBytes = decodeBytesBase64(stObj.data);
@@ -1955,13 +2306,13 @@ function applyQpdfJsonObjects(targetObjects, parsedJson, files) {
         const existing = targetObjects.get(ref.objectNumber)?.value;
         streamBytes = existing?.kind === "stream" ? existing.rawBytes : new Uint8Array(0);
       }
-      const filterNode = dictGet7(stDict, "Filter");
+      const filterNode = dictGet8(stDict, "Filter");
       const shouldStripFilter = filterNode?.kind === "name" && DECOMPRESSIBLE_FILTERS.has(filterNode.decoded) || filterNode?.kind === "array" && filterNode.items.every((it) => it.kind === "name" && DECOMPRESSIBLE_FILTERS.has(it.decoded));
       if (shouldStripFilter) {
         dictDelete(stDict, "Filter");
         dictDelete(stDict, "DecodeParms");
       }
-      dictSet(stDict, "Length", cosNumber3(streamBytes.byteLength));
+      dictSet(stDict, "Length", cosNumber4(streamBytes.byteLength));
       targetObjects.set(ref.objectNumber, {
         objectNumber: ref.objectNumber,
         generationNumber: ref.generationNumber,
@@ -1982,7 +2333,7 @@ function applyQpdfJsonObjects(targetObjects, parsedJson, files) {
   if (!rootRef) {
     for (const obj of targetObjects.values()) {
       if (obj.value.kind === "dict") {
-        const t = dictGet7(obj.value, "Type");
+        const t = dictGet8(obj.value, "Type");
         if (t?.kind === "name" && t.decoded === "Catalog") {
           rootRef = { kind: "ref", objectNumber: obj.objectNumber, generationNumber: obj.generationNumber };
           break;
@@ -2026,13 +2377,13 @@ function collectDocumentAttachments(doc) {
   const seenKeys = /* @__PURE__ */ new Set();
   const pushFilespec = (fsDict, fallbackKey) => {
     if (!fsDict) return;
-    const ufNode = doc.cos.resolve(dictGet7(fsDict, "UF") ?? dictGet7(fsDict, "F"));
-    const fnStr = ufNode?.kind === "string" ? decodePdfString6(ufNode) : fallbackKey;
+    const ufNode = doc.cos.resolve(dictGet8(fsDict, "UF") ?? dictGet8(fsDict, "F"));
+    const fnStr = ufNode?.kind === "string" ? decodePdfString7(ufNode) : fallbackKey;
     const keyStr = fallbackKey || fnStr;
     if (seenKeys.has(keyStr)) return;
-    const efDict = asDict(doc.cos.resolve(dictGet7(fsDict, "EF")));
+    const efDict = asDict(doc.cos.resolve(dictGet8(fsDict, "EF")));
     const stNode = efDict ? doc.cos.resolve(
-      dictGet7(efDict, "UF") ?? dictGet7(efDict, "F") ?? dictGet7(efDict, "DOS") ?? dictGet7(efDict, "Mac") ?? dictGet7(efDict, "Unix")
+      dictGet8(efDict, "UF") ?? dictGet8(efDict, "F") ?? dictGet8(efDict, "DOS") ?? dictGet8(efDict, "Mac") ?? dictGet8(efDict, "Unix")
     ) : void 0;
     if (stNode?.kind === "stream") {
       seenKeys.add(keyStr);
@@ -2041,16 +2392,16 @@ function collectDocumentAttachments(doc) {
   };
   const walkNames = (nodeDict, visited = /* @__PURE__ */ new Set()) => {
     if (!nodeDict) return;
-    const namesArr = asArray(doc.cos.resolve(dictGet7(nodeDict, "Names")));
+    const namesArr = asArray(doc.cos.resolve(dictGet8(nodeDict, "Names")));
     if (namesArr) {
       for (let idx = 0; idx + 1 < namesArr.items.length; idx += 2) {
         const kNode = doc.cos.resolve(namesArr.items[idx]);
-        const keyStr = kNode?.kind === "string" ? decodePdfString6(kNode) : `att_${idx}`;
+        const keyStr = kNode?.kind === "string" ? decodePdfString7(kNode) : `att_${idx}`;
         const fsDict = asDict(doc.cos.resolve(namesArr.items[idx + 1]));
         pushFilespec(fsDict, keyStr);
       }
     }
-    const kidsArr = asArray(doc.cos.resolve(dictGet7(nodeDict, "Kids")));
+    const kidsArr = asArray(doc.cos.resolve(dictGet8(nodeDict, "Kids")));
     if (kidsArr) {
       for (const kid of kidsArr.items) {
         if (kid.kind === "ref") {
@@ -2062,22 +2413,22 @@ function collectDocumentAttachments(doc) {
     }
   };
   const rootDict = asDict(doc.cos.resolve(doc.cos.rootRef));
-  const namesRoot = rootDict ? asDict(doc.cos.resolve(dictGet7(rootDict, "Names"))) : void 0;
-  walkNames(namesRoot ? asDict(doc.cos.resolve(dictGet7(namesRoot, "EmbeddedFiles"))) : void 0);
-  const rootAfArr = rootDict ? asArray(doc.cos.resolve(dictGet7(rootDict, "AF"))) : void 0;
+  const namesRoot = rootDict ? asDict(doc.cos.resolve(dictGet8(rootDict, "Names"))) : void 0;
+  walkNames(namesRoot ? asDict(doc.cos.resolve(dictGet8(namesRoot, "EmbeddedFiles"))) : void 0);
+  const rootAfArr = rootDict ? asArray(doc.cos.resolve(dictGet8(rootDict, "AF"))) : void 0;
   if (rootAfArr) {
     for (const item of rootAfArr.items) {
       pushFilespec(asDict(doc.cos.resolve(item)), "");
     }
   }
   for (const p of doc.getPages()) {
-    const annotsArr = asArray(doc.cos.resolve(dictGet7(p.dict, "Annots")));
+    const annotsArr = asArray(doc.cos.resolve(dictGet8(p.dict, "Annots")));
     if (!annotsArr) continue;
     for (const item of annotsArr.items) {
       const aDict = asDict(doc.cos.resolve(item));
       if (!aDict) continue;
-      if (asName(dictGet7(aDict, "Subtype"))?.decoded === "FileAttachment") {
-        pushFilespec(asDict(doc.cos.resolve(dictGet7(aDict, "FS"))), "");
+      if (asName(dictGet8(aDict, "Subtype"))?.decoded === "FileAttachment") {
+        pushFilespec(asDict(doc.cos.resolve(dictGet8(aDict, "FS"))), "");
       }
     }
   }
@@ -2086,7 +2437,7 @@ function collectDocumentAttachments(doc) {
 function collectNumberTreeDicts(doc, treeDict, visited = /* @__PURE__ */ new Set()) {
   const out = [];
   if (!treeDict) return out;
-  const numsArr = asArray(doc.cos.resolve(dictGet7(treeDict, "Nums")));
+  const numsArr = asArray(doc.cos.resolve(dictGet8(treeDict, "Nums")));
   if (numsArr) {
     for (let idx = 0; idx + 1 < numsArr.items.length; idx += 2) {
       const kNode = doc.cos.resolve(numsArr.items[idx]);
@@ -2096,7 +2447,7 @@ function collectNumberTreeDicts(doc, treeDict, visited = /* @__PURE__ */ new Set
       }
     }
   }
-  const kidsArr = asArray(doc.cos.resolve(dictGet7(treeDict, "Kids")));
+  const kidsArr = asArray(doc.cos.resolve(dictGet8(treeDict, "Kids")));
   if (kidsArr) {
     for (const kid of kidsArr.items) {
       if (kid.kind === "ref") {
@@ -2209,7 +2560,8 @@ function parseQpdfArguments(argv) {
     } else if (arg === "--linearize") {
       linearize = true;
     } else if (arg === "--show-linearization" || arg === "--check-linearization") {
-      showLinearization = true;
+      const mode = arg === "--show-linearization" ? "show" : "check";
+      showLinearization = !showLinearization || showLinearization === mode ? mode : "both";
     } else if (arg === "--collate") {
       collateCount = 1;
     } else if (arg.startsWith("--collate=")) {
@@ -2462,23 +2814,30 @@ function parseQpdfArguments(argv) {
     } else if (arg === "--encrypt") {
       const userPassword = argv[++i] ?? "";
       const ownerPassword = argv[++i] ?? "";
-      const keyLength = Number.parseInt(argv[++i] ?? "256", 10) || 256;
+      if (argv[++i] !== "256") {
+        return { result: { exitCode: 2, stdout: "", stderr: "qpdf: only 256-bit encryption is supported; use --encrypt user-password owner-password 256 --\n" } };
+      }
       const cfg = {
         userPassword,
         ownerPassword,
-        keyLength,
-        print: true,
-        modify: true,
-        copy: true,
-        addNotes: true
+        permissions: {
+          print: true,
+          printHighRes: true,
+          modify: true,
+          copy: true,
+          addNotes: true,
+          fillForms: true,
+          assemble: true,
+          extractAccessibility: true
+        }
       };
       i++;
       while (i < argv.length && argv[i] !== "--") {
         const sub = argv[i];
-        if (sub === "--print=none") cfg.print = false;
-        if (sub === "--modify=none") cfg.modify = false;
-        if (sub === "--extract=n") cfg.copy = false;
-        if (sub === "--annotate=n") cfg.addNotes = false;
+        if (sub === "--print=none") cfg.permissions.print = cfg.permissions.printHighRes = false;
+        if (sub === "--modify=none") cfg.permissions.modify = cfg.permissions.addNotes = cfg.permissions.fillForms = cfg.permissions.assemble = false;
+        if (sub === "--extract=n") cfg.permissions.copy = false;
+        if (sub === "--annotate=n") cfg.permissions.addNotes = false;
         i++;
       }
       encryptConfig = cfg;
@@ -2721,27 +3080,45 @@ function* executeQpdfCli(options, files) {
     let linDict;
     for (const obj of cos.objects.values()) {
       const d = asDict(obj.value);
-      if (d && dictGet7(d, "Linearized") !== void 0) {
+      if (d && dictGet8(d, "Linearized") !== void 0) {
         linDict = d;
         break;
       }
     }
     if (!linDict) {
-      return { exitCode: 0, stdout: `${inputFile ?? "empty"}: not linearized
-`, stderr: "" };
+      return { exitCode: 0, stdout: `${inputFile ?? "empty"} is not linearized
+`.repeat(showLinearization === "both" ? 2 : 1), stderr: "" };
     }
     const numVal = (k, fb = 0) => {
-      const n = cos.resolve(dictGet7(linDict, k));
+      const n = cos.resolve(dictGet8(linDict, k));
       return n?.kind === "number" ? n.value : fb;
     };
-    const hArr = cos.resolveArray(dictGet7(linDict, "H"));
-    const h0 = hArr && hArr.items[0] ? cos.resolve(hArr.items[0])?.value ?? 0 : 0;
-    const h1 = hArr && hArr.items[1] ? cos.resolve(hArr.items[1])?.value ?? 0 : 0;
-    const out = [
-      `${inputFile ?? "empty"}: linearized`,
-      `Linearization dictionary: L=${numVal("L")} H=[${h0} ${h1}] O=${numVal("O")} E=${numVal("E")} N=${numVal("N", baseDoc.getPageCount())} T=${numVal("T")}`,
-      `no linearization errors`
-    ].join("\n") + "\n";
+    const hArr = cos.resolveArray(dictGet8(linDict, "H"));
+    const hint = (index) => {
+      const value = cos.resolve(hArr?.items[index]);
+      return value?.kind === "number" ? value.value : 0;
+    };
+    const h0 = hint(0), h1 = hint(1);
+    if (showLinearization === "check") return { exitCode: 0, stdout: `${inputFile ?? "empty"}: no linearization errors
+`, stderr: "" };
+    const values = { file_size: numVal("L"), first_page_object: numVal("O"), first_page_end: numVal("E"), npages: baseDoc.getPageCount(), xref_zero_offset: numVal("T"), first_page: numVal("P"), H_offset: h0, H_length: h1 };
+    let hintStream;
+    for (const object of cos.objects.values()) if (object.span?.start === h0 && object.value.kind === "stream") {
+      hintStream = object.value;
+      break;
+    }
+    const hintBytes = hintStream ? cos.decodeStream(hintStream) : new Uint8Array();
+    const shared = hintStream && cos.resolve(dictGet8(hintStream.dict, "S")), outline = hintStream && cos.resolve(dictGet8(hintStream.dict, "O"));
+    const report = linearizationReport(inputFile ?? "empty", values, hintBytes.length, shared?.kind === "number" ? shared.value : 0, outline?.kind === "number" ? outline.value : void 0);
+    let out = showLinearization === "both" ? `${inputFile ?? "empty"}: no linearization errors
+` : "", step = report.next();
+    while (!step.done) {
+      yield;
+      if (typeof step.value === "string") {
+        out += step.value;
+        step = report.next(new Uint8Array());
+      } else step = report.next(hintBytes.subarray(step.value.offset, step.value.offset + step.value.length));
+    }
     return { exitCode: 0, stdout: out, stderr: "" };
   }
   if (check) {
@@ -2749,7 +3126,7 @@ function* executeQpdfCli(options, files) {
     let isLin = false;
     for (const obj of cos.objects.values()) {
       const d = asDict(obj.value);
-      if (d && dictGet7(d, "Linearized") !== void 0) {
+      if (d && dictGet8(d, "Linearized") !== void 0) {
         isLin = true;
         break;
       }
@@ -2770,22 +3147,22 @@ errors that qpdf cannot detect
     const pages = baseDoc.getPages();
     const collectImagesFromResources = (resDict, visitedForms = /* @__PURE__ */ new Set()) => {
       if (!resDict) return;
-      const xobjDict = asDict(baseDoc.cos.resolve(dictGet7(resDict, "XObject")));
+      const xobjDict = asDict(baseDoc.cos.resolve(dictGet8(resDict, "XObject")));
       if (!xobjDict) return;
       for (const entry of xobjDict.entries) {
         const ref = asRef(entry.value);
         const resolved = baseDoc.cos.resolve(entry.value);
         const streamDict = resolved?.kind === "stream" ? resolved.dict : asDict(resolved);
-        const subtype = streamDict ? asName(dictGet7(streamDict, "Subtype"))?.decoded : void 0;
+        const subtype = streamDict ? asName(dictGet8(streamDict, "Subtype"))?.decoded : void 0;
         if (subtype === "Image") {
-          const w = asNumber(dictGet7(streamDict, "Width"))?.value ?? 0;
-          const h = asNumber(dictGet7(streamDict, "Height"))?.value ?? 0;
+          const w = asNumber(dictGet8(streamDict, "Width"))?.value ?? 0;
+          const h = asNumber(dictGet8(streamDict, "Height"))?.value ?? 0;
           const refStr = ref ? `${ref.objectNumber} ${ref.generationNumber} R` : "inline";
-          lines.push(`    /${entry.key.decoded}: ${refStr} (${w} x ${h})`);
+          lines.push(`    /${entry.key.decoded}: ${refStr}, ${w} x ${h}`);
         } else if (subtype === "Form" && streamDict) {
           if (ref && visitedForms.has(ref.objectNumber)) continue;
           if (ref) visitedForms.add(ref.objectNumber);
-          const formRes = asDict(baseDoc.cos.resolve(dictGet7(streamDict, "Resources")));
+          const formRes = asDict(baseDoc.cos.resolve(dictGet8(streamDict, "Resources")));
           collectImagesFromResources(formRes, visitedForms);
         }
       }
@@ -2794,11 +3171,12 @@ errors that qpdf cannot detect
       const p = pages[idx];
       lines.push(`page ${idx + 1}: ${p.ref.objectNumber} ${p.ref.generationNumber} R`);
       if (withImages) {
-        lines.push("  images:");
+        const imageStart = lines.length;
         collectImagesFromResources(p.getResourcesDict());
+        if (lines.length > imageStart) lines.splice(imageStart, 0, "  images:");
       }
       lines.push("  content:");
-      const contentsNode = dictGet7(p.dict, "Contents");
+      const contentsNode = dictGet8(p.dict, "Contents");
       if (contentsNode?.kind === "ref") {
         lines.push(`    ${contentsNode.objectNumber} ${contentsNode.generationNumber} R`);
       } else if (contentsNode?.kind === "array") {
@@ -2816,30 +3194,20 @@ errors that qpdf cannot detect
 `, stderr: "" };
   }
   if (showEncryption) {
-    const enc = baseDoc.cos.encryption;
-    if (!enc) {
-      return { exitCode: 0, stdout: "File is not encrypted\n", stderr: "" };
-    }
-    const out = `R = ${enc.revision}
-V = ${enc.version}
-Length = ${enc.keyLengthBits}
-print: ${enc.permissions.print ? "allowed" : "not allowed"}
-modify: ${enc.permissions.modify ? "allowed" : "not allowed"}
-extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
-`;
-    return { exitCode: 0, stdout: out, stderr: "" };
+    return { exitCode: 0, stdout: encryptionReport(baseDoc.cos.encryption), stderr: "" };
   }
   if (showXref) {
     const lines = [];
-    const revEntries = baseDoc.cos.revisions[0]?.entries;
+    const revEntries = new Map(baseDoc.cos.revisions.flatMap((revision) => [...revision.entries]).reverse());
     for (const [objNum, obj] of [...baseDoc.cos.objects.entries()].sort((a, b) => a[0] - b[0])) {
       const xEntry = revEntries?.get(objNum);
       if (xEntry?.type === "compressed") {
         lines.push(
-          `${objNum}/0: compressed; stream = ${xEntry.objectStreamNumber}; index = ${xEntry.indexInObjectStream}; type = ${obj.value.kind}`
+          `${objNum}/0: compressed; stream = ${xEntry.objectStreamNumber}, index = ${xEntry.indexInStream ?? xEntry.indexInObjectStream}`
         );
       } else {
-        lines.push(`${objNum}/${obj.generationNumber}: uncompressed; type = ${obj.value.kind}`);
+        const offset = xEntry?.offset ?? obj.span?.start;
+        lines.push(`${objNum}/${obj.generationNumber}: uncompressed; ${offset === void 0 ? `type = ${obj.value.kind}` : `offset = ${offset}`}`);
       }
     }
     return { exitCode: 0, stdout: lines.join("\n") + "\n", stderr: "" };
@@ -2883,11 +3251,23 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
         stderr: "qpdf: --json-stream-data=file requires --json-stream-prefix or an output file\n"
       };
     }
+    const include = (key) => !jsonKeys.length || jsonKeys.includes(key);
+    const includeObjects = include(jsonVersion === 1 ? "objects" : "qpdf");
+    const objectInfo = {};
     const objectsMap = {};
     const hasSelector = jsonObjectSelectors.length > 0;
     const matchesSelector = (objNum, genNum) => !hasSelector || jsonObjectSelectors.some((s) => s.kind === "obj" && s.objNum === objNum && s.genNum === genNum);
     for (const [objNum, obj] of baseDoc.cos.objects.entries()) {
       if (!matchesSelector(objNum, obj.generationNumber)) continue;
+      if (jsonKeys.includes("objectinfo")) {
+        const dict = obj.value.kind === "stream" ? obj.value.dict : void 0;
+        objectInfo[`${objNum} ${obj.generationNumber} R`] = { stream: {
+          filter: dict ? cosNodeToJson(dictGet8(dict, "Filter") ?? cosNull()) : null,
+          is: Boolean(dict),
+          length: dict ? cosNodeToJson(dictGet8(dict, "Length") ?? cosNull()) : null
+        } };
+      }
+      if (!includeObjects) continue;
       if (obj.value.kind === "stream") {
         const streamObj = {
           dict: cosNodeToJson(obj.value.dict)
@@ -2908,10 +3288,10 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
       }
     }
     if (!hasSelector || jsonObjectSelectors.some((s) => s.kind === "trailer")) {
-      const trailerDict = cosDict5({
+      const trailerDict = cosDict6({
         Root: baseDoc.cos.rootRef,
         ...baseDoc.cos.infoRef ? { Info: baseDoc.cos.infoRef } : {},
-        Size: cosNumber3(baseDoc.cos.maxObjectNumber + 1)
+        Size: cosNumber4(baseDoc.cos.maxObjectNumber + 1)
       });
       objectsMap.trailer = {
         value: cosNodeToJson(trailerDict)
@@ -2919,12 +3299,12 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
     }
     const attachmentsJson = {};
     const rootDictForJson = asDict(baseDoc.cos.resolve(baseDoc.cos.rootRef));
-    for (const att of collectDocumentAttachments(baseDoc)) {
+    for (const att of include("attachments") ? collectDocumentAttachments(baseDoc) : []) {
       attachmentsJson[att.key] = { filename: att.filename };
     }
-    const acroDictJson = rootDictForJson ? asDict(baseDoc.cos.resolve(dictGet7(rootDictForJson, "AcroForm"))) : void 0;
-    const needAppJson = acroDictJson ? baseDoc.cos.resolve(dictGet7(acroDictJson, "NeedAppearances")) : void 0;
-    const acroFieldsJson = baseDoc.getFormFields().map((f) => ({
+    const acroDictJson = rootDictForJson ? asDict(baseDoc.cos.resolve(dictGet8(rootDictForJson, "AcroForm"))) : void 0;
+    const needAppJson = acroDictJson ? baseDoc.cos.resolve(dictGet8(acroDictJson, "NeedAppearances")) : void 0;
+    const acroFieldsJson = (include("acroform") ? baseDoc.getFormFields() : []).map((f) => ({
       name: f.name,
       type: f.type,
       value: f.value
@@ -2935,7 +3315,7 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
       fields: acroFieldsJson
     };
     const outlinesJson = [];
-    const outlinesRootJson = rootDictForJson ? asDict(baseDoc.cos.resolve(dictGet7(rootDictForJson, "Outlines"))) : void 0;
+    const outlinesRootJson = rootDictForJson ? asDict(baseDoc.cos.resolve(dictGet8(rootDictForJson, "Outlines"))) : void 0;
     const collectJsonOutlines = (nodeOrRef, visited = /* @__PURE__ */ new Set()) => {
       let cur = nodeOrRef;
       while (cur) {
@@ -2945,9 +3325,9 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
         }
         const d = asDict(baseDoc.cos.resolve(cur));
         if (!d) break;
-        const tNode = baseDoc.cos.resolve(dictGet7(d, "Title"));
-        const title = tNode?.kind === "string" ? decodePdfString6(tNode) : "";
-        const destPageIdx = resolveDestinationPageIndex(baseDoc, dictGet7(d, "Dest") ?? dictGet7(d, "A")) ?? 0;
+        const tNode = baseDoc.cos.resolve(dictGet8(d, "Title"));
+        const title = tNode?.kind === "string" ? decodePdfString7(tNode) : "";
+        const destPageIdx = resolveDestinationPageIndex(baseDoc, dictGet8(d, "Dest") ?? dictGet8(d, "A")) ?? 0;
         const pageRef = baseDoc.getPageCount() > 0 ? baseDoc.getPage(destPageIdx).ref : { objectNumber: 0, generationNumber: 0 };
         if (title) {
           outlinesJson.push({
@@ -2956,29 +3336,46 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
             destpageobject: `obj:${pageRef.objectNumber} ${pageRef.generationNumber} R`
           });
         }
-        const firstChild = dictGet7(d, "First");
+        const firstChild = dictGet8(d, "First");
         if (firstChild) collectJsonOutlines(firstChild, visited);
-        cur = dictGet7(d, "Next");
+        cur = dictGet8(d, "Next");
       }
     };
-    if (outlinesRootJson) collectJsonOutlines(dictGet7(outlinesRootJson, "First"));
+    if (include("outlines") && outlinesRootJson) collectJsonOutlines(dictGet8(outlinesRootJson, "First"));
     const pagelabelsJson = [];
-    const plTreeJson = rootDictForJson ? asDict(baseDoc.cos.resolve(dictGet7(rootDictForJson, "PageLabels"))) : void 0;
-    for (const { index: plIdx, dict: vDict } of collectNumberTreeDicts(baseDoc, plTreeJson)) {
-      const stNode = baseDoc.cos.resolve(dictGet7(vDict, "St"));
-      const pNode = baseDoc.cos.resolve(dictGet7(vDict, "P"));
-      const sNode = baseDoc.cos.resolve(dictGet7(vDict, "S"));
+    const plTreeJson = rootDictForJson ? asDict(baseDoc.cos.resolve(dictGet8(rootDictForJson, "PageLabels"))) : void 0;
+    for (const { index: plIdx, dict: vDict } of include("pagelabels") ? collectNumberTreeDicts(baseDoc, plTreeJson) : []) {
+      const stNode = baseDoc.cos.resolve(dictGet8(vDict, "St"));
+      const pNode = baseDoc.cos.resolve(dictGet8(vDict, "P"));
+      const sNode = baseDoc.cos.resolve(dictGet8(vDict, "S"));
       pagelabelsJson.push({
         index: plIdx,
         start: stNode?.kind === "number" ? stNode.value : 1,
-        ...pNode?.kind === "string" ? { prefix: decodePdfString6(pNode) } : {},
+        ...pNode?.kind === "string" ? { prefix: decodePdfString7(pNode) } : {},
         ...sNode?.kind === "name" ? { style: sNode.decoded } : {}
       });
     }
-    const pagesVal = jsonKeys.includes("pages") ? baseDoc.getPages().map((pg, idx) => ({
-      object: `obj:${pg.ref.objectNumber} ${pg.ref.generationNumber} R`,
-      pageposfrom1: idx + 1
-    })) : baseDoc.getPageCount();
+    let pagesVal = baseDoc.getPageCount();
+    if (jsonKeys.includes("pages")) {
+      const values = [];
+      for (const [index, page] of baseDoc.getPages().entries()) {
+        let materialize2 = function(value) {
+          if (value === null || typeof value !== "object") return value;
+          if (value.kind === "array") return Array.from(value.values, materialize2);
+          if (value.kind === "object") return Object.fromEntries(Array.from(value.entries, ([key, item]) => [key, materialize2(item)]));
+          throw new Error("Unexpected page JSON value");
+        };
+        var materialize = materialize2;
+        const steps = qpdfJsonPage(page.dict, page.ref, index, rootDictForJson, jsonVersion);
+        let step = steps.next();
+        while (!step.done) {
+          yield;
+          step = steps.next(baseDoc.cos.resolve(step.value));
+        }
+        values.push(materialize2(step.value));
+      }
+      pagesVal = values;
+    }
     const payload = jsonVersion === 1 ? {
       version: 1,
       pdfversion: baseDoc.cos.version,
@@ -3005,7 +3402,20 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
         objectsMap
       ]
     };
-    const jsonOut = JSON.stringify(payload, null, 2) + "\n";
+    const sections = {
+      pages: pagesVal,
+      pagelabels: pagelabelsJson,
+      outlines: outlinesJson,
+      acroform: acroformSection,
+      encrypt: { encrypted: Boolean(baseDoc.cos.encryption) },
+      attachments: attachmentsJson,
+      objects: objectsMap,
+      objectinfo: objectInfo,
+      qpdf: [{ jsonversion: 2, pdfversion: baseDoc.cos.version, maxobjectid: baseDoc.cos.maxObjectNumber }, objectsMap]
+    };
+    const selectedPayload = { version: jsonVersion, parameters: { decodelevel: "generalized" } };
+    for (const key of jsonKeys) selectedPayload[key] = sections[key];
+    const jsonOut = JSON.stringify(jsonKeys.length ? selectedPayload : payload, null, 2) + "\n";
     if (outputFile && outputFile !== "-") {
       files.set(outputFile, new TextEncoder().encode(jsonOut));
       return { exitCode: 0, stdout: "", stderr: "" };
@@ -3132,17 +3542,17 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
         const targetRes = targetPage.getResourcesDict();
         const srcRes = srcStampPage.getResourcesDict();
         for (const catKey of ["Font", "XObject", "ExtGState", "ColorSpace", "Pattern", "Shading", "Properties"]) {
-          const srcSub = asDict(stampDoc.cos.resolve(dictGet7(srcRes, catKey)));
+          const srcSub = asDict(stampDoc.cos.resolve(dictGet8(srcRes, catKey)));
           if (!srcSub) continue;
-          let dstSub = asDict(workingDoc.cos.resolve(dictGet7(targetRes, catKey)));
+          let dstSub = asDict(workingDoc.cos.resolve(dictGet8(targetRes, catKey)));
           if (!dstSub) {
-            dstSub = cosDict5({});
+            dstSub = cosDict6({});
             dictSet(targetRes, catKey, dstSub);
           }
           for (const entry of srcSub.entries) {
             const origKey = entry.key.decoded;
             let finalKey = origKey;
-            if (dictGet7(dstSub, origKey)) {
+            if (dictGet8(dstSub, origKey)) {
               finalKey = `QStp${stampResCounter++}_${origKey}`;
               stampStreamStr = replacePdfNameToken(stampStreamStr, origKey, finalKey);
             }
@@ -3150,43 +3560,10 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
           }
         }
         const stampStream = iso88591ToBytes(stampStreamStr);
-        const dstSize = targetPage.getSize();
-        const srcSize = srcStampPage.getSize();
-        const rotDiff = ((targetPage.getRotation() - srcStampPage.getRotation()) % 360 + 360) % 360;
-        let stampOpenStr = "q\n";
-        if (srcSize.width > 0 && srcSize.height > 0) {
-          const fmt6 = (n) => Number(n.toFixed(6));
-          const fmt4 = (n) => Number(n.toFixed(4));
-          if (rotDiff === 90) {
-            const s = Math.min(dstSize.height / srcSize.width, dstSize.width / srcSize.height);
-            const ox = (dstSize.height - srcSize.width * s) / 2;
-            const oy = (dstSize.width - srcSize.height * s) / 2;
-            stampOpenStr = `q
-0 ${fmt6(s)} ${fmt6(-s)} 0 ${fmt4(dstSize.width - oy)} ${fmt4(ox)} cm
-`;
-          } else if (rotDiff === 180) {
-            const s = Math.min(dstSize.width / srcSize.width, dstSize.height / srcSize.height);
-            const ox = (dstSize.width - srcSize.width * s) / 2;
-            const oy = (dstSize.height - srcSize.height * s) / 2;
-            stampOpenStr = `q
-${fmt6(-s)} 0 0 ${fmt6(-s)} ${fmt4(dstSize.width - ox)} ${fmt4(dstSize.height - oy)} cm
-`;
-          } else if (rotDiff === 270) {
-            const s = Math.min(dstSize.height / srcSize.width, dstSize.width / srcSize.height);
-            const ox = (dstSize.height - srcSize.width * s) / 2;
-            const oy = (dstSize.width - srcSize.height * s) / 2;
-            stampOpenStr = `q
-0 ${fmt6(-s)} ${fmt6(s)} 0 ${fmt4(oy)} ${fmt4(dstSize.height - ox)} cm
-`;
-          } else if (Math.abs(srcSize.width - dstSize.width) > 0.5 || Math.abs(srcSize.height - dstSize.height) > 0.5) {
-            const s = Math.min(dstSize.width / srcSize.width, dstSize.height / srcSize.height);
-            const tx = (dstSize.width - srcSize.width * s) / 2;
-            const ty = (dstSize.height - srcSize.height * s) / 2;
-            stampOpenStr = `q
-${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
-`;
-          }
-        }
+        const stampOpenStr = retainedStampTransform(
+          { mediaBox: targetPage.getMediaBox(), rotation: targetPage.getRotation() },
+          { mediaBox: srcStampPage.getMediaBox(), rotation: srcStampPage.getRotation() }
+        );
         const qOpenTarget = enc.encode("q\n");
         const qOpenStamp = enc.encode(stampOpenStr);
         const qClose = enc.encode("\nQ\n");
@@ -3235,10 +3612,10 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
           const [p0x, p0y] = mapPt(nums[0], nums[1]);
           const [p1x, p1y] = mapPt(nums[2], nums[3]);
           return cosArray3([
-            cosNumber3(Math.min(p0x, p1x)),
-            cosNumber3(Math.min(p0y, p1y)),
-            cosNumber3(Math.max(p0x, p1x)),
-            cosNumber3(Math.max(p0y, p1y))
+            cosNumber4(Math.min(p0x, p1x)),
+            cosNumber4(Math.min(p0y, p1y)),
+            cosNumber4(Math.max(p0x, p1x)),
+            cosNumber4(Math.max(p0y, p1y))
           ]);
         };
         let cmCmd = "";
@@ -3246,7 +3623,7 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
           cmCmd = `q
 0 -1 1 0 0 ${W} cm
 `;
-          dictSet(page.dict, "MediaBox", cosArray3([cosNumber3(0), cosNumber3(0), cosNumber3(H), cosNumber3(W)]));
+          dictSet(page.dict, "MediaBox", cosArray3([cosNumber4(0), cosNumber4(0), cosNumber4(H), cosNumber4(W)]));
         } else if (rot === 180) {
           cmCmd = `q
 -1 0 0 -1 ${W} ${H} cm
@@ -3255,18 +3632,18 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
           cmCmd = `q
 0 1 -1 0 ${H} 0 cm
 `;
-          dictSet(page.dict, "MediaBox", cosArray3([cosNumber3(0), cosNumber3(0), cosNumber3(H), cosNumber3(W)]));
+          dictSet(page.dict, "MediaBox", cosArray3([cosNumber4(0), cosNumber4(0), cosNumber4(H), cosNumber4(W)]));
         }
         for (const boxKey of ["CropBox", "BleedBox", "TrimBox", "ArtBox"]) {
-          const mapped = mapRectNode(dictGet7(page.dict, boxKey));
+          const mapped = mapRectNode(dictGet8(page.dict, boxKey));
           if (mapped) dictSet(page.dict, boxKey, mapped);
         }
-        const annotsArr = asArray(workingDoc.cos.resolve(dictGet7(page.dict, "Annots")));
+        const annotsArr = asArray(workingDoc.cos.resolve(dictGet8(page.dict, "Annots")));
         if (annotsArr) {
           for (const item of annotsArr.items) {
             const aDict = asDict(workingDoc.cos.resolve(item));
             if (!aDict) continue;
-            const mappedRect = mapRectNode(dictGet7(aDict, "Rect"));
+            const mappedRect = mapRectNode(dictGet8(aDict, "Rect"));
             if (mappedRect) dictSet(aDict, "Rect", mappedRect);
           }
         }
@@ -3286,19 +3663,19 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
     const enc = new TextEncoder();
     for (const page of workingDoc.getPages()) {
       yield;
-      const annotsNode = workingDoc.cos.resolve(dictGet7(page.dict, "Annots"));
+      const annotsNode = workingDoc.cos.resolve(dictGet8(page.dict, "Annots"));
       const annotsArr = asArray(annotsNode);
       if (!annotsArr) continue;
       const survivingAnnots = [];
       for (const item of annotsArr.items) {
         const annotDict = asDict(workingDoc.cos.resolve(item));
         if (!annotDict) continue;
-        const subtype = asName(dictGet7(annotDict, "Subtype"))?.decoded;
+        const subtype = asName(dictGet8(annotDict, "Subtype"))?.decoded;
         if (subtype === "Link" || subtype === "Popup") {
           survivingAnnots.push(item);
           continue;
         }
-        const flagsNode = asNumber(workingDoc.cos.resolve(dictGet7(annotDict, "F")));
+        const flagsNode = asNumber(workingDoc.cos.resolve(dictGet8(annotDict, "F")));
         if (flagsNode !== void 0) {
           const flags = flagsNode.value;
           const isInvisibleOrHidden = (flags & 1) !== 0 || (flags & 2) !== 0;
@@ -3310,26 +3687,26 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
             continue;
           }
         }
-        const rectArr = asArray(workingDoc.cos.resolve(dictGet7(annotDict, "Rect")));
+        const rectArr = asArray(workingDoc.cos.resolve(dictGet8(annotDict, "Rect")));
         const rx0 = asNumber(workingDoc.cos.resolve(rectArr?.items[0]))?.value ?? 72;
         const ry0 = asNumber(workingDoc.cos.resolve(rectArr?.items[1]))?.value ?? 72;
         const rx1 = asNumber(workingDoc.cos.resolve(rectArr?.items[2]))?.value ?? rx0 + 50;
         const ry1 = asNumber(workingDoc.cos.resolve(rectArr?.items[3]))?.value ?? ry0 + 20;
-        const apDict = asDict(workingDoc.cos.resolve(dictGet7(annotDict, "AP")));
-        let apStreamNode = apDict ? workingDoc.cos.resolve(dictGet7(apDict, "N")) : void 0;
+        const apDict = asDict(workingDoc.cos.resolve(dictGet8(annotDict, "AP")));
+        let apStreamNode = apDict ? workingDoc.cos.resolve(dictGet8(apDict, "N")) : void 0;
         if (apStreamNode?.kind === "dict") {
-          const asState = asName(workingDoc.cos.resolve(dictGet7(annotDict, "AS")))?.decoded;
-          apStreamNode = (asState ? workingDoc.cos.resolve(dictGet7(apStreamNode, asState)) : void 0) ?? workingDoc.cos.resolve(apStreamNode.entries[0]?.value);
+          const asState = asName(workingDoc.cos.resolve(dictGet8(annotDict, "AS")))?.decoded;
+          apStreamNode = (asState ? workingDoc.cos.resolve(dictGet8(apStreamNode, asState)) : void 0) ?? workingDoc.cos.resolve(apStreamNode.entries[0]?.value);
         }
         if (apStreamNode?.kind === "stream") {
           let apBytes = workingDoc.cos.decodeStream(apStreamNode);
           if (apBytes.byteLength > 0) {
-            const bboxArr = asArray(workingDoc.cos.resolve(dictGet7(apStreamNode.dict, "BBox")));
+            const bboxArr = asArray(workingDoc.cos.resolve(dictGet8(apStreamNode.dict, "BBox")));
             const bx0 = asNumber(workingDoc.cos.resolve(bboxArr?.items[0]))?.value ?? 0;
             const by0 = asNumber(workingDoc.cos.resolve(bboxArr?.items[1]))?.value ?? 0;
             const bx1 = asNumber(workingDoc.cos.resolve(bboxArr?.items[2]))?.value ?? Math.max(1, rx1 - rx0);
             const by1 = asNumber(workingDoc.cos.resolve(bboxArr?.items[3]))?.value ?? Math.max(1, ry1 - ry0);
-            const matArr = asArray(workingDoc.cos.resolve(dictGet7(apStreamNode.dict, "Matrix")));
+            const matArr = asArray(workingDoc.cos.resolve(dictGet8(apStreamNode.dict, "Matrix")));
             let ma = 1, mb = 0, mc = 0, md = 1, me = 0, mf = 0;
             let hasFormMatrix = false;
             if (matArr && matArr.items.length >= 6) {
@@ -3358,27 +3735,27 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
             const scaleY = (ry1 - ry0) / bh;
             const tx = rx0 - tbx0 * scaleX;
             const ty = ry0 - tby0 * scaleY;
-            const apRes = asDict(workingDoc.cos.resolve(dictGet7(apStreamNode.dict, "Resources")));
+            const apRes = asDict(workingDoc.cos.resolve(dictGet8(apStreamNode.dict, "Resources")));
             const resRenames = /* @__PURE__ */ new Map();
             if (apRes) {
               const pageRes = page.getResourcesDict();
               for (const catKey of ["Font", "XObject", "ExtGState", "ColorSpace", "Pattern", "Shading", "Properties"]) {
-                const srcSub = asDict(workingDoc.cos.resolve(dictGet7(apRes, catKey)));
+                const srcSub = asDict(workingDoc.cos.resolve(dictGet8(apRes, catKey)));
                 if (!srcSub) continue;
-                let dstSub = asDict(workingDoc.cos.resolve(dictGet7(pageRes, catKey)));
+                let dstSub = asDict(workingDoc.cos.resolve(dictGet8(pageRes, catKey)));
                 if (!dstSub) {
-                  dstSub = cosDict5({});
+                  dstSub = cosDict6({});
                   dictSet(pageRes, catKey, dstSub);
                 }
                 for (const entry of srcSub.entries) {
                   const origName = entry.key.decoded;
-                  const existingEntry = dictGet7(dstSub, origName);
+                  const existingEntry = dictGet8(dstSub, origName);
                   if (!existingEntry) {
                     dictSet(dstSub, origName, entry.value);
                   } else if (existingEntry.kind === "ref" && entry.value.kind === "ref" && existingEntry.objectNumber === entry.value.objectNumber) {
                   } else {
                     let suffix2 = 1;
-                    while (dictGet7(dstSub, `${origName}_qap${suffix2}`)) suffix2++;
+                    while (dictGet8(dstSub, `${origName}_qap${suffix2}`)) suffix2++;
                     const newName = `${origName}_qap${suffix2}`;
                     dictSet(dstSub, newName, entry.value);
                     resRenames.set(origName, newName);
@@ -3410,14 +3787,14 @@ Q
             continue;
           }
         }
-        const contentsNode = dictGet7(annotDict, "Contents");
-        let text = contentsNode?.kind === "string" ? decodePdfString6(contentsNode).trim() : "";
+        const contentsNode = dictGet8(annotDict, "Contents");
+        let text = contentsNode?.kind === "string" ? decodePdfString7(contentsNode).trim() : "";
         if (!text) {
-          const parentDict = asDict(workingDoc.cos.resolve(dictGet7(annotDict, "Parent")));
-          const vNode = workingDoc.cos.resolve(dictGet7(annotDict, "V")) ?? (parentDict ? workingDoc.cos.resolve(dictGet7(parentDict, "V")) : void 0);
-          const asStateNode = workingDoc.cos.resolve(dictGet7(annotDict, "AS"));
+          const parentDict = asDict(workingDoc.cos.resolve(dictGet8(annotDict, "Parent")));
+          const vNode = workingDoc.cos.resolve(dictGet8(annotDict, "V")) ?? (parentDict ? workingDoc.cos.resolve(dictGet8(parentDict, "V")) : void 0);
+          const asStateNode = workingDoc.cos.resolve(dictGet8(annotDict, "AS"));
           if (vNode?.kind === "string") {
-            text = decodePdfString6(vNode).trim();
+            text = decodePdfString7(vNode).trim();
           } else if (vNode?.kind === "name" && vNode.decoded !== "Off") {
             text = vNode.decoded;
           } else if (asStateNode?.kind === "name" && asStateNode.decoded !== "Off") {
@@ -3467,7 +3844,7 @@ Q
       yield;
       let modified = false;
       const pageRes = page.getResourcesDict();
-      let xobjSub = asDict(workingDoc.cos.resolve(dictGet7(pageRes, "XObject")));
+      let xobjSub = asDict(workingDoc.cos.resolve(dictGet8(pageRes, "XObject")));
       const transformNodes = (nodes) => {
         const out = [];
         for (const node of nodes) {
@@ -3477,14 +3854,14 @@ Q
             out.push({ ...node, children: transformNodes(node.children) });
           } else if (node.kind === "inline-image" && node.data.byteLength >= iiMinBytes) {
             if (!xobjSub) {
-              xobjSub = cosDict5({});
+              xobjSub = cosDict6({});
               dictSet(pageRes, "XObject", xobjSub);
             }
             let resName = `ImExt${extCounter++}`;
-            while (dictGet7(xobjSub, resName)) {
+            while (dictGet8(xobjSub, resName)) {
               resName = `ImExt${extCounter++}`;
             }
-            const imgDict = cosDict5({
+            const imgDict = cosDict6({
               Type: cosName2("XObject"),
               Subtype: cosName2("Image")
             });
@@ -3553,12 +3930,12 @@ Q
       yield;
       const refNames = /* @__PURE__ */ new Set();
       collectPdfNamesFromBytes(page.getRawContentStream(), refNames);
-      const annotsArr = asArray(workingDoc.cos.resolve(dictGet7(page.dict, "Annots")));
+      const annotsArr = asArray(workingDoc.cos.resolve(dictGet8(page.dict, "Annots")));
       if (annotsArr) {
         for (const item of annotsArr.items) {
           const aDict = asDict(workingDoc.cos.resolve(item));
-          const apDict = aDict ? asDict(workingDoc.cos.resolve(dictGet7(aDict, "AP"))) : void 0;
-          const apN = apDict ? workingDoc.cos.resolve(dictGet7(apDict, "N")) : void 0;
+          const apDict = aDict ? asDict(workingDoc.cos.resolve(dictGet8(aDict, "AP"))) : void 0;
+          const apN = apDict ? workingDoc.cos.resolve(dictGet8(apDict, "N")) : void 0;
           if (apN?.kind === "stream") {
             collectPdfNamesFromBytes(workingDoc.cos.decodeStream(apN), refNames);
           }
@@ -3570,7 +3947,7 @@ Q
       while (changed) {
         changed = false;
         for (const catKey of ["XObject", "Pattern"]) {
-          const sub = asDict(workingDoc.cos.resolve(dictGet7(pageRes, catKey)));
+          const sub = asDict(workingDoc.cos.resolve(dictGet8(pageRes, catKey)));
           if (!sub) continue;
           for (const entry of sub.entries) {
             const visitId = `${catKey}:${entry.key.decoded}`;
@@ -3587,7 +3964,7 @@ Q
         }
       }
       for (const catKey of resourceCategories) {
-        const sub = asDict(workingDoc.cos.resolve(dictGet7(pageRes, catKey)));
+        const sub = asDict(workingDoc.cos.resolve(dictGet8(pageRes, catKey)));
         if (!sub) continue;
         for (const entry of [...sub.entries]) {
           if (!refNames.has(entry.key.decoded)) {
@@ -3601,33 +3978,40 @@ Q
     }
   }
   if (linearize) {
-    const linDict = cosDict5({
-      Linearized: cosNumber3(1),
-      N: cosNumber3(workingDoc.getPageCount())
+    const linDict = cosDict6({
+      Linearized: cosNumber4(1),
+      N: cosNumber4(workingDoc.getPageCount())
     });
     workingDoc.cos.allocateObject(linDict);
   }
-  if (removePageLabels || pageLabelSpecs.length > 0) {
+  let pageLabels;
+  try {
+    pageLabels = parseQpdfPageLabels(pageLabelSpecs, workingDoc.getPageCount());
+  } catch (error) {
+    return { exitCode: 2, stdout: "", stderr: `qpdf: ${error.message}
+` };
+  }
+  if (removePageLabels || pageLabels.length > 0) {
     const rootDict = asDict(workingDoc.cos.resolve(workingDoc.cos.rootRef));
     if (rootDict) {
-      if (removePageLabels && pageLabelSpecs.length === 0) {
+      if (removePageLabels && pageLabels.length === 0) {
         dictDelete(rootDict, "PageLabels");
-      } else if (pageLabelSpecs.length > 0) {
+      } else if (pageLabels.length > 0) {
         const numsItems = [];
-        for (const { index, style, start, prefix } of parseQpdfPageLabels(pageLabelSpecs)) {
-          const labelDict = cosDict5({});
+        for (const { index, style, start, prefix } of pageLabels) {
+          const labelDict = cosDict6({});
           if (style !== void 0) {
             dictSet(labelDict, "S", cosName2(style));
           }
           if (start !== void 0 && start !== 1) {
-            dictSet(labelDict, "St", cosNumber3(start));
+            dictSet(labelDict, "St", cosNumber4(start));
           }
           if (prefix) {
             dictSet(labelDict, "P", cosString3(prefix));
           }
-          numsItems.push(cosNumber3(index), labelDict);
+          numsItems.push(cosNumber4(index), labelDict);
         }
-        dictSet(rootDict, "PageLabels", workingDoc.cos.allocateObject(cosDict5({ Nums: cosArray3(numsItems) })));
+        dictSet(rootDict, "PageLabels", workingDoc.cos.allocateObject(cosDict6({ Nums: cosArray3(numsItems) })));
       }
     }
   }
@@ -3640,7 +4024,7 @@ Q
       if (rootDict) dictDelete(rootDict, "Metadata");
       const infoDict = workingDoc.cos.infoRef ? asDict(workingDoc.cos.resolve(workingDoc.cos.infoRef)) : void 0;
       if (infoDict) {
-        const modDate = dictGet7(infoDict, "ModDate");
+        const modDate = dictGet8(infoDict, "ModDate");
         infoDict.entries.length = 0;
         if (modDate) {
           dictSet(infoDict, "ModDate", modDate);
@@ -3669,14 +4053,14 @@ Q
     }
     const srcDoc = yield* PdfDocument.loadSteps(srcBytes, copySpec.password ? { password: copySpec.password } : {});
     const srcRoot = asDict(srcDoc.cos.resolve(srcDoc.cos.rootRef));
-    const srcNames = srcRoot ? asDict(srcDoc.cos.resolve(dictGet7(srcRoot, "Names"))) : void 0;
-    const srcEf = srcNames ? asDict(srcDoc.cos.resolve(dictGet7(srcNames, "EmbeddedFiles"))) : void 0;
+    const srcNames = srcRoot ? asDict(srcDoc.cos.resolve(dictGet8(srcRoot, "Names"))) : void 0;
+    const srcEf = srcNames ? asDict(srcDoc.cos.resolve(dictGet8(srcNames, "EmbeddedFiles"))) : void 0;
     const flatPairs = [];
     const collectSrcEf = (nodeDict, visited = /* @__PURE__ */ new Set()) => {
       if (!nodeDict) return;
-      const nArr = asArray(srcDoc.cos.resolve(dictGet7(nodeDict, "Names")));
+      const nArr = asArray(srcDoc.cos.resolve(dictGet8(nodeDict, "Names")));
       if (nArr) flatPairs.push(...nArr.items);
-      const kArr = asArray(srcDoc.cos.resolve(dictGet7(nodeDict, "Kids")));
+      const kArr = asArray(srcDoc.cos.resolve(dictGet8(nodeDict, "Kids")));
       if (kArr) {
         for (const kid of kArr.items) {
           if (kid.kind === "ref") {
@@ -3692,56 +4076,56 @@ Q
     if (srcNamesArr) {
       for (let idx = 0; idx + 1 < srcNamesArr.items.length; idx += 2) {
         const kNode = srcDoc.cos.resolve(srcNamesArr.items[idx]);
-        const origKey = kNode?.kind === "string" ? decodePdfString6(kNode) : `att_${idx}`;
+        const origKey = kNode?.kind === "string" ? decodePdfString7(kNode) : `att_${idx}`;
         const fsDict = asDict(srcDoc.cos.resolve(srcNamesArr.items[idx + 1]));
         if (!fsDict) continue;
-        const ufNode = srcDoc.cos.resolve(dictGet7(fsDict, "UF") ?? dictGet7(fsDict, "F"));
-        const fnStr = ufNode?.kind === "string" ? decodePdfString6(ufNode) : origKey;
-        const efDict = asDict(srcDoc.cos.resolve(dictGet7(fsDict, "EF")));
+        const ufNode = srcDoc.cos.resolve(dictGet8(fsDict, "UF") ?? dictGet8(fsDict, "F"));
+        const fnStr = ufNode?.kind === "string" ? decodePdfString7(ufNode) : origKey;
+        const efDict = asDict(srcDoc.cos.resolve(dictGet8(fsDict, "EF")));
         const stNode = efDict ? srcDoc.cos.resolve(
-          dictGet7(efDict, "UF") ?? dictGet7(efDict, "F") ?? dictGet7(efDict, "DOS") ?? dictGet7(efDict, "Mac") ?? dictGet7(efDict, "Unix")
+          dictGet8(efDict, "UF") ?? dictGet8(efDict, "F") ?? dictGet8(efDict, "DOS") ?? dictGet8(efDict, "Mac") ?? dictGet8(efDict, "Unix")
         ) : void 0;
         if (stNode?.kind === "stream") {
           const data = srcDoc.cos.decodeStream(stNode);
           const newKey = `${copySpec.prefix}${origKey}`;
           const rootDict = asDict(workingDoc.cos.resolve(workingDoc.cos.rootRef));
           if (rootDict) {
-            let namesDict = asDict(workingDoc.cos.resolve(dictGet7(rootDict, "Names")));
+            let namesDict = asDict(workingDoc.cos.resolve(dictGet8(rootDict, "Names")));
             if (!namesDict) {
-              namesDict = cosDict5({});
+              namesDict = cosDict6({});
               dictSet(rootDict, "Names", workingDoc.cos.allocateObject(namesDict));
             }
-            let efTree = asDict(workingDoc.cos.resolve(dictGet7(namesDict, "EmbeddedFiles")));
+            let efTree = asDict(workingDoc.cos.resolve(dictGet8(namesDict, "EmbeddedFiles")));
             if (!efTree) {
-              efTree = cosDict5({ Names: cosArray3([]) });
+              efTree = cosDict6({ Names: cosArray3([]) });
               dictSet(namesDict, "EmbeddedFiles", workingDoc.cos.allocateObject(efTree));
             }
-            let namesArr = asArray(workingDoc.cos.resolve(dictGet7(efTree, "Names")));
+            let namesArr = asArray(workingDoc.cos.resolve(dictGet8(efTree, "Names")));
             if (!namesArr) {
               namesArr = cosArray3([]);
               dictSet(efTree, "Names", namesArr);
             }
             for (let j = 0; j + 1 < namesArr.items.length; j += 2) {
               const exNode = workingDoc.cos.resolve(namesArr.items[j]);
-              if (exNode?.kind === "string" && decodePdfString6(exNode) === newKey) {
+              if (exNode?.kind === "string" && decodePdfString7(exNode) === newKey) {
                 return { exitCode: 2, stdout: "", stderr: `qpdf: duplicate attachment key ${newKey}
 ` };
               }
             }
             const efStreamRef = workingDoc.cos.allocateObject(
               cosStream(data, {
-                dict: cosDict5({
+                dict: cosDict6({
                   Type: cosName2("EmbeddedFile"),
-                  Params: cosDict5({ Size: cosNumber3(data.byteLength) })
+                  Params: cosDict6({ Size: cosNumber4(data.byteLength) })
                 })
               })
             );
             const fsRef = workingDoc.cos.allocateObject(
-              cosDict5({
+              cosDict6({
                 Type: cosName2("Filespec"),
                 F: cosString3(fnStr),
                 UF: cosString3(fnStr),
-                EF: cosDict5({ F: efStreamRef, UF: efStreamRef })
+                EF: cosDict6({ F: efStreamRef, UF: efStreamRef })
               })
             );
             namesArr.items.push(cosString3(newKey), fsRef);
@@ -3753,22 +4137,22 @@ Q
   if (removeAttachmentKeys.length > 0 || addAttachmentSpecs.length > 0) {
     const rootDict = asDict(workingDoc.cos.resolve(workingDoc.cos.rootRef));
     if (rootDict) {
-      let namesDict = asDict(workingDoc.cos.resolve(dictGet7(rootDict, "Names")));
+      let namesDict = asDict(workingDoc.cos.resolve(dictGet8(rootDict, "Names")));
       if (!namesDict) {
-        namesDict = cosDict5({});
+        namesDict = cosDict6({});
         dictSet(rootDict, "Names", workingDoc.cos.allocateObject(namesDict));
       }
-      let efTree = asDict(workingDoc.cos.resolve(dictGet7(namesDict, "EmbeddedFiles")));
+      let efTree = asDict(workingDoc.cos.resolve(dictGet8(namesDict, "EmbeddedFiles")));
       if (!efTree) {
-        efTree = cosDict5({ Names: cosArray3([]) });
+        efTree = cosDict6({ Names: cosArray3([]) });
         dictSet(namesDict, "EmbeddedFiles", workingDoc.cos.allocateObject(efTree));
       }
       const flattenedEfPairs = [];
       const flattenEfTree = (nodeDict, visited = /* @__PURE__ */ new Set()) => {
         if (!nodeDict) return;
-        const nArr = asArray(workingDoc.cos.resolve(dictGet7(nodeDict, "Names")));
+        const nArr = asArray(workingDoc.cos.resolve(dictGet8(nodeDict, "Names")));
         if (nArr) flattenedEfPairs.push(...nArr.items);
-        const kArr = asArray(workingDoc.cos.resolve(dictGet7(nodeDict, "Kids")));
+        const kArr = asArray(workingDoc.cos.resolve(dictGet8(nodeDict, "Kids")));
         if (kArr) {
           for (const kid of kArr.items) {
             if (kid.kind === "ref") {
@@ -3784,17 +4168,20 @@ Q
       let namesArr = cosArray3(flattenedEfPairs);
       dictSet(efTree, "Names", namesArr);
       if (removeAttachmentKeys.length > 0) {
-        const remSet = new Set(removeAttachmentKeys);
+        const remSet = new Set(removeAttachmentKeys), missing = new Set(removeAttachmentKeys);
         const kept = [];
         for (let k = 0; k + 1 < namesArr.items.length; k += 2) {
           const keyNode = workingDoc.cos.resolve(namesArr.items[k]);
-          const keyStr = keyNode?.kind === "string" ? decodePdfString6(keyNode) : "";
+          const keyStr = keyNode?.kind === "string" ? decodePdfString7(keyNode) : "";
+          missing.delete(keyStr);
           if (!remSet.has(keyStr)) {
             kept.push(namesArr.items[k], namesArr.items[k + 1]);
           }
         }
+        if (missing.size) return { exitCode: 2, stdout: "", stderr: `qpdf: attachment ${missing.values().next().value} not found
+` };
         dictSet(efTree, "Names", cosArray3(kept));
-        namesArr = asArray(dictGet7(efTree, "Names"));
+        namesArr = asArray(dictGet8(efTree, "Names"));
       }
       for (const addSpec of addAttachmentSpecs) {
         yield;
@@ -3806,7 +4193,7 @@ Q
         let existingIdx = -1;
         for (let idx = 0; idx + 1 < namesArr.items.length; idx += 2) {
           const kNode = workingDoc.cos.resolve(namesArr.items[idx]);
-          if (kNode?.kind === "string" && decodePdfString6(kNode) === addSpec.key) {
+          if (kNode?.kind === "string" && decodePdfString7(kNode) === addSpec.key) {
             existingIdx = idx;
             break;
           }
@@ -3817,17 +4204,17 @@ Q
         }
         const efStreamRef = workingDoc.cos.allocateObject(
           cosStream(attBytes, {
-            dict: cosDict5({
+            dict: cosDict6({
               Type: cosName2("EmbeddedFile"),
-              Params: cosDict5({ Size: cosNumber3(attBytes.byteLength) })
+              Params: cosDict6({ Size: cosNumber4(attBytes.byteLength) })
             })
           })
         );
-        const fsDict = cosDict5({
+        const fsDict = cosDict6({
           Type: cosName2("Filespec"),
           F: cosString3(addSpec.filename),
           UF: cosString3(addSpec.filename),
-          EF: cosDict5({ F: efStreamRef, UF: efStreamRef })
+          EF: cosDict6({ F: efStreamRef, UF: efStreamRef })
         });
         if (addSpec.description) {
           dictSet(fsDict, "Desc", cosString3(addSpec.description));
@@ -3878,16 +4265,7 @@ Q
   });
   if (encryptConfig && !decrypt) {
     const parsedOut = yield* parseCosDocumentSteps(outBytes);
-    outBytes = yield* encryptCosDocumentSteps(parsedOut, {
-      userPassword: encryptConfig.userPassword,
-      ownerPassword: encryptConfig.ownerPassword,
-      permissions: {
-        print: encryptConfig.print,
-        modify: encryptConfig.modify,
-        copy: encryptConfig.copy,
-        addNotes: encryptConfig.addNotes
-      }
-    });
+    outBytes = yield* encryptCosDocumentSteps(parsedOut, encryptConfig);
   } else if (decrypt && workingDoc.cos.encryption) {
     workingDoc.cos.encryptRef = void 0;
     workingDoc.cos.encryption = void 0;
@@ -3932,7 +4310,7 @@ async function qpdf(context, options = {}) {
       const path = token.slice(1);
       let source;
       try {
-        source = await PdfFileSource3.open(context.fs, resolvePath2(context.cwd, path), { signal: invocation.signal, chunkBytes: 16384 });
+        source = await PdfFileSource4.open(context.fs, resolvePath2(context.cwd, path), { signal: invocation.signal, chunkBytes: 16384 });
       } catch {
         invocation.signal.throwIfAborted();
         await writeBytes2(context.stderr, encoder.encode(`qpdf: cannot open ${path}
@@ -4103,6 +4481,11 @@ async function qpdf(context, options = {}) {
       }
     }
     return { exitCode: res.exitCode };
+  } catch (error) {
+    if (!(error instanceof QpdfPageRangeError)) throw error;
+    await writeBytes2(context.stderr, new TextEncoder().encode(`qpdf: ${error.message}
+`), invocation.signal);
+    return { exitCode: 2 };
   } finally {
     await invocation.close();
   }