@poe-platform/safe-bash 0.1.800 → 0.1.801

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

@@ -1,101 +1,83 @@
 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 {
   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-SZH7EJLD.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";
+} from "./chunk-IVRQ4BXL.js";
 import {
   compareByteArrays,
   decodeBytes,
   encodeBytes,
-  equalBytes,
   indexOfBytes
-} from "./chunk-BHJE5LPZ.js";
+} from "./chunk-D3ANYGMC.js";
 import {
   createPrCommands
-} from "./chunk-F3RV2F72.js";
+} from "./chunk-CHYGPFVM.js";
 import {
   RegexExecutor,
   createBoundedRegexProvider
-} from "./chunk-6HZYFL3H.js";
+} from "./chunk-NR3EM4LS.js";
 import {
   Chi,
   HashMD,
@@ -115,23 +97,23 @@ import {
   sha256,
   sha384,
   sha512
-} from "./chunk-JJSTTIEZ.js";
+} from "./chunk-ICFDYV64.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";
+} from "./chunk-7R5BDCG7.js";
 import {
   RESOLVED_EXIT_ZERO,
   RETURN_EXIT_ONE,
@@ -143,11 +125,13 @@ import {
   builtInDirectContextExecutors,
   codeOf,
   concatenate,
+  decoder,
   define,
   diagnostic,
   encoder,
   input,
   integer,
+  isDefaultCommandOptions,
   lines,
   options,
   output,
@@ -158,10 +142,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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
+        }
+      }
+      for (const command4 of commands) host.commands.register(command4, { replace });
+    }
+  };
+}
 
 // packages/safe-bash/src/commands/text-programs/index.ts
 init_platform();
@@ -242,11 +255,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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command4 of commands) host.commands.register(command4, { replace });
     }
   };
 }
@@ -272,11 +285,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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command4 of commands) host.commands.register(command4, { replace });
     }
   };
 }
@@ -342,11 +355,11 @@ import { createJoinCommand } from "../../safe-bash-command-join/join.js";
 
 // packages/safe-bash/src/commands/table-text/internal.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";
+import { Budget as Budget2, Inputs, OrderCheck, RecordReader, argument, command, compare, empty, encode, fail, settings as settings2 } from "../../safe-bash-table-text-engine/table-text/internal.js";
 
 // packages/safe-bash/src/commands/table-text/index.ts
 function createTableTextCommands(options2 = {}) {
-  settings(options2);
+  settings2(options2);
   const defs = [createPasteCommand(options2), createCommCommand(options2), createJoinCommand(options2)];
   for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
   return defs;
@@ -361,6 +374,85 @@ function tableTextCommands(options2 = {}) {
   } };
 }
 
+// packages/safe-bash/src/commands/stream-inspection/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/stream-inspection/tac.ts
+init_platform();
+import { createTacWithSettings } from "../../safe-bash-command-tac/tac.js";
+
+// packages/safe-bash/src/commands/stream-inspection/expand.ts
+init_platform();
+import { createExpandWithSettings } from "../../safe-bash-command-expand/expand.js";
+
+// packages/safe-bash/src/commands/stream-inspection/index.ts
+import { createFoldCommand } from "../../safe-bash-command-fold/family.js";
+
+// packages/safe-bash/src/commands/stream-inspection/strings.ts
+init_platform();
+import { createStringsWithSettings } from "../../safe-bash-command-strings/strings.js";
+
+// packages/safe-bash/src/commands/stream-inspection/shared.ts
+init_platform();
+import { ByteOutput, RecordBuffer, Session, command as command2, settings as settings3 } from "../../safe-bash-text-stream-engine/stream-inspection/shared.js";
+
+// packages/safe-bash/src/commands/stream-inspection/index.ts
+function createStreamInspectionCommands(options2 = {}) {
+  const limits = settings3(options2);
+  const defs = [createTacWithSettings(limits), createExpandWithSettings(limits), createFoldCommand(limits), createStringsWithSettings(limits)];
+  for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  return defs;
+}
+function streamInspectionCommands(options2 = {}) {
+  const commands = createStreamInspectionCommands(options2);
+  return { name: "stream-inspection-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}`);
+    }
+    for (const definition of commands) host.commands.register(definition, { replace: options2.replace ?? false });
+  } };
+}
+
+// packages/safe-bash/src/commands/stream-format/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/stream-format/seq.ts
+init_platform();
+import { createSeqWithSettings } from "../../safe-bash-command-seq/seq.js";
+
+// packages/safe-bash/src/commands/stream-format/nl.ts
+init_platform();
+import { createNlWithSettings } from "../../safe-bash-command-nl/nl.js";
+
+// packages/safe-bash/src/commands/stream-format/rev.ts
+init_platform();
+import { createRevWithSettings } from "../../safe-bash-command-rev/rev.js";
+
+// packages/safe-bash/src/commands/stream-format/unexpand.ts
+init_platform();
+import { createUnexpandWithSettings } from "../../safe-bash-command-unexpand/unexpand.js";
+
+// packages/safe-bash/src/commands/stream-format/shared.ts
+init_platform();
+import { ByteOutput as ByteOutput2, Session as Session2, command as command3, forEachRecord, records, settings as settings4 } from "../../safe-bash-text-stream-engine/stream-format/shared.js";
+
+// packages/safe-bash/src/commands/stream-format/index.ts
+function createStreamFormatCommands(options2 = {}) {
+  const limits = settings4(options2);
+  const defs = [createSeqWithSettings(limits), createNlWithSettings(limits), createRevWithSettings(limits), createUnexpandWithSettings(limits)];
+  for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  return defs;
+}
+function streamFormatCommands(options2 = {}) {
+  const commands = createStreamFormatCommands(options2);
+  return { name: "stream-format-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}`);
+    }
+    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";
@@ -373,6 +465,112 @@ import { columnCommands, createColumnCommand, createColumnCommands } from "../..
 init_platform();
 import { applyPatchCommands, createApplyPatchCommand, createApplyPatchCommands, evalSyncApplyPatch } from "../../safe-bash-command-apply-patch/index.js";
 
+// packages/safe-bash/src/commands/bc/index.ts
+init_platform();
+import {
+  createBcCommand as createRawBcCommand,
+  createBcCommands as createRawBcCommands
+} from "../../safe-bash-command-bc/index.js";
+import { settings as settings5 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
+        }
+      }
+      for (const command4 of commands) host.commands.register(command4, { replace });
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/sponge/index.ts
+init_platform();
+import {
+  createSpongeCommand as createRawSpongeCommand,
+  createSpongeCommands as createRawSpongeCommands,
+  spongeCommands as rawSpongeCommands,
+  settings as settings6
+} 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 "";
+}
+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 });
+      }
+    }
+  };
+}
+
 // packages/safe-bash/src/commands/openssl/index.ts
 init_platform();
 
@@ -615,7 +813,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 settings7 } 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 +839,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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command4 of commands) host.commands.register(command4, { replace });
     }
   };
 }
@@ -1204,7 +1402,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 settings8 } 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 +1542,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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command4 of commands) host.commands.register(command4, { replace });
     }
   };
 }
@@ -1699,7 +1897,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 settings9 } 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 +2006,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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace });
+      for (const command4 of commands) host.commands.register(command4, { replace });
     }
   };
 }
@@ -1995,11 +2193,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 settings10 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
+        }
+      }
+      for (const command4 of commands) host.commands.register(command4, { 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 settings11 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
+        }
+      }
+      for (const command4 of commands) host.commands.register(command4, { 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 settings12 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
+        }
+      }
+      for (const command4 of commands) host.commands.register(command4, { 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 settings13 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
+        }
+      }
+      for (const command4 of commands) host.commands.register(command4, { 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 settings14 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
+        }
+      }
+      for (const command4 of commands) host.commands.register(command4, { 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 settings15 } 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 settings16, 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 command4 of commands) {
+          if (host.commands.has(command4.name)) throw new Error(`Command already registered: ${command4.name}`);
+        }
+      }
+      for (const command4 of commands) host.commands.register(command4, { 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 settings18 } 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 settings19 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) {
+            throw new Error(`Command already registered: ${command4.name}`);
+          }
+        }
+      }
+      for (const command4 of commands) {
+        host.commands.register(command4, { 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 settings20 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) {
+            throw new Error(`Command already registered: ${command4.name}`);
+          }
+        }
+      }
+      for (const command4 of commands) {
+        host.commands.register(command4, { 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 settings21 } 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 command4 of commands) {
+          if (host.commands.has(command4.name)) {
+            throw new Error(`Command already registered: ${command4.name}`);
+          }
+        }
+      }
+      for (const command4 of commands) {
+        host.commands.register(command4, { replace: options2.replace ?? false });
+      }
+    }
+  };
+}
+syncCommandEvaluators.evalSyncSqlite3 = evalSyncSqlite3;
+
 // packages/safe-bash/src/plugins/composition.ts
 init_platform();
 
@@ -2476,7 +3003,7 @@ async function followTail(caller, selection, cap, select, scheduler = tailFollow
 
 // packages/safe-bash/src/commands/record-buffer.ts
 init_platform();
-import { RecordBuffer } from "../../safe-bash-io-engine/record-buffer.js";
+import { RecordBuffer as RecordBuffer2 } from "../../safe-bash-io-engine/record-buffer.js";
 
 // packages/safe-bash/src/commands/streams.ts
 var SMALL_WC_COUNT_LINES = Array.from({ length: 129 }, (_, i) => `${i}
@@ -2487,9 +3014,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;
@@ -2827,7 +3351,7 @@ async function suffix(context, source, count, bytes, omit, delimiter) {
       let pendingLines = [];
       let start2 = 0;
       let size2 = 0;
-      const pending2 = new RecordBuffer(bufferLimit);
+      const pending2 = new RecordBuffer2(bufferLimit);
       const pushLine = (lineBytes, terminated) => {
         const lineLength = lineBytes.length + (terminated ? 1 : 0);
         pendingLines.push({ bytes: lineBytes, terminated });
@@ -2911,10 +3435,10 @@ async function suffix(context, source, count, bytes, omit, delimiter) {
   let pending = [];
   let start = 0;
   let size = 0;
-  const records = bytes ? source : (async function* () {
+  const records2 = bytes ? source : (async function* () {
     for await (const line of lines(source, delimiter)) yield line.terminated ? concatenate([line.bytes, Uint8Array.of(delimiter)]) : line.bytes;
   })();
-  for await (const chunk of records) {
+  for await (const chunk of records2) {
     context.signal.throwIfAborted();
     if (bytes && !chunk.length) continue;
     pending.push(new Uint8Array(chunk));
@@ -3397,20 +3921,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 +3950,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((command4) => ({ ...command4, filesystemRequirements: streamRequirements[command4.name] }));
 }
 async function executeTrAsync(context, iter, deleting, squeezing, mapping, removed, squeezingTable, initialPrevious, alreadyOwnsShared) {
   const squeezed = squeezingTable;
@@ -3490,7 +4004,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,14 +4485,14 @@ var SortWork = class {
     }
   }
 };
-async function sortRecords(records, compare2, work) {
-  if (records.length < 2) return records;
-  let source = records;
-  let target = new Array(records.length);
-  for (let width = 1; width < records.length; width *= 2) {
-    for (let begin = 0; begin < records.length; begin += width * 2) {
-      const middle = Math.min(begin + width, records.length);
-      const end = Math.min(begin + width * 2, records.length);
+async function sortRecords(records2, compare2, work) {
+  if (records2.length < 2) return records2;
+  let source = records2;
+  let target = new Array(records2.length);
+  for (let width = 1; width < records2.length; width *= 2) {
+    for (let begin = 0; begin < records2.length; begin += width * 2) {
+      const middle = Math.min(begin + width, records2.length);
+      const end = Math.min(begin + width * 2, records2.length);
       let left = begin;
       let right = middle;
       for (let index = begin; index < end; index++) {
@@ -4054,9 +4571,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 +4582,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 +4655,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) {
@@ -4617,14 +5120,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",
@@ -4826,11 +5321,11 @@ async function keyBytes(line, key, separator, blanks, work) {
   const end = key.end === void 0 ? line.length : last === void 0 ? line.length : key.endCharacter === void 0 ? last.end : Math.min(line.length, await fieldStart(last, key.endBlanks || inheritBlanks) + key.endCharacter);
   return line.subarray(Math.min(start, line.length), Math.max(start, end));
 }
-async function emitRecords(context, records, destination) {
+async function emitRecords(context, records2, destination) {
   if (destination === void 0) {
     const buffered = createBufferedOutput(context.stdout, context.signal);
     try {
-      for await (const bytes of records) {
+      for await (const bytes of records2) {
         await buffered.write(bytes);
         await buffered.flush();
       }
@@ -4841,12 +5336,12 @@ async function emitRecords(context, records, destination) {
   }
   await admitTextOutput(context, destination);
   const capabilities = await context.fs.capabilitiesFor?.(pathOf(context, destination), { signal: context.signal }) ?? context.fs.capabilities;
-  if (context.fs.writeStream && capabilities.streamingWrite !== false) await context.fs.writeStream(pathOf(context, destination), records, { signal: context.signal });
+  if (context.fs.writeStream && capabilities.streamingWrite !== false) await context.fs.writeStream(pathOf(context, destination), records2, { signal: context.signal });
   else {
     if (capabilities.write === false) throw new FsError("ENOTSUP", { syscall: "writeFile", path: pathOf(context, destination) });
     let size = 0;
     const chunks = [];
-    for await (const bytes of records) {
+    for await (const bytes of records2) {
       size += bytes.length;
       if (size > bufferLimit) throw new FsError("EFBIG", { message: "output buffer limit exceeded" });
       chunks.push(bytes);
@@ -4855,7 +5350,7 @@ async function emitRecords(context, records, destination) {
   }
 }
 async function readOwnedSortInput(source, signal, firstChunk, secondResult) {
-  const buffered = new RecordBuffer(bufferLimit);
+  const buffered = new RecordBuffer2(bufferLimit);
   try {
     signal.throwIfAborted();
     if (firstChunk) buffered.append(firstChunk);
@@ -4878,7 +5373,7 @@ async function readOwnedSortInput(source, signal, firstChunk, secondResult) {
   }
 }
 async function collectSortRecords(source, delimiter, budget, signal, accept) {
-  const pending = new RecordBuffer(bufferLimit);
+  const pending = new RecordBuffer2(bufferLimit);
   const admit = (length) => {
     signal.throwIfAborted();
     budget.admit(length);
@@ -5421,20 +5916,20 @@ async function executeSortGeneral(context, preReadChunks) {
     }
     return compareSlowAsync(result, left, right);
   };
-  const records = [];
+  const records2 = [];
   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 (!parsed.flags.has("C")) await diagnostic(context, new PublicDiagnostic(`disorder at record ${records.length + 1}`));
+    if (records2.length && (await compare2(records2.at(-1), bytes) > 0 || parsed.flags.has("u") && await keyCompare(records2.at(-1), bytes) === 0)) {
+      if (!parsed.flags.has("C")) await diagnostic(context, new PublicDiagnostic(`disorder at record ${records2.length + 1}`));
       return false;
     }
-    records.push(bytes);
+    records2.push(bytes);
     return true;
   };
   for (const name of parsed.operands.length ? parsed.operands : ["-"]) {
     const run = [];
     if (parsed.flags.has("m")) runs.push(run);
-    const targetList = parsed.flags.has("m") ? run : records;
+    const targetList = parsed.flags.has("m") ? run : records2;
     const acceptRecord = checking ? checkRecordAsync : (bytes) => {
       targetList.push(bytes);
     };
@@ -5451,8 +5946,8 @@ 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;
+  if (!parsed.flags.has("m") && !parsed.flags.has("u") && records2.length >= 2 && records2.length <= 65536 && (canMultiKeyFast || isSingleLexKeyFast)) {
+    const count = records2.length;
     const keySpecs = keys.map((k) => {
       const f = k.flags.size ? k.flags : parsed.flags;
       const numeric = f.has("n") || f.has("h");
@@ -5468,7 +5963,7 @@ async function executeSortGeneral(context, preReadChunks) {
       return { numeric: false, blanks, revScale, key: k, slices };
     });
     for (let i = 0; i < count; i++) {
-      const rec = records[i];
+      const rec = records2[i];
       for (let ki = 0; ki < keySpecs.length; ki++) {
         const ks = keySpecs[ki];
         const sliceOrPromise = keyBytesSync(rec, ks.key, separator, ks.blanks, work);
@@ -5537,8 +6032,8 @@ async function executeSortGeneral(context, preReadChunks) {
               if (cmp !== 0) break;
             }
             if (cmp === 0 && !skipTieFallback) {
-              const ra = records[a];
-              const rb = records[b];
+              const ra = records2[a];
+              const rb = records2[b];
               const minL = ra.length < rb.length ? ra.length : rb.length;
               let d = 0;
               for (let p = 0; p < minL; p++) {
@@ -5561,9 +6056,9 @@ async function executeSortGeneral(context, preReadChunks) {
       dstIdx = tmp;
     }
     ordered = new Array(count);
-    for (let i = 0; i < count; i++) ordered[i] = records[srcIdx[i]];
+    for (let i = 0; i < count; i++) ordered[i] = records2[srcIdx[i]];
   } else {
-    ordered = parsed.flags.has("m") ? await mergeSortRuns(runs, compare2, work) : await sortRecords(records, compare2, work);
+    ordered = parsed.flags.has("m") ? await mergeSortRuns(runs, compare2, work) : await sortRecords(records2, compare2, work);
   }
   let estBytes = 0;
   let allCounted = true;
@@ -5652,267 +6147,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 * (outDelimLen > 1 ? outDelimLen : 1) + 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);
+            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;
                 }
-                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;
-                }
-                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 RecordBuffer2(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 };
 }
@@ -6000,7 +6491,7 @@ async function executeUniqGeneral(context, preReadSource) {
     }
     return ignoreCase ? fold(result) : result;
   };
-  const records = (async function* () {
+  const records2 = (async function* () {
     let previous;
     let previousKey;
     let count = 0;
@@ -6066,7 +6557,7 @@ async function executeUniqGeneral(context, preReadSource) {
         }
       }
     };
-    const pending = new RecordBuffer(bufferLimit);
+    const pending = new RecordBuffer2(bufferLimit);
     try {
       for await (const chunk of preReadSource ?? input(context, parsed.operands[0])) {
         let start = 0;
@@ -6101,7 +6592,7 @@ async function executeUniqGeneral(context, preReadSource) {
     while (flushChunks.length) yield flushChunks.shift();
     if (outUsed > 0) yield outBuf.subarray(0, outUsed);
   })();
-  await emitRecords(context, records, parsed.operands[1]);
+  await emitRecords(context, records2, parsed.operands[1]);
   return { exitCode: 0 };
 }
 function textCommands() {
@@ -6129,22 +6620,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 +6641,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 +6691,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 +6700,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 +6710,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 +6766,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 +6948,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 +6966,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 +6982,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 +7024,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 +7039,7 @@ function textCommands() {
       }
       return executeCutGeneral(context);
     })
-  ].map((command2) => ({ ...command2, filesystemRequirements: command2.name === "cut" ? inputRequirements : textOutputRequirements }));
+  ].map((command4) => ({ ...command4, filesystemRequirements: command4.name === "cut" ? inputRequirements : textOutputRequirements }));
 }
 async function executeSortFastAsync(context, direction, req) {
   await req;
@@ -6679,9 +7130,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 +7261,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 +7269,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 settings22, shufCommands as shufCommands2 } from "../../safe-bash-command-shuf/index.js";
 
 // packages/safe-bash/src/commands/standard.ts
 var defaultBaseStandardCommands;
@@ -6830,12 +7277,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 command4 = commands.find((definition) => definition.name === context.command);
+    if (command4) return command4.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 +7293,7 @@ function createStandardCommandsWithGrep(options2, grep) {
       ...predicateCommands(void 0),
       cmpCommand(),
       fmtCommand(),
-      createShufCommand(),
+      createShufCommand2(),
       numfmtCommand()
     ]);
     commands.push(
@@ -6859,8 +7306,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 +7323,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 command4 = lookup(context.command);
+    if (command4) return command4.execute(context);
     await diagnostic(context, new PublicDiagnostic("command not found"));
     return { exitCode: 127 };
   };
@@ -6946,7 +7388,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((command4) => command4.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 +7415,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((command4) => command4.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((command4) => !options2.muscleMemory || command4.name !== "shuf" && command4.name !== "numfmt"),
     ...createTextProgramCommands({ ...options2.text }),
     ...createStructuredCommands({ ...options2.structured }),
     createRgCommand(executors.search, options2.search),
@@ -7056,6 +7498,9 @@ function createAgentCommandPlugin(options2, executors, additionalCommands = [])
 }
 
 export {
+  createNumfmtCommand,
+  createNumfmtCommands,
+  numfmtCommands,
   createStandardCommandsWithGrep,
   sedCommand,
   createTextProgramCommands,
@@ -7074,6 +7519,10 @@ export {
   byteCommands,
   createTableTextCommands,
   tableTextCommands,
+  createStreamInspectionCommands,
+  streamInspectionCommands,
+  createStreamFormatCommands,
+  streamFormatCommands,
   createSplitCommand,
   createSplitCommands,
   evalSyncSplit,
@@ -7085,6 +7534,12 @@ export {
   createApplyPatchCommand,
   createApplyPatchCommands,
   evalSyncApplyPatch,
+  createBcCommand,
+  createBcCommands,
+  bcCommands,
+  createSpongeCommand,
+  createSpongeCommands,
+  spongeCommands,
   createOpensslCommand,
   createOpensslCommands,
   opensslCommands,
@@ -7095,9 +7550,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,