@poe-platform/safe-bash 0.1.800 → 0.1.802

package/dist/safe-bash/chunks/{chunk-KW24TAIU.js → chunk-NQCM3TYR.js}

@@ -1,137 +1,153 @@
 import {
   createFactorCommands
-} from "./chunk-MHZ24KEI.js";
+} from "./chunk-AM5ESLPH.js";
 import {
   createHexdumpCommands
-} from "./chunk-M4CFCXHN.js";
+} from "./chunk-CS4MNM6I.js";
 import {
   createTimeoutCommands
-} from "./chunk-SOZK5JVX.js";
+} from "./chunk-FBUCWVTE.js";
 import {
   createTsortCommands
-} from "./chunk-T3JTVIEP.js";
+} from "./chunk-6PAVEFT3.js";
+import {
+  RegexExecutor
+} from "./chunk-VKNVHEX3.js";
+import {
+  Chi,
+  HashMD,
+  Maj,
+  abytes,
+  aexists,
+  ahash,
+  anumber,
+  aoutput,
+  checkOpts,
+  clean,
+  createHasher,
+  createOutputOperation,
+  createView,
+  kdfInputToBytes,
+  rotl,
+  sha256,
+  sha384,
+  sha512
+} from "./chunk-HZAMGT5I.js";
+import {
+  createColumnCommands
+} from "./chunk-3HQU4OJO.js";
+import {
+  createApplyPatchCommands
+} from "./chunk-XAQMU6OY.js";
 import {
   assertCommandRequirements,
   basicCommands,
   cmpCommand,
-  createArchiveCommands,
-  createBcCommands,
   createCalCommands,
   createChecksumCommands,
   createCompressionCommands,
-  createDdCommands,
   createDfCommands,
   createDiffPatchCommands,
-  createDuCommands,
-  createEnvsubstCommands,
   createFdCommands,
-  createFileCommands,
   createFindDefinitions,
-  createGetconfCommands,
-  createHostnameCommands,
-  createHtmlToMarkdownCommands,
-  createIdCommands,
   createLessCommands,
-  createLocaleCommands,
-  createMetadataCommands,
-  createNprocCommands,
-  createNumfmtCommands,
   createPathchkCommands,
   createRgCommand,
-  createShufCommands,
-  createSpongeCommands,
-  createSqlite3Commands,
-  createStreamFormatCommands,
-  createStreamInspectionCommands,
-  createTimeEnvCommands,
-  createTreeCommands,
-  createUnameCommands,
   createWhichCommands,
-  createWhoamiCommands,
   directExecutor,
   executionCommands,
   filesystemCommands,
   fmtCommand,
-  numfmtCommand,
   openFileOutput,
   predicateCommands,
   wcDisplayWidth
-} from "./chunk-K4YMYFRJ.js";
+} from "./chunk-44ALJ4QG.js";
 import {
   createGetoptCommands
-} from "./chunk-3L3T6LYV.js";
+} from "./chunk-AUSNDQTJ.js";
 import {
   createIconvCommands
-} from "./chunk-H6JW3E4F.js";
+} from "./chunk-CTVWDACF.js";
 import {
   createDos2unixCommands2 as createDos2unixCommands
-} from "./chunk-4SEW2Q6H.js";
+} from "./chunk-3R3AANOR.js";
 import {
   createMdqCommand
-} from "./chunk-PPYM75Z3.js";
+} from "./chunk-OV6IHKO6.js";
 import {
   compareCopyIdentity,
   compareObservedEntries,
   inputRequirements,
   resolveInputLimit,
   textOutputRequirements
-} from "./chunk-LLZCZ24K.js";
+} from "./chunk-XVOSKJE2.js";
 import {
   createXmlCommands
-} from "./chunk-K7IQZE7D.js";
+} from "./chunk-C5OWC2TL.js";
 import {
   PublicDiagnostic
-} from "./chunk-TYD7EVUJ.js";
-import {
-  compareByteArrays,
-  decodeBytes,
-  encodeBytes,
-  equalBytes,
-  indexOfBytes
-} from "./chunk-BHJE5LPZ.js";
+} from "./chunk-PH63PLPZ.js";
 import {
   createPrCommands
-} from "./chunk-F3RV2F72.js";
+} from "./chunk-CHYGPFVM.js";
 import {
-  RegexExecutor,
   createBoundedRegexProvider
-} from "./chunk-6HZYFL3H.js";
+} from "./chunk-FZE4HW6G.js";
 import {
-  Chi,
-  HashMD,
-  Maj,
-  abytes,
-  aexists,
-  ahash,
-  anumber,
-  aoutput,
-  checkOpts,
-  clean,
-  createHasher,
-  createOutputOperation,
-  createView,
-  kdfInputToBytes,
-  rotl,
-  sha256,
-  sha384,
-  sha512
-} from "./chunk-JJSTTIEZ.js";
+  CommandRegistry
+} from "./chunk-7R5BDCG7.js";
+import {
+  createTreeCommands
+} from "./chunk-55YJASTN.js";
+import {
+  createFileCommands
+} from "./chunk-4BSJLKNM.js";
+import {
+  createHtmlToMarkdownCommands
+} from "./chunk-DQP3VHSB.js";
+import {
+  createDuCommands
+} from "./chunk-GEG3BWGE.js";
+import {
+  createMetadataCommands
+} from "./chunk-VSAJ4OTM.js";
+import {
+  compareByteArrays,
+  decodeBytes,
+  encodeBytes,
+  indexOfBytes
+} from "./chunk-D3ANYGMC.js";
 import {
   FsError
-} from "./chunk-46UISJCK.js";
+} from "./chunk-VTH3MLDU.js";
 import {
   hasYieldCheckpoint,
   monotonicNow,
   yieldTurn
-} from "./chunk-VYZTG3GV.js";
+} from "./chunk-NZQXYWA3.js";
 import {
   collectBytes,
   createBufferedOutput,
   outputFailure
-} from "./chunk-PYVEAFJM.js";
+} from "./chunk-74GHTNJA.js";
 import {
-  CommandRegistry
-} from "./chunk-LQHGH25W.js";
+  createArchiveCommands
+} from "./chunk-QGUV42T5.js";
+import {
+  createTableTextCommands
+} from "./chunk-4D4N7IU2.js";
+import {
+  createStreamInspectionCommands
+} from "./chunk-HBCN24ZA.js";
+import {
+  createStreamFormatCommands
+} from "./chunk-R3NAKOED.js";
+import {
+  createSplitCommands
+} from "./chunk-7ZBU7KYV.js";
+import {
+  createTimeEnvCommands
+} from "./chunk-ZVD5IS4V.js";
 import {
   RESOLVED_EXIT_ZERO,
   RETURN_EXIT_ONE,
@@ -143,11 +159,13 @@ import {
   builtInDirectContextExecutors,
   codeOf,
   concatenate,
+  decoder,
   define,
   diagnostic,
   encoder,
   input,
   integer,
+  isDefaultCommandOptions,
   lines,
   options,
   output,
@@ -158,10 +176,39 @@ import {
   requireOperands,
   syncCommandEvaluators,
   value
-} from "./chunk-NLAW7KDI.js";
+} from "./chunk-E7OYNDGL.js";
 import {
   init_platform
-} from "./chunk-YG5WAHK7.js";
+} from "./chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/numfmt/index.ts
+init_platform();
+import {
+  createNumfmtCommand as createRawNumfmtCommand,
+  createNumfmtCommands as createRawNumfmtCommands
+} from "../../safe-bash-command-numfmt/index.js";
+import { numfmtCommand, settings } from "../../safe-bash-command-numfmt/index.js";
+function createNumfmtCommand(options2 = {}) {
+  return registerDefaultExecutor(createRawNumfmtCommand(options2), options2);
+}
+function createNumfmtCommands(options2 = {}) {
+  return registerDefaultExecutors(createRawNumfmtCommands(options2), options2);
+}
+function numfmtCommands(options2 = {}) {
+  const commands = createNumfmtCommands(options2);
+  const replace = options2.replace ?? false;
+  return {
+    name: "numfmt-commands",
+    setup(host) {
+      if (!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 });
+    }
+  };
+}
 
 // packages/safe-bash/src/commands/text-programs/index.ts
 init_platform();
@@ -242,11 +289,11 @@ function odCommands(options2 = {}) {
     name: "od-commands",
     setup(host) {
       if (!replace) {
-        for (const command2 of commands) {
-          if (host.commands.has(command2.name)) throw new Error(`Command already registered: ${command2.name}`);
+        for (const command of commands) {
+          if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command of commands) host.commands.register(command, { replace });
     }
   };
 }
@@ -272,11 +319,11 @@ function xxdCommands(options2 = {}) {
     name: "xxd-commands",
     setup(host) {
       if (!replace) {
-        for (const command2 of commands) {
-          if (host.commands.has(command2.name)) throw new Error(`Command already registered: ${command2.name}`);
+        for (const command of commands) {
+          if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command of commands) host.commands.register(command, { replace });
     }
   };
 }
@@ -325,54 +372,112 @@ function byteCommands(options2 = {}) {
   };
 }
 
-// packages/safe-bash/src/commands/table-text/index.ts
-init_platform();
-
-// packages/safe-bash/src/commands/table-text/paste.ts
-init_platform();
-import { createPasteCommand } from "../../safe-bash-command-paste/paste.js";
-
-// packages/safe-bash/src/commands/table-text/comm.ts
-init_platform();
-import { createCommCommand } from "../../safe-bash-command-comm/comm.js";
-
-// packages/safe-bash/src/commands/table-text/join.ts
+// packages/safe-bash/src/commands/bc/index.ts
 init_platform();
-import { createJoinCommand } from "../../safe-bash-command-join/join.js";
+import {
+  createBcCommand as createRawBcCommand,
+  createBcCommands as createRawBcCommands
+} from "../../safe-bash-command-bc/index.js";
+import { settings as settings2 } from "../../safe-bash-command-bc/index.js";
+function createBcCommand(options2 = {}) {
+  return registerDefaultExecutor(createRawBcCommand(options2), options2);
+}
+function createBcCommands(options2 = {}) {
+  return registerDefaultExecutors(createRawBcCommands(options2), options2);
+}
+function bcCommands(options2 = {}) {
+  const commands = createBcCommands(options2);
+  const replace = options2.replace ?? false;
+  return {
+    name: "bc-commands",
+    setup(host) {
+      if (!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 });
+    }
+  };
+}
 
-// packages/safe-bash/src/commands/table-text/internal.ts
+// packages/safe-bash/src/commands/sponge/index.ts
 init_platform();
-import { Budget as Budget2, Inputs, OrderCheck, RecordReader, argument, command, compare, empty, encode, fail, settings } from "../../safe-bash-table-text-engine/table-text/internal.js";
-
-// packages/safe-bash/src/commands/table-text/index.ts
-function createTableTextCommands(options2 = {}) {
-  settings(options2);
-  const defs = [createPasteCommand(options2), createCommCommand(options2), createJoinCommand(options2)];
-  for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
-  return defs;
+import {
+  createSpongeCommand as createRawSpongeCommand,
+  createSpongeCommands as createRawSpongeCommands,
+  spongeCommands as rawSpongeCommands,
+  settings as settings3
+} from "../../safe-bash-command-sponge/index.js";
+function evalSyncSponge(inBytes, opArgs, readFileSync, writeFileSync) {
+  let append = false;
+  const files = [];
+  let endOfOptions = false;
+  for (const arg of opArgs) {
+    if (!endOfOptions && arg === "--") {
+      endOfOptions = true;
+      continue;
+    }
+    if (!endOfOptions && arg === "--append") {
+      append = true;
+      continue;
+    }
+    if (!endOfOptions && (arg === "--help" || arg === "-h")) {
+      return "Usage: sponge [-a] [FILE]\nSoak up standard input and write to FILE (or stdout).\n";
+    }
+    if (!endOfOptions && arg === "--version") {
+      return "sponge (virtual-bash)\n";
+    }
+    if (!endOfOptions && arg.startsWith("-") && arg.length > 1) {
+      for (let i = 1; i < arg.length; i++) {
+        if (arg[i] === "a") append = true;
+        else return void 0;
+      }
+      continue;
+    }
+    files.push(arg);
+  }
+  if (files.length > 1) return void 0;
+  const payload = inBytes ?? new Uint8Array(0);
+  if (files.length === 0 || files[0] === "-") return decoder.decode(payload);
+  if (!writeFileSync) return void 0;
+  const target = files[0];
+  if (append) {
+    const existing = readFileSync?.(target) ?? new Uint8Array(0);
+    const combined = new Uint8Array(existing.length + payload.length);
+    combined.set(existing, 0);
+    combined.set(payload, existing.length);
+    if (!writeFileSync(target, combined)) return void 0;
+  } else {
+    if (!writeFileSync(target, payload)) return void 0;
+  }
+  return "";
 }
-function tableTextCommands(options2 = {}) {
-  const commands = createTableTextCommands(options2);
-  return { name: "table-text-commands", setup(host) {
-    if (!options2.replace) for (const definition of commands) {
-      if (host.commands.has(definition.name)) throw new Error(`Command already registered: ${definition.name}`);
+syncCommandEvaluators.evalSyncSponge = evalSyncSponge;
+function createSpongeCommand(options2 = {}) {
+  const def = createRawSpongeCommand(options2);
+  if (isDefaultCommandOptions(options2)) builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createSpongeCommands(options2 = {}) {
+  return createRawSpongeCommands(options2).map((def) => {
+    if (isDefaultCommandOptions(options2)) builtInDirectContextExecutors.add(def.execute);
+    return def;
+  });
+}
+function spongeCommands(options2 = {}) {
+  const plugin = rawSpongeCommands(options2);
+  return {
+    ...plugin,
+    setup(host) {
+      for (const def of createSpongeCommands(options2)) {
+        if (!options2.replace && host.commands.has(def.name)) throw new Error(`Command already registered: ${def.name}`);
+        host.commands.register(def, { replace: options2.replace ?? false });
+      }
     }
-    for (const definition of commands) host.commands.register(definition, { replace: options2.replace ?? false });
-  } };
+  };
 }
 
-// packages/safe-bash/src/commands/split/index.ts
-init_platform();
-import { createSplitCommand, createSplitCommands, evalSyncSplit, splitCommands } from "../../safe-bash-command-split/index.js";
-
-// packages/safe-bash/src/commands/column/index.ts
-init_platform();
-import { columnCommands, createColumnCommand, createColumnCommands } from "../../safe-bash-command-column/index.js";
-
-// packages/safe-bash/src/commands/apply-patch/index.ts
-init_platform();
-import { applyPatchCommands, createApplyPatchCommand, createApplyPatchCommands, evalSyncApplyPatch } from "../../safe-bash-command-apply-patch/index.js";
-
 // packages/safe-bash/src/commands/openssl/index.ts
 init_platform();
 
@@ -615,7 +720,7 @@ import {
   createOpensslCommand as createRawOpensslCommand,
   createOpensslCommands as createRawOpensslCommands
 } from "../../safe-bash-command-openssl/index.js";
-import { settings as settings2 } from "../../safe-bash-command-openssl/index.js";
+import { settings as settings4 } from "../../safe-bash-command-openssl/index.js";
 function isDefaultOpensslOptions(options2) {
   if (!options2) return true;
   return options2.limits === void 0 && options2.maxBufferedBytes === void 0;
@@ -641,11 +746,11 @@ function opensslCommands(options2 = {}) {
     name: "openssl-commands",
     setup(host) {
       if (!replace) {
-        for (const command2 of commands) {
-          if (host.commands.has(command2.name)) throw new Error(`Command already registered: ${command2.name}`);
+        for (const command of commands) {
+          if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command of commands) host.commands.register(command, { replace });
     }
   };
 }
@@ -1204,7 +1309,7 @@ import {
   createSshKeygenCommand as createRawSshKeygenCommand,
   createSshCommands as createRawSshCommands
 } from "../../safe-bash-command-ssh/index.js";
-import { settings as settings3 } from "../../safe-bash-command-ssh/index.js";
+import { settings as settings5 } from "../../safe-bash-command-ssh/index.js";
 var ED25519_P = 2n ** 255n - 19n;
 var ED25519_L = 2n ** 252n + 27742317777372353535851937790883648493n;
 var edMod = (a, m = ED25519_P) => (a % m + m) % m;
@@ -1344,11 +1449,11 @@ function sshCommands(options2 = {}) {
     name: "ssh-commands",
     setup(host) {
       if (!replace) {
-        for (const command2 of commands) {
-          if (host.commands.has(command2.name)) throw new Error(`Command already registered: ${command2.name}`);
+        for (const command of commands) {
+          if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command of commands) host.commands.register(command, { replace });
     }
   };
 }
@@ -1699,7 +1804,7 @@ import {
   createGpgCommand as createRawGpgCommand,
   createGpgCommands as createRawGpgCommands
 } from "../../safe-bash-command-gpg/index.js";
-import { settings as settings4 } from "../../safe-bash-command-gpg/index.js";
+import { settings as settings6 } from "../../safe-bash-command-gpg/index.js";
 var ED25519_P2 = 2n ** 255n - 19n;
 var ED25519_L2 = 2n ** 252n + 27742317777372353535851937790883648493n;
 var edMod2 = (a, m = ED25519_P2) => (a % m + m) % m;
@@ -1808,11 +1913,11 @@ function gpgCommands(options2 = {}) {
     name: "gpg-commands",
     setup(host) {
       if (!replace) {
-        for (const command2 of commands) {
-          if (host.commands.has(command2.name)) throw new Error(`Command already registered: ${command2.name}`);
+        for (const command of commands) {
+          if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command of commands) host.commands.register(command, { replace });
     }
   };
 }
@@ -1995,11 +2100,340 @@ ${pgpCrc24(pktBytes)}
 }
 syncCommandEvaluators.evalSyncGpg = evalSyncGpg;
 
+// packages/safe-bash/src/commands/id/index.ts
+init_platform();
+import {
+  createIdCommand as createRawIdCommand,
+  createIdCommands as createRawIdCommands
+} from "../../safe-bash-command-id/index.js";
+import { settings as settings7 } from "../../safe-bash-command-id/index.js";
+function createIdCommand(options2 = {}) {
+  return registerDefaultExecutor(createRawIdCommand(options2), options2);
+}
+function createIdCommands(options2 = {}) {
+  return registerDefaultExecutors(createRawIdCommands(options2), options2);
+}
+function idCommands(options2 = {}) {
+  const commands = createIdCommands(options2);
+  const replace = options2.replace ?? false;
+  return {
+    name: "id-commands",
+    setup(host) {
+      if (!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 });
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/whoami/index.ts
+init_platform();
+import {
+  createWhoamiCommand as createRawWhoamiCommand,
+  createWhoamiCommands as createRawWhoamiCommands
+} from "../../safe-bash-command-whoami/index.js";
+import { settings as settings8 } from "../../safe-bash-command-whoami/index.js";
+function createWhoamiCommand(options2 = {}) {
+  return registerDefaultExecutor(createRawWhoamiCommand(options2), options2);
+}
+function createWhoamiCommands(options2 = {}) {
+  return registerDefaultExecutors(createRawWhoamiCommands(options2), options2);
+}
+function whoamiCommands(options2 = {}) {
+  const commands = createWhoamiCommands(options2);
+  const replace = options2.replace ?? false;
+  return {
+    name: "whoami-commands",
+    setup(host) {
+      if (!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 });
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/uname/index.ts
+init_platform();
+import {
+  createUnameCommand as createRawUnameCommand,
+  createUnameCommands as createRawUnameCommands
+} from "../../safe-bash-command-uname/index.js";
+import { settings as settings9 } from "../../safe-bash-command-uname/index.js";
+function createUnameCommand(options2 = {}) {
+  return registerDefaultExecutor(createRawUnameCommand(options2), options2);
+}
+function createUnameCommands(options2 = {}) {
+  return registerDefaultExecutors(createRawUnameCommands(options2), options2);
+}
+function unameCommands(options2 = {}) {
+  const commands = createUnameCommands(options2);
+  const replace = options2.replace ?? false;
+  return {
+    name: "uname-commands",
+    setup(host) {
+      if (!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 });
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/hostname/index.ts
+init_platform();
+import {
+  createHostnameCommand as createRawHostnameCommand,
+  createHostnameCommands as createRawHostnameCommands
+} from "../../safe-bash-command-hostname/index.js";
+import { settings as settings10 } from "../../safe-bash-command-hostname/index.js";
+function createHostnameCommand(options2 = {}) {
+  return registerDefaultExecutor(createRawHostnameCommand(options2), options2);
+}
+function createHostnameCommands(options2 = {}) {
+  return registerDefaultExecutors(createRawHostnameCommands(options2), options2);
+}
+function hostnameCommands(options2 = {}) {
+  const commands = createHostnameCommands(options2);
+  const replace = options2.replace ?? false;
+  return {
+    name: "hostname-commands",
+    setup(host) {
+      if (!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 });
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/nproc/index.ts
+init_platform();
+import {
+  createNprocCommand as createRawNprocCommand,
+  createNprocCommands as createRawNprocCommands
+} from "../../safe-bash-command-nproc/index.js";
+import { settings as settings11 } from "../../safe-bash-command-nproc/index.js";
+function createNprocCommand(options2 = {}) {
+  return registerDefaultExecutor(createRawNprocCommand(options2), options2);
+}
+function createNprocCommands(options2 = {}) {
+  return registerDefaultExecutors(createRawNprocCommands(options2), options2);
+}
+function nprocCommands(options2 = {}) {
+  const commands = createNprocCommands(options2);
+  const replace = options2.replace ?? false;
+  return {
+    name: "nproc-commands",
+    setup(host) {
+      if (!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 });
+    }
+  };
+}
+
+// packages/safe-bash/src/shuf.ts
+init_platform();
+import { createShufCommand, createShufCommands, shufCommands } from "../../safe-bash-command-shuf/index.js";
+
 // packages/safe-bash/src/yes.ts
 init_platform();
-import { settings as settings5 } from "../../safe-bash-command-yes/index.js";
+import { settings as settings12 } from "../../safe-bash-command-yes/index.js";
 import { createYesCommand, createYesCommands, yesCommands } from "../../safe-bash-command-yes/index.js";
 
+// packages/safe-bash/src/dd.ts
+init_platform();
+import {
+  createDdCommand as createRawDdCommand,
+  createDdCommands as createRawDdCommands
+} from "../../safe-bash-command-dd/index.js";
+import { evalSyncDd, openDdFile, settings as settings13, transferReport } from "../../safe-bash-command-dd/index.js";
+function createDdCommand(options2 = {}) {
+  return registerDefaultExecutor(createRawDdCommand(options2), options2);
+}
+function createDdCommands(options2 = {}) {
+  return registerDefaultExecutors(createRawDdCommands(options2), options2);
+}
+function ddCommands(options2 = {}) {
+  const commands = createDdCommands(options2);
+  const replace = options2.replace ?? false;
+  return {
+    name: "dd-commands",
+    setup(host) {
+      if (!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 });
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/envsubst/index.ts
+init_platform();
+import {
+  createEnvsubstCommand as createRawEnvsubstCommand,
+  createEnvsubstCommands as createRawEnvsubstCommands,
+  envsubstCommands as rawEnvsubstCommands
+} from "../../safe-bash-command-envsubst/index.js";
+import { settings as settings15 } from "../../safe-bash-command-envsubst/index.js";
+function createEnvsubstCommand(options2 = {}) {
+  const def = createRawEnvsubstCommand(options2);
+  builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createEnvsubstCommands(options2 = {}) {
+  const defs = createRawEnvsubstCommands(options2);
+  for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  return defs;
+}
+function envsubstCommands(options2 = {}) {
+  createEnvsubstCommands(options2);
+  return rawEnvsubstCommands(options2);
+}
+
+// packages/safe-bash/src/commands/getconf/index.ts
+init_platform();
+import {
+  createGetconfCommand as createRawGetconfCommand,
+  createGetconfCommands as createRawGetconfCommands
+} from "../../safe-bash-command-getconf/index.js";
+import { settings as settings16 } from "../../safe-bash-command-getconf/index.js";
+function isDefaultGetconfOptions(options2) {
+  return options2?.processors === void 0 && options2?.variables === void 0 && options2?.limits === void 0;
+}
+function createGetconfCommand(options2 = {}) {
+  const def = createRawGetconfCommand(options2);
+  if (isDefaultGetconfOptions(options2)) builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createGetconfCommands(options2 = {}) {
+  const defs = createRawGetconfCommands(options2);
+  if (isDefaultGetconfOptions(options2)) {
+    for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  }
+  return defs;
+}
+function getconfCommands(options2 = {}) {
+  const commands = createGetconfCommands(options2);
+  return {
+    name: "getconf-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 });
+      }
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/locale/index.ts
+init_platform();
+import {
+  createLocaleCommand as createRawLocaleCommand,
+  createLocaleCommands as createRawLocaleCommands
+} from "../../safe-bash-command-locale/index.js";
+import { settings as settings17 } from "../../safe-bash-command-locale/index.js";
+function isDefaultLocaleOptions(options2) {
+  return options2?.locales === void 0 && options2?.charmaps === void 0 && options2?.defaultLocale === void 0 && options2?.limits === void 0;
+}
+function createLocaleCommand(options2 = {}) {
+  const def = createRawLocaleCommand(options2);
+  if (isDefaultLocaleOptions(options2)) builtInDirectContextExecutors.add(def.execute);
+  return def;
+}
+function createLocaleCommands(options2 = {}) {
+  const defs = createRawLocaleCommands(options2);
+  if (isDefaultLocaleOptions(options2)) {
+    for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  }
+  return defs;
+}
+function localeCommands(options2 = {}) {
+  const commands = createLocaleCommands(options2);
+  return {
+    name: "locale-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 });
+      }
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/sqlite3/index.ts
+init_platform();
+import {
+  createSqlite3Command as createRawSqlite3Command,
+  createSqlite3Commands as createRawSqlite3Commands,
+  evalSyncSqlite3
+} from "../../safe-bash-command-sqlite3/index.js";
+import { evalSyncSqlite3 as evalSyncSqlite32, settings as settings18 } from "../../safe-bash-command-sqlite3/index.js";
+function isDefaultSqlite3Options(options2) {
+  if (!options2) return true;
+  return options2.limits === void 0 && options2.engine === void 0;
+}
+function createSqlite3Command(options2 = {}) {
+  const def = createRawSqlite3Command(options2);
+  if (isDefaultSqlite3Options(options2)) {
+    builtInDirectContextExecutors.add(def.execute);
+  }
+  return def;
+}
+function createSqlite3Commands(options2 = {}) {
+  const defs = createRawSqlite3Commands(options2);
+  if (isDefaultSqlite3Options(options2)) {
+    for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  }
+  return defs;
+}
+function sqlite3Commands(options2 = {}) {
+  const commands = createSqlite3Commands(options2);
+  return {
+    name: "sqlite3-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 });
+      }
+    }
+  };
+}
+syncCommandEvaluators.evalSyncSqlite3 = evalSyncSqlite3;
+
 // packages/safe-bash/src/plugins/composition.ts
 init_platform();
 
@@ -2031,56 +2465,56 @@ function parseTailFollow(arguments_) {
   };
   let ended = false;
   for (let index = 0; index < arguments_.length; index++) {
-    const argument2 = arguments_[index];
-    if (ended || argument2 === "-" || !argument2.startsWith("-")) {
-      args.push(argument2);
+    const argument = arguments_[index];
+    if (ended || argument === "-" || !argument.startsWith("-")) {
+      args.push(argument);
       continue;
     }
-    if (argument2 === "--") {
+    if (argument === "--") {
       ended = true;
-      args.push(argument2);
+      args.push(argument);
       continue;
     }
-    if (argument2 === "--follow" || argument2.startsWith("--follow=")) {
-      const method = argument2 === "--follow" ? "descriptor" : argument2.slice(9);
+    if (argument === "--follow" || argument.startsWith("--follow=")) {
+      const method = argument === "--follow" ? "descriptor" : argument.slice(9);
       if (method !== "descriptor" && method !== "name") throw new UsageError(`invalid argument '${method}' for 'follow'`);
       mode = method === "name" ? "F" : "f";
       if (method === "descriptor") retry = explicitRetry;
-    } else if (argument2 === "--retry") {
+    } else if (argument === "--retry") {
       retry = true;
       explicitRetry = true;
-    } else if (argument2 === "--sleep-interval" || argument2.startsWith("--sleep-interval=")) {
-      sleepMs = sleep(argument2 === "--sleep-interval" ? arguments_[++index] : argument2.slice(17));
-    } else if (argument2 === "--max-unchanged-stats" || argument2.startsWith("--max-unchanged-stats=")) {
-      const text = argument2 === "--max-unchanged-stats" ? arguments_[++index] : argument2.slice(22);
+    } else if (argument === "--sleep-interval" || argument.startsWith("--sleep-interval=")) {
+      sleepMs = sleep(argument === "--sleep-interval" ? arguments_[++index] : argument.slice(17));
+    } else if (argument === "--max-unchanged-stats" || argument.startsWith("--max-unchanged-stats=")) {
+      const text = argument === "--max-unchanged-stats" ? arguments_[++index] : argument.slice(22);
       if (!text || [...text].some((digit) => digit < "0" || digit > "9") || !Number.isSafeInteger(Number(text))) throw new UsageError(`invalid maximum number of unchanged stats: '${text ?? ""}'`);
       maxUnchangedStats = Number(text);
-    } else if (argument2 === "--max-idle" || argument2.startsWith("--max-idle=")) {
-      const text = argument2 === "--max-idle" ? arguments_[++index] : argument2.slice(11);
+    } else if (argument === "--max-idle" || argument.startsWith("--max-idle=")) {
+      const text = argument === "--max-idle" ? arguments_[++index] : argument.slice(11);
       if (text === void 0 || !/^(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)$/u.test(text)) throw new UsageError("max-idle must be nonnegative decimal seconds");
       const [whole = "", fraction = ""] = text.split(".");
       if (fraction.slice(3).split("").some((digit) => digit !== "0")) throw new UsageError("max-idle must resolve to integer milliseconds");
       const milliseconds = BigInt(whole || "0") * 1000n + BigInt(fraction.slice(0, 3).padEnd(3, "0"));
       if (milliseconds > BigInt(Number.MAX_SAFE_INTEGER)) throw new UsageError("max-idle exceeds safe milliseconds");
       idleMs = Number(milliseconds);
-    } else if (argument2.startsWith("--")) {
-      args.push(argument2);
-      if ((argument2 === "--lines" || argument2 === "--bytes") && index + 1 < arguments_.length) args.push(arguments_[++index]);
+    } else if (argument.startsWith("--")) {
+      args.push(argument);
+      if ((argument === "--lines" || argument === "--bytes") && index + 1 < arguments_.length) args.push(arguments_[++index]);
     } else {
       let kept = "-";
-      for (let offset = 1; offset < argument2.length; offset++) {
-        const flag = argument2[offset];
+      for (let offset = 1; offset < argument.length; offset++) {
+        const flag = argument[offset];
         if (flag === "f" || flag === "F") {
           mode = flag;
           retry = flag === "F" || explicitRetry;
         } else if (flag === "s") {
-          sleepMs = sleep(offset + 1 === argument2.length ? arguments_[++index] : argument2.slice(offset + 1));
+          sleepMs = sleep(offset + 1 === argument.length ? arguments_[++index] : argument.slice(offset + 1));
           break;
         } else {
           kept += flag;
           if (flag === "n" || flag === "c") {
-            kept += argument2.slice(offset + 1);
-            if (offset + 1 === argument2.length && index + 1 < arguments_.length) {
+            kept += argument.slice(offset + 1);
+            if (offset + 1 === argument.length && index + 1 < arguments_.length) {
               args.push(kept, arguments_[++index]);
               kept = "-";
             }
@@ -2487,9 +2921,6 @@ function isSyncResolved(promise) {
   return Boolean(promise && typeof promise === "object" && promise[syncResolved]);
 }
 var sharedTrOutBuffer = new Uint8Array(64 * 1024);
-var cachedTrOutBuffer = new Uint8Array(32768);
-var lastTrInBuf;
-var lastTrMapping;
 var sharedTrOutInUse = false;
 var trConfigCache = /* @__PURE__ */ new Map();
 var lastTrArg0;
@@ -2885,14 +3316,14 @@ async function suffix(context, source, count, bytes, omit, delimiter) {
           const needed = line.bytes.length + (line.terminated ? 1 : 0);
           if (needed > batch.length) {
             if (batchUsed > 0) {
-              await output(context, batch.subarray(0, batchUsed));
+              await outputRange(context, batch, batchUsed);
               batchUsed = 0;
             }
             await output(context, line.terminated ? concatenate([line.bytes, delimiterByte]) : line.bytes);
             continue;
           }
           if (batchUsed + needed > batch.length) {
-            await output(context, batch.subarray(0, batchUsed));
+            await outputRange(context, batch, batchUsed);
             batchUsed = 0;
           }
           batch.set(line.bytes, batchUsed);
@@ -2900,7 +3331,7 @@ async function suffix(context, source, count, bytes, omit, delimiter) {
           if (line.terminated) batch[batchUsed++] = delimiter;
         }
         if (batchUsed > 0) {
-          await output(context, batch.subarray(0, batchUsed));
+          await outputRange(context, batch, batchUsed);
         }
       }
       return;
@@ -2990,12 +3421,12 @@ function headTailArguments(name, arguments_) {
   const args = [];
   let ended = false;
   for (let index = 0; index < arguments_.length; index++) {
-    const argument2 = arguments_[index];
-    if (argument2 === "--") ended = true;
+    const argument = arguments_[index];
+    if (argument === "--") ended = true;
     let offset = 1;
-    while (offset < argument2.length && argument2[offset] >= "0" && argument2[offset] <= "9") offset++;
-    if (!ended && (argument2[0] === "-" || name === "tail" && index === 0 && argument2[0] === "+") && offset > 1) {
-      const remainder = argument2.slice(offset);
+    while (offset < argument.length && argument[offset] >= "0" && argument[offset] <= "9") offset++;
+    if (!ended && (argument[0] === "-" || name === "tail" && index === 0 && argument[0] === "+") && offset > 1) {
+      const remainder = argument.slice(offset);
       let unitFlag = "-n";
       let unitSuffix = "";
       let rest = remainder;
@@ -3020,13 +3451,13 @@ function headTailArguments(name, arguments_) {
       }
       const allowedFlags = name === "tail" ? "qvzfF" : "qvz";
       if (Array.from(rest).every((ch) => allowedFlags.includes(ch))) {
-        args.push(unitFlag, `${argument2[0] === "+" ? "+" : ""}${argument2.slice(1, offset)}${unitSuffix}`);
+        args.push(unitFlag, `${argument[0] === "+" ? "+" : ""}${argument.slice(1, offset)}${unitSuffix}`);
         for (const ch of rest) args.push(`-${ch}`);
         continue;
       }
     }
-    args.push(argument2);
-    if (!ended && (["--lines", "--bytes", "--max-idle", "--sleep-interval", "--max-unchanged-stats"].includes(argument2) || argument2.startsWith("-") && !argument2.startsWith("--") && (argument2.endsWith("n") || argument2.endsWith("c") || argument2.endsWith("s")))) {
+    args.push(argument);
+    if (!ended && (["--lines", "--bytes", "--max-idle", "--sleep-interval", "--max-unchanged-stats"].includes(argument) || argument.startsWith("-") && !argument.startsWith("--") && (argument.endsWith("n") || argument.endsWith("c") || argument.endsWith("s")))) {
       if (arguments_[index + 1] !== void 0) args.push(arguments_[++index]);
     }
   }
@@ -3301,12 +3732,12 @@ function streamCommands(maxTeeTargets = Infinity, maxTailFollowHandles = Infinit
     define("tee", async (context) => {
       const args = [];
       let ended = false;
-      for (const argument2 of context.args) {
-        if (argument2 === "--") ended = true;
-        if (!ended && argument2 === "--output-error") args.push("--output-error=warn-nopipe");
-        else if (!ended && argument2.startsWith("-") && !argument2.startsWith("--") && argument2.includes("p")) {
-          for (const flag of argument2.slice(1)) args.push(flag === "p" ? "--output-error=warn-nopipe" : `-${flag}`);
-        } else args.push(argument2);
+      for (const argument of context.args) {
+        if (argument === "--") ended = true;
+        if (!ended && argument === "--output-error") args.push("--output-error=warn-nopipe");
+        else if (!ended && argument.startsWith("-") && !argument.startsWith("--") && argument.includes("p")) {
+          for (const flag of argument.slice(1)) args.push(flag === "p" ? "--output-error=warn-nopipe" : `-${flag}`);
+        } else args.push(argument);
       }
       const parsed = options(args, "ai", { append: "a", "ignore-interrupts": "i", "output-error": "output-error:" });
       const errorMode = value(parsed, "output-error");
@@ -3397,20 +3828,7 @@ function streamCommands(maxTeeTargets = Infinity, maxTailFollowHandles = Infinit
             const useShared = chunk.length <= sharedTrOutBuffer.length;
             const buf = useShared ? sharedTrOutBuffer : new Uint8Array(chunk.length);
             if (!deleting && !squeezing) {
-              if (useShared && chunk.length >= 256 && lastTrInBuf !== void 0 && chunk.length === lastTrInBuf.byteLength && mapping === lastTrMapping && equalBytes(lastTrInBuf, chunk)) {
-                const p2 = outputRange(context, cachedTrOutBuffer, chunk.length);
-                if (!isSyncResolved(p2)) {
-                  released = true;
-                  return executeTrAfterPending(p2, context, iter, deleting, squeezing, mapping, removed, squeezed, previous, true);
-                }
-                continue;
-              }
               for (let index = 0; index < chunk.length; index++) buf[index] = mapping[chunk[index]];
-              if (useShared && chunk.length >= 256 && chunk.length <= 32768) {
-                lastTrInBuf = encodeBytes(chunk);
-                lastTrMapping = mapping;
-                cachedTrOutBuffer.set(buf.subarray(0, chunk.length));
-              }
               const p = useShared ? outputRange(context, buf, chunk.length) : output(context, buf);
               if (!isSyncResolved(p)) {
                 released = true;
@@ -3439,12 +3857,15 @@ function streamCommands(maxTeeTargets = Infinity, maxTailFollowHandles = Infinit
           released = true;
           return rejectTrOutput(iter, err);
         } finally {
-          if (!released) sharedTrOutInUse = false;
+          if (!released) {
+            sharedTrOutBuffer.fill(0);
+            sharedTrOutInUse = false;
+          }
         }
       }
       return executeTrAsync(context, iter, deleting, squeezing, mapping, removed, squeezed, previous, false);
     })
-  ].map((command2) => ({ ...command2, filesystemRequirements: streamRequirements[command2.name] }));
+  ].map((command) => ({ ...command, filesystemRequirements: streamRequirements[command.name] }));
 }
 async function executeTrAsync(context, iter, deleting, squeezing, mapping, removed, squeezingTable, initialPrevious, alreadyOwnsShared) {
   const squeezed = squeezingTable;
@@ -3468,7 +3889,7 @@ async function executeTrAsync(context, iter, deleting, squeezing, mapping, remov
       const buf = useShared ? sharedTrOutBuffer : new Uint8Array(chunk.length);
       if (!deleting && !squeezing) {
         for (let index = 0; index < chunk.length; index++) buf[index] = mapping[chunk[index]];
-        const p = output(context, useShared ? buf.subarray(0, chunk.length) : buf);
+        const p = useShared ? outputRange(context, buf, chunk.length) : output(context, buf);
         if (!isSyncResolved(p)) await p;
         continue;
       }
@@ -3482,7 +3903,7 @@ async function executeTrAsync(context, iter, deleting, squeezing, mapping, remov
         previous = translated;
       }
       if (count) {
-        const p = output(context, buf.subarray(0, count));
+        const p = outputRange(context, buf, count);
         if (!isSyncResolved(p)) await p;
       }
     }
@@ -3490,7 +3911,10 @@ async function executeTrAsync(context, iter, deleting, squeezing, mapping, remov
     if (ownsShared) sharedTrOutBuffer = new Uint8Array(sharedTrOutBuffer.length);
     throw error;
   } finally {
-    if (ownsShared) sharedTrOutInUse = false;
+    if (ownsShared) {
+      sharedTrOutBuffer.fill(0);
+      sharedTrOutInUse = false;
+    }
     if (!done) {
       if (typeof iter.syncReturn === "function") iter.syncReturn();
       else await iter.return?.();
@@ -3968,7 +4392,7 @@ var SortWork = class {
     }
   }
 };
-async function sortRecords(records, compare2, work) {
+async function sortRecords(records, compare, work) {
   if (records.length < 2) return records;
   let source = records;
   let target = new Array(records.length);
@@ -3986,7 +4410,7 @@ async function sortRecords(records, compare2, work) {
             target[index] = source[left++];
             continue;
           }
-          const compared = compare2(source[left], source[right]);
+          const compared = compare(source[left], source[right]);
           const order = typeof compared === "number" ? compared : await compared;
           if (order <= 0) {
             target[index] = source[left++];
@@ -4054,9 +4478,6 @@ async function cutRanges(list, work) {
   }
   return normalized;
 }
-var sharedCutOutBuffer = new Uint8Array(64 * 1024);
-var sharedCutOutInUse = false;
-var sharedUniqOutBuffer = new Uint8Array(128 * 1024);
 function writeUniqCountBytes(writeByte, count) {
   const digits = String(count);
   const pad = 7 - digits.length;
@@ -4068,19 +4489,11 @@ var CutOutput = class {
   constructor(context, work) {
     this.context = context;
     this.work = work;
-    if (!sharedCutOutInUse) {
-      sharedCutOutInUse = true;
-      this.#buffer = sharedCutOutBuffer;
-      this.#ownsShared = true;
-    } else {
-      this.#buffer = new Uint8Array(64 * 1024);
-      this.#ownsShared = false;
-    }
+    this.#buffer = new Uint8Array(64 * 1024);
   }
   context;
   work;
   #buffer;
-  #ownsShared;
   #used = 0;
   get remaining() {
     return this.#buffer.length - this.#used;
@@ -4149,9 +4562,6 @@ var CutOutput = class {
     this.#used = 0;
     await output(this.context, bytes);
   }
-  release() {
-    if (this.#ownsShared) sharedCutOutInUse = false;
-  }
 };
 function cutFieldBoundary(record, separator, start, work) {
   if (record.length - start <= 4096) {
@@ -4516,7 +4926,7 @@ async function compareVersions(left, right, work) {
   if (result) return result;
   return await compareVersionParts(await versionPrefix(left, work), await versionPrefix(right, work), work) || await compareVersionParts(left, right, work);
 }
-async function mergeSortRuns(runs, compare2, work) {
+async function mergeSortRuns(runs, compare, work) {
   while (runs.length > 1) {
     const next = [];
     for (let index = 0; index < runs.length; index += 2) {
@@ -4531,7 +4941,7 @@ async function mergeSortRuns(runs, compare2, work) {
             merged.push(left[first++]);
             continue;
           }
-          const compared = compare2(left[first], right[second]);
+          const compared = compare(left[first], right[second]);
           const order = typeof compared === "number" ? compared : await compared;
           if (order <= 0) {
             merged.push(left[first++]);
@@ -4617,14 +5027,6 @@ var sharedSortIndices = new Int32Array(4096);
 var sharedSortScratchIndices = new Int32Array(4096);
 var sharedSortInScratch = new Uint8Array(65536);
 var sharedSortInUse = false;
-var sharedSortOutScratch = new Uint8Array(65536);
-var lastSort;
-var cachedCutOutBuffer = new Uint8Array(32768);
-var lastCutInBuf;
-var lastCutSep = -1;
-var lastCutField = -1;
-var lastCutMaxLineLen = 0;
-var lastCutOutUsed = -1;
 var SORT_LONG_OPTIONS = Object.freeze({
   "human-numeric-sort": "h",
   "numeric-sort": "n",
@@ -4932,13 +5334,13 @@ async function executeSortGeneral(context, preReadChunks) {
       break;
     }
   }
-  const args = hasCheckLong ? context.args.map((argument2) => {
-    if (ended) return argument2;
-    if (argument2 === "--") ended = true;
-    if (argument2 === "--check" || argument2 === "--check=diagnose-first") return "-c";
-    if (argument2 === "--check=quiet" || argument2 === "--check=silent") return "-C";
-    if (argument2.startsWith("--check=")) throw new UsageError(`invalid argument '${argument2.slice(8)}' for '--check'`);
-    return argument2;
+  const args = hasCheckLong ? context.args.map((argument) => {
+    if (ended) return argument;
+    if (argument === "--") ended = true;
+    if (argument === "--check" || argument === "--check=diagnose-first") return "-c";
+    if (argument === "--check=quiet" || argument === "--check=silent") return "-C";
+    if (argument.startsWith("--check=")) throw new UsageError(`invalid argument '${argument.slice(8)}' for '--check'`);
+    return argument;
   }) : context.args;
   const parsed = options(args, "hngMVdimrfbuszt:k:o:cCS:", SORT_LONG_OPTIONS, false, void 0, (key, index) => {
     if (key === "S" && !args[index].startsWith("--sort=") && args[index - 1] !== "--sort") throw new UsageError("invalid option -- 'S'");
@@ -5412,7 +5814,7 @@ async function executeSortGeneral(context, preReadChunks) {
     if (resolved !== 0 || skipTieFallback) return resolved;
     return await compareSortBytes(left, right, work) * direction;
   };
-  const compare2 = (left, right) => {
+  const compare = (left, right) => {
     const result = keyCompare(left, right);
     if (typeof result === "number") {
       if (result !== 0 || skipTieFallback) return result;
@@ -5424,7 +5826,7 @@ async function executeSortGeneral(context, preReadChunks) {
   const records = [];
   const runs = [];
   const checkRecordAsync = async (bytes) => {
-    if (records.length && (await compare2(records.at(-1), bytes) > 0 || parsed.flags.has("u") && await keyCompare(records.at(-1), bytes) === 0)) {
+    if (records.length && (await compare(records.at(-1), bytes) > 0 || parsed.flags.has("u") && await keyCompare(records.at(-1), bytes) === 0)) {
       if (!parsed.flags.has("C")) await diagnostic(context, new PublicDiagnostic(`disorder at record ${records.length + 1}`));
       return false;
     }
@@ -5450,121 +5852,7 @@ async function executeSortGeneral(context, preReadChunks) {
     }
   }
   if (checking) return { exitCode };
-  let ordered;
-  if (!parsed.flags.has("m") && !parsed.flags.has("u") && records.length >= 2 && records.length <= 65536 && (canMultiKeyFast || isSingleLexKeyFast)) {
-    const count = records.length;
-    const keySpecs = keys.map((k) => {
-      const f = k.flags.size ? k.flags : parsed.flags;
-      const numeric = f.has("n") || f.has("h");
-      const human = f.has("h");
-      const blanks = f.has("b");
-      const revScale = f.has("r") ? -1 : 1;
-      if (numeric) {
-        const fastNums = new Float64Array(count);
-        const numVals = new Array(count);
-        return { numeric: true, human, blanks, revScale, key: k, fastNums, numVals };
-      }
-      const slices = new Array(count);
-      return { numeric: false, blanks, revScale, key: k, slices };
-    });
-    for (let i = 0; i < count; i++) {
-      const rec = records[i];
-      for (let ki = 0; ki < keySpecs.length; ki++) {
-        const ks = keySpecs[ki];
-        const sliceOrPromise = keyBytesSync(rec, ks.key, separator, ks.blanks, work);
-        const slice = sliceOrPromise instanceof Promise ? await sliceOrPromise : sliceOrPromise;
-        if (ks.numeric) {
-          const parsedOrPromise = parseNumeric(slice, work, ks.human);
-          const nv = parsedOrPromise instanceof Promise ? await parsedOrPromise : parsedOrPromise;
-          ks.numVals[i] = nv;
-          if (!ks.human && nv.fraction.length === 0 && nv.whole.length <= 15) {
-            const mag = nv.whole.length === 0 ? 0 : Number(nv.whole);
-            ks.fastNums[i] = nv.negative ? mag === 0 ? 0 : -mag : mag;
-          } else {
-            ks.fastNums[i] = Number.NaN;
-          }
-        } else {
-          ks.slices[i] = slice;
-        }
-      }
-    }
-    let srcIdx = new Int32Array(count);
-    let dstIdx = new Int32Array(count);
-    for (let i = 0; i < count; i++) srcIdx[i] = i;
-    for (let width = 1; width < count; width *= 2) {
-      for (let begin = 0; begin < count; begin += width * 2) {
-        const middle = Math.min(begin + width, count);
-        const end = Math.min(begin + width * 2, count);
-        let left = begin;
-        let right = middle;
-        for (let index = begin; index < end; index++) {
-          const cp = work.charge(2);
-          if (cp) await cp;
-          if (left < middle) {
-            if (right === end) {
-              dstIdx[index] = srcIdx[left++];
-              continue;
-            }
-            const a = srcIdx[left];
-            const b = srcIdx[right];
-            let cmp = 0;
-            for (let ki = 0; ki < keySpecs.length; ki++) {
-              const ks = keySpecs[ki];
-              if (ks.numeric) {
-                const fa = ks.fastNums[a];
-                const fb = ks.fastNums[b];
-                if (fa === fa && fb === fb) {
-                  cmp = fa === fb ? 0 : fa < fb ? -ks.revScale : ks.revScale;
-                } else {
-                  const r = compareNumericValues(ks.numVals[a], ks.numVals[b], work);
-                  const resolved = typeof r === "number" ? r : await r;
-                  cmp = resolved * ks.revScale;
-                }
-              } else {
-                const sa = ks.slices[a];
-                const sb = ks.slices[b];
-                const lenA = sa.length;
-                const lenB = sb.length;
-                const minL = lenA < lenB ? lenA : lenB;
-                let d = 0;
-                for (let p = 0; p < minL; p++) {
-                  d = sa[p] - sb[p];
-                  if (d !== 0) break;
-                }
-                if (d === 0) d = lenA - lenB;
-                cmp = d * ks.revScale;
-              }
-              if (cmp !== 0) break;
-            }
-            if (cmp === 0 && !skipTieFallback) {
-              const ra = records[a];
-              const rb = records[b];
-              const minL = ra.length < rb.length ? ra.length : rb.length;
-              let d = 0;
-              for (let p = 0; p < minL; p++) {
-                d = ra[p] - rb[p];
-                if (d !== 0) break;
-              }
-              if (d === 0) d = ra.length - rb.length;
-              cmp = d * direction;
-            }
-            if (cmp <= 0) {
-              dstIdx[index] = srcIdx[left++];
-              continue;
-            }
-          }
-          dstIdx[index] = srcIdx[right++];
-        }
-      }
-      const tmp = srcIdx;
-      srcIdx = dstIdx;
-      dstIdx = tmp;
-    }
-    ordered = new Array(count);
-    for (let i = 0; i < count; i++) ordered[i] = records[srcIdx[i]];
-  } else {
-    ordered = parsed.flags.has("m") ? await mergeSortRuns(runs, compare2, work) : await sortRecords(records, compare2, work);
-  }
+  const ordered = parsed.flags.has("m") ? await mergeSortRuns(runs, compare, work) : await sortRecords(records, compare, work);
   let estBytes = 0;
   let allCounted = true;
   for (let i = 0; i < ordered.length; i++) {
@@ -5652,267 +5940,263 @@ async function executeCutGeneral(context) {
   const outputDelimiterBytes = outputDelimiter === void 0 ? separator : outputDelimiter.length === 0 ? Uint8Array.of(0) : encoder.encode(outputDelimiter);
   const writer = new CutOutput(context, work);
   let exitCode = 0;
-  try {
-    for (const name of parsed.operands.length ? parsed.operands : ["-"]) {
+  for (const name of parsed.operands.length ? parsed.operands : ["-"]) {
+    try {
       try {
-        try {
-          const onlyDelimited = parsed.flags.has("s");
-          const fastSingleByteField = mode === "f" && separator.length === 1;
-          const sepByte = separator[0];
-          const outDelimLen = outputDelimiterBytes.length;
-          const processFastFieldRangeSlow = async (buf, lineStart, lineEnd) => {
-            context.signal.throwIfAborted();
-            let boundary = buf.indexOf(sepByte, lineStart);
-            if (boundary >= lineEnd) boundary = -1;
-            const c0 = work.charge(boundary < 0 ? lineEnd - lineStart : boundary - lineStart + 1);
-            if (c0) await c0;
+        const onlyDelimited = parsed.flags.has("s");
+        const fastSingleByteField = mode === "f" && separator.length === 1;
+        const sepByte = separator[0];
+        const outDelimLen = outputDelimiterBytes.length;
+        const processFastFieldRangeSlow = async (buf, lineStart, lineEnd) => {
+          context.signal.throwIfAborted();
+          let boundary = buf.indexOf(sepByte, lineStart);
+          if (boundary >= lineEnd) boundary = -1;
+          const c0 = work.charge(boundary < 0 ? lineEnd - lineStart : boundary - lineStart + 1);
+          if (c0) await c0;
+          if (boundary < 0) {
+            if (onlyDelimited) return;
+            const w = writer.writeRange(buf, lineStart, lineEnd);
+            if (w) await w;
+          } else {
+            let cursor = 0;
+            let field = 1;
+            let start = lineStart;
+            let emitted = false;
+            while (true) {
+              const cp = work.charge();
+              if (cp) await cp;
+              while (cursor < ranges.length && field > ranges[cursor].end) cursor++;
+              const included = cursor < ranges.length && field >= ranges[cursor].start;
+              if (included !== complement) {
+                if (emitted) {
+                  const w1 = writer.write(outputDelimiterBytes);
+                  if (w1) await w1;
+                }
+                const w2 = writer.writeRange(buf, start, boundary < 0 ? lineEnd : boundary);
+                if (w2) await w2;
+                emitted = true;
+              }
+              field++;
+              if (boundary < 0 || !complement && cursor >= ranges.length) break;
+              start = boundary + 1;
+              boundary = start <= lineEnd ? buf.indexOf(sepByte, start) : -1;
+              if (boundary >= lineEnd) boundary = -1;
+              const cn = work.charge(boundary < 0 ? lineEnd - start : boundary - start + 1);
+              if (cn) await cn;
+            }
+          }
+          const wd = writer.writeByte(recordDelimiter);
+          if (wd) await wd;
+        };
+        const processFastFieldRange = (buf, lineStart, lineEnd) => {
+          const lineLen = lineEnd - lineStart;
+          if (writer.remaining <= lineLen * (outDelimLen > 1 ? outDelimLen : 1) + 1) {
+            return processFastFieldRangeSlow(buf, lineStart, lineEnd);
+          }
+          context.signal.throwIfAborted();
+          let boundary = buf.indexOf(sepByte, lineStart);
+          if (boundary >= lineEnd) boundary = -1;
+          let totalCharge = boundary < 0 ? lineLen : boundary - lineStart + 1;
+          if (boundary < 0) {
+            if (onlyDelimited) return work.charge(totalCharge);
+            totalCharge += writer.writeRangeUncharged(buf, lineStart, lineEnd);
+          } else {
+            let cursor = 0;
+            let field = 1;
+            let start = lineStart;
+            let emitted = false;
+            while (true) {
+              totalCharge += 1;
+              while (cursor < ranges.length && field > ranges[cursor].end) cursor++;
+              const included = cursor < ranges.length && field >= ranges[cursor].start;
+              if (included !== complement) {
+                if (emitted) {
+                  totalCharge += writer.writeRangeUncharged(outputDelimiterBytes, 0, outDelimLen);
+                }
+                totalCharge += writer.writeRangeUncharged(buf, start, boundary < 0 ? lineEnd : boundary);
+                emitted = true;
+              }
+              field++;
+              if (boundary < 0 || !complement && cursor >= ranges.length) break;
+              start = boundary + 1;
+              boundary = start <= lineEnd ? buf.indexOf(sepByte, start) : -1;
+              if (boundary >= lineEnd) boundary = -1;
+              totalCharge += boundary < 0 ? lineEnd - start : boundary - start + 1;
+            }
+          }
+          writer.writeByteUncharged(recordDelimiter);
+          totalCharge += 1;
+          return work.charge(totalCharge);
+        };
+        const sharedUtf8Decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+        const canFastSliceCut = (byteSelection || mode === "c") && !complement && ranges.length <= 16;
+        const processFastSliceRange = (buf, lineStart, lineEnd) => {
+          const lineLen = lineEnd - lineStart;
+          if (writer.remaining <= lineLen + (outputDelimiter !== void 0 ? Math.max(0, ranges.length - 1) * outDelimLen : 0) + 1) {
+            return null;
+          }
+          if (!byteSelection) {
+            for (let i = lineStart; i < lineEnd; i++) {
+              if (buf[i] >= 128) return null;
+            }
+          }
+          context.signal.throwIfAborted();
+          let totalCharge = lineLen + 1;
+          let emitted = false;
+          for (let rIdx = 0; rIdx < ranges.length; rIdx++) {
+            const r = ranges[rIdx];
+            const s = lineStart + r.start - 1;
+            if (s >= lineEnd) break;
+            const e = Math.min(lineEnd, lineStart + r.end);
+            if (e > s) {
+              if (emitted && outputDelimiter !== void 0) {
+                totalCharge += writer.writeRangeUncharged(outputDelimiterBytes, 0, outDelimLen);
+              }
+              totalCharge += writer.writeRangeUncharged(buf, s, e);
+              emitted = true;
+            }
+          }
+          writer.writeByteUncharged(recordDelimiter);
+          return work.charge(totalCharge);
+        };
+        const processLineBytes = async (lineBytes) => {
+          context.signal.throwIfAborted();
+          let cursor = 0;
+          const selected = (position) => {
+            while (cursor < ranges.length && position > ranges[cursor].end) cursor++;
+            const included = cursor < ranges.length && position >= ranges[cursor].start;
+            return included !== complement ? cursor : -1;
+          };
+          if (mode === "f") {
+            const record = encodeBytes(lineBytes.buffer, lineBytes.byteOffset, lineBytes.byteLength);
+            const b0 = cutFieldBoundary(record, separator, 0, work);
+            let boundary = typeof b0 === "number" ? b0 : await b0;
             if (boundary < 0) {
               if (onlyDelimited) return;
-              const w = writer.writeRange(buf, lineStart, lineEnd);
+              const w = writer.write(lineBytes);
               if (w) await w;
             } else {
-              let cursor = 0;
               let field = 1;
-              let start = lineStart;
+              let start = 0;
               let emitted = false;
               while (true) {
-                const cp = work.charge();
-                if (cp) await cp;
-                while (cursor < ranges.length && field > ranges[cursor].end) cursor++;
-                const included = cursor < ranges.length && field >= ranges[cursor].start;
-                if (included !== complement) {
+                const checkpoint = work.charge();
+                if (checkpoint) await checkpoint;
+                if (selected(field++) >= 0) {
                   if (emitted) {
                     const w1 = writer.write(outputDelimiterBytes);
                     if (w1) await w1;
                   }
-                  const w2 = writer.writeRange(buf, start, boundary < 0 ? lineEnd : boundary);
+                  const w2 = writer.write(record.subarray(start, boundary < 0 ? record.length : boundary));
                   if (w2) await w2;
                   emitted = true;
                 }
-                field++;
                 if (boundary < 0 || !complement && cursor >= ranges.length) break;
-                start = boundary + 1;
-                boundary = start <= lineEnd ? buf.indexOf(sepByte, start) : -1;
-                if (boundary >= lineEnd) boundary = -1;
-                const cn = work.charge(boundary < 0 ? lineEnd - start : boundary - start + 1);
-                if (cn) await cn;
+                start = boundary + separator.length;
+                const bn = cutFieldBoundary(record, separator, start, work);
+                boundary = typeof bn === "number" ? bn : await bn;
               }
             }
-            const wd = writer.writeByte(recordDelimiter);
-            if (wd) await wd;
-          };
-          const processFastFieldRange = (buf, lineStart, lineEnd) => {
-            const lineLen = lineEnd - lineStart;
-            if (writer.remaining <= lineLen * (outDelimLen > 1 ? outDelimLen : 1) + 1) {
-              return processFastFieldRangeSlow(buf, lineStart, lineEnd);
-            }
-            context.signal.throwIfAborted();
-            let boundary = buf.indexOf(sepByte, lineStart);
-            if (boundary >= lineEnd) boundary = -1;
-            let totalCharge = boundary < 0 ? lineLen : boundary - lineStart + 1;
-            if (boundary < 0) {
-              if (onlyDelimited) return work.charge(totalCharge);
-              totalCharge += writer.writeRangeUncharged(buf, lineStart, lineEnd);
-            } else {
-              let cursor = 0;
-              let field = 1;
-              let start = lineStart;
-              let emitted = false;
-              while (true) {
-                totalCharge += 1;
-                while (cursor < ranges.length && field > ranges[cursor].end) cursor++;
-                const included = cursor < ranges.length && field >= ranges[cursor].start;
-                if (included !== complement) {
-                  if (emitted) {
-                    totalCharge += writer.writeRangeUncharged(outputDelimiterBytes, 0, outDelimLen);
-                  }
-                  totalCharge += writer.writeRangeUncharged(buf, start, boundary < 0 ? lineEnd : boundary);
+          } else if (byteSelection) {
+            let emitted = false;
+            let previousRange = -1;
+            for (let offset = 0; offset < lineBytes.length; offset += 4096) {
+              const end = Math.min(lineBytes.length, offset + 4096);
+              const checkpoint = work.charge(end - offset);
+              if (checkpoint) await checkpoint;
+              let start = -1;
+              for (let index = offset; index < end; index++) {
+                const range = selected(index + 1);
+                if (range !== previousRange && start >= 0) {
+                  await writer.write(lineBytes.subarray(start, index));
+                  start = -1;
+                }
+                if (range >= 0 && start < 0) {
+                  if (range !== previousRange && emitted && outputDelimiter !== void 0) await writer.write(outputDelimiterBytes);
+                  start = index;
                   emitted = true;
                 }
-                field++;
-                if (boundary < 0 || !complement && cursor >= ranges.length) break;
-                start = boundary + 1;
-                boundary = start <= lineEnd ? buf.indexOf(sepByte, start) : -1;
-                if (boundary >= lineEnd) boundary = -1;
-                totalCharge += boundary < 0 ? lineEnd - start : boundary - start + 1;
-              }
-            }
-            writer.writeByteUncharged(recordDelimiter);
-            totalCharge += 1;
-            return work.charge(totalCharge);
-          };
-          const sharedUtf8Decoder = new TextDecoder("utf-8", { ignoreBOM: true });
-          const canFastSliceCut = (byteSelection || mode === "c") && !complement && ranges.length <= 16;
-          const processFastSliceRange = (buf, lineStart, lineEnd) => {
-            const lineLen = lineEnd - lineStart;
-            if (writer.remaining <= lineLen * (outDelimLen > 1 ? outDelimLen : 1) + 1) {
-              return null;
-            }
-            if (!byteSelection) {
-              for (let i = lineStart; i < lineEnd; i++) {
-                if (buf[i] >= 128) return null;
+                previousRange = range;
               }
+              if (start >= 0) await writer.write(lineBytes.subarray(start, end));
             }
-            context.signal.throwIfAborted();
-            let totalCharge = lineLen + 1;
+          } else {
+            const decoder2 = sharedUtf8Decoder;
+            let index = 0;
             let emitted = false;
-            for (let rIdx = 0; rIdx < ranges.length; rIdx++) {
-              const r = ranges[rIdx];
-              const s = lineStart + r.start - 1;
-              if (s >= lineEnd) break;
-              const e = Math.min(lineEnd, lineStart + r.end);
-              if (e > s) {
-                if (emitted && outputDelimiter !== void 0) {
-                  totalCharge += writer.writeRangeUncharged(outputDelimiterBytes, 0, outDelimLen);
-                }
-                totalCharge += writer.writeRangeUncharged(buf, s, e);
-                emitted = true;
-              }
-            }
-            writer.writeByteUncharged(recordDelimiter);
-            return work.charge(totalCharge);
-          };
-          const processLineBytes = async (lineBytes) => {
-            context.signal.throwIfAborted();
-            let cursor = 0;
-            const selected = (position) => {
-              while (cursor < ranges.length && position > ranges[cursor].end) cursor++;
-              const included = cursor < ranges.length && position >= ranges[cursor].start;
-              return included !== complement ? cursor : -1;
-            };
-            if (mode === "f") {
-              const record = encodeBytes(lineBytes.buffer, lineBytes.byteOffset, lineBytes.byteLength);
-              const b0 = cutFieldBoundary(record, separator, 0, work);
-              let boundary = typeof b0 === "number" ? b0 : await b0;
-              if (boundary < 0) {
-                if (onlyDelimited) return;
-                const w = writer.write(lineBytes);
-                if (w) await w;
-              } else {
-                let field = 1;
-                let start = 0;
-                let emitted = false;
-                while (true) {
-                  const checkpoint = work.charge();
-                  if (checkpoint) await checkpoint;
-                  if (selected(field++) >= 0) {
-                    if (emitted) {
-                      const w1 = writer.write(outputDelimiterBytes);
-                      if (w1) await w1;
-                    }
-                    const w2 = writer.write(record.subarray(start, boundary < 0 ? record.length : boundary));
-                    if (w2) await w2;
-                    emitted = true;
-                  }
-                  if (boundary < 0 || !complement && cursor >= ranges.length) break;
-                  start = boundary + separator.length;
-                  const bn = cutFieldBoundary(record, separator, start, work);
-                  boundary = typeof bn === "number" ? bn : await bn;
-                }
-              }
-            } else if (byteSelection) {
-              let emitted = false;
-              let previousRange = -1;
-              for (let offset = 0; offset < lineBytes.length; offset += 4096) {
-                const end = Math.min(lineBytes.length, offset + 4096);
-                const checkpoint = work.charge(end - offset);
-                if (checkpoint) await checkpoint;
-                let start = -1;
-                for (let index = offset; index < end; index++) {
-                  const range = selected(index + 1);
-                  if (range !== previousRange && start >= 0) {
-                    await writer.write(lineBytes.subarray(start, index));
-                    start = -1;
-                  }
-                  if (range >= 0 && start < 0) {
-                    if (range !== previousRange && emitted && outputDelimiter !== void 0) await writer.write(outputDelimiterBytes);
-                    start = index;
-                    emitted = true;
-                  }
-                  previousRange = range;
-                }
-                if (start >= 0) await writer.write(lineBytes.subarray(start, end));
-              }
-            } else {
-              const decoder = sharedUtf8Decoder;
-              let index = 0;
-              let emitted = false;
-              let previousRange = -1;
-              for (let offset = 0; offset < lineBytes.length; offset += 4096) {
-                const end = Math.min(lineBytes.length, offset + 4096);
-                const checkpoint = work.charge(end - offset);
-                if (checkpoint) await checkpoint;
-                const text = decoder.decode(lineBytes.subarray(offset, end), { stream: end < lineBytes.length });
-                let start = -1;
-                let position = 0;
-                for (const character of text) {
-                  const checkpoint2 = work.charge();
-                  if (checkpoint2) await checkpoint2;
-                  const range = selected(++index);
-                  if (range !== previousRange && start >= 0) {
-                    await writer.text(text.slice(start, position));
-                    start = -1;
-                  }
-                  if (range >= 0 && start < 0) {
-                    if (range !== previousRange && emitted && outputDelimiter !== void 0) await writer.write(outputDelimiterBytes);
-                    start = position;
-                    emitted = true;
-                  }
-                  position += character.length;
-                  previousRange = range;
+            let previousRange = -1;
+            for (let offset = 0; offset < lineBytes.length; offset += 4096) {
+              const end = Math.min(lineBytes.length, offset + 4096);
+              const checkpoint = work.charge(end - offset);
+              if (checkpoint) await checkpoint;
+              const text = decoder2.decode(lineBytes.subarray(offset, end), { stream: end < lineBytes.length });
+              let start = -1;
+              let position = 0;
+              for (const character of text) {
+                const checkpoint2 = work.charge();
+                if (checkpoint2) await checkpoint2;
+                const range = selected(++index);
+                if (range !== previousRange && start >= 0) {
+                  await writer.text(text.slice(start, position));
+                  start = -1;
                 }
-                if (start >= 0) await writer.text(text.slice(start));
-              }
-            }
-            const wd = writer.writeByte(recordDelimiter);
-            if (wd) await wd;
-          };
-          const pending = new RecordBuffer(bufferLimit);
-          try {
-            for await (const chunk of input(context, name)) {
-              let start = 0;
-              while (start < chunk.length) {
-                const offset = chunk.indexOf(recordDelimiter, start);
-                if (offset < 0) break;
-                if (fastSingleByteField && pending.size === 0 && offset - start <= 4096) {
-                  const p = processFastFieldRange(chunk, start, offset);
-                  if (p) await p;
-                } else if (canFastSliceCut && pending.size === 0 && offset - start <= 4096) {
-                  const p = processFastSliceRange(chunk, start, offset);
-                  if (p === null) {
-                    await processLineBytes(chunk.subarray(start, offset));
-                  } else if (p) {
-                    await p;
-                  }
-                } else {
-                  await processLineBytes(pending.finish(void 0, chunk, start, offset));
+                if (range >= 0 && start < 0) {
+                  if (range !== previousRange && emitted && outputDelimiter !== void 0) await writer.write(outputDelimiterBytes);
+                  start = position;
+                  emitted = true;
                 }
-                start = offset + 1;
+                position += character.length;
+                previousRange = range;
               }
-              pending.append(chunk, start);
+              if (start >= 0) await writer.text(text.slice(start));
             }
-            if (pending.size) {
-              const finalBytes = pending.finish();
-              if (fastSingleByteField && finalBytes.length <= 4096) {
-                const p = processFastFieldRange(finalBytes, 0, finalBytes.length);
+          }
+          const wd = writer.writeByte(recordDelimiter);
+          if (wd) await wd;
+        };
+        const pending = new RecordBuffer(bufferLimit);
+        try {
+          for await (const chunk of input(context, name)) {
+            let start = 0;
+            while (start < chunk.length) {
+              const offset = chunk.indexOf(recordDelimiter, start);
+              if (offset < 0) break;
+              if (fastSingleByteField && pending.size === 0 && offset - start <= 4096) {
+                const p = processFastFieldRange(chunk, start, offset);
                 if (p) await p;
+              } else if (canFastSliceCut && pending.size === 0 && offset - start <= 4096) {
+                const p = processFastSliceRange(chunk, start, offset);
+                if (p === null) {
+                  await processLineBytes(chunk.subarray(start, offset));
+                } else if (p) {
+                  await p;
+                }
               } else {
-                await processLineBytes(finalBytes);
+                await processLineBytes(pending.finish(void 0, chunk, start, offset));
               }
+              start = offset + 1;
+            }
+            pending.append(chunk, start);
+          }
+          if (pending.size) {
+            const finalBytes = pending.finish();
+            if (fastSingleByteField && finalBytes.length <= 4096) {
+              const p = processFastFieldRange(finalBytes, 0, finalBytes.length);
+              if (p) await p;
+            } else {
+              await processLineBytes(finalBytes);
             }
-          } finally {
-            pending.clear();
           }
         } finally {
-          await writer.flush();
+          pending.clear();
         }
-      } catch (error) {
-        await diagnostic(context, error);
-        exitCode = 1;
+      } finally {
+        await writer.flush();
       }
+    } catch (error) {
+      await diagnostic(context, error);
+      exitCode = 1;
     }
-  } finally {
-    writer.release();
   }
   return { exitCode };
 }
@@ -5924,12 +6208,12 @@ async function executeUniqGeneral(context, preReadSource) {
   let ended = false;
   let repeatedMethod = "none";
   let groupMethod;
-  const args = context.args.map((argument2) => {
-    if (ended) return argument2;
-    if (argument2 === "--") ended = true;
-    if (argument2 === "--all-repeated") return "--all-repeated=none";
-    if (argument2 === "--group") return "--group=separate";
-    return argument2;
+  const args = context.args.map((argument) => {
+    if (ended) return argument;
+    if (argument === "--") ended = true;
+    if (argument === "--all-repeated") return "--all-repeated=none";
+    if (argument === "--group") return "--group=separate";
+    return argument;
   });
   const parsed = options(args, "cduiDf:s:w:z", { count: "c", repeated: "d", unique: "u", "all-repeated": "all-repeated:", group: "group:", "ignore-case": "i", "skip-fields": "f", "skip-chars": "s", "check-chars": "w", "zero-terminated": "z" }, false, void 0, void 0, (option, method) => {
     if (option === "D") repeatedMethod = "none";
@@ -6129,22 +6413,6 @@ function textCommands() {
             } catch (error) {
               return diagnostic(context, error).then(RETURN_EXIT_TWO);
             }
-            const cached = lastSort;
-            if (cached !== void 0 && firstChunkLen >= 256 && firstChunkLen === cached.input.byteLength && direction === cached.direction && cached.maxLineLength <= bufferLimit && equalBytes(cached.input, rawFirst)) {
-              let res2Fast;
-              try {
-                res2Fast = srcIter.tryNextSync();
-              } catch (error) {
-                return diagnostic(context, error).then(RETURN_EXIT_TWO);
-              }
-              if (res2Fast !== void 0 && res2Fast.done) {
-                context.signal.throwIfAborted();
-                const p = outputRange(context, cached.output, cached.output.length);
-                if (isSyncResolved2(p)) return RESOLVED_EXIT_ZERO;
-                return p.then(RETURN_EXIT_ZERO);
-              }
-              return executeSortFastContinueAsync(context, direction, srcIter, cached.input, res2Fast);
-            }
             let firstChunk;
             let usedSortInScratch = false;
             try {
@@ -6166,11 +6434,9 @@ function textCommands() {
                 let start = 0;
                 let count = 0;
                 let validLines = true;
-                let maxSortLine = 0;
                 while (start < firstChunkLen) {
                   const offset = firstChunk.indexOf(10, start);
                   const lLen = offset - start;
-                  if (lLen > maxSortLine) maxSortLine = lLen;
                   if (offset < 0 || offset >= firstChunkLen || count >= 4096 || lLen > bufferLimit) {
                     validLines = false;
                     break;
@@ -6218,7 +6484,7 @@ function textCommands() {
                     src = dst;
                     dst = tmp;
                   }
-                  const outBuf = sharedSortOutScratch;
+                  const outBuf = new Uint8Array(65536);
                   let used = 0;
                   for (let i = 0; i < count; i++) {
                     const idx = src[i];
@@ -6227,14 +6493,6 @@ function textCommands() {
                     for (let p2 = s; p2 < e; p2++) outBuf[used++] = firstChunk[p2];
                     outBuf[used++] = 10;
                   }
-                  if (firstChunkLen >= 256 && used <= 32768) {
-                    lastSort = {
-                      input: encodeBytes(firstChunk.subarray(0, firstChunkLen)),
-                      output: outBuf.slice(0, used),
-                      direction,
-                      maxLineLength: maxSortLine
-                    };
-                  }
                   const p = outputRange(context, outBuf, used);
                   if (isSyncResolved2(p)) return RESOLVED_EXIT_ZERO;
                   return p.then(RETURN_EXIT_ZERO);
@@ -6245,7 +6503,10 @@ function textCommands() {
             } catch (error) {
               return diagnostic(context, error).then(RETURN_EXIT_TWO);
             } finally {
-              if (usedSortInScratch) sharedSortInUse = false;
+              if (usedSortInScratch) {
+                sharedSortInScratch.fill(0);
+                sharedSortInUse = false;
+              }
             }
           }
         }
@@ -6298,7 +6559,7 @@ function textCommands() {
                 return diagnostic(context, error).then(RETURN_EXIT_ONE);
               }
               if (res2 !== void 0 && res2.done && chunk.length <= 65536) {
-                const outBuf = sharedUniqOutBuffer;
+                const outBuf = new Uint8Array(128 * 1024);
                 let outUsed = 0;
                 let prevStart = -1;
                 let prevEnd = -1;
@@ -6480,7 +6741,7 @@ function textCommands() {
         }
         if (canFast && (targetField >= 1 || fieldMask !== 0 && typeof context.stdin.tryReadAllSync === "function")) {
           const req = assertInputRequirements(context, operand !== void 0 ? [operand] : EMPTY_OPERANDS);
-          if (!req && operand === void 0 && !sharedCutOutInUse) {
+          if (!req && operand === void 0) {
             const srcIter = input(context, "-")[Symbol.asyncIterator]();
             if (typeof srcIter.tryNextSync === "function") {
               let res1;
@@ -6498,18 +6759,10 @@ function textCommands() {
                 } catch (error) {
                   return diagnostic(context, error).then(RETURN_EXIT_ONE);
                 }
-                if (res2 !== void 0 && res2.done && chunk.length < sharedCutOutBuffer.length) {
-                  if (fieldMask === 0 && lastCutOutUsed >= 0 && chunk.length >= 256 && lastCutInBuf !== void 0 && chunk.length === lastCutInBuf.byteLength && sepByte === lastCutSep && targetField === lastCutField && lastCutMaxLineLen <= bufferLimit && equalBytes(lastCutInBuf, chunk)) {
-                    context.signal.throwIfAborted();
-                    if (lastCutOutUsed === 0) return RESOLVED_EXIT_ZERO;
-                    const p2 = outputRange(context, cachedCutOutBuffer, lastCutOutUsed);
-                    if (isSyncResolved2(p2)) return RESOLVED_EXIT_ZERO;
-                    return p2.then(RETURN_EXIT_ZERO);
-                  }
-                  const outBuf = sharedCutOutBuffer;
+                if (res2 !== void 0 && res2.done && chunk.length < 65536) {
+                  const outBuf = new Uint8Array(65536);
                   let outUsed = 0;
                   let start = 0;
-                  let maxCutLine = 0;
                   while (start < chunk.length) {
                     let offset = chunk.indexOf(10, start);
                     const hasNewline = offset >= 0;
@@ -6522,7 +6775,6 @@ function textCommands() {
                     context.signal.throwIfAborted();
                     let boundary = chunk.indexOf(sepByte, start);
                     if (boundary >= offset) boundary = -1;
-                    if (offset - start > maxCutLine) maxCutLine = offset - start;
                     if (fieldMask !== 0 && boundary >= 0) {
                       let f = 1;
                       let curStart = start;
@@ -6565,14 +6817,6 @@ function textCommands() {
                     }
                     start = offset + 1;
                   }
-                  if (fieldMask === 0 && chunk.length >= 256 && outUsed <= 32768) {
-                    lastCutInBuf = encodeBytes(chunk);
-                    lastCutSep = sepByte;
-                    lastCutField = targetField;
-                    lastCutMaxLineLen = maxCutLine;
-                    lastCutOutUsed = outUsed;
-                    cachedCutOutBuffer.set(outBuf.subarray(0, outUsed));
-                  }
                   if (outUsed === 0) return RESOLVED_EXIT_ZERO;
                   const p = outputRange(context, outBuf, outUsed);
                   if (isSyncResolved2(p)) return RESOLVED_EXIT_ZERO;
@@ -6588,7 +6832,7 @@ function textCommands() {
       }
       return executeCutGeneral(context);
     })
-  ].map((command2) => ({ ...command2, filesystemRequirements: command2.name === "cut" ? inputRequirements : textOutputRequirements }));
+  ].map((command) => ({ ...command, filesystemRequirements: command.name === "cut" ? inputRequirements : textOutputRequirements }));
 }
 async function executeSortFastAsync(context, direction, req) {
   await req;
@@ -6679,9 +6923,7 @@ async function executeSortFastContinueAsync(context, direction, srcIter, initial
 }
 async function executeCutFastAsync(context, operand, sepByte, targetField, req, existingIter, initialFirstChunk, initialSecondRes) {
   if (req) await req;
-  const ownsShared = !sharedCutOutInUse;
-  if (ownsShared) sharedCutOutInUse = true;
-  const outBuf = ownsShared ? sharedCutOutBuffer : new Uint8Array(65536);
+  const outBuf = new Uint8Array(65536);
   let outUsed = 0;
   const isPipeStage = Boolean(context.stdout.isPipeStage);
   const syncSink = !isPipeStage ? context.stdout : void 0;
@@ -6812,8 +7054,6 @@ async function executeCutFastAsync(context, operand, sepByte, targetField, req,
   } catch (error) {
     await diagnostic(context, error);
     return { exitCode: 1 };
-  } finally {
-    if (ownsShared) sharedCutOutInUse = false;
   }
 }
 
@@ -6822,7 +7062,7 @@ init_platform();
 
 // packages/safe-bash/src/commands/shuf/index.ts
 init_platform();
-import { RandomIntegers, createShufCommand, createShufCommands as createShufCommands2, evalSyncShuf, settings as settings6, shufCommands } from "../../safe-bash-command-shuf/index.js";
+import { RandomIntegers, createShufCommand as createShufCommand2, createShufCommands as createShufCommands2, evalSyncShuf, settings as settings19, shufCommands as shufCommands2 } from "../../safe-bash-command-shuf/index.js";
 
 // packages/safe-bash/src/commands/standard.ts
 var defaultBaseStandardCommands;
@@ -6830,12 +7070,12 @@ var defaultTailStandardCommands;
 function createStandardCommandsWithGrep(options2, grep) {
   const commands = [];
   const execute = directExecutor(options2.execute ?? (async (context) => {
-    const command2 = commands.find((definition) => definition.name === context.command);
-    if (command2) return command2.execute(context);
+    const command = commands.find((definition) => definition.name === context.command);
+    if (command) return command.execute(context);
     await diagnostic(context, new PublicDiagnostic("command not found"));
     return { exitCode: 127 };
   }));
-  if (options2.maxDirectoryEntries === void 0 && options2.maxTeeTargets === void 0 && options2.maxTailFollowHandles === void 0 && options2.predicateIdentity === void 0) {
+  if (options2.maxDirectoryEntries === void 0 && options2.maxRecursiveDirectoryDepth === void 0 && options2.maxTeeTargets === void 0 && options2.maxTailFollowHandles === void 0 && options2.predicateIdentity === void 0) {
     defaultBaseStandardCommands ??= Object.freeze([
       ...basicCommands(),
       ...filesystemCommands(void 0),
@@ -6846,7 +7086,7 @@ function createStandardCommandsWithGrep(options2, grep) {
       ...predicateCommands(void 0),
       cmpCommand(),
       fmtCommand(),
-      createShufCommand(),
+      createShufCommand2(),
       numfmtCommand()
     ]);
     commands.push(
@@ -6859,8 +7099,8 @@ function createStandardCommandsWithGrep(options2, grep) {
     for (let i = 0; i < commands.length; i++) builtInDirectContextExecutors.add(commands[i].execute);
     return commands;
   }
-  commands.push(...basicCommands(), ...filesystemCommands(options2.maxDirectoryEntries), ...streamCommands(options2.maxTeeTargets, options2.maxTailFollowHandles), ...textCommands(), ...grep, ...predicateCommands(options2.predicateIdentity), ...executionCommands(execute, options2.execution), ...createFindDefinitions(execute, options2.maxDirectoryEntries));
-  commands.push(cmpCommand(), fmtCommand(), createShufCommand(), numfmtCommand());
+  commands.push(...basicCommands(), ...filesystemCommands(options2.maxDirectoryEntries, options2.maxRecursiveDirectoryDepth), ...streamCommands(options2.maxTeeTargets, options2.maxTailFollowHandles), ...textCommands(), ...grep, ...predicateCommands(options2.predicateIdentity), ...executionCommands(execute, options2.execution), ...createFindDefinitions(execute, options2.maxDirectoryEntries));
+  commands.push(cmpCommand(), fmtCommand(), createShufCommand2(), numfmtCommand());
   for (let i = 0; i < commands.length; i++) builtInDirectContextExecutors.add(commands[i].execute);
   return commands;
 }
@@ -6876,18 +7116,13 @@ import { alias, createGrepAliases } from "../../safe-bash-io-engine/commands/gre
 // packages/safe-bash/src/plugins/composition.ts
 import { createExprCommandWithExecutor } from "../../safe-bash-command-expr/command.js";
 import { createCsplitCommandWithExecutor } from "../../safe-bash-command-csplit/command.js";
-var defaultMuscleMemoryLookup;
-function getExtraAgentCommand(name) {
-  defaultMuscleMemoryLookup ??= new Map(createExtraAgentCommands().map((cmd) => [cmd.name, cmd]));
-  return defaultMuscleMemoryLookup.get(name);
-}
 function createExtraAgentCommands(options2) {
   return [...createBcCommands(options2?.bc), ...createSpongeCommands(options2?.sponge), ...createOpensslCommands(), ...createSshCommands(), ...createGpgCommands(), ...createFdCommands(options2?.fd), ...createLessCommands(options2?.less), ...createIdCommands(), ...createWhoamiCommands(), ...createUnameCommands(), ...createHostnameCommands(), ...createNprocCommands(), ...createShufCommands(), ...createYesCommands(), ...createDdCommands(), ...createNumfmtCommands(), ...createEnvsubstCommands(), ...createCalCommands(), ...createPathchkCommands(), ...createGetconfCommands(), ...createLocaleCommands(), ...createDfCommands(), ...createSqlite3Commands(options2?.sqlite3)];
 }
 function commandExecutor(lookup) {
   return async (context) => {
-    const command2 = lookup(context.command) ?? getExtraAgentCommand(context.command);
-    if (command2) return command2.execute(context);
+    const command = lookup(context.command);
+    if (command) return command.execute(context);
     await diagnostic(context, new PublicDiagnostic("command not found"));
     return { exitCode: 127 };
   };
@@ -6946,7 +7181,7 @@ function composeRawAgentCommands(options2, executors, additionalCommands = []) {
     const defaults = getDefaultStatelessFamilies();
     const aliasesGrep = executors.aliases === executors.grep ? grep[0] : createGrepCommands(executors.aliases, { ergonomicRegex: useErgonomicGrep })[0];
     commands.push(
-      ...createStandardCommandsWithGrep({ execute: options2.execute ?? commandExecutor((name) => commands.find((command2) => command2.name === name)), ...options2.execution === void 0 ? {} : { execution: options2.execution }, ...options2.regex === void 0 ? {} : { regex: options2.regex }, ...options2.maxDirectoryEntries === void 0 ? {} : { maxDirectoryEntries: options2.maxDirectoryEntries }, ...options2.maxTeeTargets === void 0 ? {} : { maxTeeTargets: options2.maxTeeTargets }, ...options2.maxTailFollowHandles === void 0 ? {} : { maxTailFollowHandles: options2.maxTailFollowHandles } }, grep),
+      ...createStandardCommandsWithGrep({ execute: options2.execute ?? commandExecutor((name) => commands.find((command) => command.name === name)), ...options2.execution === void 0 ? {} : { execution: options2.execution }, ...options2.regex === void 0 ? {} : { regex: options2.regex }, ...options2.maxDirectoryEntries === void 0 ? {} : { maxDirectoryEntries: options2.maxDirectoryEntries }, ...options2.maxRecursiveDirectoryDepth === void 0 ? {} : { maxRecursiveDirectoryDepth: options2.maxRecursiveDirectoryDepth }, ...options2.maxTeeTargets === void 0 ? {} : { maxTeeTargets: options2.maxTeeTargets }, ...options2.maxTailFollowHandles === void 0 ? {} : { maxTailFollowHandles: options2.maxTailFollowHandles } }, grep),
       ...defaults.beforeAliases,
       createRgCommand(executors.search, options2.search),
       ...createGrepAliases(aliasesGrep),
@@ -6973,7 +7208,7 @@ function composeRawAgentCommands(options2, executors, additionalCommands = []) {
   const applyPatchLimits = options2.applyPatch?.limits;
   const xmlLimits = options2.xml?.limits;
   commands.push(
-    ...createStandardCommandsWithGrep({ execute: options2.execute ?? commandExecutor((name) => commands.find((command2) => command2.name === name)), ...options2.execution === void 0 ? {} : { execution: options2.execution }, ...options2.regex === void 0 ? {} : { regex: options2.regex }, ...options2.maxDirectoryEntries === void 0 ? {} : { maxDirectoryEntries: options2.maxDirectoryEntries }, ...options2.maxTeeTargets === void 0 ? {} : { maxTeeTargets: options2.maxTeeTargets }, ...options2.maxTailFollowHandles === void 0 ? {} : { maxTailFollowHandles: options2.maxTailFollowHandles } }, grep).filter((command2) => !options2.muscleMemory || command2.name !== "shuf" && command2.name !== "numfmt"),
+    ...createStandardCommandsWithGrep({ execute: options2.execute ?? commandExecutor((name) => commands.find((command) => command.name === name)), ...options2.execution === void 0 ? {} : { execution: options2.execution }, ...options2.regex === void 0 ? {} : { regex: options2.regex }, ...options2.maxDirectoryEntries === void 0 ? {} : { maxDirectoryEntries: options2.maxDirectoryEntries }, ...options2.maxRecursiveDirectoryDepth === void 0 ? {} : { maxRecursiveDirectoryDepth: options2.maxRecursiveDirectoryDepth }, ...options2.maxTeeTargets === void 0 ? {} : { maxTeeTargets: options2.maxTeeTargets }, ...options2.maxTailFollowHandles === void 0 ? {} : { maxTailFollowHandles: options2.maxTailFollowHandles } }, grep).filter((command) => !options2.muscleMemory || command.name !== "shuf" && command.name !== "numfmt"),
     ...createTextProgramCommands({ ...options2.text }),
     ...createStructuredCommands({ ...options2.structured }),
     createRgCommand(executors.search, options2.search),
@@ -7056,6 +7291,9 @@ function createAgentCommandPlugin(options2, executors, additionalCommands = [])
 }
 
 export {
+  createNumfmtCommand,
+  createNumfmtCommands,
+  numfmtCommands,
   createStandardCommandsWithGrep,
   sedCommand,
   createTextProgramCommands,
@@ -7072,19 +7310,12 @@ export {
   xxdCommands,
   createByteCommands,
   byteCommands,
-  createTableTextCommands,
-  tableTextCommands,
-  createSplitCommand,
-  createSplitCommands,
-  evalSyncSplit,
-  splitCommands,
-  columnCommands,
-  createColumnCommand,
-  createColumnCommands,
-  applyPatchCommands,
-  createApplyPatchCommand,
-  createApplyPatchCommands,
-  evalSyncApplyPatch,
+  createBcCommand,
+  createBcCommands,
+  bcCommands,
+  createSpongeCommand,
+  createSpongeCommands,
+  spongeCommands,
   createOpensslCommand,
   createOpensslCommands,
   opensslCommands,
@@ -7095,9 +7326,42 @@ export {
   createGpgCommand,
   createGpgCommands,
   gpgCommands,
+  createIdCommand,
+  createIdCommands,
+  idCommands,
+  createWhoamiCommand,
+  createWhoamiCommands,
+  whoamiCommands,
+  createUnameCommand,
+  createUnameCommands,
+  unameCommands,
+  createHostnameCommand,
+  createHostnameCommands,
+  hostnameCommands,
+  createNprocCommand,
+  createNprocCommands,
+  nprocCommands,
+  createShufCommand,
+  createShufCommands,
+  shufCommands,
   createYesCommand,
   createYesCommands,
   yesCommands,
+  createDdCommand,
+  createDdCommands,
+  ddCommands,
+  createEnvsubstCommand,
+  createEnvsubstCommands,
+  envsubstCommands,
+  createGetconfCommand,
+  createGetconfCommands,
+  getconfCommands,
+  createLocaleCommand,
+  createLocaleCommands,
+  localeCommands,
+  createSqlite3Command,
+  createSqlite3Commands,
+  sqlite3Commands,
   composeAgentCommands,
   createRegexExecutors,
   baseAgentCommands,