@poe-platform/safe-bash 0.1.539 → 0.1.541

package/dist/safe-bash/core.browser.js

@@ -2,12 +2,18 @@ import {
   createGetoptCommand,
   createGetoptCommands,
   getoptCommands
-} from "./chunks/chunk-GV76QENF.js";
+} from "./chunks/chunk-EZLQA6ON.js";
+import {
+  createHdCommand,
+  createHexdumpCommand,
+  createHexdumpCommands,
+  hexdumpCommands
+} from "./chunks/chunk-R3QJL5HH.js";
 import {
   createXmlCommands,
   defaultXmlQueryLimits,
   xmlCommands
-} from "./chunks/chunk-F4UILGOA.js";
+} from "./chunks/chunk-HFEU5SBQ.js";
 import {
   Interpreter,
   createYqCommand,
@@ -18,7 +24,7 @@ import {
   rawValues,
   stringify,
   yqCommands
-} from "./chunks/chunk-QWCD4HKE.js";
+} from "./chunks/chunk-YEJBZLE5.js";
 import {
   Budget,
   JqError,
@@ -31,7 +37,7 @@ import {
   resolveJqLimits,
   truth,
   wellFormed
-} from "./chunks/chunk-5X2TAR25.js";
+} from "./chunks/chunk-6PSMEBVP.js";
 import {
   CurlError,
   cloudflareWorkerNetworkLimits,
@@ -44,7 +50,7 @@ import {
   curlCommands,
   defaultNetworkLimits,
   networkCommands
-} from "./chunks/chunk-RVGX5DQT.js";
+} from "./chunks/chunk-TPD45VUZ.js";
 import {
   RecordBuffer,
   UsageError,
@@ -76,7 +82,7 @@ import {
   textOutputRequirements,
   value,
   writeDiagnostic
-} from "./chunks/chunk-R5ZK7V4W.js";
+} from "./chunks/chunk-T5BV7HPD.js";
 import {
   AvailableRecords,
   EreLedger,
@@ -96,22 +102,22 @@ import {
   exprMatchCeilings,
   matchEre,
   withRegexSession
-} from "./chunks/chunk-67TENRTW.js";
+} from "./chunks/chunk-WODV2DVM.js";
 import {
   bindFileOutputBudget,
   openFileOutput,
   writeFileOutput
-} from "./chunks/chunk-RDIJ6M2D.js";
+} from "./chunks/chunk-AZNI263O.js";
 import {
   createPrCommand,
   createPrCommands,
   prCommands
-} from "./chunks/chunk-GZH6ILJC.js";
+} from "./chunks/chunk-VNDFKT6F.js";
 import {
   createTsortCommand,
   createTsortCommands,
   tsortCommands
-} from "./chunks/chunk-ELK3CQTQ.js";
+} from "./chunks/chunk-WF4P7XKI.js";
 import {
   basename,
   dirname,
@@ -121,15 +127,15 @@ import {
   relativePath,
   resolvePath,
   validatePath
-} from "./chunks/chunk-CI42NIWL.js";
+} from "./chunks/chunk-DPJWEGIX.js";
 import {
   createFactorCommand,
   createFactorCommands,
   factorCommands
-} from "./chunks/chunk-LUIEXTN5.js";
+} from "./chunks/chunk-66VSWIUC.js";
 import {
   createOutputOperation
-} from "./chunks/chunk-UL4TNDNV.js";
+} from "./chunks/chunk-PZMJ4EC3.js";
 import {
   CommandArgumentIdentityError,
   CommandRegistry,
@@ -142,8 +148,7 @@ import {
   createBytePipe,
   createCommandArguments,
   getCommandArguments,
-  import_buffer,
-  init_platform,
+  inheritYieldCheckpoint,
   isErrnoCode,
   isFsError,
   monotonicNow,
@@ -164,7 +169,11 @@ import {
   writeBytes,
   writeText,
   yieldTurn
-} from "./chunks/chunk-4NMFAR4Z.js";
+} from "./chunks/chunk-5VBLSPNM.js";
+import {
+  import_buffer,
+  init_platform
+} from "./chunks/chunk-2KL6W6NB.js";
 
 // packages/safe-bash/src/core.browser.ts
 init_platform();
@@ -17252,6 +17261,88 @@ init_platform();
 
 // packages/safe-bash/src/commands/bytes/compression/files.ts
 init_platform();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+
+// packages/safe-bash/src/commands/bytes/compression/options.ts
+init_platform();
+var profiles = [
+  { format: "gzip", names: ["gzip", "gunzip", "zcat"], suffix: ".gz", level: 6, keep: false },
+  { format: "bzip2", names: ["bzip2", "bunzip2", "bzcat"], suffix: ".bz2", level: 9, keep: false },
+  { format: "xz", names: ["xz", "unxz", "xzcat"], suffix: ".xz", level: 3, keep: false },
+  { format: "zstd", names: ["zstd", "unzstd", "zstdcat"], suffix: ".zst", level: 3, keep: true }
+];
+var aliases = {
+  stdout: "c",
+  "to-stdout": "c",
+  decompress: "d",
+  uncompress: "d",
+  keep: "k",
+  force: "f",
+  test: "t",
+  fast: "1",
+  best: "9",
+  "no-name": "n",
+  help: "h"
+};
+function parseOptions(command7, args) {
+  const profile2 = profiles.find((value2) => value2.names.some((name2) => name2 === command7));
+  if (!profile2) throw new UsageError(`unknown compression command '${command7}'`);
+  const result2 = {
+    format: profile2.format,
+    decompress: command7 !== profile2.names[0],
+    stdout: command7 === profile2.names[2],
+    keep: profile2.keep,
+    force: false,
+    test: false,
+    help: false,
+    level: profile2.level,
+    operands: []
+  };
+  let ended = false;
+  for (const argument2 of args) {
+    if (ended || argument2 === "-" || !argument2.startsWith("-")) {
+      result2.operands.push(argument2);
+      continue;
+    }
+    if (argument2 === "--") {
+      ended = true;
+      continue;
+    }
+    const flags3 = argument2.startsWith("--") ? aliases[argument2.slice(2)] : argument2.slice(1);
+    if (!flags3) throw new UsageError(`unrecognized option '${argument2}'`);
+    for (const flag of flags3) {
+      switch (flag) {
+        case "c":
+          result2.stdout = true;
+          break;
+        case "d":
+          result2.decompress = true;
+          break;
+        case "k":
+          result2.keep = true;
+          break;
+        case "f":
+          result2.force = true;
+          break;
+        case "t":
+          result2.test = true;
+          result2.decompress = true;
+          break;
+        case "h":
+          result2.help = true;
+          break;
+        case "n":
+          if (profile2.format !== "gzip") throw new UsageError(`invalid option -- '${flag}'`);
+          break;
+        default:
+          if (/^[1-9]$/u.test(flag)) result2.level = Number(flag);
+          else throw new UsageError(`invalid option -- '${flag}'`);
+      }
+    }
+  }
+  if (!result2.operands.length) result2.operands.push("-");
+  return result2;
+}
 
 // packages/safe-bash/src/commands/bytes/compression/stream.ts
 init_platform();
@@ -20545,6 +20636,187 @@ async function* gunzipMembers(source2, parentSignal, force, warn) {
   }
 }
 
+// packages/safe-bash/src/commands/bytes/compression/bounded-codec.ts
+init_platform();
+
+// packages/safe-bash/src/commands/bytes/compression/codec-loader.ts
+init_platform();
+function unavailable() {
+  throw new Error("codec attempted an unavailable host operation");
+}
+var wasi = Object.freeze({
+  fd_prestat_get: () => 8,
+  fd_prestat_dir_name: unavailable,
+  fd_write: unavailable,
+  fd_read: unavailable,
+  fd_close: unavailable,
+  fd_seek: unavailable,
+  fd_fdstat_get: unavailable,
+  fd_fdstat_set_flags: unavailable,
+  fd_filestat_get: unavailable,
+  environ_get: unavailable,
+  environ_sizes_get: unavailable,
+  random_get: unavailable,
+  clock_time_get: unavailable,
+  proc_exit: unavailable
+});
+async function createCodec(options2, signal, factory) {
+  signal.throwIfAborted();
+  if (!Number.isInteger(options2.level) || options2.level < 1 || options2.level > 9) throw new RangeError("invalid codec level");
+  if (!factory) {
+    switch (options2.format) {
+      case "bzip2":
+        factory = (await import("./chunks/bz2-B2RXT4EX.js")).default;
+        break;
+      case "xz":
+        factory = (await import("./chunks/xz-AVXFDXW4.js")).default;
+        break;
+      case "zstd":
+        factory = (await import("./chunks/zstd-R6RPHJYO.js")).default;
+        break;
+    }
+  }
+  signal.throwIfAborted();
+  const module = factory(wasi);
+  let closed = false;
+  const close = () => {
+    if (!closed) {
+      closed = true;
+      module.bridge_destroy();
+    }
+  };
+  try {
+    module._initialize?.();
+    const initialized = module.bridge_create(Number(options2.decompress), options2.level, 64 * 1024 * 1024, 23);
+    signal.throwIfAborted();
+    if (initialized !== 0) throw new PublicDiagnostic("codec initialization failed or memory limit exceeded");
+    const inputPointer = module.bridge_input();
+    const outputPointer = module.bridge_output();
+    return {
+      step(input3, output2, finish) {
+        signal.throwIfAborted();
+        if (closed) throw new Error("codec is closed");
+        if (input3.length > 65536 || output2.length < 1 || output2.length > 65536) throw new RangeError("invalid codec buffer size");
+        new Uint8Array(module.memory.buffer, inputPointer, input3.length).set(input3);
+        const status2 = module.bridge_step(inputPointer, input3.length, outputPointer, output2.length, Number(finish));
+        signal.throwIfAborted();
+        if (status2 === -4) throw new PublicDiagnostic("unexpected end of file");
+        if (status2 === -2 || status2 === -3) throw new PublicDiagnostic("invalid compressed data or codec memory limit exceeded");
+        if (status2 !== 1 && status2 !== 2 && status2 !== 3) throw new Error(`invalid codec status ${status2}`);
+        const consumed = module.bridge_consumed();
+        const produced = module.bridge_produced();
+        if (!Number.isSafeInteger(consumed) || consumed < 0 || consumed > input3.length || !Number.isSafeInteger(produced) || produced < 0 || produced > output2.length) throw new Error("invalid codec progress");
+        output2.set(new Uint8Array(module.memory.buffer, outputPointer, produced));
+        return { consumed, produced, status: status2 === 1 ? "end" : status2 === 3 ? "output" : "input" };
+      },
+      close
+    };
+  } catch (error) {
+    try {
+      close();
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// packages/safe-bash/src/commands/bytes/compression/bounded-codec.ts
+async function* boundedCodec(input3, options2, signal, create = createCodec) {
+  signal.throwIfAborted();
+  let stream;
+  let current = new Uint8Array();
+  let offset = 0;
+  let eof = false;
+  let needsInput = true;
+  let ended = false;
+  let calls = 0;
+  let work = 0;
+  let failed = false;
+  let output2 = new Uint8Array(64 * 1024);
+  try {
+    stream = await create(options2, signal);
+    for (; ; ) {
+      signal.throwIfAborted();
+      if ((needsInput || ended) && offset === current.length && !eof) {
+        current = await input3.chunk() ?? new Uint8Array();
+        offset = 0;
+        eof = current.length === 0;
+        signal.throwIfAborted();
+      }
+      if (ended) {
+        if (options2.format === "xz") {
+          let padding = 0;
+          while (!eof) {
+            while (offset < current.length && current[offset] === 0) {
+              offset++;
+              padding = (padding + 1) % 4;
+              if (++work >= 64 * 1024) {
+                await yieldTurn(signal);
+                work = 0;
+                calls = 0;
+              }
+            }
+            if (offset < current.length) break;
+            current = await input3.chunk() ?? new Uint8Array();
+            offset = 0;
+            eof = current.length === 0;
+            signal.throwIfAborted();
+          }
+          if (padding) throw new PublicDiagnostic("invalid XZ stream padding");
+        }
+        if (eof) return;
+        const previous = stream;
+        stream = void 0;
+        previous.close();
+        stream = await create(options2, signal);
+        signal.throwIfAborted();
+        ended = false;
+      }
+      const bytes3 = current.subarray(offset, Math.min(current.length, offset + 64 * 1024));
+      const result2 = stream.step(bytes3, output2, eof);
+      signal.throwIfAborted();
+      if (!Number.isSafeInteger(result2.consumed) || result2.consumed < 0 || result2.consumed > bytes3.length || !Number.isSafeInteger(result2.produced) || result2.produced < 0 || result2.produced > output2.length || !["input", "output", "end"].includes(result2.status)) {
+        throw new Error("invalid codec progress");
+      }
+      offset += result2.consumed;
+      if (!result2.consumed && !result2.produced && result2.status !== "end") {
+        if (eof) throw new PublicDiagnostic("unexpected end of file");
+        if (bytes3.length || result2.status !== "input") throw new Error("codec made no progress");
+      }
+      if (result2.produced) {
+        yield output2.subarray(0, result2.produced);
+        signal.throwIfAborted();
+        output2 = new Uint8Array(64 * 1024);
+      }
+      signal.throwIfAborted();
+      work += result2.consumed + result2.produced;
+      if (++calls >= 64 || work >= 64 * 1024) {
+        await yieldTurn(signal);
+        calls = 0;
+        work = 0;
+      }
+      if (result2.status === "end") {
+        if (!options2.decompress) return;
+        ended = true;
+      }
+      needsInput = result2.status !== "output";
+    }
+  } catch (error) {
+    failed = true;
+    options2.onFailure?.(error);
+    throw error;
+  } finally {
+    if (failed) {
+      try {
+        stream?.close();
+      } catch {
+      }
+    } else {
+      stream?.close();
+    }
+  }
+}
+
 // packages/safe-bash/src/commands/bytes/compression/stream.ts
 var chunkBytes = 64 * 1024;
 var stagingLimit = 256 * 1024 * 1024;
@@ -20607,6 +20879,7 @@ async function* split2(source2, signal, fail4) {
 async function transform(source2, consume, options2, parentSignal, maxOutput = Infinity) {
   const controller = new AbortController();
   const signal = AbortSignal.any([parentSignal, controller.signal]);
+  inheritYieldCheckpoint(parentSignal, signal);
   let failure;
   let hasFailure = false;
   const fail4 = (error) => {
@@ -20618,11 +20891,11 @@ async function transform(source2, consume, options2, parentSignal, maxOutput = I
   };
   let prepared = split2(typeof source2 === "function" ? source2(signal) : source2, signal, fail4);
   let warned2 = false;
-  if (options2.decompress) prepared = gunzipMembers(prepared, signal, options2.force, () => {
+  if (options2.format === "gzip" && options2.decompress) prepared = gunzipMembers(prepared, signal, options2.force, () => {
     warned2 = true;
   });
-  const reader = options2.decompress ? void 0 : new CodecReader(prepared, signal);
-  const transformed = reader ? codec(reader, { mode: "gzip", level: options2.level, onFailure: fail4 }, signal) : prepared;
+  const reader = options2.format === "gzip" && options2.decompress ? void 0 : new CodecReader(prepared, signal);
+  const transformed = options2.format !== "gzip" ? boundedCodec(reader, { format: options2.format, decompress: options2.decompress, level: options2.level, onFailure: fail4 }, signal) : reader ? codec(reader, { mode: "gzip", level: options2.level, onFailure: fail4 }, signal) : prepared;
   let consumed = false;
   const output2 = (async function* () {
     let size = 0;
@@ -20630,7 +20903,7 @@ async function transform(source2, consume, options2, parentSignal, maxOutput = I
       for await (const chunk of readBytes(transformed, signal)) {
         if (chunk.length > maxOutput - size) throw new FsError("EFBIG", { message: `staged output exceeds ${maxOutput} bytes` });
         let bytes3 = chunk;
-        if (!options2.decompress && size <= 9 && size + chunk.length > 9) {
+        if (options2.format === "gzip" && !options2.decompress && size <= 9 && size + chunk.length > 9) {
           bytes3 = chunk.slice();
           bytes3[9 - size] = 255;
         }
@@ -20662,15 +20935,153 @@ async function transform(source2, consume, options2, parentSignal, maxOutput = I
   return warned2;
 }
 
+// packages/safe-bash/src/commands/bytes/compression/file-operation.ts
+init_platform();
+var FileOperation = class {
+  signal;
+  fs;
+  controller = new AbortController();
+  pending = /* @__PURE__ */ new Set();
+  sources = [];
+  closing;
+  caller;
+  constructor(context2, cleanup) {
+    this.caller = context2.signal;
+    this.signal = this.controller.signal;
+    this.caller.throwIfAborted();
+    inheritYieldCheckpoint(this.caller, this.signal);
+    const filesystem = context2.fs;
+    this.caller.throwIfAborted();
+    this.fs = new Proxy(filesystem, {
+      get: (target, key) => {
+        this.check();
+        const value2 = Reflect.get(target, key, target);
+        this.check();
+        return typeof value2 === "function" ? (...args) => {
+          this.check();
+          const result2 = Reflect.apply(value2, target, args);
+          return key === "readStream" ? this.ownSource(result2) : result2;
+        } : value2;
+      }
+    });
+    let outcomeClaimed = false;
+    let registeredClosing;
+    const abort = () => {
+      void retire().catch(() => {
+      });
+    };
+    const retire = () => {
+      if (!this.closing) {
+        this.closing = Promise.resolve().then(async () => {
+          try {
+            const sources2 = Promise.allSettled(this.sources.map((close) => close()));
+            await Promise.allSettled([...this.pending]);
+            const outcomes = await sources2;
+            await cleanup?.();
+            const failures = outcomes.filter((outcome) => outcome.status === "rejected").map((outcome) => outcome.reason);
+            if (failures.length === 1) throw failures[0];
+            if (failures.length) throw new AggregateError(failures, "Compression source cleanup failed");
+          } finally {
+            this.caller.removeEventListener("abort", abort);
+          }
+        });
+        void this.closing.catch(() => {
+        });
+        this.controller.abort(this.caller.aborted ? this.caller.reason : new Error("Compression file operation is closed"));
+      }
+      return this.closing;
+    };
+    this.close = () => {
+      outcomeClaimed = true;
+      return retire();
+    };
+    const register = context2.registerCleanup;
+    this.check();
+    if (register) Reflect.apply(register, context2, [() => {
+      registeredClosing ??= retire().catch((error) => {
+        if (!outcomeClaimed) throw error;
+      });
+      void registeredClosing.catch(() => {
+      });
+      return registeredClosing;
+    }]);
+    this.check();
+    this.caller.addEventListener("abort", abort, { once: true });
+    if (this.caller.aborted) abort();
+  }
+  close;
+  check() {
+    this.caller.throwIfAborted();
+    this.signal.throwIfAborted();
+  }
+  async run(start) {
+    this.check();
+    const pending = Promise.resolve().then(() => {
+      this.check();
+      return start();
+    });
+    this.pending.add(pending);
+    try {
+      return await pending;
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+  ownSource(source2) {
+    let iterator = void 0;
+    let closing;
+    const close = () => {
+      closing ??= Promise.resolve().then(async () => {
+        const method = iterator?.return;
+        return method ? await Reflect.apply(method, iterator, []) : { done: true, value: void 0 };
+      });
+      void closing.catch(() => {
+      });
+      return closing;
+    };
+    this.sources.push(close);
+    const factory = source2[Symbol.asyncIterator];
+    iterator = Reflect.apply(factory, source2, []);
+    this.check();
+    let claimed = false;
+    return {
+      [Symbol.asyncIterator]: () => {
+        this.check();
+        if (claimed) throw new Error("Compression input was already acquired");
+        claimed = true;
+        return {
+          next: async () => {
+            this.check();
+            if (closing) throw new Error("Compression input is closed");
+            const method = iterator.next;
+            this.check();
+            const result2 = await Reflect.apply(method, iterator, []);
+            this.check();
+            const done = result2.done;
+            this.check();
+            const value2 = result2.value;
+            this.check();
+            return done ? { done: true, value: value2 } : { done: false, value: value2 };
+          },
+          return: close
+        };
+      }
+    };
+  }
+};
+
 // packages/safe-bash/src/commands/bytes/compression/files.ts
+function identified(stat) {
+  return stat.identityScope !== void 0 && Number.isSafeInteger(stat.ino) && Number.isSafeInteger(stat.dev);
+}
 function sameIdentity(first, second) {
-  return first.ino !== void 0 && second.ino !== void 0 && first.ino === second.ino && first.dev === second.dev;
+  return identified(first) && identified(second) && first.identityScope === second.identityScope && first.ino === second.ino && first.dev === second.dev;
 }
 function sameSnapshot(first, second) {
-  return first.type === second.type && first.size === second.size && first.mode === second.mode && first.mtimeMs === second.mtimeMs && first.ctimeMs === second.ctimeMs && first.ino === second.ino && first.dev === second.dev && first.nlink === second.nlink && first.birthtimeMs === second.birthtimeMs && first.uid === second.uid && first.gid === second.gid;
+  return first.type === second.type && first.size === second.size && first.mode === second.mode && first.mtimeMs === second.mtimeMs && first.ctimeMs === second.ctimeMs && first.ino === second.ino && first.dev === second.dev && first.nlink === second.nlink && first.birthtimeMs === second.birthtimeMs && first.uid === second.uid && first.gid === second.gid && first.identityScope === second.identityScope;
 }
 function sameEntry(first, second) {
-  return first.type === second.type && first.ino === second.ino && first.dev === second.dev && first.birthtimeMs === second.birthtimeMs;
+  return sameIdentity(first, second) && first.type === second.type && first.birthtimeMs === second.birthtimeMs;
 }
 async function existing(context2, path) {
   try {
@@ -20681,6 +21092,17 @@ async function existing(context2, path) {
   }
 }
 function outputPath(source2, options2) {
+  if (options2.format !== "gzip") {
+    const suffix2 = profiles.find((profile2) => profile2.format === options2.format).suffix;
+    if (options2.decompress) {
+      if (!source2.endsWith(suffix2)) throw new FsError("EINVAL", { path: source2, message: `unknown ${options2.format} suffix (use -c for stdout)` });
+      const destination2 = source2.slice(0, -suffix2.length);
+      if (destination2.endsWith("/")) throw new FsError("EINVAL", { path: source2, message: "empty output filename" });
+      return destination2;
+    }
+    if (!options2.force && source2.endsWith(suffix2)) throw new FsError("EINVAL", { path: source2, message: `already has a ${options2.format} suffix (use -f to compress again)` });
+    return source2 + suffix2;
+  }
   if (options2.decompress) {
     if (/\.(?:tgz|taz)$/iu.test(source2)) return source2.slice(0, -4) + ".tar";
     const suffix2 = /(?:\.gz|\.z|-gz|-z|_z)$/iu.exec(source2);
@@ -20695,6 +21117,15 @@ function outputPath(source2, options2) {
   return source2 + ".gz";
 }
 async function planOperands(context2, options2) {
+  const operation2 = new FileOperation(context2);
+  try {
+    return await operation2.run(() => collectOperands({ ...context2, fs: operation2.fs, signal: operation2.signal }, options2));
+  } finally {
+    await operation2.close();
+    context2.signal.throwIfAborted();
+  }
+}
+async function collectOperands(context2, options2) {
   const plans = [];
   for (const name2 of options2.operands) {
     context2.signal.throwIfAborted();
@@ -20728,6 +21159,13 @@ async function planOperands(context2, options2) {
       throw new FsError("ENOTSUP", { message: "file output requires VFS streaming writes (use -c for stdout)" });
     }
     const destinationStat = await existing(context2, destination2);
+    if (!identified(sourceStat) || destinationStat && !identified(destinationStat)) {
+      throw new FsError("ENOTSUP", { path: source2, message: "file output requires stable scoped entry identities" });
+    }
+    if (!context2.fs.rmdir || capabilities.exclusiveCreate !== true || (destinationStat ? capabilities.atomicRename : capabilities.atomicRenameNoReplace) !== true) {
+      throw new FsError("ENOTSUP", { path: destination2, message: "file output requires exclusive staging, safe rmdir and atomic publication (use -c for stdout)" });
+    }
+    context2.signal.throwIfAborted();
     if (destinationStat) {
       if (destinationStat.type !== "file" || sameIdentity(sourceStat, destinationStat) || realSource === await context2.fs.realpath(destination2, { signal: context2.signal })) {
         throw new FsError("EINVAL", { path: destination2, message: "destination is not a distinct regular file" });
@@ -20758,23 +21196,10 @@ async function unchangedSource(context2, plan) {
     throw new FsError("EBUSY", { path: plan.source, message: "input identity or metadata changed; input retained" });
   }
 }
-async function temporaryDirectory(context2, destination2) {
-  for (let attempt = 0; attempt < 16; attempt++) {
-    const path = joinPath(dirname(destination2), `.virtual-bash-gzip-${globalThis.crypto.randomUUID()}`);
-    try {
-      await context2.fs.mkdir(path, { mode: 448, signal: context2.signal });
-      return path;
-    } catch (error) {
-      if (codeOf(error) !== "EEXIST") throw error;
-    }
-  }
-  throw new FsError("EEXIST", { message: "unable to allocate a private gzip staging directory" });
-}
 async function writeFileOperand(context2, plan, options2) {
   const destination2 = plan.destination;
-  await unchangedSource(context2, plan);
-  const directory2 = await temporaryDirectory(context2, destination2);
-  const staged = joinPath(directory2, "data");
+  let directory2;
+  let staged;
   let directoryStat;
   let stageStat;
   let stageOwned = false;
@@ -20782,146 +21207,127 @@ async function writeFileOperand(context2, plan, options2) {
   let failure;
   let failed = false;
   let warned2 = false;
+  let cleanupFailed = false;
+  let retainedCleanup;
+  const operation2 = new FileOperation(context2, async () => {
+    await retainedCleanup?.();
+  });
+  const active = { ...context2, fs: operation2.fs, signal: operation2.signal };
+  const { fs, signal } = active;
+  const snapshot = (stat) => {
+    const result2 = {};
+    for (const key of ["type", "size", "mode", "mtimeMs", "atimeMs", "ctimeMs", "birthtimeMs", "identityScope", "ino", "dev", "nlink", "uid", "gid"]) {
+      result2[key] = stat[key];
+      operation2.check();
+    }
+    return Object.freeze(result2);
+  };
   try {
-    directoryStat = await context2.fs.lstat(directory2, { signal: context2.signal });
-    if (directoryStat.type !== "directory") throw new FsError("EBUSY", { path: directory2 });
-    await context2.fs.writeFile(staged, new Uint8Array(), { flag: "wx", mode: 384, signal: context2.signal });
-    stageOwned = true;
-    stageStat = await context2.fs.lstat(staged, { signal: context2.signal });
-    if (stageStat.type !== "file" || stageStat.size !== 0) throw new FsError("EBUSY", { path: staged });
-    warned2 = await transform((signal) => context2.fs.readStream(plan.source, { signal, chunkSize: chunkBytes }), async (output2, signal) => {
-      await context2.fs.writeStream(staged, output2, { flag: "w", mode: 384, signal });
-    }, { ...options2, force: false }, context2.signal, stagingLimit);
-    await unchangedSource(context2, plan);
-    const target = await existing(context2, destination2);
+    retainedCleanup = retainFileSystemCleanup(context2.fs, async (cleanup) => {
+      if (directory2 === void 0) return;
+      const cleanupSignal = AbortSignal.timeout(5e3);
+      const currentDirectory = await cleanup.lstat(directory2, { signal: cleanupSignal });
+      if (!directoryStat || !sameEntry(directoryStat, currentDirectory)) {
+        throw new FsError("EBUSY", { path: directory2, message: "staging directory identity is unknown or changed; refusing cleanup" });
+      }
+      if (stageOwned && !moved && staged !== void 0) {
+        let currentStage;
+        try {
+          currentStage = await cleanup.lstat(staged, { signal: cleanupSignal });
+        } catch (error) {
+          if (codeOf(error) !== "ENOENT") throw error;
+        }
+        if (currentStage) {
+          if (!stageStat || !sameEntry(stageStat, currentStage)) throw new FsError("EBUSY", { path: staged, message: "staging file identity changed; refusing cleanup" });
+          await cleanup.rm(staged, { signal: cleanupSignal });
+        }
+      }
+      if (!cleanup.rmdir) throw new FsError("ENOTSUP", { path: directory2, message: "safe directory removal unavailable" });
+      try {
+        await cleanup.rmdir(directory2, { signal: cleanupSignal });
+      } catch (error) {
+        if (codeOf(error) === "ENOTEMPTY") throw new FsError("ENOTEMPTY", { path: directory2, message: "unexpected staging entries; refusing cleanup" });
+        throw error;
+      }
+    }, { maxOperations: 8 });
+    operation2.check();
+    await operation2.run(() => unchangedSource(active, plan));
+    for (let attempt = 0; directory2 === void 0 && attempt < 16; attempt++) {
+      const path = joinPath(dirname(destination2), `.virtual-bash-gzip-${globalThis.crypto.randomUUID()}`);
+      const capabilities = await operation2.run(async () => await fs.capabilitiesFor?.(path, { signal, create: true, allowDirectory: true }) ?? fs.capabilities);
+      operation2.check();
+      const snapshotRmdir = capabilities.snapshotRmdir;
+      operation2.check();
+      if (snapshotRmdir === true) throw new FsError("ENOTSUP", { path, message: "strong staging directory cleanup unavailable; snapshot-only rmdir is unsupported" });
+      try {
+        await operation2.run(async () => {
+          await fs.mkdir(path, { mode: 448, signal });
+          directory2 = path;
+        });
+      } catch (error) {
+        operation2.check();
+        if (codeOf(error) !== "EEXIST") throw error;
+      }
+    }
+    if (directory2 === void 0) throw new FsError("EEXIST", { message: "unable to allocate a private gzip staging directory" });
+    staged = joinPath(directory2, "data");
+    directoryStat = snapshot(await operation2.run(() => fs.lstat(directory2, { signal })));
+    if (directoryStat.type !== "directory" || !identified(directoryStat)) throw new FsError("EBUSY", { path: directory2 });
+    await operation2.run(async () => {
+      await fs.writeFile(staged, new Uint8Array(), { flag: "wx", mode: 384, signal });
+      stageOwned = true;
+    });
+    stageStat = snapshot(await operation2.run(() => fs.lstat(staged, { signal })));
+    if (stageStat.type !== "file" || stageStat.size !== 0 || !identified(stageStat)) throw new FsError("EBUSY", { path: staged });
+    warned2 = await operation2.run(() => transform((signal2) => fs.readStream(plan.source, { signal: signal2, chunkSize: chunkBytes }), async (output2, signal2) => {
+      await fs.writeStream(staged, output2, { flag: "w", mode: 384, signal: signal2 });
+    }, { ...options2, force: false }, signal, stagingLimit));
+    await operation2.run(() => unchangedSource(active, plan));
+    const target = await operation2.run(() => existing(active, destination2));
     if (plan.destinationStat ? !target || !sameSnapshot(plan.destinationStat, target) : target !== void 0) {
       throw new FsError("EBUSY", { path: destination2, message: "destination changed during compression" });
     }
-    if (!sameEntry(stageStat, await context2.fs.lstat(staged, { signal: context2.signal }))) {
+    if (!sameEntry(stageStat, snapshot(await operation2.run(() => fs.lstat(staged, { signal }))))) {
       throw new FsError("EBUSY", { path: staged, message: "staging identity changed" });
     }
-    if (plan.destinationStat) {
-      await context2.fs.rename(staged, destination2, { signal: context2.signal });
+    await operation2.run(async () => {
+      await fs.rename(staged, destination2, { signal, noReplace: !plan.destinationStat });
       moved = true;
-    } else await context2.fs.copyFile(staged, destination2, { exclusive: true, signal: context2.signal });
-    context2.signal.throwIfAborted();
+    });
+    operation2.check();
+    try {
+      await retainedCleanup();
+    } catch (error) {
+      cleanupFailed = true;
+      throw error;
+    }
+    operation2.check();
+    if (!options2.keep) {
+      await operation2.run(() => unchangedSource(active, plan));
+      await operation2.run(() => fs.rm(plan.source, { signal }));
+    }
   } catch (error) {
     failed = true;
     failure = error;
   }
   try {
-    const signal = AbortSignal.timeout(5e3);
-    const currentDirectory = await context2.fs.lstat(directory2, { signal });
-    if (directoryStat && !sameEntry(directoryStat, currentDirectory)) {
-      throw new FsError("EBUSY", { path: directory2, message: "staging directory identity changed; refusing cleanup" });
-    }
-    if (stageOwned && !moved) {
-      let currentStage;
-      try {
-        currentStage = await context2.fs.lstat(staged, { signal });
-      } catch (error) {
-        if (codeOf(error) !== "ENOENT") throw error;
-      }
-      if (currentStage) {
-        if (!stageStat || !sameEntry(stageStat, currentStage)) {
-          throw new FsError("EBUSY", { path: staged, message: "staging file identity changed; refusing cleanup" });
-        }
-        await context2.fs.rm(staged, { signal });
-      }
-    }
-    if ((await context2.fs.readdir(directory2, { signal })).length) {
-      throw new FsError("ENOTEMPTY", { path: directory2, message: "unexpected staging entries; refusing recursive cleanup" });
-    }
-    await context2.fs.rm(directory2, { recursive: true, signal });
+    await operation2.close();
   } catch (error) {
+    if (cleanupFailed && error === failure) throw error;
     if (failed) {
       const aggregate = new AggregateError([failure, error], "compression failed and staging cleanup failed; input retained");
       throw new PublicDiagnostic(aggregate.message, { cause: aggregate });
     }
     throw error;
   }
+  context2.signal.throwIfAborted();
   if (failed) throw failure;
-  if (!options2.keep) {
-    await unchangedSource(context2, plan);
-    await context2.fs.rm(plan.source, { signal: context2.signal });
-  }
   return warned2;
 }
 
-// packages/safe-bash/src/commands/bytes/compression/options.ts
-init_platform();
-var aliases = {
-  stdout: "c",
-  "to-stdout": "c",
-  decompress: "d",
-  uncompress: "d",
-  keep: "k",
-  force: "f",
-  test: "t",
-  fast: "1",
-  best: "9",
-  "no-name": "n",
-  help: "h"
-};
-function parseOptions(command7, args) {
-  const result2 = {
-    decompress: command7 !== "gzip",
-    stdout: command7 === "zcat",
-    keep: false,
-    force: false,
-    test: false,
-    help: false,
-    level: 6,
-    operands: []
-  };
-  let ended = false;
-  for (const argument2 of args) {
-    if (ended || argument2 === "-" || !argument2.startsWith("-")) {
-      result2.operands.push(argument2);
-      continue;
-    }
-    if (argument2 === "--") {
-      ended = true;
-      continue;
-    }
-    const flags3 = argument2.startsWith("--") ? aliases[argument2.slice(2)] : argument2.slice(1);
-    if (!flags3) throw new UsageError(`unrecognized option '${argument2}'`);
-    for (const flag of flags3) {
-      switch (flag) {
-        case "c":
-          result2.stdout = true;
-          break;
-        case "d":
-          result2.decompress = true;
-          break;
-        case "k":
-          result2.keep = true;
-          break;
-        case "f":
-          result2.force = true;
-          break;
-        case "t":
-          result2.test = true;
-          result2.decompress = true;
-          break;
-        case "h":
-          result2.help = true;
-          break;
-        case "n":
-          break;
-        default:
-          if (/^[1-9]$/u.test(flag)) result2.level = Number(flag);
-          else throw new UsageError(`invalid option -- '${flag}'`);
-      }
-    }
-  }
-  if (!result2.operands.length) result2.operands.push("-");
-  return result2;
-}
-
 // packages/safe-bash/src/commands/bytes/compression/index.ts
 function createCompressionCommands() {
-  return ["gzip", "gunzip", "zcat"].map((name2) => define(name2, async (context2) => {
+  return profiles.flatMap((profile2) => profile2.names).map((name2) => define(name2, async (context2) => {
     const options2 = parseOptions(name2, context2.args);
     if (options2.help) {
       await output(context2, `Usage: ${name2} [OPTION]... [FILE]...
@@ -20931,8 +21337,9 @@ function createCompressionCommands() {
 -f, --force
 -t, --test
 -1..-9, --fast, --best
--n, --no-name (always enabled)
--h, --help
+${options2.format === "gzip" ? "-n, --no-name (always enabled)\n" : `Default compression level: ${options2.level}; 64 MiB codec allocation cap.
+High presets may exceed the cap and fail explicitly.
+`}-h, --help
 No FILE or FILE '-' uses stdin; file output uses private VFS staging.
 `);
       return { exitCode: 0 };
@@ -24802,7 +25209,7 @@ function truncateCommand(options2 = {}) {
   const configured = settings(options2);
   const argumentLimit = Math.min(65536, configured.limits.maxArgumentBytes);
   const outputMaximum = Math.min(bufferLimit, configured.limits.maxOutputBytes);
-  return { name: "truncate", filesystemRequirements: [{ id: "resize", description: "Resize retained writable VFS entries", capabilities: ["retainedResize"], mutates: true }], async execute(context2) {
+  return { name: "truncate", filesystemRequirements: [{ id: "resize", description: "Resize writable VFS entries through retained handles or atomic operations", capabilities: [], anyOf: [["retainedResize"], ["atomicResize"]], mutates: true }], async execute(context2) {
     context2.signal.throwIfAborted();
     const root = createOutputOperation({ signal: context2.signal, registerCleanup(cleanup) {
       let retirement;
@@ -24962,6 +25369,26 @@ ${error.usage ? "Try 'truncate --help' for more information.\n" : ""}`);
             if (readOnly === true) throw new FsError("EROFS");
             const retainedResize = capabilities.retainedResize;
             signal.throwIfAborted();
+            if (retainedResize !== true && capabilities.atomicResize === true) {
+              signal.throwIfAborted();
+              const resize = filesystem.resizeFile;
+              signal.throwIfAborted();
+              if (typeof resize !== "function") throw new FsError("ENOTSUP");
+              const operation2 = {
+                size: settings17.size ?? reference,
+                modifier: settings17.modifier,
+                ...reference === void 0 ? {} : { referenceSize: reference },
+                ioBlocks: settings17.blocks
+              };
+              await root.acquire((signal2) => Reflect.apply(resize, filesystem, [
+                path,
+                operation2,
+                { create: !settings17.noCreate, mode: 438 & ~configured.umask, signal: signal2 }
+              ]), () => {
+              });
+              signal.throwIfAborted();
+              continue;
+            }
             if (retainedResize !== true) throw new FsError("ENOTSUP");
             const openResizeFile = filesystem.openResizeFile;
             signal.throwIfAborted();
@@ -26597,7 +27024,7 @@ async function writeZipArchive(archive, limits, signal) {
 
 // packages/safe-bash/src/commands/archive/zip/safety.ts
 init_platform();
-import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { retainFileSystemCleanup as retainFileSystemCleanup2 } from "@poe-platform/safe-fs/core";
 var ZipScope = class {
   constructor(original, limits) {
     this.original = original;
@@ -26705,7 +27132,7 @@ async function publishZip(scope, prepared) {
     const owner = directory2 && await scope.stat(directory2.path);
     if (parent !== prepared.parent || !owner || owner.type !== "directory" || !sameIdentity2(owner, directory2.stat)) fail("ZIP temporary ownership changed before mutation");
   };
-  const close = retainFileSystemCleanup(fs, async (cleanup) => {
+  const close = retainFileSystemCleanup2(fs, async (cleanup) => {
     if (!directory2 || !hasIdentity(directory2.stat)) return;
     const parent = await cleanup.realpath(prepared.parentName);
     const owner = await cleanup.lstat(directory2.path);
@@ -27210,7 +27637,7 @@ var Answers = class {
 
 // packages/safe-bash/src/commands/archive/unzip/safety.ts
 init_platform();
-import { retainFileSystemCleanup as retainFileSystemCleanup2 } from "@poe-platform/safe-fs/core";
+import { retainFileSystemCleanup as retainFileSystemCleanup3 } from "@poe-platform/safe-fs/core";
 var Extraction = class {
   constructor(context2, limits) {
     this.context = context2;
@@ -27397,7 +27824,7 @@ var Extraction = class {
     let identity2;
     let created = false;
     let failure;
-    const cleanup = retainFileSystemCleanup2(fs, async (view) => {
+    const cleanup = retainFileSystemCleanup3(fs, async (view) => {
       if (!created || !identity2) return;
       try {
         let parent = "/";
@@ -36374,6 +36801,7 @@ function composeAgentCommands(options2, executors) {
   const tsortLimits = options2.tsort?.limits;
   const factorLimits = options2.factor?.limits;
   const getoptLimits = options2.getopt?.limits;
+  const hexdumpLimits = options2.hexdump?.limits;
   const whichLimits = options2.which?.limits;
   const timeoutOptions = options2.timeout;
   const applyPatchLimits = options2.applyPatch?.limits;
@@ -36411,7 +36839,8 @@ function composeAgentCommands(options2, executors) {
     ...createPrCommands({ ...prLimits === void 0 ? {} : { limits: prLimits }, ...prClock === void 0 ? {} : { clock: prClock } }),
     ...createTsortCommands(tsortLimits === void 0 ? {} : { limits: tsortLimits }),
     ...createFactorCommands(factorLimits === void 0 ? {} : { limits: factorLimits }),
-    ...createGetoptCommands(getoptLimits === void 0 ? {} : { limits: getoptLimits })
+    ...createGetoptCommands(getoptLimits === void 0 ? {} : { limits: getoptLimits }),
+    ...createHexdumpCommands(hexdumpLimits === void 0 ? {} : { limits: hexdumpLimits })
   );
   return new CommandRegistry(commands).list();
 }
@@ -48969,7 +49398,7 @@ init_platform();
 // packages/safe-js/dist/browser/safe-fs.js
 init_platform();
 
-// packages/safe-js/dist/browser/chunks/chunk-HG5OAL4N.js
+// packages/safe-js/dist/browser/chunks/chunk-BAO3TSWI.js
 init_platform();
 var platform = Object.freeze({
   errno(_code) {
@@ -50461,7 +50890,8 @@ var deviceCapabilities = Object.freeze({
   atomicRename: false,
   atomicRenameNoReplace: false,
   descriptorWriteStream: true,
-  retainedResize: true
+  retainedResize: true,
+  atomicResize: false
 });
 var syntheticStat = Object.freeze({
   type: "directory",
@@ -52794,6 +53224,9 @@ export {
   createGetoptCommand,
   createGetoptCommands,
   createGrepAliasCommands,
+  createHdCommand,
+  createHexdumpCommand,
+  createHexdumpCommands,
   createHtmlToMarkdownCommand,
   createHtmlToMarkdownCommands,
   createMemoryFileSystem2 as createMemoryFileSystem,
@@ -52851,6 +53284,7 @@ export {
   getCommandArguments,
   getoptCommands,
   grepAliasCommands,
+  hexdumpCommands,
   htmlToMarkdownCommands,
   isAbsolutePath3 as isAbsolutePath,
   isErrnoCode,