@poe-platform/safe-bash 0.1.817 → 0.1.819

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

@@ -1,43 +1,20 @@
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
 
-// packages/safe-bash-command-pdftotext/src/text-markup.ts
-function escapeXml(text) {
-  return text.replaceAll("&", "&amp;").replaceAll("'", "&apos;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-function* escaped(value) {
-  const encoder = new TextEncoder();
-  for (let offset = 0; offset < value.length; ) {
-    let end = Math.min(value.length, offset + 4096);
-    if (end < value.length && value.charCodeAt(end - 1) >= 55296 && value.charCodeAt(end - 1) <= 56319) end--;
-    yield encoder.encode(escapeXml(value.slice(offset, end)));
-    offset = end;
-  }
-}
-function* streamTextHtmlStart(metadata, element) {
-  const encoder = new TextEncoder();
-  yield encoder.encode('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml">\n<head>\n');
-  yield encoder.encode("<title>");
-  yield* escaped(metadata.Title ?? "");
-  yield encoder.encode("</title>\n");
-  for (const name of ["Author", "Subject", "Creator", "Producer"]) {
-    const value = metadata[name];
-    if (!value) continue;
-    yield encoder.encode(`<meta name="${name}" content="`);
-    yield* escaped(value);
-    yield encoder.encode('"/>\n');
-  }
-  yield encoder.encode(`</head>
-<body>
-<${element}>
-`);
-}
-async function* streamTextHtml(input, metadata) {
-  const decoder = new TextDecoder();
-  yield* streamTextHtmlStart(metadata, "pre");
-  for await (const bytes of input) yield* escaped(decoder.decode(bytes, { stream: true }));
-  yield* escaped(decoder.decode());
-  yield new TextEncoder().encode("</pre>\n</body>\n</html>\n");
-}
+// packages/safe-bash-command-pdftotext/src/retained-html.ts
+import {
+  PdfFileSource,
+  PdfRetainedDocument,
+  PdfRetainedDecodedImage,
+  PdfStagingStorage,
+  PdfStagedOutputs,
+  PdfError,
+  encodeRetainedPng,
+  encodeJpegChunks,
+  streamHtmlPageText
+} from "../pdf-ast/index.js";
+import { InputByteBudget, readBytes, writeBytes } from "../safe-bash-contracts/io.js";
+import { resolvePath as resolvePath2 } from "../safe-bash-contracts/path.js";
+import { yieldTurn } from "../safe-bash-contracts/yield.js";
 
 // packages/safe-bash-command-pdftotext/src/output-encoding.ts
 var ASCII7_COMPAT_MAP = {
@@ -112,9 +89,450 @@ async function* encodePopplerChunks(input, encoding, eol) {
   if (final.length) yield final;
 }
 
+// packages/safe-bash-command-pdftotext/src/retained-output.ts
+import { FsError } from "../safe-bash-contracts/errors.js";
+import { resolvePath } from "../safe-bash-contracts/path.js";
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
+async function publishPdfOutput(context, path, source, signal) {
+  const fs = context.fs;
+  const capabilities = await fs.capabilitiesFor?.(path, { signal, create: true, stagingAncestry: true }) ?? fs.capabilities;
+  if (!capabilities.atomicFileStaging || !capabilities.retainedStagingWrite || !capabilities.retainedStagingCleanup || !capabilities.atomicStagingAncestry || !fs.prepareStagingResolution || !fs.createStagedFile || !fs.publishStagedFile) {
+    throw new FsError("ENOTSUP", { path, message: "PDF text output requires retained atomic staging" });
+  }
+  const resolution = await fs.prepareStagingResolution(path, { signal });
+  const directory = resolvePath(resolution.path, "..");
+  const staging = await fs.createStagedFile(
+    `${directory}/.pdf-text-${crypto.randomUUID()}`,
+    "output",
+    { type: "file", data: new Uint8Array() },
+    { parent: resolution.parent, retainCleanup: true, signal }
+  );
+  let failed = false;
+  try {
+    if (!staging.writer || !staging.cleanup) throw new FsError("ENOTSUP", { path, message: "PDF backend omitted retained staging handles" });
+    for await (const bytes of source) {
+      await writeFileOutput({ ...context, signal }, bytes, (data) => staging.writer.write(data, { signal }));
+    }
+    const stat = await staging.writer.finish({ signal });
+    await fs.publishStagedFile(
+      { ...staging, file: { ...staging.file, stat } },
+      resolution.path,
+      { parent: resolution.parent, destination: resolution.destination, ancestors: resolution.ancestors, commitGuard: resolution.validate, signal }
+    );
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    const cleanup = async () => {
+      try {
+        await staging.cleanup?.remove();
+      } finally {
+        await staging.cleanup?.close();
+      }
+    };
+    await cleanup().catch((error) => {
+      if (!failed) throw error;
+    });
+  }
+}
+
+// packages/safe-bash-command-pdftotext/src/retained-html.ts
+var escape = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+async function* base64(input, signal) {
+  let value = 0, count = 0, text = "";
+  for await (const bytes of input) {
+    signal.throwIfAborted();
+    for (const byte of bytes) {
+      value = value << 8 | byte;
+      if (++count !== 3) continue;
+      text += alphabet[value >>> 18 & 63] + alphabet[value >>> 12 & 63] + alphabet[value >>> 6 & 63] + alphabet[value & 63];
+      count = 0;
+      value = 0;
+      if (text.length >= 4096) {
+        yield text;
+        text = "";
+      }
+    }
+  }
+  if (count) {
+    value <<= (3 - count) * 8;
+    text += alphabet[value >>> 18 & 63] + alphabet[value >>> 12 & 63] + (count === 2 ? alphabet[value >>> 6 & 63] : "=") + "=";
+  }
+  if (text) yield text;
+}
+async function executeRetainedHtml(context, plan, stdout, signal, maxInputBytes = Infinity) {
+  const encoder = new TextEncoder(), directory = resolvePath2(context.cwd, context.env.TMPDIR || "/tmp");
+  const budget = new InputByteBudget(maxInputBytes, context.inputBudget);
+  const maximum = Math.min(maxInputBytes, context.inputBudget?.maxBytes ?? Infinity);
+  const storage = new PdfStagingStorage({ fs: context.fs, directory });
+  let source, document, outputs, failed = false;
+  const error = async (message, exitCode) => {
+    await writeBytes(context.stderr, encoder.encode(message), signal);
+    return { exitCode };
+  };
+  try {
+    await context.fs.mkdir(directory, { recursive: true, signal });
+    try {
+      if (plan.inputPath === "-") {
+        async function* input() {
+          for await (const bytes of readBytes(context.stdin, signal)) {
+            budget.charge(bytes.length);
+            yield bytes;
+          }
+        }
+        source = await PdfFileSource.fromStream(storage.fs, directory, input(), { signal, maxInputBytes: maximum });
+        if (!source.size) return await error("I/O Error: Couldn't open file '-'\n", 1);
+      } else {
+        const path = resolvePath2(context.cwd, plan.inputPath);
+        const size = (await context.fs.stat(path, { signal })).size;
+        budget.charge(size);
+        source = await PdfFileSource.open(context.fs, path, { signal, maxInputBytes: maximum });
+        if (source.size > size) budget.charge(source.size - size);
+      }
+    } catch (failure) {
+      signal.throwIfAborted();
+      budget.assertOpen();
+      if (failure instanceof PdfError && failure.code === "E_LIMIT") throw failure;
+      return await error(`I/O Error: Couldn't open file '${plan.inputPath}'
+`, 1);
+    }
+    let pageCount = 0;
+    try {
+      document = await PdfRetainedDocument.open(source, storage, { signal, recovery: "repair", ...plan.password ? { password: plan.password } : {} });
+      for await (const ignored of document.pages()) {
+        void ignored;
+        pageCount++;
+      }
+    } catch (failure) {
+      signal.throwIfAborted();
+      return await error(`PDF Error: ${failure.message}
+`, 1);
+    }
+    const totalPages = Math.max(1, pageCount), endPage = plan.lastPage > 0 ? Math.min(totalPages, plan.lastPage) : totalPages;
+    if (plan.firstPage > totalPages || plan.lastPage > 0 && plan.firstPage > endPage) {
+      return await error(`Command Line Error: Wrong page range given: the first page (${plan.firstPage}) can not be after the last page (${endPage}).
+`, 99);
+    }
+    if (!pageCount) throw new PdfError("E_CAPABILITY", "Page index out of bounds: 0");
+    const doc = document;
+    async function* images(firstPage, lastPage) {
+      let pageNumber = 0, number = 0;
+      for await (const occurrence of doc.images({ firstPage, lastPage })) {
+        await yieldTurn(signal);
+        if (pageNumber !== occurrence.pageNumber) {
+          pageNumber = occurrence.pageNumber;
+          number = 0;
+        }
+        const name = `page${pageNumber}_${++number}.${plan.imageFmt}`;
+        const decoded = await PdfRetainedDecodedImage.open(doc, occurrence, storage, { signal });
+        let imageFailed = false;
+        try {
+          const chunks = () => plan.imageFmt === "jpg" ? encodeJpegChunks(decoded.width, decoded.height, decoded.rows(), { signal }) : encodeRetainedPng(decoded.width, decoded.height, decoded.rows(), storage, { signal });
+          yield { name, width: decoded.width, height: decoded.height, chunks };
+        } catch (failure) {
+          imageFailed = true;
+          throw failure;
+        } finally {
+          await decoded.close().catch((failure) => {
+            if (!imageFailed) throw failure;
+          });
+        }
+      }
+    }
+    async function* imageMarkup(page) {
+      if (plan.ignoreImages) return;
+      for await (const image of images(page, page)) {
+        if (plan.xmlMode) yield `    <image top="0" left="0" width="${image.width}" height="${image.height}" src="`;
+        else yield '  <img src="';
+        if (plan.dataUrls) {
+          yield `data:image/${plan.imageFmt === "jpg" ? "jpeg" : "png"};base64,`;
+          yield* base64(image.chunks(), signal);
+        } else {
+          if (plan.stdoutOutput) for await (const ignored of image.chunks()) void ignored;
+          yield image.name;
+        }
+        yield plan.xmlMode ? '"/>\n' : `" width="${image.width}" height="${image.height}"/>
+`;
+      }
+    }
+    async function* indent(level) {
+      for (let left = level * 2; left > 0; left -= 2048) {
+        signal.throwIfAborted();
+        yield " ".repeat(Math.min(left, 2048));
+      }
+    }
+    async function* outlines() {
+      let depth = 0, skipLevel;
+      for await (const item of doc.streamOutlineDetails({ includeUntitled: true, includeNameTitles: false })) {
+        if (skipLevel !== void 0) {
+          if (item.level > skipLevel) continue;
+          skipLevel = void 0;
+        }
+        let hasTitle = false;
+        for await (const part of item.title()) if (part) {
+          hasTitle = true;
+          break;
+        }
+        if (!hasTitle) {
+          skipLevel = item.level;
+          continue;
+        }
+        await yieldTurn(signal);
+        if (!depth) yield plan.xmlMode ? "  <outline>\n" : '<hr/>\n<a name="outline"></a><h1>Document Outline</h1>\n<ul>\n';
+        const level = Math.max(1, item.level);
+        if (depth) {
+          if (level > depth) {
+            for (let at = depth; at < level; at++) {
+              if (plan.xmlMode) yield* indent(at + 1);
+              yield plan.xmlMode ? "<outline>\n" : "<ul>\n";
+            }
+          } else {
+            if (!plan.xmlMode) yield "</li>\n";
+            for (let at = depth; at > level; at--) {
+              if (plan.xmlMode) yield* indent(at);
+              yield plan.xmlMode ? "</outline>\n" : "</ul>\n</li>\n";
+            }
+          }
+        }
+        depth = level;
+        if (plan.xmlMode) yield* indent(depth + 1);
+        yield plan.xmlMode ? `<item page="${item.pageIndex + 1}">` : `<li><a href="#page${item.pageIndex + 1}">`;
+        for await (const part of item.title()) yield escape(part);
+        yield plan.xmlMode ? "</item>\n" : "</a>\n";
+      }
+      if (depth && !plan.xmlMode) yield "</li>\n";
+      for (let at = depth; at > 0; at--) {
+        if (plan.xmlMode) yield* indent(at);
+        yield plan.xmlMode ? "</outline>\n" : at > 1 ? "</ul>\n</li>\n" : "</ul>\n";
+      }
+    }
+    async function* markup() {
+      if (plan.xmlMode) yield '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE pdf2xml SYSTEM "pdf2xml.dtd">\n<pdf2xml producer="@poe-code/pdf-ast" version="24.08.0">\n';
+      else {
+        yield '<!DOCTYPE html>\n<html>\n<head><meta charset="utf-8"/><title>';
+        let hasTitle = false;
+        for await (const part of doc.streamInfoValue("Title")) {
+          hasTitle = true;
+          yield escape(part);
+        }
+        if (!hasTitle) for (let at = 0; at < plan.inputPath.length; at += 2048) yield escape(plan.inputPath.slice(at, at + 2048));
+        yield "</title></head>\n<body>\n";
+      }
+      for await (const page of doc.pages()) {
+        await yieldTurn(signal);
+        const number = page.index + 1;
+        if (number < plan.firstPage) continue;
+        if (number > endPage) break;
+        const { mediaBox } = await page.attributes(), width = Math.abs(mediaBox[2] - mediaBox[0]), height = Math.abs(mediaBox[3] - mediaBox[1]);
+        yield plan.xmlMode ? `  <page number="${number}" position="absolute" top="0" left="0" height="${Math.round(height * plan.zoom)}" width="${Math.round(width * plan.zoom)}">
+` : `<div class="page" id="page${number}" style="position:relative;width:${Math.round(width * plan.zoom)}pt;height:${Math.round(height * plan.zoom)}pt;">
+`;
+        const index = await page.indexText(storage, { mode: "layout", retainFontNames: true, signal });
+        let pageFailed = false;
+        try {
+          yield* streamHtmlPageText(doc, page, index, storage, { xml: plan.xmlMode, zoom: plan.zoom, height, signal, images: () => imageMarkup(number) });
+        } catch (failure) {
+          pageFailed = true;
+          throw failure;
+        } finally {
+          await index.close().catch((failure) => {
+            if (!pageFailed) throw failure;
+          });
+        }
+        yield plan.xmlMode ? "  </page>\n" : "</div>\n";
+      }
+      yield* outlines();
+      yield plan.xmlMode ? "</pdf2xml>\n" : "</body>\n</html>\n";
+    }
+    async function* encoded() {
+      let high = "";
+      for await (const part of markup()) {
+        let text = high + part;
+        high = "";
+        const last = text.charCodeAt(text.length - 1);
+        if (last >= 55296 && last <= 56319) {
+          high = text.slice(-1);
+          text = text.slice(0, -1);
+        }
+        if (text) yield encoder.encode(applyPopplerOutputEncoding(text, plan.encoding));
+      }
+      if (high) yield encoder.encode(applyPopplerOutputEncoding(high, plan.encoding));
+    }
+    let inputReplaced = plan.outPath === plan.inputPath;
+    async function* entries() {
+      if (!plan.stdoutOutput) yield { name: plan.inputPath, chunks: [] };
+      if (!plan.ignoreImages && !plan.dataUrls && !plan.stdoutOutput) {
+        for await (const image of images(plan.firstPage, endPage)) {
+          const name = plan.imageDirectory + image.name;
+          if (name === plan.inputPath) inputReplaced = true;
+          yield { name, chunks: image.chunks() };
+        }
+      }
+      yield { name: plan.outPath, chunks: encoded() };
+    }
+    outputs = await PdfStagedOutputs.create(storage, entries(), { signal });
+    for await (const output of outputs.entries()) {
+      if (!plan.stdoutOutput && output.name === plan.inputPath && !inputReplaced) continue;
+      if (plan.stdoutOutput) for await (const bytes of output.contents()) await writeBytes(stdout, bytes, signal);
+      else try {
+        await publishPdfOutput(context, resolvePath2(context.cwd, output.name), output.contents(), signal);
+      } catch (failure) {
+        signal.throwIfAborted();
+        if (!(failure instanceof Error) || !("code" in failure)) throw failure;
+        return await error(`I/O Error: Couldn't open html file '${output.name}'
+`, 0);
+      }
+    }
+    return { exitCode: 0 };
+  } catch (failure) {
+    failed = true;
+    throw failure;
+  } finally {
+    const closed = await Promise.allSettled([outputs?.close(), document?.close(), source?.close()]);
+    if (!failed) {
+      for (const result of closed) if (result.status === "rejected") await Promise.reject(result.reason);
+    }
+  }
+}
+
+// packages/safe-bash-command-pdftotext/src/html-arguments.ts
+var SUPPORTED_ENCODINGS = /* @__PURE__ */ new Set([
+  "ASCII7",
+  "Latin1",
+  "UTF-8",
+  "UCS-2",
+  "Symbol",
+  "ZapfDingbats"
+]);
+function parseHtmlArguments(argv, hasStdin = false) {
+  let xmlMode = false;
+  let toStdout = false;
+  let ignoreImages = false;
+  let dataUrls = false;
+  let firstPage = 1;
+  let lastPage = 0;
+  let zoom = 1;
+  let imageFmt = "png";
+  let encoding = "UTF-8";
+  let password = "";
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg === "-v" || arg === "--version") {
+      return { exitCode: 0, stdout: "pdftohtml version 24.08.0\n", stderr: "" };
+    }
+    if (arg === "-h" || arg === "-help" || arg === "--help" || arg === "-?") {
+      return {
+        exitCode: 0,
+        stdout: "Usage: pdftohtml [options] <PDF-file> [<html-file>|<xml-file>]\n  -xml / -stdout / -s / -i / -noframes / -c / -f <int> / -l <int>\n",
+        stderr: ""
+      };
+    }
+    if (arg === "-xml")
+      xmlMode = true;
+    else if (arg === "-stdout")
+      toStdout = true;
+    else if (arg === "-i")
+      ignoreImages = true;
+    else if (arg === "-dataurls")
+      dataUrls = true;
+    else if (arg === "-f")
+      firstPage = Math.max(1, Number(argv[++i] ?? "1") || 1);
+    else if (arg === "-l")
+      lastPage = Math.max(0, Number(argv[++i] ?? "0") || 0);
+    else if (arg === "-zoom") {
+      const z = Number.parseFloat(argv[++i] ?? "1");
+      if (Number.isFinite(z) && z > 0)
+        zoom = z;
+    } else if (arg === "-fmt") {
+      const fmtVal = (argv[++i] ?? "").toLowerCase();
+      if (fmtVal === "png")
+        imageFmt = "png";
+      else if (fmtVal === "jpg" || fmtVal === "jpeg")
+        imageFmt = "jpg";
+      else {
+        return { exitCode: 99, stdout: "", stderr: `Command Line Error: Invalid image format '${fmtVal}'
+` };
+      }
+    } else if (arg === "-enc") {
+      const nextEnc = argv[++i] ?? "";
+      if (!SUPPORTED_ENCODINGS.has(nextEnc)) {
+        return { exitCode: 99, stdout: "", stderr: `Command Line Error: Unknown encoding '${nextEnc}'
+` };
+      }
+      encoding = nextEnc;
+    } else if (arg === "-upw" || arg === "-opw")
+      password = argv[++i] ?? "";
+    else if (arg === "-s" || arg === "-noframes" || arg === "-c" || arg === "-p" || arg === "-q" || arg === "-hidden" || arg === "-nomerge" || arg === "-nodrm") {
+    } else if (!arg.startsWith("-") || arg === "-") {
+      positionals.push(arg);
+    }
+  }
+  const inputPath = positionals[0] ?? (hasStdin ? "-" : void 0);
+  if (!inputPath) {
+    return { exitCode: 99, stdout: "", stderr: "Usage: pdftohtml [options] <PDF-file> [<html-file>]\n" };
+  }
+  const explicitOut = positionals[1];
+  const stdoutOutput = toStdout || explicitOut === "-" || inputPath === "-" && !explicitOut;
+  const defaultExt = xmlMode ? ".xml" : ".html";
+  const inputStem = inputPath.toLowerCase().endsWith(".pdf") ? inputPath.slice(0, -4) : inputPath;
+  const outPath = explicitOut ? explicitOut.endsWith(".html") || explicitOut.endsWith(".xml") ? explicitOut : `${explicitOut}${defaultExt}` : inputStem + defaultExt;
+  const imageDirectory = outPath.slice(0, outPath.lastIndexOf("/") + 1);
+  return { inputPath, outPath, imageDirectory, xmlMode, stdoutOutput, ignoreImages, dataUrls, firstPage, lastPage, zoom, imageFmt, encoding, password };
+}
+
+// packages/safe-bash-command-pdftotext/src/text-markup.ts
+function escapeXml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("'", "&apos;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function* escaped(value) {
+  const encoder = new TextEncoder();
+  for (let offset = 0; offset < value.length; ) {
+    let end = Math.min(value.length, offset + 4096);
+    if (end < value.length && value.charCodeAt(end - 1) >= 55296 && value.charCodeAt(end - 1) <= 56319) end--;
+    yield encoder.encode(escapeXml(value.slice(offset, end)));
+    offset = end;
+  }
+}
+async function* streamTextHtmlStart(metadata, element) {
+  const encoder = new TextEncoder();
+  yield encoder.encode('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml">\n<head>\n');
+  yield encoder.encode("<title>");
+  for await (const part of metadata("Title")) yield* escaped(part);
+  yield encoder.encode("</title>\n");
+  for (const name of ["Author", "Subject", "Creator", "Producer"]) {
+    let opened = false;
+    for await (const part of metadata(name)) {
+      if (!part) continue;
+      if (!opened) {
+        yield encoder.encode(`<meta name="${name}" content="`);
+        opened = true;
+      }
+      yield* escaped(part);
+    }
+    if (opened) yield encoder.encode('"/>\n');
+  }
+  yield encoder.encode(`</head>
+<body>
+<${element}>
+`);
+}
+async function* streamTextHtml(input, metadata) {
+  const decoder = new TextDecoder();
+  yield* streamTextHtmlStart(metadata, "pre");
+  for await (const bytes of input) yield* escaped(decoder.decode(bytes, { stream: true }));
+  yield* escaped(decoder.decode());
+  yield new TextEncoder().encode("</pre>\n</body>\n</html>\n");
+}
+
 // packages/safe-bash-command-pdftotext/src/retained-bbox.ts
-async function* streamRawBboxPage(page, storage, geometry, options) {
-  const index = await page.indexRawText(storage, { discardDiagonal: options.nodiag, clipText: options.clip, signal: options.signal });
+async function* streamTextGeometryPage(page, storage, geometry, options) {
+  const index = await page.indexText(storage, { mode: options.raw ? "raw" : options.layout ? "layout" : "logical", colSpacing: options.colspacing, discardDiagonal: options.nodiag, clipText: options.clip, signal: options.signal });
   const encoder = new TextEncoder(), scale = options.resolution / 72;
   let failed = false, hasWords = false;
   function selected(box) {
@@ -136,8 +554,15 @@ async function* streamRawBboxPage(page, storage, geometry, options) {
   function coordinates(box) {
     return `xMin="${(box[0] * scale).toFixed(6)}" yMin="${((geometry.height - box[3]) * scale).toFixed(6)}" xMax="${(box[2] * scale).toFixed(6)}" yMax="${((geometry.height - box[1]) * scale).toFixed(6)}"`;
   }
+  function tsvCoordinates(box, precision) {
+    return [box[0] * scale, (geometry.height - box[3]) * scale, (box[2] - box[0]) * scale, (box[3] - box[1]) * scale].map((value) => value.toFixed(precision)).join("	");
+  }
+  const tsv = options.tsv === true;
+  let blockIndex = 0;
   try {
-    yield encoder.encode(`  <page width="${geometry.width.toFixed(6)}" height="${geometry.height.toFixed(6)}">
+    if (tsv) yield encoder.encode(`1	${page.index + 1}	0	0	0	0	0.000000	0.000000	${geometry.width.toFixed(6)}	${geometry.height.toFixed(6)}	-1	###PAGE###
+`);
+    else yield encoder.encode(`  <page width="${geometry.width.toFixed(6)}" height="${geometry.height.toFixed(6)}">
 `);
     for await (const block of index.blocks()) {
       let blockBox;
@@ -146,27 +571,37 @@ async function* streamRawBboxPage(page, storage, geometry, options) {
         if (box) blockBox = union(blockBox, box);
       }
       if (!blockBox) continue;
-      if (options.bboxLayout) yield encoder.encode(`    <flow>
+      if (tsv) yield encoder.encode(`3	${page.index + 1}	${blockIndex}	${blockIndex}	0	0	${tsvCoordinates(blockBox, 6)}	-1	###FLOW###
+`);
+      else if (options.bboxLayout) yield encoder.encode(`    <flow>
       <block ${coordinates(blockBox)}>
 `);
+      let lineIndex = 0;
       for await (const line of block.lines()) {
         const box = await lineBounds(line);
         if (!box) continue;
-        if (options.bboxLayout) yield encoder.encode(`        <line ${coordinates(box)}>
+        if (tsv) yield encoder.encode(`4	${page.index + 1}	${blockIndex}	${blockIndex}	${lineIndex}	0	${tsvCoordinates(box, 6)}	-1	###LINE###
 `);
+        else if (options.bboxLayout) yield encoder.encode(`        <line ${coordinates(box)}>
+`);
+        let wordIndex = 0;
         for await (const word of line.words()) {
           const wordBox = selected(word.bbox);
           if (!wordBox) continue;
           hasWords = true;
-          yield encoder.encode(`          <word ${coordinates(wordBox)}>`);
-          for await (const text of word.text()) yield encoder.encode(escapeXml(text));
-          yield encoder.encode("</word>\n");
+          if (tsv) yield encoder.encode(`5	${page.index + 1}	${blockIndex}	${blockIndex}	${lineIndex}	${wordIndex}	${tsvCoordinates(wordBox, 2)}	100	`);
+          else yield encoder.encode(`          <word ${coordinates(wordBox)}>`);
+          for await (const text of word.text()) yield encoder.encode(tsv ? text : escapeXml(text));
+          yield encoder.encode(tsv ? "\n" : "</word>\n");
+          wordIndex++;
         }
-        if (options.bboxLayout) yield encoder.encode("        </line>\n");
+        if (!tsv && options.bboxLayout) yield encoder.encode("        </line>\n");
+        lineIndex++;
       }
-      if (options.bboxLayout) yield encoder.encode("      </block>\n    </flow>\n");
+      if (!tsv && options.bboxLayout) yield encoder.encode("      </block>\n    </flow>\n");
+      blockIndex++;
     }
-    yield encoder.encode("  </page>\n");
+    if (!tsv) yield encoder.encode("  </page>\n");
     return hasWords;
   } catch (error) {
     failed = true;
@@ -179,63 +614,19 @@ async function* streamRawBboxPage(page, storage, geometry, options) {
 }
 
 // packages/safe-bash-command-pdftotext/src/retained-raw.ts
-import { PdfError, PdfNameIndex, PdfFileSource, PdfRetainedDocument, PdfStagingStorage, dictGet } from "../pdf-ast/index.js";
-import { FsError } from "../safe-bash-contracts/errors.js";
-import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
-import { readBytes, writeBytes } from "../safe-bash-contracts/io.js";
-import { resolvePath } from "../safe-bash-contracts/path.js";
-import { yieldTurn } from "../safe-bash-contracts/yield.js";
-async function publish(context, path, source, signal) {
-  const fs = context.fs;
-  const capabilities = await fs.capabilitiesFor?.(path, { signal, create: true, stagingAncestry: true }) ?? fs.capabilities;
-  if (!capabilities.atomicFileStaging || !capabilities.retainedStagingWrite || !capabilities.retainedStagingCleanup || !capabilities.atomicStagingAncestry || !fs.prepareStagingResolution || !fs.createStagedFile || !fs.publishStagedFile) {
-    throw new FsError("ENOTSUP", { path, message: "PDF text output requires retained atomic staging" });
-  }
-  const resolution = await fs.prepareStagingResolution(path, { signal });
-  const directory = resolvePath(resolution.path, "..");
-  const staging = await fs.createStagedFile(
-    `${directory}/.pdf-text-${crypto.randomUUID()}`,
-    "output",
-    { type: "file", data: new Uint8Array() },
-    { parent: resolution.parent, retainCleanup: true, signal }
-  );
-  let failed = false;
-  try {
-    if (!staging.writer || !staging.cleanup) throw new FsError("ENOTSUP", { path, message: "PDF backend omitted retained staging handles" });
-    for await (const bytes of source.stream(0, source.size, signal)) {
-      await writeFileOutput({ ...context, signal }, bytes, (data) => staging.writer.write(data, { signal }));
-    }
-    const stat = await staging.writer.finish({ signal });
-    await fs.publishStagedFile(
-      { ...staging, file: { ...staging.file, stat } },
-      resolution.path,
-      { parent: resolution.parent, destination: resolution.destination, ancestors: resolution.ancestors, commitGuard: resolution.validate, signal }
-    );
-  } catch (error) {
-    failed = true;
-    throw error;
-  } finally {
-    const cleanup = async () => {
-      try {
-        await staging.cleanup?.remove();
-      } finally {
-        await staging.cleanup?.close();
-      }
-    };
-    await cleanup().catch((error) => {
-      if (!failed) throw error;
-    });
-  }
-}
-async function executeRetainedRawText(context, plan, stdout, signal, maxInputBytes = Infinity) {
+import { PdfError as PdfError2, PdfNameIndex, PdfFileSource as PdfFileSource2, PdfRetainedDocument as PdfRetainedDocument2, PdfStagingStorage as PdfStagingStorage2, dictGet } from "../pdf-ast/index.js";
+import { readBytes as readBytes2, writeBytes as writeBytes2 } from "../safe-bash-contracts/io.js";
+import { resolvePath as resolvePath3 } from "../safe-bash-contracts/path.js";
+import { yieldTurn as yieldTurn2 } from "../safe-bash-contracts/yield.js";
+async function executeRetainedText(context, plan, stdout, signal, maxInputBytes = Infinity) {
   const encoder = new TextEncoder(), inputPath = plan.inputFile ?? "-", outputPath = plan.outputFile ?? "-";
   const warning = plan.invalidEolWarning ? "Bad '-eol' value on command line\n" : "";
   async function error(message, exitCode, includeWarning = true) {
-    if (!plan.quiet) await writeBytes(context.stderr, encoder.encode((includeWarning ? warning : "") + message), signal);
+    if (!plan.quiet) await writeBytes2(context.stderr, encoder.encode((includeWarning ? warning : "") + message), signal);
     return { exitCode };
   }
-  const directory = resolvePath(context.cwd, context.env.TMPDIR || "/tmp");
-  const storage = new PdfStagingStorage({ fs: context.fs, directory });
+  const directory = resolvePath3(context.cwd, context.env.TMPDIR || "/tmp");
+  const storage = new PdfStagingStorage2({ fs: context.fs, directory });
   let source, document, result, failed = false;
   try {
     await context.fs.mkdir(directory, { recursive: true, signal });
@@ -244,18 +635,18 @@ async function executeRetainedRawText(context, plan, stdout, signal, maxInputByt
       if (inputPath === "-") {
         async function* input() {
           let total = 0, turns = 0;
-          for await (const bytes of readBytes(context.stdin, signal)) {
-            if (++turns % 64 === 0) await yieldTurn(signal);
+          for await (const bytes of readBytes2(context.stdin, signal)) {
+            if (++turns % 64 === 0) await yieldTurn2(signal);
             total += bytes.length;
             context.inputBudget?.check(total);
             yield bytes;
           }
         }
-        source = await PdfFileSource.fromStream(storage.fs, directory, input(), { maxInputBytes: maximum, signal });
+        source = await PdfFileSource2.fromStream(storage.fs, directory, input(), { maxInputBytes: maximum, signal });
       } else {
-        const path = resolvePath(context.cwd, inputPath);
+        const path = resolvePath3(context.cwd, inputPath);
         context.inputBudget?.check((await context.fs.stat(path, { signal })).size);
-        source = await PdfFileSource.open(context.fs, path, { maxInputBytes: maximum, signal });
+        source = await PdfFileSource2.open(context.fs, path, { maxInputBytes: maximum, signal });
         context.inputBudget?.check(source.size);
       }
     } catch (failure) {
@@ -270,15 +661,15 @@ async function executeRetainedRawText(context, plan, stdout, signal, maxInputByt
     let pageCount = 0;
     try {
       const password = plan.opw ?? plan.upw;
-      document = await PdfRetainedDocument.open(source, storage, { recovery: "repair", signal, ...password !== void 0 ? { password } : {} });
+      document = await PdfRetainedDocument2.open(source, storage, { recovery: "repair", signal, ...password !== void 0 ? { password } : {} });
       for await (const ignored of document.pages()) {
         void ignored;
         pageCount++;
-        await yieldTurn(signal);
+        await yieldTurn2(signal);
       }
     } catch (failure) {
       signal.throwIfAborted();
-      if (!(failure instanceof PdfError)) throw failure;
+      if (!(failure instanceof PdfError2)) throw failure;
       if (failure.code === "E_PASSWORD" || failure.code === "E_CAPABILITY" && failure.message === "Invalid PDF password") return await error("Command Line Error: Incorrect password\n", 1);
       if (failure.code !== "E_PARSE") throw failure;
       return await error(`Syntax Error: ${failure.message}
@@ -291,16 +682,16 @@ async function executeRetainedRawText(context, plan, stdout, signal, maxInputByt
     const retained = document;
     let emptyPageWarning = false;
     async function* text() {
-      if (plan.bbox) yield* streamTextHtmlStart(await retained.info(), "doc");
+      if (plan.bbox) yield* streamTextHtmlStart((key) => retained.streamInfoValue(key), "doc");
       else if (plan.tsv) yield encoder.encode("level	page_num	par_num	block_num	line_num	word_num	left	top	width	height	conf	text\n");
       for await (const page of retained.pages()) {
-        await yieldTurn(signal);
+        await yieldTurn2(signal);
         if (page.index + 1 < first) continue;
         if (page.index + 1 > last) break;
         const geometry = await rawGeometry(retained, page, plan);
-        if (plan.bbox) {
-          const hasWords = yield* streamRawBboxPage(page, storage, geometry, { ...plan, signal });
-          if (!hasWords && !plan.bboxLayout && !plan.quiet) emptyPageWarning = true;
+        if (plan.bbox || plan.tsv && !plan.raw) {
+          const hasWords = yield* streamTextGeometryPage(page, storage, geometry, { ...plan, tsv: plan.tsv && !plan.bbox, signal });
+          if (plan.bbox && !hasWords && !plan.bboxLayout && !plan.quiet) emptyPageWarning = true;
           continue;
         }
         if (plan.tsv) {
@@ -312,14 +703,19 @@ async function executeRetainedRawText(context, plan, stdout, signal, maxInputByt
           continue;
         }
         const crop = geometry?.crop;
-        const raw = page.streamRawText(storage, { ...crop ? { crop } : {}, rejoinHyphens: false, discardDiagonal: plan.nodiag, clipText: plan.clip, signal });
-        if (!plan.urls) yield* raw;
-        else {
+        const textOptions = { ...crop ? { crop } : {}, rejoinHyphens: !plan.raw && plan.removeHyphens, discardDiagonal: plan.nodiag, clipText: plan.clip, colSpacing: plan.colspacing, fixedPitch: plan.fixed, lineSpacing: plan.linespacing, signal };
+        const raw = plan.raw ? page.streamRawText(storage, textOptions) : plan.layout ? page.streamLayoutText(storage, textOptions) : page.streamLogicalText(storage, textOptions);
+        let lastByte;
+        if (!plan.urls) {
+          for await (const bytes of raw) {
+            lastByte = bytes.at(-1) ?? lastByte;
+            yield bytes;
+          }
+        } else {
           const names = new PdfNameIndex(storage, Infinity, signal);
           let body, pageFailed = false;
           try {
-            body = await PdfFileSource.fromStream(storage.fs, directory, raw, { signal });
-            let lastByte;
+            body = await PdfFileSource2.fromStream(storage.fs, directory, raw, { signal });
             for await (const bytes of body.stream(0, body.size, signal)) {
               lastByte = bytes.at(-1) ?? lastByte;
               yield bytes;
@@ -342,18 +738,22 @@ async function executeRetainedRawText(context, plan, stdout, signal, maxInputByt
             }
           }
         }
+        if (!plan.raw && lastByte !== void 0) {
+          if (lastByte !== 10) yield new Uint8Array([10]);
+          if (!plan.layout) yield new Uint8Array([10]);
+        }
         if (!plan.nopgbrk) yield new Uint8Array([12]);
       }
       if (plan.bbox) yield encoder.encode("</doc>\n</body>\n</html>\n");
     }
-    const formatted = plan.htmlmeta && !plan.bbox ? streamTextHtml(encodePopplerChunks(text(), "UTF-8", plan.tsv ? "unix" : plan.eol), await document.info()) : text();
-    result = await PdfFileSource.fromStream(storage.fs, directory, encodePopplerChunks(formatted, plan.encoding, plan.htmlmeta || plan.tsv || plan.bbox ? "unix" : plan.eol), { signal });
-    if (warning || emptyPageWarning) await writeBytes(context.stderr, encoder.encode(warning + (emptyPageWarning ? "no word list\n" : "")), signal);
+    const formatted = plan.htmlmeta && !plan.bbox ? streamTextHtml(encodePopplerChunks(text(), "UTF-8", plan.tsv ? "unix" : plan.eol), (key) => retained.streamInfoValue(key)) : text();
+    result = await PdfFileSource2.fromStream(storage.fs, directory, encodePopplerChunks(formatted, plan.encoding, plan.htmlmeta || plan.tsv || plan.bbox ? "unix" : plan.eol), { signal });
+    if (warning || emptyPageWarning) await writeBytes2(context.stderr, encoder.encode(warning + (emptyPageWarning ? "no word list\n" : "")), signal);
     if (outputPath === "-") {
-      for await (const bytes of result.stream(0, result.size, signal)) await writeBytes(stdout, bytes, signal);
+      for await (const bytes of result.stream(0, result.size, signal)) await writeBytes2(stdout, bytes, signal);
     } else {
       try {
-        await publish(context, resolvePath(context.cwd, outputPath), result, signal);
+        await publishPdfOutput(context, resolvePath3(context.cwd, outputPath), result.stream(0, result.size, signal), signal);
       } catch (failure) {
         signal.throwIfAborted();
         if (!(failure instanceof Error) || !("code" in failure)) throw failure;
@@ -376,7 +776,7 @@ async function containsText(source, needle, signal) {
   const decoder = new TextDecoder();
   let overlap = "";
   for await (const bytes of source.stream(0, source.size, signal)) {
-    await yieldTurn(signal);
+    await yieldTurn2(signal);
     const text = overlap + decoder.decode(bytes, { stream: true });
     if (text.includes(needle)) return true;
     overlap = needle.length > 1 ? text.slice(-(needle.length - 1)) : "";
@@ -389,7 +789,7 @@ async function rawGeometry(document, page, plan) {
     let current = page.dict, depth = 0;
     const visited = /* @__PURE__ */ new Set();
     while (current) {
-      if (++depth > document.depthLimit) throw new PdfError("E_LIMIT", "PDF inherited crop depth limit exceeded");
+      if (++depth > document.depthLimit) throw new PdfError2("E_LIMIT", "PDF inherited crop depth limit exceeded");
       const candidate = (await document.lookup(dictGet(current, "CropBox")))?.value;
       if (candidate?.kind === "array" && candidate.items.length >= 4) {
         box = [];
@@ -426,25 +826,15 @@ async function rawGeometry(document, page, plan) {
 }
 
 // packages/safe-bash-command-pdftotext/src/index.ts
-import { resolvePath as resolvePath2 } from "../safe-bash-contracts/path.js";
-import { yieldTurn as yieldTurn2, drainCooperativeSteps as drainSteps } from "../safe-bash-contracts/yield.js";
-import { InputByteBudget } from "../safe-bash-contracts/io.js";
-import { writeFileOutput as writeFileOutput2 } from "../safe-bash-contracts/filesystem-output-budget.js";
+import { drainCooperativeSteps as drainSteps } from "../safe-bash-contracts/yield.js";
+import { InputByteBudget as InputByteBudget2 } from "../safe-bash-contracts/io.js";
 import {
   commandRuntimeIdentity,
   getCommandArguments
 } from "../safe-bash-contracts/command.js";
-import { readBytes as readBytes2, writeBytes as writeBytes2 } from "../safe-bash-contracts/io.js";
+import { writeBytes as writeBytes3 } from "../safe-bash-contracts/io.js";
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
 import { PdfDocument, decodePdfString, dictGet as dictGet2, extractPageAnnotations, formatExtractedPageText, resolveDestinationPageIndex, encodeJpegSteps, encodePngSteps, extractDocumentImagesSteps } from "../pdf-ast/index.js";
-var SUPPORTED_ENCODINGS = /* @__PURE__ */ new Set([
-  "ASCII7",
-  "Latin1",
-  "UTF-8",
-  "UCS-2",
-  "Symbol",
-  "ZapfDingbats"
-]);
 function parseStrictIntArg(raw) {
   if (!raw || raw.length === 0) return void 0;
   let start = 0;
@@ -1145,11 +1535,10 @@ function* runPdftotextCliSteps(argv, files, stdinBytes = new Uint8Array(0), sign
 async function runPdftotextCli(argv, files, stdinBytes = new Uint8Array(0), signal) {
   return drainSteps(runPdftotextCliSteps(argv, files, stdinBytes, signal), signal);
 }
-function usesRetainedRaw(parsed) {
-  return !parsed.error && !parsed.listenc && !parsed.version && !parsed.help && parsed.raw;
+function usesRetainedText(parsed) {
+  return !parsed.error && !parsed.listenc && !parsed.version && !parsed.help;
 }
 async function pdftotext(context) {
-  let cooperativeWork = 63;
   const invocation = createOutputOperation(context, { write: async () => {
   } });
   try {
@@ -1157,105 +1546,39 @@ async function pdftotext(context) {
     const argv = [...carrier.args];
     const parsed = parseArgs(argv);
     if (parsed.error || parsed.listenc || parsed.version || parsed.help) {
-      const res2 = await drainSteps(extractPdfToTextBytesCooperativelySteps(new Uint8Array(0), argv, invocation.signal), invocation.signal);
-      if (res2.stderr) {
-        await writeBytes2(context.stderr, new TextEncoder().encode(res2.stderr), invocation.signal);
+      const res = await drainSteps(extractPdfToTextBytesCooperativelySteps(new Uint8Array(0), argv, invocation.signal), invocation.signal);
+      if (res.stderr) {
+        await writeBytes3(context.stderr, new TextEncoder().encode(res.stderr), invocation.signal);
       }
-      if (res2.output) {
+      if (res.output) {
         const stdout = invocation.child(context.stdout);
-        await writeBytes2(stdout.output, new TextEncoder().encode(res2.output), invocation.signal);
+        await writeBytes3(stdout.output, new TextEncoder().encode(res.output), invocation.signal);
       }
-      return { exitCode: res2.exitCode };
-    }
-    if (usesRetainedRaw(parsed)) {
-      return await executeRetainedRawText(context, parsed, invocation.child(context.stdout).output, invocation.signal);
-    }
-    const inputTarget = parsed.inputFile ?? "-";
-    let pdfBytes;
-    let accountedBytes = 0;
-    const chargeBytes = (delta) => {
-      if (delta > 0) {
-        accountedBytes += delta;
-        context.inputBudget?.check(accountedBytes);
-      }
-    };
-    if (inputTarget === "-") {
-      const chunks = [];
-      let total = 0;
-      for await (const chunk of readBytes2(context.stdin, invocation.signal)) {
-        if (++cooperativeWork % 64 === 0) await yieldTurn2(context.signal);
-        chunks.push(chunk);
-        total += chunk.byteLength;
-        chargeBytes(chunk.byteLength);
-      }
-      pdfBytes = new Uint8Array(total);
-      let offset = 0;
-      for (const c of chunks) {
-        if (++cooperativeWork % 64 === 0) await yieldTurn2(context.signal);
-        pdfBytes.set(c, offset);
-        offset += c.byteLength;
-      }
-    } else {
-      const resolvedPath = resolvePath2(context.cwd, inputTarget);
-      try {
-        pdfBytes = await context.fs.readFile(resolvedPath, { signal: invocation.signal });
-        chargeBytes(pdfBytes.byteLength);
-      } catch {
-        if (!parsed.quiet) {
-          const msg = `I/O Error: Couldn't open file '${inputTarget}': No such file or directory.
-`;
-          await writeBytes2(context.stderr, new TextEncoder().encode(msg), invocation.signal);
-        }
-        return { exitCode: 1 };
-      }
-    }
-    const res = await drainSteps(extractPdfToTextBytesCooperativelySteps(pdfBytes, argv, invocation.signal), invocation.signal);
-    if (res.stderr) {
-      await writeBytes2(context.stderr, new TextEncoder().encode(res.stderr), invocation.signal);
-    }
-    if (res.exitCode !== 0) {
       return { exitCode: res.exitCode };
     }
-    const outBytes = parsed.encoding === "Latin1" ? Uint8Array.from(res.output, (char) => char.charCodeAt(0)) : parsed.encoding === "UCS-2" ? encodeUcs2(res.output) : new TextEncoder().encode(res.output);
-    if (res.outputPath === "-") {
-      const stdout = invocation.child(context.stdout);
-      await writeBytes2(stdout.output, outBytes, invocation.signal);
-    } else {
-      const outResolved = resolvePath2(context.cwd, res.outputPath);
-      try {
-        await writeFileOutput2(context, outBytes, (data) => context.fs.writeFile(outResolved, data, { signal: invocation.signal }));
-      } catch {
-        if (!parsed.quiet) {
-          const msg = `I/O Error: Couldn't open text file '${res.outputPath}'
-`;
-          await writeBytes2(context.stderr, new TextEncoder().encode(msg), invocation.signal);
-        }
-        return { exitCode: 2 };
-      }
-    }
-    return { exitCode: 0 };
+    return await executeRetainedText(context, parsed, invocation.child(context.stdout).output, invocation.signal);
   } finally {
     await invocation.close();
   }
 }
 function createPdftotextCommand(options = {}) {
-  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
+  const maxInputBytes = InputByteBudget2.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",
     async execute(context) {
       const parsed = parseArgs(getCommandArguments(context).args);
-      if (usesRetainedRaw(parsed)) {
+      if (usesRetainedText(parsed)) {
         const invocation = createOutputOperation(context, { write: async () => {
         } });
         try {
-          return await executeRetainedRawText(context, parsed, invocation.child(context.stdout).output, invocation.signal, maxInputBytes);
+          return await executeRetainedText(context, parsed, invocation.child(context.stdout).output, invocation.signal, maxInputBytes);
         } finally {
           await invocation.close();
         }
       }
-      return new InputByteBudget(maxInputBytes).run(context, pdftotext);
+      return new InputByteBudget2(maxInputBytes).run(context, pdftotext);
     }
   });
 }
@@ -1280,85 +1603,9 @@ function bytesToBase64(bytes) {
 }
 function* runPdftohtmlCliSteps(argv, files, signal) {
   let cooperativeWork = 63;
-  let xmlMode = false;
-  let toStdout = false;
-  let ignoreImages = false;
-  let dataUrls = false;
-  let firstPage = 1;
-  let lastPage = 0;
-  let zoom = 1;
-  let imageFmt = "png";
-  let encoding = "UTF-8";
-  let password = "";
-  const positionals = [];
-  for (let i = 0; i < argv.length; i++) {
-    if (++cooperativeWork % 64 === 0)
-      yield;
-    const arg = argv[i];
-    if (arg === "--") {
-      positionals.push(...argv.slice(i + 1));
-      break;
-    }
-    if (arg === "-v" || arg === "--version") {
-      return { exitCode: 0, stdout: "pdftohtml version 24.08.0\n", stderr: "" };
-    }
-    if (arg === "-h" || arg === "-help" || arg === "--help" || arg === "-?") {
-      return {
-        exitCode: 0,
-        stdout: "Usage: pdftohtml [options] <PDF-file> [<html-file>|<xml-file>]\n  -xml / -stdout / -s / -i / -noframes / -c / -f <int> / -l <int>\n",
-        stderr: ""
-      };
-    }
-    if (arg === "-xml")
-      xmlMode = true;
-    else if (arg === "-stdout")
-      toStdout = true;
-    else if (arg === "-i")
-      ignoreImages = true;
-    else if (arg === "-dataurls")
-      dataUrls = true;
-    else if (arg === "-f")
-      firstPage = Math.max(1, Number(argv[++i] ?? "1") || 1);
-    else if (arg === "-l")
-      lastPage = Math.max(0, Number(argv[++i] ?? "0") || 0);
-    else if (arg === "-zoom") {
-      const z = Number.parseFloat(argv[++i] ?? "1");
-      if (Number.isFinite(z) && z > 0)
-        zoom = z;
-    } else if (arg === "-fmt") {
-      const fmtVal = (argv[++i] ?? "").toLowerCase();
-      if (fmtVal === "png")
-        imageFmt = "png";
-      else if (fmtVal === "jpg" || fmtVal === "jpeg")
-        imageFmt = "jpg";
-      else {
-        return { exitCode: 99, stdout: "", stderr: `Command Line Error: Invalid image format '${fmtVal}'
-` };
-      }
-    } else if (arg === "-enc") {
-      const nextEnc = argv[++i] ?? "";
-      if (!SUPPORTED_ENCODINGS.has(nextEnc)) {
-        return { exitCode: 99, stdout: "", stderr: `Command Line Error: Unknown encoding '${nextEnc}'
-` };
-      }
-      encoding = nextEnc;
-    } else if (arg === "-upw" || arg === "-opw")
-      password = argv[++i] ?? "";
-    else if (arg === "-s" || arg === "-noframes" || arg === "-c" || arg === "-p" || arg === "-q" || arg === "-hidden" || arg === "-nomerge" || arg === "-nodrm") {
-    } else if (!arg.startsWith("-") || arg === "-") {
-      positionals.push(arg);
-    }
-  }
-  const inputPath = positionals[0] ?? (files.has("-") ? "-" : void 0);
-  if (!inputPath) {
-    return { exitCode: 99, stdout: "", stderr: "Usage: pdftohtml [options] <PDF-file> [<html-file>]\n" };
-  }
-  const explicitOut = positionals[1];
-  const stdoutOutput = toStdout || explicitOut === "-" || inputPath === "-" && !explicitOut;
-  const defaultExt = xmlMode ? ".xml" : ".html";
-  const inputStem = inputPath.toLowerCase().endsWith(".pdf") ? inputPath.slice(0, -4) : inputPath;
-  const outPath = explicitOut ? explicitOut.endsWith(".html") || explicitOut.endsWith(".xml") ? explicitOut : `${explicitOut}${defaultExt}` : inputStem + defaultExt;
-  const imageDirectory = outPath.slice(0, outPath.lastIndexOf("/") + 1);
+  const parsed = parseHtmlArguments(argv, files.has("-"));
+  if ("exitCode" in parsed) return parsed;
+  const { inputPath, outPath, imageDirectory, xmlMode, stdoutOutput, ignoreImages, dataUrls, firstPage, lastPage, zoom, imageFmt, encoding, password } = parsed;
   const pdfBytes = files.get(inputPath);
   if (!pdfBytes) {
     return { exitCode: 1, stdout: "", stderr: `I/O Error: Couldn't open file '${inputPath}'
@@ -1615,104 +1862,30 @@ function runPdftohtmlCliSync(argv, files, signal) {
   }
   return next.value;
 }
-async function pdftohtml(context) {
-  let cooperativeWork = 63;
+async function pdftohtml(context, maxInputBytes = Infinity) {
   const invocation = createOutputOperation(context, { write: async () => {
   } });
   try {
-    const carrier = getCommandArguments(context);
-    const argv = [...carrier.args];
-    const vfsFiles = /* @__PURE__ */ new Map();
-    let accountedBytes = 0;
-    const chargeBytes = (delta) => {
-      if (delta > 0) {
-        accountedBytes += delta;
-        context.inputBudget?.check(accountedBytes);
-      }
-    };
-    let inputOperand;
-    for (let i = 0; i < argv.length; i++) {
-      if (++cooperativeWork % 64 === 0) await yieldTurn2(context.signal);
-      const arg = argv[i];
-      if (arg === "--") {
-        inputOperand = argv[i + 1];
-        break;
-      }
-      if (["-f", "-l", "-zoom", "-fmt", "-enc", "-upw", "-opw"].includes(arg)) {
-        i++;
-      } else if (arg === "-" || !arg.startsWith("-")) {
-        inputOperand = arg;
-        break;
-      }
-    }
-    if (inputOperand === "-") {
-      const chunks = [];
-      let total = 0;
-      for await (const chunk of readBytes2(context.stdin, invocation.signal)) {
-        if (++cooperativeWork % 64 === 0) await yieldTurn2(context.signal);
-        chunks.push(chunk);
-        total += chunk.byteLength;
-        chargeBytes(chunk.byteLength);
-      }
-      if (total > 0) {
-        const buf = new Uint8Array(total);
-        let off = 0;
-        for (const c of chunks) {
-          if (++cooperativeWork % 64 === 0) await yieldTurn2(context.signal);
-          buf.set(c, off);
-          off += c.byteLength;
-        }
-        vfsFiles.set("-", buf);
-      }
-    }
-    for (const token of inputOperand && inputOperand !== "-" ? [inputOperand] : []) {
-      if (++cooperativeWork % 64 === 0) await yieldTurn2(context.signal);
-      try {
-        const bytes = await context.fs.readFile(resolvePath2(context.cwd, token), { signal: invocation.signal });
-        chargeBytes(bytes.byteLength);
-        vfsFiles.set(token, bytes);
-      } catch {
-      }
-    }
-    context.inputBudget?.check(0);
-    const existingSnap = new Map(vfsFiles);
-    const res = await runPdftohtmlCli(argv, vfsFiles, invocation.signal);
-    if (res.stderr) {
-      await writeBytes2(context.stderr, new TextEncoder().encode(res.stderr), invocation.signal);
-    }
-    if (res.stdout) {
-      const outBytes = new TextEncoder().encode(res.stdout);
-      const stdout = invocation.child(context.stdout);
-      await writeBytes2(stdout.output, outBytes, invocation.signal);
-    }
-    for (const [key, val] of vfsFiles.entries()) {
-      if (++cooperativeWork % 64 === 0) await yieldTurn2(context.signal);
-      if (existingSnap.get(key) !== val) {
-        const abs = resolvePath2(context.cwd, key);
-        try {
-          await writeFileOutput2(context, val, (data) => context.fs.writeFile(abs, data, { signal: invocation.signal }));
-        } catch (error) {
-          invocation.signal.throwIfAborted();
-          if (!(error instanceof Error) || !("code" in error)) throw error;
-          await writeBytes2(context.stderr, new TextEncoder().encode(`I/O Error: Couldn't open html file '${key}'
-`), invocation.signal);
-          return { exitCode: 0 };
-        }
-      }
+    const plan = parseHtmlArguments(getCommandArguments(context).args, true);
+    const stdout = invocation.child(context.stdout);
+    if ("exitCode" in plan) {
+      if (plan.stdout) await writeBytes3(stdout.output, new TextEncoder().encode(plan.stdout), invocation.signal);
+      if (plan.stderr) await writeBytes3(context.stderr, new TextEncoder().encode(plan.stderr), invocation.signal);
+      return { exitCode: plan.exitCode };
     }
-    return { exitCode: res.exitCode };
+    return await executeRetainedHtml(context, plan, stdout.output, invocation.signal, maxInputBytes);
   } finally {
     await invocation.close();
   }
 }
 function createPdftohtmlCommand(options = {}) {
-  const maxInputBytes = InputByteBudget.limit(options.limits?.maxInputBytes);
+  const maxInputBytes = InputByteBudget2.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 new InputByteBudget(maxInputBytes).run(context, pdftohtml);
+      return pdftohtml(context, maxInputBytes);
     }
   });
 }