@poe-platform/safe-bash 0.1.788 → 0.1.790

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

@@ -4,6 +4,7 @@ import {
 
 // packages/safe-bash-command-qpdf/dist/index.js
 init_buffer();
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 import {
   commandRuntimeIdentity,
@@ -27100,6 +27101,11 @@ function tokenizeCos(bytes, start = 0, end = bytes.length) {
   }
   return tokens;
 }
+function drainWork(work) {
+  let step = work.next();
+  while (!step.done) step = work.next();
+  return step.value;
+}
 function bytesToString3(bytes) {
   if (typeof bytes !== "object" || bytes?.length === void 0) {
     throw new Error("Invalid argument for bytesToString");
@@ -27695,7 +27701,9 @@ function concatByteArrays(chunks) {
   }
   return out;
 }
-function serializeCosDocument(options) {
+function* serializeCosDocumentSteps(options) {
+  yield;
+  let work = 0;
   const maxOutputBytes = options.maxOutputBytes ?? Infinity;
   const maxObjects = options.maxObjects ?? Infinity;
   const sorted = [...options.objects].sort((a, b) => a.objectNumber - b.objectNumber);
@@ -27718,6 +27726,7 @@ function serializeCosDocument(options) {
     const packable = [];
     const direct = [];
     for (const obj of sorted) {
+      if (++work % 16 === 0) yield;
       const isLinearized = obj.value.kind === "dict" && dictGet(obj.value, "Linearized") !== void 0;
       if (obj.value.kind !== "stream" && obj.generationNumber === 0 && !isLinearized) {
         packable.push(obj);
@@ -27732,6 +27741,7 @@ function serializeCosDocument(options) {
       const headerPairs = [];
       let relOffset = 0;
       for (const pObj of packable) {
+        if (++work % 16 === 0) yield;
         headerPairs.push(`${pObj.objectNumber} ${relOffset}`);
         const bBytes = serializeCosNodeBytes(pObj.value);
         const nl = textEncoder2.encode("\n");
@@ -27757,6 +27767,7 @@ function serializeCosDocument(options) {
       ];
       const directOffsets = /* @__PURE__ */ new Map();
       for (const dObj of allDirect) {
+        if (++work % 16 === 0) yield;
         directOffsets.set(dObj.objectNumber, { offset, generation: dObj.generationNumber });
         const prefix = textEncoder2.encode(`${dObj.objectNumber} ${dObj.generationNumber} obj
 `);
@@ -27767,6 +27778,7 @@ function serializeCosDocument(options) {
       }
       const compressedMap = /* @__PURE__ */ new Map();
       for (let idx = 0; idx < packable.length; idx++) {
+        if (++work % 16 === 0) yield;
         compressedMap.set(packable[idx].objectNumber, idx);
       }
       const xrefOffset2 = offset;
@@ -27784,6 +27796,7 @@ function serializeCosDocument(options) {
       };
       writeEntry7(0, 0, 0, 65535);
       for (let i = 1; i < size2; i++) {
+        if (++work % 16 === 0) yield;
         if (i === xrefStmNum) {
           writeEntry7(i, 1, xrefOffset2, 0);
         } else if (compressedMap.has(i)) {
@@ -27864,6 +27877,7 @@ ${xrefOffset2}
     let pageCount = 0;
     let firstPageObjNum = options.rootRef.objectNumber;
     for (const o of sorted) {
+      if (++work % 16 === 0) yield;
       if (o.value.kind === "dict") {
         const t = dictGet(o.value, "Type");
         if (t?.kind === "name" && t.decoded === "Page") {
@@ -27911,6 +27925,7 @@ ${xrefOffset2}
   }
   const objectOffsets = /* @__PURE__ */ new Map();
   for (const obj of sorted) {
+    if (++work % 16 === 0) yield;
     objectOffsets.set(obj.objectNumber, { offset, generation: obj.generationNumber });
     let value = obj.value;
     if (options.normalizeContent && value.kind === "stream" && value.decodedBytes) {
@@ -27942,6 +27957,7 @@ ${xrefOffset2}
 0000000000 65535 f 
 `;
   for (let i = 1; i < size; i++) {
+    if (++work % 16 === 0) yield;
     const entry = objectOffsets.get(i);
     if (entry) {
       xrefText += `${String(entry.offset).padStart(10, "0")} ${String(entry.generation).padStart(5, "0")} n 
@@ -27988,6 +28004,7 @@ ${xrefOffset}
     let endFirstPage = xrefOffset;
     const sortedOffsets = [...objectOffsets.entries()].sort((a, b) => a[1].offset - b[1].offset);
     for (let i = 0; i < sortedOffsets.length; i++) {
+      if (++work % 16 === 0) yield;
       const [objNum, info3] = sortedOffsets[i];
       const nextOff = sortedOffsets[i + 1]?.[1].offset ?? xrefOffset;
       if (objNum === hintObjAfter.objectNumber) {
@@ -28021,6 +28038,9 @@ ${xrefOffset}
   }
   return fullBytes;
 }
+function serializeCosDocument(options) {
+  return drainWork(serializeCosDocumentSteps(options));
+}
 function appendIncrementalRevision(originalBytes, doc, updatedObjects) {
   const chunks = [originalBytes, textEncoder2.encode("\n")];
   let offset = originalBytes.length + 1;
@@ -28294,48 +28314,30 @@ function encryptPdfBuffer(state, objectNumber, generationNumber, plaintext) {
   const objKey = md5Bytes([state.fileKey, suffix]).subarray(0, Math.min(16, state.fileKey.length + 5));
   return rc4Transform(objKey, plaintext);
 }
-function transformNodeStringsAndStreams(node, transform, transformStream) {
+function* transformNodeStringsAndStreamsSteps(node, transform, transformStream) {
+  yield;
   switch (node.kind) {
     case "string":
-      return {
-        kind: "string",
-        format: "hex",
-        bytes: transform(node.bytes)
-      };
-    case "array":
-      return {
-        kind: "array",
-        items: node.items.map((item) => transformNodeStringsAndStreams(item, transform, transformStream))
-      };
+      return { kind: "string", format: "hex", bytes: transform(node.bytes) };
+    case "array": {
+      const items = [];
+      for (const item of node.items) items.push(yield* transformNodeStringsAndStreamsSteps(item, transform, transformStream));
+      return { kind: "array", items };
+    }
     case "dict": {
-      const type = dictGet(node, "Type");
-      const fieldType = dictGet(node, "FT");
-      const byteRange = dictGet(node, "ByteRange");
+      const type = dictGet(node, "Type"), fieldType = dictGet(node, "FT"), byteRange = dictGet(node, "ByteRange");
       const signature = type?.kind === "name" && type.decoded === "Sig" || fieldType?.kind === "name" && fieldType.decoded === "Sig" || byteRange?.kind === "array" && dictGet(node, "Filter")?.kind === "name";
-      return {
-        kind: "dict",
-        entries: node.entries.map((e) => ({
-          key: e.key,
-          value: signature && e.key.decoded === "Contents" ? e.value : transformNodeStringsAndStreams(e.value, transform, transformStream)
-        }))
-      };
+      const entries = [];
+      for (const e of node.entries) entries.push({ key: e.key, value: signature && e.key.decoded === "Contents" ? e.value : yield* transformNodeStringsAndStreamsSteps(e.value, transform, transformStream) });
+      return { kind: "dict", entries };
     }
     case "stream": {
       const type = dictGet(node.dict, "Type");
       if (type?.kind === "name" && type.decoded === "XRef") return node;
       const stream = transformStream ? transformStream(node) : { ...node, rawBytes: transform(node.rawBytes) };
-      const updatedDict = {
-        kind: "dict",
-        entries: stream.dict.entries.map((e) => ({
-          key: e.key,
-          value: e.key.decoded === "Length" ? cosNumber(stream.rawBytes.length) : transformNodeStringsAndStreams(e.value, transform, transformStream)
-        }))
-      };
-      return {
-        kind: "stream",
-        dict: updatedDict,
-        rawBytes: stream.rawBytes
-      };
+      const entries = [];
+      for (const e of stream.dict.entries) entries.push({ key: e.key, value: e.key.decoded === "Length" ? cosNumber(stream.rawBytes.length) : yield* transformNodeStringsAndStreamsSteps(e.value, transform, transformStream) });
+      return { kind: "stream", dict: { kind: "dict", entries }, rawBytes: stream.rawBytes };
     }
     default:
       return node;
@@ -28404,7 +28406,8 @@ function createR6Encryption(userPassword, ownerPassword, pMask) {
     StrF: cosName("StdCF")
   }) };
 }
-function encryptCosDocument(doc, options = {}) {
+function* encryptCosDocumentSteps(doc, options = {}) {
+  yield;
   const userPassword = options.userPassword ?? "";
   const ownerPassword = options.ownerPassword ?? userPassword;
   const revision = options.revision ?? 6;
@@ -28426,14 +28429,15 @@ function encryptCosDocument(doc, options = {}) {
   const encryptObjNum = maxObjNum + 1;
   const encryptedObjects = [];
   for (const obj of doc.objects.values()) {
-    const transformed = transformNodeStringsAndStreams(
+    yield;
+    const transformed = yield* transformNodeStringsAndStreamsSteps(
       obj.value,
       (plain) => encryptPdfBuffer(state, obj.objectNumber, obj.generationNumber, plain)
     );
     encryptedObjects.push({ objectNumber: obj.objectNumber, generationNumber: obj.generationNumber, value: transformed });
   }
   encryptedObjects.push({ objectNumber: encryptObjNum, generationNumber: 0, value: encryptDict });
-  return serializeCosDocument({
+  return yield* serializeCosDocumentSteps({
     objects: encryptedObjects,
     rootRef: doc.rootRef,
     infoRef: doc.infoRef,
@@ -28483,17 +28487,19 @@ function decryptStream(doc, stream, transform) {
   }
   return { kind: "stream", dict, rawBytes: bytes };
 }
-function decryptCosDocument(doc, state) {
+function* decryptCosDocumentSteps(doc, state) {
+  yield;
   const encryptObjNum = doc.encryptRef?.objectNumber;
   const handler = securityHandlers.get(state);
   for (const [num, obj] of doc.objects.entries()) {
+    yield;
     if (num === encryptObjNum || handler?.plaintextObjects.has(num)) continue;
     if (obj.value.kind === "stream") {
       const type = doc.resolve(dictGet(obj.value.dict, "Type"));
       if (type?.kind === "name" && (type.decoded === "XRef" || type.decoded === "Metadata" && !state.encryptMetadata)) continue;
     }
     const transform = handler?.factory.createCipherTransform(obj.objectNumber, obj.generationNumber);
-    const decrypted = transformNodeStringsAndStreams(
+    const decrypted = yield* transformNodeStringsAndStreamsSteps(
       obj.value,
       (cipher) => decryptPdfBuffer(state, obj.objectNumber, obj.generationNumber, cipher),
       transform ? (stream) => decryptStream(doc, stream, transform) : void 0
@@ -28607,9 +28613,12 @@ var ParsedCosDocument = class {
     return void 0;
   }
 };
-function parseNodeFromLexer(lexer, bytes, maxDepth, repair = false) {
+function* parseNodeFromLexerSteps(lexer, bytes, maxDepth, repair = false) {
+  yield;
+  let work = 0;
   const stack = [];
   while (true) {
+    if (++work % 16 === 0) yield;
     const tok = lexer.nextToken();
     const parent = stack.at(-1);
     if (!tok) {
@@ -28805,7 +28814,8 @@ function parseHeaderVersion(bytes) {
   }
   return head.slice(idx + 5, idx + 8);
 }
-function parseObjectAtOffset(bytes, offset, maxRecursionDepth, repair = false) {
+function* parseObjectAtOffsetSteps(bytes, offset, maxRecursionDepth, repair = false) {
+  yield;
   const lexer = new CosByteLexer(bytes, offset);
   const objNumTok = lexer.nextToken();
   const genNumTok = lexer.nextToken();
@@ -28813,7 +28823,7 @@ function parseObjectAtOffset(bytes, offset, maxRecursionDepth, repair = false) {
   if (objNumTok?.kind !== "number" || genNumTok?.kind !== "number" || objKwTok?.kind !== "keyword" || objKwTok.value !== "obj") {
     throw new PdfError("E_PARSE", `Malformed indirect object header at byte offset ${offset}`);
   }
-  const value = parseNodeFromLexer(lexer, bytes, maxRecursionDepth, repair);
+  const value = yield* parseNodeFromLexerSteps(lexer, bytes, maxRecursionDepth, repair);
   if (!value) {
     throw new PdfError("E_PARSE", `Empty indirect object ${objNumTok.value} at offset ${offset}`);
   }
@@ -28824,7 +28834,9 @@ function parseObjectAtOffset(bytes, offset, maxRecursionDepth, repair = false) {
     span: { start: objNumTok.span.start, end: lexer.offset }
   };
 }
-function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursionDepth, maxObjects) {
+function* parseXrefRevisionAtSteps(bytes, xrefOffset, maxDecompressedBytes, maxRecursionDepth, maxObjects) {
+  yield;
+  let work = 0;
   if (xrefOffset < 0 || xrefOffset >= bytes.length) {
     throw new PdfError("E_PARSE", `Invalid xref offset: ${xrefOffset}`);
   }
@@ -28836,6 +28848,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
   if (firstTok.kind === "keyword" && firstTok.value === "xref") {
     const entries2 = /* @__PURE__ */ new Map();
     while (true) {
+      if (++work % 16 === 0) yield;
       const saved = lexer.offset;
       const tok = lexer.nextToken();
       if (!tok) {
@@ -28859,6 +28872,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
       }
       if (count > maxObjects + 1) throw new PdfError("E_LIMIT", "PDF object count limit exceeded while reading xref entries");
       for (let i = 0; i < count; i++) {
+        if (++work % 16 === 0) yield;
         const offTok = lexer.nextToken();
         const genTok = lexer.nextToken();
         const flagTok = lexer.nextToken();
@@ -28884,7 +28898,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
         if (entries2.size > maxObjects + 1) throw new PdfError("E_LIMIT", "PDF object count limit exceeded while reading xref entries");
       }
     }
-    const trailerNode = parseNodeFromLexer(lexer, bytes, maxRecursionDepth);
+    const trailerNode = yield* parseNodeFromLexerSteps(lexer, bytes, maxRecursionDepth);
     if (!trailerNode || trailerNode.kind !== "dict") {
       throw new PdfError("E_PARSE", "Missing trailer dictionary after xref table");
     }
@@ -28896,7 +28910,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
       previousXrefOffset: prevNode2?.kind === "number" ? prevNode2.value : void 0
     };
   }
-  const xrefObj = parseObjectAtOffset(bytes, xrefOffset, maxRecursionDepth);
+  const xrefObj = yield* parseObjectAtOffsetSteps(bytes, xrefOffset, maxRecursionDepth);
   if (xrefObj.value.kind !== "stream") {
     throw new PdfError("E_PARSE", `Expected xref table or XRef stream at offset ${xrefOffset}`);
   }
@@ -28917,6 +28931,7 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
   if (indexArray) {
     if (indexArray.kind !== "array" || indexArray.items.length % 2 !== 0) throw new PdfError("E_PARSE", "Invalid XRef range fields");
     for (let i = 0; i < indexArray.items.length; i += 2) {
+      if (++work % 16 === 0) yield;
       const first = indexArray.items[i];
       const count = indexArray.items[i + 1];
       if (first?.kind !== "number" || count?.kind !== "number" || !Number.isSafeInteger(first.value) || first.value < 0 || !Number.isSafeInteger(count.value) || count.value < 0 || !Number.isSafeInteger(first.value + count.value)) {
@@ -28939,9 +28954,11 @@ function parseXrefRevisionAt(bytes, xrefOffset, maxDecompressedBytes, maxRecursi
     return v;
   };
   for (const [startObj, count] of subsections) {
+    if (++work % 16 === 0) yield;
     if (count > (decoded.length - pos) / stride) throw new PdfError("E_PARSE", "Truncated XRef stream");
     if (count > maxObjects + 1) throw new PdfError("E_LIMIT", "PDF object count limit exceeded while reading xref entries");
     for (let i = 0; i < count; i++) {
+      if (++work % 16 === 0) yield;
       const objNum = startObj + i;
       const field0 = w0 > 0 ? readInt(w0) : 1;
       const field1 = readInt(w1);
@@ -28987,12 +29004,16 @@ function isAsciiWhitespace(ch3) {
 function isAsciiDigit(ch3) {
   return ch3 >= 48 && ch3 <= 57;
 }
-function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
+function* repairScanCosDocumentSteps(bytes, maxObjects, maxRecursionDepth) {
+  yield;
+  let work = 0;
   const objects = /* @__PURE__ */ new Map();
   const trailers = [];
   let pos = 0;
   while (pos < bytes.length) {
+    if (++work % 16 === 0) yield;
     while (pos < bytes.length && !isAsciiDigit(bytes[pos])) {
+      if (++work % 16 === 0) yield;
       if (bytes[pos] === 37) {
         while (pos < bytes.length && bytes[pos] !== 10 && bytes[pos] !== 13) pos++;
         continue;
@@ -29002,7 +29023,7 @@ function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
         try {
           const token = lexer.nextToken();
           if (token?.kind === "keyword" && token.value === "trailer") {
-            const trailer = parseNodeFromLexer(lexer, bytes, maxRecursionDepth, true);
+            const trailer = yield* parseNodeFromLexerSteps(lexer, bytes, maxRecursionDepth, true);
             if (trailer?.kind === "dict") trailers.push(trailer);
             pos = lexer.offset;
             continue;
@@ -29035,7 +29056,7 @@ function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
     bytes[pos + 3] === 40)) {
       pos += 3;
       try {
-        const parsed = parseObjectAtOffset(bytes, headerStart, maxRecursionDepth, true);
+        const parsed = yield* parseObjectAtOffsetSteps(bytes, headerStart, maxRecursionDepth, true);
         objects.set(parsed.objectNumber, parsed);
         if (parsed.value.kind === "stream") {
           const type = dictGet(parsed.value.dict, "Type");
@@ -29052,13 +29073,17 @@ function repairScanCosDocument(bytes, maxObjects, maxRecursionDepth) {
   }
   return { objects, trailers };
 }
-function unpackRecoveredObjects(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth) {
+function* unpackRecoveredObjectsSteps(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth) {
+  yield;
+  let work = 0;
   for (const obj of [...objects.values()]) {
+    if (++work % 16 === 0) yield;
     if (obj.value.kind === "stream") {
       const t = dictGet(obj.value.dict, "Type");
       if (t?.kind === "name" && t.decoded === "ObjStm") {
         try {
-          for (const [unpackedNum, unpackedVal] of unpackObjectStream(obj.value, maxDecompressedBytes, maxRecursionDepth, true).entries()) {
+          for (const [unpackedNum, unpackedVal] of (yield* unpackObjectStreamSteps(obj.value, maxDecompressedBytes, maxRecursionDepth, true)).entries()) {
+            if (++work % 16 === 0) yield;
             if (!objects.has(unpackedNum)) {
               objects.set(unpackedNum, {
                 objectNumber: unpackedNum,
@@ -29094,7 +29119,9 @@ function recoveredReferences(objects) {
   }
   return { ...rootRef ? { rootRef } : {}, ...infoRef ? { infoRef } : {} };
 }
-function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth, repair = false) {
+function* unpackObjectStreamSteps(streamObj, maxDecompressedBytes, maxRecursionDepth, repair = false) {
+  yield;
+  let work = 0;
   const nNode = dictGet(streamObj.dict, "N");
   const firstNode = dictGet(streamObj.dict, "First");
   if (nNode?.kind !== "number" || firstNode?.kind !== "number") {
@@ -29104,6 +29131,7 @@ function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth,
   const headerLexer = new CosByteLexer(decoded, 0);
   const pairs = [];
   for (let i = 0; i < nNode.value; i++) {
+    if (++work % 16 === 0) yield;
     const numTok = headerLexer.nextToken();
     const offTok = headerLexer.nextToken();
     if (numTok?.kind === "number" && offTok?.kind === "number") {
@@ -29112,9 +29140,10 @@ function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth,
   }
   const result = /* @__PURE__ */ new Map();
   for (const pair of pairs) {
+    if (++work % 16 === 0) yield;
     try {
       const valLexer = new CosByteLexer(decoded, firstNode.value + pair.relativeOffset);
-      const node = parseNodeFromLexer(valLexer, decoded, maxRecursionDepth, repair);
+      const node = yield* parseNodeFromLexerSteps(valLexer, decoded, maxRecursionDepth, repair);
       if (node) {
         result.set(pair.objectNumber, node);
       }
@@ -29124,7 +29153,9 @@ function unpackObjectStream(streamObj, maxDecompressedBytes, maxRecursionDepth,
   }
   return result;
 }
-function parseCosDocument(bytes, options = {}) {
+function* parseCosDocumentSteps(bytes, options = {}) {
+  yield;
+  let work = 0;
   const version = parseHeaderVersion(bytes);
   const recovery = options.recovery ?? "strict";
   const maxObjects = options.maxObjects ?? Infinity;
@@ -29159,10 +29190,12 @@ function parseCosDocument(bytes, options = {}) {
         let currentXrefOffset = offsetTok.value;
         const visitedOffsets = /* @__PURE__ */ new Set();
         while (currentXrefOffset !== void 0 && !visitedOffsets.has(currentXrefOffset)) {
+          if (++work % 16 === 0) yield;
           visitedOffsets.add(currentXrefOffset);
-          const rev = parseXrefRevisionAt(bytes, currentXrefOffset, maxDecompressedBytes, maxRecursionDepth, maxObjects);
+          const rev = yield* parseXrefRevisionAtSteps(bytes, currentXrefOffset, maxDecompressedBytes, maxRecursionDepth, maxObjects);
           revisions.push(rev);
           for (const [num, entry] of rev.entries.entries()) {
+            if (++work % 16 === 0) yield;
             if (!mergedXref.has(num)) {
               mergedXref.set(num, entry);
               if (mergedXref.size > maxObjects + 1) throw new PdfError("E_LIMIT", "PDF object count limit exceeded while reading xref entries");
@@ -29195,8 +29228,9 @@ function parseCosDocument(bytes, options = {}) {
   if (!useRepair && rootRef) {
     try {
       for (const [objNum, entry] of mergedXref.entries()) {
+        if (++work % 16 === 0) yield;
         if (entry.type !== "uncompressed") continue;
-        const parsed = parseObjectAtOffset(bytes, entry.offset ?? 0, maxRecursionDepth, recovery === "repair");
+        const parsed = yield* parseObjectAtOffsetSteps(bytes, entry.offset ?? 0, maxRecursionDepth, recovery === "repair");
         if (parsed.objectNumber !== objNum || parsed.generationNumber !== (entry.generationNumber ?? 0)) {
           throw new PdfError("E_PARSE", `Bad uncompressed XRef entry for object ${objNum}`);
         }
@@ -29214,7 +29248,7 @@ function parseCosDocument(bytes, options = {}) {
       throw new PdfError("E_PARSE", "PDF trailer missing /Root reference");
     }
     useRepair = true;
-    const scanned = repairScanCosDocument(bytes, maxObjects, maxRecursionDepth);
+    const scanned = yield* repairScanCosDocumentSteps(bytes, maxObjects, maxRecursionDepth);
     objects = scanned.objects;
     revisions.length = 0;
     mergedXref.clear();
@@ -29249,7 +29283,7 @@ function parseCosDocument(bytes, options = {}) {
     encryptNode = encrypt?.kind === "ref" || encrypt?.kind === "dict" ? encrypt : void 0;
     encryptRef = encrypt?.kind === "ref" ? encrypt : void 0;
     idArray = id?.kind === "array" ? id : void 0;
-    if (!rootRef && !encryptNode) unpackRecoveredObjects(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth);
+    if (!rootRef && !encryptNode) yield* unpackRecoveredObjectsSteps(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth);
     const fallback = recoveredReferences(objects);
     rootRef ??= fallback.rootRef;
     infoRef ??= fallback.infoRef;
@@ -29284,20 +29318,21 @@ function parseCosDocument(bytes, options = {}) {
       maxRecursionDepth
     });
     doc.encryption = encState;
-    decryptCosDocument(doc, encState);
+    yield* decryptCosDocumentSteps(doc, encState);
   }
   if (useRepair) {
-    unpackRecoveredObjects(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth);
+    yield* unpackRecoveredObjectsSteps(objects, maxObjects, maxDecompressedBytes, maxRecursionDepth);
     doc.infoRef ??= recoveredReferences(objects).infoRef;
   }
   const objStmCache = /* @__PURE__ */ new Map();
   for (const [objNum, entry] of mergedXref.entries()) {
+    if (++work % 16 === 0) yield;
     if (entry.type === "compressed" && entry.objectStreamNumber !== void 0) {
       let unpacked = objStmCache.get(entry.objectStreamNumber);
       if (!unpacked) {
         const stmObj = objects.get(entry.objectStreamNumber)?.value;
         if (stmObj?.kind === "stream") {
-          unpacked = unpackObjectStream(stmObj, maxDecompressedBytes, maxRecursionDepth, recovery === "repair");
+          unpacked = yield* unpackObjectStreamSteps(stmObj, maxDecompressedBytes, maxRecursionDepth, recovery === "repair");
           objStmCache.set(entry.objectStreamNumber, unpacked);
         }
       }
@@ -29314,6 +29349,9 @@ function parseCosDocument(bytes, options = {}) {
   }
   return doc;
 }
+function parseCosDocument(bytes, options = {}) {
+  return drainWork(parseCosDocumentSteps(bytes, options));
+}
 var WIN_ANSI_HIGH_BYTES = {
   128: 8364,
   130: 8218,
@@ -40344,7 +40382,8 @@ function resolveInheritedFieldEntry(doc, dict, key) {
   }
   return void 0;
 }
-function collectFieldDicts(doc, node, prefix = "", out = [], parentFt = "", parentFf = 0, parentQ = 0, parentMaxLen) {
+function* collectFieldDictsSteps(doc, node, prefix = "", out = [], parentFt = "", parentFf = 0, parentQ = 0, parentMaxLen, yieldState = { work: 0 }) {
+  if (++yieldState.work % 256 === 0) yield;
   const dict = doc.resolveDict(node);
   if (!dict) return out;
   const tNode = doc.resolve(dictGet(dict, "T"));
@@ -40377,7 +40416,8 @@ function collectFieldDicts(doc, node, prefix = "", out = [], parentFt = "", pare
       return out;
     }
     for (const kid of kidsArr.items) {
-      collectFieldDicts(doc, kid, fullName, out, currentFt, currentFf, currentQ, currentMaxLen);
+      if (++yieldState.work % 16 === 0) yield;
+      yield* collectFieldDictsSteps(doc, kid, fullName, out, currentFt, currentFf, currentQ, currentMaxLen, yieldState);
     }
   } else if (fullName) {
     out.push({
@@ -40806,7 +40846,9 @@ function setDocumentFormField(doc, fieldName, value) {
   const fieldRef = doc.allocateObject(newFieldDict);
   fieldsArr.items.push(fieldRef);
 }
-function generateDocumentFormAppearances(doc) {
+function* generateDocumentFormAppearancesSteps(doc) {
+  yield;
+  let work = 0;
   const catalog = doc.resolveDict(doc.rootRef);
   if (!catalog) return;
   const acroForm = doc.resolveDict(dictGet(catalog, "AcroForm"));
@@ -40817,9 +40859,11 @@ function generateDocumentFormAppearances(doc) {
   if (fieldsArr) {
     const all = [];
     for (const item of fieldsArr.items) {
-      collectFieldDicts(doc, item, "", all);
+      if (++work % 16 === 0) yield;
+      yield* collectFieldDictsSteps(doc, item, "", all);
     }
     for (const entry of all) {
+      if (++work % 16 === 0) yield;
       const ftNode = doc.resolve(dictGet(entry.dict, "FT"));
       const ft = entry.inheritedFt || (ftNode?.kind === "name" ? ftNode.decoded : "");
       const vNode = doc.resolve(dictGet(entry.dict, "V"));
@@ -40869,6 +40913,7 @@ function generateDocumentFormAppearances(doc) {
           const optArr = doc.resolveArray(dictGet(entry.dict, "Opt"));
           if (optArr) {
             for (const optItem of optArr.items) {
+              if (++work % 16 === 0) yield;
               const resolvedOpt = doc.resolve(optItem);
               if (resolvedOpt?.kind === "array" && resolvedOpt.items.length >= 2) {
                 const expNode = doc.resolve(resolvedOpt.items[0]);
@@ -40897,6 +40942,7 @@ function generateDocumentFormAppearances(doc) {
         const kidsArr = doc.resolveArray(dictGet(entry.dict, "Kids"));
         if (kidsArr) {
           for (const kid of kidsArr.items) {
+            if (++work % 16 === 0) yield;
             const kidDict = doc.resolveDict(kid);
             if (kidDict && !dictGet(kidDict, "T")) {
               synthesizeTextAppearanceStream(
@@ -40928,6 +40974,9 @@ function escapePdfLiteralString(str) {
   }
   return out;
 }
+function collectFieldDicts(doc, node, prefix = "", out = [], parentFt = "", parentFf = 0, parentQ = 0, parentMaxLen) {
+  drainWork(collectFieldDictsSteps(doc, node, prefix, out, parentFt, parentFf, parentQ, parentMaxLen));
+}
 var PdfPage = class {
   cosDoc;
   pageRef;
@@ -43381,14 +43430,18 @@ var PdfDocument = class _PdfDocument {
     });
     return new _PdfDocument(parseCosDocument(rawBytes));
   }
-  static load(bytes, options) {
+  static *loadSteps(bytes, options) {
+    yield;
     return new _PdfDocument(
-      parseCosDocument(bytes, {
+      yield* parseCosDocumentSteps(bytes, {
         ...options,
         recovery: options?.recovery ?? "repair"
       })
     );
   }
+  static load(bytes, options) {
+    return drainWork(_PdfDocument.loadSteps(bytes, options));
+  }
   rebuildPagesList() {
     const catalog = this.cos.resolveDict(this.cos.rootRef);
     const pagesNode = catalog ? dictGet(catalog, "Pages") : void 0;
@@ -43470,20 +43523,30 @@ var PdfDocument = class _PdfDocument {
     this.pages.splice(index, 1);
     this.syncPageTree();
   }
-  copyPagesFrom(sourceDoc, indices) {
+  *copyPagesFromSteps(sourceDoc, indices) {
+    function* cloneItems(items) {
+      const result = [];
+      for (const item of items) result.push(yield* cloneNode(item));
+      return result;
+    }
+    yield;
+    let work = 0;
     const memo = /* @__PURE__ */ new Map();
     const sourcePageObjNums = /* @__PURE__ */ new Set();
     for (let i = 0; i < sourceDoc.getPageCount(); i++) {
+      if (++work % 16 === 0) yield;
       sourcePageObjNums.add(sourceDoc.getPage(i).ref.objectNumber);
     }
     const targetPageRefs = [];
     for (const idx of indices) {
+      if (++work % 16 === 0) yield;
       const srcPage = sourceDoc.getPage(idx);
       const pageRef = this.cos.allocateObject({ kind: "null" });
       targetPageRefs.push(pageRef);
       memo.set(srcPage.ref.objectNumber, pageRef);
     }
-    const cloneNode = (node) => {
+    const cloneNode = function* (node) {
+      if (++work % 16 === 0) yield;
       if (node.kind === "ref") {
         const existing = memo.get(node.objectNumber);
         if (existing) return existing;
@@ -43494,12 +43557,12 @@ var PdfDocument = class _PdfDocument {
         if (!target) return cosRef(0);
         const placeholderRef = this.cos.allocateObject({ kind: "null" });
         memo.set(node.objectNumber, placeholderRef);
-        const clonedTarget = cloneNode(target);
+        const clonedTarget = yield* cloneNode(target);
         this.cos.setObject(placeholderRef.objectNumber, clonedTarget, 0);
         return placeholderRef;
       }
       if (node.kind === "array") {
-        return cosArray(node.items.map(cloneNode));
+        return cosArray(yield* cloneItems(node.items));
       }
       if (node.kind === "dict") {
         const typeEntry = dictGet(node, "Type");
@@ -43509,13 +43572,13 @@ var PdfDocument = class _PdfDocument {
           if (isPageTreeNode && entry.key.decoded === "Parent") continue;
           newEntries.push({
             key: { ...entry.key },
-            value: cloneNode(entry.value)
+            value: yield* cloneNode(entry.value)
           });
         }
         return { kind: "dict", entries: newEntries };
       }
       if (node.kind === "stream") {
-        const clonedDict = cloneNode(node.dict);
+        const clonedDict = yield* cloneNode(node.dict);
         return {
           kind: "stream",
           dict: clonedDict,
@@ -43524,11 +43587,12 @@ var PdfDocument = class _PdfDocument {
         };
       }
       return node;
-    };
+    }.bind(this);
     const copiedPages = [];
     for (const [position, idx] of indices.entries()) {
+      if (++work % 16 === 0) yield;
       const srcPage = sourceDoc.getPage(idx);
-      const clonedPageDict = cloneNode(srcPage.pageDict);
+      const clonedPageDict = yield* cloneNode(srcPage.pageDict);
       const size = srcPage.getSize();
       if (!dictGet(clonedPageDict, "MediaBox")) {
         dictSet(
@@ -43538,13 +43602,14 @@ var PdfDocument = class _PdfDocument {
         );
       }
       if (!dictGet(clonedPageDict, "Resources")) {
-        dictSet(clonedPageDict, "Resources", cloneNode(srcPage.getResourcesDict()));
+        dictSet(clonedPageDict, "Resources", yield* cloneNode(srcPage.getResourcesDict()));
       }
       if (!dictGet(clonedPageDict, "Rotate") && srcPage.getRotation() !== 0) {
         dictSet(clonedPageDict, "Rotate", cosNumber(srcPage.getRotation()));
       }
       const inheritedBoxKeys = ["CropBox", "BleedBox", "TrimBox", "ArtBox"];
       for (const boxKey of inheritedBoxKeys) {
+        if (++work % 16 === 0) yield;
         if (!dictGet(clonedPageDict, boxKey)) {
           const boxVal = boxKey === "CropBox" ? srcPage.getCropBox() : boxKey === "BleedBox" ? srcPage.getBleedBox() : boxKey === "TrimBox" ? srcPage.getTrimBox() : srcPage.getArtBox();
           if (boxVal[0] !== 0 || boxVal[1] !== 0 || boxVal[2] !== size.width || boxVal[3] !== size.height) {
@@ -43586,8 +43651,9 @@ var PdfDocument = class _PdfDocument {
       };
       const clonedRootFieldRefs = [];
       for (const item of srcFieldsArr.items) {
+        if (++work % 16 === 0) yield;
         if (!hasClonedDescendant(item)) continue;
-        const cloned = cloneNode(item);
+        const cloned = yield* cloneNode(item);
         if (cloned.kind === "ref") {
           const clonedDict = this.cos.resolveDict(cloned);
           const kidsArr = clonedDict ? this.cos.resolveArray(dictGet(clonedDict, "Kids")) : void 0;
@@ -43621,6 +43687,7 @@ var PdfDocument = class _PdfDocument {
             dstFields.items.filter((x) => x.kind === "ref").map((x) => x.objectNumber)
           );
           for (const fRef of clonedRootFieldRefs) {
+            if (++work % 16 === 0) yield;
             if (!existingNums.has(fRef.objectNumber)) {
               dstFields.items.push(fRef);
               existingNums.add(fRef.objectNumber);
@@ -43628,11 +43695,11 @@ var PdfDocument = class _PdfDocument {
           }
           const srcDr = dictGet(srcAcroForm, "DR");
           if (srcDr && !dictGet(dstAcroForm, "DR")) {
-            dictSet(dstAcroForm, "DR", cloneNode(srcDr));
+            dictSet(dstAcroForm, "DR", yield* cloneNode(srcDr));
           }
           const srcDa = dictGet(srcAcroForm, "DA");
           if (srcDa && !dictGet(dstAcroForm, "DA")) {
-            dictSet(dstAcroForm, "DA", cloneNode(srcDa));
+            dictSet(dstAcroForm, "DA", yield* cloneNode(srcDa));
           }
         }
       }
@@ -43641,12 +43708,15 @@ var PdfDocument = class _PdfDocument {
     if (srcOcProps) {
       const dstCatalog = this.cos.resolveDict(this.cos.rootRef);
       if (dstCatalog && !dictGet(dstCatalog, "OCProperties")) {
-        dictSet(dstCatalog, "OCProperties", cloneNode(srcOcProps));
+        dictSet(dstCatalog, "OCProperties", yield* cloneNode(srcOcProps));
       }
     }
     this.syncPageTree();
     return copiedPages;
   }
+  copyPagesFrom(sourceDoc, indices) {
+    return drainWork(this.copyPagesFromSteps(sourceDoc, indices));
+  }
   embedStandardFont(fontName) {
     return createStandardFontHandle(fontName);
   }
@@ -43846,14 +43916,15 @@ var PdfDocument = class _PdfDocument {
     });
     return buildSemanticAstFromPages(extractedPages, tablesByPage, displayLists);
   }
-  save(options = {}) {
+  *saveSteps(options = {}) {
+    yield;
     this.syncPageTree();
     if (this.cos.requiresFullRewrite) {
       pruneUnusedXObjects(this.cos, this.pages);
       discardUnreachableObjects(this.cos);
     }
     if (options.encrypt) {
-      return encryptCosDocument(this.cos, options.encrypt);
+      return yield* encryptCosDocumentSteps(this.cos, options.encrypt);
     }
     const allObjects = [...this.cos.objects.values()].sort(
       (a, b) => a.objectNumber - b.objectNumber
@@ -43861,7 +43932,7 @@ var PdfDocument = class _PdfDocument {
     if (options.incremental && !this.cos.requiresFullRewrite && this.cos.bytes.length > 0) {
       return appendIncrementalRevision(this.cos.bytes, this.cos, allObjects);
     }
-    return serializeCosDocument({
+    return yield* serializeCosDocumentSteps({
       objects: allObjects,
       rootRef: this.cos.rootRef,
       infoRef: this.cos.infoRef,
@@ -43872,6 +43943,9 @@ var PdfDocument = class _PdfDocument {
       linearize: options.linearize
     });
   }
+  save(options = {}) {
+    return drainWork(this.saveSteps(options));
+  }
 };
 function resolveDestinationPageIndex(doc, destOrActionNode) {
   const cos = doc.cos;
@@ -43993,6 +44067,13 @@ function replacePdfNameToken(content, oldName, newName) {
   }
   return out;
 }
+function resolveLimits(options) {
+  const limits = { maxInputBytes: Infinity, maxOutputBytes: Infinity, maxArgumentBytes: Infinity, ...options.limits };
+  for (const [name, value] of Object.entries(limits)) {
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) throw new RangeError(`${name} limit must be a nonnegative safe integer or Infinity`);
+  }
+  return limits;
+}
 function parseSingleTokenPageNumber(tok, totalPages) {
   const trimmed = tok.trim();
   if (trimmed === "z") return totalPages;
@@ -44417,13 +44498,25 @@ function collectNumberTreeDicts(doc, treeDict, visited = /* @__PURE__ */ new Set
   }
   return out;
 }
-async function runQpdfCli(argv, files, readStdin) {
+async function runQpdfCli(argv, files, readStdin, signal) {
+  signal?.throwIfAborted();
   const parsed = parseQpdfArguments(argv);
   if (parsed.result) return parsed.result;
   const { inputFile, pageSpecs, stampSpecs, addAttachmentSpecs, copyAttachmentsSpecs, updateFromJsonFiles } = parsed.options;
   const usesStdin = inputFile === "-" || updateFromJsonFiles.includes("-") || [...pageSpecs, ...stampSpecs, ...addAttachmentSpecs, ...copyAttachmentsSpecs].some((spec) => spec.file === "-");
   if (readStdin && usesStdin) await readStdin();
-  return executeQpdfCli(parsed.options, files);
+  const steps = executeQpdfCli(parsed.options, files);
+  try {
+    let step = steps.next();
+    while (!step.done) {
+      await yieldTurn(signal);
+      signal?.throwIfAborted();
+      step = steps.next();
+    }
+    return step.value;
+  } finally {
+    steps.return({ exitCode: 2, stdout: "", stderr: "" });
+  }
 }
 function parseQpdfArguments(argv) {
   let check = false;
@@ -44845,9 +44938,12 @@ function parseQpdfArguments(argv) {
 function runQpdfCliSync(argv, files) {
   const parsed = parseQpdfArguments(argv);
   if (parsed.result) return parsed.result;
-  return executeQpdfCli(parsed.options, files);
+  const steps = executeQpdfCli(parsed.options, files);
+  let step = steps.next();
+  while (!step.done) step = steps.next();
+  return step.value;
 }
-function executeQpdfCli(options, files) {
+function* executeQpdfCli(options, files) {
   const {
     check,
     showNpages,
@@ -44928,7 +45024,7 @@ function executeQpdfCli(options, files) {
       return { exitCode: 0, stdout: "", stderr: "" };
     }
     try {
-      parseCosDocument(raw, { password });
+      yield* parseCosDocumentSteps(raw, { password });
       return { exitCode: 3, stdout: "", stderr: "" };
     } catch {
       return { exitCode: 0, stdout: "", stderr: "" };
@@ -44956,12 +45052,12 @@ function executeQpdfCli(options, files) {
           return { exitCode: 2, stdout: "", stderr: `qpdf: ${inputFile}: missing trailer /Root
 ` };
         }
-        const rebuiltBytes = serializeCosDocument({
+        const rebuiltBytes = yield* serializeCosDocumentSteps({
           objects: [...objectsMap.values()],
           rootRef,
           infoRef
         });
-        baseDoc = PdfDocument.load(rebuiltBytes);
+        baseDoc = yield* PdfDocument.loadSteps(rebuiltBytes);
       } catch (err2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
         return { exitCode: 2, stdout: "", stderr: `qpdf: ${inputFile}: ${msg}
@@ -44969,10 +45065,10 @@ function executeQpdfCli(options, files) {
       }
     } else {
       try {
-        baseDoc = PdfDocument.load(raw, password !== void 0 ? { password } : {});
+        baseDoc = yield* PdfDocument.loadSteps(raw, password !== void 0 ? { password } : {});
       } catch {
         try {
-          baseDoc = PdfDocument.load(raw, {
+          baseDoc = yield* PdfDocument.loadSteps(raw, {
             ...password !== void 0 ? { password } : {},
             recovery: "repair"
           });
@@ -45003,12 +45099,12 @@ function executeQpdfCli(options, files) {
 ` };
       }
     }
-    const updatedBytes = serializeCosDocument({
+    const updatedBytes = yield* serializeCosDocumentSteps({
       objects: [...baseDoc.cos.objects.values()],
       rootRef: baseDoc.cos.rootRef,
       infoRef: baseDoc.cos.infoRef
     });
-    baseDoc = PdfDocument.load(updatedBytes);
+    baseDoc = yield* PdfDocument.loadSteps(updatedBytes);
   }
   if (showLinearization) {
     const cos = baseDoc.cos;
@@ -45316,13 +45412,14 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
     }
     const loadedSpecs = [];
     for (const spec of pageSpecs) {
+      yield;
       const srcBytes = loadBytes(spec.file);
       if (!srcBytes) {
         return { exitCode: 2, stdout: "", stderr: `qpdf: cannot open ${spec.file}
 ` };
       }
       const srcPw = spec.password ?? password;
-      const srcDoc = PdfDocument.load(srcBytes, srcPw !== void 0 ? { password: srcPw } : {});
+      const srcDoc = yield* PdfDocument.loadSteps(srcBytes, srcPw !== void 0 ? { password: srcPw } : {});
       const pageNumbers = parseQpdfPageRange(spec.range, srcDoc.getPageCount());
       loadedSpecs.push({ doc: srcDoc, indices: pageNumbers.map((p) => p - 1) });
     }
@@ -45336,7 +45433,7 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
           const cur = cursors[s];
           if (cur < item.indices.length) {
             const slice = item.indices.slice(cur, cur + collateCount);
-            mergedDoc.copyPagesFrom(item.doc, slice);
+            yield* mergedDoc.copyPagesFromSteps(item.doc, slice);
             cursors[s] = cur + slice.length;
             if (cursors[s] < item.indices.length) remaining = true;
           }
@@ -45344,7 +45441,7 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
       }
     } else {
       for (const item of loadedSpecs) {
-        mergedDoc.copyPagesFrom(item.doc, item.indices);
+        yield* mergedDoc.copyPagesFromSteps(item.doc, item.indices);
       }
     }
     workingDoc = mergedDoc;
@@ -45352,6 +45449,7 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
   for (const rot of rotateSpecs) {
     const pageNums = parseQpdfPageRange(rot.range, workingDoc.getPageCount());
     for (const pNum of pageNums) {
+      yield;
       const page = workingDoc.getPage(pNum - 1);
       if (rot.relative) {
         const current = page.getRotation();
@@ -45372,7 +45470,7 @@ extract for accessibility: ${enc.permissions.copy ? "allowed" : "not allowed"}
 ` };
     }
     const stampPw = stamp.password ?? password;
-    const stampDoc = PdfDocument.load(stampBytes, stampPw !== void 0 ? { password: stampPw } : {});
+    const stampDoc = yield* PdfDocument.loadSteps(stampBytes, stampPw !== void 0 ? { password: stampPw } : {});
     const fromPages = parseQpdfPageRange(stamp.fromRange, stampDoc.getPageCount());
     const toPages = parseQpdfPageRange(stamp.toRange, workingDoc.getPageCount());
     const repeatPages = stamp.repeatRange ? parseQpdfPageRange(stamp.repeatRange, stampDoc.getPageCount()) : fromPages;
@@ -45508,6 +45606,7 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
   if (flattenRotation) {
     const enc = new TextEncoder();
     for (const page of workingDoc.getPages()) {
+      yield;
       const rot = page.getRotation();
       if (rot === 90 || rot === 180 || rot === 270) {
         const { width: W, height: H } = page.getSize();
@@ -45576,6 +45675,7 @@ ${fmt6(s)} 0 0 ${fmt6(s)} ${fmt4(tx)} ${fmt4(ty)} cm
   if (flattenAnnotations !== false) {
     const enc = new TextEncoder();
     for (const page of workingDoc.getPages()) {
+      yield;
       const annotsNode = workingDoc.cos.resolve(dictGet(page.dict, "Annots"));
       const annotsArr = asArray(annotsNode);
       if (!annotsArr) continue;
@@ -45754,6 +45854,7 @@ Q
     };
     let extCounter = 1;
     for (const page of workingDoc.getPages()) {
+      yield;
       let modified = false;
       const pageRes = page.getResourcesDict();
       let xobjSub = asDict(workingDoc.cos.resolve(dictGet(pageRes, "XObject")));
@@ -45839,6 +45940,7 @@ Q
       "Properties"
     ];
     for (const page of workingDoc.getPages()) {
+      yield;
       const refNames = /* @__PURE__ */ new Set();
       collectPdfNamesFromBytes(page.getRawContentStream(), refNames);
       const annotsArr = asArray(workingDoc.cos.resolve(dictGet(page.dict, "Annots")));
@@ -45928,7 +46030,7 @@ Q
     }
   }
   if (generateAppearances && !removeAcroform) {
-    generateDocumentFormAppearances(workingDoc.cos);
+    yield* generateDocumentFormAppearancesSteps(workingDoc.cos);
   }
   if (removeInfo || removeMetadata || removeStructure || removeAcroform) {
     const rootDict = asDict(workingDoc.cos.resolve(workingDoc.cos.rootRef));
@@ -45957,12 +46059,13 @@ Q
     }
   }
   for (const copySpec of copyAttachmentsSpecs) {
+    yield;
     const srcBytes = loadBytes(copySpec.file);
     if (!srcBytes) {
       return { exitCode: 2, stdout: "", stderr: `qpdf: cannot open ${copySpec.file}
 ` };
     }
-    const srcDoc = PdfDocument.load(srcBytes, copySpec.password ? { password: copySpec.password } : {});
+    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(dictGet(srcRoot, "Names"))) : void 0;
     const srcEf = srcNames ? asDict(srcDoc.cos.resolve(dictGet(srcNames, "EmbeddedFiles"))) : void 0;
@@ -46092,6 +46195,7 @@ Q
         namesArr = asArray(dictGet(efTree, "Names"));
       }
       for (const addSpec of addAttachmentSpecs) {
+        yield;
         const attBytes = loadBytes(addSpec.file);
         if (!attBytes) {
           return { exitCode: 2, stdout: "", stderr: `qpdf: cannot open attachment ${addSpec.file}
@@ -46190,6 +46294,7 @@ Q
       return replaced ? out : void 0;
     };
     for (let startIdx = 0; startIdx < total; startIdx += splitPagesGroup) {
+      yield;
       const endIdx = Math.min(total - 1, startIdx + splitPagesGroup - 1);
       const subDoc = PdfDocument.create();
       if (wMeta.title) subDoc.setTitle(wMeta.title);
@@ -46198,24 +46303,24 @@ Q
       if (wMeta.keywords) subDoc.setKeywords(wMeta.keywords);
       const indices = [];
       for (let k = startIdx; k <= endIdx; k++) indices.push(k);
-      subDoc.copyPagesFrom(workingDoc, indices);
+      yield* subDoc.copyPagesFromSteps(workingDoc, indices);
       const sPad = String(startIdx + 1).padStart(padLen, "0");
       const ePad = String(endIdx + 1).padStart(padLen, "0");
       const suffix = splitPagesGroup === 1 ? sPad : `${sPad}-${ePad}`;
       const formattedSpec = formatSplitSpec(finalTarget, startIdx + 1, endIdx + 1);
       const splitName = formattedSpec ?? `${baseStem}-${suffix}.pdf`;
-      files.set(splitName, subDoc.save({ normalizeContent: qdf }));
+      files.set(splitName, yield* subDoc.saveSteps({ normalizeContent: qdf }));
     }
     return { exitCode: 0, stdout: "", stderr: "" };
   }
   const shouldNormalizeContent = normalizeContentFlag !== void 0 ? normalizeContentFlag : qdf || streamDataMode === "uncompress";
-  let outBytes = workingDoc.save({
+  let outBytes = yield* workingDoc.saveSteps({
     normalizeContent: shouldNormalizeContent,
     objectStreams: objectStreamsMode
   });
   if (encryptConfig && !decrypt2) {
-    const parsedOut = parseCosDocument(outBytes);
-    outBytes = encryptCosDocument(parsedOut, {
+    const parsedOut = yield* parseCosDocumentSteps(outBytes);
+    outBytes = yield* encryptCosDocumentSteps(parsedOut, {
       userPassword: encryptConfig.userPassword,
       ownerPassword: encryptConfig.ownerPassword,
       permissions: {
@@ -46228,7 +46333,7 @@ Q
   } else if (decrypt2 && workingDoc.cos.encryption) {
     workingDoc.cos.encryptRef = void 0;
     workingDoc.cos.encryption = void 0;
-    outBytes = serializeCosDocument({
+    outBytes = yield* serializeCosDocumentSteps({
       objects: [...workingDoc.cos.objects.values()],
       rootRef: workingDoc.cos.rootRef,
       infoRef: workingDoc.cos.infoRef
@@ -46237,12 +46342,20 @@ Q
   files.set(finalTarget, outBytes);
   return { exitCode: repairedWarning && !warningExit0 ? 3 : 0, stdout: "", stderr: "" };
 }
-async function qpdf(context) {
+async function qpdf(context, options = {}) {
+  const limits = resolveLimits(options);
+  let outputBytes = 0;
+  const chargeOutput = (bytes) => {
+    outputBytes += bytes;
+    if (outputBytes > limits.maxOutputBytes) throw new RangeError("Output byte limit exceeded");
+  };
   const invocation = createOutputOperation(context, { write: async () => {
   } });
   try {
     const carrier = getCommandArguments(context);
     const argv = [...carrier.args];
+    const argumentBytes = argv.reduce((total, arg) => total + new TextEncoder().encode(arg).byteLength + 1, 0);
+    if (argumentBytes > limits.maxArgumentBytes) throw new RangeError("Argument byte limit exceeded");
     const vfsFiles = /* @__PURE__ */ new Map();
     const resolveVfsPath = (p) => p.startsWith("/") ? p : `${context.cwd === "/" ? "" : context.cwd}/${p}`;
     let accountedBytes = 0;
@@ -46250,6 +46363,7 @@ async function qpdf(context) {
       if (delta > 0) {
         accountedBytes += delta;
         context.inputBudget?.check(accountedBytes);
+        if (accountedBytes > limits.maxInputBytes) throw new RangeError("Input byte limit exceeded");
       }
     };
     for (let i = 0; i < argv.length; i++) {
@@ -46270,39 +46384,49 @@ async function qpdf(context) {
       i += args.length - 1;
     }
     for (const token of argv) {
+      await yieldTurn(invocation.signal);
+      invocation.signal.throwIfAborted();
       let candidate = token;
-      if (token.startsWith("--overlay=") || token.startsWith("--underlay=") || token.startsWith("--update-from-json=")) {
+      if (token.startsWith("--overlay=") || token.startsWith("--underlay=") || token.startsWith("--add-attachment=") || token.startsWith("--copy-attachments-from=") || token.startsWith("--update-from-json=")) {
         candidate = token.slice(token.indexOf("=") + 1);
       } else if (token.startsWith("-") || token === "--" || token === ".") {
         continue;
       }
       const abs = resolveVfsPath(candidate);
+      let bytes;
       try {
-        const bytes = await context.fs.readFile(abs, { signal: invocation.signal });
-        chargeBytes(bytes.byteLength);
-        vfsFiles.set(candidate, bytes);
+        bytes = await context.fs.readFile(abs, { signal: invocation.signal });
       } catch {
+        invocation.signal.throwIfAborted();
+        continue;
       }
+      chargeBytes(bytes.byteLength);
+      vfsFiles.set(candidate, bytes);
     }
     if (argv.includes("--json-input") || argv.some((t) => t.startsWith("--update-from-json="))) {
       for (const fileBytes of [...vfsFiles.values()]) {
+        let parsed;
         try {
-          const parsed = JSON.parse(new TextDecoder().decode(fileBytes));
-          const objs = Array.isArray(parsed.qpdf) && typeof parsed.qpdf[1] === "object" ? parsed.qpdf[1] : typeof parsed.objects === "object" && parsed.objects !== null ? parsed.objects : void 0;
-          if (!objs) continue;
-          for (const entry of Object.values(objs)) {
-            if (typeof entry === "object" && entry !== null && "stream" in entry) {
-              const st = entry.stream;
-              if (st && typeof st.datafile === "string" && !vfsFiles.has(st.datafile)) {
-                const dfBytes = await context.fs.readFile(resolveVfsPath(st.datafile), {
-                  signal: invocation.signal
-                });
-                chargeBytes(dfBytes.byteLength);
-                vfsFiles.set(st.datafile, dfBytes);
-              }
-            }
-          }
+          parsed = JSON.parse(new TextDecoder().decode(fileBytes));
         } catch {
+          continue;
+        }
+        if (!parsed || typeof parsed !== "object") continue;
+        const objs = Array.isArray(parsed.qpdf) && typeof parsed.qpdf[1] === "object" ? parsed.qpdf[1] : typeof parsed.objects === "object" && parsed.objects !== null ? parsed.objects : void 0;
+        if (!objs) continue;
+        for (const entry of Object.values(objs)) {
+          if (typeof entry !== "object" || entry === null || !("stream" in entry)) continue;
+          const stream = entry.stream;
+          if (!stream || typeof stream.datafile !== "string" || vfsFiles.has(stream.datafile)) continue;
+          let bytes;
+          try {
+            bytes = await context.fs.readFile(resolveVfsPath(stream.datafile), { signal: invocation.signal });
+          } catch {
+            invocation.signal.throwIfAborted();
+            continue;
+          }
+          chargeBytes(bytes.byteLength);
+          vfsFiles.set(stream.datafile, bytes);
         }
       }
     }
@@ -46323,19 +46447,19 @@ async function qpdf(context) {
       }
       vfsFiles.set("-", bytes);
       existingSnap.set("-", bytes);
-    });
+    }, invocation.signal);
     if (res.stderr) {
       await writeBytes(context.stderr, new TextEncoder().encode(res.stderr), invocation.signal);
     }
     if (res.stdout) {
       const outBytes = new TextEncoder().encode(res.stdout);
-      chargeBytes(outBytes.byteLength);
+      chargeOutput(outBytes.byteLength);
       const stdout = invocation.child(context.stdout);
       await writeBytes(stdout.output, outBytes, invocation.signal);
     }
     for (const [fileKey, fileBytes] of vfsFiles.entries()) {
       if (existingSnap.get(fileKey) !== fileBytes) {
-        chargeBytes(fileBytes.byteLength);
+        chargeOutput(fileBytes.byteLength);
         if (fileKey === "-") {
           const stdout = invocation.child(context.stdout);
           await writeBytes(stdout.output, fileBytes, invocation.signal);
@@ -46350,13 +46474,13 @@ async function qpdf(context) {
     await invocation.close();
   }
 }
-function createQpdfCommand(_options = {}) {
+function createQpdfCommand(options = {}) {
   return Object.freeze({
     name: "qpdf",
     runtimeIdentity: commandRuntimeIdentity,
     description: "Structural PDF inspection, encryption, page selection, and transformation via @poe-code/pdf-ast",
     execute(context) {
-      return qpdf(context);
+      return qpdf(context, options);
     }
   });
 }