@poe-platform/safe-bash 0.1.787 → 0.1.789

package/dist/safe-bash-command-truncate/sync.d.ts

@@ -0,0 +1 @@
+export declare function evalSyncTruncate(opArgs: readonly string[], readFileSync?: (filePath: string) => Uint8Array | undefined, writeFileSync?: (filePath: string, bytes: Uint8Array) => boolean): string | undefined;

package/dist/safe-bash-command-truncate/sync.js

@@ -0,0 +1,60 @@
+import { parseArguments, helpText } from "./arguments.js";
+import { syncCommandEvaluators } from "../safe-bash-io-engine/internal.js";
+export function evalSyncTruncate(opArgs, readFileSync, writeFileSync) {
+    try {
+        const args = parseArguments(opArgs, false);
+        if (args.display === "help")
+            return helpText;
+        if (args.display === "version")
+            return "truncate (safe-bash; GNU coreutils 9.7 semantics)\n";
+        if (!writeFileSync || args.files.length === 0)
+            return undefined;
+        const blockFactor = args.ioBlocks ? 4096n : 1n;
+        let refSize;
+        if (args.reference !== undefined) {
+            const refBytes = readFileSync?.(args.reference);
+            if (!refBytes)
+                return undefined;
+            refSize = BigInt(refBytes.length);
+        }
+        for (const file of args.files) {
+            const existing = readFileSync?.(file);
+            if (!existing && args.noCreate)
+                continue;
+            const curSize = BigInt(existing?.length ?? 0);
+            const base = refSize ?? curSize;
+            const scaledSize = args.size === undefined ? undefined : args.size * blockFactor;
+            let target;
+            if (scaledSize === undefined)
+                target = refSize;
+            else if (args.mode === "absolute")
+                target = scaledSize;
+            else if (args.mode === "relative")
+                target = base + scaledSize;
+            else if (args.mode === "<")
+                target = base < scaledSize ? base : scaledSize;
+            else if (args.mode === ">")
+                target = base > scaledSize ? base : scaledSize;
+            else if (args.mode === "/")
+                target = (base / scaledSize) * scaledSize;
+            else
+                target = ((base + scaledSize - 1n) / scaledSize) * scaledSize;
+            if (target < 0n)
+                target = 0n;
+            if (target > 1048576n)
+                return undefined;
+            const n = Number(target);
+            const out = new Uint8Array(n);
+            if (existing && existing.length > 0) {
+                out.set(existing.subarray(0, Math.min(existing.length, n)));
+            }
+            if (!writeFileSync(file, out))
+                return undefined;
+        }
+        return "";
+    }
+    catch {
+        return undefined;
+    }
+}
+syncCommandEvaluators.evalSyncTruncate = evalSyncTruncate;

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

@@ -4,7 +4,7 @@ import {
 
 // packages/safe-bash-command-wkhtmltopdf/dist/index.js
 init_buffer();
-import { yieldTurn } from "../safe-bash-contracts/yield.js";
+import { drainCooperativeSteps } from "../safe-bash-contracts/yield.js";
 import { commandRuntimeIdentity, getCommandArguments } from "../safe-bash-contracts/command.js";
 import { readBytes, writeBytes } from "../safe-bash-contracts/io.js";
 import { shellValueByteLength } from "../safe-bash-contracts/value.js";
@@ -45520,10 +45520,14 @@ function extractLinks(html) {
   }
   return links;
 }
-function parseHtmlDocumentSync(rawHtml, replacements, signal) {
+function* parseHtmlDocumentSteps(rawHtml, replacements, signal) {
+  let cooperativeWork = 0;
   let html = rawHtml;
   for (const [key, value] of replacements) {
-    if (key) html = html.split(key).join(value);
+    if (++cooperativeWork % 64 === 0)
+      yield;
+    if (key)
+      html = html.split(key).join(value);
   }
   const titleMatch = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
   const title = titleMatch ? stripTags(titleMatch[1] ?? "") : "";
@@ -45534,8 +45538,11 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
   let match;
   let work = 0;
   while ((match = tokenRegex.exec(bodyHtml)) !== null) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     signal.throwIfAborted();
-    if (++work % 64 === 0) signal.throwIfAborted();
+    if (++work % 64 === 0)
+      signal.throwIfAborted();
     const leadingText = stripTags(bodyHtml.slice(lastIndex, match.index));
     if (leadingText) {
       blocks.push({ kind: "paragraph", text: leadingText, links: extractLinks(bodyHtml.slice(lastIndex, match.index)) });
@@ -45584,8 +45591,11 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       const liRegex = /<li\b[^>]*>([\s\S]*?)<\/li>/gi;
       let liMatch;
       while ((liMatch = liRegex.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const itemText = stripTags(liMatch[1] ?? "");
-        if (itemText) items.push(itemText);
+        if (itemText)
+          items.push(itemText);
       }
       if (items.length > 0) {
         blocks.push({ kind: "list", ordered: tag === "ol", items });
@@ -45596,6 +45606,8 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       let m;
       let currentTerm = "";
       while ((m = dtDdRegex.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const t = m[1].toLowerCase();
         const txt = stripTags(m[2] ?? "");
         if (t === "dt") {
@@ -45617,6 +45629,8 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       const rectRe = /<rect\b([^>]*)\/?>/gi;
       let rm;
       while ((rm = rectRe.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const ra = rm[1] ?? "";
         const rx = Number(/\bx=["']?([\d.]+)/i.exec(ra)?.[1] ?? 0);
         const ry = Number(/\by=["']?([\d.]+)/i.exec(ra)?.[1] ?? 0);
@@ -45627,11 +45641,14 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       const textRe = /<text\b([^>]*)>([\s\S]*?)<\/text>/gi;
       let tm;
       while ((tm = textRe.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const ta = tm[1] ?? "";
         const tx = Number(/\bx=["']?([\d.]+)/i.exec(ta)?.[1] ?? 8);
         const ty = Number(/\by=["']?([\d.]+)/i.exec(ta)?.[1] ?? 16);
         const txt = stripTags(tm[2] ?? "");
-        if (txt) svgPrimitives.push({ kind: "text", x: tx, y: ty, text: txt });
+        if (txt)
+          svgPrimitives.push({ kind: "text", x: tx, y: ty, text: txt });
       }
       blocks.push({ kind: "svg", displayWidth, displayHeight, svgPrimitives });
     } else if (tag === "blockquote") {
@@ -45644,13 +45661,18 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       const trRegex = /<tr\b[^>]*>([\s\S]*?)<\/tr>/gi;
       let trMatch;
       while ((trMatch = trRegex.exec(inner)) !== null) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const rowHtml = trMatch[1] ?? "";
         const cells = [];
         let header = false;
         const cellRegex = /<(th|td)\b([^>]*)>([\s\S]*?)<\/\1>/gi;
         let cellMatch;
         while ((cellMatch = cellRegex.exec(rowHtml)) !== null) {
-          if (cellMatch[1]?.toLowerCase() === "th") header = true;
+          if (++cooperativeWork % 64 === 0)
+            yield;
+          if (cellMatch[1]?.toLowerCase() === "th")
+            header = true;
           const cellAttrs = cellMatch[2] ?? "";
           const colspanMatch = /colspan=["']?(\d+)/i.exec(cellAttrs);
           const colspan = Math.max(1, colspanMatch ? Number(colspanMatch[1]) : 1);
@@ -45665,7 +45687,7 @@ function parseHtmlDocumentSync(rawHtml, replacements, signal) {
       }
     } else {
       if (/<(h[1-6]|p|pre|ul|ol|dl|table|svg|hr|img|blockquote|div|section|article)\b/i.test(inner)) {
-        const nested = parseHtmlDocumentSync(inner, [], signal);
+        const nested = yield* parseHtmlDocumentSteps(inner, [], signal);
         blocks.push(...nested.blocks);
       } else {
         const text = stripTags(inner);
@@ -45712,7 +45734,8 @@ function rgbColor(r, g, b, grayscale) {
   const lum = Math.round((0.299 * r + 0.587 * g + 0.114 * b) * 1e3) / 1e3;
   return { r: lum, g: lum, b: lum };
 }
-function layoutObjectPagesSync(blocks, box, settings, signal) {
+function* layoutObjectPagesSteps(blocks, box, settings, signal) {
+  let cooperativeWork = 0;
   const pages = [];
   let currentActions = [];
   const headerReserve = settings.header.left || settings.header.center || settings.header.right ? 24 : 0;
@@ -45733,8 +45756,11 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
   };
   let work = 0;
   for (const block of blocks) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     signal.throwIfAborted();
-    if (++work % 64 === 0) signal.throwIfAborted();
+    if (++work % 64 === 0)
+      signal.throwIfAborted();
     if (block.kind === "pagebreak") {
       flushPage();
       continue;
@@ -45749,6 +45775,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
       cursorY -= 4;
       const blockTopY = cursorY;
       for (const line of lines) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const drawY = cursorY - fontSize;
         const x = box.marginLeft;
         currentActions.push((page, _doc, grayscale) => {
@@ -45766,6 +45794,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
         const rectBottom = cursorY;
         const rectTop = blockTopY;
         for (const link of block.links) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           currentActions.push((page) => {
             page.addLinkAnnotation({
               rect: [box.marginLeft, rectBottom, box.marginLeft + Math.min(contentWidth, 220), rectTop],
@@ -45785,6 +45815,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
       ensureHeight(lines.length * lineHeight + 6);
       const blockTopY = cursorY;
       for (const line of lines) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const drawY = cursorY - fontSize;
         const x = box.marginLeft;
         const hasLink = (block.links?.length ?? 0) > 0;
@@ -45803,6 +45835,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
         const rectBottom = cursorY;
         const rectTop = blockTopY;
         for (const link of block.links) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           currentActions.push((page) => {
             page.addLinkAnnotation({
               rect: [box.marginLeft, rectBottom, box.marginLeft + Math.min(contentWidth, 220), rectTop],
@@ -45835,6 +45869,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
       });
       cursorY -= 6;
       for (const rawLine of rawLines) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const drawY = cursorY - fontSize;
         const x = box.marginLeft + 6;
         currentActions.push((page, _doc, grayscale) => {
@@ -45856,10 +45892,14 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
       const lineHeight = 15;
       const items = block.items ?? [];
       for (let idx = 0; idx < items.length; idx++) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const prefix = block.ordered ? `${idx + 1}. ` : "\u2022 ";
         const lines = wrapTextLines(prefix + items[idx], Math.max(20, Math.floor((contentWidth - 14) / 5.8)));
         ensureHeight(lines.length * lineHeight + 2);
         for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+          if (++cooperativeWork % 64 === 0)
+            yield;
           const drawY = cursorY - fontSize;
           const x = box.marginLeft + (lineIdx === 0 ? 10 : 22);
           const lineText = lines[lineIdx];
@@ -45898,6 +45938,8 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
         });
       });
       for (const line of lines) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         const drawY = cursorY - fontSize;
         const x = box.marginLeft + 14;
         currentActions.push((page, _doc, grayscale) => {
@@ -45949,19 +45991,21 @@ function layoutObjectPagesSync(blocks, box, settings, signal) {
     }
     if (block.kind === "table") {
       const rows = block.rows ?? [];
-      const colCount = Math.max(
-        1,
-        ...rows.map((r) => r.cells.reduce((sum, c) => sum + c.colspan, 0))
-      );
+      const colCount = Math.max(1, ...rows.map((r) => r.cells.reduce((sum, c) => sum + c.colspan, 0)));
       const colWidth = contentWidth / colCount;
       const rowHeight = 20;
       ensureHeight(rows.length * rowHeight + 8);
       for (const row of rows) {
+        if (++cooperativeWork % 64 === 0)
+          yield;
         ensureHeight(rowHeight);
         const rowBottom = cursorY - rowHeight;
         let colCursor = 0;
         for (const cell of row.cells) {
-          if (colCursor >= colCount) break;
+          if (++cooperativeWork % 64 === 0)
+            yield;
+          if (colCursor >= colCount)
+            break;
           const span = Math.min(cell.colspan, colCount - colCursor);
           const cellX = box.marginLeft + colCursor * colWidth;
           const cellW = span * colWidth;
@@ -46035,7 +46079,8 @@ function substituteFurnitureTokens(template, tokens) {
   const isoDate = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   return template.replace(/\[page\]/g, String(tokens.page)).replace(/\[topage\]/g, String(tokens.topage)).replace(/\[webpage\]/g, tokens.webpage).replace(/\[title\]/g, tokens.title).replace(/\[section\]/g, tokens.section ?? tokens.title).replace(/\[subsection\]/g, tokens.subsection ?? "").replace(/\[isodate\]/g, isoDate).replace(/\[date\]/g, isoDate);
 }
-function renderPdfAstSync(request) {
+function* renderPdfAstSteps(request) {
+  let cooperativeWork = 0;
   request.signal.throwIfAborted();
   const { job, inputs, signal, limits } = request;
   const decoder2 = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
@@ -46045,15 +46090,17 @@ function renderPdfAstSync(request) {
   const objectMeta = [];
   let inferredDocumentTitle = job.global.documentTitle;
   for (let i = 0; i < job.objects.length; i++) {
+    if (++cooperativeWork % 64 === 0)
+      yield;
     signal.throwIfAborted();
     const obj = job.objects[i];
     const htmlBytes = inputs[i] ?? new Uint8Array(0);
     const htmlText = decoder2.decode(htmlBytes);
-    const parsed = parseHtmlDocumentSync(htmlText, obj.settings.replacements, signal);
+    const parsed = yield* parseHtmlDocumentSteps(htmlText, obj.settings.replacements, signal);
     if (!inferredDocumentTitle && parsed.title) {
       inferredDocumentTitle = parsed.title;
     }
-    const pages = layoutObjectPagesSync(parsed.blocks, box, obj.settings, signal);
+    const pages = yield* layoutObjectPagesSteps(parsed.blocks, box, obj.settings, signal);
     laidOutPerObject.push(pages);
     objectMeta.push({
       title: parsed.title || inferredDocumentTitle || "Document",
@@ -46061,23 +46108,20 @@ function renderPdfAstSync(request) {
       settings: obj.settings
     });
   }
-  const sequence = planPageSequence(
-    laidOutPerObject.map((pages, idx) => ({
-      physicalPages: pages.length,
-      pagesCount: job.objects[idx].settings.pagesCount
-    })),
-    {
-      copies: job.global.copies,
-      collate: job.global.collate,
-      pageOffset: job.global.pageOffset,
-      limits: {
-        maxObjects: limits.parse.maxObjects,
-        maxPhysicalPages: Infinity,
-        maxWork: limits.resources.maxWork
-      },
-      signal
-    }
-  );
+  const sequence = planPageSequence(laidOutPerObject.map((pages, idx) => ({
+    physicalPages: pages.length,
+    pagesCount: job.objects[idx].settings.pagesCount
+  })), {
+    copies: job.global.copies,
+    collate: job.global.collate,
+    pageOffset: job.global.pageOffset,
+    limits: {
+      maxObjects: limits.parse.maxObjects,
+      maxPhysicalPages: Infinity,
+      maxWork: limits.resources.maxWork
+    },
+    signal
+  });
   const doc = PdfDocument.create();
   doc.setMetadata({
     title: inferredDocumentTitle || "Document",
@@ -46085,11 +46129,16 @@ function renderPdfAstSync(request) {
     producer: "@poe-code/pdf-ast"
   });
   for (const outPage of sequence.pages) {
+    yield;
     signal.throwIfAborted();
     const spec = laidOutPerObject[outPage.objectIndex][outPage.pageIndex];
     const meta = objectMeta[outPage.objectIndex];
     const page = doc.addPage({ width: box.width, height: box.height });
-    for (const action of spec.actions) action(page, doc, grayscale);
+    for (const action of spec.actions) {
+      if (++cooperativeWork % 64 === 0)
+        yield;
+      action(page, doc, grayscale);
+    }
     const tokens = {
       page: outPage.logicalPage,
       topage: sequence.logicalTotal + job.global.pageOffset,
@@ -46185,8 +46234,7 @@ function createPdfAstRenderer() {
   return Object.freeze({
     profile: pdfAstRendererProfile,
     async open(request) {
-      await yieldTurn(request.signal);
-      const pdfBytes = renderPdfAstSync(request);
+      const pdfBytes = await drainCooperativeSteps(renderPdfAstSteps(request), request.signal);
       return {
         success: true,
         errorCode: 0,
@@ -46211,6 +46259,12 @@ function pdfAstWkhtmltopdfCommands(options = {}) {
     ...options.replace === void 0 ? {} : { replace: options.replace }
   });
 }
+function renderPdfAstSync(request) {
+  const steps = renderPdfAstSteps(request);
+  let next = steps.next();
+  while (!next.done) next = steps.next();
+  return next.value;
+}
 var pdfAstRendererProfile;
 var PAGE_SIZES_PT;
 var pdfAstRenderer;

package/dist/safe-bash-command-wkhtmltopdf/pdf-renderer.d.ts

@@ -3,9 +3,9 @@ import type { CommandDefinition } from "../safe-bash-contracts/command.js";
 import type { VirtualShellPlugin } from "../safe-bash-contracts/plugin.js";
 import { type RendererProfile } from "./engine.js";
 export declare const pdfAstRendererProfile: RendererProfile;
-export declare function renderPdfAstSync(request: Parameters<StaticRenderer["open"]>[0]): Uint8Array;
 export declare function createPdfAstRenderer(): StaticRenderer;
 export declare const pdfAstRenderer: StaticRenderer;
 export declare function createPdfAstWkhtmltopdfCommand(options?: Partial<WkhtmltopdfCommandOptions>): CommandDefinition;
 export declare const pdfAstWkhtmltopdfCommand: CommandDefinition;
 export declare function pdfAstWkhtmltopdfCommands(options?: Partial<WkhtmltopdfCommandOptions>): VirtualShellPlugin;
+export declare function renderPdfAstSync(request: Parameters<StaticRenderer["open"]>[0]): Uint8Array;

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

@@ -4,6 +4,7 @@ import {
 
 // packages/safe-bash-command-xxd/dist/index.js
 init_buffer();
+import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 import { isAbsolutePath, validatePath } from "@poe-platform/safe-fs/core";
 import { CommandArgumentIdentityError, FsError, readBytes, shellValueByteLength, writeBytes } from "../safe-bash-contracts/index.js";
 import { PublicDiagnostic } from "../safe-bash-contracts/public-diagnostic.js";
@@ -304,7 +305,18 @@ function hexDigit(byte) {
     return byte - 87;
   return -1;
 }
-async function reversePlain(context, files, maxInputBytes) {
+async function padToAddress(context, start, address) {
+  if (!Number.isSafeInteger(address) || address < start)
+    throw new PublicDiagnostic("invalid input: cannot seek backwards on output stream");
+  while (start < address) {
+    const length = Math.min(blockSize, address - start);
+    await output(context, new Uint8Array(length));
+    start += length;
+    await yieldTurn(context.signal);
+  }
+}
+async function reversePlain(context, files, maxInputBytes, seek) {
+  await padToAddress(context, 0, seek);
   let high = -1;
   for await (const chunk of sources(context, files, maxInputBytes)) {
     const pending = [];
@@ -327,7 +339,7 @@ async function reversePlain(context, files, maxInputBytes) {
       await output(context, Uint8Array.from(pending));
   }
 }
-async function reverseNormal(context, files, columns, maxInputBytes) {
+async function reverseNormal(context, files, columns, maxInputBytes, seek) {
   let line = "";
   let offset = 0;
   const outBuf = new Uint8Array(8192);
@@ -342,7 +354,7 @@ async function reverseNormal(context, files, columns, maxInputBytes) {
     }
   };
   const rowScratch = new Uint8Array(Math.max(columns, 256));
-  const parseLineBytesInto = (buf, startPos, endPos) => {
+  const parseLineBytesInto = async (buf, startPos, endPos) => {
     let nonSpace = false;
     for (let i = startPos; i < endPos; i++) {
       const c = buf[i];
@@ -351,7 +363,7 @@ async function reverseNormal(context, files, columns, maxInputBytes) {
         break;
       }
     }
-    if (!nonSpace)
+    if (!nonSpace || endPos - startPos === 1 && buf[startPos] === 42)
       return 0;
     const colonAbs = buf.indexOf(58, startPos);
     const colon = colonAbs >= 0 && colonAbs < endPos ? colonAbs - startPos : -1;
@@ -364,8 +376,10 @@ async function reverseNormal(context, files, columns, maxInputBytes) {
         throw new PublicDiagnostic("invalid input: expected hexadecimal address and colon");
       address = address * 16 + digit;
     }
-    if (!Number.isSafeInteger(address) || address !== offset)
-      throw new PublicDiagnostic("invalid input: reverse requires contiguous addresses starting at zero");
+    address = addOffset(address, seek);
+    await flushOut();
+    await padToAddress(context, offset, address);
+    offset = address;
     let count = 0;
     let high = -1;
     let spaces = 0;
@@ -406,7 +420,7 @@ async function reverseNormal(context, files, columns, maxInputBytes) {
       }
       let count = 0;
       if (line.length === 0) {
-        count = parseLineBytesInto(chunk, start, nl);
+        count = await parseLineBytesInto(chunk, start, nl);
       } else {
         for (let i = start; i < nl; i++)
           line += String.fromCharCode(chunk[i]);
@@ -414,7 +428,7 @@ async function reverseNormal(context, files, columns, maxInputBytes) {
         for (let i = 0; i < line.length; i++)
           lineBytes[i] = line.charCodeAt(i);
         line = "";
-        count = parseLineBytesInto(lineBytes, 0, lineBytes.length);
+        count = await parseLineBytesInto(lineBytes, 0, lineBytes.length);
       }
       start = nl + 1;
       if (count > 0) {
@@ -433,7 +447,7 @@ async function reverseNormal(context, files, columns, maxInputBytes) {
     const lineBytes = new Uint8Array(line.length);
     for (let i = 0; i < line.length; i++)
       lineBytes[i] = line.charCodeAt(i);
-    const count = parseLineBytesInto(lineBytes, 0, lineBytes.length);
+    const count = await parseLineBytesInto(lineBytes, 0, lineBytes.length);
     if (count > 0) {
       if (outUsed + count > outBuf.length)
         await flushOut();
@@ -472,7 +486,9 @@ function createXxdCommand(optionsOrMaxBytes) {
       "-len": "-l",
       "-bits": "-b",
       "-include": "-i",
-      "-name": "-n"
+      "-name": "-n",
+      "-autoskip": "-a",
+      "-capitalize": "-C"
     };
     let ended = false;
     const args = context.args.map((argument) => {
@@ -482,10 +498,17 @@ function createXxdCommand(optionsOrMaxBytes) {
         ended = true;
       return aliases[argument] ?? argument;
     });
-    const parsed = parseOptions(args, "prdubiec:g:l:s:o:n:");
+    const parsed = parseOptions(args, "aCprdubiec:g:l:s:o:n:");
     requireOperands(parsed.operands, 0, 2);
     if (parsed.operands[1] !== void 0 && parsed.operands[1] !== "-") {
-      throw new UsageError("output-file operands are not supported; output is stdout only");
+      const original = context;
+      const path = pathOf(context, parsed.operands[1]);
+      let started = false;
+      context = { ...original, stdout: { async write(bytes) {
+        await writeFileOutput(original, bytes, (data) => started ? original.fs.appendFile(path, data, { signal: original.signal }) : original.fs.writeFile(path, data, { signal: original.signal }));
+        started = true;
+      } } };
+      await writeBytes(context.stdout, new Uint8Array(), context.signal);
     }
     const files = parsed.operands.slice(0, 1);
     const plain = parsed.flags.has("p");
@@ -511,21 +534,31 @@ function createXxdCommand(optionsOrMaxBytes) {
     if (littleEndian && group && !Number.isInteger(Math.log2(group))) {
       throw new UsageError("number of octets per group must be a power of 2 with -e");
     }
-    const skip = validatedOption(parsed, "s", (text) => numeric(text.startsWith("+") && text.length > 1 ? text.slice(1) : text), 0);
+    let skip = validatedOption(parsed, "s", (text) => {
+      const relative = text.startsWith("+") ? text.slice(1) : text;
+      return relative.startsWith("-") ? -numeric(relative.slice(1)) : numeric(relative);
+    }, 0);
     const count = validatedOption(parsed, "l", numeric, Infinity);
     const displacement = validatedOption(parsed, "o", numeric, 0);
-    if (reverse && ["s", "l", "o", "d"].some((flag) => parsed.flags.has(flag))) {
+    if (reverse && ["l", "o", "d"].some((flag) => parsed.flags.has(flag))) {
       throw new UsageError("reverse does not support seek, length, displacement, or decimal addresses");
     }
     if (reverse) {
       if (plain)
-        await reversePlain(context, files, maxInputBytes);
+        await reversePlain(context, files, maxInputBytes, skip);
       else
-        await reverseNormal(context, files, columns, maxInputBytes);
+        await reverseNormal(context, files, columns, maxInputBytes, skip);
       return { exitCode: 0 };
     }
+    const input = sources(context, files, maxInputBytes);
+    if (skip < 0) {
+      if (!files[0] || files[0] === "-")
+        throw new UsageError("negative seek requires an input file");
+      const size = (await context.fs.stat(pathOf(context, files[0]), { signal: context.signal })).size;
+      skip = Math.max(0, size + skip);
+    }
     let offset = addOffset(skip, displacement);
-    const source = range(sources(context, files, maxInputBytes), skip, count);
+    const source = range(input, skip, count);
     let any = false;
     let includeLength = 0;
     let includeRow = "";
@@ -539,6 +572,8 @@ function createXxdCommand(optionsOrMaxBytes) {
       if (identifier[0] && identifier[0] >= "0" && identifier[0] <= "9")
         identifier = "__" + identifier;
     }
+    if (parsed.flags.has("C"))
+      identifier = identifier.toUpperCase();
     const upper = parsed.flags.has("u");
     const hexTable = upper ? HEX_UPPER : HEX_LOWER;
     const byteTable = binary ? BIN_TABLE : hexTable;
@@ -564,6 +599,17 @@ function createXxdCommand(optionsOrMaxBytes) {
       await writeOut(`unsigned char ${identifier}[] = {
 `);
     const rowWidth = plain && !columns ? 4096 : columns;
+    let zeroRun = 0;
+    let zeroSecond = "", zeroLast = "";
+    const finishZeros = (atEnd) => {
+      if (zeroRun >= (atEnd ? 4 : 3))
+        outBuf += "*\n" + (atEnd ? zeroLast : "");
+      else if (zeroRun === 3)
+        outBuf += zeroSecond + zeroLast;
+      else if (zeroRun === 2)
+        outBuf += zeroLast;
+      zeroRun = 0;
+    };
     for await (const batch of rows(source, rowWidth)) {
       any = true;
       for (let rowStart = 0; rowStart < batch.length; rowStart += rowWidth) {
@@ -578,7 +624,7 @@ function createXxdCommand(optionsOrMaxBytes) {
             await flushOut();
           continue;
         }
-        if (!plain && !littleEndian && !binary && columns === 16 && group === 2 && row.length === 16) {
+        if (!parsed.flags.has("a") && !plain && !littleEndian && !binary && columns === 16 && group === 2 && row.length === 16) {
           const b0 = row[0], b1 = row[1], b2 = row[2], b3 = row[3];
           const b4 = row[4], b5 = row[5], b6 = row[6], b7 = row[7];
           const b8 = row[8], b9 = row[9], b10 = row[10], b11 = row[11];
@@ -615,20 +661,32 @@ function createXxdCommand(optionsOrMaxBytes) {
           outBuf += data + (columns ? "\n" : "");
         else {
           const address = offset.toString(decimalAddress ? 10 : 16).padStart(8, "0");
-          outBuf += `${address}: ${data.padEnd(width)}  ${ascii}
+          const formatted = `${address}: ${data.padEnd(width)}  ${ascii}
 `;
+          if (parsed.flags.has("a") && row.length === columns && row.every((byte) => byte === 0)) {
+            if (zeroRun === 0)
+              outBuf += formatted;
+            if (zeroRun === 1)
+              zeroSecond = formatted;
+            zeroRun++;
+            zeroLast = formatted;
+          } else {
+            finishZeros(false);
+            outBuf += formatted;
+          }
         }
         offset = addOffset(offset, row.length);
         if (!flushedFirst || outBuf.length >= 16384)
           await flushOut();
       }
     }
+    finishZeros(true);
     if (include) {
       if (includeRow)
         await writeOut(includeRow + "\n");
       if (includeName !== void 0)
         await writeOut(`};
-unsigned int ${identifier}_len = ${includeLength};
+unsigned int ${identifier}${parsed.flags.has("C") ? "_LEN" : "_len"} = ${includeLength};
 `);
     }
     if (plain && !columns && any)

package/dist/safe-bash-command-xz/command.d.ts

@@ -1,7 +1,11 @@
 import type { CommandDefinition } from "../safe-bash-contracts/index.js";
 import { type CompressionCommandOptions } from "../safe-bash-compression-engine/stream.js";
 import type { VirtualShellPlugin } from "../safe-bash-contracts/plugin.js";
+export interface XzLimits {
+    readonly maxDecodedBytes: number;
+}
 export interface XzCommandsOptions extends CompressionCommandOptions {
+    readonly limits?: Partial<XzLimits>;
     readonly replace?: boolean;
 }
 export declare function createXzCommand(config?: XzCommandsOptions, name?: string): CommandDefinition;

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

@@ -1,2 +1,2 @@
-export { createXzCommands, createXzCommand, xzCommands, type XzCommandsOptions } from "./command.js";
+export { createXzCommands, createXzCommand, xzCommands, type XzLimits, type XzCommandsOptions } from "./command.js";
 export type { CompressionCommandOptions } from "../safe-bash-compression-engine/stream.js";

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

@@ -24,7 +24,7 @@ import { runOperand } from "../safe-bash-compression-engine/operand.js";
 import { planOperands, verifyOperandDestinations } from "../safe-bash-compression-engine/files.js";
 import { DecodedBudget } from "../safe-bash-compression-engine/stream.js";
 function createXzCommand(config = {}, name = "xz") {
-  const maxDecodedBytes = config.maxDecodedBytes;
+  const maxDecodedBytes = config.limits?.maxDecodedBytes ?? config.maxDecodedBytes ?? Infinity;
   if (maxDecodedBytes !== void 0 && maxDecodedBytes !== Infinity && (!Number.isSafeInteger(maxDecodedBytes) || maxDecodedBytes < 0)) {
     throw new RangeError("maxDecodedBytes must be a nonnegative safe integer or Infinity");
   }