@poe-platform/safe-bash 0.1.787 → 0.1.789

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

@@ -387,6 +387,7 @@ var MMDC_HELP_TEXT = [
 
 // packages/safe-bash-command-mmdc/dist/command.js
 init_buffer();
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
 import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
 import { FsError } from "../safe-bash-contracts/errors.js";
@@ -7728,10 +7729,11 @@ function renderNode(node, fontFamily, monoFontFamily, index, idPrefix) {
   const linesSvg = node.lines.map((l) => renderTextLine(l, fontFamily, monoFontFamily)).join("");
   return `<g class="mmdc-node" data-id="${escapeXml(node.id)}">${shapeSvg}${dividersSvg}${badgesSvg}${linesSvg}</g>`;
 }
-function serializeSceneToSvg(scene, budget, svgId) {
+function* serializeSceneToSvgSteps(scene, budget, svgId) {
   const { theme } = scene;
   const idPrefix = svgId === void 0 ? "" : `svg-${Array.from(svgId, (ch) => ch.codePointAt(0).toString(16)).join("-")}-`;
   const parts = [];
+  let work = 0;
   parts.push(`<svg xmlns="http://www.w3.org/2000/svg"${svgId === void 0 ? "" : ` id="${escapeXml(svgId)}"`} width="${scene.width}" height="${scene.height}" viewBox="${scene.viewBox.x} ${scene.viewBox.y} ${scene.viewBox.width} ${scene.viewBox.height}" role="img">`);
   if (scene.title) {
     parts.push(`<title>${escapeXml(scene.title)}</title>`);
@@ -7744,6 +7746,8 @@ function serializeSceneToSvg(scene, budget, svgId) {
     parts.push(`<rect width="${scene.viewBox.width}" height="${scene.viewBox.height}" fill="${escapeXml(scene.backgroundColor)}"/>`);
   }
   for (const life of scene.lifelines) {
+    if (++work % 16 === 0)
+      yield;
     parts.push(`<line x1="${life.x}" y1="${life.y1}" x2="${life.x}" y2="${life.y2}" stroke="${escapeXml(life.stroke)}" stroke-width="1.25" stroke-dasharray="5 5"/>`);
   }
   scene.groups.forEach((group, idx) => {
@@ -7764,16 +7768,25 @@ function serializeSceneToSvg(scene, budget, svgId) {
     parts.push(`</g>`);
   });
   for (const act of scene.activations) {
+    if (++work % 16 === 0)
+      yield;
     parts.push(`<rect x="${act.x}" y="${act.y}" width="${act.width}" height="${act.height}" rx="2" fill="${escapeXml(act.fill)}" stroke="${escapeXml(act.stroke)}" stroke-width="1.25"/>`);
   }
   for (const edge of scene.edges) {
+    if (++work % 16 === 0)
+      yield;
     const dash = edge.lineStyle === "dotted" ? ` stroke-dasharray="5 4"` : "";
     parts.push(`<g class="mmdc-edge" data-id="${escapeXml(edge.id)}"><path d="${edge.d}" fill="none" stroke="${escapeXml(edge.stroke)}" stroke-width="${edge.strokeWidth}" stroke-linecap="round" stroke-linejoin="round"${dash}/>` + renderMarker(edge.startMarker) + renderMarker(edge.endMarker) + `</g>`);
   }
-  scene.nodes.forEach((node, idx) => {
+  for (let idx = 0; idx < scene.nodes.length; idx++) {
+    if (++work % 16 === 0)
+      yield;
+    const node = scene.nodes[idx];
     parts.push(renderNode(node, theme.fontFamily, theme.monospaceFontFamily, idx, idPrefix));
-  });
+  }
   for (const edge of scene.edges) {
+    if (++work % 16 === 0)
+      yield;
     if (edge.labelPill) {
       parts.push(renderPill(edge.labelPill, theme.fontFamily, theme.monospaceFontFamily));
     }
@@ -7785,6 +7798,8 @@ function serializeSceneToSvg(scene, budget, svgId) {
     }
   }
   for (const note of scene.notes) {
+    if (++work % 16 === 0)
+      yield;
     const filterAttr = note.shadow ? ` filter="url(#${idPrefix}mmdc-shadow)"` : "";
     const linesSvg = note.lines.map((l) => renderTextLine(l, theme.fontFamily, theme.monospaceFontFamily)).join("");
     parts.push(`<g class="mmdc-note" data-id="${escapeXml(note.id)}"><rect x="${note.x}" y="${note.y}" width="${note.width}" height="${note.height}" rx="${note.rx}" fill="${escapeXml(note.fill)}" stroke="${escapeXml(note.stroke)}" stroke-width="1.25"${filterAttr}/>` + linesSvg + `</g>`);
@@ -7794,6 +7809,13 @@ function serializeSceneToSvg(scene, budget, svgId) {
   budget?.chargeOutputBytes(encoder3.encode(svg).byteLength);
   return svg;
 }
+function serializeSceneToSvg(scene, budget, svgId) {
+  const steps = serializeSceneToSvgSteps(scene, budget, svgId);
+  let step = steps.next();
+  while (!step.done)
+    step = steps.next();
+  return step.value;
+}
 
 // packages/safe-bash-command-mmdc/dist/command.js
 var encoder4 = new TextEncoder();
@@ -7978,7 +8000,7 @@ function resolveRenderOptions(options) {
     } }
   };
 }
-function renderMermaidSvg(source, options) {
+function* renderMermaidSvgSteps(source, options) {
   options = resolveRenderOptions(options);
   const hostCeiling = options?.settings?.limits ? admitMermaidLimits(options.settings.limits, defaultMermaidLimits) : defaultMermaidLimits;
   const limits = admitMermaidLimits(options?.limits, hostCeiling);
@@ -7994,7 +8016,7 @@ function renderMermaidSvg(source, options) {
   if (!check.ok) {
     throw new MermaidError("E_LIMIT", `Scene geometry verification failed: ${check.violations[0] ?? "invalid geometry"}`);
   }
-  const svg = serializeSceneToSvg(scene, budget, options?.svgId);
+  const svg = yield* serializeSceneToSvgSteps(scene, budget, options?.svgId);
   return {
     svg,
     width: scene.width,
@@ -8004,6 +8026,13 @@ function renderMermaidSvg(source, options) {
     accounting: budget.snapshot()
   };
 }
+function renderMermaidSvg(source, options) {
+  const steps = renderMermaidSvgSteps(source, options);
+  let step = steps.next();
+  while (!step.done)
+    step = steps.next();
+  return step.value;
+}
 function renderMermaidPng(source, options) {
   options = resolveRenderOptions(options);
   const hostCeiling = options?.settings?.limits ? admitMermaidLimits(options.settings.limits, defaultMermaidLimits) : defaultMermaidLimits;
@@ -8276,7 +8305,8 @@ async function runMmdc(context, options = {}) {
         span: { offset: 0, line: 1, column: 1 }
       });
     }
-    await Promise.resolve();
+    await yieldTurn(signal);
+    signal.throwIfAborted();
     budget.check();
     const resolvedMode = cfgThemeMode ?? parsedArgs.theme ?? snapSettings.theme?.mode ?? "light";
     const mergedSettings = {
@@ -8305,15 +8335,23 @@ async function runMmdc(context, options = {}) {
     };
     let outputBytes;
     if (parsedArgs.outputFormat === "svg") {
-      const res = renderMermaidSvg(sourceText, renderOptions);
-      outputBytes = encoder4.encode(res.svg);
+      const steps = renderMermaidSvgSteps(sourceText, renderOptions);
+      let step = steps.next();
+      while (!step.done) {
+        await yieldTurn(signal);
+        signal.throwIfAborted();
+        step = steps.next();
+      }
+      outputBytes = encoder4.encode(step.value.svg);
     } else {
-      await Promise.resolve();
+      await yieldTurn(signal);
+      signal.throwIfAborted();
       budget.check();
       const res = renderMermaidPng(sourceText, renderOptions);
       outputBytes = res.png;
     }
-    await Promise.resolve();
+    await yieldTurn(signal);
+    signal.throwIfAborted();
     budget.check();
     if (outPath === "-") {
       await writeBytes(stdout.output, outputBytes, signal);

package/dist/safe-bash-command-mmdc/svg.d.ts

@@ -1,3 +1,4 @@
 import type { MermaidBudget, MermaidScene } from "./contracts.js";
 export declare function escapeXml(raw: string): string;
+export declare function serializeSceneToSvgSteps(scene: MermaidScene, budget?: MermaidBudget, svgId?: string): Generator<void, string>;
 export declare function serializeSceneToSvg(scene: MermaidScene, budget?: MermaidBudget, svgId?: string): string;

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

@@ -7,6 +7,7 @@ init_buffer();
 
 // packages/safe-bash-command-op/dist/cli.js
 init_buffer();
+import { InputByteBudget } from "../safe-bash-contracts/io.js";
 
 // packages/safe-bash-command-op/dist/encoding.js
 init_buffer();
@@ -3992,27 +3993,25 @@ function approvalManifest(request, requests, prepared, effects) {
   return freezeJson(manifest);
 }
 function createOpCommand(options = {}) {
-  const { backend = createObjectBackend(), authorize, approve, authorizeResolution, approveResolved, approvalMode = "resolved", version = "0.0.1", channel = "stable" } = options;
-  const inputLimits = { maxInputBytes: options.limits?.maxInputBytes ?? Infinity };
-  if (inputLimits.maxInputBytes !== Infinity && (!Number.isSafeInteger(inputLimits.maxInputBytes) || inputLimits.maxInputBytes < 1))
+  const maxInputBytes = options.limits?.maxInputBytes ?? Infinity;
+  if (maxInputBytes !== Infinity && (!Number.isSafeInteger(maxInputBytes) || maxInputBytes < 1))
     throw new RangeError("Invalid op limit: maxInputBytes");
+  const { backend = createObjectBackend(), authorize, approve, authorizeResolution, approveResolved, approvalMode = "resolved", version = "0.0.1", channel = "stable" } = options;
   const handlers = { ...options.handlers };
   const planners = new Map(Object.entries(handlers).flatMap(([key, handler]) => typeof handler.prepare === "function" ? [[key, handler.prepare.bind(handler)]] : []));
   return {
     name: "op",
     async execute(callerContext) {
+      const budget = new InputByteBudget(maxInputBytes);
       const context = {
         ...callerContext,
-        stdin: { async *[Symbol.asyncIterator]() {
-          let bytes = 0;
-          for await (const chunk of callerContext.stdin) {
-            callerContext.signal.throwIfAborted();
-            bytes += chunk.byteLength;
-            if (bytes > inputLimits.maxInputBytes)
-              throw new Error(`input exceeds maximum size of ${inputLimits.maxInputBytes} bytes`);
-            yield chunk;
-          }
-        } },
+        stdin: budget.read(callerContext.stdin, callerContext.signal),
+        ...callerContext.readFile ? { readFile: async (path) => {
+          budget.assertOpen();
+          const bytes = await callerContext.readFile(path);
+          budget.charge(bytes.byteLength);
+          return bytes;
+        } } : {},
         binding: void 0,
         args: Object.freeze([...callerContext.args]),
         env: Object.freeze({ ...callerContext.env }),
@@ -4196,7 +4195,13 @@ function createOpCommand(options = {}) {
         }
         return { exitCode: 0 };
       } catch (error) {
-        await original.stderr.write(new TextEncoder().encode(`op: ${context.signal.aborted ? "operation aborted" : error instanceof Error ? error.message : "operation failed"}
+        let message = error instanceof Error ? error.message : "operation failed";
+        try {
+          budget.assertOpen();
+        } catch {
+          message = `input exceeds maximum size of ${maxInputBytes} bytes`;
+        }
+        await original.stderr.write(new TextEncoder().encode(`op: ${context.signal.aborted ? "operation aborted" : message}
 `));
         return { exitCode: context.signal.aborted ? 130 : 1 };
       } finally {

package/dist/safe-bash-command-pandoc/command.js

@@ -2,7 +2,7 @@ import {
   createPandocCommand,
   createPandocCommands,
   pandocCommands
-} from "../safe-bash/command-chunks/chunk-FXYWQ6S4.js";
+} from "../safe-bash/command-chunks/chunk-2VTMZTV3.js";
 import "../safe-bash/command-chunks/chunk-MKQVQMXO.js";
 import "../safe-bash/command-chunks/chunk-RDV7UCYZ.js";
 import "../safe-bash/command-chunks/chunk-5GRLAARV.js";

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

@@ -21,7 +21,7 @@ import {
   readDocument,
   resolveConversionArgs,
   writeDocument
-} from "../safe-bash/command-chunks/chunk-FXYWQ6S4.js";
+} from "../safe-bash/command-chunks/chunk-2VTMZTV3.js";
 import "../safe-bash/command-chunks/chunk-MKQVQMXO.js";
 import "../safe-bash/command-chunks/chunk-RDV7UCYZ.js";
 import "../safe-bash/command-chunks/chunk-5GRLAARV.js";

package/dist/safe-bash-command-pdfimages/index.d.ts

@@ -1,6 +1,10 @@
 import { type CommandDefinition } from "../safe-bash-contracts/command.js";
 import type { VirtualShellPlugin } from "../safe-bash-contracts/plugin.js";
+export interface PdfimagesLimits {
+    readonly maxInputBytes: number;
+}
 export interface PdfimagesCommandOptions {
+    readonly limits?: Partial<PdfimagesLimits>;
     readonly replace?: boolean;
 }
 export interface PdfimagesCliResult {
@@ -9,12 +13,14 @@ export interface PdfimagesCliResult {
     readonly stderr: string;
 }
 export declare function runPdfimagesCli(argv: readonly string[], files: Map<string, Uint8Array>, options?: {
+    readonly signal?: AbortSignal;
     readonly onAllocateBytes?: (bytes: number) => void;
 }): Promise<PdfimagesCliResult>;
 export declare function runPdfimagesCliSync(argv: readonly string[], files: Map<string, Uint8Array>, options?: {
+    readonly signal?: AbortSignal;
     readonly onAllocateBytes?: (bytes: number) => void;
 }): PdfimagesCliResult;
-export declare function createPdfimagesCommand(_options?: PdfimagesCommandOptions): CommandDefinition;
+export declare function createPdfimagesCommand(options?: PdfimagesCommandOptions): CommandDefinition;
 export declare const pdfimagesCommand: CommandDefinition;
 export declare function pdfimagesPlugin(options?: PdfimagesCommandOptions): VirtualShellPlugin;
 export declare const pdfimagesCommands: typeof pdfimagesPlugin;

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

@@ -4,6 +4,8 @@ import {
 
 // packages/safe-bash-command-pdfimages/dist/index.js
 init_buffer();
+import { yieldTurn, drainCooperativeSteps as drainSteps } from "../safe-bash-contracts/yield.js";
+import { InputByteBudget } from "../safe-bash-contracts/io.js";
 import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 import {
   commandRuntimeIdentity,
@@ -44292,10 +44294,8 @@ function extractPdfimagesPositionals(argv) {
   }
   return pos;
 }
-async function runPdfimagesCli(argv, files, options = {}) {
-  return runPdfimagesCliSync(argv, files, options);
-}
-function runPdfimagesCliSync(argv, files, options = {}) {
+function* runPdfimagesCliSteps(argv, files, options = {}) {
+  let cooperativeWork = 63;
   let listOnly = false;
   let usePng = false;
   let useJpeg = false;
@@ -44312,6 +44312,8 @@ function runPdfimagesCliSync(argv, files, options = {}) {
   let password = "";
   const positionals = [];
   for (let i = 0; i < argv.length; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const arg = argv[i];
     if (arg === "-v" || arg === "--version") {
       return { exitCode: 0, stdout: "pdfimages version 24.08.0\n", stderr: "" };
@@ -44323,23 +44325,34 @@ function runPdfimagesCliSync(argv, files, options = {}) {
         stderr: ""
       };
     }
-    if (arg === "-list") listOnly = true;
-    else if (arg === "-png") usePng = true;
-    else if (arg === "-j") useJpeg = true;
-    else if (arg === "-tiff") useTiff = true;
-    else if (arg === "-jp2") useJp2 = true;
-    else if (arg === "-jbig2") useJbig2 = true;
-    else if (arg === "-ccitt") useCcitt = true;
+    if (arg === "-list")
+      listOnly = true;
+    else if (arg === "-png")
+      usePng = true;
+    else if (arg === "-j")
+      useJpeg = true;
+    else if (arg === "-tiff")
+      useTiff = true;
+    else if (arg === "-jp2")
+      useJp2 = true;
+    else if (arg === "-jbig2")
+      useJbig2 = true;
+    else if (arg === "-ccitt")
+      useCcitt = true;
     else if (arg === "-all") {
       usePng = true;
       useJpeg = true;
       useJp2 = true;
       useJbig2 = true;
       useCcitt = true;
-    } else if (arg === "-p") includePage = true;
-    else if (arg === "-u") uniqueOnly = true;
-    else if (arg === "-print-filenames") printFilenames = true;
-    else if (arg === "-q") quiet = true;
+    } else if (arg === "-p")
+      includePage = true;
+    else if (arg === "-u")
+      uniqueOnly = true;
+    else if (arg === "-print-filenames")
+      printFilenames = true;
+    else if (arg === "-q")
+      quiet = true;
     else if (arg === "-f") {
       firstPage = Math.max(1, Number.parseInt(argv[++i] ?? "1", 10) || 1);
     } else if (arg === "-l") {
@@ -44382,9 +44395,11 @@ function runPdfimagesCliSync(argv, files, options = {}) {
   });
   const seenObjectIds = /* @__PURE__ */ new Set();
   const extracted = uniqueOnly ? allExtracted.filter((img) => {
-    if (img.inline || !img.objectId) return true;
+    if (img.inline || !img.objectId)
+      return true;
     const key = `${img.objectId.objNum}:${img.objectId.genNum}`;
-    if (seenObjectIds.has(key)) return false;
+    if (seenObjectIds.has(key))
+      return false;
     seenObjectIds.add(key);
     return true;
   }) : allExtracted;
@@ -44395,22 +44410,16 @@ function runPdfimagesCliSync(argv, files, options = {}) {
   const root = positionals[1] ?? "image";
   const printedFilenames = [];
   for (let idx = 0; idx < extracted.length; idx++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     const img = extracted[idx];
     const numStr = String(idx).padStart(3, "0");
     const objField = img.inline || !img.objectId ? "  [inline]" : `${String(img.objectId.objNum).padStart(6)} ${String(img.objectId.genNum).padStart(2)}`;
     const sizeStr = formatPopplerSize(img.byteLength).padStart(5);
-    const ratioStr = formatPopplerRatio(
-      img.byteLength,
-      img.width,
-      img.height,
-      img.components,
-      img.bitsPerComponent
-    ).padStart(5);
+    const ratioStr = formatPopplerRatio(img.byteLength, img.width, img.height, img.components, img.bitsPerComponent).padStart(5);
     const interpStr = (img.interpolate ? "yes" : "no").padStart(6);
     const colorCol = (img.colorSpaceLabel ?? img.colorSpace).padEnd(5);
-    listLines.push(
-      `${String(img.pageNumber).padStart(4)} ${String(idx).padStart(5)} ${img.type.padEnd(6)} ${String(img.width).padStart(5)} ${String(img.height).padStart(6)} ${colorCol} ${String(img.components).padStart(4)} ${String(img.bitsPerComponent).padStart(3)}  ${img.encoding.padEnd(5)} ${interpStr} ${objField} ${String(img.xPpi).padStart(5)} ${String(img.yPpi).padStart(5)} ${sizeStr} ${ratioStr}`
-    );
+    listLines.push(`${String(img.pageNumber).padStart(4)} ${String(idx).padStart(5)} ${img.type.padEnd(6)} ${String(img.width).padStart(5)} ${String(img.height).padStart(6)} ${colorCol} ${String(img.components).padStart(4)} ${String(img.bitsPerComponent).padStart(3)}  ${img.encoding.padEnd(5)} ${interpStr} ${objField} ${String(img.xPpi).padStart(5)} ${String(img.yPpi).padStart(5)} ${sizeStr} ${ratioStr}`);
     if (!listOnly) {
       let ext;
       let outBytes;
@@ -44445,7 +44454,8 @@ function runPdfimagesCliSync(argv, files, options = {}) {
       if (ext === "jb2e" && img.jbig2GlobalsBytes) {
         const jb2gName = includePage ? `${root}-${String(img.pageNumber).padStart(3, "0")}-${numStr}.jb2g` : `${root}-${numStr}.jb2g`;
         files.set(jb2gName, img.jbig2GlobalsBytes);
-        if (printFilenames) printedFilenames.push(jb2gName);
+        if (printFilenames)
+          printedFilenames.push(jb2gName);
       }
       if (ext === "ccitt") {
         const paramsBase = includePage ? `${root}-${String(img.pageNumber).padStart(3, "0")}-${numStr}.params` : `${root}-${numStr}.params`;
@@ -44460,9 +44470,11 @@ function runPdfimagesCliSync(argv, files, options = {}) {
         ].join(" ");
         files.set(paramsBase, new TextEncoder().encode(`${extraFlags}
 `));
-        if (printFilenames) printedFilenames.push(paramsBase);
+        if (printFilenames)
+          printedFilenames.push(paramsBase);
       }
-      if (printFilenames) printedFilenames.push(outName);
+      if (printFilenames)
+        printedFilenames.push(outName);
     }
   }
   if (listOnly) {
@@ -44473,7 +44485,19 @@ function runPdfimagesCliSync(argv, files, options = {}) {
   }
   return { exitCode: 0, stdout: "", stderr: "" };
 }
+async function runPdfimagesCli(argv, files, options = {}) {
+  return drainSteps(runPdfimagesCliSteps(argv, files, options), options.signal);
+}
+function runPdfimagesCliSync(argv, files, options = {}) {
+  const steps = runPdfimagesCliSteps(argv, files, options);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
+}
 async function executePdfimages(context) {
+  let cooperativeWork = 63;
   const invocation = createOutputOperation(context, { write: async () => {
   } });
   try {
@@ -44493,6 +44517,7 @@ async function executePdfimages(context) {
       const chunks = [];
       let total = 0;
       for await (const chunk of readBytes(context.stdin, invocation.signal)) {
+        if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
         chunks.push(chunk);
         total += chunk.byteLength;
         chargeBytes(chunk.byteLength);
@@ -44501,6 +44526,7 @@ async function executePdfimages(context) {
         const buf = new Uint8Array(total);
         let off = 0;
         for (const c of chunks) {
+          if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
           buf.set(c, off);
           off += c.byteLength;
         }
@@ -44508,6 +44534,7 @@ async function executePdfimages(context) {
       }
     }
     for (const token of positionals) {
+      if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (token === "-") continue;
       try {
         const bytes = await context.fs.readFile(resolveVfsPath(token), { signal: invocation.signal });
@@ -44516,8 +44543,9 @@ async function executePdfimages(context) {
       } catch {
       }
     }
+    context.inputBudget?.check(0);
     const existingSnap = new Map(vfsFiles);
-    const res = await runPdfimagesCli(argv, vfsFiles, { onAllocateBytes: chargeBytes });
+    const res = await runPdfimagesCli(argv, vfsFiles, { onAllocateBytes: chargeBytes, signal: invocation.signal });
     if (res.stderr) {
       await writeBytes(context.stderr, new TextEncoder().encode(res.stderr), invocation.signal);
     }
@@ -44526,6 +44554,7 @@ async function executePdfimages(context) {
       await writeBytes(stdout.output, new TextEncoder().encode(res.stdout), invocation.signal);
     }
     for (const [key, val] of vfsFiles.entries()) {
+      if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (key !== "-" && existingSnap.get(key) !== val) {
         const abs = resolveVfsPath(key);
         const parentDir = abs.slice(0, abs.lastIndexOf("/")) || "/";
@@ -44541,13 +44570,14 @@ async function executePdfimages(context) {
     await invocation.close();
   }
 }
-function createPdfimagesCommand(_options = {}) {
+function createPdfimagesCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "pdfimages",
     runtimeIdentity: commandRuntimeIdentity,
     description: "List and extract embedded images from PDF pages via @poe-code/pdf-ast",
     execute(context) {
-      return executePdfimages(context);
+      return new InputByteBudget(maxInputBytes).run(context, executePdfimages);
     }
   });
 }

package/dist/safe-bash-command-pdfinfo/index.d.ts

@@ -1,6 +1,10 @@
 import { type CommandContext, type CommandDefinition } from "../safe-bash-contracts/command.js";
 import type { VirtualShellPlugin } from "../safe-bash-contracts/plugin.js";
+export interface PdfinfoLimits {
+    readonly maxInputBytes: number;
+}
 export interface PdfinfoCommandOptions {
+    readonly limits?: Partial<PdfinfoLimits>;
     readonly replace?: boolean;
 }
 export interface PdfinfoInspectionOptions {
@@ -13,72 +17,72 @@ export interface PdfinfoCliResult {
     readonly stderr: string;
 }
 export declare function inspectPdfBytes(bytes: Uint8Array, argv?: readonly string[], options?: PdfinfoInspectionOptions): PdfinfoCliResult;
-export declare function runPdfinfoCli(argv: readonly string[], files: ReadonlyMap<string, Uint8Array>, stdinBytes?: Uint8Array): Promise<PdfinfoCliResult>;
+export declare function runPdfinfoCli(argv: readonly string[], files: ReadonlyMap<string, Uint8Array>, stdinBytes?: Uint8Array, signal?: AbortSignal): Promise<PdfinfoCliResult>;
 export declare function pdfinfo(context: CommandContext): Promise<{
     exitCode: number;
 }>;
-export declare function createPdfinfoCommand(_options?: PdfinfoCommandOptions): CommandDefinition;
+export declare function createPdfinfoCommand(options?: PdfinfoCommandOptions): CommandDefinition;
 export declare const pdfinfoCommand: CommandDefinition;
-export declare function runPdftoppmCli(argv: readonly string[], files: Map<string, Uint8Array>): Promise<{
+export declare function runPdftoppmCli(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): Promise<{
     exitCode: number;
     stdout: string;
     stderr: string;
     stdoutBytes?: Uint8Array;
 }>;
-export declare function runPdfimagesCli(argv: readonly string[], files: Map<string, Uint8Array>): Promise<{
+export declare function runPdfimagesCli(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): Promise<{
     exitCode: number;
     stdout: string;
     stderr: string;
 }>;
-export declare function runPdfuniteCli(argv: readonly string[], files: Map<string, Uint8Array>): Promise<{
+export declare function runPdfuniteCli(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): Promise<{
     exitCode: number;
     stdout: string;
     stderr: string;
 }>;
-export declare function runPdfseparateCli(argv: readonly string[], files: Map<string, Uint8Array>): Promise<{
+export declare function runPdfseparateCli(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): Promise<{
     exitCode: number;
     stdout: string;
     stderr: string;
 }>;
-export declare function runPdffontsCli(argv: readonly string[], files: Map<string, Uint8Array>): Promise<{
+export declare function runPdffontsCli(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): Promise<{
     exitCode: number;
     stdout: string;
     stderr: string;
 }>;
-export declare function runPdffontsCliSync(argv: readonly string[], files: Map<string, Uint8Array>): {
+export declare function runPdffontsCliSync(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): {
     exitCode: number;
     stdout: string;
     stderr: string;
 };
-export declare function runPdfdetachCliSync(argv: readonly string[], files: Map<string, Uint8Array>): {
+export declare function runPdfdetachCli(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): Promise<{
     exitCode: number;
     stdout: string;
     stderr: string;
-};
-export declare function runPdfdetachCli(argv: readonly string[], files: Map<string, Uint8Array>): Promise<{
+}>;
+export declare function runPdfdetachCliSync(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): {
     exitCode: number;
     stdout: string;
     stderr: string;
-}>;
-export declare function createPdftoppmCommand(_options?: PdfinfoCommandOptions): CommandDefinition;
+};
+export declare function createPdftoppmCommand(options?: PdfinfoCommandOptions): CommandDefinition;
 export declare const pdftoppmCommand: CommandDefinition;
-export declare function createPdfimagesCommand(_options?: PdfinfoCommandOptions): CommandDefinition;
+export declare function createPdfimagesCommand(options?: PdfinfoCommandOptions): CommandDefinition;
 export declare const pdfimagesCommand: CommandDefinition;
-export declare function createPdfuniteCommand(_options?: PdfinfoCommandOptions): CommandDefinition;
+export declare function createPdfuniteCommand(options?: PdfinfoCommandOptions): CommandDefinition;
 export declare const pdfuniteCommand: CommandDefinition;
-export declare function createPdfseparateCommand(_options?: PdfinfoCommandOptions): CommandDefinition;
+export declare function createPdfseparateCommand(options?: PdfinfoCommandOptions): CommandDefinition;
 export declare const pdfseparateCommand: CommandDefinition;
-export declare function createPdffontsCommand(_options?: PdfinfoCommandOptions): CommandDefinition;
+export declare function createPdffontsCommand(options?: PdfinfoCommandOptions): CommandDefinition;
 export declare const pdffontsCommand: CommandDefinition;
-export declare function createPdfdetachCommand(_options?: PdfinfoCommandOptions): CommandDefinition;
+export declare function createPdfdetachCommand(options?: PdfinfoCommandOptions): CommandDefinition;
 export declare const pdfdetachCommand: CommandDefinition;
-export declare function runPdftocairoCli(argv: readonly string[], files: Map<string, Uint8Array>): Promise<{
+export declare function runPdftocairoCli(argv: readonly string[], files: Map<string, Uint8Array>, signal?: AbortSignal): Promise<{
     exitCode: number;
     stdout: string;
     stderr: string;
     stdoutBytes?: Uint8Array;
 }>;
-export declare function createPdftocairoCommand(_options?: PdfinfoCommandOptions): CommandDefinition;
+export declare function createPdftocairoCommand(options?: PdfinfoCommandOptions): CommandDefinition;
 export declare const pdftocairoCommand: CommandDefinition;
 export declare function pdfinfoCommands(options?: PdfinfoCommandOptions): VirtualShellPlugin;
 export type PdfinfoCommandsOptions = PdfinfoCommandOptions;