@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/command-chunks/{chunk-6GWJUQAV.js → chunk-Z5ZZVDUD.js}

@@ -244,7 +244,10 @@ function extendedSource(source) {
     const character = source[offset];
     if (!bracket && character === "\\" && offset + 1 < source.length) {
       const next = source[++offset];
-      result += "()|+?{}".includes(next) ? next : `\\${next}`;
+      if (next === "(" && source.startsWith("?:", offset + 1)) {
+        result += "(?:";
+        offset += 2;
+      } else result += "()|+?{}".includes(next) ? next : `\\${next}`;
     } else if (bracket) {
       if (bracketFirst && character === "^") {
         result += character;
@@ -435,11 +438,24 @@ var Pattern = class {
     let offset = 0;
     let groups = 0;
     const closedGroups = /* @__PURE__ */ new Set();
-    const characterNode = (character) => ({
-      type: "character",
-      ...ignoreCase ? {} : { literal: character },
-      accepts: (candidate) => ignoreCase ? candidate.toLowerCase() === character.toLowerCase() : candidate === character
-    });
+    let insensitive = ignoreCase;
+    let multiline = false;
+    let dotAll = dialect !== "jq" || modifiers.includes("m");
+    const characterNode = (character) => {
+      const fold = insensitive;
+      return {
+        type: "character",
+        ...fold ? {} : { literal: character },
+        accepts: (candidate) => fold ? candidate.toLowerCase() === character.toLowerCase() : candidate === character
+      };
+    };
+    const shorthand = (reference) => {
+      const alphabet = reference.toLowerCase();
+      return (character) => {
+        const accepted = alphabet === "d" ? character >= "0" && character <= "9" : alphabet === "s" ? " 	\n\r\f\v".includes(character) : isWordChar(character);
+        return reference === alphabet ? accepted : !accepted;
+      };
+    };
     const escaped = () => {
       const character = offset < source.length ? String.fromCodePoint(source.codePointAt(offset)) : void 0;
       offset += character?.length ?? 1;
@@ -462,6 +478,7 @@ var Pattern = class {
       const negate = source[offset] === "^";
       if (negate) offset++;
       const tests = [];
+      const fold = insensitive;
       let first = true;
       while (offset < source.length && (source[offset] !== "]" || first)) {
         first = false;
@@ -474,6 +491,12 @@ var Pattern = class {
           continue;
         }
         if (source.startsWith("[.", offset) || source.startsWith("[=", offset)) throw new ProgramError("collating and equivalence classes are not supported");
+        if (source[offset] === "\\" && "dDsSwW".includes(source[offset + 1] ?? " ")) {
+          tests.push(shorthand(source[offset + 1]));
+          offset += 2;
+          if (source[offset] === "-" && source[offset + 1] !== "]") throw new ProgramError("character class cannot be a range endpoint");
+          continue;
+        }
         const readBracketChar = () => {
           const ch = String.fromCodePoint(source.codePointAt(offset));
           offset += ch.length;
@@ -491,6 +514,7 @@ var Pattern = class {
         const start = readBracketChar();
         if (source[offset] === "-" && source[offset + 1] !== "]" && source[offset + 1] !== void 0) {
           offset++;
+          if (source[offset] === "\\" && "dDsSwW".includes(source[offset + 1] ?? " ")) throw new ProgramError("character class cannot be a range endpoint");
           const end = readBracketChar();
           if (start > end) throw new ProgramError("reversed character range");
           tests.push((character) => character >= start && character <= end);
@@ -498,7 +522,7 @@ var Pattern = class {
       }
       if (source[offset++] !== "]") throw new ProgramError("unterminated bracket expression");
       return { type: "character", accepts: (character) => {
-        const accepted = tests.some((test) => test(character) || ignoreCase && (test(character.toLowerCase()) || test(character.toUpperCase())));
+        const accepted = tests.some((test) => test(character) || fold && (test(character.toLowerCase()) || test(character.toUpperCase())));
         return negate ? !accepted : accepted;
       } };
     };
@@ -512,7 +536,7 @@ var Pattern = class {
           const index = Number(reference);
           if (!closedGroups.has(index)) throw new ProgramError("pattern references an undefined or open capture group");
           offset++;
-          return { type: "backreference", index };
+          return { type: "backreference", index, ignoreCase: insensitive };
         }
         if (reference !== void 0 && "bByY<>".includes(reference)) {
           offset++;
@@ -528,17 +552,16 @@ var Pattern = class {
         }
         if ((dialect === "jq" || dialect === "sed" || dialect === "awk") && reference !== void 0 && "dDsSwW".includes(reference)) {
           offset++;
-          const alphabet = reference.toLowerCase();
-          return { type: "character", accepts: (character) => {
-            const accepted = alphabet === "d" ? character >= "0" && character <= "9" : alphabet === "s" ? " 	\n\r\f\v".includes(character) : character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character >= "0" && character <= "9" || character === "_";
-            return reference === alphabet ? accepted : !accepted;
-          } };
+          return { type: "character", accepts: shorthand(reference) };
         }
         return characterNode(escaped());
       }
-      if (token === ".") return { type: "character", accepts: (character) => dialect !== "jq" || modifiers.includes("m") || character !== "\n" };
-      if (token === "^") return extended || atStart ? { type: "begin" } : characterNode(token);
-      if (token === "$") return extended || offset === source.length || source[offset] === ")" || source[offset] === "|" ? { type: "end" } : characterNode(token);
+      if (token === ".") {
+        const all = dotAll;
+        return { type: "character", accepts: (character) => all || character !== "\n" };
+      }
+      if (token === "^") return extended || atStart ? { type: "begin", multiline } : characterNode(token);
+      if (token === "$") return extended || offset === source.length || source[offset] === ")" || source[offset] === "|" ? { type: "end", multiline } : characterNode(token);
       if (token === "*" && !extended && (atStart || afterBegin)) return characterNode(token);
       if (token === void 0 || "*+?{}".includes(token)) throw new ProgramError("quantifier without an expression");
       return characterNode(token);
@@ -583,6 +606,7 @@ var Pattern = class {
         offset++;
         const inner = finish(frame);
         frames.pop();
+        if (frame.flags) ({ insensitive, multiline, dotAll } = frame.flags);
         closedGroups.add(frame.index);
         const node = frame.assertion ? { type: "assertion", node: inner, ...frame.assertion } : frame.index ? { type: "group", index: frame.index, lastCapture: groups, node: inner } : inner;
         frames[frames.length - 1].nodes.push(repeated(node));
@@ -590,6 +614,33 @@ var Pattern = class {
         if (frames.length > (limits.maxPatternDepth ?? Infinity)) throw new ProgramError(`${prefix}regular expression depth limit exceeded`);
         this.patternDepth = Math.max(this.patternDepth, frames.length);
         offset++;
+        const flags = { insensitive, multiline, dotAll };
+        if (dialect === "jq" && source[offset] === "?" && "ims-".includes(source[offset + 1] ?? " ")) {
+          offset++;
+          let enabled = true;
+          let count = 0;
+          while (offset < source.length && source[offset] !== ":" && source[offset] !== ")") {
+            const flag = source[offset++];
+            if (flag === "-" && enabled) {
+              enabled = false;
+              count = 0;
+              continue;
+            }
+            if (flag === "i") insensitive = enabled;
+            else if (flag === "m") multiline = enabled;
+            else if (flag === "s") dotAll = enabled;
+            else throw new ProgramError("unsupported inline regular expression flag");
+            count++;
+          }
+          if (!count) throw new ProgramError("empty inline regular expression flags");
+          if (source[offset] === ")") {
+            offset++;
+            continue;
+          }
+          if (source[offset++] !== ":") throw new ProgramError("unterminated inline regular expression flags");
+          frames.push({ nodes: [], alternatives: [], index: 0, flags });
+          continue;
+        }
         let name;
         let capturing = true;
         let assertion;
@@ -617,7 +668,7 @@ var Pattern = class {
         }
         const index = capturing ? ++groups : 0;
         if (name !== void 0) this.groupNames.set(name, index);
-        frames.push({ nodes: [], alternatives: [], index, assertion });
+        frames.push({ nodes: [], alternatives: [], index, assertion, flags });
       } else {
         frame.nodes.push(repeated(atom(frame.nodes.length === 0, frame.nodes.length === 1 && frame.nodes[0].type === "begin")));
       }
@@ -973,74 +1024,44 @@ var Pattern = class {
       let matchEnd = -1;
       let groupStart = -1;
       let groupEnd = -1;
-      if (anchoredStart2) {
-        if (textStart + prefix.length <= textEnd && text.startsWith(prefix, textStart)) {
-          const pos = textStart + prefix.length;
-          let cursor = pos;
-          let count = 0;
-          while (cursor < textEnd) {
-            const code = text.codePointAt(cursor);
-            if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
-            cursor += code > 65535 ? 2 : 1;
-            count++;
-          }
-          if (count >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
-            found2 = textStart;
-            matchEnd = cursor;
-            groupStart = pos;
-            groupEnd = cursor;
-          }
-        }
-      } else if (prefix.length === 0) {
-        let searchFrom = from;
-        const maxStart = textEnd - minimum;
-        while (searchFrom <= maxStart) {
-          const c0 = text.codePointAt(searchFrom);
-          if (c0 < 128 ? ascii[c0] === 0 : !accepts(String.fromCodePoint(c0))) {
-            searchFrom += c0 > 65535 ? 2 : 1;
-            continue;
-          }
-          const idx = searchFrom;
-          let cursor = idx + (c0 > 65535 ? 2 : 1);
-          let count = 1;
-          while (cursor < textEnd) {
-            const code = text.codePointAt(cursor);
+      let searchFrom = from;
+      let runStart = -1;
+      let runEnd = -1;
+      let count = 0;
+      while (searchFrom <= textEnd - prefix.length) {
+        budget.step();
+        const idx = anchoredStart2 ? textStart + prefix.length <= textEnd && text.startsWith(prefix, textStart) ? textStart : -1 : text.indexOf(prefix, searchFrom);
+        if (idx < 0 || idx > textEnd - prefix.length) break;
+        budget.step(idx - searchFrom);
+        const pos = idx + prefix.length;
+        if (pos > runEnd) {
+          runStart = pos;
+          runEnd = pos;
+          count = 0;
+          while (runEnd < textEnd) {
+            budget.step();
+            const code = text.codePointAt(runEnd);
             if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
-            cursor += code > 65535 ? 2 : 1;
+            runEnd += code > 65535 ? 2 : 1;
             count++;
           }
-          if (count >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
-            found2 = idx;
-            matchEnd = cursor;
-            groupStart = idx;
-            groupEnd = cursor;
-            break;
+        } else {
+          while (runStart < pos) {
+            budget.step();
+            runStart += text.codePointAt(runStart) > 65535 ? 2 : 1;
+            count--;
           }
-          searchFrom = cursor + ((text.codePointAt(cursor) ?? 0) > 65535 ? 2 : 1);
         }
-      } else {
-        let searchFrom = from;
-        while (searchFrom <= textEnd - prefix.length) {
-          const idx = text.indexOf(prefix, searchFrom);
-          if (idx < 0 || idx > textEnd - prefix.length) break;
-          const pos = idx + prefix.length;
-          let cursor = pos;
-          let count = 0;
-          while (cursor < textEnd) {
-            const code = text.codePointAt(cursor);
-            if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
-            cursor += code > 65535 ? 2 : 1;
-            count++;
-          }
-          if (count >= minimum && (!anchoredEnd2 || cursor === textEnd)) {
-            found2 = idx;
-            matchEnd = cursor;
-            groupStart = pos;
-            groupEnd = cursor;
-            break;
-          }
-          searchFrom = idx + 1;
+        if (count >= minimum && (!anchoredEnd2 || runEnd === textEnd)) {
+          found2 = idx;
+          matchEnd = runEnd;
+          groupStart = pos;
+          groupEnd = runEnd;
+          break;
         }
+        if (anchoredStart2) break;
+        const next = prefix.length === 0 ? runEnd : idx;
+        searchFrom = next + ((text.codePointAt(next) ?? 0) > 65535 ? 2 : 1);
       }
       const positionsTried2 = anchoredStart2 ? 1 : found2 >= 0 ? found2 - from + 1 : textEnd - from + 1;
       const len2 = found2 >= 0 ? matchEnd - found2 : 0;
@@ -1168,58 +1189,15 @@ var Pattern = class {
     return found !== void 0;
   }
   execSimpleRepeat(text, budget, from) {
-    const { prefix, anchoredStart, anchoredEnd, captured, minimum, accepts, ascii } = this.simpleRepeatMatch;
-    if (from > text.length || anchoredStart && from > 0) return void 0;
-    let found = -1;
-    let matchEnd = -1;
-    let groupStart = -1;
-    let groupEnd = -1;
-    if (anchoredStart) {
-      if (text.startsWith(prefix)) {
-        const pos = prefix.length;
-        let cursor = pos;
-        let count = 0;
-        while (cursor < text.length) {
-          const code = text.codePointAt(cursor);
-          if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
-          cursor += code > 65535 ? 2 : 1;
-          count++;
-        }
-        if (count >= minimum && (!anchoredEnd || cursor === text.length)) {
-          found = 0;
-          matchEnd = cursor;
-          groupStart = pos;
-          groupEnd = cursor;
-        }
-      }
-    } else {
-      let searchFrom = from;
-      while (searchFrom <= text.length - prefix.length) {
-        const idx = text.indexOf(prefix, searchFrom);
-        if (idx < 0) break;
-        const pos = idx + prefix.length;
-        let cursor = pos;
-        let count = 0;
-        while (cursor < text.length) {
-          const code = text.codePointAt(cursor);
-          if (code < 128 ? ascii[code] === 0 : !accepts(String.fromCodePoint(code))) break;
-          cursor += code > 65535 ? 2 : 1;
-          count++;
-        }
-        if (count >= minimum && (!anchoredEnd || cursor === text.length)) {
-          found = idx;
-          matchEnd = cursor;
-          groupStart = pos;
-          groupEnd = cursor;
-          break;
-        }
-        searchFrom = idx + ((text.codePointAt(idx) ?? 0) > 65535 ? 2 : 1);
-      }
-    }
+    const matched = this.findSyncFastInto(text, budget, from, FAST_MATCH_OFFSETS);
+    const found = matched ? FAST_MATCH_OFFSETS[0] : -1;
+    const matchEnd = matched ? FAST_MATCH_OFFSETS[1] : -1;
+    const groupStart = matched ? FAST_MATCH_OFFSETS[2] : -1;
+    const groupEnd = matched ? FAST_MATCH_OFFSETS[3] : -1;
+    const { anchoredStart, captured } = this.simpleRepeatMatch;
     const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
     const len = found >= 0 ? matchEnd - found : 0;
     const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
-    budget.step(stepCount);
     if (stepCount >= 64) {
       const midCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
       if (midCheck) {
@@ -1497,9 +1475,60 @@ var Pattern = class {
     }
   }
 };
-async function replacementLength(replacement, match, budget, available, syntax) {
+function hasCaseConversion(replacement) {
+  return replacement.includes("\\U") || replacement.includes("\\L") || replacement.includes("\\u") || replacement.includes("\\l") || replacement.includes("\\E");
+}
+function* caseReplacement(replacement, match, encoding) {
+  const characterAt = (text, index) => {
+    if (encoding !== "utf8" || text.charCodeAt(index) < 128) return String.fromCodePoint(text.codePointAt(index));
+    const decoded = decodeByteText(text.slice(index, index + 4)).text;
+    return encodeByteText(String.fromCodePoint(decoded.codePointAt(0)));
+  };
+  let mode = "";
+  let once = "";
+  for (let index = 0; index < replacement.length; ) {
+    let piece = characterAt(replacement, index);
+    index += piece.length;
+    if (piece === "&") piece = match.groups[0] ?? "";
+    else if (piece === "\\" && index < replacement.length) {
+      const next = replacement[index++];
+      if (next === "U" || next === "L" || next === "E") {
+        mode = next === "E" ? "" : next;
+        once = "";
+        yield "";
+        continue;
+      }
+      if (next === "u" || next === "l") {
+        once = next.toUpperCase();
+        yield "";
+        continue;
+      }
+      piece = next >= "0" && next <= "9" ? match.groups[Number(next)] ?? "" : next === "n" ? "\n" : next === "t" ? "	" : next;
+    }
+    if (!piece) yield "";
+    for (let offset = 0; offset < piece.length; ) {
+      const raw = characterAt(piece, offset);
+      offset += raw.length;
+      const character = encoding === "utf8" ? decodeByteText(raw).text : raw;
+      const conversion = once || mode;
+      once = "";
+      const converted = encoding === "byte" && character.charCodeAt(0) >= 128 ? character : conversion === "U" ? character.toUpperCase() : conversion === "L" ? character.toLowerCase() : character;
+      yield encoding === "utf8" ? encodeByteText(converted) : converted;
+    }
+  }
+}
+async function replacementLength(replacement, match, budget, available, syntax, encoding) {
   let length = 0;
   let tokens = 0;
+  if (syntax === "sed" && hasCaseConversion(replacement)) {
+    for (const piece of caseReplacement(replacement, match, encoding)) {
+      if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+      budget.step();
+      if (piece.length > available - length) throw new ProgramError("text buffer limit exceeded");
+      length += piece.length;
+    }
+    return length;
+  }
   for (let index = 0; index < replacement.length; index++) {
     if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
     budget.step();
@@ -1523,9 +1552,23 @@ async function replacementLength(replacement, match, budget, available, syntax)
   }
   return length;
 }
-async function replacementText(replacement, match, buffer, budget, syntax) {
+async function replacementText(replacement, match, buffer, budget, syntax, encoding) {
   let literal = 0;
   let tokens = 0;
+  if (syntax === "sed" && hasCaseConversion(replacement)) {
+    let chunk = "";
+    for (const piece of caseReplacement(replacement, match, encoding)) {
+      if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
+      budget.step();
+      chunk += piece;
+      if (chunk.length >= 1024) {
+        await buffer.append(chunk);
+        chunk = "";
+      }
+    }
+    await buffer.append(chunk);
+    return;
+  }
   for (let index = 0; index < replacement.length; index++) {
     if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
     budget.step();
@@ -1563,6 +1606,10 @@ function getSimpleReplacement(replacement, syntax) {
     SIMPLE_REPLACEMENT_CACHE.set(key, res);
     return res;
   }
+  if (syntax === "sed" && hasCaseConversion(replacement)) {
+    SIMPLE_REPLACEMENT_CACHE.set(key, null);
+    return null;
+  }
   if (syntax === "sed") {
     let prefix = "";
     let mid = "";
@@ -1708,7 +1755,7 @@ function appendReplacementFromOffsetsSync(out, replacement, text, matchStart, ma
   return out;
 }
 function trySubstituteSync(text, pattern, replacement, budget, global, occurrence = 1, syntax = "sed") {
-  if (pattern.canFindSync() && text.length <= 4096 && replacement.length <= 256) {
+  if (pattern.canFindSync() && text.length <= 4096 && replacement.length <= 256 && !(syntax === "sed" && hasCaseConversion(replacement))) {
     let search = 0;
     let consumed = 0;
     let previousEnd = -1;
@@ -1816,6 +1863,7 @@ async function substitute(text, pattern, replacement, budget, global, occurrence
   let previousEnd = -1;
   let encountered = 0;
   let count = 0;
+  const encoding = pattern instanceof BytePattern ? pattern.usesUnicode(budget) ? "utf8" : "byte" : void 0;
   const result = new ReplacementBuffer(budget);
   try {
     while (search <= text.length) {
@@ -1831,10 +1879,10 @@ async function substitute(text, pattern, replacement, budget, global, occurrence
       if (encountered >= occurrence) {
         const prefix = match.start - consumed;
         result.admit(prefix);
-        const length = await replacementLength(replacement, match, budget, result.remaining - prefix, syntax);
+        const length = await replacementLength(replacement, match, budget, result.remaining - prefix, syntax, encoding);
         result.admit(prefix + length);
         await result.append(text, consumed, match.start);
-        await replacementText(replacement, match, result, budget, syntax);
+        await replacementText(replacement, match, result, budget, syntax, encoding);
         consumed = match.end;
         count++;
         if (!global) break;

package/dist/safe-bash/command-chunks/{chunk-W5DNF4JH.js → chunk-ZHN3QDCI.js}

@@ -1,6 +1,6 @@
 import {
   createCodec
-} from "./chunk-KJIMDLBB.js";
+} from "./chunk-JNANXVJV.js";
 import {
   CompressedDataError
 } from "./chunk-2UQSP2CE.js";

package/dist/safe-bash/commands/alias/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-alias/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/alias/index.js

@@ -0,0 +1,2 @@
+export * from "../../../safe-bash-command-alias/index.js";
+//# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/apply-patch/index.browser.js

@@ -3,9 +3,8 @@ import {
   createApplyPatchCommand,
   createApplyPatchCommands,
   evalSyncApplyPatch
-} from "../../chunks/chunk-XAQMU6OY.js";
-import "../../chunks/chunk-IWDICZVK.js";
-import "../../chunks/chunk-B7TAL7S5.js";
+} from "../../chunks/chunk-EE5YGFIZ.js";
+import "../../chunks/chunk-PTAEWLSE.js";
 export {
   applyPatchCommands,
   createApplyPatchCommand,

package/dist/safe-bash/commands/apply-patch/index.d.ts

@@ -1,3 +1,2 @@
-import "../../portable-buffer.js";
 export * from "../../../safe-bash-command-apply-patch/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/safe-bash/commands/apply-patch/index.js

@@ -1,3 +1,2 @@
-import "../../portable-buffer.js";
 export * from "../../../safe-bash-command-apply-patch/index.js";
 //# sourceMappingURL=index.js.map

package/dist/safe-bash/commands/archive/index.browser.js

@@ -14,9 +14,8 @@ import {
   tarCommands,
   unzipCommands,
   zipCommands
-} from "../../chunks/chunk-QGUV42T5.js";
-import "../../chunks/chunk-IWDICZVK.js";
-import "../../chunks/chunk-B7TAL7S5.js";
+} from "../../chunks/chunk-YL3GBUG4.js";
+import "../../chunks/chunk-PTAEWLSE.js";
 export {
   DEFAULT_ARCHIVE_LIMITS,
   archiveCommands,

package/dist/safe-bash/commands/archive/index.d.ts

@@ -1,4 +1,3 @@
-import "../../portable-buffer.js";
 import type { CommandDefinition, VirtualShellPlugin } from "../../../safe-bash-contracts/index.js";
 import { type ArchiveCommandsOptions } from "../../../safe-bash-command-tar/index.js";
 export declare function createArchiveCommands(options?: ArchiveCommandsOptions): readonly CommandDefinition[];

package/dist/safe-bash/commands/archive/index.js

@@ -1,4 +1,3 @@
-import "../../portable-buffer.js";
 import { createTarCommand } from "../../../safe-bash-command-tar/index.js";
 import { createZipCommand } from "../../../safe-bash-command-zip/index.js";
 import { createUnzipCommand } from "../../../safe-bash-command-unzip/index.js";

package/dist/safe-bash/commands/bytes/compression/index.js

@@ -23,65 +23,68 @@ export function createCompressionCommands(config = {}) {
     if (maxDecodedBytes !== undefined && maxDecodedBytes !== Infinity && (!Number.isSafeInteger(maxDecodedBytes) || maxDecodedBytes < 0)) {
         throw new RangeError("maxDecodedBytes must be a nonnegative safe integer or Infinity");
     }
-    const commands = profiles.flatMap(profile => profile.format === "gzip" ? createGzipCommands(config) : profile.format === "bzip2" ? createBzip2Commands(config) : profile.names.map((name) => define(name, withInputByteBudget(async (context) => {
-        const options = parseOptions(name, context.args);
-        if (options.help) {
-            await output(context, `Usage: ${name} [OPTION]... [FILE]...\n-c, --stdout, --to-stdout\n-d, --decompress, --uncompress\n-k, --keep\n-f, --force\n-t, --test\n${options.format === "zstd" ? "-1..-9, --best\nHigher levels and --fast[=NUM] are unsupported by the bounded codec.\n" : "-1..-9, --fast, --best\n"}${options.format === "zstd" ? "-q, --quiet (repeat to suppress errors)\n" : ""}${options.format === "gzip" ? "-q, --quiet (suppress warnings)\n-r, --recursive (traverse directories without following symlinks)\n-n, --no-name (always enabled)\n" : `Default compression level: ${options.level}.\n`}-h, --help\nNo FILE or FILE '-' uses stdin; file output uses private VFS staging.\n`);
-            return { exitCode: 0 };
-        }
-        let plans;
-        let planningFailed = false;
-        try {
-            if (options.operands.length > 1) {
-                plans = [];
-                for (const name of options.operands) {
-                    try {
-                        plans.push(...await planOperands(context, { ...options, operands: [name] }));
-                    }
-                    catch (error) {
-                        context.signal.throwIfAborted();
-                        if (codeOf(error) === "EROFS")
-                            throw error;
-                        planningFailed = true;
-                        if (options.quiet < 2)
-                            await diagnostic(context, error);
-                    }
-                }
-                if (plans.length > 1)
-                    await verifyOperandDestinations(context, plans);
+    const commands = profiles.flatMap(profile => profile.format === "gzip" ? createGzipCommands(config) : profile.format === "bzip2" ? createBzip2Commands(config) : profile.names.map((name) => {
+        const command = define(name, async (context) => {
+            const options = parseOptions(name, context.args);
+            if (options.help) {
+                await output(context, `Usage: ${name} [OPTION]... [FILE]...\n-c, --stdout, --to-stdout\n-d, --decompress, --uncompress\n-k, --keep\n-f, --force\n-t, --test\n${options.format === "zstd" ? "-1..-9, --best\nHigher levels and --fast[=NUM] are unsupported by the bounded codec.\n" : "-1..-9, --fast, --best\n"}${options.format === "zstd" ? "-q, --quiet (repeat to suppress errors)\n" : ""}${options.format === "gzip" ? "-q, --quiet (suppress warnings)\n-r, --recursive (traverse directories without following symlinks)\n-n, --no-name (always enabled)\n" : `Default compression level: ${options.level}.\n`}-h, --help\nNo FILE or FILE '-' uses stdin; file output uses private VFS staging.\n`);
+                return { exitCode: 0 };
             }
-            else
-                plans = await planOperands(context, options);
-        }
-        catch (error) {
-            context.signal.throwIfAborted();
-            if (options.quiet < 2)
-                throw error;
-            return { exitCode: 1 };
-        }
-        const decodedBudget = new DecodedBudget(maxDecodedBytes);
-        let exitCode = planningFailed ? 1 : 0;
-        for (const plan of plans) {
+            let plans;
+            let planningFailed = false;
             try {
-                const warned = await runOperand(context, plan, options, decodedBudget);
-                if (warned) {
-                    if (!options.quiet)
-                        await diagnostic(context, new PublicDiagnostic(`${plan.source}: decompression OK, trailing garbage ignored`));
-                    if (exitCode === 0)
-                        exitCode = 2;
+                if (options.operands.length > 1) {
+                    plans = [];
+                    for (const name of options.operands) {
+                        try {
+                            plans.push(...await planOperands(context, { ...options, operands: [name] }));
+                        }
+                        catch (error) {
+                            context.signal.throwIfAborted();
+                            if (codeOf(error) === "EROFS")
+                                throw error;
+                            planningFailed = true;
+                            if (options.quiet < 2)
+                                await diagnostic(context, error);
+                        }
+                    }
+                    if (plans.length > 1)
+                        await verifyOperandDestinations(context, plans);
                 }
+                else
+                    plans = await planOperands(context, options);
             }
             catch (error) {
                 context.signal.throwIfAborted();
                 if (options.quiet < 2)
-                    await diagnostic(context, error);
-                exitCode = 1;
-                if (decodedBudget.exceeded)
-                    break;
+                    throw error;
+                return { exitCode: 1 };
             }
-        }
-        return { exitCode };
-    }))));
+            const decodedBudget = new DecodedBudget(maxDecodedBytes);
+            let exitCode = planningFailed ? 1 : 0;
+            for (const plan of plans) {
+                try {
+                    const warned = await runOperand(context, plan, options, decodedBudget);
+                    if (warned) {
+                        if (!options.quiet)
+                            await diagnostic(context, new PublicDiagnostic(`${plan.source}: decompression OK, trailing garbage ignored`));
+                        if (exitCode === 0)
+                            exitCode = 2;
+                    }
+                }
+                catch (error) {
+                    context.signal.throwIfAborted();
+                    if (options.quiet < 2)
+                        await diagnostic(context, error);
+                    exitCode = 1;
+                    if (decodedBudget.exceeded)
+                        break;
+                }
+            }
+            return { exitCode };
+        });
+        return { ...command, execute: withInputByteBudget(async (context) => command.execute(context)) };
+    }));
     const xzCmds = createXzCommands(config);
     if (maxDecodedBytes === undefined || maxDecodedBytes === Infinity) {
         for (const c of [...commands, ...xzCmds])