@poe-platform/safe-bash 0.1.802 → 0.1.803

package/dist/safe-bash/command-chunks/{chunk-OQKC5ZU2.js → chunk-NKIELG7Y.js}

@@ -6,7 +6,7 @@ import {
 init_buffer();
 import { utf8ByteLength, bytesFrom } from "../../safe-bash-byte-engine/index.js";
 import { tryReadMemoryFileViewSync } from "@poe-platform/safe-fs/core";
-import { assertCommandRequirements, collectBytes } from "../../safe-bash-contracts/index.js";
+import { assertCommandRequirements, collectBytes, createCommandArguments, getCommandArguments } from "../../safe-bash-contracts/index.js";
 import { hasYieldCheckpoint } from "../../safe-bash-contracts/yield.js";
 import { chargeRuntimeFileSystemOperation, getRuntimeBackingFileSystem } from "../../safe-bash-contracts/runtime-control.js";
 import { Matcher } from "../../safe-bash-search-engine/matcher.js";
@@ -1024,12 +1024,33 @@ ${totals.bytes_searched} bytes searched
     })();
   });
 }
+async function executeRgWithConfig(context, executor, options, path) {
+  try {
+    if (parse(context.args).noConfig) return await executeRgSlow(context, executor, options);
+    const maximum = options.maxFileBytes ?? Infinity;
+    const bytes = await collectBytes(requiredFileInput(context, searchRequirements, "file", pathFor(context, path), maximum), { maxBytes: maximum, signal: context.signal });
+    const configArgs = new TextDecoder("utf-8", { fatal: true }).decode(bytes).split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+    const original = getCommandArguments(context);
+    const argumentsWithConfig = original.slice(0, 0).concat(createCommandArguments(configArgs), original);
+    const configured = Object.create(context, {
+      args: { value: argumentsWithConfig.args },
+      argumentValues: { value: argumentsWithConfig }
+    });
+    return await executeRgSlow(configured, executor, options);
+  } catch (error) {
+    context.signal.throwIfAborted();
+    await diagnostic(context, error);
+    return { exitCode: 2 };
+  }
+}
 function createRgCommand(executor, options = {}) {
   return {
     name: "rg",
     filesystemRequirements: searchRequirements,
     description: "Search virtual files or stdin with recursive filtering and structured results",
     execute(context) {
+      const config = context.env.RIPGREP_CONFIG_PATH;
+      if (config) return executeRgWithConfig(context, executor, options, config);
       const fastSync = tryExecuteRgFastSync(context, executor, options);
       if (fastSync !== void 0) return fastSync;
       return executeRgSlow(context, executor, options);

package/dist/safe-bash/command-chunks/{chunk-WPYIOKE3.js → chunk-PICVQ6B5.js}

@@ -2,10 +2,10 @@ import {
   chunkBytes,
   stagingLimit,
   transform
-} from "./chunk-2JRBIDAD.js";
+} from "./chunk-V4K2JDYU.js";
 import {
   formats
-} from "./chunk-5E4WAO4O.js";
+} from "./chunk-JD5QNRNO.js";
 import {
   codeOf,
   pathOf

package/dist/safe-bash/command-chunks/{chunk-YOFC45RK.js → chunk-QVOS4YXL.js}

@@ -5,7 +5,7 @@ import {
   outputFailure,
   removeManagedAbortWaiter,
   writeBytes
-} from "./chunk-VXSLJH7G.js";
+} from "./chunk-6JSIFWYT.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-VGG2DL5Q.js → chunk-TRR4MYWF.js}

@@ -28,6 +28,7 @@ var ParsedArguments = class _ParsedArguments {
   patterns = [];
   paths = [];
   reset() {
+    this.noConfig = false;
     this.help = void 0;
     this.version = void 0;
     this.patternFiles = EMPTY_STRINGS;
@@ -86,6 +87,7 @@ var ParsedArguments = class _ParsedArguments {
   }
   static {
     Object.assign(_ParsedArguments.prototype, {
+      noConfig: false,
       patternFiles: EMPTY_STRINGS,
       explicitPatterns: false,
       mode: "lines",
@@ -434,7 +436,9 @@ function parse(args, target) {
           result.requireGit = false;
           break;
         case "no-ignore-global":
+          break;
         case "no-config":
+          result.noConfig = true;
           break;
         case "a":
         case "text":

package/dist/safe-bash/command-chunks/{chunk-2JRBIDAD.js → chunk-V4K2JDYU.js}

@@ -1,12 +1,12 @@
 import {
   zstdDecode
-} from "./chunk-F4TEEZTL.js";
+} from "./chunk-CQHP3I66.js";
 import {
   gunzipMembers
 } from "./chunk-Z6UEDK5T.js";
 import {
   boundedCodec
-} from "./chunk-W5DNF4JH.js";
+} from "./chunk-LOICUCHG.js";
 import {
   CodecReader,
   codec

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

@@ -973,74 +973,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 +1138,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) {

package/dist/safe-bash/command-chunks/chunk-ZDN7MJE6.js

@@ -0,0 +1,168 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-mktemp/src/command.ts
+init_buffer();
+import { creationUmask } from "../../safe-bash-contracts/runtime-control.js";
+import { randomInteger } from "../../safe-bash-metadata-engine/random.js";
+import { FsError, validatePath } from "../../safe-bash-contracts/index.js";
+import { codeOf, diagnostic, pathOf, syncCommandEvaluators, UsageError } from "../../safe-bash-io-engine/internal.js";
+import { gnuInformationSync } from "../../safe-bash-io-engine/gnu-information.js";
+import { MetadataBudget, metadataCommand, settings } from "../../safe-bash-metadata-engine/index.js";
+var mktempEncoder = new TextEncoder();
+function parse(args) {
+  let directory = false;
+  let dryRun = false;
+  let quiet = false;
+  let useTmpdir = false;
+  let deprecatedTmpdir = false;
+  let tmpdir;
+  let suffix;
+  let literal = false;
+  const operands = [];
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (literal || argument === "-" || !argument.startsWith("-")) operands.push(argument);
+    else if (argument === "--") literal = true;
+    else if (argument === "--directory") directory = true;
+    else if (argument === "--dry-run") dryRun = true;
+    else if (argument === "--quiet") quiet = true;
+    else if (argument === "--tmpdir" || argument.startsWith("--tmpdir=")) {
+      useTmpdir = true;
+      tmpdir = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : "";
+    } else if (argument === "--suffix" || argument.startsWith("--suffix=")) {
+      suffix = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : args[++index];
+      if (suffix === void 0) throw new UsageError("--suffix requires an argument");
+    } else if (!argument.startsWith("--")) {
+      for (let offset = 1; offset < argument.length; offset++) {
+        const option = argument[offset];
+        if (option === "d") directory = true;
+        else if (option === "u") dryRun = true;
+        else if (option === "q") quiet = true;
+        else if (option === "t") {
+          useTmpdir = true;
+          deprecatedTmpdir = true;
+        } else if (option === "p") {
+          tmpdir = argument.slice(offset + 1) || args[++index];
+          if (tmpdir === void 0) throw new UsageError("-p requires an argument");
+          useTmpdir = true;
+          break;
+        } else throw new UsageError(`unrecognized option '${argument}'`);
+      }
+    } else throw new UsageError(`unrecognized option '${argument}'`);
+  }
+  if (operands.length > 1) throw new UsageError("too many templates");
+  const template = operands[0] ?? "tmp.XXXXXXXXXX";
+  if (operands.length === 0) useTmpdir = true;
+  validatePath(template);
+  if (deprecatedTmpdir && template.includes("/")) throw new UsageError("template contains directory separator");
+  validatePath(suffix ?? "");
+  if (suffix?.includes("/") || suffix !== void 0 && !template.endsWith("X")) throw new UsageError("suffix requires a template ending in X and cannot contain '/'");
+  const name = template.slice(template.lastIndexOf("/") + 1);
+  if (name.length + (suffix?.length ?? 0) > 255 || mktempEncoder.encode(name).byteLength + mktempEncoder.encode(suffix ?? "").byteLength > 255) throw new FsError("ENAMETOOLONG", { path: template });
+  const end = name.lastIndexOf("X") + 1;
+  let start = end;
+  while (start > 0 && name[start - 1] === "X") start--;
+  if (end - start < 3) throw new UsageError("template must contain at least three consecutive X characters in its last component");
+  if (useTmpdir && template.startsWith("/")) throw new UsageError("template must be relative with --tmpdir/-p");
+  const tail = suffix ?? name.slice(end);
+  return { directory, dryRun, quiet, useTmpdir, deprecatedTmpdir, tmpdir, template, prefix: template.slice(0, template.length - name.length + start), count: end - start, tail };
+}
+var alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function sampleTemplateChars(count) {
+  let out = "";
+  for (let index = 0; index < count; index++) out += alphabet[randomInteger(alphabet.length)];
+  return out;
+}
+function evalSyncMktemp(opArgs, env, statTypeSync, writeFileSync, mkdirSync) {
+  const gnuInfo = gnuInformationSync("mktemp", opArgs);
+  if (gnuInfo !== void 0) return gnuInfo;
+  try {
+    const parsed = parse(opArgs);
+    const parent = parsed.deprecatedTmpdir && env.TMPDIR || parsed.tmpdir || env.TMPDIR || "/tmp";
+    validatePath(parent);
+    if (!statTypeSync) return void 0;
+    if (parsed.useTmpdir && !parsed.dryRun && statTypeSync(parent || ".") !== "directory") return void 0;
+    for (let attempt = 0; attempt < 32; attempt++) {
+      const random = sampleTemplateChars(parsed.count);
+      const generated = `${parsed.prefix}${random}${parsed.tail}`;
+      const display = parsed.useTmpdir ? `${parent.replace(/\/+$/u, "")}/${generated}` : generated;
+      const st = statTypeSync(display);
+      if (st !== "missing") continue;
+      if (!parsed.dryRun) {
+        if (parsed.directory) {
+          if (!mkdirSync || !mkdirSync(display)) return void 0;
+        } else {
+          if (!writeFileSync || !writeFileSync(display, new Uint8Array(0))) return void 0;
+        }
+      }
+      return `${display}
+`;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+syncCommandEvaluators.evalSyncMktemp = evalSyncMktemp;
+function createMktempCommand(configuration = {}) {
+  const configured = settings(configuration);
+  const configuredUmask = configuration.umask === void 0 ? void 0 : configured.umask;
+  return metadataCommand("mktemp", async (context) => {
+    const budget = new MetadataBudget(context, configured.limits);
+    const parsed = parse(context.args);
+    const parent = parsed.deprecatedTmpdir && context.env.TMPDIR || parsed.tmpdir || context.env.TMPDIR || "/tmp";
+    validatePath(parent);
+    try {
+      if (!parsed.dryRun) {
+        if (context.fs.capabilities.readOnly) throw new FsError("EROFS", { syscall: "mktemp" });
+      }
+      for (let attempt = 0; attempt < configured.limits.maxAttempts; attempt++) {
+        await budget.step();
+        const random = sampleTemplateChars(parsed.count);
+        const generated = `${parsed.prefix}${random}${parsed.tail}`;
+        const display = parsed.useTmpdir ? `${parent.replace(/\/+$/u, "")}/${generated}` : generated;
+        const path = pathOf(context, display);
+        if (mktempEncoder.encode(display).byteLength + 1 > configured.limits.maxOutputBytes) throw new FsError("EFBIG", { message: "temporary pathname output exceeds limit" });
+        if (parsed.dryRun) {
+          try {
+            await context.fs.lstat(path, { signal: context.signal });
+            continue;
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (codeOf(error) !== "ENOENT") throw error;
+          }
+        } else {
+          const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
+          if (capabilities.readOnly === true) throw new FsError("EROFS", { syscall: "mktemp" });
+          if (capabilities.permissions !== true) throw new FsError("ENOTSUP", { syscall: "mktemp", message: "private temporary creation requires declared permission support" });
+          try {
+            const mask = configuredUmask ?? Reflect.get(context.fs, creationUmask);
+            const activeUmask = typeof mask === "number" ? mask : configured.umask;
+            const mode = (parsed.directory ? 448 : 384) & ~activeUmask;
+            if (parsed.directory) await context.fs.mkdir(path, { mode, recursive: false, signal: context.signal });
+            else await context.fs.writeFile(path, new Uint8Array(), { mode, flag: "wx", signal: context.signal });
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (codeOf(error) !== "EEXIST") throw error;
+            continue;
+          }
+        }
+        await budget.output(`${display}
+`);
+        return { exitCode: 0 };
+      }
+      throw new FsError("EEXIST", { syscall: "mktemp", message: "temporary name collision limit exceeded" });
+    } catch (error) {
+      context.signal.throwIfAborted();
+      if (!parsed.quiet) await diagnostic(context, error);
+      return { exitCode: 1 };
+    }
+  });
+}
+
+export {
+  evalSyncMktemp,
+  createMktempCommand
+};

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])

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

@@ -0,0 +1,14 @@
+import {
+  init_platform
+} from "../../chunks/chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/chmod/index.ts
+init_platform();
+import { chmodCommands, createChmodCommand, createChmodCommands, evalSyncChmod, modeChange } from "../../../safe-bash-command-chmod/index.js";
+export {
+  chmodCommands,
+  createChmodCommand,
+  createChmodCommands,
+  evalSyncChmod,
+  modeChange
+};

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

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

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

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

package/dist/safe-bash/commands/metadata/chmod.d.ts

@@ -1,8 +1,2 @@
-export { modeChange } from "../../../safe-bash-io-engine/commands/mode-change.js";
-import { type MetadataCommandsOptions } from "./internal.js";
-export declare function createChmodCommand(configuration?: MetadataCommandsOptions): import("../../../safe-bash-contracts/command.js").CommandDefinition;
-export declare function evalSyncChmod(opArgs: readonly string[], umask: number, chmodNodeSync?: (filePath: string, change: (stat: {
-    type: "file" | "directory" | "symlink";
-    mode: number;
-}) => number) => boolean): string | undefined;
+export * from "../../../safe-bash-command-chmod/command.js";
 //# sourceMappingURL=chmod.d.ts.map