@poe-platform/safe-bash 0.1.802 → 0.1.803

package/dist/safe-bash/chunks/{chunk-44ALJ4QG.js → chunk-PNBBUWSM.js}

@@ -15,23 +15,15 @@ import {
   quoteShellOperand,
   writeDiagnostic
 } from "./chunk-PH63PLPZ.js";
-import {
-  shellValueByteLength,
-  shellValueBytes
-} from "./chunk-J42RIHHJ.js";
-import {
-  getCommandArguments
-} from "./chunk-7R5BDCG7.js";
-import {
-  creationUmask,
-  getRuntimeBackingFileSystem,
-  modeChange
-} from "./chunk-VSAJ4OTM.js";
 import {
   byteLength,
   compareUtf8,
   equalBytes
 } from "./chunk-D3ANYGMC.js";
+import {
+  shellValueByteLength,
+  shellValueBytes
+} from "./chunk-J42RIHHJ.js";
 import {
   FsError
 } from "./chunk-VTH3MLDU.js";
@@ -44,12 +36,18 @@ import {
   relativePath,
   resolvePath,
   yieldTurn
-} from "./chunk-NZQXYWA3.js";
+} from "./chunk-5OHX7C2V.js";
 import {
   collectBytes,
   readBytes,
   writeBytes
 } from "./chunk-74GHTNJA.js";
+import {
+  getCommandArguments
+} from "./chunk-7R5BDCG7.js";
+import {
+  modeChange
+} from "./chunk-VBTDHOWC.js";
 import {
   RESOLVED_EXIT_ZERO,
   UsageError,
@@ -361,6 +359,10 @@ import { clearRgFastRunnerPool, createRgCommand } from "../../safe-bash-command-
 init_platform();
 import { assertCommandRequirements, evaluateCommandSupport } from "../../safe-bash-contracts/command-requirements.js";
 
+// packages/safe-bash/src/fs/creation-mask.ts
+init_platform();
+import { abortManagedController, addAbortSignalWaiter, builtInDirectContextExecutors as builtInDirectContextExecutors2, chargeRuntimeFileSystemOperation, combineManagedSignals, createManagedControlController, creationUmask, getRuntimeBackingFileSystem, interruptible, isManagedAbortSignal, isManagedControlSignal, isSyncResolved, notifyAbortSignalWaiters, registerManagedAbortSignal, registerRuntimeBackingFileSystem, removeAbortSignalWaiter, syncCommandEvaluators as syncCommandEvaluators2, toNativeAbortSignal } from "../../safe-bash-contracts/runtime-control.js";
+
 // packages/safe-bash/src/commands/bytes/checksums/index.ts
 init_platform();
 import { command } from "../../safe-bash-checksum-engine/index.js";
@@ -417,10 +419,11 @@ function createCompressionCommands(config = {}) {
   if (maxDecodedBytes !== void 0 && maxDecodedBytes !== Infinity && (!Number.isSafeInteger(maxDecodedBytes) || maxDecodedBytes < 0)) {
     throw new RangeError("maxDecodedBytes must be a nonnegative safe integer or Infinity");
   }
-  const commands = profiles.flatMap((profile) => profile.format === "gzip" ? createGzipCommands(config) : profile.format === "bzip2" ? createBzip2Commands(config) : profile.names.map((name) => define(name, withInputByteBudget(async (context) => {
-    const options2 = parseOptions(name, context.args);
-    if (options2.help) {
-      await output(context, `Usage: ${name} [OPTION]... [FILE]...
+  const commands = profiles.flatMap((profile) => profile.format === "gzip" ? createGzipCommands(config) : profile.format === "bzip2" ? createBzip2Commands(config) : profile.names.map((name) => {
+    const command2 = define(name, async (context) => {
+      const options2 = parseOptions(name, context.args);
+      if (options2.help) {
+        await output(context, `Usage: ${name} [OPTION]... [FILE]...
 -c, --stdout, --to-stdout
 -d, --decompress, --uncompress
 -k, --keep
@@ -430,48 +433,50 @@ ${options2.format === "zstd" ? "-1..-9, --best\nHigher levels and --fast[=NUM] a
 `}-h, --help
 No FILE or FILE '-' uses stdin; file output uses private VFS staging.
 `);
-      return { exitCode: 0 };
-    }
-    let plans;
-    let planningFailed = false;
-    try {
-      if (options2.operands.length > 1) {
-        plans = [];
-        for (const name2 of options2.operands) {
-          try {
-            plans.push(...await planOperands(context, { ...options2, operands: [name2] }));
-          } catch (error) {
-            context.signal.throwIfAborted();
-            if (codeOf(error) === "EROFS") throw error;
-            planningFailed = true;
-            if (options2.quiet < 2) await diagnostic(context, error);
-          }
-        }
-        if (plans.length > 1) await verifyOperandDestinations(context, plans);
-      } else plans = await planOperands(context, options2);
-    } catch (error) {
-      context.signal.throwIfAborted();
-      if (options2.quiet < 2) throw error;
-      return { exitCode: 1 };
-    }
-    const decodedBudget = new DecodedBudget(maxDecodedBytes);
-    let exitCode = planningFailed ? 1 : 0;
-    for (const plan of plans) {
+        return { exitCode: 0 };
+      }
+      let plans;
+      let planningFailed = false;
       try {
-        const warned = await runOperand(context, plan, options2, decodedBudget);
-        if (warned) {
-          if (!options2.quiet) await diagnostic(context, new PublicDiagnostic(`${plan.source}: decompression OK, trailing garbage ignored`));
-          if (exitCode === 0) exitCode = 2;
-        }
+        if (options2.operands.length > 1) {
+          plans = [];
+          for (const name2 of options2.operands) {
+            try {
+              plans.push(...await planOperands(context, { ...options2, operands: [name2] }));
+            } catch (error) {
+              context.signal.throwIfAborted();
+              if (codeOf(error) === "EROFS") throw error;
+              planningFailed = true;
+              if (options2.quiet < 2) await diagnostic(context, error);
+            }
+          }
+          if (plans.length > 1) await verifyOperandDestinations(context, plans);
+        } else plans = await planOperands(context, options2);
       } catch (error) {
         context.signal.throwIfAborted();
-        if (options2.quiet < 2) await diagnostic(context, error);
-        exitCode = 1;
-        if (decodedBudget.exceeded) break;
+        if (options2.quiet < 2) throw error;
+        return { exitCode: 1 };
       }
-    }
-    return { exitCode };
-  }))));
+      const decodedBudget = new DecodedBudget(maxDecodedBytes);
+      let exitCode = planningFailed ? 1 : 0;
+      for (const plan of plans) {
+        try {
+          const warned = await runOperand(context, plan, options2, decodedBudget);
+          if (warned) {
+            if (!options2.quiet) await diagnostic(context, new PublicDiagnostic(`${plan.source}: decompression OK, trailing garbage ignored`));
+            if (exitCode === 0) exitCode = 2;
+          }
+        } catch (error) {
+          context.signal.throwIfAborted();
+          if (options2.quiet < 2) await diagnostic(context, error);
+          exitCode = 1;
+          if (decodedBudget.exceeded) break;
+        }
+      }
+      return { exitCode };
+    });
+    return { ...command2, execute: withInputByteBudget(async (context) => command2.execute(context)) };
+  }));
   const xzCmds = createXzCommands(config);
   if (maxDecodedBytes === void 0 || maxDecodedBytes === Infinity) {
     for (const c of [...commands, ...xzCmds]) builtInDirectContextExecutors.add(c.execute);
@@ -8109,6 +8114,17 @@ export {
   createRgCommand,
   assertCommandRequirements,
   evaluateFilePredicate,
+  abortManagedController,
+  addAbortSignalWaiter,
+  combineManagedSignals,
+  createManagedControlController,
+  creationUmask,
+  getRuntimeBackingFileSystem,
+  interruptible,
+  isManagedAbortSignal,
+  isSyncResolved,
+  registerManagedAbortSignal,
+  removeAbortSignalWaiter,
   wcDisplayWidth,
   bindFileOutputBudget,
   openFileOutput,

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

@@ -1,18 +1,18 @@
+import {
+  createTsortCommands
+} from "./chunk-6PAVEFT3.js";
 import {
   createFactorCommands
 } from "./chunk-AM5ESLPH.js";
 import {
   createHexdumpCommands
 } from "./chunk-CS4MNM6I.js";
-import {
-  createTimeoutCommands
-} from "./chunk-FBUCWVTE.js";
-import {
-  createTsortCommands
-} from "./chunk-6PAVEFT3.js";
 import {
   RegexExecutor
 } from "./chunk-VKNVHEX3.js";
+import {
+  createTimeoutCommands
+} from "./chunk-FBUCWVTE.js";
 import {
   Chi,
   HashMD,
@@ -39,6 +39,9 @@ import {
 import {
   createApplyPatchCommands
 } from "./chunk-XAQMU6OY.js";
+import {
+  createBoundedRegexProvider
+} from "./chunk-FZE4HW6G.js";
 import {
   assertCommandRequirements,
   basicCommands,
@@ -61,7 +64,13 @@ import {
   openFileOutput,
   predicateCommands,
   wcDisplayWidth
-} from "./chunk-44ALJ4QG.js";
+} from "./chunk-PNBBUWSM.js";
+import {
+  createMdqCommand
+} from "./chunk-OV6IHKO6.js";
+import {
+  createPrCommands
+} from "./chunk-CHYGPFVM.js";
 import {
   createGetoptCommands
 } from "./chunk-AUSNDQTJ.js";
@@ -71,9 +80,6 @@ import {
 import {
   createDos2unixCommands2 as createDos2unixCommands
 } from "./chunk-3R3AANOR.js";
-import {
-  createMdqCommand
-} from "./chunk-OV6IHKO6.js";
 import {
   compareCopyIdentity,
   compareObservedEntries,
@@ -88,11 +94,24 @@ import {
   PublicDiagnostic
 } from "./chunk-PH63PLPZ.js";
 import {
-  createPrCommands
-} from "./chunk-CHYGPFVM.js";
+  compareByteArrays,
+  decodeBytes,
+  encodeBytes,
+  indexOfBytes
+} from "./chunk-D3ANYGMC.js";
 import {
-  createBoundedRegexProvider
-} from "./chunk-FZE4HW6G.js";
+  FsError
+} from "./chunk-VTH3MLDU.js";
+import {
+  hasYieldCheckpoint,
+  monotonicNow,
+  yieldTurn
+} from "./chunk-5OHX7C2V.js";
+import {
+  collectBytes,
+  createBufferedOutput,
+  outputFailure
+} from "./chunk-74GHTNJA.js";
 import {
   CommandRegistry
 } from "./chunk-7R5BDCG7.js";
@@ -110,26 +129,7 @@ import {
 } from "./chunk-GEG3BWGE.js";
 import {
   createMetadataCommands
-} from "./chunk-VSAJ4OTM.js";
-import {
-  compareByteArrays,
-  decodeBytes,
-  encodeBytes,
-  indexOfBytes
-} from "./chunk-D3ANYGMC.js";
-import {
-  FsError
-} from "./chunk-VTH3MLDU.js";
-import {
-  hasYieldCheckpoint,
-  monotonicNow,
-  yieldTurn
-} from "./chunk-NZQXYWA3.js";
-import {
-  collectBytes,
-  createBufferedOutput,
-  outputFailure
-} from "./chunk-74GHTNJA.js";
+} from "./chunk-VBTDHOWC.js";
 import {
   createArchiveCommands
 } from "./chunk-QGUV42T5.js";
@@ -4371,6 +4371,17 @@ var SortRecordBudget = class {
 };
 
 // packages/safe-bash/src/commands/text.ts
+function sortCollator(env) {
+  const locale = env.LC_ALL || env.LC_COLLATE || env.LANG || "C";
+  if (["C", "POSIX", "C.UTF-8", "C.utf8"].includes(locale)) return void 0;
+  const language = locale.split(".")[0].split("_").join("-");
+  try {
+    if (!Intl.Collator.supportedLocalesOf([language]).length || locale.includes("@")) throw new RangeError();
+    return new Intl.Collator(language, { usage: "sort", sensitivity: "variant", caseFirst: "lower" });
+  } catch {
+    throw new UsageError(`unsupported collation locale '${locale}'`);
+  }
+}
 var SortWork = class {
   constructor(signal) {
     this.signal = signal;
@@ -5323,7 +5334,7 @@ async function collectSortRecords(source, delimiter, budget, signal, accept) {
     pending.clear();
   }
 }
-async function executeSortGeneral(context, preReadChunks) {
+async function executeSortGeneral(context, preReadChunks, collator = sortCollator(context.env)) {
   let ended = false;
   let hasCheckLong = false;
   for (let i = 0; i < context.args.length; i++) {
@@ -5374,6 +5385,22 @@ async function executeSortGeneral(context, preReadChunks) {
   const simple = !keys.length && !["b", "f", "h", "n", "g", "M", "V", "d", "i"].some((flag) => parsed.flags.has(flag));
   const direction = parsed.flags.has("r") ? -1 : 1;
   const work = new SortWork(context.signal);
+  const decoder2 = collator ? new TextDecoder("utf-8", { fatal: true }) : void 0;
+  const compareText = collator ? async (left, right, work2) => {
+    await work2.charge(left.length + right.length);
+    let first, second;
+    try {
+      first = decoder2.decode(left);
+    } catch {
+    }
+    try {
+      second = decoder2.decode(right);
+    } catch {
+    }
+    if (first === void 0) return second === void 0 ? compareSortBytes(left, right, work2) : 1;
+    if (second === void 0) return -1;
+    return collator.compare(first, second);
+  } : compareSortBytes;
   const numericKey = keys.length === 1 ? keys[0] : void 0;
   const numericKeyFlags = numericKey?.flags.size ? numericKey.flags : parsed.flags;
   const skipTieFallback = simple || parsed.flags.has("s") || parsed.flags.has("u");
@@ -5381,7 +5408,7 @@ async function executeSortGeneral(context, preReadChunks) {
   const exitCode = 0;
   const delimiter = parsed.flags.has("z") ? 0 : 10;
   const outPath = value(parsed, "o");
-  const canFastIndexSort = !preReadChunks && !checking && !hasYieldCheckpoint(context.signal) && !parsed.flags.has("m") && !parsed.flags.has("u") && outPath === void 0 && parsed.operands.length <= 1 && SortRecordBudget.prototype.admit === defaultSortAdmit && Uint8Array === defaultUint8Array && (simple || keys.length === 1 && numericKey !== void 0 && numericKeyFlags.has("n") && !numericKeyFlags.has("h") && !["b", "f", "d", "i", "M", "V", "g"].some((flag) => numericKeyFlags.has(flag)) && !["b", "f", "d", "i", "h", "M", "V", "g"].some((flag) => parsed.flags.has(flag)) && numericKey.startCharacter === 1 && (numericKey.endCharacter === void 0 || numericKey.endCharacter === 0));
+  const canFastIndexSort = collator === void 0 && !preReadChunks && !checking && !hasYieldCheckpoint(context.signal) && !parsed.flags.has("m") && !parsed.flags.has("u") && outPath === void 0 && parsed.operands.length <= 1 && SortRecordBudget.prototype.admit === defaultSortAdmit && Uint8Array === defaultUint8Array && (simple || keys.length === 1 && numericKey !== void 0 && numericKeyFlags.has("n") && !numericKeyFlags.has("h") && !["b", "f", "d", "i", "M", "V", "g"].some((flag) => numericKeyFlags.has(flag)) && !["b", "f", "d", "i", "h", "M", "V", "g"].some((flag) => parsed.flags.has(flag)) && numericKey.startCharacter === 1 && (numericKey.endCharacter === void 0 || numericKey.endCharacter === 0));
   if (canFastIndexSort) {
     let firstChunk;
     try {
@@ -5580,7 +5607,7 @@ async function executeSortGeneral(context, preReadChunks) {
         result = a.rank - b.rank || (a.value < b.value ? -1 : a.value > b.value ? 1 : 0);
       } else if (flags.has("M")) result = await monthValue(first, work) - await monthValue(second, work);
       else if (flags.has("V")) result = await compareVersions(first, second, work);
-      else result = flags.has("n") || flags.has("h") ? await compareNumeric(first, second, flags.has("h")) : await compareSortBytes(first, second, work);
+      else result = flags.has("n") || flags.has("h") ? await compareNumeric(first, second, flags.has("h")) : await compareText(first, second, work);
       if (flags.has("r")) result = -result;
       if (result) return result;
     }
@@ -5588,7 +5615,7 @@ async function executeSortGeneral(context, preReadChunks) {
   };
   const keyCompareSimpleAsync = async (left, right, checkpoint) => {
     await checkpoint;
-    return await compareSortBytes(left, right, work) * direction;
+    return await compareText(left, right, work) * direction;
   };
   const compareUnkeyedNumericAsync = async (left, right, rightPending) => {
     const leftValue = await left;
@@ -5599,7 +5626,7 @@ async function executeSortGeneral(context, preReadChunks) {
     const checkpoint = work.charge();
     if (simple) {
       if (checkpoint) return keyCompareSimpleAsync(left, right, checkpoint);
-      const cmp = compareSortBytes(left, right, work);
+      const cmp = compareText(left, right, work);
       return typeof cmp === "number" ? cmp * direction : resolveScaledAfterPromise(cmp, direction);
     }
     if (isUnkeyedNumericFast && checkpoint === void 0) {
@@ -5637,7 +5664,7 @@ async function executeSortGeneral(context, preReadChunks) {
       if (checkpoint) await checkpoint;
       const first = await (firstPending ?? getKeyedLexSlice(left));
       const second = await (secondPending ?? getKeyedLexSlice(right));
-      return await compareSortBytes(first, second, work) * lexRev;
+      return await compareText(first, second, work) * lexRev;
     };
     keyCompare = (left, right) => {
       const checkpoint = work.charge();
@@ -5648,7 +5675,7 @@ async function executeSortGeneral(context, preReadChunks) {
         if (!(first instanceof Promise)) {
           second = getKeyedLexSlice(right);
           if (!(second instanceof Promise)) {
-            const cmp = compareSortBytes(first, second, work);
+            const cmp = compareText(first, second, work);
             if (typeof cmp === "number") return cmp * lexRev;
             return resolveScaledAfterPromise(cmp, lexRev);
           }
@@ -5801,7 +5828,7 @@ async function executeSortGeneral(context, preReadChunks) {
           if (ls === void 0) return keyCompareGeneralAsync(left, right, void 0);
           const rs = ev.evalLexSync(right);
           if (rs === void 0) return keyCompareGeneralAsync(left, right, void 0);
-          const cmp = compareSortBytes(ls, rs, work);
+          const cmp = compareText(ls, rs, work);
           if (typeof cmp !== "number") return keyCompareGeneralAsync(left, right, void 0);
           if (cmp !== 0) return cmp * ev.revScale;
         }
@@ -5812,13 +5839,13 @@ async function executeSortGeneral(context, preReadChunks) {
   const compareSlowAsync = async (resultPromise, left, right) => {
     const resolved = await resultPromise;
     if (resolved !== 0 || skipTieFallback) return resolved;
-    return await compareSortBytes(left, right, work) * direction;
+    return await compareText(left, right, work) * direction;
   };
   const compare = (left, right) => {
     const result = keyCompare(left, right);
     if (typeof result === "number") {
       if (result !== 0 || skipTieFallback) return result;
-      const fallback = compareSortBytes(left, right, work);
+      const fallback = compareText(left, right, work);
       return typeof fallback === "number" ? fallback * direction : resolveScaledAfterPromise(fallback, direction);
     }
     return compareSlowAsync(result, left, right);
@@ -6391,6 +6418,8 @@ async function executeUniqGeneral(context, preReadSource) {
 function textCommands() {
   return [
     define("sort", (context) => {
+      const collator = sortCollator(context.env);
+      if (collator) return executeSortGeneral(context, void 0, collator);
       if ((context.args.length === 0 || context.args.length === 1 && context.args[0] === "-r") && !hasYieldCheckpoint(context.signal) && SortRecordBudget.prototype.admit === defaultSortAdmit && Uint8Array === defaultUint8Array) {
         const direction = context.args.length === 1 ? -1 : 1;
         const req = assertInputRequirements(context, EMPTY_OPERANDS);

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

@@ -0,0 +1,55 @@
+import {
+  registerDefaultExecutors
+} from "./chunk-E7OYNDGL.js";
+import {
+  init_platform
+} from "./chunk-B7TAL7S5.js";
+
+// packages/safe-bash/src/commands/metadata/index.ts
+init_platform();
+
+// packages/safe-bash/src/commands/metadata/chmod.ts
+init_platform();
+import { createChmodCommand, evalSyncChmod, modeChange } from "../../safe-bash-command-chmod/command.js";
+
+// packages/safe-bash/src/commands/metadata/stat.ts
+init_platform();
+import { createStatCommand, evalSyncStat } from "../../safe-bash-command-stat/command.js";
+
+// packages/safe-bash/src/commands/metadata/mktemp.ts
+init_platform();
+import { createMktempCommand, evalSyncMktemp } from "../../safe-bash-command-mktemp/command.js";
+
+// packages/safe-bash/src/commands/truncate.ts
+init_platform();
+import {} from "../../safe-bash-command-truncate/index.js";
+import { createTruncateCommand, createTruncateCommands, truncateCommand, truncateCommands, evalSyncTruncate } from "../../safe-bash-command-truncate/index.js";
+
+// packages/safe-bash/src/commands/metadata/internal.ts
+init_platform();
+import { MetadataBudget, metadataCommand, permissionString, settings } from "../../safe-bash-metadata-engine/index.js";
+
+// packages/safe-bash/src/commands/metadata/index.ts
+import { evalSyncTruncate as evalSyncTruncate2 } from "../../safe-bash-command-truncate/index.js";
+function createMetadataCommands(options = {}) {
+  settings(options);
+  return registerDefaultExecutors([createChmodCommand(options), createStatCommand(options), createMktempCommand(options), truncateCommand(options)], options);
+}
+function metadataCommands(options = {}) {
+  const commands = createMetadataCommands(options);
+  return { name: "metadata-commands", setup(host) {
+    if (!options.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: options.replace ?? false });
+  } };
+}
+
+export {
+  modeChange,
+  evalSyncStat,
+  evalSyncMktemp,
+  createMetadataCommands,
+  metadataCommands,
+  evalSyncTruncate2 as evalSyncTruncate
+};

package/dist/safe-bash/command-chunks/{chunk-ORYGZYKW.js → chunk-4FEVBOL5.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-VGG2DL5Q.js";
+} from "./chunk-TRR4MYWF.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-VXSLJH7G.js → chunk-6JSIFWYT.js}

@@ -10,7 +10,7 @@ import {
 
 // packages/safe-bash-contracts/src/io.ts
 init_buffer();
-import { collectBytes, readBytes } from "@poe-platform/safe-fs/core";
+import { collectBytes, readBytes, retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
 import { collectBytes as collectBytes2, readBytes as readBytes2, toByteSource } from "@poe-platform/safe-fs/core";
 
 // packages/safe-bash-contracts/src/managed-abort.ts
@@ -305,6 +305,7 @@ Object.assign(PipeWriteEndpointImpl.prototype, {
 });
 var BytePipeImpl = class {
   constructor(options) {
+    this.admitWrite = options.admitWrite;
     const highWaterMark = options.highWaterMark ?? 64 * 1024;
     if (!Number.isSafeInteger(highWaterMark) || highWaterMark < 1) {
       throw new RangeError("highWaterMark must be a positive safe integer");
@@ -636,6 +637,7 @@ var BytePipeImpl = class {
       if (!this.readerReferences) throw brokenPipe();
       if (!(chunk instanceof Uint8Array)) throw new TypeError("Byte sinks require Uint8Array chunks");
       if (!chunk.byteLength) return resolvedVoid;
+      this.admitWrite?.(chunk.byteLength);
       const owned = new Uint8Array(chunk);
       if (!this.writes || this.writes.size === 0) {
         const reading = this.reads && this.reads.size > 0 ? this.reads.values().next().value : void 0;
@@ -858,16 +860,21 @@ var InputByteBudget = class _InputByteBudget {
     return value;
   }
   assertOpen() {
-    if (this.#failure) throw this.#failure;
+    if (this.#failure) throw this.#failure.error;
   }
   charge(bytes) {
     this.assertOpen();
     if (!Number.isSafeInteger(bytes) || bytes < 0) throw new RangeError("Invalid input byte charge");
     if (bytes > this.maximum - this.#used) {
-      this.#failure = new FsError("EFBIG", { message: "command input byte limit exceeded" });
-      throw this.#failure;
+      this.#failure = { error: new FsError("EFBIG", { message: "command input byte limit exceeded" }) };
+      throw this.#failure.error;
+    }
+    try {
+      this.host?.check(this.#used + bytes);
+    } catch (error) {
+      this.#failure = { error };
+      throw error;
     }
-    this.host?.check(this.#used + bytes);
     this.#used += bytes;
   }
   async run(context, execute) {
@@ -875,7 +882,7 @@ var InputByteBudget = class _InputByteBudget {
     const limited = {
       ...context,
       stdin: this.read(context.stdin, context.signal),
-      fs: Object.create(fs, {
+      fs: new Proxy(Object.create(fs, {
         readFile: { configurable: true, value: async (...args) => {
           this.assertOpen();
           const bytes = await fs.readFile(...args);
@@ -902,6 +909,12 @@ var InputByteBudget = class _InputByteBudget {
           this.assertOpen();
           return this.read(fs.readStream(...args), context.signal);
         } } } : {}
+      }), {
+        get(target, key) {
+          if (Object.hasOwn(target, key)) return Reflect.get(target, key, target);
+          const value = Reflect.get(fs, key, fs);
+          return typeof value === "function" ? value.bind(fs) : value;
+        }
       }),
       inputBudget: {
         maxBytes: Math.min(this.maximum, context.inputBudget?.maxBytes ?? Infinity),
@@ -912,6 +925,13 @@ var InputByteBudget = class _InputByteBudget {
         }
       }
     };
+    const retain = (filesystem, callback, options) => {
+      if (filesystem !== limited.fs) throw new TypeError("Invalid input-budget cleanup filesystem");
+      return retainFileSystemCleanup(fs, callback, options);
+    };
+    Object.defineProperty(limited.fs, /* @__PURE__ */ Symbol.for("safe-fs.retainedCleanup"), {
+      value: Object.freeze({ filesystem: limited.fs, retain })
+    });
     try {
       return await execute(limited);
     } finally {