@poe-platform/safe-bash 0.1.802 → 0.1.803

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

@@ -0,0 +1,466 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-stat/src/command.ts
+init_buffer();
+import { FsError } from "../../safe-bash-contracts/index.js";
+import { codeOf, diagnostic, pathOf, requireOperands, UsageError } from "../../safe-bash-io-engine/internal.js";
+import { MetadataBudget, metadataCommand, permissionString, settings } from "../../safe-bash-metadata-engine/index.js";
+var syncStatEncoder = new TextEncoder();
+function concatBytes(chunks) {
+  if (chunks.length === 0) return new Uint8Array(0);
+  if (chunks.length === 1) return chunks[0];
+  let total = 0;
+  for (let i = 0; i < chunks.length; i++) total += chunks[i].byteLength;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    const c = chunks[i];
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+function allocSpaces(length) {
+  const out = new Uint8Array(length);
+  out.fill(32);
+  return out;
+}
+function parse(args) {
+  let follow = false;
+  let filesystem = false;
+  let terse = false;
+  let format;
+  let printf = false;
+  let literal = false;
+  const paths = [];
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (literal || argument === "-" || !argument.startsWith("-")) paths.push(argument);
+    else if (argument === "--") literal = true;
+    else if (argument === "--dereference") follow = true;
+    else if (argument === "--cached=default" || argument === "--cached=never" || argument === "--cached=always") continue;
+    else if (argument === "--file-system") filesystem = true;
+    else if (argument === "--terse") terse = true;
+    else if (argument === "--format" || argument.startsWith("--format=") || argument === "--printf" || argument.startsWith("--printf=")) {
+      printf = argument.startsWith("--printf");
+      format = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : args[++index];
+      if (format === void 0) throw new UsageError(`missing format for '${argument}'`);
+    } else if (!argument.startsWith("--")) {
+      for (let offset = 1; offset < argument.length; offset++) {
+        if (argument[offset] === "L") follow = true;
+        else if (argument[offset] === "f") filesystem = true;
+        else if (argument[offset] === "t") terse = true;
+        else if (argument[offset] === "c") {
+          format = argument.slice(offset + 1) || args[++index];
+          if (format === void 0) throw new UsageError("missing format for '-c'");
+          printf = false;
+          break;
+        } else throw new UsageError(`unrecognized option '${argument}'`);
+      }
+    } else throw new UsageError(`unrecognized option '${argument}'`);
+  }
+  requireOperands(paths);
+  return { follow, filesystem, terse, format, printf, paths };
+}
+function quoted(text, style) {
+  if (style === "literal") return text;
+  if (style && !["shell-escape-always", "shell-always"].includes(style)) throw new FsError("ENOTSUP", { message: `unsupported QUOTING_STYLE: ${style}` });
+  if (style !== "shell-always" && /[\x00-\x1f\x7f]/u.test(text)) {
+    return "$'" + text.replace(/[\\'\x00-\x1f\x7f]/gu, (character) => {
+      if (character === "\\" || character === "'") return `\\${character}`;
+      if (character === "\n") return "\\n";
+      if (character === "\r") return "\\r";
+      if (character === "	") return "\\t";
+      return `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}`;
+    }) + "'";
+  }
+  return `'${text.replace(/'/gu, "'\\''")}'`;
+}
+function available(value, field) {
+  if (value === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: `filesystem does not expose ${field}` });
+  if (!Number.isFinite(value)) throw new FsError("EIO", { syscall: "stat", message: `invalid ${field}` });
+  return value;
+}
+function timestamp(milliseconds) {
+  const value = available(milliseconds, "timestamp");
+  if (Math.abs(value) > 864e13) throw new FsError("EIO", { message: "invalid filesystem timestamp" });
+  const [coefficient = "0", exponent = "0"] = Math.abs(value).toString().split("e");
+  const [integer = "0", fraction = ""] = coefficient.split(".");
+  const digits = BigInt(integer + fraction);
+  const power = Number(exponent) - fraction.length + 6;
+  const divisor = power < 0 ? 10n ** BigInt(-power) : 1n;
+  const magnitude = power < 0 ? (digits + divisor / 2n) / divisor : digits * 10n ** BigInt(power);
+  const nanoseconds = value < 0 ? -magnitude : magnitude;
+  const remainder = (nanoseconds % 1000000000n + 1000000000n) % 1000000000n;
+  const seconds = (nanoseconds - remainder) / 1000000000n;
+  const date = new Date(Number(seconds * 1000n));
+  if (Number.isNaN(date.getTime())) throw new FsError("EIO", { message: "invalid filesystem timestamp" });
+  return `${date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/u, `.${remainder.toString().padStart(9, "0")}`)} +0000`;
+}
+function epoch(milliseconds, precision) {
+  const value = available(milliseconds, "timestamp");
+  const [coefficient = "0", exponent = "0"] = Math.abs(value).toString().split("e");
+  const [integer = "0", decimal = ""] = coefficient.split(".");
+  const digits = BigInt(integer + decimal);
+  const places = Math.min(precision, 9);
+  const scale = 10n ** BigInt(places);
+  const power = Number(exponent) - decimal.length - 3 + places;
+  const absolute = power < 0 ? digits / 10n ** BigInt(-power) : digits * 10n ** BigInt(power);
+  const fraction = absolute % scale;
+  const seconds = value < 0 && fraction === 0n ? -Math.floor(value / 1e3) : absolute / scale;
+  const suffix = precision ? "." + fraction.toString().padStart(places, "0") + "0".repeat(precision - places) : "";
+  return `${value < 0 ? "-" : ""}${seconds}${suffix}`;
+}
+function directive(format, start) {
+  let index = start + 1;
+  const flagsStart = index;
+  while (index < format.length && "-+ #0".includes(format[index])) index++;
+  const flags = format.slice(flagsStart, index);
+  const widthStart = index;
+  while (index < format.length && format[index] >= "0" && format[index] <= "9") index++;
+  const width = format.slice(widthStart, index);
+  let precision;
+  if (format[index] === ".") {
+    const precisionStart = ++index;
+    while (index < format.length && format[index] >= "0" && format[index] <= "9") index++;
+    precision = format.slice(precisionStart, index);
+  }
+  const code = format[index];
+  if (code === void 0) throw new UsageError("invalid stat format directive");
+  const codePoint = code.charCodeAt(0);
+  if (code !== "%" && !(codePoint >= 65 && codePoint <= 90) && !(codePoint >= 97 && codePoint <= 122)) {
+    throw new UsageError("invalid stat format directive");
+  }
+  return { code, flags, length: index + 1 - start, precision, width };
+}
+function formatField(text, code, flags, width, precision, numeric, epoch2) {
+  if (numeric) {
+    const nonzero = !/^0+$/u.test(text);
+    if (!epoch2 && precision !== void 0) text = precision === 0 && !nonzero ? "" : text.padStart(precision, "0");
+    if (flags.includes("#")) text = code === "a" ? text.startsWith("0") ? text : `0${text}` : (code === "f" || code === "D") && nonzero ? `0x${text}` : text;
+    if (epoch2 && !text.startsWith("-") && (flags.includes("+") || flags.includes(" "))) text = `${flags.includes("+") ? "+" : " "}${text}`;
+  }
+  if (epoch2 && precision) {
+    const decimal = text.indexOf(".");
+    const integerWidth = width > precision + 2 && !flags.includes("-") ? width - precision - 1 : 0;
+    const integer = formatField(text.slice(0, decimal), code, flags, integerWidth, void 0, true, false);
+    const trailingWidth = integer.length < width && 1 < width - integer.length ? Math.abs(width - integer.length - 1 - precision) : 0;
+    return concatBytes([integer, syncStatEncoder.encode(text.slice(decimal)), allocSpaces(trailingWidth)]);
+  }
+  const encoded = syncStatEncoder.encode(text);
+  const bytes = !numeric && precision !== void 0 ? encoded.subarray(0, precision) : encoded;
+  const padding = Math.max(0, width - bytes.length);
+  if (flags.includes("-")) return concatBytes([bytes, allocSpaces(padding)]);
+  if (numeric && flags.includes("0") && (epoch2 || precision === void 0) && padding) {
+    const prefix = /^[+ -]|^0x/u.exec(text)?.[0] ?? "";
+    return syncStatEncoder.encode(prefix + "0".repeat(padding) + text.slice(prefix.length));
+  }
+  return concatBytes([allocSpaces(padding), bytes]);
+}
+async function render(context, path, name, stat, format, escapes, limit, filesystem, terse) {
+  const chunks = [];
+  let bytes = 0;
+  const append = (text) => {
+    const chunk = typeof text === "string" ? new TextEncoder().encode(text) : text;
+    bytes += chunk.byteLength;
+    if (bytes > limit) throw new FsError("EFBIG", { message: "stat format output limit exceeded" });
+    chunks.push(chunk);
+  };
+  for (let index = 0; index < format.length; ) {
+    context.signal.throwIfAborted();
+    if (escapes && format[index] === "\\") {
+      const named = { a: "\x07", b: "\b", e: "\x1B", f: "\f", n: "\n", r: "\r", t: "	", v: "\v", "\\": "\\", '"': '"' };
+      const code2 = format[index + 1] ?? "";
+      if (Object.hasOwn(named, code2)) {
+        append(named[code2]);
+        index += 2;
+        continue;
+      }
+      const radix = code2 === "x" ? 16 : 8;
+      const start = index + (radix === 16 ? 2 : 1);
+      const end = Math.min(format.length, start + (radix === 16 ? 2 : 3));
+      let offset = start;
+      let value = 0;
+      while (offset < end) {
+        const digit = "0123456789abcdef".indexOf(format[offset].toLowerCase());
+        if (digit < 0 || digit >= radix) break;
+        value = value * radix + digit;
+        offset++;
+      }
+      if (offset === start) {
+        append(format[index++]);
+        continue;
+      }
+      append(Uint8Array.of(value));
+      index = offset;
+      continue;
+    }
+    if (format[index] !== "%") {
+      const point = String.fromCodePoint(format.codePointAt(index));
+      append(point);
+      index += point.length;
+      continue;
+    }
+    const parsed = directive(format, index);
+    index += parsed.length;
+    const { code, flags } = parsed;
+    const width = Number(parsed.width || 0);
+    if (!Number.isSafeInteger(width) || width > limit) throw new FsError("EFBIG", { message: "stat format width limit exceeded" });
+    const epochCode = !filesystem && ["X", "Y", "Z", "W"].includes(code);
+    const precision = parsed.precision === void 0 ? void 0 : Number(parsed.precision || (epochCode ? 9 : 0));
+    if (precision !== void 0 && (!Number.isSafeInteger(precision) || precision > limit)) throw new FsError("EFBIG", { message: "stat format precision limit exceeded" });
+    if (code === "%" && parsed.length !== 2) throw new UsageError("invalid stat format directive");
+    if (filesystem) {
+      let text2;
+      if (code === "n") text2 = name;
+      else if (code === "%") text2 = "%";
+      else if (code === "T") {
+        if (stat.filesystemType === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: "filesystem does not expose its type" });
+        if (typeof stat.filesystemType !== "string" || stat.filesystemType.length === 0) throw new FsError("EIO", { syscall: "stat", message: "invalid filesystem type" });
+        text2 = stat.filesystemType;
+      } else throw new FsError("ENOTSUP", { message: `unsupported filesystem stat format: %${code}` });
+      append(formatField(text2, code, flags, width, precision, false, false));
+      continue;
+    }
+    let text;
+    let linkText;
+    let numeric = false;
+    if (["a", "A", "f"].includes(code)) available(stat.mode, "mode");
+    const times = { X: stat.atimeMs, Y: stat.mtimeMs, Z: stat.ctimeMs, W: stat.birthtimeMs };
+    if (Object.hasOwn(times, code)) {
+      text = terse && times[code] === void 0 ? "?" : epoch(available(times[code], code), precision ?? 0);
+      numeric = text !== "?";
+    } else if (code === "n") text = name;
+    else if (code === "N") {
+      text = quoted(name, context.env.QUOTING_STYLE);
+      if (stat.type === "symlink") {
+        if (!context.fs.readlink) throw new FsError("ENOTSUP", { syscall: "readlink", path });
+        linkText = quoted(await context.fs.readlink(path, { signal: context.signal }), context.env.QUOTING_STYLE);
+      }
+    } else if (code === "%") text = "%";
+    else if (code === "A") text = permissionString(stat.mode, stat.type);
+    else if (code === "U") text = available(stat.uid, "u") === 0 ? "root" : String(stat.uid);
+    else if (code === "G") text = available(stat.gid, "g") === 0 ? "root" : String(stat.gid);
+    else if (code === "m") text = "/";
+    else if (code === "F") text = stat.type === "directory" ? "directory" : stat.type === "symlink" ? "symbolic link" : stat.type === "character" ? "character special file" : stat.size === 0 ? "regular empty file" : "regular file";
+    else if (["x", "y", "z", "w"].includes(code)) {
+      const value = times[code.toUpperCase()];
+      text = code === "w" && value === void 0 ? "-" : timestamp(available(value, code));
+    } else {
+      const fields = {
+        s: stat.size,
+        a: stat.mode & 4095,
+        f: stat.mode,
+        i: stat.ino,
+        h: stat.nlink,
+        u: stat.uid,
+        g: stat.gid,
+        d: stat.dev,
+        D: stat.dev,
+        B: 512,
+        b: stat.allocatedBytes === void 0 ? void 0 : Math.ceil(stat.allocatedBytes / 512),
+        o: stat.ioBlockSize,
+        t: stat.rdevMajor,
+        T: stat.rdevMinor
+      };
+      if (!Object.hasOwn(fields, code)) throw new FsError("ENOTSUP", { message: `unsupported stat format: %${code}` });
+      const value = fields[code];
+      text = terse && value === void 0 ? "?" : available(value, code).toString(code === "a" ? 8 : ["f", "D", "t", "T"].includes(code) ? 16 : 10);
+      numeric = text !== "?";
+    }
+    append(formatField(text, code, flags, width, precision, numeric, epochCode));
+    if (linkText !== void 0) {
+      append(" -> ");
+      append(formatField(linkText, code, flags, width, precision, false, false));
+    }
+  }
+  return concatBytes(chunks);
+}
+function createStatCommand(configuration = {}) {
+  const configured = settings(configuration);
+  return metadataCommand("stat", async (context) => {
+    const budget = new MetadataBudget(context, configured.limits);
+    const parsed = parse(context.args);
+    let exitCode = 0;
+    for (const name of parsed.paths) {
+      await budget.step();
+      try {
+        const path = pathOf(context, name);
+        const stat = await context.fs[parsed.follow || parsed.filesystem ? "stat" : "lstat"](path, { signal: context.signal });
+        const terse = parsed.terse && parsed.format === void 0;
+        if (terse && parsed.filesystem) throw new FsError("ENOTSUP", { message: "filesystem terse stat is unsupported" });
+        const format = parsed.format ?? (parsed.filesystem ? "  File: %n\n  Type: %T" : terse ? "%n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %W %o" : "  File: %N\n  Size: %s	Type: %F\n  Mode: %a (%A)\nAccess: %x\nModify: %y\nChange: %z\n Birth: %w");
+        const text = await render(context, path, name, stat, format, parsed.printf, configured.limits.maxOutputBytes, parsed.filesystem, terse);
+        await budget.output(parsed.printf ? text : concatBytes([text, Uint8Array.of(10)]));
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (codeOf(error) === "EFBIG") throw error;
+        await diagnostic(context, error);
+        exitCode = 1;
+      }
+    }
+    return { exitCode };
+  });
+}
+var syncStatDecoder = new TextDecoder("utf-8", { fatal: false });
+function renderSync(path, name, stat, format, escapes, limit, filesystem, terse, quotingStyle) {
+  const chunks = [];
+  let bytes = 0;
+  const append = (text) => {
+    const chunk = typeof text === "string" ? new TextEncoder().encode(text) : text;
+    bytes += chunk.byteLength;
+    if (bytes > limit) throw new FsError("EFBIG", { message: "stat format output limit exceeded" });
+    chunks.push(chunk);
+  };
+  for (let index = 0; index < format.length; ) {
+    if (escapes && format[index] === "\\") {
+      const named = { a: "\x07", b: "\b", e: "\x1B", f: "\f", n: "\n", r: "\r", t: "	", v: "\v", "\\": "\\", '"': '"' };
+      const code2 = format[index + 1] ?? "";
+      if (Object.hasOwn(named, code2)) {
+        append(named[code2]);
+        index += 2;
+        continue;
+      }
+      const radix = code2 === "x" ? 16 : 8;
+      const start = index + (radix === 16 ? 2 : 1);
+      const end = Math.min(format.length, start + (radix === 16 ? 2 : 3));
+      let offset = start;
+      let value = 0;
+      while (offset < end) {
+        const digit = "0123456789abcdef".indexOf(format[offset].toLowerCase());
+        if (digit < 0 || digit >= radix) break;
+        value = value * radix + digit;
+        offset++;
+      }
+      if (offset === start) {
+        append(format[index++]);
+        continue;
+      }
+      append(Uint8Array.of(value));
+      index = offset;
+      continue;
+    }
+    if (format[index] !== "%") {
+      const point = String.fromCodePoint(format.codePointAt(index));
+      append(point);
+      index += point.length;
+      continue;
+    }
+    const parsed = directive(format, index);
+    index += parsed.length;
+    const { code, flags } = parsed;
+    const width = Number(parsed.width || 0);
+    if (!Number.isSafeInteger(width) || width > limit) throw new FsError("EFBIG", { message: "stat format width limit exceeded" });
+    const epochCode = !filesystem && ["X", "Y", "Z", "W"].includes(code);
+    const precision = parsed.precision === void 0 ? void 0 : Number(parsed.precision || (epochCode ? 9 : 0));
+    if (precision !== void 0 && (!Number.isSafeInteger(precision) || precision > limit)) throw new FsError("EFBIG", { message: "stat format precision limit exceeded" });
+    if (code === "%" && parsed.length !== 2) throw new UsageError("invalid stat format directive");
+    if (filesystem) {
+      let text2;
+      if (code === "n") text2 = name;
+      else if (code === "%") text2 = "%";
+      else if (code === "T") {
+        if (stat.filesystemType === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: "filesystem does not expose its type" });
+        if (typeof stat.filesystemType !== "string" || stat.filesystemType.length === 0) throw new FsError("EIO", { syscall: "stat", message: "invalid filesystem type" });
+        text2 = stat.filesystemType;
+      } else throw new FsError("ENOTSUP", { message: `unsupported filesystem stat format: %${code}` });
+      append(formatField(text2, code, flags, width, precision, false, false));
+      continue;
+    }
+    let text;
+    let linkText;
+    let numeric = false;
+    if (["a", "A", "f"].includes(code)) available(stat.mode, "mode");
+    const times = { X: stat.atimeMs, Y: stat.mtimeMs, Z: stat.ctimeMs, W: stat.birthtimeMs };
+    if (Object.hasOwn(times, code)) {
+      text = terse && times[code] === void 0 ? "?" : epoch(available(times[code], code), precision ?? 0);
+      numeric = text !== "?";
+    } else if (code === "n") text = name;
+    else if (code === "N") {
+      text = quoted(name, quotingStyle);
+      if (stat.type === "symlink") {
+        if (stat.target === void 0) throw new FsError("ENOTSUP", { syscall: "readlink", path });
+        linkText = quoted(stat.target, quotingStyle);
+      }
+    } else if (code === "%") text = "%";
+    else if (code === "A") text = permissionString(stat.mode, stat.type);
+    else if (code === "U") text = available(stat.uid, "u") === 0 ? "root" : String(stat.uid);
+    else if (code === "G") text = available(stat.gid, "g") === 0 ? "root" : String(stat.gid);
+    else if (code === "m") text = "/";
+    else if (code === "F") text = stat.type === "directory" ? "directory" : stat.type === "symlink" ? "symbolic link" : stat.type === "character" ? "character special file" : stat.size === 0 ? "regular empty file" : "regular file";
+    else if (["x", "y", "z", "w"].includes(code)) {
+      const value = times[code.toUpperCase()];
+      text = code === "w" && value === void 0 ? "-" : timestamp(available(value, code));
+    } else {
+      const fields = {
+        s: stat.size,
+        a: stat.mode & 4095,
+        f: stat.mode,
+        i: stat.ino,
+        h: stat.nlink,
+        u: stat.uid,
+        g: stat.gid,
+        d: stat.dev,
+        D: stat.dev,
+        B: 512,
+        b: stat.allocatedBytes === void 0 ? void 0 : Math.ceil(stat.allocatedBytes / 512),
+        o: stat.ioBlockSize,
+        t: stat.rdevMajor,
+        T: stat.rdevMinor
+      };
+      if (!Object.hasOwn(fields, code)) throw new FsError("ENOTSUP", { message: `unsupported stat format: %${code}` });
+      const value = fields[code];
+      text = terse && value === void 0 ? "?" : available(value, code).toString(code === "a" ? 8 : ["f", "D", "t", "T"].includes(code) ? 16 : 10);
+      numeric = text !== "?";
+    }
+    append(formatField(text, code, flags, width, precision, numeric, epochCode));
+    if (linkText !== void 0) {
+      append(" -> ");
+      append(formatField(linkText, code, flags, width, precision, false, false));
+    }
+  }
+  return concatBytes(chunks);
+}
+function resolveSyncStatPath(cwd, target) {
+  const raw = target.startsWith("/") ? target : cwd.endsWith("/") ? cwd + target : `${cwd}/${target}`;
+  const parts = raw.split("/");
+  const stack = [];
+  for (const part of parts) {
+    if (!part || part === ".") continue;
+    if (part === "..") stack.pop();
+    else stack.push(part);
+  }
+  return "/" + stack.join("/");
+}
+function evalSyncStat(args, cwd, quotingStyle, inspectStat) {
+  let parsed;
+  try {
+    parsed = parse(args);
+  } catch {
+    return void 0;
+  }
+  const outChunks = [];
+  for (const name of parsed.paths) {
+    if (!name) return void 0;
+    const abs = resolveSyncStatPath(cwd, name);
+    const stat = inspectStat(abs, parsed.follow || parsed.filesystem);
+    if (!stat) return void 0;
+    const terse = parsed.terse && parsed.format === void 0;
+    if (terse && parsed.filesystem) return void 0;
+    const format = parsed.format ?? (parsed.filesystem ? "  File: %n\n  Type: %T" : terse ? "%n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %W %o" : "  File: %N\n  Size: %s	Type: %F\n  Mode: %a (%A)\nAccess: %x\nModify: %y\nChange: %z\n Birth: %w");
+    try {
+      const rendered = renderSync(abs, name, stat, format, parsed.printf, 262144, parsed.filesystem, terse, quotingStyle);
+      outChunks.push(parsed.printf ? rendered : concatBytes([rendered, Uint8Array.of(10)]));
+    } catch {
+      return void 0;
+    }
+  }
+  return syncStatDecoder.decode(concatBytes(outChunks));
+}
+
+export {
+  createStatCommand,
+  evalSyncStat
+};

package/dist/safe-bash/command-chunks/{chunk-FPVUD6TH.js → chunk-HDCNKOIX.js}

@@ -95,17 +95,19 @@ function createSyncSingleChunkByteSource(bytes, signal) {
 function requiredFileInput(context, requirements, mode, file, maxBytes) {
   if (maxBytes === Infinity && (context.inputBudget?.maxBytes ?? Infinity) === Infinity) {
     const fastMemFs = context._fastMemoryBackingFs;
-    if (fastMemFs !== void 0 && fastMemFs.capabilitiesFor === void 0 && context._cachedInputBudget === void 0 && !Object.prototype.hasOwnProperty.call(fastMemFs, "readStream") && !Object.prototype.hasOwnProperty.call(fastMemFs, "readFile")) {
+    if (fastMemFs !== void 0 && fastMemFs.capabilitiesFor === void 0 && !Object.prototype.hasOwnProperty.call(fastMemFs, "readStream") && !Object.prototype.hasOwnProperty.call(fastMemFs, "readFile")) {
       const path2 = pathOf(context, file);
       if (path2 !== "/dev" && !path2.startsWith("/dev/")) {
+        let bytes;
         try {
-          const bytes = tryReadMemoryFileViewSync(fastMemFs, path2, void 0, context.signal);
-          if (bytes !== void 0) {
-            context._chargeFastFsOp?.();
-            return createSyncSingleChunkByteSource(bytes, context.signal);
-          }
+          bytes = tryReadMemoryFileViewSync(fastMemFs, path2, void 0, context.signal);
         } catch {
         }
+        if (bytes !== void 0) {
+          context.inputBudget?.check(bytes.byteLength);
+          context._chargeFastFsOp?.();
+          return createSyncSingleChunkByteSource(bytes, context.signal);
+        }
       }
     }
     const path = pathOf(context, file);
@@ -135,9 +137,9 @@ async function* requiredFileInputSlow(context, requirements, mode, file, maxByte
     try {
       for await (const chunk of readBytes(context.fs.readStream(path, { signal: context.signal }), context.signal)) {
         reading = false;
+        context.inputBudget?.check(bytes + chunk.byteLength);
         if (chunk.byteLength > maxBytes - bytes) throw new FsError("EFBIG", { syscall: "read", path, message: "input file byte limit exceeded" });
         bytes += chunk.byteLength;
-        context.inputBudget?.check(bytes);
         if (chunk.byteLength) emitted = true;
         yield chunk;
         reading = true;

package/dist/safe-bash/command-chunks/{chunk-MQFIPHIQ.js → chunk-ILX2NOLF.js}

@@ -167,7 +167,7 @@ function tryExecuteJqFastSync(context, limits) {
   const syncSink = typeof context.stdout.writeSync === "function" ? context.stdout : void 0;
   if (!syncSink) return void 0;
   const fastMemFs = context._fastMemoryBackingFs;
-  if (!fastMemFs || fastMemFs.capabilitiesFor !== void 0 || context._cachedInputBudget !== void 0 || Object.prototype.hasOwnProperty.call(fastMemFs, "readStream") || Object.prototype.hasOwnProperty.call(fastMemFs, "readFile")) {
+  if (!fastMemFs || fastMemFs.capabilitiesFor !== void 0 || Object.prototype.hasOwnProperty.call(fastMemFs, "readStream") || Object.prototype.hasOwnProperty.call(fastMemFs, "readFile")) {
     return void 0;
   }
   const absolute = file.charCodeAt(0) === 47 && file.length > 1 && file.charCodeAt(file.length - 1) !== 47 && !file.includes("//") && !file.includes("/.") ? file : pathOf(context, file);
@@ -178,6 +178,7 @@ function tryExecuteJqFastSync(context, limits) {
   } catch {
     return void 0;
   }
+  if (rawBytes !== void 0) context.inputBudget?.check(rawBytes.byteLength);
   if (!rawBytes || rawBytes.byteLength === 0 || rawBytes[0] !== 123 || rawBytes[rawBytes.byteLength - 1] !== 10) {
     return void 0;
   }
@@ -661,23 +662,25 @@ function inputs(context, options, budget, convert, onValue, onChunkEnd, hasPendi
     const file = options.files[0];
     const absolute = pathOf(context, file);
     const fastMemFs = context._fastMemoryBackingFs;
-    if (fastMemFs !== void 0 && fastMemFs.capabilitiesFor === void 0 && context._cachedInputBudget === void 0 && absolute !== "/dev" && !absolute.startsWith("/dev/") && !Object.prototype.hasOwnProperty.call(fastMemFs, "readStream") && !Object.prototype.hasOwnProperty.call(fastMemFs, "readFile")) {
+    if (fastMemFs !== void 0 && fastMemFs.capabilitiesFor === void 0 && absolute !== "/dev" && !absolute.startsWith("/dev/") && !Object.prototype.hasOwnProperty.call(fastMemFs, "readStream") && !Object.prototype.hasOwnProperty.call(fastMemFs, "readFile")) {
+      let rawBytes;
       try {
-        const rawBytes = tryReadMemoryFileViewSync(fastMemFs, absolute, void 0, context.signal);
-        if (rawBytes !== void 0) {
-          const tickPromise = budget.tickSync();
-          if (tickPromise) {
-            return (async function* () {
-              await tickPromise;
-              yield* inputs(context, options, budget, convert, onValue, onChunkEnd, hasPendingDiagnostics, retainValues);
-            })();
-          }
-          context._chargeFastFsOp?.();
-          budget.inputLocation = { name: file, line: 0, complete: false };
-          source = createSyncSingleChunkByteSource(rawBytes, context.signal);
-        }
+        rawBytes = tryReadMemoryFileViewSync(fastMemFs, absolute, void 0, context.signal);
       } catch {
       }
+      if (rawBytes !== void 0) {
+        context.inputBudget?.check(rawBytes.byteLength);
+        const tickPromise = budget.tickSync();
+        if (tickPromise) {
+          return (async function* () {
+            await tickPromise;
+            yield* inputs(context, options, budget, convert, onValue, onChunkEnd, hasPendingDiagnostics, retainValues);
+          })();
+        }
+        context._chargeFastFsOp?.();
+        budget.inputLocation = { name: file, line: 0, complete: false };
+        source = createSyncSingleChunkByteSource(rawBytes, context.signal);
+      }
     }
     if (source === void 0) {
       const backing = getRuntimeBackingFileSystem(context.fs);

package/dist/safe-bash/command-chunks/{chunk-5E4WAO4O.js → chunk-JD5QNRNO.js}

@@ -79,7 +79,7 @@ function createOptionsParser(profiles2) {
           } else {
             if (!supplied || ![...supplied].every((character) => character >= "0" && character <= "9") || !Number.isSafeInteger(Number(supplied))) throw new UsageError(`invalid --${name} value`);
             const number = Number(supplied);
-            if (name === "threads" && number !== 1) throw new UsageError("only --threads=1 is supported by the single-threaded Zstandard codec");
+            if (name === "threads" && number !== 0 && number !== 1) throw new UsageError("only --threads=0 or --threads=1 is supported by the single-threaded Zstandard codec");
             if (name === "long") {
               if (number < 10 || number > 30) throw new UsageError("long-distance matching requires a window log from 10 through 30");
               result.zstd.window = number;
@@ -208,7 +208,7 @@ function createOptionsParser(profiles2) {
         }
         if (argument === "--threads" || argument.startsWith("--threads=")) {
           const threads = argument === "--threads" ? args[++index] : argument.slice("--threads=".length);
-          if (threads !== "1") throw new UsageError("only --threads=1 is supported by the single-threaded XZ codec");
+          if (threads !== "0" && threads !== "1") throw new UsageError("only --threads=0 or --threads=1 is supported by the single-threaded XZ codec");
           continue;
         }
       }
@@ -254,7 +254,7 @@ function createOptionsParser(profiles2) {
           case "T": {
             if (profile.format !== "xz" && profile.format !== "zstd") throw new UsageError(`invalid option -- '${flag}'`);
             const threads = flags.slice(offset + 1) || args[++index];
-            if (threads !== "1") throw new UsageError(`only --threads=1 is supported by the single-threaded ${profile.format} codec`);
+            if (threads !== "0" && threads !== "1") throw new UsageError(`only --threads=0 or --threads=1 is supported by the single-threaded ${profile.format} codec`);
             offset = flags.length;
             break;
           }

package/dist/safe-bash/command-chunks/{chunk-I237SNW5.js → chunk-LFJJQQND.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-VGG2DL5Q.js";
+} from "./chunk-TRR4MYWF.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

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

package/dist/safe-bash/command-chunks/{chunk-7U7EXOXX.js → chunk-NASVPT6F.js}

@@ -1054,7 +1054,7 @@ function tryExecutePairFastSync(program, context, file, quiet, budget, separator
   const stdoutSync = typeof context.stdout.writeSync === "function" ? context.stdout : void 0;
   if (!stdoutSync) return void 0;
   const fastMem = context._fastMemoryBackingFs;
-  if (!fastMem || fastMem.capabilitiesFor !== void 0 || context._cachedInputBudget !== void 0 || Object.prototype.hasOwnProperty.call(fastMem, "readStream") || Object.prototype.hasOwnProperty.call(fastMem, "readFile")) {
+  if (!fastMem || fastMem.capabilitiesFor !== void 0 || Object.prototype.hasOwnProperty.call(fastMem, "readStream") || Object.prototype.hasOwnProperty.call(fastMem, "readFile")) {
     return void 0;
   }
   const path = pathOf(context, file);
@@ -1066,6 +1066,7 @@ function tryExecutePairFastSync(program, context, file, quiet, budget, separator
     console.error("SED_SYNC_ERR:", e);
     return void 0;
   }
+  if (rawBytes !== void 0) context.inputBudget?.check(rawBytes.byteLength);
   if (!rawBytes || rawBytes.byteLength < 256) return void 0;
   const cachedBatch = getCachedLatin1Batch(rawBytes);
   if (!cachedBatch || cachedBatch.lastLineStart !== cachedBatch.text.length || cachedBatch.maxLineLen > budget.maxBufferBytes) {