@poe-platform/safe-bash 0.1.787 → 0.1.789

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

@@ -4,6 +4,8 @@ import {
 
 // packages/safe-bash-command-pdftotext/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,
@@ -44895,7 +44897,7 @@ function renderTsv(pages, args) {
   }
   return rows.join("\n") + "\n";
 }
-function extractPdfToTextBytes(bytes, argv = []) {
+function* extractPdfToTextBytesSteps(bytes, argv = []) {
   const args = parseArgs(argv);
   const stderrParts = [];
   if (args.invalidEolWarning) {
@@ -44974,12 +44976,14 @@ ${[...SUPPORTED_ENCODINGS].join("\n")}
   const mode = args.raw ? "raw" : args.layout ? "layout" : "logical";
   const pages = [];
   for (let p = firstPage; p <= lastPage; p++) {
+    yield;
     const page = doc.getPage(p - 1);
     let pageCropBoxPt;
     if (args.cropbox) {
       let cur = page.pageDict;
       const visited = /* @__PURE__ */ new Set();
       while (cur && !visited.has(cur)) {
+        yield;
         visited.add(cur);
         const cb = doc.cos.resolveArray(dictGet(cur, "CropBox"));
         if (cb && cb.items.length >= 4) {
@@ -45058,6 +45062,7 @@ ${escapeXml(tsvText)}</pre>
   const eolChar = args.eol === "dos" ? "\r\n" : args.eol === "mac" ? "\r" : "\n";
   let textOut = "";
   for (const { pageNumber, extracted } of pages) {
+    yield;
     let pageText = formatExtractedPageText(extracted, {
       mode,
       rejoinHyphens: mode === "logical" && args.removeHyphens,
@@ -45069,6 +45074,7 @@ ${escapeXml(tsvText)}</pre>
       const annots = extractPageAnnotations(doc.cos, doc.getPage(pageNumber - 1).pageDict);
       const uris = [];
       for (const ann of annots) {
+        yield;
         if (ann.uri && !pageText.includes(ann.uri) && !uris.includes(ann.uri)) {
           uris.push(ann.uri);
         }
@@ -45123,14 +45129,34 @@ ${escapeXml(textOut)}</pre>
     outputPath: args.outputFile ?? "-"
   };
 }
-async function runPdftotextCli(argv, files, stdinBytes = new Uint8Array(0)) {
+function extractPdfToTextBytes(bytes, argv = []) {
+  const steps = extractPdfToTextBytesSteps(bytes, argv);
+  for (; ; ) {
+    const step = steps.next();
+    if (step.done) return step.value;
+  }
+}
+function* extractPdfToTextBytesCooperativelySteps(bytes, argv = [], signal) {
+  const steps = extractPdfToTextBytesSteps(bytes, argv);
+  try {
+    for (; ; ) {
+      yield;
+      const step = steps.next();
+      if (step.done)
+        return step.value;
+    }
+  } finally {
+    steps.return({ exitCode: 1, output: "", stderr: "", outputPath: "-" });
+  }
+}
+function* runPdftotextCliSteps(argv, files, stdinBytes = new Uint8Array(0), signal) {
   const args = parseArgs(argv);
   if (args.error || args.listenc || args.version || args.help) {
-    return extractPdfToTextBytes(new Uint8Array(0), argv);
+    return yield* extractPdfToTextBytesCooperativelySteps(new Uint8Array(0), argv, signal);
   }
   const target = args.inputFile ?? "-";
   if (target === "-") {
-    return extractPdfToTextBytes(stdinBytes, argv);
+    return yield* extractPdfToTextBytesCooperativelySteps(stdinBytes, argv, signal);
   }
   const fileBytes = files.get(target);
   if (!fileBytes) {
@@ -45142,9 +45168,13 @@ async function runPdftotextCli(argv, files, stdinBytes = new Uint8Array(0)) {
       outputPath: args.outputFile ?? "-"
     };
   }
-  return extractPdfToTextBytes(fileBytes, argv);
+  return yield* extractPdfToTextBytesCooperativelySteps(fileBytes, argv, signal);
+}
+async function runPdftotextCli(argv, files, stdinBytes = new Uint8Array(0), signal) {
+  return drainSteps(runPdftotextCliSteps(argv, files, stdinBytes, signal), signal);
 }
 async function pdftotext(context) {
+  let cooperativeWork = 63;
   const invocation = createOutputOperation(context, { write: async () => {
   } });
   try {
@@ -45152,7 +45182,7 @@ async function pdftotext(context) {
     const argv = [...carrier.args];
     const parsed = parseArgs(argv);
     if (parsed.error || parsed.listenc || parsed.version || parsed.help) {
-      const res2 = extractPdfToTextBytes(new Uint8Array(0), argv);
+      const res2 = await drainSteps(extractPdfToTextBytesCooperativelySteps(new Uint8Array(0), argv, invocation.signal), invocation.signal);
       if (res2.stderr) {
         await writeBytes(context.stderr, new TextEncoder().encode(res2.stderr), invocation.signal);
       }
@@ -45175,6 +45205,7 @@ async function pdftotext(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);
@@ -45182,6 +45213,7 @@ async function pdftotext(context) {
       pdfBytes = new Uint8Array(total);
       let offset = 0;
       for (const c of chunks) {
+        if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
         pdfBytes.set(c, offset);
         offset += c.byteLength;
       }
@@ -45199,7 +45231,7 @@ async function pdftotext(context) {
         return { exitCode: 1 };
       }
     }
-    const res = extractPdfToTextBytes(pdfBytes, argv);
+    const res = await drainSteps(extractPdfToTextBytesCooperativelySteps(pdfBytes, argv, invocation.signal), invocation.signal);
     if (res.stderr) {
       await writeBytes(context.stderr, new TextEncoder().encode(res.stderr), invocation.signal);
     }
@@ -45229,13 +45261,14 @@ async function pdftotext(context) {
     await invocation.close();
   }
 }
-function createPdftotextCommand(_options = {}) {
+function createPdftotextCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "pdftotext",
     runtimeIdentity: commandRuntimeIdentity,
     description: "Extract PDF text, layout, XHTML bounding boxes, and TSV via @poe-code/pdf-ast",
     execute(context) {
-      return pdftotext(context);
+      return new InputByteBudget(maxInputBytes).run(context, pdftotext);
     }
   });
 }
@@ -45258,10 +45291,8 @@ function bytesToBase64(bytes) {
   }
   return out;
 }
-async function runPdftohtmlCli(argv, files) {
-  return runPdftohtmlCliSync(argv, files);
-}
-function runPdftohtmlCliSync(argv, files) {
+function* runPdftohtmlCliSteps(argv, files, signal) {
+  let cooperativeWork = 63;
   let xmlMode = false;
   let toStdout = false;
   let ignoreImages = false;
@@ -45274,6 +45305,8 @@ function runPdftohtmlCliSync(argv, files) {
   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: "pdftohtml version 24.08.0\n", stderr: "" };
@@ -45343,6 +45376,7 @@ function runPdftohtmlCliSync(argv, files) {
   }
   const pageRefToNum = /* @__PURE__ */ new Map();
   for (let i = 0; i < doc.pageCount; i++) {
+    yield;
     pageRefToNum.set(doc.getPage(i).ref.objectNumber, i + 1);
   }
   const resolveOutlineDestPage = (itemDict) => {
@@ -45354,11 +45388,13 @@ function runPdftohtmlCliSync(argv, files) {
     let cur = firstNode;
     while (cur) {
       if (cur.kind === "ref") {
-        if (visited.has(cur.objectNumber)) break;
+        if (visited.has(cur.objectNumber))
+          break;
         visited.add(cur.objectNumber);
       }
       const dict = doc.cos.resolveDict(cur);
-      if (!dict) break;
+      if (!dict)
+        break;
       const tNode = doc.cos.resolve(dictGet(dict, "Title"));
       const title = tNode?.kind === "string" ? decodePdfString(tNode) : "";
       const pageNumber = resolveOutlineDestPage(dict);
@@ -45381,6 +45417,7 @@ function runPdftohtmlCliSync(argv, files) {
       `<pdf2xml producer="@poe-code/pdf-ast" version="24.08.0">`
     ];
     for (let p = firstPage; p <= endPage; p++) {
+      yield;
       const page = doc.getPage(p - 1);
       const { width, height } = page.getSize();
       const extracted = page.extractPage();
@@ -45391,6 +45428,8 @@ function runPdftohtmlCliSync(argv, files) {
       const fontSubDict = resDict ? doc.cos.resolveDict(dictGet(resDict, "Font")) : void 0;
       if (fontSubDict) {
         for (const entry of fontSubDict.entries) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           const fDict = doc.cos.resolveDict(entry.value);
           const bfNode = fDict ? doc.cos.resolve(dictGet(fDict, "BaseFont") ?? dictGet(fDict, "Name")) : void 0;
           if (bfNode?.kind === "name") {
@@ -45408,6 +45447,7 @@ function runPdftohtmlCliSync(argv, files) {
       lines.push(`  <page number="${p}" position="absolute" top="0" left="0" height="${Math.round(height * zoom)}" width="${Math.round(width * zoom)}">`);
       const imageLines = [];
       for (let imgIdx = 0; imgIdx < pageImages.length; imgIdx++) {
+        yield;
         const img = pageImages[imgIdx];
         const imgBytes = imageFmt === "jpg" ? encodeJpeg(img.bitmap) : encodePng(img.bitmap);
         const imgFile = `page${p}_${imgIdx + 1}.${imageFmt}`;
@@ -45420,7 +45460,11 @@ function runPdftohtmlCliSync(argv, files) {
       }
       const textLines = [];
       for (const block of extracted.blocks) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         for (const line of block.lines) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           const [x0, y0, x1, y1] = line.bbox;
           const top = Math.max(0, Math.round((height - y1) * zoom));
           const left = Math.max(0, Math.round(x0 * zoom));
@@ -45436,13 +45480,9 @@ function runPdftohtmlCliSync(argv, files) {
           if (specId === void 0) {
             specId = fontSpecIdByKey.size;
             fontSpecIdByKey.set(specKey, specId);
-            fontSpecLines.push(
-              `    <fontspec id="${specId}" size="${scaledSize}" family="${escapeHtmlXml(family)}" color="#000000"/>`
-            );
+            fontSpecLines.push(`    <fontspec id="${specId}" size="${scaledSize}" family="${escapeHtmlXml(family)}" color="#000000"/>`);
           }
-          const matchingLink = annots.find(
-            (a) => a.uri && Math.min(x1, Math.max(a.rect[0], a.rect[2])) > Math.max(x0, Math.min(a.rect[0], a.rect[2])) && Math.min(y1, Math.max(a.rect[1], a.rect[3])) > Math.max(y0, Math.min(a.rect[1], a.rect[3]))
-          );
+          const matchingLink = annots.find((a) => a.uri && Math.min(x1, Math.max(a.rect[0], a.rect[2])) > Math.max(x0, Math.min(a.rect[0], a.rect[2])) && Math.min(y1, Math.max(a.rect[1], a.rect[3])) > Math.max(y0, Math.min(a.rect[1], a.rect[3])));
           let styledText = escapeHtmlXml(line.text);
           const lowerFam = family.toLowerCase();
           if (lowerFam.includes("italic") || lowerFam.includes("oblique")) {
@@ -45483,6 +45523,7 @@ function runPdftohtmlCliSync(argv, files) {
       `<body>`
     ];
     for (let p = firstPage; p <= endPage; p++) {
+      yield;
       const page = doc.getPage(p - 1);
       const { width, height } = page.getSize();
       const extracted = page.extractPage();
@@ -45490,6 +45531,7 @@ function runPdftohtmlCliSync(argv, files) {
       const pageImages = ignoreImages ? [] : extractDocumentImages(doc.cos, { firstPage: p, lastPage: p });
       lines.push(`<div class="page" id="page${p}" style="position:relative;width:${Math.round(width * zoom)}pt;height:${Math.round(height * zoom)}pt;">`);
       for (let imgIdx = 0; imgIdx < pageImages.length; imgIdx++) {
+        yield;
         const img = pageImages[imgIdx];
         const imgBytes = imageFmt === "jpg" ? encodeJpeg(img.bitmap) : encodePng(img.bitmap);
         const imgFile = `page${p}_${imgIdx + 1}.${imageFmt}`;
@@ -45501,13 +45543,15 @@ function runPdftohtmlCliSync(argv, files) {
         lines.push(`  <img src="${src}" width="${img.width}" height="${img.height}"/>`);
       }
       for (const block of extracted.blocks) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         for (const line of block.lines) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           const [x0, y0, x1, y1] = line.bbox;
           const top = Math.max(0, Math.round((height - y1) * zoom));
           const left = Math.max(0, Math.round(x0 * zoom));
-          const matchingLink = annots.find(
-            (a) => a.uri && Math.min(x1, Math.max(a.rect[0], a.rect[2])) > Math.max(x0, Math.min(a.rect[0], a.rect[2])) && Math.min(y1, Math.max(a.rect[1], a.rect[3])) > Math.max(y0, Math.min(a.rect[1], a.rect[3]))
-          );
+          const matchingLink = annots.find((a) => a.uri && Math.min(x1, Math.max(a.rect[0], a.rect[2])) > Math.max(x0, Math.min(a.rect[0], a.rect[2])) && Math.min(y1, Math.max(a.rect[1], a.rect[3])) > Math.max(y0, Math.min(a.rect[1], a.rect[3])));
           const firstWord = line.words[0];
           const rawFontName = firstWord?.fontName ?? firstWord?.glyphs[0]?.fontName ?? "Helvetica";
           const cleanFontKey = rawFontName.startsWith("/") ? rawFontName.slice(1) : rawFontName;
@@ -45559,7 +45603,19 @@ function runPdftohtmlCliSync(argv, files) {
   files.set(outPath, new TextEncoder().encode(outputText));
   return { exitCode: 0, stdout: "", stderr: "" };
 }
+async function runPdftohtmlCli(argv, files, signal) {
+  return drainSteps(runPdftohtmlCliSteps(argv, files, signal), signal);
+}
+function runPdftohtmlCliSync(argv, files, signal) {
+  const steps = runPdftohtmlCliSteps(argv, files, signal);
+  let next = steps.next();
+  while (!next.done) {
+    next = steps.next();
+  }
+  return next.value;
+}
 async function pdftohtml(context) {
+  let cooperativeWork = 63;
   const invocation = createOutputOperation(context, { write: async () => {
   } });
   try {
@@ -45576,6 +45632,7 @@ async function pdftohtml(context) {
     };
     let inputOperand;
     for (let i = 0; i < argv.length; i++) {
+      if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       const arg = argv[i];
       if (["-f", "-l", "-zoom", "-fmt", "-enc", "-upw", "-opw"].includes(arg)) {
         i++;
@@ -45588,6 +45645,7 @@ async function pdftohtml(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);
@@ -45596,6 +45654,7 @@ async function pdftohtml(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;
         }
@@ -45603,6 +45662,7 @@ async function pdftohtml(context) {
       }
     }
     for (const token of argv) {
+      if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (token.startsWith("-") && token !== "-") continue;
       try {
         const bytes = await context.fs.readFile(resolveVfsPath(token), { signal: invocation.signal });
@@ -45611,8 +45671,9 @@ async function pdftohtml(context) {
       } catch {
       }
     }
+    context.inputBudget?.check(0);
     const existingSnap = new Map(vfsFiles);
-    const res = await runPdftohtmlCli(argv, vfsFiles);
+    const res = await runPdftohtmlCli(argv, vfsFiles, invocation.signal);
     if (res.stderr) {
       await writeBytes(context.stderr, new TextEncoder().encode(res.stderr), invocation.signal);
     }
@@ -45623,6 +45684,7 @@ async function pdftohtml(context) {
       await writeBytes(stdout.output, outBytes, invocation.signal);
     }
     for (const [key, val] of vfsFiles.entries()) {
+      if (++cooperativeWork % 64 === 0) await yieldTurn(context.signal);
       if (existingSnap.get(key) !== val) {
         chargeBytes(val.byteLength);
         const abs = resolveVfsPath(key);
@@ -45634,13 +45696,14 @@ async function pdftohtml(context) {
     await invocation.close();
   }
 }
-function createPdftohtmlCommand(_options = {}) {
+function createPdftohtmlCommand(options = {}) {
+  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
   return Object.freeze({
     name: "pdftohtml",
     runtimeIdentity: commandRuntimeIdentity,
     description: "Convert PDF pages into HTML or XML layout documents via @poe-code/pdf-ast",
     execute(context) {
-      return pdftohtml(context);
+      return new InputByteBudget(maxInputBytes).run(context, pdftohtml);
     }
   });
 }

package/dist/safe-bash-command-pptx/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,33 @@
+import { type CommandDefinition, type VirtualShellPlugin } from "../safe-bash-contracts/index.js";
+export interface PptxCommandEngine {
+    execute(request: {
+        readonly args: readonly Uint8Array[];
+        readonly signal: AbortSignal;
+        readonly readInput: (path: string, maxBytes: number) => Promise<Uint8Array>;
+        readonly publishOutput?: (publication: {
+            readonly inputPath?: string;
+            readonly protectedInputPaths?: readonly string[];
+            readonly outputPath: string;
+            readonly bytes: Uint8Array;
+            readonly originalBytes: Uint8Array;
+            readonly inPlace: boolean;
+            readonly force: boolean;
+            readonly dryRun: boolean;
+        }) => Promise<void>;
+    }): Promise<{
+        readonly exitCode: number;
+        readonly stdout: Uint8Array;
+        readonly stderr: Uint8Array;
+    }>;
+}
+export interface PptxLimits {
+    readonly maxArgumentBytes: number;
+}
+export interface PptxCommandsOptions {
+    readonly engine: PptxCommandEngine;
+    readonly replace?: boolean;
+    readonly limits?: Partial<PptxLimits>;
+}
+export declare function createPptxCommand(options: PptxCommandsOptions): CommandDefinition;
+export declare function createPptxCommands(options: PptxCommandsOptions): readonly CommandDefinition[];
+export declare function pptxCommands(options: PptxCommandsOptions): VirtualShellPlugin;

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

@@ -0,0 +1,168 @@
+import {
+  init_buffer
+} from "../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-pptx/dist/index.js
+init_buffer();
+import { shellValueByteLength } from "../safe-bash-contracts/value.js";
+import { collectBytes, FsError, getCommandArguments, writeBytes } from "../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output.js";
+import { compareObservedEntries } from "../safe-bash-contracts/filesystem-identity.js";
+import { pathOf } from "../safe-bash-io-engine/internal.js";
+import { inputRequirements } from "../safe-bash-io-engine/portable-requirements.js";
+function createPptxCommand(options) {
+  if (!options?.engine || typeof options.engine.execute !== "function")
+    throw new TypeError("An explicit pptx command engine is required.");
+  if (options.replace !== void 0 && typeof options.replace !== "boolean")
+    throw new TypeError("pptx replace must be boolean");
+  const maxArgumentBytes = options.limits?.maxArgumentBytes ?? Infinity;
+  if (maxArgumentBytes !== Infinity && (!Number.isSafeInteger(maxArgumentBytes) || maxArgumentBytes < 0)) {
+    throw new RangeError("maxArgumentBytes must be a nonnegative safe integer or Infinity");
+  }
+  const engine = options.engine;
+  return { name: "pptx", filesystemRequirements: inputRequirements, async execute(context) {
+    const arguments_ = getCommandArguments(context);
+    let argumentBytes = 0;
+    for (let index = 0; index < arguments_.args.length; index++) {
+      const bytes = shellValueByteLength(arguments_.values[index]);
+      if (bytes > maxArgumentBytes - argumentBytes)
+        throw new FsError("EFBIG", { message: "document argument limit exceeded" });
+      argumentBytes += bytes;
+    }
+    const snapshots = /* @__PURE__ */ new Map();
+    const result = await engine.execute({
+      args: arguments_.args.map((_, index) => arguments_.bytes(index)),
+      signal: context.signal,
+      async readInput(path, maxBytes) {
+        try {
+          context.signal.throwIfAborted();
+          if (path === "-")
+            return await collectBytes(context.stdin, { maxBytes, signal: context.signal });
+          const resolved = pathOf(context, path);
+          if (!snapshots.has(resolved)) {
+            try {
+              snapshots.set(resolved, await context.fs.lstat(resolved, { signal: context.signal }));
+            } catch {
+              context.signal.throwIfAborted();
+            }
+          }
+          const capabilities = await context.fs.capabilitiesFor?.(resolved, { signal: context.signal }) ?? context.fs.capabilities;
+          context.signal.throwIfAborted();
+          if (context.fs.readStream && capabilities.streamingRead !== false) {
+            let emitted = false;
+            try {
+              const stream = context.fs.readStream(resolved, { signal: context.signal });
+              return await collectBytes((async function* () {
+                for await (const chunk of stream) {
+                  if (chunk.byteLength)
+                    emitted = true;
+                  yield chunk;
+                }
+              })(), { maxBytes, signal: context.signal });
+            } catch (error) {
+              context.signal.throwIfAborted();
+              if (emitted || !(error instanceof FsError) || error.code !== "ENOTSUP")
+                throw error;
+            }
+          }
+          if (capabilities.read === false)
+            throw new FsError("ENOTSUP");
+          const bytes = await context.fs.readFile(resolved, { maxBytes, signal: context.signal });
+          context.signal.throwIfAborted();
+          if (bytes.byteLength > maxBytes)
+            throw new FsError("EFBIG");
+          return bytes;
+        } catch (error) {
+          context.signal.throwIfAborted();
+          throw Object.assign(new Error("Input could not be read."), { code: error instanceof FsError && error.code === "EFBIG" ? "resource-limit" : "io-failure" });
+        }
+      },
+      async publishOutput(publication) {
+        try {
+          const { fs, signal } = context;
+          signal.throwIfAborted();
+          const input = publication.inputPath === void 0 || publication.inputPath === "-" ? void 0 : pathOf(context, publication.inputPath);
+          const output = pathOf(context, publication.outputPath);
+          if (publication.inPlace ? !input || input !== output : input === output)
+            throw new FsError("EINVAL");
+          const capabilities = await fs.capabilitiesFor?.(output, { signal }) ?? fs.capabilities;
+          signal.throwIfAborted();
+          if (capabilities.readOnly === true || capabilities.write === false || !capabilities.atomicFileMutation || !fs.writeFileConditional)
+            throw new FsError("ENOTSUP");
+          let destination;
+          try {
+            destination = await fs.lstat(output, { signal });
+          } catch (error) {
+            signal.throwIfAborted();
+            if (!(error instanceof FsError) || error.code !== "ENOENT")
+              throw error;
+            destination = null;
+          }
+          if (destination && destination.type !== "file")
+            throw new FsError("EINVAL");
+          if (destination) {
+            const protectedInputs = new Set((publication.protectedInputPaths ?? []).filter((path) => path !== "-").map((path) => pathOf(context, path)));
+            for (const [source, observed] of snapshots) {
+              if (source === input && !protectedInputs.has(source))
+                continue;
+              const identity = observed.type === "symlink" ? await fs.stat(source, { signal }) : observed;
+              if (source === output || await compareObservedEntries(fs, source, identity, fs, output, destination, { signal }) !== "distinct")
+                throw new FsError("EINVAL");
+            }
+          }
+          if (destination && !publication.inPlace) {
+            if (!publication.force)
+              throw new FsError("EEXIST");
+            if (input && await compareObservedEntries(fs, input, await fs.stat(input, { signal }), fs, output, destination, { signal }) !== "distinct")
+              throw new FsError("EINVAL");
+          }
+          const parentPath = output.slice(0, output.lastIndexOf("/")) || "/";
+          const parent = await fs.stat(parentPath, { signal });
+          if (parent.type !== "directory")
+            throw new FsError("ENOTDIR");
+          if (publication.inPlace) {
+            const original = snapshots.get(input);
+            if (!original || original.type !== "file" || !destination || original.revision === void 0 || original.revision !== destination.revision || original.size !== destination.size || original.mode !== destination.mode || original.nlink !== destination.nlink || original.mtimeMs !== destination.mtimeMs || original.ctimeMs !== destination.ctimeMs || await compareObservedEntries(fs, input, original, fs, output, destination, { signal }) !== "same")
+              throw new FsError("EAGAIN");
+            const current = await fs.readFile(input, { maxBytes: publication.originalBytes.length, signal });
+            if (current.length !== publication.originalBytes.length || current.some((byte, index) => byte !== publication.originalBytes[index]))
+              throw new FsError("EAGAIN");
+            destination = original;
+          }
+          signal.throwIfAborted();
+          if (!publication.dryRun)
+            await writeFileOutput(context, publication.bytes, async (bytes) => {
+              await fs.writeFileConditional(output, bytes, { parent, expected: destination, signal });
+            });
+        } catch (error) {
+          context.signal.throwIfAborted();
+          const code = error instanceof FsError && error.code === "EAGAIN" ? "stale-input" : error instanceof FsError && error.code === "ENOTSUP" ? "publication-unsupported" : "io-failure";
+          throw Object.assign(new Error("Output could not be published."), { code });
+        }
+      }
+    });
+    if (result.stdout.length)
+      await writeBytes(context.stdout, result.stdout, context.signal);
+    if (result.stderr.length)
+      await writeBytes(context.stderr, result.stderr, context.signal);
+    return { exitCode: result.exitCode };
+  } };
+}
+function createPptxCommands(options) {
+  return [createPptxCommand(options)];
+}
+function pptxCommands(options) {
+  const commands = createPptxCommands(options);
+  const replace = options.replace ?? false;
+  return { name: "pptx-commands", setup(host) {
+    if (!replace && host.commands.has("pptx"))
+      throw new Error("Command already registered: pptx");
+    for (const command of commands)
+      host.commands.register(command, { replace });
+  } };
+}
+export {
+  createPptxCommand,
+  createPptxCommands,
+  pptxCommands
+};

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

@@ -1,6 +1,12 @@
 import { type CommandContext, type CommandDefinition } from "../safe-bash-contracts/command.js";
 import type { VirtualShellPlugin } from "../safe-bash-contracts/plugin.js";
+export interface QpdfLimits {
+    readonly maxInputBytes: number;
+    readonly maxOutputBytes: number;
+    readonly maxArgumentBytes: number;
+}
 export interface QpdfCommandOptions {
+    readonly limits?: Partial<QpdfLimits>;
     readonly replace?: boolean;
 }
 export interface QpdfCliResult {
@@ -9,12 +15,12 @@ export interface QpdfCliResult {
     readonly stderr: string;
 }
 export declare function parseQpdfPageRange(rangeSpec: string, totalPages: number): number[];
-export declare function runQpdfCli(argv: readonly string[], files: Map<string, Uint8Array>, readStdin?: () => Promise<void>): Promise<QpdfCliResult>;
+export declare function runQpdfCli(argv: readonly string[], files: Map<string, Uint8Array>, readStdin?: () => Promise<void>, signal?: AbortSignal): Promise<QpdfCliResult>;
 export declare function runQpdfCliSync(argv: readonly string[], files: Map<string, Uint8Array>): QpdfCliResult;
-export declare function qpdf(context: CommandContext): Promise<{
+export declare function qpdf(context: CommandContext, options?: QpdfCommandOptions): Promise<{
     exitCode: number;
 }>;
-export declare function createQpdfCommand(_options?: QpdfCommandOptions): CommandDefinition;
+export declare function createQpdfCommand(options?: QpdfCommandOptions): CommandDefinition;
 export declare const qpdfCommand: CommandDefinition;
 export declare function qpdfCommands(options?: QpdfCommandsOptions): VirtualShellPlugin;
 export type QpdfCommandsOptions = QpdfCommandOptions;