@poe-platform/safe-bash 0.1.539 → 0.1.540

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

@@ -2,12 +2,12 @@ import {
   createGetoptCommand,
   createGetoptCommands,
   getoptCommands
-} from "./chunks/chunk-GV76QENF.js";
+} from "./chunks/chunk-LRVRQIG5.js";
 import {
   createXmlCommands,
   defaultXmlQueryLimits,
   xmlCommands
-} from "./chunks/chunk-F4UILGOA.js";
+} from "./chunks/chunk-ZQEL7DYC.js";
 import {
   Interpreter,
   createYqCommand,
@@ -18,7 +18,7 @@ import {
   rawValues,
   stringify,
   yqCommands
-} from "./chunks/chunk-QWCD4HKE.js";
+} from "./chunks/chunk-QKQNBJOU.js";
 import {
   Budget,
   JqError,
@@ -31,7 +31,7 @@ import {
   resolveJqLimits,
   truth,
   wellFormed
-} from "./chunks/chunk-5X2TAR25.js";
+} from "./chunks/chunk-PPPN3OME.js";
 import {
   CurlError,
   cloudflareWorkerNetworkLimits,
@@ -44,7 +44,7 @@ import {
   curlCommands,
   defaultNetworkLimits,
   networkCommands
-} from "./chunks/chunk-RVGX5DQT.js";
+} from "./chunks/chunk-IIWXPQB3.js";
 import {
   RecordBuffer,
   UsageError,
@@ -76,7 +76,7 @@ import {
   textOutputRequirements,
   value,
   writeDiagnostic
-} from "./chunks/chunk-R5ZK7V4W.js";
+} from "./chunks/chunk-J4CKSMJV.js";
 import {
   AvailableRecords,
   EreLedger,
@@ -96,22 +96,22 @@ import {
   exprMatchCeilings,
   matchEre,
   withRegexSession
-} from "./chunks/chunk-67TENRTW.js";
+} from "./chunks/chunk-Z75O7XWR.js";
 import {
   bindFileOutputBudget,
   openFileOutput,
   writeFileOutput
-} from "./chunks/chunk-RDIJ6M2D.js";
+} from "./chunks/chunk-32GGX4AS.js";
 import {
   createPrCommand,
   createPrCommands,
   prCommands
-} from "./chunks/chunk-GZH6ILJC.js";
+} from "./chunks/chunk-UGMO7OO5.js";
 import {
   createTsortCommand,
   createTsortCommands,
   tsortCommands
-} from "./chunks/chunk-ELK3CQTQ.js";
+} from "./chunks/chunk-LZUOZVGJ.js";
 import {
   basename,
   dirname,
@@ -121,15 +121,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-DJHZJAB7.js";
 import {
   createOutputOperation
-} from "./chunks/chunk-UL4TNDNV.js";
+} from "./chunks/chunk-EYJTLUBJ.js";
 import {
   CommandArgumentIdentityError,
   CommandRegistry,
@@ -142,8 +142,6 @@ import {
   createBytePipe,
   createCommandArguments,
   getCommandArguments,
-  import_buffer,
-  init_platform,
   isErrnoCode,
   isFsError,
   monotonicNow,
@@ -164,7 +162,11 @@ import {
   writeBytes,
   writeText,
   yieldTurn
-} from "./chunks/chunk-4NMFAR4Z.js";
+} from "./chunks/chunk-GZKLXMBM.js";
+import {
+  import_buffer,
+  init_platform
+} from "./chunks/chunk-2KL6W6NB.js";
 
 // packages/safe-bash/src/core.browser.ts
 init_platform();
@@ -17253,6 +17255,87 @@ init_platform();
 // packages/safe-bash/src/commands/bytes/compression/files.ts
 init_platform();
 
+// 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 +20628,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;
@@ -20618,11 +20882,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 +20894,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;
         }
@@ -20681,6 +20945,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);
@@ -20848,80 +21123,9 @@ async function writeFileOperand(context2, plan, options2) {
   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 +21135,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 +25007,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 +25167,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();
@@ -48969,7 +49194,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 +50686,8 @@ var deviceCapabilities = Object.freeze({
   atomicRename: false,
   atomicRenameNoReplace: false,
   descriptorWriteStream: true,
-  retainedResize: true
+  retainedResize: true,
+  atomicResize: false
 });
 var syntheticStat = Object.freeze({
   type: "directory",