poe-code 14.0.24 → 14.0.26

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

@@ -41,7 +41,7 @@ var require_base64_js = __commonJS({
   "node_modules/base64-js/index.js"(exports) {
     "use strict";
     init_platform();
-    exports.byteLength = byteLength;
+    exports.byteLength = byteLength2;
     exports.toByteArray = toByteArray;
     exports.fromByteArray = fromByteArray;
     var lookup = [];
@@ -66,7 +66,7 @@ var require_base64_js = __commonJS({
       var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
       return [validLen, placeHoldersLen];
     }
-    function byteLength(b64) {
+    function byteLength2(b64) {
       var lens = getLens(b64);
       var validLen = lens[0];
       var placeHoldersLen = lens[1];
@@ -366,7 +366,7 @@ var require_buffer = __commonJS({
       if (!Buffer3.isEncoding(encoding)) {
         throw new TypeError("Unknown encoding: " + encoding);
       }
-      const length = byteLength(string, encoding) | 0;
+      const length = byteLength2(string, encoding) | 0;
       let buf = createBuffer(length);
       const actual = buf.write(string, encoding);
       if (actual !== length) {
@@ -374,11 +374,11 @@ var require_buffer = __commonJS({
       }
       return buf;
     }
-    function fromArrayLike(array) {
-      const length = array.length < 0 ? 0 : checked(array.length) | 0;
+    function fromArrayLike(array2) {
+      const length = array2.length < 0 ? 0 : checked(array2.length) | 0;
       const buf = createBuffer(length);
       for (let i = 0; i < length; i += 1) {
-        buf[i] = array[i] & 255;
+        buf[i] = array2[i] & 255;
       }
       return buf;
     }
@@ -389,20 +389,20 @@ var require_buffer = __commonJS({
       }
       return fromArrayLike(arrayView);
     }
-    function fromArrayBuffer(array, byteOffset, length) {
-      if (byteOffset < 0 || array.byteLength < byteOffset) {
+    function fromArrayBuffer(array2, byteOffset2, length) {
+      if (byteOffset2 < 0 || array2.byteLength < byteOffset2) {
         throw new RangeError('"offset" is outside of buffer bounds');
       }
-      if (array.byteLength < byteOffset + (length || 0)) {
+      if (array2.byteLength < byteOffset2 + (length || 0)) {
         throw new RangeError('"length" is outside of buffer bounds');
       }
       let buf;
-      if (byteOffset === void 0 && length === void 0) {
-        buf = new Uint8Array(array);
+      if (byteOffset2 === void 0 && length === void 0) {
+        buf = new Uint8Array(array2);
       } else if (length === void 0) {
-        buf = new Uint8Array(array, byteOffset);
+        buf = new Uint8Array(array2, byteOffset2);
       } else {
-        buf = new Uint8Array(array, byteOffset, length);
+        buf = new Uint8Array(array2, byteOffset2, length);
       }
       Object.setPrototypeOf(buf, Buffer3.prototype);
       return buf;
@@ -520,7 +520,7 @@ var require_buffer = __commonJS({
       }
       return buffer;
     };
-    function byteLength(string, encoding) {
+    function byteLength2(string, encoding) {
       if (Buffer3.isBuffer(string)) {
         return string.length;
       }
@@ -563,7 +563,7 @@ var require_buffer = __commonJS({
         }
       }
     }
-    Buffer3.byteLength = byteLength;
+    Buffer3.byteLength = byteLength2;
     function slowToString(encoding, start, end) {
       let loweredCase = false;
       if (start === void 0 || start < 0) {
@@ -726,26 +726,26 @@ var require_buffer = __commonJS({
       if (y < x) return 1;
       return 0;
     };
-    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+    function bidirectionalIndexOf(buffer, val, byteOffset2, encoding, dir) {
       if (buffer.length === 0) return -1;
-      if (typeof byteOffset === "string") {
-        encoding = byteOffset;
-        byteOffset = 0;
-      } else if (byteOffset > 2147483647) {
-        byteOffset = 2147483647;
-      } else if (byteOffset < -2147483648) {
-        byteOffset = -2147483648;
-      }
-      byteOffset = +byteOffset;
-      if (numberIsNaN(byteOffset)) {
-        byteOffset = dir ? 0 : buffer.length - 1;
-      }
-      if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
-      if (byteOffset >= buffer.length) {
+      if (typeof byteOffset2 === "string") {
+        encoding = byteOffset2;
+        byteOffset2 = 0;
+      } else if (byteOffset2 > 2147483647) {
+        byteOffset2 = 2147483647;
+      } else if (byteOffset2 < -2147483648) {
+        byteOffset2 = -2147483648;
+      }
+      byteOffset2 = +byteOffset2;
+      if (numberIsNaN(byteOffset2)) {
+        byteOffset2 = dir ? 0 : buffer.length - 1;
+      }
+      if (byteOffset2 < 0) byteOffset2 = buffer.length + byteOffset2;
+      if (byteOffset2 >= buffer.length) {
         if (dir) return -1;
-        else byteOffset = buffer.length - 1;
-      } else if (byteOffset < 0) {
-        if (dir) byteOffset = 0;
+        else byteOffset2 = buffer.length - 1;
+      } else if (byteOffset2 < 0) {
+        if (dir) byteOffset2 = 0;
         else return -1;
       }
       if (typeof val === "string") {
@@ -755,21 +755,21 @@ var require_buffer = __commonJS({
         if (val.length === 0) {
           return -1;
         }
-        return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+        return arrayIndexOf(buffer, val, byteOffset2, encoding, dir);
       } else if (typeof val === "number") {
         val = val & 255;
         if (typeof Uint8Array.prototype.indexOf === "function") {
           if (dir) {
-            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset2);
           } else {
-            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset2);
           }
         }
-        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+        return arrayIndexOf(buffer, [val], byteOffset2, encoding, dir);
       }
       throw new TypeError("val must be string, number or Buffer");
     }
-    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+    function arrayIndexOf(arr, val, byteOffset2, encoding, dir) {
       let indexSize = 1;
       let arrLength = arr.length;
       let valLength = val.length;
@@ -782,7 +782,7 @@ var require_buffer = __commonJS({
           indexSize = 2;
           arrLength /= 2;
           valLength /= 2;
-          byteOffset /= 2;
+          byteOffset2 /= 2;
         }
       }
       function read(buf, i2) {
@@ -795,7 +795,7 @@ var require_buffer = __commonJS({
       let i;
       if (dir) {
         let foundIndex = -1;
-        for (i = byteOffset; i < arrLength; i++) {
+        for (i = byteOffset2; i < arrLength; i++) {
           if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
             if (foundIndex === -1) foundIndex = i;
             if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
@@ -805,8 +805,8 @@ var require_buffer = __commonJS({
           }
         }
       } else {
-        if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
-        for (i = byteOffset; i >= 0; i--) {
+        if (byteOffset2 + valLength > arrLength) byteOffset2 = arrLength - valLength;
+        for (i = byteOffset2; i >= 0; i--) {
           let found = true;
           for (let j = 0; j < valLength; j++) {
             if (read(arr, i + j) !== read(val, j)) {
@@ -819,14 +819,14 @@ var require_buffer = __commonJS({
       }
       return -1;
     }
-    Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
-      return this.indexOf(val, byteOffset, encoding) !== -1;
+    Buffer3.prototype.includes = function includes(val, byteOffset2, encoding) {
+      return this.indexOf(val, byteOffset2, encoding) !== -1;
     };
-    Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
-      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    Buffer3.prototype.indexOf = function indexOf(val, byteOffset2, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset2, encoding, true);
     };
-    Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
-      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+    Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset2, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset2, encoding, false);
     };
     function hexWrite(buf, string, offset, length) {
       offset = Number(offset) || 0;
@@ -1066,28 +1066,28 @@ var require_buffer = __commonJS({
       if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
       if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
     }
-    Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+    Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength3, noAssert) {
       offset = offset >>> 0;
-      byteLength2 = byteLength2 >>> 0;
-      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      byteLength3 = byteLength3 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength3, this.length);
       let val = this[offset];
       let mul = 1;
       let i = 0;
-      while (++i < byteLength2 && (mul *= 256)) {
+      while (++i < byteLength3 && (mul *= 256)) {
         val += this[offset + i] * mul;
       }
       return val;
     };
-    Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+    Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength3, noAssert) {
       offset = offset >>> 0;
-      byteLength2 = byteLength2 >>> 0;
+      byteLength3 = byteLength3 >>> 0;
       if (!noAssert) {
-        checkOffset(offset, byteLength2, this.length);
+        checkOffset(offset, byteLength3, this.length);
       }
-      let val = this[offset + --byteLength2];
+      let val = this[offset + --byteLength3];
       let mul = 1;
-      while (byteLength2 > 0 && (mul *= 256)) {
-        val += this[offset + --byteLength2] * mul;
+      while (byteLength3 > 0 && (mul *= 256)) {
+        val += this[offset + --byteLength3] * mul;
       }
       return val;
     };
@@ -1140,32 +1140,32 @@ var require_buffer = __commonJS({
       const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
       return (BigInt(hi) << BigInt(32)) + BigInt(lo);
     });
-    Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+    Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength3, noAssert) {
       offset = offset >>> 0;
-      byteLength2 = byteLength2 >>> 0;
-      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      byteLength3 = byteLength3 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength3, this.length);
       let val = this[offset];
       let mul = 1;
       let i = 0;
-      while (++i < byteLength2 && (mul *= 256)) {
+      while (++i < byteLength3 && (mul *= 256)) {
         val += this[offset + i] * mul;
       }
       mul *= 128;
-      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+      if (val >= mul) val -= Math.pow(2, 8 * byteLength3);
       return val;
     };
-    Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+    Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength3, noAssert) {
       offset = offset >>> 0;
-      byteLength2 = byteLength2 >>> 0;
-      if (!noAssert) checkOffset(offset, byteLength2, this.length);
-      let i = byteLength2;
+      byteLength3 = byteLength3 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength3, this.length);
+      let i = byteLength3;
       let mul = 1;
       let val = this[offset + --i];
       while (i > 0 && (mul *= 256)) {
         val += this[offset + --i] * mul;
       }
       mul *= 128;
-      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
+      if (val >= mul) val -= Math.pow(2, 8 * byteLength3);
       return val;
     };
     Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
@@ -1244,37 +1244,37 @@ var require_buffer = __commonJS({
       if (value2 > max || value2 < min) throw new RangeError('"value" argument is out of bounds');
       if (offset + ext > buf.length) throw new RangeError("Index out of range");
     }
-    Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value2, offset, byteLength2, noAssert) {
+    Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value2, offset, byteLength3, noAssert) {
       value2 = +value2;
       offset = offset >>> 0;
-      byteLength2 = byteLength2 >>> 0;
+      byteLength3 = byteLength3 >>> 0;
       if (!noAssert) {
-        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
-        checkInt(this, value2, offset, byteLength2, maxBytes, 0);
+        const maxBytes = Math.pow(2, 8 * byteLength3) - 1;
+        checkInt(this, value2, offset, byteLength3, maxBytes, 0);
       }
       let mul = 1;
       let i = 0;
       this[offset] = value2 & 255;
-      while (++i < byteLength2 && (mul *= 256)) {
+      while (++i < byteLength3 && (mul *= 256)) {
         this[offset + i] = value2 / mul & 255;
       }
-      return offset + byteLength2;
+      return offset + byteLength3;
     };
-    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value2, offset, byteLength2, noAssert) {
+    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value2, offset, byteLength3, noAssert) {
       value2 = +value2;
       offset = offset >>> 0;
-      byteLength2 = byteLength2 >>> 0;
+      byteLength3 = byteLength3 >>> 0;
       if (!noAssert) {
-        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
-        checkInt(this, value2, offset, byteLength2, maxBytes, 0);
+        const maxBytes = Math.pow(2, 8 * byteLength3) - 1;
+        checkInt(this, value2, offset, byteLength3, maxBytes, 0);
       }
-      let i = byteLength2 - 1;
+      let i = byteLength3 - 1;
       let mul = 1;
       this[offset + i] = value2 & 255;
       while (--i >= 0 && (mul *= 256)) {
         this[offset + i] = value2 / mul & 255;
       }
-      return offset + byteLength2;
+      return offset + byteLength3;
     };
     Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value2, offset, noAssert) {
       value2 = +value2;
@@ -1365,33 +1365,33 @@ var require_buffer = __commonJS({
     Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value2, offset = 0) {
       return wrtBigUInt64BE(this, value2, offset, BigInt(0), BigInt("0xffffffffffffffff"));
     });
-    Buffer3.prototype.writeIntLE = function writeIntLE(value2, offset, byteLength2, noAssert) {
+    Buffer3.prototype.writeIntLE = function writeIntLE(value2, offset, byteLength3, noAssert) {
       value2 = +value2;
       offset = offset >>> 0;
       if (!noAssert) {
-        const limit = Math.pow(2, 8 * byteLength2 - 1);
-        checkInt(this, value2, offset, byteLength2, limit - 1, -limit);
+        const limit = Math.pow(2, 8 * byteLength3 - 1);
+        checkInt(this, value2, offset, byteLength3, limit - 1, -limit);
       }
       let i = 0;
       let mul = 1;
       let sub = 0;
       this[offset] = value2 & 255;
-      while (++i < byteLength2 && (mul *= 256)) {
+      while (++i < byteLength3 && (mul *= 256)) {
         if (value2 < 0 && sub === 0 && this[offset + i - 1] !== 0) {
           sub = 1;
         }
         this[offset + i] = (value2 / mul >> 0) - sub & 255;
       }
-      return offset + byteLength2;
+      return offset + byteLength3;
     };
-    Buffer3.prototype.writeIntBE = function writeIntBE(value2, offset, byteLength2, noAssert) {
+    Buffer3.prototype.writeIntBE = function writeIntBE(value2, offset, byteLength3, noAssert) {
       value2 = +value2;
       offset = offset >>> 0;
       if (!noAssert) {
-        const limit = Math.pow(2, 8 * byteLength2 - 1);
-        checkInt(this, value2, offset, byteLength2, limit - 1, -limit);
+        const limit = Math.pow(2, 8 * byteLength3 - 1);
+        checkInt(this, value2, offset, byteLength3, limit - 1, -limit);
       }
-      let i = byteLength2 - 1;
+      let i = byteLength3 - 1;
       let mul = 1;
       let sub = 0;
       this[offset + i] = value2 & 255;
@@ -1401,7 +1401,7 @@ var require_buffer = __commonJS({
         }
         this[offset + i] = (value2 / mul >> 0) - sub & 255;
       }
-      return offset + byteLength2;
+      return offset + byteLength3;
     };
     Buffer3.prototype.writeInt8 = function writeInt8(value2, offset, noAssert) {
       value2 = +value2;
@@ -1646,28 +1646,28 @@ var require_buffer = __commonJS({
       }
       return `${val.slice(0, i)}${res}`;
     }
-    function checkBounds(buf, offset, byteLength2) {
+    function checkBounds(buf, offset, byteLength3) {
       validateNumber(offset, "offset");
-      if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
-        boundsError(offset, buf.length - (byteLength2 + 1));
+      if (buf[offset] === void 0 || buf[offset + byteLength3] === void 0) {
+        boundsError(offset, buf.length - (byteLength3 + 1));
       }
     }
-    function checkIntBI(value2, min, max, buf, offset, byteLength2) {
+    function checkIntBI(value2, min, max, buf, offset, byteLength3) {
       if (value2 > max || value2 < min) {
         const n = typeof min === "bigint" ? "n" : "";
         let range;
-        if (byteLength2 > 3) {
+        if (byteLength3 > 3) {
           if (min === 0 || min === BigInt(0)) {
-            range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+            range = `>= 0${n} and < 2${n} ** ${(byteLength3 + 1) * 8}${n}`;
           } else {
-            range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+            range = `>= -(2${n} ** ${(byteLength3 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength3 + 1) * 8 - 1}${n}`;
           }
         } else {
           range = `>= ${min}${n} and <= ${max}${n}`;
         }
         throw new errors.ERR_OUT_OF_RANGE("value", range, value2);
       }
-      checkBounds(buf, offset, byteLength2);
+      checkBounds(buf, offset, byteLength3);
     }
     function validateNumber(value2, name2) {
       if (typeof value2 !== "number") {
@@ -2179,18 +2179,18 @@ var CommandRegistry = class {
   constructor(commands = []) {
     for (const command2 of commands) this.register(command2);
   }
-  register(command2, options2 = {}) {
-    const { name: name2, execute: execute2 } = command2;
+  register(command2, options3 = {}) {
+    const { name: name2, execute: execute3 } = command2;
     if (typeof name2 !== "string" || !name2 || /[\s/\0]/u.test(name2)) {
       throw new TypeError("Command names must be nonempty and contain no whitespace, slash, or NUL");
     }
-    if (typeof execute2 !== "function") {
+    if (typeof execute3 !== "function") {
       throw new TypeError("Command execute must be a function");
     }
-    if (this.#commands.has(name2) && !options2.replace) {
+    if (this.#commands.has(name2) && !options3.replace) {
       throw new Error(`Command already registered: ${name2}`);
     }
-    this.#commands.set(name2, Object.freeze({ ...command2, name: name2, execute: execute2 }));
+    this.#commands.set(name2, Object.freeze({ ...command2, name: name2, execute: execute3 }));
     return this;
   }
   get(name2) {
@@ -2273,9 +2273,9 @@ init_platform();
 import { collectBytes, readBytes } from "poe-code/safe-fs/core";
 import { collectBytes as collectBytes2, readBytes as readBytes2, toByteSource } from "poe-code/safe-fs/core";
 var outputFailure = /* @__PURE__ */ Symbol("output failure");
-function createBytePipe(options2 = {}) {
-  const highWaterMark = options2.highWaterMark ?? 64 * 1024;
-  const signal = options2.signal;
+function createBytePipe(options3 = {}) {
+  const highWaterMark = options3.highWaterMark ?? 64 * 1024;
+  const signal = options3.signal;
   if (!Number.isSafeInteger(highWaterMark) || highWaterMark < 1) {
     throw new RangeError("highWaterMark must be a positive safe integer");
   }
@@ -2390,8 +2390,8 @@ async function pipeBytes(source, sink, signal) {
   }
   signal?.throwIfAborted();
 }
-async function collectText(source, options2) {
-  return new TextDecoder().decode(await collectBytes(source, options2));
+async function collectText(source, options3) {
+  return new TextDecoder().decode(await collectBytes(source, options3));
 }
 async function abortable(operation, signal) {
   signal?.throwIfAborted();
@@ -2796,17 +2796,6 @@ function concatenate(chunks, size = chunks.reduce((sum, chunk) => sum + chunk.le
   }
   return result;
 }
-async function collect(source, signal, limit = bufferLimit) {
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of source) {
-    signal.throwIfAborted();
-    size += chunk.length;
-    if (size > limit) throw new FsError("EFBIG", { message: `buffer limit exceeded (${limit} bytes)` });
-    chunks.push(new Uint8Array(chunk));
-  }
-  return concatenate(chunks, size);
-}
 async function* lines(source, separator = 10) {
   let pending = [];
   let size = 0;
@@ -3128,23 +3117,23 @@ function compareCopyIdentity(left, right) {
   if (!left || !right || !complete(left) || !complete(right)) return "unknown";
   return left.identityScope === right.identityScope && left.dev === right.dev && left.ino === right.ino ? "same" : "distinct";
 }
-async function compareObservedEntries(fs, path, stat, peer, peerPath, peerStat, options2 = {}) {
-  options2.signal?.throwIfAborted();
+async function compareObservedEntries(fs, path, stat, peer, peerPath, peerStat, options3 = {}) {
+  options3.signal?.throwIfAborted();
   const identity = compareCopyIdentity(stat, peerStat);
   if (identity !== "unknown") return identity;
   let result = "unknown";
   const operands = fs === peer ? [[fs, path, peer, peerPath]] : [[fs, path, peer, peerPath], [peer, peerPath, fs, path]];
   for (const [owner, ownPath, other, otherPath] of operands) {
-    options2.signal?.throwIfAborted();
+    options3.signal?.throwIfAborted();
     if (!owner.compareEntry) continue;
     let answer;
     try {
-      answer = await owner.compareEntry(ownPath, other, otherPath, options2);
+      answer = await owner.compareEntry(ownPath, other, otherPath, options3);
     } catch (error) {
-      options2.signal?.throwIfAborted();
+      options3.signal?.throwIfAborted();
       throw error;
     }
-    options2.signal?.throwIfAborted();
+    options3.signal?.throwIfAborted();
     if (answer !== "same" && answer !== "distinct" && answer !== "unknown") {
       throw new FsError("EIO", { path, dest: peerPath, message: "invalid entry comparison answer" });
     }
@@ -4597,6 +4586,68 @@ function streamCommands() {
 
 // packages/safe-bash/src/commands/text.ts
 init_platform();
+var SortWork = class {
+  constructor(signal) {
+    this.signal = signal;
+  }
+  signal;
+  #pending = 0;
+  charge(units = 1) {
+    this.signal.throwIfAborted();
+    this.#pending += units;
+    if (this.#pending >= 4096) return this.#checkpoint();
+  }
+  async #checkpoint() {
+    while (this.#pending >= 4096) {
+      this.#pending -= 4096;
+      await yieldTurn(this.signal);
+      this.signal.throwIfAborted();
+    }
+  }
+};
+async function sortRecords(records, compare, 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);
+      let left = begin;
+      let right = middle;
+      for (let index = begin; index < end; index++) {
+        const checkpoint = work.charge();
+        if (checkpoint) await checkpoint;
+        if (left < middle && (right === end || await compare(source[left], source[right]) <= 0)) target[index] = source[left++];
+        else target[index] = source[right++];
+      }
+    }
+    [source, target] = [target, source];
+  }
+  return source;
+}
+async function compareSortBytes(left, right, work) {
+  const length = Math.min(left.length, right.length);
+  for (let offset = 0; offset < length; offset += 1024) {
+    const end = Math.min(offset + 1024, length);
+    await work.charge(2 * (end - offset));
+    const compared = import_buffer.Buffer.compare(left.subarray(offset, end), right.subarray(offset, end));
+    if (compared) return compared;
+  }
+  return left.length - right.length;
+}
+async function foldSortBytes(bytes2, work) {
+  const folded = new Uint8Array(bytes2.length);
+  for (let offset = 0; offset < bytes2.length; offset += 1024) {
+    const end = Math.min(offset + 1024, bytes2.length);
+    await work.charge(end - offset);
+    for (let index = offset; index < end; index++) {
+      const byte = bytes2[index];
+      folded[index] = byte >= 97 && byte <= 122 ? byte - 32 : byte;
+    }
+  }
+  return folded;
+}
 async function admitTextOutput(context, destination) {
   if (destination === void 0) return;
   assertCommandRequirements(context, textOutputRequirements, ["output"]);
@@ -4613,27 +4664,37 @@ function compareBytes(left, right) {
 function fold(bytes2) {
   return bytes2.map((byte) => byte >= 97 && byte <= 122 ? byte - 32 : byte);
 }
-function parseNumeric(bytes2) {
+async function parseNumeric(bytes2, work) {
+  await work.charge(bytes2.length);
   const match = /^[ \t]*(-?)([0-9]*)(?:\.([0-9]*))?/u.exec(import_buffer.Buffer.from(bytes2).toString("latin1"));
   const whole = (match[2] ?? "").replace(/^0+/u, "") || "0";
   const fraction = (match[3] ?? "").replace(/0+$/u, "");
   return { whole, fraction, negative: match[1] === "-" && (whole !== "0" || fraction !== "") };
 }
-function compareNumericValues(first, second) {
+async function compareNumericValues(first, second, work) {
   if (first.negative !== second.negative) return first.negative ? -1 : 1;
   let compared = first.whole.length - second.whole.length;
-  if (!compared) compared = first.whole < second.whole ? -1 : first.whole > second.whole ? 1 : 0;
+  if (!compared) {
+    for (let offset = 0; offset < first.whole.length && !compared; offset += 1024) {
+      const end = Math.min(offset + 1024, first.whole.length);
+      await work.charge(2 * (end - offset));
+      const firstWhole = first.whole.slice(offset, end);
+      const secondWhole = second.whole.slice(offset, end);
+      compared = firstWhole < secondWhole ? -1 : firstWhole > secondWhole ? 1 : 0;
+    }
+  }
   if (!compared) {
     const width = Math.max(first.fraction.length, second.fraction.length);
-    const firstFraction = first.fraction.padEnd(width, "0");
-    const secondFraction = second.fraction.padEnd(width, "0");
-    compared = firstFraction < secondFraction ? -1 : firstFraction > secondFraction ? 1 : 0;
+    for (let offset = 0; offset < width && !compared; offset += 1024) {
+      const end = Math.min(offset + 1024, width);
+      await work.charge(2 * (end - offset));
+      const firstFraction = first.fraction.slice(offset, end).padEnd(end - offset, "0");
+      const secondFraction = second.fraction.slice(offset, end).padEnd(end - offset, "0");
+      compared = firstFraction < secondFraction ? -1 : firstFraction > secondFraction ? 1 : 0;
+    }
   }
   return first.negative ? -compared : compared;
 }
-function numericCompare(left, right) {
-  return compareNumericValues(parseNumeric(left), parseNumeric(right));
-}
 function sortKey(specification) {
   const match = /^([0-9]+)(?:\.([0-9]+))?([bfnr]*)(?:,([0-9]+)(?:\.([0-9]+))?([bfnr]*))?$/u.exec(specification);
   if (!match) throw new UsageError(`invalid key '${specification}'`);
@@ -4645,25 +4706,33 @@ function sortKey(specification) {
     flags: new Set((match[3] ?? "") + (match[6] ?? ""))
   };
 }
-function keyBytes(line, key, separator, blanks) {
+async function keyBytes(line, key, separator, blanks, work) {
   const fields = [];
   if (separator !== void 0) {
     let start2 = 0;
-    for (let offset = 0; offset <= line.length; offset++) if (offset === line.length || line[offset] === separator) {
-      fields.push({ start: start2, end: offset });
-      start2 = offset + 1;
+    for (let offset = 0; offset <= line.length; offset++) {
+      if (offset > 0 && offset % 1024 === 0) await work.charge(1024);
+      if (offset === line.length || line[offset] === separator) {
+        fields.push({ start: start2, end: offset });
+        start2 = offset + 1;
+      }
     }
   } else {
     let offset = 0;
     while (offset < line.length) {
       const leading = offset;
-      while (offset < line.length && (line[offset] === 32 || line[offset] === 9)) offset++;
+      while (offset < line.length && (line[offset] === 32 || line[offset] === 9)) {
+        if (++offset % 1024 === 0) await work.charge(1024);
+      }
       const start2 = blanks ? offset : leading;
       if (offset === line.length) break;
-      while (offset < line.length && line[offset] !== 32 && line[offset] !== 9) offset++;
+      while (offset < line.length && line[offset] !== 32 && line[offset] !== 9) {
+        if (++offset % 1024 === 0) await work.charge(1024);
+      }
       fields.push({ start: start2, end: offset });
     }
   }
+  await work.charge(line.length % 1024);
   const start = (fields[key.start - 1]?.start ?? line.length) + key.startCharacter - 1;
   const last = key.end === void 0 ? void 0 : fields[key.end - 1];
   const end = key.end === void 0 ? line.length : last === void 0 ? line.length : key.endCharacter === void 0 ? last.end : Math.min(last.end, last.start + key.endCharacter);
@@ -4726,42 +4795,50 @@ function textCommands() {
       const keys = (parsed.values.get("k") ?? []).map(sortKey);
       const simple = !keys.length && !["b", "f", "n"].some((flag) => parsed.flags.has(flag));
       const direction = parsed.flags.has("r") ? -1 : 1;
-      let compareNumeric = numericCompare;
+      const work = new SortWork(context.signal);
+      let compareNumeric = async (left, right) => compareNumericValues(await parseNumeric(left, work), await parseNumeric(right, work), work);
       if (!keys.length && parsed.flags.has("n") && !["b", "f", "c"].some((flag) => parsed.flags.has(flag))) {
         const numericValues = /* @__PURE__ */ new Map();
         let retainedBytes = 0;
-        const numericValue = (bytes2) => {
+        const numericValue = async (bytes2) => {
           const cached = numericValues.get(bytes2);
           if (cached !== void 0) return cached;
           context.signal.throwIfAborted();
           const charge2 = 6 * bytes2.length + 2;
-          if (numericValues.size >= 16384 || charge2 > 1048576 - retainedBytes) return parseNumeric(bytes2);
-          const parsedValue = parseNumeric(bytes2);
+          if (numericValues.size >= 16384 || charge2 > 1048576 - retainedBytes) return parseNumeric(bytes2, work);
+          const parsedValue = await parseNumeric(bytes2, work);
           numericValues.set(bytes2, parsedValue);
           retainedBytes += charge2;
           return parsedValue;
         };
-        compareNumeric = (left, right) => compareNumericValues(numericValue(left), numericValue(right));
+        compareNumeric = async (left, right) => compareNumericValues(await numericValue(left), await numericValue(right), work);
       }
-      let keyCompare = simple ? (left, right) => compareBytes(left, right) * direction : (left, right) => {
+      let keyCompare = async (left, right) => {
+        const checkpoint = work.charge();
+        if (checkpoint) await checkpoint;
+        if (simple) return await compareSortBytes(left, right, work) * direction;
         for (const key of keys.length ? keys : [void 0]) {
+          await work.charge();
           const flags = key?.flags.size ? key.flags : parsed.flags;
-          let first = key ? keyBytes(left, key, separator, flags.has("b")) : left;
-          let second = key ? keyBytes(right, key, separator, flags.has("b")) : right;
+          let first = key ? await keyBytes(left, key, separator, flags.has("b"), work) : left;
+          let second = key ? await keyBytes(right, key, separator, flags.has("b"), work) : right;
           if (!key && flags.has("b")) {
-            const trim = (bytes2) => {
+            const trim = async (bytes2) => {
               let offset = 0;
-              while (bytes2[offset] === 9 || bytes2[offset] === 32) offset++;
+              while (bytes2[offset] === 9 || bytes2[offset] === 32) {
+                if (++offset % 1024 === 0) await work.charge(1024);
+              }
+              await work.charge(offset % 1024);
               return bytes2.subarray(offset);
             };
-            first = trim(first);
-            second = trim(second);
+            first = await trim(first);
+            second = await trim(second);
           }
           if (flags.has("f")) {
-            first = fold(first);
-            second = fold(second);
+            first = await foldSortBytes(first, work);
+            second = await foldSortBytes(second, work);
           }
-          let result = flags.has("n") ? compareNumeric(first, second) : compareBytes(first, second);
+          let result = flags.has("n") ? await compareNumeric(first, second) : await compareSortBytes(first, second, work);
           if (flags.has("r")) result = -result;
           if (result) return result;
         }
@@ -4772,24 +4849,29 @@ function textCommands() {
       if (numericKey && numericKeyFlags.has("n") && !["b", "f"].some((flag) => numericKeyFlags.has(flag)) && !parsed.flags.has("c")) {
         const keyedNumericValues = /* @__PURE__ */ new Map();
         let retainedKeyBytes = 0;
-        const keyedNumericValue = (record3) => {
-          const cached = keyedNumericValues.get(record3);
+        const keyedNumericValue = async (record4) => {
+          const cached = keyedNumericValues.get(record4);
           if (cached !== void 0) return cached;
           context.signal.throwIfAborted();
-          const bytes2 = keyBytes(record3, numericKey, separator, false);
+          const bytes2 = await keyBytes(record4, numericKey, separator, false, work);
           const charge2 = 6 * bytes2.length + 2;
-          if (keyedNumericValues.size >= 16384 || charge2 > 1048576 - retainedKeyBytes) return parseNumeric(bytes2);
-          const parsedValue = parseNumeric(bytes2);
-          keyedNumericValues.set(record3, parsedValue);
+          if (keyedNumericValues.size >= 16384 || charge2 > 1048576 - retainedKeyBytes) return parseNumeric(bytes2, work);
+          const parsedValue = await parseNumeric(bytes2, work);
+          keyedNumericValues.set(record4, parsedValue);
           retainedKeyBytes += charge2;
           return parsedValue;
         };
-        keyCompare = (left, right) => {
-          const result = compareNumericValues(keyedNumericValue(left), keyedNumericValue(right));
+        keyCompare = async (left, right) => {
+          const checkpoint = work.charge();
+          if (checkpoint) await checkpoint;
+          const result = await compareNumericValues(await keyedNumericValue(left), await keyedNumericValue(right), work);
           return numericKeyFlags.has("r") ? -result : result;
         };
       }
-      const compare = simple ? keyCompare : (left, right) => keyCompare(left, right) || (parsed.flags.has("s") || parsed.flags.has("u") ? 0 : compareBytes(left, right) * (parsed.flags.has("r") ? -1 : 1));
+      const compare = async (left, right) => {
+        const result = await keyCompare(left, right);
+        return result || (simple || parsed.flags.has("s") || parsed.flags.has("u") ? 0 : await compareSortBytes(left, right, work) * direction);
+      };
       const records = [];
       let size = 0;
       const exitCode = 0;
@@ -4809,7 +4891,7 @@ function textCommands() {
             context.signal.throwIfAborted();
             size += line.bytes.length + 1;
             if (size > bufferLimit) throw new FsError("EFBIG", { message: "sort buffer limit exceeded" });
-            if (parsed.flags.has("c") && records.length && (compare(records.at(-1), line.bytes) > 0 || parsed.flags.has("u") && keyCompare(records.at(-1), line.bytes) === 0)) {
+            if (parsed.flags.has("c") && records.length && (await compare(records.at(-1), line.bytes) > 0 || parsed.flags.has("u") && await keyCompare(records.at(-1), line.bytes) === 0)) {
               await diagnostic(context, new Error(`disorder at record ${records.length + 1}`));
               return { exitCode: 1 };
             }
@@ -4821,18 +4903,18 @@ function textCommands() {
         }
       }
       if (parsed.flags.has("c")) return { exitCode };
-      records.sort(compare);
+      const ordered = await sortRecords(records, compare, work);
       const sorted = (async function* () {
         let previous;
         let buffer = new Uint8Array(64 * 1024);
         let used = 0;
-        for (const record3 of records) {
+        for (const record4 of ordered) {
           context.signal.throwIfAborted();
-          if (parsed.flags.has("u") && previous !== void 0 && keyCompare(previous, record3) === 0) continue;
+          if (parsed.flags.has("u") && previous !== void 0 && await keyCompare(previous, record4) === 0) continue;
           let offset = 0;
-          while (offset < record3.length) {
-            const length = Math.min(record3.length - offset, buffer.length - used);
-            buffer.set(record3.subarray(offset, offset + length), used);
+          while (offset < record4.length) {
+            const length = Math.min(record4.length - offset, buffer.length - used);
+            buffer.set(record4.subarray(offset, offset + length), used);
             offset += length;
             used += length;
             if (used === buffer.length) {
@@ -4847,7 +4929,7 @@ function textCommands() {
             buffer = new Uint8Array(64 * 1024);
             used = 0;
           }
-          previous = record3;
+          previous = record4;
         }
         if (used) yield buffer.subarray(0, used);
       })();
@@ -4878,19 +4960,19 @@ function textCommands() {
         let previousKey;
         let count2 = 0;
         const selected = () => (!parsed.flags.has("d") || count2 > 1) && (!parsed.flags.has("u") || count2 === 1);
-        const record3 = () => concatenate([...parsed.flags.has("c") ? [encoder2.encode(`${String(count2).padStart(7)} `)] : [], previous, Uint8Array.of(delimiter)]);
+        const record4 = () => concatenate([...parsed.flags.has("c") ? [encoder2.encode(`${String(count2).padStart(7)} `)] : [], previous, Uint8Array.of(delimiter)]);
         for await (const line of lines(input(context, parsed.operands[0]), delimiter)) {
           context.signal.throwIfAborted();
           const currentKey = key(line.bytes);
           if (previousKey && compareBytes(previousKey, currentKey) === 0) count2++;
           else {
-            if (previous !== void 0 && selected()) yield record3();
+            if (previous !== void 0 && selected()) yield record4();
             previous = line.bytes;
             previousKey = currentKey;
             count2 = 1;
           }
         }
-        if (previous !== void 0 && selected()) yield record3();
+        if (previous !== void 0 && selected()) yield record4();
       })();
       if (parsed.operands[1] !== void 0 && parsed.operands[0] !== "-" && pathOf(context, parsed.operands[0]) === pathOf(context, parsed.operands[1])) throw new UsageError("input and output must be different files");
       await emitRecords(context, records, parsed.operands[1]);
@@ -4923,9 +5005,9 @@ function textCommands() {
             context.signal.throwIfAborted();
             let bytes2;
             if (mode === "f") {
-              const record3 = import_buffer.Buffer.from(line.bytes.buffer, line.bytes.byteOffset, line.bytes.byteLength);
+              const record4 = import_buffer.Buffer.from(line.bytes.buffer, line.bytes.byteOffset, line.bytes.byteLength);
               const separator = import_buffer.Buffer.from(delimiter);
-              let boundary = record3.indexOf(separator);
+              let boundary = record4.indexOf(separator);
               if (boundary < 0) {
                 if (parsed.flags.has("s")) continue;
                 bytes2 = line.bytes;
@@ -4938,12 +5020,12 @@ function textCommands() {
                 while (true) {
                   if (selected(field++)) {
                     if (emitted) pieces.push(joiner);
-                    pieces.push(record3.subarray(start, boundary < 0 ? record3.length : boundary));
+                    pieces.push(record4.subarray(start, boundary < 0 ? record4.length : boundary));
                     emitted = true;
                   }
                   if (boundary < 0) break;
                   start = boundary + separator.length;
-                  boundary = record3.indexOf(separator, start);
+                  boundary = record4.indexOf(separator, start);
                 }
                 bytes2 = concatenate(pieces);
               }
@@ -6327,7 +6409,7 @@ var Parser = class {
       this.advance();
       let nodes = 0;
       const grouped = /* @__PURE__ */ new WeakSet();
-      const admit = () => {
+      const admit2 = () => {
         if (nodes >= 4096) this.error("Conditional syntax exceeds 4096 nodes");
         nodes++;
       };
@@ -6338,7 +6420,7 @@ var Parser = class {
       const primary = (depth) => {
         if (depth > 64) this.error("Conditional syntax nesting exceeds 64");
         if (this.is("!")) {
-          admit();
+          admit2();
           this.advance();
           const expression2 = primary(depth + 1);
           return expression2.kind === "not" && !grouped.has(expression2) ? expression2.operand : { kind: "not", operand: expression2 };
@@ -6350,7 +6432,7 @@ var Parser = class {
           grouped.add(expression2);
           return expression2;
         }
-        admit();
+        admit2();
         const first = operand();
         if (conditionalBinary.has(this.current.value)) {
           const operator = this.current.value;
@@ -6365,7 +6447,7 @@ var Parser = class {
       const conjunction = (depth) => {
         let expression2 = primary(depth);
         while (this.is("&&")) {
-          admit();
+          admit2();
           this.advance();
           expression2 = { kind: "and", left: expression2, right: primary(depth) };
         }
@@ -6374,7 +6456,7 @@ var Parser = class {
       const disjunction = (depth) => {
         let expression2 = conjunction(depth);
         while (this.is("||")) {
-          admit();
+          admit2();
           this.advance();
           expression2 = { kind: "or", left: expression2, right: conjunction(depth) };
         }
@@ -6539,18 +6621,18 @@ var Parser = class {
     return script;
   }
   redirect() {
-    let descriptor;
+    let descriptor2;
     if (this.current.kind === "word" && /^\d+$/u.test(this.current.value)) {
       const next = this.peek();
-      if (/^(?:>|>>|<|<<|<<-|<<<|>&|<&|>\|)$/u.test(next.value) && this.current.end === next.offset) descriptor = Number(this.advance().value);
+      if (/^(?:>|>>|<|<<|<<-|<<<|>&|<&|>\|)$/u.test(next.value) && this.current.end === next.offset) descriptor2 = Number(this.advance().value);
     }
     if (!/^(?:>|>>|<|<<|<<-|<<<|>&|<&|>\||&>)$/u.test(this.current.value) || this.current.kind !== "operator") return void 0;
     const operator = this.advance().value;
-    descriptor ??= operator.startsWith("<") ? 0 : 1;
-    if (!Number.isSafeInteger(descriptor) || descriptor > 255) this.error("File descriptor must be between 0 and 255");
+    descriptor2 ??= operator.startsWith("<") ? 0 : 1;
+    if (!Number.isSafeInteger(descriptor2) || descriptor2 > 255) this.error("File descriptor must be between 0 and 255");
     if (!this.current.word) this.error("Expected redirect target");
     const target = this.advance();
-    return { descriptor, operator, target: target.word, line: this.lexer.lineAt(Math.max(target.offset, target.end - 1)), ...(operator === "<&" || operator === ">&") && this.lexer.source[target.end - 1] === "-" ? { move: true } : {}, ...target.document ? { document: target.document } : {} };
+    return { descriptor: descriptor2, operator, target: target.word, line: this.lexer.lineAt(Math.max(target.offset, target.end - 1)), ...(operator === "<&" || operator === ">&") && this.lexer.source[target.end - 1] === "-" ? { move: true } : {}, ...target.document ? { document: target.document } : {} };
   }
 };
 function parseShell(source, depth = 0) {
@@ -6599,13 +6681,13 @@ init_platform();
 // packages/safe-bash/src/shell/value-state.ts
 init_platform();
 var ValueArena = class {
-  constructor(maximumBytes, maximumSlots, checkpoint, fail = (limit) => {
+  constructor(maximumBytes, maximumSlots, checkpoint, fail2 = (limit) => {
     throw new ShellLimitError(limit);
   }) {
     this.maximumBytes = maximumBytes;
     this.maximumSlots = maximumSlots;
     this.checkpoint = checkpoint;
-    this.fail = fail;
+    this.fail = fail2;
   }
   maximumBytes;
   maximumSlots;
@@ -6635,25 +6717,25 @@ var ValueArena = class {
     if (!Number.isSafeInteger(bytes2) || bytes2 < 0 || !Number.isSafeInteger(slots) || slots < 0) throw new RangeError("Invalid shell value allocation");
     if (bytes2 > this.maximumBytes - this.#bytes) this.fail("maxExpansionBytes");
     if (slots > this.maximumSlots - this.#slots) this.fail("maxExpansionFields");
-    const record3 = { bytes: bytes2, slots, references: 1 };
+    const record4 = { bytes: bytes2, slots, references: 1 };
     this.#bytes += bytes2;
     this.#slots += slots;
-    this.#records.add(record3);
-    return record3;
+    this.#records.add(record4);
+    return record4;
   }
-  commit(record3, object) {
+  commit(record4, object) {
     this.assertOpen();
-    if (!this.#records.has(record3) || record3.object || this.#objects.has(object)) throw new Error("Shell value reservation is not fresh");
-    record3.object = object;
-    this.#objects.set(object, record3);
-  }
-  release(record3) {
-    if (!this.#records.has(record3)) return;
-    if (--record3.references) return;
-    this.#records.delete(record3);
-    if (record3.object) this.#objects.delete(record3.object);
-    this.#bytes -= record3.bytes;
-    this.#slots -= record3.slots;
+    if (!this.#records.has(record4) || record4.object || this.#objects.has(object)) throw new Error("Shell value reservation is not fresh");
+    record4.object = object;
+    this.#objects.set(object, record4);
+  }
+  release(record4) {
+    if (!this.#records.has(record4)) return;
+    if (--record4.references) return;
+    this.#records.delete(record4);
+    if (record4.object) this.#objects.delete(record4.object);
+    this.#bytes -= record4.bytes;
+    this.#slots -= record4.slots;
   }
   hold(value2) {
     this.assertOpen();
@@ -6696,7 +6778,7 @@ var ValueArena = class {
   }
   close() {
     this.#closed = true;
-    for (const record3 of this.#records) if (record3.object) this.#objects.delete(record3.object);
+    for (const record4 of this.#records) if (record4.object) this.#objects.delete(record4.object);
     this.#records.clear();
     this.#bytes = 0;
     this.#slots = 0;
@@ -6718,19 +6800,19 @@ var ValueScope = class {
   reserve(bytes2, slots) {
     this.assertOpen();
     this.#enrollment ??= this.arena.allocate(64, 1);
-    const record3 = this.arena.allocate(bytes2, slots);
+    const record4 = this.arena.allocate(bytes2, slots);
     let released = false;
     const release = () => {
       if (released) return;
       released = true;
       this.#releases.delete(release);
-      this.arena.release(record3);
+      this.arena.release(record4);
     };
     this.#releases.add(release);
     return { commit: (value2) => {
       this.assertOpen();
       if (released) throw new Error("Shell value reservation is released");
-      this.arena.commit(record3, value2);
+      this.arena.commit(record4, value2);
     }, release };
   }
   hold(value2) {
@@ -6898,28 +6980,28 @@ function positionalTemplate(source, checkpoint) {
   }
   return found;
 }
-function positionalValue(name2, options2) {
+function positionalValue(name2, options3) {
   let index = 0;
   let outside = false;
   for (let position = 0; position < name2.length; position++) {
-    if (position % 128 === 0) options2.checkpoint();
+    if (position % 128 === 0) options3.checkpoint();
     const next = name2.charCodeAt(position) - 48;
-    if (index > Math.floor((options2.positional.length - next) / 10)) outside = true;
+    if (index > Math.floor((options3.positional.length - next) / 10)) outside = true;
     if (!outside) index = index * 10 + next;
   }
-  return outside ? void 0 : index === 0 ? options2.arg0 : options2.positional[index - 1];
+  return outside ? void 0 : index === 0 ? options3.arg0 : options3.positional[index - 1];
 }
-function evaluatePositionalArithmetic(program, options2, evaluate) {
+function evaluatePositionalArithmetic(program, options3, evaluate) {
   const source = program.source;
   if (!source.includes("$")) return evaluate(program);
-  options2.checkpoint();
-  if (!positionalTemplate(source, options2.checkpoint)) return evaluate(program);
-  const header = options2.owner?.reserve({ metadata: 128, allocatedSlots: 2, work: source.length * 2 + 8 });
+  options3.checkpoint();
+  if (!positionalTemplate(source, options3.checkpoint)) return evaluate(program);
+  const header = options3.owner?.reserve({ metadata: 128, allocatedSlots: 2, work: source.length * 2 + 8 });
   const admissions = [];
   const chunks = [];
   let bytes2 = 0;
   const reserve = (payload) => {
-    const admission = options2.owner?.reserve({ payload, metadata: 64, allocatedSlots: 2, work: 4 });
+    const admission = options3.owner?.reserve({ payload, metadata: 64, allocatedSlots: 2, work: 4 });
     if (admission) admissions.push(admission);
   };
   const length = (text, start, end, maximum) => {
@@ -6927,7 +7009,7 @@ function evaluatePositionalArithmetic(program, options2, evaluate) {
     let nextCheckpoint = start;
     for (let position = start; position < end; ) {
       if (position >= nextCheckpoint) {
-        options2.checkpoint();
+        options3.checkpoint();
         nextCheckpoint = position + 128;
       }
       const code = text.charCodeAt(position++);
@@ -6937,14 +7019,14 @@ function evaluatePositionalArithmetic(program, options2, evaluate) {
         size += 4;
         position++;
       } else size += 3;
-      if (size > maximum) options2.limit();
+      if (size > maximum) options3.limit();
     }
-    options2.owner?.reserve({ work: end - start }).release();
+    options3.owner?.reserve({ work: end - start }).release();
     return size;
   };
   const literal = (start, end) => {
     if (start === end) return;
-    const size = length(source, start, end, options2.maximumBytes - bytes2);
+    const size = length(source, start, end, options3.maximumBytes - bytes2);
     reserve(size);
     chunks.push(source.slice(start, end));
     bytes2 += size;
@@ -6954,7 +7036,7 @@ function evaluatePositionalArithmetic(program, options2, evaluate) {
     let nextCheckpoint = 0;
     for (let position = 0; position < source.length; ) {
       if (position >= nextCheckpoint) {
-        options2.checkpoint();
+        options3.checkpoint();
         nextCheckpoint = position + 128;
       }
       if (source[position] !== "$") {
@@ -6967,17 +7049,17 @@ function evaluatePositionalArithmetic(program, options2, evaluate) {
       let nameEnd = nameStart + 1;
       if (braced) while (digit(source, nameEnd)) {
         if (nameEnd >= nextCheckpoint) {
-          options2.checkpoint();
+          options3.checkpoint();
           nextCheckpoint = nameEnd + 128;
         }
         nameEnd++;
       }
       reserve(nameEnd - nameStart);
       const name2 = source.slice(nameStart, nameEnd);
-      const value2 = positionalValue(name2, options2);
-      options2.requireParameter(name2, value2);
+      const value2 = positionalValue(name2, options3);
+      options3.requireParameter(name2, value2);
       const text = value2 ?? "";
-      const size = length(text, 0, text.length, options2.maximumBytes - bytes2);
+      const size = length(text, 0, text.length, options3.maximumBytes - bytes2);
       reserve(size);
       chunks.push(text);
       bytes2 += size;
@@ -6985,10 +7067,10 @@ function evaluatePositionalArithmetic(program, options2, evaluate) {
       start = position;
     }
     literal(start, source.length);
-    options2.checkpoint();
+    options3.checkpoint();
     reserve(bytes2);
     const expanded = chunks.join("");
-    options2.checkpoint();
+    options3.checkpoint();
     return evaluate(prepareArithmetic(expanded));
   } finally {
     for (let position = admissions.length - 1; position >= 0; position--) admissions[position].release();
@@ -7522,7 +7604,7 @@ async function* argumentsFrom(source, signal, delimiter, replacement = false) {
   if (quote || escaped) throw new UsageError(quote ? "unmatched quote in input" : "trailing backslash in input");
   if (active) yield current;
 }
-function executionCommands(execute2) {
+function executionCommands(execute3) {
   return [
     define("env", async (context) => {
       const argumentValues = getCommandArguments(context);
@@ -7573,7 +7655,7 @@ function executionCommands(execute2) {
           stderr: context.stderr,
           ...context.stdinIsDefault === void 0 ? {} : { stdinIsDefault: context.stdinIsDefault }
         });
-        return execute2({ ...context, command: parsed.operands[offset], args: childArguments.args, argumentValues: childArguments, env: childEnv, cwd });
+        return execute3({ ...context, command: parsed.operands[offset], args: childArguments.args, argumentValues: childArguments, env: childEnv, cwd });
       }
       for (const name2 of names) await output(context, `${name2}=${env[name2]}${parsed.flags.has("0") ? "\0" : "\n"}`);
       return { exitCode: 0 };
@@ -7613,7 +7695,7 @@ function executionCommands(execute2) {
         const size = encoder2.encode(command2).length + 1 + childArguments.values.reduce((sum, argument) => sum + shellValueByteLength(argument) + 1, 0);
         if (size > maxBytes) throw new UsageError("expanded arguments exceed command size limit");
         if (parsed.flags.has("t")) await writeBytes(context.stderr, encoder2.encode([command2, ...args].map((argument) => /^[A-Za-z0-9_./-]+$/u.test(argument) ? argument : `'${argument.replaceAll("'", "'\\''")}'`).join(" ") + "\n"), context.signal);
-        const result = await execute2({ ...context, command: command2, args, argumentValues: childArguments, stdin: emptyInput(), stdinIsDefault: true, env: { ...context.env } });
+        const result = await execute3({ ...context, command: command2, args, argumentValues: childArguments, stdin: emptyInput(), stdinIsDefault: true, env: { ...context.env } });
         executed = true;
         if (result.exitCode === 255) {
           status = 124;
@@ -7770,9 +7852,9 @@ async function validateString(value2, work, optstring = false) {
     else work.addBytes(3);
   }
 }
-async function scanGetopts(state, optstring, args, options2) {
-  if (!record2(options2) || typeof options2.reportErrors !== "boolean") throw new GetoptsError("INVALID_INPUT", "Getopts requires explicit diagnostic policy and work controls");
-  const work = new ScanWork(options2.work);
+async function scanGetopts(state, optstring, args, options3) {
+  if (!record2(options3) || typeof options3.reportErrors !== "boolean") throw new GetoptsError("INVALID_INPUT", "Getopts requires explicit diagnostic policy and work controls");
+  const work = new ScanWork(options3.work);
   const original = cloneGetoptsState(state);
   if (!Array.isArray(args)) throw new GetoptsError("INVALID_INPUT", "Getopts requires an argument array");
   if (args.length > work.maxArguments) throw new GetoptsError("ARGUMENT_LIMIT", "Getopts argument limit exceeded");
@@ -7827,7 +7909,7 @@ async function scanGetopts(state, optstring, args, options2) {
   active = attached ? { argument: active.argument, offset } : void 0;
   if (!attached) index++;
   if (specification[code] === -1) {
-    return finish("unknown-option", "?", silent ? { kind: "set", value: option } : { kind: "unset" }, !silent && options2.reportErrors ? { kind: "unknown-option", option } : null);
+    return finish("unknown-option", "?", silent ? { kind: "set", value: option } : { kind: "unset" }, !silent && options3.reportErrors ? { kind: "unknown-option", option } : null);
   }
   if (specification[code] === 1) {
     if (attached) {
@@ -7840,7 +7922,7 @@ async function scanGetopts(state, optstring, args, options2) {
       index++;
       return finish("option", option, { kind: "set", value: value2 }, null);
     }
-    return finish("missing-argument", silent ? ":" : "?", silent ? { kind: "set", value: option } : { kind: "unset" }, !silent && options2.reportErrors ? { kind: "missing-argument", option } : null);
+    return finish("missing-argument", silent ? ":" : "?", silent ? { kind: "set", value: option } : { kind: "unset" }, !silent && options3.reportErrors ? { kind: "missing-argument", option } : null);
   }
   return finish("option", option, { kind: "unset" }, null);
 }
@@ -8179,17 +8261,17 @@ function throwLocalActivationFailure(state) {
   const failure = localActivationFailure(state);
   if (failure.failed) throw failure.reason;
 }
-function prepareChildCancellation(parent, options2, snapshot, controls) {
+function prepareChildCancellation(parent, options3, snapshot, controls) {
   const parentState = requireLink(parent);
   throwAdmissionFailure(parentState);
   let localSignal;
-  if (options2 !== void 0) {
-    if (options2 === null || typeof options2 !== "object" && typeof options2 !== "function") {
+  if (options3 !== void 0) {
+    if (options3 === null || typeof options3 !== "object" && typeof options3 !== "function") {
       return stagedFailure(parentState, new TypeError("Cancellation options must be an object or function"));
     }
     let candidate;
     try {
-      candidate = options2.signal;
+      candidate = options3.signal;
     } catch (error) {
       return stagedFailure(parentState, error);
     }
@@ -9154,10 +9236,10 @@ var StateMonitor = class {
           monitor.finish(tickets, name2);
           return result;
         },
-        defineProperty(target, key, descriptor) {
+        defineProperty(target, key, descriptor2) {
           const name2 = named ? String(key) : void 0;
           const tickets = monitor.mutation(name2);
-          const result = Reflect.defineProperty(target, key, descriptor);
+          const result = Reflect.defineProperty(target, key, descriptor2);
           if (result) monitor.changedValue(target, field, key);
           monitor.finish(tickets, name2);
           return result;
@@ -9954,6 +10036,7 @@ var defaultLimits = {
   maxInputBytes: 32 * 1024 * 1024,
   maxOutputBytes: 16 * 1024 * 1024,
   maxCommands: 1e4,
+  maxRedirects: 64,
   maxPipelineStages: 64,
   maxLoopIterations: 1e4,
   maxSubstitutionDepth: 64,
@@ -10178,12 +10261,21 @@ var Capture = class {
     }
     return bytes2;
   }
+  takeBytes() {
+    const chunk = this.chunks.length === 1 ? this.chunks[0] : void 0;
+    const bytes2 = chunk && chunk.byteLength === chunk.buffer.byteLength ? chunk : this.bytes();
+    this.chunks.length = 0;
+    this.length = 0;
+    this.#tail = void 0;
+    this.#tailLength = 0;
+    return bytes2;
+  }
 };
 var typedSavedVariables = /* @__PURE__ */ new WeakMap();
 var valueScope = /* @__PURE__ */ Symbol("shell value allocation scope");
 var invokedValues = /* @__PURE__ */ new WeakMap();
 function isolateIO(io) {
-  return { ...io, ...io.descriptors ? { descriptors: new Map([...io.descriptors].map(([number, descriptor]) => [number, { ...descriptor }])) } : {} };
+  return { ...io, ...io.descriptors ? { descriptors: new Map([...io.descriptors].map(([number, descriptor2]) => [number, { ...descriptor2 }])) } : {} };
 }
 function activeIO(io) {
   const input3 = io.descriptors?.get(0);
@@ -10197,6 +10289,13 @@ function activeIO(io) {
     ...error?.closed && error.output === io.stderr ? { stderr: closedSink } : {}
   };
 }
+function appendOutputBytes(current, chunk) {
+  const length = current.length + chunk.length;
+  const bytes2 = current.buffer.byteLength - current.byteOffset >= length ? new Uint8Array(current.buffer, current.byteOffset, length) : new Uint8Array(Math.max(length, current.length * 2, 64));
+  if (bytes2.buffer !== current.buffer) bytes2.set(current);
+  bytes2.set(chunk, current.length);
+  return bytes2.subarray(0, length);
+}
 var Flow = class extends Error {
   constructor(kind, status, levels = 1) {
     super(kind);
@@ -10654,11 +10753,11 @@ var DirectoryStackWork = class {
     await writeText(this.stdout, text);
     this.signal.throwIfAborted();
   }
-  async display(cwd, entries, options2, home) {
+  async display(cwd, entries, options3, home) {
     await this.scan(cwd, "path");
-    const homeBytes = !options2.long && home !== void 0 ? await this.scan(home, "HOME") : 0;
-    const start = options2.index ?? 0;
-    const end = options2.index ?? entries.length;
+    const homeBytes = !options3.long && home !== void 0 ? await this.scan(home, "HOME") : 0;
+    const start = options3.index ?? 0;
+    const end = options3.index ?? entries.length;
     for (let index = start; index <= end; index++) {
       await this.charge(1);
       let entry = index === 0 ? cwd : entries[index - 1];
@@ -10676,12 +10775,12 @@ var DirectoryStackWork = class {
           if (entry.length === home.length || entry[home.length] === "/") entry = `~${entry.slice(home.length)}`;
         }
       }
-      if (index !== start && !options2.lines && !options2.verbose) await this.emit(" ");
-      if (options2.verbose) await this.emit(`${String(index).padStart(2, " ")}  `);
+      if (index !== start && !options3.lines && !options3.verbose) await this.emit(" ");
+      if (options3.verbose) await this.emit(`${String(index).padStart(2, " ")}  `);
       await this.emit(entry);
-      if (options2.lines || options2.verbose) await this.emit("\n");
+      if (options3.lines || options3.verbose) await this.emit("\n");
     }
-    if (!options2.lines && !options2.verbose) await this.emit("\n");
+    if (!options3.lines && !options3.verbose) await this.emit("\n");
     await this.flushOutput();
   }
 };
@@ -10739,34 +10838,34 @@ var RuntimeCancellationState = class {
   }
   bind(promise, boundary) {
     if (this.#closed) throw new Error("Cancellation outcome admission is closed");
-    const record3 = { promise, boundary, finalized: false, consumed: false };
-    this.#records.add(record3);
-    return record3;
+    const record4 = { promise, boundary, finalized: false, consumed: false };
+    this.#records.add(record4);
+    return record4;
   }
-  finalize(record3, selection) {
-    if (record3.consumed || !this.#records.has(record3)) return;
-    record3.selection = selection;
-    record3.finalized = true;
+  finalize(record4, selection) {
+    if (record4.consumed || !this.#records.has(record4)) return;
+    record4.selection = selection;
+    record4.finalized = true;
   }
   consume(rawReturn, capturedReason) {
-    for (const record3 of this.#records) {
-      if (record3.promise !== rawReturn) continue;
-      record3.consumed = true;
-      this.#records.delete(record3);
-      const selection = record3.selection;
-      if (!record3.finalized || selection?.outcome.kind !== "throw" || !Object.is(selection.outcome.reason, capturedReason)) return void 0;
+    for (const record4 of this.#records) {
+      if (record4.promise !== rawReturn) continue;
+      record4.consumed = true;
+      this.#records.delete(record4);
+      const selection = record4.selection;
+      if (!record4.finalized || selection?.outcome.kind !== "throw" || !Object.is(selection.outcome.reason, capturedReason)) return void 0;
       return selection.report;
     }
     return void 0;
   }
-  discard(record3) {
-    if (!record3) return;
-    record3.consumed = true;
-    this.#records.delete(record3);
+  discard(record4) {
+    if (!record4) return;
+    record4.consumed = true;
+    this.#records.delete(record4);
   }
   close() {
     this.#closed = true;
-    for (const record3 of this.#records) record3.consumed = true;
+    for (const record4 of this.#records) record4.consumed = true;
     this.#records.clear();
     this.#diagnostics = /* @__PURE__ */ new WeakMap();
   }
@@ -10820,7 +10919,7 @@ var InvocationCancellationOwner = class {
       throw error;
     }
   }
-  capture(execute2, frame) {
+  capture(execute3, frame) {
     return new Promise((resolve) => {
       let settled = false;
       let raw;
@@ -10842,7 +10941,7 @@ var InvocationCancellationOwner = class {
         });
       };
       try {
-        raw = Promise.resolve(execute2());
+        raw = Promise.resolve(execute3());
       } catch (reason) {
         settle({ kind: "throw", reason });
         return;
@@ -11080,13 +11179,13 @@ var Runtime = class _Runtime {
       }
     );
   }
-  invokeChild(options2, state, parent, validate, execute2) {
+  invokeChild(options3, state, parent, validate, execute3) {
     const publicPromise = Promise.resolve().then(async () => {
       if (!this.cancellation.deliverySignal.aborted) parent.assertOpen();
       const childDepth = this.cancellationDepth + 1;
       const prepared = prepareChildCancellation(
         this.cancellation,
-        options2,
+        options3,
         this.cancellationAdmission(childDepth)
       );
       this.cancellationOwner?.assertAdmissionOpen();
@@ -11126,7 +11225,7 @@ var Runtime = class _Runtime {
         frame
       );
       let captured;
-      const executeChild = () => execute2(runtime, scope);
+      const executeChild = () => execute3(runtime, scope);
       if (owner) captured = await owner.capture(executeChild, frame);
       else {
         try {
@@ -11275,8 +11374,8 @@ var Runtime = class _Runtime {
       if (!typedSavedVariables.has(saved)) await this.prepareVariable(state, name2, saved);
       await owner.ledger.checkpoint(this.signal);
     }
-    for (const frame of stateMonitor(state).overlayFrames()) for (const [name2, record3] of frame) {
-      const saved = record3;
+    for (const frame of stateMonitor(state).overlayFrames()) for (const [name2, record4] of frame) {
+      const saved = record4;
       if (!saved.superseded && !typedSavedVariables.has(saved)) await this.prepareVariable(state, name2, saved, true);
       await owner.ledger.checkpoint(this.signal);
     }
@@ -11805,7 +11904,7 @@ var Runtime = class _Runtime {
     let io = originalIO;
     let diagnosticFailure;
     try {
-      const execute2 = async () => {
+      const execute3 = async () => {
         if (command2.kind === "function") {
           if (state.profile === "sh" && specialBuiltinNames.has(command2.name)) {
             await this.diagnostic(io, `\`${command2.name}': is a special builtin`);
@@ -11958,7 +12057,7 @@ var Runtime = class _Runtime {
         }
         return status2;
       };
-      const status = await execute2();
+      const status = await execute3();
       await finishOutputs(status);
       return status;
     } catch (caught) {
@@ -12052,6 +12151,8 @@ var Runtime = class _Runtime {
     return value2;
   }
   async redirect(redirects, state, io, inputs, outputs, isolatedInlineInput = false, persistMoves = false, fileShortcut = false, line) {
+    this.signal.throwIfAborted();
+    if (redirects.length > this.budget.limits.maxRedirects) this.budget.fail("maxRedirects");
     io.descriptors ??= /* @__PURE__ */ new Map([
       [0, { input: io.stdin, ...io.stdinIsDefault === void 0 ? {} : { stdinIsDefault: io.stdinIsDefault } }],
       [1, { output: io.stdout }],
@@ -12072,8 +12173,8 @@ var Runtime = class _Runtime {
     if (io.stdout === closedSink) descriptors.delete(1);
     if (io.stderr === closedSink) descriptors.delete(2);
     const currentIO = () => {
-      const descriptor = descriptors.get(0)?.closed ? void 0 : descriptors.get(0);
-      const stdinIsDefault = descriptor?.input ? descriptor.stdinIsDefault : false;
+      const descriptor2 = descriptors.get(0)?.closed ? void 0 : descriptors.get(0);
+      const stdinIsDefault = descriptor2?.input ? descriptor2.stdinIsDefault : false;
       return {
         [invocationScope]: io[invocationScope],
         ...io.execution === void 0 ? {} : { execution: io.execution },
@@ -12082,7 +12183,7 @@ var Runtime = class _Runtime {
         ...io.scriptName === void 0 ? {} : { scriptName: io.scriptName },
         ...io.substitutionDiagnosticLine === void 0 ? {} : { substitutionDiagnosticLine: io.substitutionDiagnosticLine },
         ...io.substitutionDiagnosticLines === void 0 ? {} : { substitutionDiagnosticLines: io.substitutionDiagnosticLines },
-        stdin: descriptor?.input ?? closedSource,
+        stdin: descriptor2?.input ?? closedSource,
         ...stdinIsDefault === void 0 ? {} : { stdinIsDefault },
         stdout: descriptors.get(1)?.closed ? closedSink : descriptors.get(1)?.output ?? closedSink,
         stderr: descriptors.get(2)?.closed ? closedSink : descriptors.get(2)?.output ?? closedSink,
@@ -12124,20 +12225,20 @@ var Runtime = class _Runtime {
             const move = target.endsWith("-");
             if (move && !redirect.move) throw new Error(`${target}: ambiguous redirect`);
             const sourceDescriptor = Number(move ? target.slice(0, -1) : target);
-            const descriptor = descriptors.get(sourceDescriptor);
-            if (!descriptor || descriptor.closed || !move && (redirect.operator === "<&" ? !descriptor.input : !descriptor.output)) throw new Error(`${move ? sourceDescriptor : target}: Bad file descriptor`);
-            descriptors.set(redirect.descriptor, { ...descriptor });
+            const descriptor2 = descriptors.get(sourceDescriptor);
+            if (!descriptor2 || descriptor2.closed || !move && (redirect.operator === "<&" ? !descriptor2.input : !descriptor2.output)) throw new Error(`${move ? sourceDescriptor : target}: Bad file descriptor`);
+            descriptors.set(redirect.descriptor, { ...descriptor2 });
             if (move && sourceDescriptor !== redirect.descriptor) {
               descriptors.delete(sourceDescriptor);
-              if (persistMoves && !replaced.has(sourceDescriptor)) descriptor.closed = true;
+              if (persistMoves && !replaced.has(sourceDescriptor)) descriptor2.closed = true;
             }
           }
         } else {
           const path = resolvePath(state.cwd, target);
-          const options2 = { signal: this.signal };
+          const options3 = { signal: this.signal };
           if (redirect.operator === "<") {
-            await interruptible(this.fs.access(path, 4, options2), this.signal);
-            const stat = await interruptible(this.fs.stat(path, options2), this.signal);
+            await interruptible(this.fs.access(path, 4, options3), this.signal);
+            const stat = await interruptible(this.fs.stat(path, options3), this.signal);
             if (stat.type === "directory" && !fileShortcut) throw new Error(`${target}: Is a directory`);
             const source = stat.type === "directory" ? toByteSource("") : await fileInput(this.fs, path, this.budget.limits.maxInputBytes, this.signal);
             const input3 = new ShellInput(source, this.budget, this.signal);
@@ -12145,7 +12246,7 @@ var Runtime = class _Runtime {
             descriptors.set(redirect.descriptor, { input: input3, stdinIsDefault: false });
           } else {
             const append = redirect.operator === ">>";
-            const capabilities = await this.fs.capabilitiesFor?.(path, options2) ?? this.fs.capabilities;
+            const capabilities = await this.fs.capabilitiesFor?.(path, options3) ?? this.fs.capabilities;
             const random = capabilities.randomAccessWrite === true;
             let file;
             await this.fileOperation(path, async () => {
@@ -12158,8 +12259,8 @@ var Runtime = class _Runtime {
             let offset = 0;
             const incremental = async () => {
               await this.fileOperation(path, async () => {
-                if (append) await this.fs.appendFile(path, new Uint8Array(), options2);
-                else await this.fs.writeFile(path, new Uint8Array(), { ...options2, flag: "w" });
+                if (append) await this.fs.appendFile(path, new Uint8Array(), options3);
+                else await this.fs.writeFile(path, new Uint8Array(), { ...options3, flag: "w" });
                 if (!append) file.data = new Uint8Array();
               });
               return { write: (chunk) => {
@@ -12167,22 +12268,27 @@ var Runtime = class _Runtime {
                 return this.fileOperation(path, async () => {
                   if (closed) throw new Error("Output descriptor is closed");
                   const current = file.data;
-                  if (append) {
-                    await this.fs.appendFile(path, copy2, options2);
-                    if (current) {
-                      const bytes2 = new Uint8Array(current.length + copy2.length);
-                      bytes2.set(current);
-                      bytes2.set(copy2, current.length);
-                      file.data = bytes2;
+                  let atEOF = false;
+                  if (!append && current && offset === current.length && capabilities.append === true && capabilities.stat !== false) {
+                    try {
+                      atEOF = (await interruptible(this.fs.stat(path, options3), this.signal)).size === offset;
+                    } catch {
+                      this.signal.throwIfAborted();
                     }
+                    this.signal.throwIfAborted();
+                  }
+                  if (append || atEOF) {
+                    const bytes2 = current ? appendOutputBytes(current, copy2) : void 0;
+                    await this.fs.appendFile(path, copy2, options3);
+                    file.data = bytes2;
                   } else {
                     const bytes2 = new Uint8Array(Math.max(current?.length ?? 0, offset + copy2.length));
                     if (current) bytes2.set(current);
                     bytes2.set(copy2, offset);
-                    await this.fs.writeFile(path, bytes2, options2);
+                    await this.fs.writeFile(path, bytes2, options3);
                     file.data = bytes2;
-                    offset += copy2.length;
                   }
+                  if (!append) offset += copy2.length;
                 });
               } };
             };
@@ -12448,8 +12554,8 @@ var Runtime = class _Runtime {
       fs: this.fs,
       signal: this.commandSignal,
       registerCleanup: (cleanup) => scope.register(cleanup),
-      invoke: (name3, args, options2) => {
-        const invocation = this.invoke(name3, args, options2, context, state, scope);
+      invoke: (name3, args, options3) => {
+        const invocation = this.invoke(name3, args, options3, context, state, scope);
         void invocation.catch(() => void 0);
         return invocation;
       }
@@ -12465,7 +12571,7 @@ var Runtime = class _Runtime {
       });
       return this.observeRuntimeReturn(raw, runtimeFrame, () => downstream);
     });
-    const execute2 = composeMiddleware(middleware, (forwarded) => scope.run(async () => {
+    const execute3 = composeMiddleware(middleware, (forwarded) => scope.run(async () => {
       scope.assertOpen();
       const forwardedValues = getCommandArguments(forwarded);
       const admitted = forwardedValues === argumentValues ? argumentValues : this.admitArguments(forwardedValues.values, allocation);
@@ -12678,7 +12784,7 @@ var Runtime = class _Runtime {
       }
     }));
     try {
-      return validateExitCode((await interruptible(execute2(context), this.signal)).exitCode);
+      return validateExitCode((await interruptible(execute3(context), this.signal)).exitCode);
     } catch (error) {
       if (builtinFailure && error === builtinFailure.error) throw new ExecutionFailure(error, io, builtinFailure.diagnostic);
       if (runtimeFrame.report && Object.is(runtimeFrame.report.origin.signal.reason, error) && this.outcomeFrame) {
@@ -12812,10 +12918,10 @@ ${functionDisplay(name2, state.functions.get(name2))}`;
       const target = component === void 0 ? name2 : `${component || "."}${component?.endsWith("/") ? "" : "/"}${name2}`;
       const resolved = resolvePath(state.cwd, target);
       try {
-        const options2 = { signal: this.signal };
-        if ((await interruptible(this.fs.stat(resolved, options2), this.signal)).type !== "file") continue;
+        const options3 = { signal: this.signal };
+        if ((await interruptible(this.fs.stat(resolved, options3), this.signal)).type !== "file") continue;
         if (this.fs.capabilities.permissions !== true) throw new CommandFailure(`${target}: execution permissions are not supported by this filesystem`, 126);
-        await interruptible(this.fs.access(resolved, ACCESS_MODES.X_OK, options2), this.signal);
+        await interruptible(this.fs.access(resolved, ACCESS_MODES.X_OK, options3), this.signal);
         matches.push(target);
         if (!all) return matches;
       } catch (error) {
@@ -13039,8 +13145,8 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         stderr: this.budget.sink(incoming.stderr, runtime.signal),
         signal: this.commandSignal,
         registerCleanup: (cleanup) => scope.register(cleanup),
-        invoke: (name2, args, options2) => {
-          const invocation = invocationOverride.current ? invocationOverride.current(name2, args, options2) : runtime.invoke(name2, args, options2, context, child, scope);
+        invoke: (name2, args, options3) => {
+          const invocation = invocationOverride.current ? invocationOverride.current(name2, args, options3) : runtime.invoke(name2, args, options3, context, child, scope);
           void invocation.catch(() => void 0);
           return invocation;
         }
@@ -13060,7 +13166,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         });
         return runtime.observeRuntimeReturn(raw, runtimeFrame, () => downstream);
       });
-      const execute2 = composeMiddleware(middleware, async () => {
+      const execute3 = composeMiddleware(middleware, async () => {
         scope.assertOpen();
         const forwardedValues = getCommandArguments(context);
         const admitted = forwardedValues === argumentValues ? argumentValues : runtime.admitArguments(forwardedValues.values, allocation);
@@ -13071,7 +13177,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         return await runtime.observeRuntimeReturn(raw, runtimeFrame);
       });
       try {
-        const result = await interruptible(execute2(context), runtime.signal);
+        const result = await interruptible(execute3(context), runtime.signal);
         runtime.signal.throwIfAborted();
         return validateExitCode(result.exitCode);
       } catch (error) {
@@ -13084,8 +13190,8 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       if (ownsScope) await scope.close();
     }
   }
-  shebangTarget(context, state, io, command2, args, options2, target, loadedSource) {
-    return this.invokeChild(options2, state, io[invocationScope], () => {
+  shebangTarget(context, state, io, command2, args, options3, target, loadedSource) {
+    return this.invokeChild(options3, state, io[invocationScope], () => {
       this.signal.throwIfAborted();
       io[invocationScope].assertOpen();
       if (typeof command2 !== "string" || command2.includes("\0") || !Array.isArray(args) || args.some((argument) => typeof argument !== "string" || argument.includes("\0"))) {
@@ -13096,14 +13202,14 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       for (const argument of [command2, ...args]) {
         if (import_buffer.Buffer.byteLength(argument) > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
       }
-    }, (runtime, scope) => runtime.shebangTargetScoped(context, state, io, command2, args, options2, target, loadedSource, scope));
+    }, (runtime, scope) => runtime.shebangTargetScoped(context, state, io, command2, args, options3, target, loadedSource, scope));
   }
-  async shebangTargetScoped(context, state, io, command2, args, options2, target, loadedSource, scope) {
+  async shebangTargetScoped(context, state, io, command2, args, options3, target, loadedSource, scope) {
     const reserved = command2 === "bash" || command2 === "sh";
     const direct = command2.includes("/");
     const definition = this.commands.get(command2);
     const child = await this.shebangState(context, state);
-    child.cwd = resolvePath(context.cwd, options2.cwd ?? ".");
+    child.cwd = resolvePath(context.cwd, options3.cwd ?? ".");
     if (!reserved) {
       if (child.depth >= this.budget.limits.maxSubstitutionDepth) this.budget.fail("maxSubstitutionDepth");
       child.depth++;
@@ -13112,18 +13218,18 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       child.sourceDepth = 0;
       child.locals = [];
     }
-    const stdinIsDefault = options2.stdin === void 0 ? context.stdinIsDefault : options2.stdinIsDefault ?? false;
-    const argumentValues = getCommandArguments({ args, ...options2.argumentValues ? { argumentValues: options2.argumentValues } : {} });
+    const stdinIsDefault = options3.stdin === void 0 ? context.stdinIsDefault : options3.stdinIsDefault ?? false;
+    const argumentValues = getCommandArguments({ args, ...options3.argumentValues ? { argumentValues: options3.argumentValues } : {} });
     const selected = {
       ...context,
       command: command2,
       args: argumentValues.args,
       argumentValues,
       cwd: child.cwd,
-      env: options2.replaceEnv ? { ...options2.env } : { ...context.env, ...options2.env, PWD: child.cwd },
-      stdin: options2.stdin ?? context.stdin,
-      stdout: options2.stdout ?? context.stdout,
-      stderr: options2.stderr ?? context.stderr,
+      env: options3.replaceEnv ? { ...options3.env } : { ...context.env, ...options3.env, PWD: child.cwd },
+      stdin: options3.stdin ?? context.stdin,
+      stdout: options3.stdout ?? context.stdout,
+      stderr: options3.stderr ?? context.stderr,
       ...stdinIsDefault === void 0 ? {} : { stdinIsDefault }
     };
     const exitCode = await this.shebangStage(selected, child, io, async (runtime, forwarded, state2, childIO) => {
@@ -13139,7 +13245,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       await writeText(forwarded.stderr, `env: ${command2}: command not found
 `);
       return { exitCode: 127 };
-    }, void 0, options2.stdin !== context.stdin ? options2.stdin : void 0, scope);
+    }, void 0, options3.stdin !== context.stdin ? options3.stdin : void 0, scope);
     return { exitCode };
   }
   async envShebang(context, state, io, optionalArgument, target, args, loadedSource) {
@@ -13160,8 +13266,8 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       let failureReport;
       const result = await interruptible(Promise.resolve(definition.execute({
         ...forwarded,
-        invoke: (command2, arguments_, options2) => {
-          const raw = forwarded.invoke(command2, arguments_, options2);
+        invoke: (command2, arguments_, options3) => {
+          const raw = forwarded.invoke(command2, arguments_, options3);
           return raw.catch((error) => {
             failed = true;
             failure = error;
@@ -13176,7 +13282,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         throw failure;
       }
       return { exitCode: validateExitCode(result.exitCode) };
-    }, (runtime, forwarded, child, childIO) => (command2, arguments_, options2 = {}) => runtime.shebangTarget(forwarded, child, childIO, command2, arguments_, options2, target, loadedSource));
+    }, (runtime, forwarded, child, childIO) => (command2, arguments_, options3 = {}) => runtime.shebangTarget(forwarded, child, childIO, command2, arguments_, options3, target, loadedSource));
   }
   async scriptFile(context, state, io, target, args, direct, errexit = false, loadedSource) {
     if (target === "") throw new CommandFailure(`${context.command}: : No such file or directory`, 127);
@@ -13188,14 +13294,14 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     try {
       if (loadedSource?.path === path) source = loadedSource.source;
       else {
-        const options2 = { signal: this.signal };
-        const stat = await interruptible(this.fs.stat(path, options2), this.signal);
+        const options3 = { signal: this.signal };
+        const stat = await interruptible(this.fs.stat(path, options3), this.signal);
         if (stat.type !== "file") throw new CommandFailure(`${target}: ${stat.type === "directory" ? "Is a directory" : "not a regular file"}`, 126);
         if (direct && this.fs.capabilities.permissions !== true) throw new CommandFailure(`${target}: execution permissions are not supported by this filesystem`, 126);
-        await interruptible(this.fs.access(path, ACCESS_MODES.R_OK | (direct ? ACCESS_MODES.X_OK : 0), options2), this.signal);
+        await interruptible(this.fs.access(path, ACCESS_MODES.R_OK | (direct ? ACCESS_MODES.X_OK : 0), options3), this.signal);
         const maxBytes = this.budget.limits.maxSourceBytes - this.budget.sourceBytes;
         if (stat.size > maxBytes) this.budget.fail("maxSourceBytes");
-        const bytes2 = await interruptible(this.fs.readFile(path, { ...options2, maxBytes }), this.signal);
+        const bytes2 = await interruptible(this.fs.readFile(path, { ...options3, maxBytes }), this.signal);
         this.budget.source(bytes2.byteLength);
         source = this.sourceText(bytes2, target);
       }
@@ -13322,7 +13428,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     let target = filename;
     let source;
     try {
-      const options2 = { signal: this.signal };
+      const options3 = { signal: this.signal };
       if (filename && !filename.includes("/") && state.variables.PATH) {
         if (import_buffer.Buffer.byteLength(state.variables.PATH) > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
         const components = state.variables.PATH.split(":");
@@ -13333,8 +13439,8 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
           const candidate = `${component || "."}${component.endsWith("/") ? "" : "/"}${filename}`;
           const path2 = resolvePath(state.cwd, candidate);
           try {
-            if ((await interruptible(this.fs.stat(path2, options2), this.signal)).type !== "file") continue;
-            await interruptible(this.fs.access(path2, ACCESS_MODES.R_OK, options2), this.signal);
+            if ((await interruptible(this.fs.stat(path2, options3), this.signal)).type !== "file") continue;
+            await interruptible(this.fs.access(path2, ACCESS_MODES.R_OK, options3), this.signal);
             target = candidate;
             found = true;
             break;
@@ -13347,13 +13453,13 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       }
       if (!filename) throw new CommandFailure(": No such file or directory", 1);
       const path = resolvePath(state.cwd, target);
-      const stat = await interruptible(this.fs.stat(path, options2), this.signal);
+      const stat = await interruptible(this.fs.stat(path, options3), this.signal);
       if (stat.type === "directory") throw new CommandFailure(`${context.command}: ${target}: is a directory`, 1);
       if (stat.type !== "file") throw new CommandFailure(`${target}: not a regular file`, 1);
-      await interruptible(this.fs.access(path, ACCESS_MODES.R_OK, options2), this.signal);
+      await interruptible(this.fs.access(path, ACCESS_MODES.R_OK, options3), this.signal);
       const maxBytes = this.budget.limits.maxSourceBytes - this.budget.sourceBytes;
       if (stat.size > maxBytes) this.budget.fail("maxSourceBytes");
-      const bytes2 = await interruptible(this.fs.readFile(path, { ...options2, maxBytes }), this.signal);
+      const bytes2 = await interruptible(this.fs.readFile(path, { ...options3, maxBytes }), this.signal);
       this.budget.source(bytes2.byteLength);
       source = this.sourceText(bytes2, target);
     } catch (error) {
@@ -13418,22 +13524,22 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       }
     }
   }
-  invoke(name2, args, options2 = {}, context, state, parent) {
-    return this.invokeChild(options2, state, parent, () => {
+  invoke(name2, args, options3 = {}, context, state, parent) {
+    return this.invokeChild(options3, state, parent, () => {
       if (typeof name2 !== "string" || name2.includes("\0") || !Array.isArray(args) || args.some((arg) => typeof arg !== "string" || arg.includes("\0"))) {
         throw new TypeError("invoke requires a command and literal string arguments without NUL");
       }
       if (state.depth >= this.budget.limits.maxSubstitutionDepth) this.budget.fail("maxSubstitutionDepth");
-    }, (runtime, scope) => runtime.invokeScoped(name2, args, options2, context, state, scope));
+    }, (runtime, scope) => runtime.invokeScoped(name2, args, options3, context, state, scope));
   }
-  async invokeScoped(name2, args, options2, context, state, scope) {
+  async invokeScoped(name2, args, options3, context, state, scope) {
     this.signal.throwIfAborted();
     const allocation = this.budget.values.scope();
     scope.register(() => allocation.close());
-    const carrier = this.admitArguments(getCommandArguments({ args, ...options2.argumentValues ? { argumentValues: options2.argumentValues } : {} }).values, allocation);
+    const carrier = this.admitArguments(getCommandArguments({ args, ...options3.argumentValues ? { argumentValues: options3.argumentValues } : {} }).values, allocation);
     const child = await cloneState(state, this.signal);
-    child.cwd = resolvePath(context.cwd, options2.cwd ?? ".");
-    const env = options2.replaceEnv ? { ...options2.env } : { ...context.env, ...options2.env, PWD: child.cwd };
+    child.cwd = resolvePath(context.cwd, options3.cwd ?? ".");
+    const env = options3.replaceEnv ? { ...options3.env } : { ...context.env, ...options3.env, PWD: child.cwd };
     if (guestArrays(child) || Object.keys(env).some((key) => arrayStore(child)?.get(key))) await this.indexedEnvironment(child, env);
     else {
       for (const key of child.exported) delete child.variables[key];
@@ -13449,15 +13555,15 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     child.functionDepth = 0;
     child.sourceDepth = 0;
     child.locals = [];
-    const input3 = options2.stdin === void 0 ? void 0 : new ShellInput(options2.stdin, this.budget, this.signal);
-    const stdinIsDefault = options2.stdin === void 0 ? context.stdinIsDefault : options2.stdinIsDefault ?? false;
+    const input3 = options3.stdin === void 0 ? void 0 : new ShellInput(options3.stdin, this.budget, this.signal);
+    const stdinIsDefault = options3.stdin === void 0 ? context.stdinIsDefault : options3.stdinIsDefault ?? false;
     const io = {
       ...context,
       [invocationScope]: scope,
       stdin: input3 ?? context.stdin,
       ...stdinIsDefault === void 0 ? {} : { stdinIsDefault },
-      stdout: options2.stdout ? this.budget.sink(options2.stdout, this.signal) : context.stdout,
-      stderr: options2.stderr ? this.budget.sink(options2.stderr, this.signal) : context.stderr
+      stdout: options3.stdout ? this.budget.sink(options3.stdout, this.signal) : context.stdout,
+      stderr: options3.stderr ? this.budget.sink(options3.stderr, this.signal) : context.stderr
     };
     const command2 = {
       kind: "simple",
@@ -13505,8 +13611,8 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         else if (flag === "o" && position === option.length - 1) {
           const name2 = args[index + 1];
           if (name2 === void 0) {
-            const options2 = [["errexit", !!state.errexit], ["nounset", !!state.nounset], ["pipefail", state.pipefail]];
-            for (const [name3, active] of options2) await writeText(stdout, enabled ? `${name3}	${active ? "on" : "off"}
+            const options3 = [["errexit", !!state.errexit], ["nounset", !!state.nounset], ["pipefail", state.pipefail]];
+            for (const [name3, active] of options3) await writeText(stdout, enabled ? `${name3}	${active ? "on" : "off"}
 ` : `set ${active ? "-" : "+"}o ${name3}
 `);
           } else {
@@ -13537,7 +13643,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
   async letBuiltin(context, state) {
     this.signal.throwIfAborted();
     const { maxExpansionBytes: bytes2, maxExpansionFields: fields } = this.budget.limits;
-    const admit = (value3) => {
+    const admit2 = (value3) => {
       if (typeof value3 !== "string" || value3.includes("\0")) throw new CommandFailure("let: arguments must be strings without NUL", 2);
       if (value3.length > bytes2 || import_buffer.Buffer.byteLength(value3) > bytes2) this.budget.fail("maxExpansionBytes");
     };
@@ -13549,10 +13655,10 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     const { args } = context;
     if (!Array.isArray(args)) throw new CommandFailure("let: argument array required", 2);
     if (args.length + 1 > fields) this.budget.fail("maxExpansionFields");
-    admit(context.command);
+    admit2(context.command);
     for (let index = 0; index < args.length; index++) {
       this.signal.throwIfAborted();
-      admit(args[index]);
+      admit2(args[index]);
       if ((index + 1) % 128 === 0) await checkpoint();
     }
     if (args[0] === "--help") throw new CommandFailure("let: --help: unsupported option", 2);
@@ -13581,7 +13687,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
   async getoptsBuiltin(context, state) {
     this.signal.throwIfAborted();
     const { maxExpansionBytes: bytes2, maxExpansionFields: fields } = this.budget.limits;
-    const admit = (value2) => {
+    const admit2 = (value2) => {
       if (typeof value2 !== "string") throw new CommandFailure("getopts: arguments must be strings without NUL", 2);
       if (value2.length > bytes2 || import_buffer.Buffer.byteLength(value2) > bytes2) this.budget.fail("maxExpansionBytes");
       if (value2.includes("\0")) throw new CommandFailure("getopts: arguments must be strings without NUL", 2);
@@ -13593,10 +13699,10 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     };
     if (!Array.isArray(context.args)) throw new CommandFailure("getopts: argument array required", 2);
     if (context.args.length + 1 > fields) this.budget.fail("maxExpansionFields");
-    admit(context.command);
+    admit2(context.command);
     for (let index = 0; index < context.args.length; index++) {
       this.signal.throwIfAborted();
-      admit(context.args[index]);
+      admit2(context.args[index]);
       if ((index + 1) % 128 === 0) await checkpoint();
     }
     const offset = context.args[0] === "--" ? 1 : 0;
@@ -13615,7 +13721,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     if (args.length > fields) this.budget.fail("maxExpansionFields");
     for (let index = 0; index < args.length; index++) {
       this.signal.throwIfAborted();
-      admit(args[index]);
+      admit2(args[index]);
       if ((index + 1) % 128 === 0) await checkpoint();
     }
     const maxBytes = saturatedProduct(bytes2, saturatedSum(args.length, 1));
@@ -13976,14 +14082,14 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       const declarationArgs = [...args];
       let indexedLocal = false;
       if (command2 === "local") {
-        const options2 = localDeclarationOptions(declarationArgs, this.signal);
-        if (options2.error !== void 0) {
-          await writeText(stderr, `local: ${options2.error}: unsupported option
+        const options3 = localDeclarationOptions(declarationArgs, this.signal);
+        if (options3.error !== void 0) {
+          await writeText(stderr, `local: ${options3.error}: unsupported option
 `);
           return 2;
         }
-        indexedLocal = options2.indexed;
-        declarationArgs.splice(0, options2.offset);
+        indexedLocal = options3.indexed;
+        declarationArgs.splice(0, options3.offset);
         if (indexedLocal && declarationArgs.length === 0) {
           await writeText(stderr, "local: -a requires a variable name\n");
           return 2;
@@ -15178,15 +15284,15 @@ var ShellInput = class _ShellInput {
       return bytes2;
     });
   }
-  line(raw, options2) {
-    return this.#cursor.consume(this.signal, () => options2 ? this.readBounded(raw, options2) : this.readLine(raw));
+  line(raw, options3) {
+    return this.#cursor.consume(this.signal, () => options3 ? this.readBounded(raw, options3) : this.readLine(raw));
   }
-  async readBounded(raw, options2) {
+  async readBounded(raw, options3) {
     const text = new ReadText();
     let characters = 0;
     const escaped = /* @__PURE__ */ new Set();
     const decoder3 = new TextDecoder("utf-8", { fatal: true });
-    const delimiter = options2.delimiter ?? 10;
+    const delimiter = options3.delimiter ?? 10;
     let chunk = new Uint8Array();
     let offset = 0;
     let length = 0;
@@ -15194,7 +15300,7 @@ var ShellInput = class _ShellInput {
     let escapedCharacter = false;
     let units = 0;
     let pulls = 0;
-    let terminated = options2.count === 0;
+    let terminated = options3.count === 0;
     try {
       while (!terminated) {
         if (offset === chunk.length) {
@@ -15208,7 +15314,7 @@ var ShellInput = class _ShellInput {
           if (!chunk.length) continue;
         }
         const byte = chunk[offset++];
-        if (!options2.exact && !escaping && byte === delimiter) {
+        if (!options3.exact && !escaping && byte === delimiter) {
           terminated = true;
           break;
         }
@@ -15238,8 +15344,8 @@ var ShellInput = class _ShellInput {
           characters++;
           decodedCharacters++;
         }
-        units += options2.byteCount ? 1 : decodedCharacters;
-        if (units === options2.count) terminated = true;
+        units += options3.byteCount ? 1 : decodedCharacters;
+        if (units === options3.count) terminated = true;
       }
       decoder3.decode();
       return { value: text.finish(), escaped, terminated };
@@ -15349,7 +15455,7 @@ var RootInvocationCancellationOwner = class {
   assertAdmissionOpen() {
     if (!this.#admissionOpen) throw new Error("Root cancellation admission is closed");
   }
-  capture(execute2) {
+  capture(execute3) {
     return new Promise((resolve) => {
       let settled = false;
       let raw;
@@ -15371,7 +15477,7 @@ var RootInvocationCancellationOwner = class {
         });
       };
       try {
-        raw = Promise.resolve(execute2());
+        raw = Promise.resolve(execute3());
       } catch (reason) {
         settle({ kind: "throw", reason });
         return;
@@ -15412,12 +15518,12 @@ var Shell = class {
   #disposed = false;
   #disposal;
   #active = /* @__PURE__ */ new Set();
-  constructor(options2) {
-    if (!options2?.fs) throw new TypeError("Shell requires an explicit filesystem");
-    warnIfHostProcessEnv(options2.env);
-    resolveLimits(options2.limits);
-    this.#options = { ...options2, cwd: resolvePath("/", options2.cwd ?? "/"), env: { ...options2.env }, limits: { ...options2.limits } };
-    this.commands = options2.commands ?? new CommandRegistry();
+  constructor(options3) {
+    if (!options3?.fs) throw new TypeError("Shell requires an explicit filesystem");
+    warnIfHostProcessEnv(options3.env);
+    resolveLimits(options3.limits);
+    this.#options = { ...options3, cwd: resolvePath("/", options3.cwd ?? "/"), env: { ...options3.env }, limits: { ...options3.limits } };
+    this.commands = options3.commands ?? new CommandRegistry();
   }
   use(middleware) {
     if (this.#disposed) throw new Error("Shell is disposed");
@@ -15430,17 +15536,17 @@ var Shell = class {
       if (!middleware || typeof middleware.setup !== "function") throw new TypeError("Expected middleware or shell plugin");
       this.#ready = this.#ready.then(async () => {
         let active = true;
-        const admit = () => {
+        const admit2 = () => {
           if (this.#disposed && !active) throw new Error("Shell is disposed");
         };
         const host = {
           commands: this.commands,
           use: (middleware2) => {
-            admit();
+            admit2();
             this.#install(middleware2);
           },
           registerFileSystem: (scheme, factory) => {
-            admit();
+            admit2();
             this.#registerFileSystem(scheme, factory);
           }
         };
@@ -15454,9 +15560,9 @@ var Shell = class {
       void this.#ready.catch(() => void 0);
     }
   }
-  register(command2, options2) {
+  register(command2, options3) {
     if (this.#disposed) throw new Error("Shell is disposed");
-    this.commands.register(command2, options2);
+    this.commands.register(command2, options3);
     return this;
   }
   registerFileSystem(scheme, factory) {
@@ -15468,23 +15574,23 @@ var Shell = class {
     if (this.#filesystems.has(scheme)) throw new Error(`Filesystem already registered: ${scheme}`);
     this.#filesystems.set(scheme, factory);
   }
-  async createFileSystem(scheme, options2 = {}) {
+  async createFileSystem(scheme, options3 = {}) {
     if (this.#disposed) throw new Error("Shell is disposed");
     await this.#ready;
     const factory = this.#filesystems.get(scheme);
     if (!factory) throw new Error(`Unknown filesystem scheme: ${scheme}`);
-    return factory(options2);
+    return factory(options3);
   }
-  async exec(source, options2 = {}) {
+  async exec(source, options3 = {}) {
     if (this.#disposed) throw new Error("Shell is disposed");
-    warnIfHostProcessEnv(options2.env);
-    const budget = new Budget(resolveLimits(this.#options.limits, options2.limits), options2.signal);
-    const scope = new InvocationScope(options2.signal);
+    warnIfHostProcessEnv(options3.env);
+    const budget = new Budget(resolveLimits(this.#options.limits, options3.limits), options3.signal);
+    const scope = new InvocationScope(options3.signal);
     const cancellationState = new RuntimeCancellationState();
     const owner = new RootInvocationCancellationOwner(scope);
     const boundary = createRootCancellationLink({
       admission: Runtime.rootCancellationAdmission(budget),
-      callerSignal: options2.signal,
+      callerSignal: options3.signal,
       controls: [{ role: "budget-control", signal: budget.controller.signal }]
     });
     try {
@@ -15499,7 +15605,7 @@ var Shell = class {
     this.#active.add(active);
     let captured;
     try {
-      captured = await owner.capture(() => this.#execute(source, options2, scope, budget, boundary, cancellationState, owner));
+      captured = await owner.capture(() => this.#execute(source, options3, scope, budget, boundary, cancellationState, owner));
     } finally {
       budget.close();
       await scope.close();
@@ -15511,7 +15617,7 @@ var Shell = class {
     throwCleanupFailures(scope.failures);
     return selection.outcome.value;
   }
-  async #execute(source, options2, scope, budget, cancellation, cancellationState, owner) {
+  async #execute(source, options3, scope, budget, cancellation, cancellationState, owner) {
     if (typeof source !== "string") throw new TypeError("Shell source must be a string");
     if (import_buffer.Buffer.byteLength(source) > budget.limits.maxSourceBytes) throw new ShellLimitError("maxSourceBytes");
     budget.source(import_buffer.Buffer.byteLength(source));
@@ -15535,20 +15641,20 @@ var Shell = class {
     const io = {
       [invocationScope]: scope,
       stdin: toByteSource(""),
-      stdinIsDefault: options2.stdin === void 0,
-      stdout: sink(stdout, options2.stdout),
-      stderr: sink(stderr, options2.stderr)
+      stdinIsDefault: options3.stdin === void 0,
+      stdout: sink(stdout, options3.stdout),
+      stderr: sink(stderr, options3.stderr)
     };
     let exitCode;
     let failed = false;
     try {
       try {
-        let unit = parseShellUnit(source, 0, byteLocale({ ...this.#options.env, ...options2.env }));
-        stdin = new ShellInput(typeof options2.stdin === "string" || options2.stdin instanceof Uint8Array ? toByteSource(options2.stdin) : options2.stdin ?? toByteSource(""), budget);
+        let unit = parseShellUnit(source, 0, byteLocale({ ...this.#options.env, ...options3.env }));
+        stdin = new ShellInput(typeof options3.stdin === "string" || options3.stdin instanceof Uint8Array ? toByteSource(options3.stdin) : options3.stdin ?? toByteSource(""), budget);
         io.stdin = stdin;
         await interruptible(this.#ready, budget.signal);
-        const cwd = resolvePath("/", options2.cwd ?? this.#options.cwd ?? "/");
-        const variables = Object.assign(/* @__PURE__ */ Object.create(null), this.#options.env, options2.env, { PWD: cwd });
+        const cwd = resolvePath("/", options3.cwd ?? this.#options.cwd ?? "/");
+        const variables = Object.assign(/* @__PURE__ */ Object.create(null), this.#options.env, options3.env, { PWD: cwd });
         for (const [name2, value2] of Object.entries(variables)) {
           if (name2.includes("\0") || name2.includes("=") || typeof value2 !== "string" || value2.includes("\0")) throw new TypeError("Invalid environment entry");
         }
@@ -15575,7 +15681,7 @@ var Shell = class {
         };
         const admission = Runtime.rootCancellationAdmission(budget);
         const runtime = new Runtime(
-          options2.fs ?? this.#options.fs,
+          options3.fs ?? this.#options.fs,
           this.commands,
           [...this.#middleware],
           budget,
@@ -15629,8 +15735,8 @@ shell: -c: line ${line}: \`${source.split("\n")[line - 1] ?? ""}'
       });
       else await stdin?.close();
     }
-    const stdoutBytes = stdout.bytes();
-    const stderrBytes = stderr.bytes();
+    const stdoutBytes = stdout.takeBytes();
+    const stderrBytes = stderr.takeBytes();
     return {
       stdout: new TextDecoder("utf-8", { ignoreBOM: true }).decode(stdoutBytes),
       stderr: new TextDecoder("utf-8", { ignoreBOM: true }).decode(stderrBytes),
@@ -15680,6 +15786,7 @@ var cloudflareWorkerLimits = Object.freeze({
   maxInputBytes: 4 * 1024 * 1024,
   maxOutputBytes: 4 * 1024 * 1024,
   maxCommands: 1e3,
+  maxRedirects: 64,
   maxPipelineStages: 64,
   maxLoopIterations: 1e3,
   maxSubstitutionDepth: 16,
@@ -15761,8 +15868,8 @@ function requestBody(source, signal) {
     }
   });
 }
-function createFetchTransport(options2 = {}) {
-  const fetchRequest = options2.fetch ?? globalThis.fetch;
+function createFetchTransport(options3 = {}) {
+  const fetchRequest = options3.fetch ?? globalThis.fetch;
   if (typeof fetchRequest !== "function") throw new TypeError("Fetch is unavailable");
   return async (input3) => {
     input3.signal.throwIfAborted();
@@ -15829,7 +15936,7 @@ function privateHostname(input3) {
   const [first, second] = octets;
   return first === 10 || first === 127 || first === 0 || first === 169 && second === 254 || first === 192 && second === 168 || first === 172 && second >= 16 && second <= 31;
 }
-function createOriginAuthorizer(allowlist = "*", options2 = {}) {
+function createOriginAuthorizer(allowlist = "*", options3 = {}) {
   const origins = /* @__PURE__ */ new Set();
   const hosts = /* @__PURE__ */ new Set();
   for (const entry of allowlist === "*" ? [] : allowlist) {
@@ -15849,7 +15956,7 @@ function createOriginAuthorizer(allowlist = "*", options2 = {}) {
   return (request) => {
     const url = new URL(request.url);
     const hostname = url.hostname.toLowerCase().replace(/\.$/u, "");
-    if (options2.denyPrivateNetworks && privateHostname(hostname)) return false;
+    if (options3.denyPrivateNetworks && privateHostname(hostname)) return false;
     return allowlist === "*" || origins.has(url.origin) || hosts.has(hostname);
   };
 }
@@ -15899,25 +16006,25 @@ var ExprMatchError = class extends Error {
 function exactObject(value2, keys) {
   return value2 !== null && typeof value2 === "object" && !Array.isArray(value2) && Object.keys(value2).length === keys.length && keys.every((key) => Object.hasOwn(value2, key));
 }
-function validateExprInput(descriptor, rows, signal) {
+function validateExprInput(descriptor2, rows, signal) {
   signal.throwIfAborted();
   const invalid = () => {
     throw new RegexExecutionError("PROTOCOL", "invalid expr request");
   };
-  if (!exactObject(descriptor, ["kind", "pattern", "profile", "limits"]) || descriptor.kind !== "expr-match" || !(descriptor.pattern instanceof Uint8Array) || !["byte", "utf8-scalar"].includes(descriptor.profile)) invalid();
+  if (!exactObject(descriptor2, ["kind", "pattern", "profile", "limits"]) || descriptor2.kind !== "expr-match" || !(descriptor2.pattern instanceof Uint8Array) || !["byte", "utf8-scalar"].includes(descriptor2.profile)) invalid();
   const keys = Object.keys(exprMatchCeilings);
-  if (!exactObject(descriptor.limits, keys)) invalid();
+  if (!exactObject(descriptor2.limits, keys)) invalid();
   for (const key of keys) {
-    if (!Number.isSafeInteger(descriptor.limits[key]) || descriptor.limits[key] < 1 || descriptor.limits[key] > exprMatchCeilings[key]) invalid();
+    if (!Number.isSafeInteger(descriptor2.limits[key]) || descriptor2.limits[key] < 1 || descriptor2.limits[key] > exprMatchCeilings[key]) invalid();
   }
   if (!Array.isArray(rows) || rows.length !== 1) invalid();
   const row = rows[0];
   if (!exactObject(row, ["bytes", "all", "terminated"]) || !(row.bytes instanceof Uint8Array) || row.all !== false || row.terminated !== false) invalid();
-  if (descriptor.pattern.length > descriptor.limits.maxPatternBytes || row.bytes.length > descriptor.limits.maxSubjectBytes) {
+  if (descriptor2.pattern.length > descriptor2.limits.maxPatternBytes || row.bytes.length > descriptor2.limits.maxSubjectBytes) {
     throw new ExprMatchError("limit", "regex input bytes limit exceeded");
   }
 }
-function validateExprReply(value2, id, descriptor, subject, signal) {
+function validateExprReply(value2, id, descriptor2, subject, signal) {
   signal.throwIfAborted();
   const invalid = () => {
     throw new RegexExecutionError("PROTOCOL", "invalid expr reply");
@@ -15931,13 +16038,13 @@ function validateExprReply(value2, id, descriptor, subject, signal) {
   }
   if (!exactObject(reply, ["id", "operation", "result"])) return invalid();
   const result = reply.result;
-  if (!exactObject(result, ["offsetUnit", "matched", "hasCapture", "overall", "capture", "steps"]) || result.offsetUnit !== "byte" || typeof result.matched !== "boolean" || typeof result.hasCapture !== "boolean" || !Number.isSafeInteger(result.steps) || result.steps < 1 || result.steps > descriptor.limits.maxSteps) return invalid();
+  if (!exactObject(result, ["offsetUnit", "matched", "hasCapture", "overall", "capture", "steps"]) || result.offsetUnit !== "byte" || typeof result.matched !== "boolean" || typeof result.hasCapture !== "boolean" || !Number.isSafeInteger(result.steps) || result.steps < 1 || result.steps > descriptor2.limits.maxSteps) return invalid();
   const span = (value3) => {
     if (value3 === null) return null;
     if (!exactObject(value3, ["start", "end"]) || !Number.isSafeInteger(value3.start) || !Number.isSafeInteger(value3.end)) return invalid();
     const start = value3.start, end = value3.end;
     if (start < 0 || end < start || end > subject.length) return invalid();
-    if (descriptor.profile === "utf8-scalar") {
+    if (descriptor2.profile === "utf8-scalar") {
       for (const offset of [start, end]) if (offset < subject.length && subject[offset] >= 128 && subject[offset] <= 191) return invalid();
     }
     return { start, end };
@@ -15946,8 +16053,8 @@ function validateExprReply(value2, id, descriptor, subject, signal) {
   if (result.matched !== (overall !== null) || overall && overall.start !== 0 || capture && (!result.hasCapture || !overall || capture.start < overall.start || capture.end > overall.end)) return invalid();
   return { offsetUnit: "byte", matched: result.matched, hasCapture: result.hasCapture, overall, capture, steps: result.steps };
 }
-function policy(options2) {
-  const result = { ...defaults, ...options2 };
+function policy(options3) {
+  const result = { ...defaults, ...options3 };
   for (const key of Object.keys(defaults)) {
     const minimum = key === "maxQueuedRequests" || key === "maxQueuedBytes" ? 0 : 1;
     if (!Number.isSafeInteger(result[key]) || result[key] < minimum) throw new RangeError(`regex ${key} must be a safe integer >= ${minimum}`);
@@ -15957,9 +16064,9 @@ function policy(options2) {
   }
   return Object.freeze(result);
 }
-function inputBytes(descriptor, rows, signal) {
-  let total = 128 + (descriptor.kind === "glob" ? descriptor.globOptions.length * 32 : 0);
-  for (const pattern of descriptor.patterns) {
+function inputBytes(descriptor2, rows, signal) {
+  let total = 128 + (descriptor2.kind === "glob" ? descriptor2.globOptions.length * 32 : 0);
+  for (const pattern of descriptor2.patterns) {
     signal.throwIfAborted();
     total += 16 + pattern.length * 2;
     if (!Number.isSafeInteger(total)) throw new RegexExecutionError("QUEUE_EXHAUSTED", "input accounting overflow");
@@ -16004,7 +16111,7 @@ async function awaitRetirements(retirements) {
   if (failures.length === 1) throw failures[0];
   if (failures.length > 1) throw new AggregateError(failures, "regex retirement failed");
 }
-async function withRegexSession(context, executor, execute2) {
+async function withRegexSession(context, executor, execute3) {
   context.signal.throwIfAborted();
   let session;
   let closing;
@@ -16022,7 +16129,7 @@ async function withRegexSession(context, executor, execute2) {
     context.signal.throwIfAborted();
     if (closing) throw new RegexExecutionError("CLOSED", "invocation is closed");
     session = executor.open(context.signal);
-    outcome = { result: await execute2(session) };
+    outcome = { result: await execute3(session) };
   } catch (error) {
     outcome = { error };
   }
@@ -16114,10 +16221,10 @@ var Slot = class {
   }
 };
 var RegexExecutor = class {
-  constructor(provider, options2 = defaults) {
+  constructor(provider, options3 = defaults) {
     this.provider = provider;
     if (!provider || typeof provider.createWorker !== "function") throw new TypeError("a bounded regex provider is required");
-    this.options = policy(options2);
+    this.options = policy(options3);
   }
   provider;
   options;
@@ -16152,21 +16259,21 @@ var RegexExecutor = class {
     this.slots.delete(slot);
     this.pump();
   }
-  request(descriptor, rows, signal, retirements = /* @__PURE__ */ new Set()) {
+  request(descriptor2, rows, signal, retirements = /* @__PURE__ */ new Set()) {
     signal.throwIfAborted();
     if (this.disposed) return Promise.reject(new RegexExecutionError("CLOSED", "executor is disposed"));
-    if (descriptor.kind === "expr-match") validateExprInput(descriptor, rows, signal);
-    const bytes2 = descriptor.kind === "expr-match" ? 256 + descriptor.pattern.length + rows[0].bytes.length : inputBytes(descriptor, rows, signal);
+    if (descriptor2.kind === "expr-match") validateExprInput(descriptor2, rows, signal);
+    const bytes2 = descriptor2.kind === "expr-match" ? 256 + descriptor2.pattern.length + rows[0].bytes.length : inputBytes(descriptor2, rows, signal);
     const available = this.queue.length === 0 && ([...this.slots].some((slot) => !slot.busy && !slot.retired) || this.slots.size < this.options.maxWorkers);
     if (!available && (this.queue.length >= this.options.maxQueuedRequests || bytes2 > this.options.maxQueuedBytes - this.queuedBytes)) return Promise.reject(new RegexExecutionError("QUEUE_EXHAUSTED", "queued request count or input byte limit exceeded"));
-    const ownedDescriptor = descriptor.kind === "expr-match" ? { ...descriptor, pattern: Uint8Array.from(descriptor.pattern), limits: { ...descriptor.limits } } : { ...descriptor, patterns: descriptor.patterns.map((pattern) => {
+    const ownedDescriptor = descriptor2.kind === "expr-match" ? { ...descriptor2, pattern: Uint8Array.from(descriptor2.pattern), limits: { ...descriptor2.limits } } : { ...descriptor2, patterns: descriptor2.patterns.map((pattern) => {
       signal.throwIfAborted();
       return pattern;
     }) };
     if (ownedDescriptor.kind === "glob") {
-      const globOptions = ownedDescriptor.globOptions.map((options2) => {
+      const globOptions = ownedDescriptor.globOptions.map((options3) => {
         signal.throwIfAborted();
-        return { ...options2 };
+        return { ...options3 };
       });
       Object.assign(ownedDescriptor, { globOptions });
     }
@@ -16284,18 +16391,18 @@ var RegexSession = class {
   retirements = /* @__PURE__ */ new Set();
   controller = new AbortController();
   requestSignal;
-  run(descriptor, rows) {
+  run(descriptor2, rows) {
     this.signal.throwIfAborted();
     if (this.closed) throw new RegexExecutionError("CLOSED", "invocation is closed");
-    const result = this.executor.request(descriptor, rows, this.requestSignal, this.retirements);
+    const result = this.executor.request(descriptor2, rows, this.requestSignal, this.retirements);
     this.pending.add(result);
     void result.then(() => this.pending.delete(result), () => this.pending.delete(result));
     return result;
   }
-  matchExpr(descriptor, subject) {
+  matchExpr(descriptor2, subject) {
     this.signal.throwIfAborted();
     if (this.closed) throw new RegexExecutionError("CLOSED", "invocation is closed");
-    const result = this.executor.request(descriptor, [{ bytes: subject, all: false, terminated: false }], this.requestSignal, this.retirements);
+    const result = this.executor.request(descriptor2, [{ bytes: subject, all: false, terminated: false }], this.requestSignal, this.retirements);
     this.pending.add(result);
     void result.then(() => this.pending.delete(result), () => this.pending.delete(result));
     return result;
@@ -16428,10 +16535,10 @@ async function* requiredFileInput(context, requirements, mode, file, maxBytes) {
 var ProgramError = class extends Error {
 };
 var Budget3 = class {
-  constructor(context, options2) {
+  constructor(context, options3) {
     this.context = context;
-    this.remaining = options2.maxSteps ?? 5e6;
-    this.maxBufferBytes = options2.maxBufferBytes ?? 32 * 1024 * 1024;
+    this.remaining = options3.maxSteps ?? 5e6;
+    this.maxBufferBytes = options3.maxBufferBytes ?? 32 * 1024 * 1024;
     for (const value2 of [this.remaining, this.maxBufferBytes]) {
       if (!Number.isSafeInteger(value2) || value2 < 1) throw new ProgramError("limits must be positive safe integers");
     }
@@ -16440,6 +16547,7 @@ var Budget3 = class {
   maxBufferBytes;
   remaining;
   checkpoints = 0;
+  lastYield = monotonicNow();
   step(count2 = 1) {
     this.context.signal.throwIfAborted();
     this.remaining -= count2;
@@ -16450,7 +16558,11 @@ var Budget3 = class {
     return text;
   }
   async checkpoint() {
-    if (++this.checkpoints % 256 === 0) await yieldTurn(this.context.signal);
+    this.context.signal.throwIfAborted();
+    if (++this.checkpoints % 256 === 0 || monotonicNow() - this.lastYield >= 25) {
+      await yieldTurn(this.context.signal);
+      this.lastYield = monotonicNow();
+    }
     this.context.signal.throwIfAborted();
   }
 };
@@ -17048,10 +17160,10 @@ async function execute(program, context, files, quiet, budget) {
     following = void 0;
     return next;
   };
-  const prepareRecord = async (record3) => {
-    if (record3.terminated || files.length < 2) return record3;
+  const prepareRecord = async (record4) => {
+    if (record4.terminated || files.length < 2) return record4;
     const next = await peekNext();
-    return !next.done && next.value.fileIndex !== record3.fileIndex ? { ...record3, terminated: true } : record3;
+    return !next.done && next.value.fileIndex !== record4.fileIndex ? { ...record4, terminated: true } : record4;
   };
   let number = 0;
   let hold = "";
@@ -17066,8 +17178,8 @@ async function execute(program, context, files, quiet, budget) {
     while (!current.done) {
       budget.step();
       number++;
-      let record3 = await prepareRecord(current.value);
-      let pattern = record3.text;
+      let record4 = await prepareRecord(current.value);
+      let pattern = record4.text;
       const appended = [];
       let appendedSize = 0;
       const append = (item) => {
@@ -17079,7 +17191,7 @@ async function execute(program, context, files, quiet, budget) {
       let deleted = false;
       let quit = false;
       let status = 0;
-      const print = () => write(context, pattern + (record3.terminated ? "\n" : ""));
+      const print = () => write(context, pattern + (record4.terminated ? "\n" : ""));
       const flush = async () => {
         await assertPathRequirements(context, sedRequirements, ["script-read"], appended.flatMap((item) => item.file === void 0 ? [] : [item.file]));
         if (!quiet && !deleted) await print();
@@ -17140,7 +17252,7 @@ async function execute(program, context, files, quiet, budget) {
             break;
           case "P": {
             const end = pattern.indexOf("\n");
-            await write(context, end < 0 ? pattern + (record3.terminated ? "\n" : "") : pattern.slice(0, end + 1));
+            await write(context, end < 0 ? pattern + (record4.terminated ? "\n" : "") : pattern.slice(0, end + 1));
             break;
           }
           case "=":
@@ -17230,9 +17342,16 @@ async function execute(program, context, files, quiet, budget) {
             }
             break;
           }
-          case "y":
-            pattern = [...pattern].map((character) => instruction.translation.get(character) ?? character).join("");
+          case "y": {
+            budget.step(pattern.length);
+            const translated = import_buffer.Buffer.allocUnsafe(pattern.length);
+            for (let index = 0; index < pattern.length; index++) {
+              if (index % 256 === 0) await budget.checkpoint();
+              translated[index] = (instruction.translation.get(pattern[index]) ?? pattern[index]).charCodeAt(0);
+            }
+            pattern = translated.toString("latin1");
             break;
+          }
           case "b":
             pc = instruction.jump;
             continue;
@@ -17254,9 +17373,9 @@ async function execute(program, context, files, quiet, budget) {
               if (instruction.kind === "N") await flush();
               return { status: 0, quit: false };
             }
-            record3 = await prepareRecord(next.value);
+            record4 = await prepareRecord(next.value);
             number++;
-            pattern = instruction.kind === "N" ? budget.check(pattern + "\n" + record3.text) : record3.text;
+            pattern = instruction.kind === "N" ? budget.check(pattern + "\n" + record4.text) : record4.text;
             substituted = false;
             break;
           }
@@ -17272,9 +17391,9 @@ async function execute(program, context, files, quiet, budget) {
     await source.return(void 0);
   }
 }
-function sedCommand(options2 = {}) {
+function sedCommand(options3 = {}) {
   const definition = command("sed", async (context) => {
-    const budget = new Budget3(context, options2);
+    const budget = new Budget3(context, options3);
     const sources = [];
     const files = [];
     let quiet = false;
@@ -17370,6 +17489,7 @@ function sedCommand(options2 = {}) {
 
 // packages/safe-bash/src/commands/search/grep.ts
 init_platform();
+var maxPatternCount = 1024;
 function createGrepCommands(executor) {
   return [{ name: "grep", filesystemRequirements: grepRequirements, execute: (context) => withRegexSession(context, executor, async (session) => {
     try {
@@ -17382,20 +17502,46 @@ function createGrepCommands(executor) {
       const names = parsed.operands.length ? parsed.operands : ["-"];
       const patternFiles = parsed.values.get("f") ?? [];
       const patterns2 = [];
-      const addPatterns = (text, file) => {
-        if (file && text === "") return;
-        const parts = text.split("\n");
-        if (parts.length > 1 && parts.at(-1) === "") parts.pop();
-        patterns2.push(...parts);
+      let patternCount = 0;
+      let patternBytes = 0;
+      const admit2 = (chunk, atStart) => {
+        context.signal.throwIfAborted();
+        const size = typeof chunk === "string" ? import_buffer.Buffer.byteLength(chunk) : chunk.length;
+        if (size > bufferLimit - patternBytes) throw new UsageError(`pattern byte limit exceeded (${bufferLimit} bytes)`);
+        patternBytes += size;
+        for (let offset = 0; offset < chunk.length; ) {
+          if (atStart && ++patternCount > maxPatternCount) throw new UsageError(`pattern count limit exceeded (${maxPatternCount})`);
+          const newline = typeof chunk === "string" ? chunk.indexOf("\n", offset) : chunk.indexOf(10, offset);
+          if (newline < 0) return false;
+          offset = newline + 1;
+          atStart = true;
+        }
+        return atStart;
       };
-      for (const pattern of parsed.values.get("e") ?? []) addPatterns(import_buffer.Buffer.from(pattern).toString("latin1"), false);
+      const addArgument = async (pattern) => {
+        admit2(pattern, true);
+        if (pattern === "") {
+          if (++patternCount > maxPatternCount) throw new UsageError(`pattern count limit exceeded (${maxPatternCount})`);
+          patterns2.push("");
+        } else {
+          for await (const line of lines(toByteSource(pattern))) patterns2.push(import_buffer.Buffer.from(line.bytes).toString("latin1"));
+        }
+      };
+      async function* admitted(source) {
+        let atStart = true;
+        for await (const chunk of source) {
+          atStart = admit2(chunk, atStart);
+          yield chunk;
+        }
+      }
+      for (const pattern of parsed.values.get("e") ?? []) await addArgument(pattern);
       for (const name2 of patternFiles) {
-        const source = name2 === "-" ? input(context) : requiredFileInput(context, grepRequirements, "pattern-file", name2, bufferLimit);
-        addPatterns(import_buffer.Buffer.from(await collect(source, context.signal)).toString("latin1"), true);
+        const source = name2 === "-" ? input(context) : requiredFileInput(context, grepRequirements, "pattern-file", name2, bufferLimit - patternBytes);
+        for await (const line of lines(admitted(source))) patterns2.push(import_buffer.Buffer.from(line.bytes).toString("latin1"));
       }
-      if (positionalPattern !== void 0) addPatterns(import_buffer.Buffer.from(positionalPattern).toString("latin1"), false);
+      if (positionalPattern !== void 0) await addArgument(positionalPattern);
       if (parsed.flags.has("E") && parsed.flags.has("F")) throw new UsageError("conflicting matchers specified");
-      const descriptor = {
+      const descriptor2 = {
         kind: "grep",
         patterns: patterns2,
         fixed: parsed.flags.has("F"),
@@ -17404,7 +17550,7 @@ function createGrepCommands(executor) {
         whole: parsed.flags.has("x"),
         word: parsed.flags.has("w")
       };
-      await session.run(descriptor, []);
+      await session.run(descriptor2, []);
       const maxCount = value(parsed, "m") === void 0 ? Infinity : integer(value(parsed, "m"));
       const batchSize = Number.isFinite(maxCount) || parsed.flags.has("q") || parsed.flags.has("l") || parsed.flags.has("L") ? 1 : 128;
       const delimiter = parsed.flags.has("z") ? "\0" : "\n";
@@ -17419,7 +17565,7 @@ function createGrepCommands(executor) {
           const available = new AvailableRecords(parsed.flags.has("z") ? 0 : 10, bufferLimit);
           const source = name2 === "-" ? input(context) : requiredFileInput(context, grepRequirements, "file", name2, bufferLimit);
           records: if (maxCount > 0) for await (const batch of available.batches(lines(available.source(source), parsed.flags.has("z") ? 0 : 10), (line) => line.bytes.length, () => batchSize)) {
-            const results = await session.run(descriptor, batch.map((line) => ({ bytes: line.bytes, all: parsed.flags.has("o"), terminated: line.terminated })));
+            const results = await session.run(descriptor2, batch.map((line) => ({ bytes: line.bytes, all: parsed.flags.has("o"), terminated: line.terminated })));
             for (let index = 0; index < batch.length; index++) {
               const line = batch[index];
               context.signal.throwIfAborted();
@@ -17839,13 +17985,13 @@ function pathFor(context, path) {
 var OutputClosed = class extends SearchError {
 };
 var Limits = class {
-  constructor(context, options2) {
+  constructor(context, options3) {
     this.context = context;
     this.signal = AbortSignal.any([context.signal, this.stopped.signal]);
-    this.maxOutputBytes = options2.maxOutputBytes ?? 16 * 1024 * 1024;
-    this.maxLineBytes = options2.maxLineBytes ?? 1024 * 1024;
-    this.maxFileBytes = options2.maxFileBytes ?? 64 * 1024 * 1024;
-    this.maxFiles = options2.maxFiles ?? 1e5;
+    this.maxOutputBytes = options3.maxOutputBytes ?? 16 * 1024 * 1024;
+    this.maxLineBytes = options3.maxLineBytes ?? 1024 * 1024;
+    this.maxFileBytes = options3.maxFileBytes ?? 64 * 1024 * 1024;
+    this.maxFiles = options3.maxFiles ?? 1e5;
     for (const limit of [this.maxOutputBytes, this.maxLineBytes, this.maxFileBytes, this.maxFiles]) {
       if (!Number.isSafeInteger(limit) || limit < 1) throw new SearchError("search limits must be positive safe integers");
     }
@@ -18030,13 +18176,13 @@ async function matchGlobs(globs, candidates, session) {
       bytes2 += size;
       offset++;
     }
-    const descriptor = {
+    const descriptor2 = {
       kind: "glob",
       patterns: batch.map((glob) => glob.source),
       globOptions: batch.map((glob) => ({ insensitive: glob.insensitive, literalUnclosedClass: glob.literalUnclosedClass }))
     };
     try {
-      results.push(...(await session.run(descriptor, rows)).map((result) => result.length > 0));
+      results.push(...(await session.run(descriptor2, rows)).map((result) => result.length > 0));
     } catch (error) {
       if (error instanceof RegexExecutionError && error.code === "MATCH") throw new SearchError(error.message);
       throw error;
@@ -18235,10 +18381,10 @@ var Walker = class {
 };
 
 // packages/safe-bash/src/commands/search/rg-command.ts
-function selectInput(context, args, options2) {
+function selectInput(context, args, options3) {
   if (args.paths.length) return { paths: args.paths, implicit: false };
-  if (args.mode === "files" || options2.defaultInput === "cwd" || args.patternFiles.includes("-")) return { paths: ["."], implicit: true };
-  const stdin = options2.defaultInput === "stdin" || context.stdinIsDefault === false;
+  if (args.mode === "files" || options3.defaultInput === "cwd" || args.patternFiles.includes("-")) return { paths: ["."], implicit: true };
+  const stdin = options3.defaultInput === "stdin" || context.stdinIsDefault === false;
   return { paths: stdin ? ["-"] : ["."], implicit: !stdin };
 }
 async function patterns(context, args) {
@@ -18360,7 +18506,7 @@ async function searchFile(context, args, limits, matcher, printer, target, stdin
   }
   return { found, stats: totals };
 }
-function createRgCommand(executor, options2 = {}) {
+function createRgCommand(executor, options3 = {}) {
   return {
     name: "rg",
     filesystemRequirements: searchRequirements,
@@ -18371,12 +18517,12 @@ function createRgCommand(executor, options2 = {}) {
         let failed = false;
         let found = false;
         try {
-          const limits = new Limits(context, options2);
+          const limits = new Limits(context, options3);
           args = parse2(context.args);
           if (args.mode !== "files" && args.patternFiles.includes("-") && args.paths.includes("-")) {
             throw new SearchError("cannot search stdin while also reading patterns from stdin");
           }
-          const selection = selectInput(context, args, options2);
+          const selection = selectInput(context, args, options3);
           const report = async (error) => {
             context.signal.throwIfAborted();
             failed = true;
@@ -18426,16 +18572,16 @@ function createRgCommand(executor, options2 = {}) {
 }
 
 // packages/safe-bash/src/commands/search/portable.ts
-function portableSearchCommands(options2) {
-  const executor = new RegexExecutor(options2.provider, options2.regex);
-  const commands = [...createGrepCommands(executor), createRgCommand(executor, options2.search), sedCommand(options2.sed)];
+function portableSearchCommands(options3) {
+  const executor = new RegexExecutor(options3.provider, options3.regex);
+  const commands = [...createGrepCommands(executor), createRgCommand(executor, options3.search), sedCommand(options3.sed)];
   return {
     name: "portable-search-commands",
     setup(host) {
-      if (!options2.replace) for (const command2 of commands) {
+      if (!options3.replace) for (const command2 of commands) {
         if (host.commands.has(command2.name)) throw new Error(`Command already registered: ${command2.name}`);
       }
-      for (const command2 of commands) host.commands.register(command2, { replace: options2.replace ?? false });
+      for (const command2 of commands) host.commands.register(command2, { replace: options3.replace ?? false });
     },
     dispose: () => executor.dispose()
   };
@@ -18444,6 +18590,281 @@ function portableSearchCommands(options2) {
 // packages/safe-bash/src/commands/regex-execution/public.ts
 init_platform();
 
+// packages/safe-bash/src/commands/regex-execution/bounded-provider.ts
+init_platform();
+var defaults2 = Object.freeze({
+  maxWorkers: 2,
+  maxPatterns: 32,
+  maxPatternBytes: 8192,
+  maxRows: 128,
+  maxInputBytes: 65536,
+  maxResultBytes: 2048,
+  maxWork: 2e6,
+  maxAllocationUnits: 1e6,
+  maxStates: 65536
+});
+var ceilings = Object.freeze({
+  maxWorkers: 32,
+  maxPatterns: 128,
+  maxPatternBytes: 65532,
+  maxRows: 4096,
+  maxInputBytes: 1048576,
+  maxResultBytes: 65536,
+  maxWork: 33554432,
+  maxAllocationUnits: 4e6,
+  maxStates: 65536
+});
+var typedArrayPrototype2 = Object.getPrototypeOf(Uint8Array.prototype);
+var byteLength = Object.getOwnPropertyDescriptor(typedArrayPrototype2, "byteLength").get;
+var byteOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype2, "byteOffset").get;
+var byteBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype2, "buffer").get;
+function fail(kind, message2) {
+  throw new Error(`bounded regex ${kind}: ${message2}`);
+}
+function record3(value2, keys, optional = []) {
+  if (value2 === null || typeof value2 !== "object" || Array.isArray(value2)) fail("protocol", "expected a data record");
+  const ownKeys = Reflect.ownKeys(value2);
+  if (ownKeys.length < keys.length || ownKeys.length > keys.length + optional.length || ownKeys.some((key) => typeof key !== "string" || !keys.includes(key) && !optional.includes(key))) fail("protocol", "unexpected data-record fields");
+  for (const key of [...keys, ...optional]) {
+    const property = Object.getOwnPropertyDescriptor(value2, key);
+    if (property === void 0 ? keys.includes(key) : !("value" in property)) fail("protocol", "missing field or accessor");
+  }
+}
+function array(value2, limit, label) {
+  if (!Array.isArray(value2)) fail("protocol", `${label} must be an array`);
+  if (value2.length > limit) fail("limit", `${label} count limit exceeded`);
+  const keys = Reflect.ownKeys(value2);
+  if (keys.length !== value2.length + 1) fail("protocol", `${label} must be a dense data array`);
+  for (let index = 0; index < value2.length; index++) {
+    const property = Object.getOwnPropertyDescriptor(value2, index);
+    if (!property || !("value" in property)) fail("protocol", `${label} must be a dense data array`);
+  }
+}
+function options2(input3) {
+  const keys = Object.keys(defaults2);
+  try {
+    record3(input3, [], keys);
+  } catch {
+    throw new TypeError("bounded regex options require supported own data fields");
+  }
+  const result = { ...defaults2 };
+  for (const key of keys) {
+    if (!Object.hasOwn(input3, key)) continue;
+    const value2 = input3[key];
+    if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 1 || value2 > ceilings[key]) throw new RangeError(`bounded regex option ${key} is outside its limit`);
+    result[key] = value2;
+  }
+  return Object.freeze(result);
+}
+function descriptor(value2, limits) {
+  if (value2 === null || typeof value2 !== "object") fail("protocol", "invalid descriptor");
+  const kind = Object.getOwnPropertyDescriptor(value2, "kind");
+  if (!kind || !("value" in kind)) fail("protocol", "invalid descriptor kind");
+  if (kind.value !== "grep" && kind.value !== "rg") fail("unsupported", "only grep and fixed rg selection descriptors are supported");
+  const flags = kind.value === "grep" ? ["fixed", "extended", "insensitive", "whole", "word"] : ["fixed", "whole", "word", "nullData"];
+  record3(value2, ["kind", "patterns", ...flags, ...kind.value === "rg" ? ["case"] : []]);
+  for (const flag of flags) if (typeof value2[flag] !== "boolean") fail("protocol", `invalid ${flag} flag`);
+  if (kind.value === "rg" && !["sensitive", "insensitive", "smart"].includes(value2.case)) fail("protocol", "invalid case flag");
+  if (value2.word || kind.value === "grep" && value2.insensitive || kind.value === "rg" && value2.case !== "sensitive") fail("unsupported", "only case-sensitive, non-word selection is supported");
+  if (kind.value === "rg" && !value2.fixed) fail("unsupported", "rg regex and Unicode modes are unsupported; use fixed ASCII patterns");
+  array(value2.patterns, limits.maxPatterns, "pattern");
+  let bytes2 = 0;
+  for (let index = 0; index < value2.patterns.length; index++) {
+    const pattern = value2.patterns[index];
+    if (typeof pattern !== "string") fail("protocol", "patterns must be strings");
+    if (pattern.length > limits.maxPatternBytes - bytes2) fail("limit", "aggregate pattern byte limit exceeded");
+    bytes2 += pattern.length;
+  }
+  return value2;
+}
+function admit(input3, limits, signal) {
+  record3(input3, ["id", "descriptor", "rows"]);
+  const selected = descriptor(input3.descriptor, limits);
+  array(input3.rows, limits.maxRows, "row");
+  if (input3.rows.length > Math.floor(limits.maxResultBytes / 16)) fail("limit", "result byte limit exceeded");
+  let bytes2 = 0;
+  for (let index = 0; index < input3.rows.length; index++) {
+    const row = input3.rows[index];
+    record3(row, ["bytes", "all", "terminated"], ["directory", "ancestors"]);
+    if (!(row.bytes instanceof Uint8Array) || typeof row.all !== "boolean" || typeof row.terminated !== "boolean" || Object.hasOwn(row, "directory") && typeof row.directory !== "boolean" || Object.hasOwn(row, "ancestors") && typeof row.ancestors !== "boolean") fail("protocol", "invalid row");
+    if (Object.hasOwn(row, "directory") || Object.hasOwn(row, "ancestors")) fail("unsupported", "glob row flags are unsupported");
+    if (row.all) fail("unsupported", "all-match enumeration is unsupported");
+    const length = byteLength.call(row.bytes);
+    if (length > limits.maxInputBytes - bytes2) fail("limit", "aggregate input byte limit exceeded");
+    bytes2 += length;
+  }
+  const ledger = new EreLedger({ maxExpansionBytes: 1048576, maxExpansionFields: 8192 }, {
+    patternBytes: limits.maxPatternBytes + 4,
+    subjectBytes: limits.maxInputBytes,
+    work: limits.maxWork,
+    allocationUnits: limits.maxAllocationUnits,
+    states: limits.maxStates
+  });
+  ledger.charge("allocationUnits", bytes2 + input3.rows.length * 12 + selected.patterns.length * 2 + 16, signal);
+  const patterns2 = [];
+  for (let index = 0; index < selected.patterns.length; index++) patterns2.push(selected.patterns[index]);
+  const ownedDescriptor = selected.kind === "grep" ? { kind: "grep", patterns: patterns2, fixed: selected.fixed, extended: selected.extended, insensitive: selected.insensitive, whole: selected.whole, word: selected.word } : { kind: "rg", patterns: patterns2, fixed: selected.fixed, case: selected.case, whole: selected.whole, word: selected.word, nullData: selected.nullData };
+  const rows = [];
+  for (let index = 0; index < input3.rows.length; index++) {
+    const row = input3.rows[index];
+    const source = new Uint8Array(byteBuffer.call(row.bytes), byteOffset.call(row.bytes), byteLength.call(row.bytes));
+    const copy2 = new Uint8Array(source.length);
+    copy2.set(source);
+    rows.push({ bytes: copy2, all: false, terminated: row.terminated });
+  }
+  return { id: input3.id, descriptor: ownedDescriptor, rows, ledger };
+}
+async function admitBre(pattern, ledger, signal) {
+  let bracket = -1;
+  let member = false;
+  let namedClass = false;
+  for (let index = 0; index < pattern.length; index++) {
+    ledger.charge("work", 1, signal);
+    await ledger.checkpoint(signal);
+    const character = pattern[index];
+    if ("\\()+?{}|".includes(character)) fail("unsupported", "BRE escapes, groups and interval/operator extensions are unsupported; use grep -E");
+    if (bracket >= 0) {
+      if (index === bracket + 1 && character === "^") continue;
+      if (namedClass) {
+        if (character === "]" && pattern[index - 1] === ":") namedClass = false;
+      } else if (character === "]" && member) bracket = -1;
+      else if (character === "[" && pattern[index + 1] === ":") namedClass = true;
+      member = true;
+    } else if (character === "[") {
+      bracket = index;
+      member = false;
+    } else if (character === "^" && index !== 0 || character === "$" && index !== pattern.length - 1) {
+      fail("unsupported", "BRE anchors are supported only at record boundaries");
+    } else if (character === "*" && (index === 0 || index === 1 && pattern[0] === "^")) {
+      fail("unsupported", "BRE leading literal star is unsupported; use fixed matching");
+    }
+  }
+}
+async function execute2(input3, signal) {
+  const { descriptor: selected, rows, ledger } = input3;
+  const programs2 = [];
+  for (const pattern of selected.patterns) {
+    if (selected.kind === "grep" && !selected.fixed && !selected.extended) await admitBre(pattern, ledger, signal);
+    if (selected.kind === "rg" && !selected.nullData && pattern.includes("\n")) fail("unsupported", "rg multiline matching is unsupported");
+    ledger.charge("allocationUnits", (selected.whole ? 3 : 1) * 3 + 2, signal);
+    const fragments = selected.whole ? [{ text: "^(", literal: false }, { text: pattern, literal: selected.fixed }, { text: ")$", literal: false }] : [{ text: pattern, literal: selected.fixed }];
+    programs2.push(await compileEre(fragments, ledger, signal));
+  }
+  const results = [];
+  for (const row of rows) {
+    ledger.charge("allocationUnits", row.bytes.length * 2 + 2, signal);
+    const characters = [];
+    for (const byte of row.bytes) {
+      ledger.charge("work", 1, signal);
+      if (byte === 0 || byte > 127) fail("unsupported", "subjects require non-NUL ASCII; Unicode and invalid UTF-8 are unsupported");
+      characters.push(String.fromCharCode(byte));
+      await ledger.checkpoint(signal);
+    }
+    const subject = characters.join("");
+    let span;
+    for (const program of programs2) {
+      const match = await matchEre(program, subject, ledger, signal);
+      if (!match.matched) continue;
+      const candidate = match.captures[0];
+      if (selected.kind === "grep") {
+        span = candidate;
+        break;
+      }
+      if (!span || candidate.start < span.start) span = candidate;
+    }
+    signal.throwIfAborted();
+    results.push(span ? new Float64Array([span.start, span.end]) : new Float64Array());
+  }
+  return { id: input3.id, results };
+}
+var CooperativeWorker = class {
+  constructor(limits, release) {
+    this.limits = limits;
+    this.release = release;
+    queueMicrotask(() => {
+      if (!this.#closing) this.emit({ ready: true });
+    });
+  }
+  limits;
+  release;
+  #controller = new AbortController();
+  #listeners = /* @__PURE__ */ new Map();
+  #tasks = /* @__PURE__ */ new Set();
+  #busy = false;
+  #closing;
+  on(event, listener) {
+    if (this.#closing) return;
+    let listeners = this.#listeners.get(event);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.#listeners.set(event, listeners);
+    }
+    listeners.add(listener);
+  }
+  off(event, listener) {
+    this.#listeners.get(event)?.delete(listener);
+  }
+  emit(value2) {
+    for (const listener of this.#listeners.get("message") ?? []) listener(value2);
+  }
+  postMessage(input3) {
+    if (this.#closing) throw new Error("bounded regex worker is closed");
+    if (this.#busy) throw new Error("bounded regex worker is busy");
+    const identity = input3 !== null && typeof input3 === "object" ? Object.getOwnPropertyDescriptor(input3, "id") : void 0;
+    if (!identity || !("value" in identity) || !Number.isSafeInteger(identity.value) || identity.value < 1) fail("protocol", "invalid request identity");
+    const id = identity.value;
+    const submitted = Object.getOwnPropertyDescriptor(input3, "descriptor")?.value;
+    const expression = submitted !== null && typeof submitted === "object" && Object.getOwnPropertyDescriptor(submitted, "kind")?.value === "expr-match";
+    let owned;
+    let failure;
+    try {
+      owned = admit(input3, this.limits, this.#controller.signal);
+    } catch (error) {
+      failure = error instanceof Error ? error.message.slice(0, 512) : "bounded regex protocol: request admission failed";
+    }
+    this.#busy = true;
+    const task = Promise.resolve().then(async () => {
+      let reply;
+      try {
+        this.#controller.signal.throwIfAborted();
+        reply = owned ? await execute2(owned, this.#controller.signal) : { id, error: failure };
+      } catch (error) {
+        reply = { id, error: error instanceof Error ? error.message.slice(0, 512) : "bounded regex request failed" };
+      }
+      if (expression && "error" in reply) reply = { id, operation: "expr-match", category: "unsupported", error: reply.error };
+      owned = void 0;
+      this.#busy = false;
+      if (!this.#closing) this.emit(reply);
+    });
+    this.#tasks.add(task);
+    void task.then(() => this.#tasks.delete(task), () => this.#tasks.delete(task));
+  }
+  terminate() {
+    if (!this.#closing) {
+      this.#closing = Promise.allSettled([...this.#tasks]).then(() => {
+        this.#listeners.clear();
+        this.#tasks.clear();
+        this.release();
+      });
+      this.#controller.abort(new Error("bounded regex worker terminated"));
+    }
+    return this.#closing;
+  }
+};
+function createBoundedRegexProvider(input3 = {}) {
+  const limits = options2(input3);
+  let active = 0;
+  return Object.freeze({
+    createWorker() {
+      if (active >= limits.maxWorkers) fail("limit", "worker count limit exceeded");
+      active++;
+      return new CooperativeWorker(limits, () => {
+        active--;
+      });
+    }
+  });
+}
+
 // packages/safe-bash/src/browser.ts
 function createBrowserCommands() {
   return [
@@ -18454,17 +18875,17 @@ function createBrowserCommands() {
     ...textCommands()
   ];
 }
-function browserCommands(options2 = {}) {
+function browserCommands(options3 = {}) {
   return {
     name: "browser-commands",
     setup(host) {
       const commands = createBrowserCommands();
-      if (!options2.replace) {
+      if (!options3.replace) {
         for (const command2 of commands) {
           if (host.commands.has(command2.name)) throw new Error(`Command already registered: ${command2.name}`);
         }
       }
-      for (const command2 of commands) host.commands.register(command2, { replace: options2.replace ?? false });
+      for (const command2 of commands) host.commands.register(command2, { replace: options3.replace ?? false });
     }
   };
 }
@@ -18495,6 +18916,7 @@ export {
   collectText,
   compileEre,
   composeMiddleware,
+  createBoundedRegexProvider,
   createBrowserCommands,
   createBytePipe,
   createCommandArguments,