@poe-platform/safe-bash 0.1.800 → 0.1.802

package/dist/safe-bash/chunks/chunk-VSAJ4OTM.js

@@ -0,0 +1,962 @@
+import {
+  byteLength
+} from "./chunk-D3ANYGMC.js";
+import {
+  FsError
+} from "./chunk-VTH3MLDU.js";
+import {
+  validatePath,
+  yieldTurn
+} from "./chunk-NZQXYWA3.js";
+import {
+  writeBytes
+} from "./chunk-74GHTNJA.js";
+import {
+  UsageError,
+  codeOf,
+  diagnostic,
+  options,
+  pathOf,
+  registerDefaultExecutors,
+  requireOperands,
+  syncCommandEvaluators,
+  value
+} from "./chunk-E7OYNDGL.js";
+import {
+  init_platform
+} from "./chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/metadata/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/metadata/chmod.ts
+init_platform();
+import { modeChange } from "../../safe-bash-io-engine/commands/mode-change.js";
+import { modeChange as modeChange2 } from "../../safe-bash-io-engine/commands/mode-change.js";
+import { bindConditionalMutation } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash/src/fs/creation-mask.ts
+init_platform();
+import { abortManagedController, addAbortSignalWaiter, builtInDirectContextExecutors, chargeRuntimeFileSystemOperation, combineManagedSignals, createManagedControlController, creationUmask, getRuntimeBackingFileSystem, interruptible, isManagedAbortSignal, isManagedControlSignal, isSyncResolved, notifyAbortSignalWaiters, registerManagedAbortSignal, registerRuntimeBackingFileSystem, removeAbortSignalWaiter, syncCommandEvaluators as syncCommandEvaluators2, toNativeAbortSignal } from "../../safe-bash-contracts/runtime-control.js";
+
+// packages/safe-bash/src/commands/gnu-information.ts
+init_platform();
+import { gnuInformation, gnuInformationSync } from "../../safe-bash-io-engine/gnu-information.js";
+
+// packages/safe-bash/src/commands/metadata/internal.ts
+init_platform();
+function settings(options2 = {}) {
+  const limits = { maxEntries: Infinity, maxDepth: Infinity, maxOutputBytes: Infinity, maxArgumentBytes: Infinity, maxAttempts: Infinity, maxArguments: Infinity, ...options2.limits };
+  for (const [key, value2] of Object.entries(limits)) {
+    if (value2 !== Infinity && (!Number.isSafeInteger(value2) || value2 < (key === "maxDepth" ? 0 : 1))) throw new RangeError(`Invalid metadata limit: ${key}`);
+  }
+  const umask = options2.umask ?? 18;
+  if (!Number.isInteger(umask) || umask < 0 || umask > 511) throw new RangeError("Invalid metadata umask");
+  return { limits, umask };
+}
+var MetadataBudget = class {
+  constructor(context, limits) {
+    this.context = context;
+    this.limits = limits;
+    if (context.args.reduce((size, argument) => size + byteLength(argument), 0) > limits.maxArgumentBytes) throw new FsError("EFBIG", { message: "metadata argument limit exceeded" });
+  }
+  context;
+  limits;
+  entries = 0;
+  outputBytes = 0;
+  get remainingEntries() {
+    return this.limits.maxEntries - this.entries;
+  }
+  async step(depth = 0) {
+    this.context.signal.throwIfAborted();
+    if (++this.entries > this.limits.maxEntries || depth > this.limits.maxDepth) throw new FsError("EFBIG", { message: "metadata traversal limit exceeded" });
+    if (this.entries % 128 === 0) await yieldTurn();
+    this.context.signal.throwIfAborted();
+  }
+  async output(text) {
+    const bytes = typeof text === "string" ? new TextEncoder().encode(text) : text;
+    if (bytes.byteLength > this.limits.maxOutputBytes - this.outputBytes) throw new FsError("EFBIG", { message: "metadata output limit exceeded" });
+    this.outputBytes += bytes.byteLength;
+    await writeBytes(this.context.stdout, bytes, this.context.signal);
+  }
+};
+function metadataCommand(name, handler) {
+  return { name, async execute(context) {
+    context.signal.throwIfAborted();
+    try {
+      const infoPromise = gnuInformation(name, context);
+      if (infoPromise) {
+        const info = await infoPromise;
+        if (info) return info;
+      }
+      return await handler(context);
+    } catch (error) {
+      context.signal.throwIfAborted();
+      await diagnostic(context, error);
+      return { exitCode: 1 };
+    }
+  } };
+}
+function permissionString(mode, type) {
+  let text = type === "directory" ? "d" : type === "symlink" ? "l" : type === "character" ? "c" : "-";
+  for (const [read, write, execute, special, lower, upper] of [
+    [256, 128, 64, 2048, "s", "S"],
+    [32, 16, 8, 1024, "s", "S"],
+    [4, 2, 1, 512, "t", "T"]
+  ]) {
+    text += mode & read ? "r" : "-";
+    text += mode & write ? "w" : "-";
+    text += mode & special ? mode & execute ? lower : upper : mode & execute ? "x" : "-";
+  }
+  return text;
+}
+
+// packages/safe-bash/src/commands/metadata/chmod.ts
+function createChmodCommand(configuration = {}) {
+  const configured = settings(configuration);
+  const configuredUmask = configuration.umask === void 0 ? void 0 : configured.umask;
+  return metadataCommand("chmod", async (context) => {
+    const budget = new MetadataBudget(context, configured.limits);
+    const modeOptions = [];
+    let ended = false, referenceValue = false;
+    const args = context.args.flatMap((argument) => {
+      if (referenceValue) {
+        referenceValue = false;
+        return [argument];
+      }
+      if (argument === "--") ended = true;
+      if (ended) return [argument];
+      if (argument === "--reference") referenceValue = true;
+      if (argument.startsWith("-") && argument.length > 1 && "rwxXstugo01234567".includes(argument[1])) {
+        modeOptions.push(argument);
+        return [];
+      }
+      return [argument];
+    });
+    const parsed = options(args, "Rvcf", { recursive: "R", verbose: "v", changes: "c", silent: "f", quiet: "f", reference: "reference:" });
+    const reference = value(parsed, "reference");
+    if (reference !== void 0 && modeOptions.length) throw new UsageError("cannot combine mode and --reference options");
+    requireOperands(parsed.operands, reference === void 0 && !modeOptions.length ? 2 : 1);
+    const mode = modeOptions.length ? modeOptions.join(",") : reference === void 0 ? parsed.operands.shift() : void 0;
+    const mask = configuredUmask ?? Reflect.get(context.fs, creationUmask);
+    const activeUmask = typeof mask === "number" ? mask : configured.umask;
+    const change = mode === void 0 ? void 0 : modeChange(mode, activeUmask);
+    const paths = parsed.operands;
+    if (context.fs.capabilities.readOnly) throw new FsError("EROFS", { syscall: "chmod" });
+    if (!context.fs.chmod || context.fs.capabilities.permissions === false) throw new FsError("ENOTSUP", { syscall: "chmod" });
+    const referenceMode = reference === void 0 ? void 0 : (await context.fs.stat(pathOf(context, reference), { signal: context.signal })).mode & 4095;
+    let exitCode = 0;
+    const visit = async (path, display, depth, top) => {
+      await budget.step(depth);
+      const link = await context.fs.lstat(path, { signal: context.signal });
+      if (link.type === "symlink" && !top) return;
+      const target = link.type === "symlink" ? await context.fs.realpath(path, { signal: context.signal }) : path;
+      const stat = link.type === "symlink" ? await context.fs.stat(target, { signal: context.signal }) : link;
+      const mode2 = referenceMode ?? change(stat);
+      if (parsed.flags.has("R") && stat.type === "directory" && await context.fs.realpath(target, { signal: context.signal }) === "/") throw new FsError("EBUSY", { syscall: "chmod", path, message: "refusing recursive mode changes at virtual root" });
+      const canonicalTarget = await context.fs.realpath(target, { signal: context.signal });
+      const apply = async () => {
+        context.signal.throwIfAborted();
+        const currentCanonical = await context.fs.realpath(target, { signal: context.signal });
+        if (currentCanonical !== canonicalTarget) throw new FsError("EIO", { syscall: "chmod", path, message: "path changed during permission update" });
+        const fresh = await context.fs.lstat(canonicalTarget, { signal: context.signal });
+        if (fresh.type === "symlink" || fresh.type !== stat.type || stat.ino !== void 0 && fresh.ino !== stat.ino || stat.dev !== void 0 && fresh.dev !== stat.dev) throw new FsError("EIO", { syscall: "chmod", path, message: "path changed during permission update" });
+        const capabilities = await context.fs.capabilitiesFor?.(canonicalTarget, { signal: context.signal, conditionalChmod: true }) ?? context.fs.capabilities;
+        context.signal.throwIfAborted();
+        if (capabilities.conditionalChmod !== true) throw new FsError("ENOTSUP", { syscall: "chmod", path, message: "conditional permission updates are not supported" });
+        const parentPath = canonicalTarget.slice(0, canonicalTarget.lastIndexOf("/")) || "/";
+        const ancestorPaths = ["/"];
+        if (parentPath !== "/") {
+          let prefix = "";
+          for (const part of parentPath.split("/").filter(Boolean)) {
+            prefix += `/${part}`;
+            ancestorPaths.push(prefix);
+          }
+        }
+        const ancestors = await Promise.all(ancestorPaths.map(async (entryPath) => ({
+          path: entryPath,
+          stat: await context.fs.lstat(entryPath, { signal: context.signal })
+        })));
+        const parentStat = ancestors.at(-1).stat;
+        const mutation = { signal: context.signal, parent: parentStat, expected: fresh, ancestors };
+        await bindConditionalMutation(
+          fresh.identityScope,
+          { path: canonicalTarget, parent: parentStat, expected: fresh, ancestors },
+          () => context.fs.chmod(canonicalTarget, mode2, mutation)
+        );
+        if (parsed.flags.has("v") || parsed.flags.has("c") && mode2 !== (stat.mode & 4095)) {
+          await budget.output(`mode of '${display}' ${mode2 === (stat.mode & 4095) ? "retained as" : "changed from " + (stat.mode & 4095).toString(8).padStart(4, "0") + " (" + permissionString(stat.mode, stat.type).slice(1) + ") to"} ${mode2.toString(8).padStart(4, "0")} (${permissionString(mode2, stat.type).slice(1)})
+`);
+        }
+      };
+      const deferred = stat.type === "directory" && parsed.flags.has("R") && (stat.mode & 511 & ~mode2) !== 0;
+      if (!deferred) await apply();
+      if (stat.type === "directory" && parsed.flags.has("R")) {
+        const entries = await context.fs.readdir(target, {
+          signal: context.signal,
+          ...Number.isFinite(budget.remainingEntries) ? { maxEntries: budget.remainingEntries } : {}
+        });
+        if (entries.length > budget.remainingEntries) throw new FsError("EFBIG", { message: "metadata traversal limit exceeded" });
+        for (const entry of entries) {
+          if (!entry.name || entry.name === "." || entry.name === ".." || entry.name.includes("/") || entry.name.includes("\0")) throw new FsError("EIO", { message: "invalid directory entry" });
+          try {
+            await visit(`${target.replace(/\/$/u, "")}/${entry.name}`, `${display.replace(/\/$/u, "")}/${entry.name}`, depth + 1, false);
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (codeOf(error) === "EFBIG") throw error;
+            exitCode = 1;
+            if (!parsed.flags.has("f")) await diagnostic(context, error);
+          }
+        }
+      }
+      if (deferred) await apply();
+    };
+    for (const operand of paths) {
+      try {
+        await visit(pathOf(context, operand), operand, 0, true);
+      } catch (error) {
+        context.signal.throwIfAborted();
+        if (codeOf(error) === "EFBIG") throw error;
+        exitCode = 1;
+        if (!parsed.flags.has("f")) await diagnostic(context, error);
+      }
+    }
+    return { exitCode };
+  });
+}
+function evalSyncChmod(opArgs, umask, chmodNodeSync) {
+  const gnuInfo = gnuInformationSync("chmod", opArgs);
+  if (gnuInfo !== void 0) return gnuInfo;
+  if (!chmodNodeSync) return void 0;
+  try {
+    const modeOptions = [];
+    let ended = false;
+    let referenceValue = false;
+    const args = [];
+    for (const argument of opArgs) {
+      if (referenceValue) {
+        referenceValue = false;
+        args.push(argument);
+        continue;
+      }
+      if (argument === "--") {
+        ended = true;
+        args.push(argument);
+        continue;
+      }
+      if (!ended && argument === "--reference") {
+        referenceValue = true;
+        args.push(argument);
+        continue;
+      }
+      if (!ended && argument.startsWith("-") && argument.length > 1 && "rwxXstugo01234567".includes(argument[1])) {
+        modeOptions.push(argument);
+        continue;
+      }
+      args.push(argument);
+    }
+    const parsed = options(args, "vcf", { verbose: "v", changes: "c", silent: "f", quiet: "f", reference: "reference:" });
+    const reference = value(parsed, "reference");
+    if (reference !== void 0 && modeOptions.length) return void 0;
+    const minOps = reference !== void 0 || modeOptions.length ? 1 : 2;
+    if (parsed.operands.length < minOps) return void 0;
+    let referenceMode;
+    if (reference !== void 0) {
+      if (!chmodNodeSync(reference, (stat) => {
+        referenceMode = stat.mode & 4095;
+        return stat.mode;
+      }) || referenceMode === void 0) {
+        return void 0;
+      }
+    }
+    const mode = modeOptions.length ? modeOptions.join(",") : reference === void 0 ? parsed.operands.shift() : void 0;
+    const change = mode === void 0 ? void 0 : modeChange(mode, umask);
+    let out = "";
+    for (const op of parsed.operands) {
+      let line = "";
+      const ok = chmodNodeSync(op, (stat) => {
+        const oldMode = stat.mode & 4095;
+        const nextMode = (referenceMode ?? change(stat)) & 4095;
+        if (parsed.flags.has("v") || parsed.flags.has("c") && nextMode !== oldMode) {
+          line = `mode of '${op}' ${nextMode === oldMode ? "retained as" : "changed from " + oldMode.toString(8).padStart(4, "0") + " (" + permissionString(oldMode, stat.type).slice(1) + ") to"} ${nextMode.toString(8).padStart(4, "0")} (${permissionString(nextMode, stat.type).slice(1)})
+`;
+        }
+        return nextMode;
+      });
+      if (!ok) return void 0;
+      out += line;
+    }
+    return out;
+  } catch {
+    return void 0;
+  }
+}
+syncCommandEvaluators.evalSyncChmod = evalSyncChmod;
+
+// packages/safe-bash/src/commands/metadata/stat.ts
+init_platform();
+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(value2, field) {
+  if (value2 === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: `filesystem does not expose ${field}` });
+  if (!Number.isFinite(value2)) throw new FsError("EIO", { syscall: "stat", message: `invalid ${field}` });
+  return value2;
+}
+function timestamp(milliseconds) {
+  const value2 = available(milliseconds, "timestamp");
+  if (Math.abs(value2) > 864e13) throw new FsError("EIO", { message: "invalid filesystem timestamp" });
+  const [coefficient = "0", exponent = "0"] = Math.abs(value2).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 = value2 < 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 value2 = available(milliseconds, "timestamp");
+  const [coefficient = "0", exponent = "0"] = Math.abs(value2).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 = value2 < 0 && fraction === 0n ? -Math.floor(value2 / 1e3) : absolute / scale;
+  const suffix = precision ? "." + fraction.toString().padStart(places, "0") + "0".repeat(precision - places) : "";
+  return `${value2 < 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 value2 = 0;
+      while (offset < end) {
+        const digit = "0123456789abcdef".indexOf(format[offset].toLowerCase());
+        if (digit < 0 || digit >= radix) break;
+        value2 = value2 * radix + digit;
+        offset++;
+      }
+      if (offset === start) {
+        append(format[index++]);
+        continue;
+      }
+      append(Uint8Array.of(value2));
+      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 value2 = times[code.toUpperCase()];
+      text = code === "w" && value2 === void 0 ? "-" : timestamp(available(value2, 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 value2 = fields[code];
+      text = terse && value2 === void 0 ? "?" : available(value2, 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 value2 = 0;
+      while (offset < end) {
+        const digit = "0123456789abcdef".indexOf(format[offset].toLowerCase());
+        if (digit < 0 || digit >= radix) break;
+        value2 = value2 * radix + digit;
+        offset++;
+      }
+      if (offset === start) {
+        append(format[index++]);
+        continue;
+      }
+      append(Uint8Array.of(value2));
+      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 value2 = times[code.toUpperCase()];
+      text = code === "w" && value2 === void 0 ? "-" : timestamp(available(value2, 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 value2 = fields[code];
+      text = terse && value2 === void 0 ? "?" : available(value2, 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));
+}
+
+// packages/safe-bash/src/commands/metadata/mktemp.ts
+init_platform();
+
+// packages/safe-bash/src/commands/portable-random.ts
+init_platform();
+function randomInteger(maximum) {
+  const range = 4294967296;
+  if (!Number.isSafeInteger(maximum) || maximum < 1 || maximum > range) {
+    throw new RangeError("Random integer maximum must be an integer from 1 to 2^32");
+  }
+  const limit = Math.floor(range / maximum) * maximum;
+  const sample = new Uint32Array(1);
+  do {
+    globalThis.crypto.getRandomValues(sample);
+  } while (sample[0] >= limit);
+  return sample[0] % maximum;
+}
+
+// packages/safe-bash/src/commands/metadata/mktemp.ts
+var mktempEncoder = new TextEncoder();
+function parse2(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 = parse2(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 = parse2(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 };
+    }
+  });
+}
+
+// packages/safe-bash/src/commands/truncate.ts
+init_platform();
+import {} from "../../safe-bash-command-truncate/index.js";
+import { createTruncateCommand, createTruncateCommands, truncateCommand, truncateCommands, evalSyncTruncate } from "../../safe-bash-command-truncate/index.js";
+
+// packages/safe-bash/src/commands/metadata/index.ts
+import { evalSyncTruncate as evalSyncTruncate2 } from "../../safe-bash-command-truncate/index.js";
+function createMetadataCommands(options2 = {}) {
+  settings(options2);
+  return registerDefaultExecutors([createChmodCommand(options2), createStatCommand(options2), createMktempCommand(options2), truncateCommand(options2)], options2);
+}
+function metadataCommands(options2 = {}) {
+  const commands = createMetadataCommands(options2);
+  return { name: "metadata-commands", setup(host) {
+    if (!options2.replace) {
+      for (const command of commands) if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
+    }
+    for (const command of commands) host.commands.register(command, { replace: options2.replace ?? false });
+  } };
+}
+
+export {
+  abortManagedController,
+  addAbortSignalWaiter,
+  combineManagedSignals,
+  createManagedControlController,
+  creationUmask,
+  getRuntimeBackingFileSystem,
+  interruptible,
+  isManagedAbortSignal,
+  isSyncResolved,
+  registerManagedAbortSignal,
+  removeAbortSignalWaiter,
+  gnuInformationSync,
+  modeChange2 as modeChange,
+  evalSyncStat,
+  evalSyncMktemp,
+  createMetadataCommands,
+  metadataCommands,
+  evalSyncTruncate2 as evalSyncTruncate
+};