@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/command-chunks/chunk-MQREDAL6.js

@@ -0,0 +1,164 @@
+import {
+  LineEndingError,
+  missing,
+  sameIdentity
+} from "./chunk-TOH3OF3O.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-line-ending-engine/src/stage.ts
+init_buffer();
+import { FsError } from "../../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output-budget.js";
+import { dirname, resolvePath, retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+var Files = class {
+  constructor(life) {
+    this.life = life;
+  }
+  life;
+  async call(select, args) {
+    return await this.life.operation(async () => {
+      const fs = this.life.budget.context.fs;
+      this.life.assertOpen();
+      const method = select(fs);
+      this.life.assertOpen();
+      return await Reflect.apply(method, fs, args);
+    });
+  }
+  async stat(path) {
+    try {
+      return await this.call((fs) => fs.lstat, [path, { signal: this.life.budget.signal }]);
+    } catch (error) {
+      this.life.assertOpen();
+      if (missing(error)) return void 0;
+      throw error;
+    }
+  }
+  path(name) {
+    const path = resolvePath(this.life.budget.context.cwd, name);
+    this.life.budget.check(path.length * 3, this.life.budget.limits.maxPathBytes, "path bytes");
+    this.life.budget.check(path.split("/").length - 1, this.life.budget.limits.maxDepth, "path depth");
+    return path;
+  }
+  async parents(path) {
+    const parents = [];
+    let current = "/";
+    for (const component of ["", ...dirname(path).split("/").filter(Boolean)]) {
+      if (component) current = resolvePath(current, component);
+      const stat = await this.stat(current);
+      if (!stat) throw new FsError("ENOENT", { path: current });
+      if (stat.type !== "directory" || !sameIdentity(stat, stat)) throw new LineEndingError("output requires stable non-symlink directory identities");
+      parents.push({ path: current, stat });
+    }
+    return parents;
+  }
+};
+var Stage = class {
+  constructor(files, path, expected) {
+    this.files = files;
+    this.path = path;
+    this.expected = expected;
+    const { life } = files;
+    life.assertOpen();
+    this.cleanup = retainFileSystemCleanup(life.budget.context.fs, async (view) => {
+      if (!this.created || !this.identity) return;
+      try {
+        for (const parent of this.parents) {
+          const stat2 = await view.lstat(parent.path);
+          if (stat2.type !== "directory" || !sameIdentity(stat2, parent.stat)) return;
+        }
+        const stat = await view.lstat(this.temporary);
+        if (stat.type === "file" && sameIdentity(stat, this.identity)) await view.rm(this.temporary);
+      } catch (error) {
+        if (!missing(error)) throw error;
+      }
+    }, { maxOperations: Math.min(4096, life.budget.limits.maxDepth + 4) });
+    life.cleanup(this.cleanup);
+  }
+  files;
+  path;
+  expected;
+  temporary = "";
+  identity;
+  created = false;
+  parents = [];
+  cleanup;
+  async open() {
+    const { life } = this.files;
+    const { signal, limits } = life.budget;
+    const capabilities = await life.operation(async () => {
+      const fs = life.budget.context.fs;
+      const query = fs.capabilitiesFor;
+      life.assertOpen();
+      const result = query ? await Reflect.apply(query, fs, [this.path, { signal, create: true }]) : fs.capabilities;
+      life.assertOpen();
+      return result;
+    });
+    if (capabilities.atomicRename !== true || capabilities.exclusiveCreate !== true || capabilities.permissions !== true || capabilities.append === false || capabilities.remove === false) {
+      throw new LineEndingError("file conversion requires atomic rename, exclusive create, permissions, append and cleanup capabilities");
+    }
+    if (this.expected === void 0 && capabilities.atomicRenameNoReplace !== true) {
+      throw new LineEndingError("new destination requires atomic no-replace rename capability");
+    }
+    this.parents = await this.files.parents(this.path);
+    for (let attempt = 0; attempt < limits.maxTempAttempts; attempt++) {
+      this.temporary = resolvePath(dirname(this.path), `.line-ending-${attempt + 1}`);
+      this.files.path(this.temporary);
+      if (this.temporary === this.path || await this.files.stat(this.temporary)) continue;
+      try {
+        await this.files.call((fs) => fs.writeFile, [this.temporary, new Uint8Array(), { signal, flag: "wx", mode: 384 }]);
+      } catch (error) {
+        life.assertOpen();
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST") continue;
+        throw error;
+      }
+      this.created = true;
+      this.identity = await this.files.stat(this.temporary);
+      if (!this.identity || this.identity.type !== "file" || !sameIdentity(this.identity, this.identity)) throw new LineEndingError("temporary file identity unavailable; unowned path is not removed");
+      return;
+    }
+    throw new LineEndingError("temporary file attempts limit exceeded");
+  }
+  async checked() {
+    for (const parent of this.parents) {
+      const stat2 = await this.files.stat(parent.path);
+      if (!stat2 || stat2.type !== "directory" || !sameIdentity(stat2, parent.stat)) throw new LineEndingError("output parent changed before mutation");
+    }
+    const stat = await this.files.stat(this.temporary);
+    if (!this.identity || !stat || stat.type !== "file" || !sameIdentity(stat, this.identity)) throw new LineEndingError("temporary file changed before mutation");
+  }
+  async append(bytes) {
+    await this.checked();
+    const { context, signal } = this.files.life.budget;
+    await this.files.life.operation(() => writeFileOutput(
+      { signal, ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {} },
+      bytes,
+      async (chunk) => {
+        await this.files.call((fs) => fs.appendFile, [this.temporary, chunk, { signal }]);
+      }
+    ));
+  }
+  async publish(input, options) {
+    const { signal } = this.files.life.budget;
+    await this.checked();
+    if (!options.newFile && !options.allowChown && (input.uid !== void 0 && input.uid !== this.identity.uid || input.gid !== void 0 && input.gid !== this.identity.gid)) {
+      throw new LineEndingError("filesystem cannot preserve input user/group ownership");
+    }
+    await this.files.call((fs) => fs.chmod, [this.temporary, input.mode & 511 & (options.newFile ? ~18 : 511), { signal }]);
+    if (options.keepDate) {
+      await this.checked();
+      await this.files.call((fs) => fs.utimes, [this.temporary, Math.floor(input.atimeMs / 1e3) * 1e3, Math.floor(input.mtimeMs / 1e3) * 1e3, { signal }]);
+    }
+    await this.checked();
+    const current = await this.files.stat(this.path);
+    if (current ? !this.expected || current.type !== "file" || !sameIdentity(current, this.expected) : this.expected !== void 0) throw new LineEndingError("destination changed before publication");
+    await this.files.call((fs) => fs.rename, [this.temporary, this.path, { signal, noReplace: this.expected === void 0 }]);
+    this.created = false;
+  }
+};
+
+export {
+  Files,
+  Stage
+};

package/dist/safe-bash/command-chunks/{chunk-LWS62ISU.js → chunk-N6DIASO2.js}

@@ -1,6 +1,6 @@
 import {
   entities
-} from "./chunk-OQU6UT6X.js";
+} from "./chunk-OV3XREFN.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-NGL7YK7O.js

@@ -0,0 +1,188 @@
+import {
+  encodingLabels,
+  readEncoding
+} from "./chunk-TFR6B3WB.js";
+import {
+  LineEndingError
+} from "./chunk-TOH3OF3O.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-line-ending-engine/src/convert.ts
+init_buffer();
+async function convert(direction, reader, writer, life, options, name, stdio) {
+  let high = 1;
+  if (stdio) reader.beforeRead = () => writer.flush();
+  const diagnostic = async (message) => {
+    if (stdio) await writer.flush();
+    await life.diagnostic(`${direction}: ${message}
+`);
+  };
+  const input = await readEncoding(reader);
+  if (input.error) {
+    if (!options.quiet) await diagnostic("can not read from input file: Success");
+    return { kind: "bom-error", encoding: "" };
+  }
+  const bom = input.bom === "bytes" ? options.assume : input.bom;
+  if (options.verbose) {
+    if (options.assume !== "bytes") await diagnostic(`Assuming UTF-16${options.assume === "le" ? "LE" : "BE"} encoding.`);
+    if (input.bom !== "bytes") await diagnostic(`Input file ${name} has ${encodingLabels[input.bom]} BOM.`);
+  }
+  const wide = bom === "le" || bom === "be";
+  const encoding = wide ? bom === "le" ? "UTF-16LE" : "UTF-16BE" : "";
+  const env = life.budget.context.env;
+  const locale = env.LC_ALL || env.LC_CTYPE || env.LANG || "C";
+  const utf8 = locale === "C.UTF-8" || locale === "C.utf8";
+  if (wide && !options.keepUtf16 && !utf8 && locale !== "C" && locale !== "POSIX") throw new LineEndingError("UTF-16 conversion supports only C/POSIX and C.UTF-8 locales");
+  if (options.addBom || options.keepBom && bom !== "bytes") {
+    const bytes = options.keepUtf16 && wide ? bom === "le" ? [255, 254] : [254, 255] : bom === "gb" ? [132, 49, 149, 51] : [239, 187, 191];
+    for (const byte2 of bytes) await writer.put(byte2);
+    if (options.verbose) await diagnostic(`Writing ${options.keepUtf16 && wide ? encodingLabels[bom] : bom === "gb" ? "GB18030" : "UTF-8"} BOM.`);
+  }
+  const byte = input.byte;
+  let pushed = -1;
+  const unit = () => {
+    if (pushed !== -1) {
+      const value = pushed;
+      pushed = -1;
+      return value;
+    }
+    const lead = byte();
+    if (typeof lead === "number") {
+      if (lead === -1 || !wide) return lead;
+      const trail = byte();
+      if (typeof trail === "number") return trail === -1 ? -1 : bom === "le" ? lead + trail * 256 : lead * 256 + trail;
+      return trail.then((t) => t === -1 ? -1 : bom === "le" ? lead + t * 256 : lead * 256 + t);
+    }
+    return lead.then(async (l) => {
+      if (l === -1 || !wide) return l;
+      const trail = await byte();
+      return trail === -1 ? -1 : bom === "le" ? l + trail * 256 : l * 256 + trail;
+    });
+  };
+  let line = 1;
+  const result = { kind: "ok" };
+  const put = (value) => {
+    if (!wide) {
+      const p = writer.put(options.sevenBit && bom === "bytes" && value >= 128 ? 32 : value);
+      return p ? p.then(() => true) : true;
+    }
+    return putWide(value);
+  };
+  const putWide = async (value) => {
+    if (options.keepUtf16) {
+      await writer.put(bom === "le" ? value & 255 : value >> 8);
+      await writer.put(bom === "le" ? value >> 8 : value & 255);
+      return true;
+    }
+    if (high >= 55296 && high < 56320 && (value < 56320 || value >= 57344)) {
+      await diagnostic("error: Invalid surrogate pair. Missing low surrogate.");
+      result.kind = "unicode";
+      return false;
+    }
+    if (value >= 55296 && value < 56320) {
+      high = value;
+      return true;
+    }
+    if (value >= 56320 && value < 57344) {
+      if (!(high >= 55296 && high < 56320)) {
+        await diagnostic("error: Invalid surrogate pair. Missing high surrogate.");
+        result.kind = "unicode";
+        return false;
+      }
+      value = 65536 + (high & 1023) * 1024 + (value & 1023);
+      high = 1;
+    }
+    if (!utf8 && value > 127) {
+      if (!options.quiet) await diagnostic("Invalid or incomplete multibyte or wide character");
+      result.kind = "unicode";
+      return false;
+    }
+    if (value < 128) await writer.put(value);
+    else if (value < 2048) {
+      await writer.put(192 | value >> 6);
+      await writer.put(128 | value & 63);
+    } else if (value < 65536) {
+      await writer.put(224 | value >> 12);
+      await writer.put(128 | value >> 6 & 63);
+      await writer.put(128 | value & 63);
+    } else {
+      await writer.put(240 | value >> 18);
+      await writer.put(128 | value >> 12 & 63);
+      await writer.put(128 | value >> 6 & 63);
+      await writer.put(128 | value & 63);
+    }
+    return true;
+  };
+  let previous = 0;
+  let last = -1, converted = 0;
+  for (; ; ) {
+    const u = unit();
+    const current = typeof u === "number" ? u : await u;
+    if (current === -1) break;
+    last = current;
+    if (!options.force && current < 32 && current !== 9 && current !== 10 && current !== 12 && current !== 13) {
+      result.kind = "binary";
+      if (!options.quiet) await diagnostic(`Binary symbol 0x${current.toString(16).toUpperCase().padStart(wide ? 4 : 2, "0")} found at line ${line}`);
+      break;
+    }
+    if (direction === "dos2unix") {
+      if (current === 13) {
+        const u2 = unit();
+        pushed = typeof u2 === "number" ? u2 : await u2;
+        if (pushed !== 10) {
+          const ok = put(13);
+          if (!(typeof ok === "boolean" ? ok : await ok)) break;
+        } else {
+          converted++;
+          last = 10;
+          if (options.newline) {
+            const ok = put(10);
+            if (!(typeof ok === "boolean" ? ok : await ok)) break;
+          }
+        }
+      } else {
+        const ok = put(current);
+        if (!(typeof ok === "boolean" ? ok : await ok)) break;
+        if (current === 10) line++;
+      }
+    } else {
+      if (current === 10 && previous !== 13) {
+        converted++;
+        const ok2 = put(13);
+        if (!(typeof ok2 === "boolean" ? ok2 : await ok2)) break;
+      }
+      const ok = put(current);
+      if (!(typeof ok === "boolean" ? ok : await ok)) break;
+      if (current === 10) line++;
+      if (options.newline && current === 10) {
+        const ok1 = put(13);
+        if (!(typeof ok1 === "boolean" ? ok1 : await ok1)) break;
+        const ok2 = put(10);
+        if (!(typeof ok2 === "boolean" ? ok2 : await ok2)) break;
+      }
+      previous = current;
+    }
+  }
+  if (result.kind === "ok" && high >= 55296 && high < 56320) {
+    await diagnostic("error: Invalid surrogate pair. Missing low surrogate.");
+    result.kind = "unicode";
+  }
+  if (result.kind === "ok" && options.addEol && last !== -1 && last !== 10) {
+    if (options.verbose) await diagnostic("Added line break to last line.");
+    if (direction === "unix2dos") await put(13);
+    await put(10);
+  }
+  if (result.kind === "ok" && options.verbose) await diagnostic(`Converted ${converted} out of ${line - 1} line breaks.`);
+  if (stdio || result.kind === "ok") await writer.flush();
+  if (!options.quiet) {
+    if (result.kind === "binary") await diagnostic(`Skipping binary file ${name}`);
+    if (result.kind === "unicode") await diagnostic(`Skipping UTF-16 file ${name}, an UTF-16 conversion error occurred on line ${line}.`);
+  }
+  return { kind: result.kind, encoding };
+}
+
+export {
+  convert
+};

package/dist/safe-bash/command-chunks/{chunk-PEF7K3UQ.js → chunk-NJYHWKIL.js}

@@ -1,6 +1,6 @@
 import {
   SearchError
-} from "./chunk-VGG2DL5Q.js";
+} from "./chunk-TRR4MYWF.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -129,6 +129,7 @@ function escapeEreLiteral(ch) {
 }
 function parsePattern(pattern, bre, insensitive, multiline, dotall, nullData, captures = false, captureOffset = 0) {
   let pos = 0;
+  let anchorMultiline = multiline;
   let needsVm = false;
   let hasCrossLinePotential = dotall;
   let hasUppercaseLiteral = false;
@@ -288,17 +289,20 @@ function parsePattern(pattern, bre, insensitive, multiline, dotall, nullData, ca
       const ch = pattern[pos];
       if (ch === "^") {
         pos++;
-        atomNode = { type: "assert", kind: "bol" };
+        atomNode = { type: "assert", kind: "bol", multiline: anchorMultiline };
+        if (multiline && !anchorMultiline) hasCrossLinePotential = true;
         atomEre = "^";
         quantifiable = false;
       } else if (ch === "$") {
         pos++;
-        atomNode = { type: "assert", kind: "eol" };
+        atomNode = { type: "assert", kind: "eol", multiline: anchorMultiline };
+        if (multiline && !anchorMultiline) hasCrossLinePotential = true;
         atomEre = "$";
         quantifiable = false;
       } else if (ch === ".") {
         pos++;
         atomNode = { type: "dot", dotall, nullData };
+        if (dotall) hasCrossLinePotential = true;
         atomEre = ".";
       } else if (ch === "[") {
         pos++;
@@ -307,11 +311,36 @@ function parsePattern(pattern, bre, insensitive, multiline, dotall, nullData, ca
         atomEre = br.ere;
       } else if (!bre && ch === "(") {
         pos++;
+        const enclosing = { insensitive, anchorMultiline, dotall };
         let capturing = true;
         let name;
         if (pattern[pos] === "?") {
           pos++;
-          if (pattern[pos] === ":") {
+          if ("ims-".includes(pattern[pos] ?? " ")) {
+            needsVm = true;
+            capturing = false;
+            let enabled = true;
+            let count = 0;
+            while (pos < pattern.length && pattern[pos] !== ":" && pattern[pos] !== ")") {
+              const flag = pattern[pos++];
+              if (flag === "-" && enabled) {
+                enabled = false;
+                count = 0;
+                continue;
+              }
+              if (flag === "i") insensitive = enabled;
+              else if (flag === "m") anchorMultiline = enabled;
+              else if (flag === "s") dotall = enabled;
+              else throw new SearchError("unsupported inline regular expression flag");
+              count++;
+            }
+            if (!count) throw new SearchError("empty inline regular expression flags");
+            if (pattern[pos] === ")") {
+              pos++;
+              continue;
+            }
+            if (pattern[pos++] !== ":") throw new SearchError("unterminated inline regular expression flags");
+          } else if (pattern[pos] === ":") {
             pos++;
             capturing = false;
           } else if (pattern[pos] === "=" || pattern[pos] === "!" || pattern[pos] === "<" && (pattern[pos + 1] === "=" || pattern[pos + 1] === "!")) {
@@ -331,6 +360,7 @@ function parsePattern(pattern, bre, insensitive, multiline, dotall, nullData, ca
         const index = capturing ? ++captureCount : 0;
         if (name !== void 0) captureNames.set(name, index);
         const inner = parseAlternation(true);
+        ({ insensitive, anchorMultiline, dotall } = enclosing);
         if (pos >= pattern.length || pattern[pos] !== ")") {
           throw new SearchError("invalid ERE: unclosed '('");
         }
@@ -547,7 +577,7 @@ function compileAstToNfa(root) {
       case "class":
         return emit({ op: "class", node, out: next });
       case "assert":
-        return emit({ op: "assert", kind: node.kind, out: next });
+        return emit({ op: "assert", kind: node.kind, multiline: node.multiline, out: next });
       case "capture": {
         const end = emit({ op: "save", slot: node.index * 2 + 1, out: next });
         return emit({ op: "save", slot: node.index * 2, out: build(node.child, end) });
@@ -609,7 +639,7 @@ function compileAstToNfa(root) {
           reordered.push({ op: "save", slot: inst.slot, out: inst.out + 1 });
           break;
         case "assert":
-          reordered.push({ op: "assert", kind: inst.kind, out: inst.out + 1 });
+          reordered.push({ op: "assert", kind: inst.kind, multiline: inst.multiline, out: inst.out + 1 });
           break;
         case "literal":
           reordered.push({ op: "literal", cp: inst.cp, insensitive: inst.insensitive, out: inst.out + 1 });
@@ -699,12 +729,12 @@ var ErgonomicVmMatcher = class {
   nlistPositions;
   leadingLiteral;
   stepStamp = 1;
-  evalAssertion(kind, cps, len, pos) {
+  evalAssertion(kind, cps, len, pos, multiline = this.multiline) {
     switch (kind) {
       case "bol":
-        return pos === 0 || this.multiline && cps[pos - 1] === 10;
+        return pos === 0 || multiline && cps[pos - 1] === 10;
       case "eol":
-        return pos === len || this.multiline && cps[pos] === 10;
+        return pos === len || multiline && cps[pos] === 10;
       case "wb": {
         const prevW = pos > 0 && isAsciiWordCp(cps[pos - 1]);
         const nextW = pos < len && isAsciiWordCp(cps[pos]);
@@ -762,7 +792,7 @@ var ErgonomicVmMatcher = class {
         return addThread(inst.out, startPos, pos, stamp, saved);
       }
       if (inst.op === "assert") {
-        if (this.evalAssertion(inst.kind, cps, length, pos)) {
+        if (this.evalAssertion(inst.kind, cps, length, pos, inst.multiline)) {
           return addThread(inst.out, startPos, pos, stamp, slots);
         }
         return false;

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

@@ -3,14 +3,14 @@ import {
 } from "./chunk-X475DYQM.js";
 import {
   yieldTurn
-} from "./chunk-Y2WBSJG6.js";
+} from "./chunk-X4QZQI5Q.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
 
 // 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 {

package/dist/safe-bash/command-chunks/{chunk-OQU6UT6X.js → chunk-OV3XREFN.js}

@@ -41,8 +41,13 @@ var named = Object.freeze({
 });
 async function entities(text, budget) {
   if (text.length < 4096 && !text.includes("&")) {
+    budget.work(text.length);
     const result2 = new Builder(budget);
     result2.append(text);
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
     return result2.finish();
   }
   const result = new Builder(budget);
@@ -50,10 +55,16 @@ async function entities(text, budget) {
     if (text.length < 4096) {
       const nextAmp = text.indexOf("&", offset);
       if (nextAmp < 0) {
+        budget.work(text.length - offset);
         result.append(text.slice(offset));
+        {
+          const c = budget.checkpoint();
+          if (c) await c;
+        }
         break;
       }
       if (nextAmp > offset) {
+        budget.work(nextAmp - offset);
         result.append(text.slice(offset, nextAmp));
         offset = nextAmp;
         {

package/dist/safe-bash/command-chunks/{chunk-MIXBO6U7.js → chunk-PTZLF456.js}

@@ -1,9 +1,9 @@
 import {
   parse
-} from "./chunk-BDSMROQZ.js";
+} from "./chunk-36GFRF2N.js";
 import {
   contents
-} from "./chunk-ALDC4XP4.js";
+} from "./chunk-QILLRNES.js";
 import {
   FileFailure,
   PatchError,