poe-code 14.0.21 → 14.0.23

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

@@ -1816,14 +1816,12 @@ var require_buffer = __commonJS({
 });
 
 // packages/safe-bash/browser/platform.mjs
-var import_buffer, TransformStream, setImmediate, clearImmediate;
+var import_buffer, TransformStream;
 var init_platform = __esm({
   "packages/safe-bash/browser/platform.mjs"() {
     "use strict";
     import_buffer = __toESM(require_buffer(), 1);
     TransformStream = globalThis.TransformStream;
-    setImmediate = (callback, ...args) => setTimeout(callback, 0, ...args);
-    clearImmediate = clearTimeout;
   }
 });
 
@@ -1833,9 +1831,6 @@ init_platform();
 // packages/safe-bash/src/commands/basic.ts
 init_platform();
 
-// packages/safe-bash/src/contracts/index.ts
-init_platform();
-
 // packages/safe-bash/src/contracts/command.ts
 init_platform();
 
@@ -3054,6 +3049,44 @@ async function compareObservedEntries(fs, path, stat, peer, peerPath, peerStat,
 
 // packages/safe-bash/src/commands/move.ts
 init_platform();
+
+// packages/safe-bash/src/contracts/yield.ts
+init_platform();
+var checkpoints = /* @__PURE__ */ new WeakMap();
+function monotonicNow() {
+  return globalThis.performance?.now() ?? Date.now();
+}
+function registerYieldCheckpoint(signal, checkpoint) {
+  checkpoints.set(signal, checkpoint);
+}
+function scheduleTurn(callback) {
+  const host = globalThis;
+  return host.setImmediate ? { kind: "immediate", value: host.setImmediate(callback) } : { kind: "timeout", value: setTimeout(callback, 0) };
+}
+function cancelTurn(handle) {
+  if (handle?.kind === "immediate") globalThis.clearImmediate?.(handle.value);
+  else if (handle) clearTimeout(handle.value);
+}
+function yieldTurn(signal) {
+  signal?.throwIfAborted();
+  if (signal) checkpoints.get(signal)?.();
+  return new Promise((resolve, reject) => {
+    let handle;
+    const finish = () => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    };
+    const abort = () => {
+      cancelTurn(handle);
+      reject(signal.reason);
+    };
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    else handle = scheduleTurn(finish);
+  });
+}
+
+// packages/safe-bash/src/commands/move.ts
 var MoveBudget = class {
   constructor(signal) {
     this.signal = signal;
@@ -3066,7 +3099,7 @@ var MoveBudget = class {
   async step() {
     this.signal.throwIfAborted();
     if (++this.steps > 1e5) throw new FsError("EFBIG", { message: "cross-device move entry limit exceeded" });
-    if (this.steps % 128 === 0) await new Promise((resolve) => setImmediate(resolve));
+    if (this.steps % 128 === 0) await yieldTurn();
     this.signal.throwIfAborted();
   }
 };
@@ -3801,7 +3834,7 @@ function headTail(name2) {
   });
 }
 function characterSet(specification) {
-  const classes = {
+  const classes2 = {
     lower: Array.from({ length: 26 }, (_, offset) => 97 + offset),
     upper: Array.from({ length: 26 }, (_, offset) => 65 + offset),
     digit: Array.from({ length: 10 }, (_, offset) => 48 + offset),
@@ -3811,15 +3844,15 @@ function characterSet(specification) {
     graph: Array.from({ length: 94 }, (_, offset) => 33 + offset),
     print: Array.from({ length: 95 }, (_, offset) => 32 + offset)
   };
-  classes.alpha = [...classes.upper, ...classes.lower];
-  classes.alnum = [...classes.digit, ...classes.alpha];
-  classes.xdigit = [...classes.digit, ...classes.upper.slice(0, 6), ...classes.lower.slice(0, 6)];
-  classes.punct = classes.graph.filter((byte) => !classes.alnum.includes(byte));
+  classes2.alpha = [...classes2.upper, ...classes2.lower];
+  classes2.alnum = [...classes2.digit, ...classes2.alpha];
+  classes2.xdigit = [...classes2.digit, ...classes2.upper.slice(0, 6), ...classes2.lower.slice(0, 6)];
+  classes2.punct = classes2.graph.filter((byte) => !classes2.alnum.includes(byte));
   const tokens2 = [];
   for (let offset = 0; offset < specification.length; ) {
     const classMatch = /^\[:([a-z]+):\]/u.exec(specification.slice(offset));
     if (classMatch) {
-      const bytes = classes[classMatch[1]];
+      const bytes = classes2[classMatch[1]];
       if (!bytes) throw new UsageError(`unknown character class '${classMatch[1]}'`);
       tokens2.push({ bytes, literal: false });
       offset += classMatch[0].length;
@@ -3992,32 +4025,128 @@ function streamCommands() {
     }),
     define("tee", async (context) => {
       const parsed = options(context.args, "a", { append: "a" });
-      const targets = [];
+      const paths = [];
+      const streams = [];
       let exitCode = 0;
+      let closed = false;
+      let cleanup;
+      const closeStreams = () => {
+        closed = true;
+        return cleanup ??= Promise.allSettled(streams.map(async (target) => {
+          await target.pipe.abort(context.signal.aborted ? context.signal.reason : void 0);
+          await target.task;
+        })).then(() => {
+        });
+      };
+      context.registerCleanup?.(closeStreams);
+      const report = async (target, error) => {
+        target.active = false;
+        if (target.reported) return;
+        target.reported = true;
+        await diagnostic(context, error);
+        exitCode = 1;
+      };
+      const fallback = async (target) => {
+        if (context.fs.capabilities.append === false || target.accepted || !(target.failure instanceof FsError) || target.failure.code !== "ENOTSUP") return false;
+        await context.fs.writeFile(target.path, new Uint8Array(), { flag: target.flag, signal: context.signal });
+        target.active = false;
+        paths.push(target.path);
+        return true;
+      };
+      const recover = async (target, error) => {
+        try {
+          if (await fallback(target)) return;
+        } catch (fallbackError) {
+          context.signal.throwIfAborted();
+          await report(target, fallbackError);
+          return;
+        }
+        await report(target, error);
+      };
+      const streaming = context.fs.capabilities.streamingWrite !== false && typeof context.fs.writeStream === "function";
       for (const operand of parsed.operands) {
         try {
           const path = pathOf(context, operand);
-          await context.fs.writeFile(path, new Uint8Array(), { flag: parsed.flags.has("a") ? "a" : "w", signal: context.signal });
-          targets.push(path);
+          if (closed) throw new FsError("ECANCELED", { syscall: "tee", path });
+          const flag = parsed.flags.has("a") ? "a" : "w";
+          if (streaming) {
+            const pipe = createBytePipe({ signal: context.signal });
+            const target = {
+              path,
+              flag,
+              pipe,
+              task: Promise.resolve(),
+              failed: false,
+              accepted: false,
+              reported: false,
+              active: true
+            };
+            const source = (async function* () {
+              for await (const chunk of pipe.readable) {
+                target.accepted = true;
+                yield chunk;
+              }
+            })();
+            target.task = context.fs.writeStream(path, source, { flag, signal: context.signal }).catch(async (error) => {
+              target.failed = true;
+              target.failure = error;
+              await pipe.abort(error);
+            });
+            streams.push(target);
+          } else {
+            if (context.fs.capabilities.append === false) {
+              throw new FsError(context.fs.capabilities.readOnly === true ? "EROFS" : "ENOTSUP", { syscall: "tee", path });
+            }
+            await context.fs.writeFile(path, new Uint8Array(), { flag, signal: context.signal });
+            paths.push(path);
+          }
         } catch (error) {
+          context.signal.throwIfAborted();
           await diagnostic(context, error);
           exitCode = 1;
         }
       }
-      for await (const chunk of input(context)) {
-        await output(context, chunk);
-        for (let index = 0; index < targets.length; ) {
+      try {
+        for await (const chunk of input(context)) {
+          await output(context, chunk);
+          for (const target of streams) {
+            if (!target.active) continue;
+            try {
+              await target.pipe.writable.write(chunk);
+            } catch (error) {
+              context.signal.throwIfAborted();
+              await target.task;
+              await recover(target, target.failed ? target.failure : error);
+            }
+          }
+          for (let index = 0; index < paths.length; ) {
+            try {
+              await context.fs.appendFile(paths[index], chunk, { signal: context.signal });
+              index++;
+            } catch (error) {
+              context.signal.throwIfAborted();
+              await diagnostic(context, error);
+              paths.splice(index, 1);
+              exitCode = 1;
+            }
+          }
+        }
+        for (const target of streams) {
+          if (!target.active) continue;
           try {
-            await context.fs.appendFile(targets[index], chunk, { signal: context.signal });
-            index++;
+            await target.pipe.close();
+            await target.task;
+            if (target.failed) await recover(target, target.failure);
           } catch (error) {
-            await diagnostic(context, error);
-            targets.splice(index, 1);
-            exitCode = 1;
+            context.signal.throwIfAborted();
+            await target.task;
+            await recover(target, target.failed ? target.failure : error);
           }
         }
+        return { exitCode };
+      } finally {
+        await closeStreams();
       }
-      return { exitCode };
     }),
     define("tr", async (context) => {
       const parsed = options(context.args, "dscC", { delete: "d", "squeeze-repeats": "s", complement: "c" });
@@ -4444,6 +4573,17 @@ init_platform();
 // packages/safe-bash/src/shell/shell.ts
 init_platform();
 
+// packages/safe-bash/src/shell/env-warning.ts
+init_platform();
+var warned = /* @__PURE__ */ new WeakSet();
+function warnIfHostProcessEnv(env) {
+  if (!env || typeof process === "undefined" || !process.env) return;
+  if (warned.has(env)) return;
+  if (env !== process.env) return;
+  warned.add(env);
+  console.warn("[safe-bash] warning: the shell `env` is the host `process.env`. Scripts executed in this shell can read every value in it, including secrets; on Cloudflare Workers with nodejs_compat, process.env contains the Worker's secret bindings. Pass only the variables your scripts need. See docs/issues/safe-bash-cloudflare-security-audit.md (finding 1).");
+}
+
 // packages/safe-bash/src/shell/parser.ts
 init_platform();
 
@@ -4538,7 +4678,7 @@ function integer2(text) {
   for (const character of match[2]) {
     const digit2 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@_".indexOf(base <= 36 ? character.toLowerCase() : character);
     if (digit2 >= base || digit2 < 0) throw new Error("Digit exceeds arithmetic base");
-    value2 = value2 * BigInt(base) + BigInt(digit2);
+    value2 = BigInt.asIntN(64, value2 * BigInt(base) + BigInt(digit2));
   }
   return value2;
 }
@@ -4864,7 +5004,7 @@ async function tokens(pattern, work) {
   let steps = 0;
   const tick = () => {
     if (--work.remaining < 0) work.exhausted();
-    if (++steps % 1024 === 0) return new Promise((resolve) => setImmediate(resolve)).then(() => work.signal.throwIfAborted());
+    if (++steps % 1024 === 0) return yieldTurn(work.signal);
     return void 0;
   };
   for (let index = 0; index < characters.length; index++) {
@@ -4941,7 +5081,7 @@ async function matchTokens(patternTokens, value2, work) {
   while (position < characters.length) {
     if (--work.remaining < 0) work.exhausted();
     if (++steps % 1024 === 0) {
-      await new Promise((resolve) => setImmediate(resolve));
+      await yieldTurn(work.signal);
       work.signal.throwIfAborted();
     }
     const token = patternTokens[tokenIndex];
@@ -4974,7 +5114,7 @@ async function charge(context, amount = 1) {
   const previous = context.work.remaining;
   context.work.remaining -= amount;
   if (previous >>> 10 !== context.work.remaining >>> 10) {
-    await new Promise((resolve) => setImmediate(resolve));
+    await yieldTurn();
     context.signal.throwIfAborted();
   }
 }
@@ -5176,6 +5316,7 @@ var Lexer = class {
     this.documentLine = documentLine;
     this.partial = partial;
     if (depth > 64) throw new ShellSyntaxError("Syntax nesting exceeds 64", 0);
+    for (let offset = source.indexOf("\n"); offset !== -1; offset = source.indexOf("\n", offset + 1)) this.newlineOffsets.push(offset);
   }
   source;
   depth;
@@ -5191,8 +5332,16 @@ var Lexer = class {
   conditional = false;
   conditionalPattern;
   documents = [];
+  newlineOffsets = [];
   lineAt(position) {
-    return this.lineOffset + this.source.slice(0, position).split("\n").length;
+    let low = 0;
+    let high = this.newlineOffsets.length;
+    while (low < high) {
+      const middle = low + Math.floor((high - low) / 2);
+      if (this.newlineOffsets[middle] < position) low = middle + 1;
+      else high = middle;
+    }
+    return this.lineOffset + low + 1;
   }
   error(message2, unclosedQuote) {
     throw new ShellSyntaxError(message2, this.position, 2, void 0, unclosedQuote);
@@ -6614,7 +6763,7 @@ var SplitWork = class {
     return this.work >= this.nextYield;
   }
   async pause() {
-    await new Promise((resolve) => setImmediate(resolve));
+    await yieldTurn();
     this.signal.throwIfAborted();
     this.nextYield = this.work + 4096;
   }
@@ -7884,14 +8033,7 @@ var ArrayLedger = class _ArrayLedger {
     this.#checkpoint += units;
     if (this.#checkpoint >= 128) {
       this.#checkpoint %= 128;
-      return new Promise((resolve, reject) => setImmediate(() => {
-        try {
-          signal?.throwIfAborted();
-          resolve();
-        } catch (error) {
-          reject(error);
-        }
-      }));
+      return yieldTurn(signal);
     }
   }
 };
@@ -8768,43 +8910,17 @@ async function publishPipelineStatus(state, statuses, signal, scope) {
   throwCleanupFailures(scope.failures);
 }
 
-// packages/safe-bash/browser/regex.mjs
-init_platform();
-var EreTransportRoot = class {
-  constructor() {
-    throw new ConditionalUnsupported("[[ =~ ]] is not supported by the browser shell entry");
-  }
-};
-
-// packages/safe-bash/src/commands/regex-execution/ere/transport/protocol.ts
+// packages/safe-bash/src/commands/regex-execution/ere/errors.ts
 init_platform();
-var resources = Object.freeze(["patternBytes", "subjectBytes", "work", "states", "allocationUnits", "captureBytes", "captureSlots"]);
-var cumulative = Object.freeze(["work", "states", "allocationUnits", "captureBytes", "captureSlots"]);
-var EreTransportProfileLimitError = class extends Error {
-  constructor(resource, limit) {
-    super(`ERE transport profile limit exceeded: ${resource} (${limit})`);
-    this.resource = resource;
-    this.limit = limit;
-    this.name = "EreTransportProfileLimitError";
-  }
-  resource;
-  limit;
-  status = 3;
-};
-var EreTransportSemanticError = class extends Error {
-  constructor(category, offset) {
-    super(category === "syntax" ? "invalid ERE" : "unsupported ERE profile");
-    this.category = category;
+var EreSyntaxError = class extends Error {
+  constructor(message2, offset) {
+    super(`invalid ERE at ${offset}: ${message2}`);
     this.offset = offset;
-    this.name = "EreTransportSemanticError";
+    this.name = "EreSyntaxError";
   }
-  category;
   offset;
   status = 2;
 };
-
-// packages/safe-bash/src/commands/regex-execution/ere/errors.ts
-init_platform();
 var EreUnsupportedError = class extends Error {
   constructor(message2, offset) {
     super(`unsupported ERE profile at ${offset}: ${message2}`);
@@ -8825,6 +8941,564 @@ var EreProfileLimitError = class extends Error {
   limit;
   status = 3;
 };
+var EreUsageUnknownError = class extends Error {
+  status = 3;
+  constructor(reason) {
+    super("ERE invocation usage is unknown; further work is refused", { cause: reason });
+    this.name = "EreUsageUnknownError";
+  }
+};
+
+// packages/safe-bash/src/commands/regex-execution/ere/limits.ts
+init_platform();
+var resources = Object.freeze([
+  "patternBytes",
+  "subjectBytes",
+  "work",
+  "states",
+  "allocationUnits",
+  "captureBytes",
+  "captureSlots"
+]);
+function integer5(value2) {
+  if (!Number.isSafeInteger(value2) || value2 < 0) throw new TypeError("ERE bounds must be nonnegative safe integers");
+}
+function multiply(value2, factor, ceiling) {
+  return value2 > Math.floor(ceiling / factor) ? ceiling : value2 * factor;
+}
+function deriveEreLimits(bounds) {
+  integer5(bounds.maxExpansionBytes);
+  integer5(bounds.maxExpansionFields);
+  const bytes = bounds.maxExpansionBytes;
+  const fields = bounds.maxExpansionFields;
+  const byteUnits = multiply(bytes, 8, 4e6);
+  const fieldUnits = multiply(fields, 128, 4e6);
+  return Object.freeze({
+    patternBytes: Math.min(bytes, 65536),
+    subjectBytes: Math.min(bytes, 1048576),
+    work: multiply(bytes, 32, 5e7),
+    states: multiply(fields, 8, 65536),
+    allocationUnits: byteUnits >= 4e6 - fieldUnits ? 4e6 : byteUnits + fieldUnits,
+    captureBytes: bytes,
+    captureSlots: fields
+  });
+}
+var EreLedger = class {
+  limits;
+  #usage = {
+    patternBytes: 0,
+    subjectBytes: 0,
+    work: 0,
+    states: 0,
+    allocationUnits: 0,
+    captureBytes: 0,
+    captureSlots: 0
+  };
+  #poison;
+  #lastYield = 0;
+  constructor(bounds, lowering = {}) {
+    const limits = { ...deriveEreLimits(bounds) };
+    for (const resource of Object.keys(lowering)) {
+      if (!resources.includes(resource)) throw new TypeError("unknown ERE limit");
+      const key = resource;
+      const value2 = lowering[key];
+      if (value2 === void 0) throw new TypeError("undefined ERE limit");
+      integer5(value2);
+      if (value2 > limits[key]) throw new RangeError("ERE limits may only be lowered");
+      limits[key] = value2;
+    }
+    this.limits = Object.freeze(limits);
+  }
+  get usage() {
+    return Object.freeze({ ...this.#usage });
+  }
+  check(signal) {
+    if (signal?.aborted) throw signal.reason;
+    if (this.#poison) throw this.#poison;
+  }
+  charge(resource, amount, signal) {
+    this.check(signal);
+    integer5(amount);
+    if (amount > this.limits[resource] - this.#usage[resource]) {
+      throw new EreProfileLimitError(resource, this.limits[resource]);
+    }
+    this.#usage[resource] += amount;
+  }
+  admitInput(resource, length, signal) {
+    this.check(signal);
+    integer5(length);
+    if (length > this.limits[resource]) throw new EreProfileLimitError(resource, this.limits[resource]);
+    this.#usage[resource] = Math.max(this.#usage[resource], length);
+  }
+  async checkpoint(signal) {
+    this.check(signal);
+    if (this.#usage.work - this.#lastYield >= 256) {
+      this.#lastYield = this.#usage.work;
+      await yieldTurn(signal);
+      this.check(signal);
+    }
+  }
+  markUnknownUsage(reason) {
+    this.#poison ??= new EreUsageUnknownError(reason);
+  }
+};
+
+// packages/safe-bash/src/commands/regex-execution/ere/syntax.ts
+init_platform();
+var programs = /* @__PURE__ */ new WeakMap();
+var special = "\\.^$[]()|*+?{}";
+var classes = /* @__PURE__ */ new Set(["alnum", "alpha", "blank", "cntrl", "digit", "graph", "lower", "print", "punct", "space", "upper", "xdigit"]);
+function classMember(name2, code) {
+  const upper = code >= 65 && code <= 90;
+  const lower = code >= 97 && code <= 122;
+  const digit2 = code >= 48 && code <= 57;
+  switch (name2) {
+    case "alnum":
+      return upper || lower || digit2;
+    case "alpha":
+      return upper || lower;
+    case "blank":
+      return code === 9 || code === 32;
+    case "cntrl":
+      return code < 32 || code === 127;
+    case "digit":
+      return digit2;
+    case "graph":
+      return code >= 33 && code <= 126;
+    case "lower":
+      return lower;
+    case "print":
+      return code >= 32 && code <= 126;
+    case "punct":
+      return code >= 33 && code <= 126 && !upper && !lower && !digit2;
+    case "space":
+      return code === 32 || code >= 9 && code <= 13;
+    case "upper":
+      return upper;
+    case "xdigit":
+      return digit2 || code >= 65 && code <= 70 || code >= 97 && code <= 102;
+    default:
+      return false;
+  }
+}
+async function admitAscii(text, ledger, signal) {
+  for (let offset = 0; offset < text.length; offset++) {
+    ledger.charge("work", 1, signal);
+    const code = text.charCodeAt(offset);
+    if (code === 0 || code > 127) throw new EreUnsupportedError("only non-NUL ASCII in the C/POSIX profile", offset);
+    await ledger.checkpoint(signal);
+  }
+}
+async function flatten(input2, ledger, signal) {
+  if (typeof input2 === "string") {
+    ledger.admitInput("patternBytes", input2.length, signal);
+    await admitAscii(input2, ledger, signal);
+    return { pattern: input2, quoted: null };
+  }
+  let size = 0;
+  for (const fragment of input2) {
+    if (typeof fragment.text !== "string" || typeof fragment.literal !== "boolean") throw new TypeError("invalid ERE fragment");
+    ledger.charge("work", 1, signal);
+    await ledger.checkpoint(signal);
+    ledger.admitInput("patternBytes", fragment.text.length, signal);
+    await admitAscii(fragment.text, ledger, signal);
+    if (fragment.text.length > ledger.limits.patternBytes - size) ledger.admitInput("patternBytes", ledger.limits.patternBytes + 1, signal);
+    size += fragment.text.length;
+    ledger.admitInput("patternBytes", size, signal);
+  }
+  ledger.charge("allocationUnits", size * 2 + input2.length + 2, signal);
+  const output2 = [];
+  const quoted = [];
+  for (const fragment of input2) {
+    for (let offset = 0; offset < fragment.text.length; offset++) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      quoted.push(fragment.literal);
+    }
+    output2.push(fragment.text);
+    await ledger.checkpoint(signal);
+  }
+  return { pattern: output2.join(""), quoted: Object.freeze(quoted) };
+}
+var Parser2 = class {
+  constructor(pattern, quoted, ledger, signal) {
+    this.pattern = pattern;
+    this.quoted = quoted;
+    this.ledger = ledger;
+    this.signal = signal;
+  }
+  pattern;
+  quoted;
+  ledger;
+  signal;
+  offset = 0;
+  groups = 0;
+  nodes = 0;
+  at(character, offset = this.offset) {
+    return !this.quoted?.[offset] && this.pattern[offset] === character;
+  }
+  node(create) {
+    if (this.nodes >= 4096) throw new EreUnsupportedError("4096-node grammar ceiling", this.offset);
+    this.ledger.charge("allocationUnits", 8, this.signal);
+    this.nodes++;
+    return Object.freeze(create());
+  }
+  async expression(depth) {
+    if (depth > 64) throw new EreUnsupportedError("64-level grammar ceiling", this.offset);
+    this.ledger.charge("allocationUnits", 1, this.signal);
+    const alternatives = [];
+    while (true) {
+      const child = await this.sequence(depth);
+      this.ledger.charge("allocationUnits", 1, this.signal);
+      alternatives.push(child);
+      if (!this.at("|")) break;
+      this.offset++;
+    }
+    if (alternatives.length === 1) return alternatives[0];
+    this.ledger.charge("work", alternatives.length * 2, this.signal);
+    await this.ledger.checkpoint(this.signal);
+    return this.node(() => ({ kind: "alternative", children: Object.freeze(alternatives), nullable: alternatives.some((value2) => value2.nullable), captured: alternatives.some((value2) => value2.captured) }));
+  }
+  async sequence(depth) {
+    this.ledger.charge("allocationUnits", 1, this.signal);
+    const children = [];
+    while (this.offset < this.pattern.length && !this.at("|") && !this.at(")")) {
+      this.ledger.charge("work", 1, this.signal);
+      await this.ledger.checkpoint(this.signal);
+      let child = await this.atom(depth);
+      const operator = this.quoted?.[this.offset] ? void 0 : this.pattern[this.offset];
+      if (operator === "*" || operator === "+" || operator === "?" || operator === "{") {
+        const begin = this.offset++;
+        let min = operator === "+" ? 1 : 0;
+        let max = operator === "?" ? 1 : Infinity;
+        if (operator === "{") {
+          min = await this.count();
+          max = min;
+          if (this.at(",")) {
+            this.offset++;
+            max = this.at("}") ? Infinity : await this.count();
+          }
+          if (!this.at("}") || max < min) throw new EreSyntaxError("invalid interval", begin);
+          this.offset++;
+        }
+        if (child.kind === "start" || child.kind === "end") throw new EreUnsupportedError("repeated anchor", begin);
+        if (child.nullable && child.captured && max > 1) throw new EreUnsupportedError("nullable captured repetition", begin);
+        const repeated = child;
+        child = this.node(() => ({ kind: "repeat", child: repeated, min, max, nullable: min === 0 || repeated.nullable, captured: repeated.captured }));
+        const next = this.quoted?.[this.offset] ? void 0 : this.pattern[this.offset];
+        if (next === "*" || next === "+" || next === "?" || next === "{") throw new EreUnsupportedError("stacked repetition", this.offset);
+      }
+      this.ledger.charge("allocationUnits", 1, this.signal);
+      children.push(child);
+    }
+    if (children.length === 0) return this.node(() => ({ kind: "empty", nullable: true, captured: false }));
+    if (children.length === 1) return children[0];
+    this.ledger.charge("work", children.length * 2, this.signal);
+    await this.ledger.checkpoint(this.signal);
+    return this.node(() => ({ kind: "sequence", children: Object.freeze(children), nullable: children.every((value2) => value2.nullable), captured: children.some((value2) => value2.captured) }));
+  }
+  async count() {
+    const begin = this.offset;
+    let value2 = 0;
+    while (!this.quoted?.[this.offset] && this.pattern[this.offset] !== void 0 && this.pattern[this.offset] >= "0" && this.pattern[this.offset] <= "9") {
+      this.ledger.charge("work", 1, this.signal);
+      await this.ledger.checkpoint(this.signal);
+      value2 = value2 * 10 + this.pattern.charCodeAt(this.offset++) - 48;
+      if (value2 > 255) throw new EreUnsupportedError("interval counts exceed 255", begin);
+    }
+    if (begin === this.offset) throw new EreSyntaxError("missing interval count", begin);
+    return value2;
+  }
+  async atom(depth) {
+    const begin = this.offset;
+    const character = this.pattern[this.offset++];
+    if (this.quoted?.[begin]) return this.node(() => ({ kind: "literal", code: character.charCodeAt(0), nullable: false, captured: false }));
+    if (character === "(") {
+      if (this.at("?")) throw new EreUnsupportedError("extended group syntax", begin);
+      if (this.groups >= 32) throw new EreUnsupportedError("32-group grammar ceiling", begin);
+      const index = ++this.groups;
+      const child = await this.expression(depth + 1);
+      if (!this.at(")")) throw new EreSyntaxError("unclosed group", begin);
+      this.offset++;
+      return this.node(() => ({ kind: "group", index, child, nullable: child.nullable, captured: true }));
+    }
+    if (character === "[") return this.set(begin);
+    if (character === "\\") {
+      const escaped = this.pattern[this.offset++];
+      if (escaped === void 0) throw new EreSyntaxError("trailing escape", begin);
+      if (!special.includes(escaped)) throw new EreUnsupportedError("backreference or escape extension", begin);
+      return this.node(() => ({ kind: "literal", code: escaped.charCodeAt(0), nullable: false, captured: false }));
+    }
+    if (character === "*" || character === "+" || character === "?" || character === "{") throw new EreSyntaxError("repetition without operand", begin);
+    if (character === ".") return this.node(() => ({ kind: "dot", nullable: false, captured: false }));
+    if (character === "^") return this.node(() => ({ kind: "start", nullable: true, captured: false }));
+    if (character === "$") return this.node(() => ({ kind: "end", nullable: true, captured: false }));
+    return this.node(() => ({ kind: "literal", code: character.charCodeAt(0), nullable: false, captured: false }));
+  }
+  async set(begin) {
+    this.ledger.charge("allocationUnits", 128, this.signal);
+    const members = new Array(128).fill(false);
+    const negate = this.at("^");
+    if (negate) this.offset++;
+    let first = true;
+    while (this.offset < this.pattern.length) {
+      this.ledger.charge("work", 1, this.signal);
+      await this.ledger.checkpoint(this.signal);
+      if (this.at("]") && !first) {
+        this.offset++;
+        if (negate) for (let code = 1; code < 128; code++) {
+          this.ledger.charge("work", 1, this.signal);
+          await this.ledger.checkpoint(this.signal);
+          members[code] = !members[code];
+        }
+        return this.node(() => ({ kind: "set", members: Object.freeze(members), nullable: false, captured: false }));
+      }
+      first = false;
+      if (this.at("[") && (this.at(".", this.offset + 1) || this.at("=", this.offset + 1))) {
+        throw new EreUnsupportedError("collating or equivalence element", this.offset);
+      }
+      if (this.at("[") && this.at(":", this.offset + 1)) {
+        const classBegin = this.offset;
+        this.offset += 2;
+        let name2 = "";
+        while (this.offset < this.pattern.length && !this.at(":")) {
+          this.ledger.charge("work", 1, this.signal);
+          await this.ledger.checkpoint(this.signal);
+          if (name2.length >= 6) throw new EreSyntaxError("unknown character class", classBegin);
+          name2 += this.pattern[this.offset++];
+        }
+        if (!this.at(":") || !this.at("]", this.offset + 1) || !classes.has(name2)) throw new EreSyntaxError("unknown character class", classBegin);
+        this.offset += 2;
+        for (let code = 1; code < 128; code++) {
+          this.ledger.charge("work", 1, this.signal);
+          await this.ledger.checkpoint(this.signal);
+          if (classMember(name2, code)) members[code] = true;
+        }
+        if (this.at("-") && !this.at("]", this.offset + 1)) throw new EreSyntaxError("class cannot be a range endpoint", this.offset);
+      } else {
+        const lower = this.pattern.charCodeAt(this.offset++);
+        if (this.at("-") && !this.at("]", this.offset + 1) && this.pattern[this.offset + 1] !== void 0) {
+          this.offset++;
+          if (this.at("[")) throw new EreSyntaxError("nonliteral range endpoint", this.offset);
+          const upper = this.pattern.charCodeAt(this.offset++);
+          if (lower > upper) throw new EreSyntaxError("descending range", this.offset - 3);
+          for (let code = lower; code <= upper; code++) {
+            this.ledger.charge("work", 1, this.signal);
+            await this.ledger.checkpoint(this.signal);
+            members[code] = true;
+          }
+        } else members[lower] = true;
+      }
+    }
+    throw new EreSyntaxError("unclosed bracket expression", begin);
+  }
+};
+async function compileEre(input2, ledger, signal) {
+  ledger.check(signal);
+  const { pattern, quoted } = await flatten(input2, ledger, signal);
+  const parser = new Parser2(pattern, quoted, ledger, signal);
+  const root = await parser.expression(0);
+  if (parser.offset !== pattern.length) throw new EreSyntaxError("unmatched closing group", parser.offset);
+  ledger.charge("allocationUnits", 3, signal);
+  const program = Object.freeze({ pattern, groups: parser.groups });
+  programs.set(program, { root, ledger });
+  return program;
+}
+function resolveEreProgram(program, ledger) {
+  const entry = programs.get(program);
+  if (!entry || entry.ledger !== ledger) throw new TypeError("ERE program is not bound to this invocation ledger");
+  return entry.root;
+}
+
+// packages/safe-bash/src/commands/regex-execution/ere/matcher.ts
+init_platform();
+function spanOrder(left, right) {
+  if (left === null) return right === null ? 0 : -1;
+  if (right === null) return 1;
+  const length = left.end - left.start - (right.end - right.start);
+  return length === 0 ? right.start - left.start : length;
+}
+async function historyOrder(left, right, ledger, signal) {
+  const leftCount = left?.count ?? 0;
+  const rightCount = right?.count ?? 0;
+  for (let ordinal = 1; ordinal <= Math.min(leftCount, rightCount); ordinal++) {
+    ledger.charge("work", 1, signal);
+    await ledger.checkpoint(signal);
+    let leftEntry = left;
+    let rightEntry = right;
+    for (let remaining = leftCount; remaining > ordinal; remaining--) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      leftEntry = leftEntry.previous;
+    }
+    for (let remaining = rightCount; remaining > ordinal; remaining--) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      rightEntry = rightEntry.previous;
+    }
+    const compared = spanOrder(leftEntry.span, rightEntry.span);
+    if (compared !== 0) return compared;
+  }
+  return leftCount - rightCount;
+}
+async function preferred(candidate, incumbent, ledger, signal) {
+  if (candidate.position !== incumbent.position) return candidate.position > incumbent.position;
+  for (let group = 1; group < candidate.captures.length; group++) {
+    ledger.charge("work", 1, signal);
+    const compared = await historyOrder(candidate.histories[group], incumbent.histories[group], ledger, signal);
+    if (compared !== 0) return compared > 0;
+  }
+  return false;
+}
+async function resetDescendants(node, previous, ledger, signal) {
+  ledger.charge("allocationUnits", previous.length + 3, signal);
+  const captures = previous.slice();
+  const pending = [node];
+  while (pending.length > 0) {
+    ledger.charge("work", 1, signal);
+    await ledger.checkpoint(signal);
+    const current = pending.pop();
+    if (current.kind === "group") captures[current.index] = null;
+    if (current.kind === "group" || current.kind === "repeat") {
+      if (current.child.captured) {
+        ledger.charge("allocationUnits", 1, signal);
+        pending.push(current.child);
+      }
+    } else if (current.kind === "sequence" || current.kind === "alternative") {
+      for (const child of current.children) {
+        ledger.charge("work", 1, signal);
+        await ledger.checkpoint(signal);
+        if (child.captured) {
+          ledger.charge("allocationUnits", 1, signal);
+          pending.push(child);
+        }
+      }
+    }
+  }
+  return captures;
+}
+async function matchEre(program, subject, ledger, signal) {
+  ledger.check(signal);
+  const root = resolveEreProgram(program, ledger);
+  ledger.admitInput("subjectBytes", subject.length, signal);
+  await admitAscii(subject, ledger, signal);
+  const width = program.groups + 1;
+  ledger.charge("allocationUnits", width * 2 + 1, signal);
+  const emptyCaptures = Object.freeze(new Array(width).fill(null));
+  const emptyHistories = Object.freeze(new Array(width).fill(null));
+  const pending = [];
+  const task = (create) => {
+    ledger.charge("allocationUnits", 5, signal);
+    return create();
+  };
+  const push = (position, next, captures, histories) => {
+    ledger.charge("states", 1, signal);
+    ledger.charge("allocationUnits", 5, signal);
+    pending.push({ position, task: next, captures, histories });
+  };
+  for (let start = 0; start <= subject.length; start++) {
+    push(start, task(() => ({ kind: "node", node: root, next: null })), emptyCaptures, emptyHistories);
+    let best;
+    while (pending.length > 0) {
+      ledger.charge("work", 1, signal);
+      await ledger.checkpoint(signal);
+      const state = pending.pop();
+      const current = state.task;
+      if (current === null) {
+        if (!best || await preferred(state, best, ledger, signal)) best = state;
+        continue;
+      }
+      if (current.kind === "close") {
+        ledger.charge("allocationUnits", width * 2 + 6, signal);
+        const span = Object.freeze({ start: current.start, end: state.position });
+        const captures = state.captures.slice();
+        captures[current.group] = span;
+        const histories = state.histories.slice();
+        const previous = histories[current.group];
+        histories[current.group] = { span, previous, count: (previous?.count ?? 0) + 1 };
+        push(state.position, current.next, captures, histories);
+        continue;
+      }
+      if (current.kind === "repeat") {
+        const { node: node2, count } = current;
+        if (count >= node2.min) push(state.position, current.next, state.captures, state.histories);
+        const noProgress = count > 0 && state.position === current.previous;
+        if (count < node2.max && (!noProgress || count < node2.min)) {
+          const repeat = task(() => ({ kind: "repeat", node: node2, count: count + 1, previous: state.position, next: current.next }));
+          push(state.position, task(() => ({ kind: "node", node: node2.child, next: repeat })), state.captures, state.histories);
+        }
+        continue;
+      }
+      const node = current.node;
+      switch (node.kind) {
+        case "empty":
+          push(state.position, current.next, state.captures, state.histories);
+          break;
+        case "start":
+          if (state.position === 0) push(state.position, current.next, state.captures, state.histories);
+          break;
+        case "end":
+          if (state.position === subject.length) push(state.position, current.next, state.captures, state.histories);
+          break;
+        case "dot":
+        case "literal":
+        case "set": {
+          const code = subject.charCodeAt(state.position);
+          if (state.position < subject.length && (node.kind === "dot" || node.kind === "literal" && node.code === code || node.kind === "set" && node.members[code])) {
+            push(state.position + 1, current.next, state.captures, state.histories);
+          }
+          break;
+        }
+        case "sequence": {
+          let next = current.next;
+          for (let index = node.children.length - 1; index >= 0; index--) {
+            ledger.charge("work", 1, signal);
+            await ledger.checkpoint(signal);
+            const following = next;
+            next = task(() => ({ kind: "node", node: node.children[index], next: following }));
+          }
+          push(state.position, next, state.captures, state.histories);
+          break;
+        }
+        case "alternative":
+          for (let index = node.children.length - 1; index >= 0; index--) {
+            ledger.charge("work", 1, signal);
+            await ledger.checkpoint(signal);
+            push(state.position, task(() => ({ kind: "node", node: node.children[index], next: current.next })), state.captures, state.histories);
+          }
+          break;
+        case "group": {
+          const captures = node.child.captured ? await resetDescendants(node.child, state.captures, ledger, signal) : state.captures;
+          const close = task(() => ({ kind: "close", group: node.index, start: state.position, next: current.next }));
+          push(state.position, task(() => ({ kind: "node", node: node.child, next: close })), captures, state.histories);
+          break;
+        }
+        case "repeat":
+          push(state.position, task(() => ({ kind: "repeat", node, count: 0, previous: -1, next: current.next })), state.captures, state.histories);
+          break;
+      }
+    }
+    if (best) {
+      ledger.charge("captureSlots", width, signal);
+      let bytes = best.position - start;
+      for (let group = 1; group < width; group++) {
+        ledger.charge("work", 1, signal);
+        const span = best.captures[group];
+        if (span) bytes += span.end - span.start;
+      }
+      ledger.charge("captureBytes", bytes, signal);
+      ledger.charge("allocationUnits", width * 2 + bytes + 4, signal);
+      const captures = best.captures.slice();
+      captures[0] = Object.freeze({ start, end: best.position });
+      const values = captures.map((span) => span === null ? "" : subject.slice(span.start, span.end));
+      ledger.check(signal);
+      return Object.freeze({ matched: true, captures: Object.freeze(captures), values: Object.freeze(values) });
+    }
+  }
+  ledger.charge("allocationUnits", 3, signal);
+  ledger.check(signal);
+  return Object.freeze({ matched: false, captures: Object.freeze([]), values: Object.freeze([]) });
+}
 
 // packages/safe-bash/src/shell/runtime.ts
 var defaultLimits = {
@@ -8836,6 +9510,8 @@ var defaultLimits = {
   maxSourceBytes: 1024 * 1024,
   maxExpansionFields: 1e4,
   maxExpansionBytes: 16 * 1024 * 1024,
+  maxWallClockMs: 3e4,
+  maxCpuMs: 3e4,
   pipeHighWaterMark: 64 * 1024
 };
 var shellBuiltinNames = /* @__PURE__ */ new Set([
@@ -8915,6 +9591,8 @@ var Budget = class {
     this.limits = limits;
     this.signal = signal ? AbortSignal.any([signal, this.controller.signal]) : this.controller.signal;
     this.values = new ValueArena(limits.maxExpansionBytes, limits.maxExpansionFields, () => this.signal.throwIfAborted(), (limit) => this.fail(limit));
+    this.#wallClockDeadline = Date.now() + limits.maxWallClockMs;
+    this.#armWallClock();
   }
   limits;
   values;
@@ -8924,12 +9602,34 @@ var Budget = class {
   sourceBytes = 0;
   controller = new AbortController();
   signal;
+  #wallClockTimer;
+  #wallClockDeadline = 0;
+  #cpuStarted = monotonicNow();
+  #armWallClock() {
+    const remaining = this.#wallClockDeadline - Date.now();
+    if (remaining <= 0) {
+      this.controller.abort(new ShellLimitError("maxWallClockMs"));
+      return;
+    }
+    this.#wallClockTimer = setTimeout(() => this.#armWallClock(), Math.min(remaining, 2147483647));
+    const timer = this.#wallClockTimer;
+    timer.unref?.();
+  }
+  close() {
+    if (this.#wallClockTimer !== void 0) clearTimeout(this.#wallClockTimer);
+    this.#wallClockTimer = void 0;
+  }
   fail(limit) {
     const error = new ShellLimitError(limit);
     this.controller.abort(error);
     throw error;
   }
+  cpuCheckpoint() {
+    this.signal.throwIfAborted();
+    if (monotonicNow() - this.#cpuStarted > this.limits.maxCpuMs) this.fail("maxCpuMs");
+  }
   tick() {
+    this.cpuCheckpoint();
     this.signal.throwIfAborted();
     if (++this.commands > this.limits.maxCommands) this.fail("maxCommands");
   }
@@ -9328,7 +10028,7 @@ var CdLookup = class {
       amount -= step;
       if (this.spent % 128 === 0) {
         this.signal.throwIfAborted();
-        await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+        await yieldTurn(this.signal);
         this.signal.throwIfAborted();
       }
     }
@@ -9424,7 +10124,7 @@ var DirectoryStackWork = class {
   async flushWork() {
     this.signal.throwIfAborted();
     if (this.flushed === this.spent) return;
-    await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+    await yieldTurn(this.signal);
     this.signal.throwIfAborted();
     this.flushed = this.spent;
   }
@@ -9745,6 +10445,7 @@ var Runtime = class _Runtime {
     this.cancellationDepth = cancellationDepth;
     this.cancellationMaxDepth = cancellationMaxDepth;
     this.outcomeFrame = outcomeFrame;
+    registerYieldCheckpoint(this.signal, () => this.budget.cpuCheckpoint());
   }
   fs;
   commands;
@@ -9760,19 +10461,6 @@ var Runtime = class _Runtime {
   cancellationDepth;
   cancellationMaxDepth;
   outcomeFrame;
-  static #ereRoots = /* @__PURE__ */ new WeakMap();
-  static registerEreRoot(budget, scope) {
-    const entry = { closed: false };
-    scope.register(async () => {
-      entry.closed = true;
-      try {
-        await entry.cleanup?.();
-      } finally {
-        _Runtime.#ereRoots.delete(budget);
-      }
-    });
-    _Runtime.#ereRoots.set(budget, entry);
-  }
   async ereDiagnostic(io, detail) {
     try {
       await this.diagnostic(io, detail);
@@ -9821,32 +10509,21 @@ var Runtime = class _Runtime {
       await textToken(operation, subject, this.signal);
       const name2 = "BASH_REMATCH";
       const watch = await store.watch(name2, operation, this.signal);
-      const entry = _Runtime.#ereRoots.get(this.budget);
-      if (!entry || entry.closed) throw new Error("ERE invocation owner is closed");
-      if (!entry.root) entry.root = new EreTransportRoot({ maxExpansionBytes: this.budget.limits.maxExpansionBytes, maxExpansionFields: this.budget.limits.maxExpansionFields }, (cleanup) => {
-        scope.assertOpen();
-        if (entry.closed) throw new Error("ERE invocation owner is closed");
-        entry.cleanup = cleanup;
+      const ledger = new EreLedger({
+        maxExpansionBytes: this.budget.limits.maxExpansionBytes,
+        maxExpansionFields: this.budget.limits.maxExpansionFields
       });
-      const session = entry.root.openSession((cleanup) => scope.register(cleanup));
       let result;
-      let sessionEscaping = false;
       try {
-        result = await session.execute({ pattern: fragments, subject }, this.signal);
+        const program = await compileEre(fragments, ledger, this.signal);
+        result = await matchEre(program, subject, ledger, this.signal);
       } catch (error) {
-        sessionEscaping = true;
         this.signal.throwIfAborted();
-        if (error instanceof EreTransportSemanticError || error instanceof EreUnsupportedError) {
+        if (error instanceof EreSyntaxError || error instanceof EreUnsupportedError) {
           await this.ereDiagnostic(io, `[[ ${error.message}`);
-          sessionEscaping = false;
           return 2;
         }
         throw error;
-      } finally {
-        await session.close().catch((error) => {
-          if (sessionEscaping) scope.failures.push(error);
-          else throw new NounsetDiagnosticFailure(error);
-        });
       }
       const status = result.matched ? 0 : 1;
       this.signal.throwIfAborted();
@@ -9861,8 +10538,8 @@ var Runtime = class _Runtime {
       const tickets = operation.reserve({ generation: true, version: true, epoch: true, work: 8 });
       const prepared = await store.prepareName(name2, operation, this.signal);
       staged = IndexedBinding.create(store.owner);
-      if (result.matched) for (let index = 0; index < result.spans.length; index++) {
-        const span = result.spans[index];
+      if (result.matched) for (let index = 0; index < result.captures.length; index++) {
+        const span = result.captures[index];
         const size = span === null ? 0 : span.end - span.start;
         operation.reserve({ payload: size, metadata: 32, work: size + 2 });
         const value2 = span === null ? "" : subject.slice(span.start, span.end);
@@ -10024,6 +10701,7 @@ var Runtime = class _Runtime {
   writeVariable(state, name2, value2, origin = "assignment") {
     if (arrayStore(state)?.get(name2)) throw new ArrayFailure(origin === "arithmetic" ? "indexed arithmetic is unsupported" : "indexed write requires prepared publication");
     if (state.readonlyVariables?.has(name2)) throw new Error(`${name2}: readonly variable`);
+    if (shellValueByteLength(value2) > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
     if (name2 === "OPTIND" && state.getopts?.integer && origin !== "arithmetic") {
       try {
         value2 = String(evaluateArithmetic(prepareArithmetic(shellValueText(value2) || "0"), this.arithmeticVariables(state)));
@@ -10533,7 +11211,7 @@ var Runtime = class _Runtime {
             completed.add(index);
             if (incoming) {
               const upstream = index - 1;
-              const close = setImmediate(() => {
+              const close = scheduleTurn(() => {
                 closing.delete(close);
                 if (written.has(upstream) && !completed.has(upstream)) controllers[upstream].abort(new PipelineClosed());
               });
@@ -10560,7 +11238,7 @@ var Runtime = class _Runtime {
       try {
         statuses = await interruptible(Promise.all(tasks), this.signal);
       } finally {
-        for (const close of closing) clearImmediate(close);
+        for (const close of closing) cancelTurn(close);
         for (const [index, controller] of controllers.entries()) if (!completed.has(index) || written.has(index)) controller.abort(new PipelineClosed());
         await Promise.all(pipes.map((pipe) => pipe.abort()));
       }
@@ -10625,7 +11303,7 @@ var Runtime = class _Runtime {
     originalIO = { ...originalIO, diagnosticLine, substitutionDiagnosticLine: originalIO.substitutionDiagnosticLines?.get(command) ?? diagnosticLine };
     if (command.kind === "subshell") originalIO = isolateIO(originalIO);
     this.budget.tick();
-    if (this.budget.commands % 128 === 0) await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+    if (this.budget.commands % 128 === 0) await yieldTurn(this.signal);
     this.signal.throwIfAborted();
     const inputs = /* @__PURE__ */ new Set();
     const outputs = /* @__PURE__ */ new Set();
@@ -10672,7 +11350,7 @@ var Runtime = class _Runtime {
             diagnosticFailure = error;
             throw error;
           }
-          if (error instanceof EreProfileLimitError || error instanceof EreTransportProfileLimitError) {
+          if (error instanceof EreProfileLimitError) {
             try {
               await this.diagnostic(io, `[[ ${error.message}`);
             } catch (reason) {
@@ -10741,7 +11419,7 @@ var Runtime = class _Runtime {
         for (const clause of command.clauses) {
           let matched = fallthrough;
           if (!matched) for (const word of clause.patterns) {
-            if (++patterns % 128 === 0) await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+            if (++patterns % 128 === 0) await yieldTurn(this.signal);
             const pattern = (await this.word(word, state, io, false, true)).join("");
             if (await matchesPattern(pattern, subject, work)) {
               matched = true;
@@ -10862,7 +11540,7 @@ var Runtime = class _Runtime {
         this.signal.throwIfAborted();
         for (const warning of warnings.splice(0)) await writeText(io.stderr, `shell: warning: ${warning}
 `);
-        if (++words % 128 === 0) await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+        if (++words % 128 === 0) await yieldTurn(this.signal);
         const part = (await this.word(word, state, io, false)).join("");
         size += import_buffer.Buffer.byteLength(part);
         if (size > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
@@ -11056,7 +11734,7 @@ var Runtime = class _Runtime {
     }
     const wordValues = await this.valueWords(commandWords, state, originalIO, ["export", "local", "readonly"].includes(commandWords[declarationIndex]?.plain ?? ""));
     const words = wordValues.map(shellValueText);
-    const special = state.profile === "sh" && specialBuiltinNames.has(words[0] ?? "");
+    const special2 = state.profile === "sh" && specialBuiltinNames.has(words[0] ?? "");
     const inlineInput = command.redirects.some((redirect) => redirect.document || redirect.operator === "<<<");
     const functionCommand = words.length > 0 && state.functions.has(words[0]);
     const isolatedInlineInput = inlineInput && words.length > 0 && !shellBuiltinNames.has(words[0]) && !functionCommand;
@@ -11084,7 +11762,7 @@ var Runtime = class _Runtime {
         if (assignment.append) value2 = concatShellValues([stateMonitor(state)?.values.get(assignment.name, state.variables[assignment.name] ?? "") ?? state.variables[assignment.name] ?? "", value2], io[valueScope]);
         if (state.readonlyVariables?.has(assignment.name)) {
           await this.diagnostic(io, `${assignment.name}: readonly variable`);
-          if (state.profile === "sh" || !words.length) throw new Flow("exit", state.profile === "sh" && (special || !words.length) ? 127 : 1);
+          if (state.profile === "sh" || !words.length) throw new Flow("exit", state.profile === "sh" && (special2 || !words.length) ? 127 : 1);
           continue;
         }
         if (!previous.has(assignment.name)) {
@@ -11175,7 +11853,7 @@ var Runtime = class _Runtime {
       if (error instanceof Flow) throw error;
       this.signal.throwIfAborted();
       const original = error instanceof ExecutionFailure ? error.original : error;
-      if (special && !(original instanceof ShellLimitError) && !(original instanceof ExpansionFailure) && !(original instanceof Flow) && !(original instanceof ShellSyntaxError)) {
+      if (special2 && !(original instanceof ShellLimitError) && !(original instanceof ExpansionFailure) && !(original instanceof Flow) && !(original instanceof ShellSyntaxError)) {
         throw new ExecutionFailure(new FatalCommandFailure(message(original), 1), error instanceof ExecutionFailure ? error.io : io, error instanceof ExecutionFailure ? error.diagnostic : void 0);
       }
       if (error instanceof ExecutionFailure) throw error;
@@ -11415,16 +12093,16 @@ var Runtime = class _Runtime {
         }
         if (selected?.kind === "builtin") {
           if (context2.command === "command" || context2.command === "builtin" || context2.command === "type") return { exitCode: await this.discoveryBuiltin(context2, state, io, assignments2) };
-          const special = state.profile === "sh" && !bypassFunctions && specialBuiltinNames.has(context2.command);
-          if (special) assignments2.clear();
-          if (context2.command === "." || context2.command === "source") return { exitCode: await this.sourceBuiltin(context2, state, { ...io, ...context2 }, special) };
-          if (context2.command === "eval") return { exitCode: await this.evalBuiltin(context2, state, { ...io, ...context2 }, special) };
+          const special2 = state.profile === "sh" && !bypassFunctions && specialBuiltinNames.has(context2.command);
+          if (special2) assignments2.clear();
+          if (context2.command === "." || context2.command === "source") return { exitCode: await this.sourceBuiltin(context2, state, { ...io, ...context2 }, special2) };
+          if (context2.command === "eval") return { exitCode: await this.evalBuiltin(context2, state, { ...io, ...context2 }, special2) };
           const builtinWork = this.builtin(context2, state, assignments2, (error, diagnostic2) => {
             builtinFailure = { error, diagnostic: diagnostic2 };
           }, bypassFunctions);
           const builtin = arrayStore(state) ? await interruptible(builtinWork, this.signal) : await builtinWork;
           if (builtin !== void 0) {
-            if (special && builtin !== 0 && context2.command !== "shift") throw new Flow("exit", builtin);
+            if (special2 && builtin !== 0 && context2.command !== "shift") throw new Flow("exit", builtin);
             return { exitCode: builtin };
           }
         }
@@ -11736,7 +12414,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     let status = 0;
     let lines2 = 0;
     while (true) {
-      if (++lines2 % 32 === 0) await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+      if (++lines2 % 32 === 0) await yieldTurn(this.signal);
       this.signal.throwIfAborted();
       const bytes = await input2.sourceLine();
       const eof = bytes === void 0;
@@ -12056,13 +12734,13 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       return status2;
     }
   }
-  async evalBuiltin(context, state, io, special) {
+  async evalBuiltin(context, state, io, special2) {
     const args = [...context.args];
     if (args[0] === "--") args.shift();
     else if (args[0]?.startsWith("-") && args[0] !== "-") {
       await this.diagnostic(io, `eval: -${args[0][1]}: invalid option`);
       await writeText(io.stderr, "eval: usage: eval [arg ...]\n");
-      if (special) throw new Flow("exit", 2);
+      if (special2) throw new Flow("exit", 2);
       return 2;
     }
     if (!args.length) return 0;
@@ -12078,7 +12756,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       throw error;
     }
     try {
-      return await this.runCurrentText(source, state, { ...io, diagnosticOffset: (io.diagnosticLine ?? 1) - 1 }, special, `${io.scriptName ?? "shell"}: eval`);
+      return await this.runCurrentText(source, state, { ...io, diagnosticOffset: (io.diagnosticLine ?? 1) - 1 }, special2, `${io.scriptName ?? "shell"}: eval`);
     } finally {
       const restore = () => {
         state.depth--;
@@ -12087,12 +12765,12 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       else restore();
     }
   }
-  async sourceBuiltin(context, state, io, special) {
+  async sourceBuiltin(context, state, io, special2) {
     const args = [...context.args];
     if (args[0] === "--") args.shift();
     else if (args[0]?.startsWith("-") && args[0] !== "-") {
       await this.diagnostic(io, `${context.command}: ${args[0]}: unsupported option`);
-      if (special) throw new Flow("exit", 2);
+      if (special2) throw new Flow("exit", 2);
       return 2;
     }
     const filename = args.shift();
@@ -12100,7 +12778,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       await this.diagnostic(io, `${context.command}: filename argument required`);
       await writeText(io.stderr, `${context.command}: usage: ${context.command} [-p path] filename [arguments]
 `);
-      if (special) throw new Flow("exit", 2);
+      if (special2) throw new Flow("exit", 2);
       return 2;
     }
     if (state.depth >= this.budget.limits.maxSubstitutionDepth) this.budget.fail("maxSubstitutionDepth");
@@ -12146,7 +12824,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       if (error instanceof ShellLimitError) throw error;
       if (errorCode(error) === "EFBIG") this.budget.fail("maxSourceBytes");
       const diagnostic2 = error instanceof CommandFailure ? error.message : filesystemDiagnostic(error, target) ?? `${target}: ${message(error)}`;
-      if (special) throw new FatalCommandFailure(diagnostic2, 1);
+      if (special2) throw new FatalCommandFailure(diagnostic2, 1);
       throw new CommandFailure(diagnostic2, error instanceof CommandFailure ? error.status : 1);
     }
     const positional = state.positional;
@@ -12175,7 +12853,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       throw error;
     }
     try {
-      return await this.runCurrentText(source, state, { ...io, scriptName: target, diagnosticOffset: 0, diagnosticLine: 1 }, special);
+      return await this.runCurrentText(source, state, { ...io, scriptName: target, diagnosticOffset: 0, diagnosticLine: 1 }, special2);
     } catch (error) {
       if (error instanceof Flow && error.kind === "return") return error.status;
       throw error;
@@ -12317,7 +12995,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     };
     const checkpoint = async () => {
       this.signal.throwIfAborted();
-      await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+      await yieldTurn(this.signal);
       this.signal.throwIfAborted();
     };
     const { args } = context;
@@ -12362,7 +13040,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     };
     const checkpoint = async () => {
       this.signal.throwIfAborted();
-      await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+      await yieldTurn(this.signal);
       this.signal.throwIfAborted();
     };
     if (!Array.isArray(context.args)) throw new CommandFailure("getopts: argument array required", 2);
@@ -13395,7 +14073,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     const match = async (start, end) => {
       work.remaining -= end - start + 1;
       if (work.remaining < 0) work.exhausted();
-      if (++attempts % 256 === 0) await new Promise((resolve) => setImmediate(resolve));
+      if (++attempts % 256 === 0) await yieldTurn(this.signal);
       this.signal.throwIfAborted();
       if (owner) await owner.ledger.checkpoint(this.signal, end - start + 1);
       return matches(slice(start, end));
@@ -13904,7 +14582,7 @@ var ShellInput = class _ShellInput {
       let length = 0;
       let pulls = 0;
       while (true) {
-        if (++pulls % 128 === 0) await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+        if (++pulls % 128 === 0) await yieldTurn(this.signal);
         const result = await this.#cursor.take(this.signal);
         if (result.done) {
           if (!length) return void 0;
@@ -13946,7 +14624,7 @@ var ShellInput = class _ShellInput {
     try {
       while (!terminated) {
         if (offset === chunk.length) {
-          if (++pulls % 128 === 0) await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+          if (++pulls % 128 === 0) await yieldTurn(this.signal);
           const result = await this.#cursor.take(this.signal);
           if (result.done) {
             break;
@@ -13962,7 +14640,7 @@ var ShellInput = class _ShellInput {
         }
         if (++length > this.budget.limits.maxOutputBytes) this.budget.fail("maxOutputBytes");
         if (length % 1024 === 0) {
-          await interruptible(new Promise((resolve) => setImmediate(resolve)), this.signal);
+          await yieldTurn(this.signal);
           this.signal.throwIfAborted();
         }
         if (byte === 0) continue;
@@ -14155,6 +14833,7 @@ var Shell = class {
   #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();
@@ -14217,6 +14896,7 @@ var Shell = class {
   }
   async exec(source, options2 = {}) {
     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);
     const cancellationState = new RuntimeCancellationState();
@@ -14227,7 +14907,6 @@ var Shell = class {
       controls: [{ role: "budget-control", signal: budget.controller.signal }]
     });
     try {
-      Runtime.registerEreRoot(budget, scope);
       owner.activate(boundary);
     } catch (error) {
       scope.failures.push(...boundary.close().failures);
@@ -14241,6 +14920,7 @@ var Shell = class {
     try {
       captured = await owner.capture(() => this.#execute(source, options2, scope, budget, boundary, cancellationState, owner));
     } finally {
+      budget.close();
       await scope.close();
     }
     const selection = owner.finish(captured);
@@ -14413,6 +15093,22 @@ shell: -c: line ${line}: \`${source.split("\n")[line - 1] ?? ""}'
   }
 };
 
+// packages/safe-bash/src/shell/worker-limits.ts
+init_platform();
+var cloudflareWorkerLimits = Object.freeze({
+  maxInputBytes: 4 * 1024 * 1024,
+  maxOutputBytes: 4 * 1024 * 1024,
+  maxCommands: 1e3,
+  maxLoopIterations: 1e3,
+  maxSubstitutionDepth: 16,
+  maxSourceBytes: 256 * 1024,
+  maxExpansionFields: 1e3,
+  maxExpansionBytes: 4 * 1024 * 1024,
+  maxWallClockMs: 1e4,
+  maxCpuMs: 1e4,
+  pipeHighWaterMark: 16 * 1024
+});
+
 // packages/safe-bash/src/fs/memory/index.ts
 init_platform();
 import { createMemoryFileSystem, MemoryFileSystem } from "poe-code/safe-fs/core";
@@ -14429,6 +15125,153 @@ import { createMountFileSystem, MountFileSystem } from "poe-code/safe-fs/core";
 init_platform();
 import { createOverlayFileSystem, OverlayFileSystem } from "poe-code/safe-fs/core";
 
+// packages/safe-bash/src/commands/network/fetch-transport.ts
+init_platform();
+
+// packages/safe-bash/src/commands/network/types.ts
+init_platform();
+var defaultNetworkLimits = Object.freeze({
+  maxUploadBytes: 64 * 1024 * 1024,
+  maxDownloadBytes: 64 * 1024 * 1024,
+  maxBufferBytes: 8 * 1024 * 1024,
+  maxHeaderBytes: 64 * 1024,
+  maxRedirects: 10,
+  maxRetries: 5,
+  maxUrls: 32,
+  maxTimeMs: 12e4
+});
+var cloudflareWorkerNetworkLimits = Object.freeze({
+  maxUploadBytes: 4 * 1024 * 1024,
+  maxDownloadBytes: 4 * 1024 * 1024,
+  maxBufferBytes: 1024 * 1024,
+  maxHeaderBytes: 32 * 1024,
+  maxRedirects: 2,
+  maxRetries: 1,
+  maxUrls: 8,
+  maxTimeMs: 1e4
+});
+var CurlError = class extends Error {
+  constructor(exitCode, message2) {
+    super(message2);
+    this.exitCode = exitCode;
+    this.name = "CurlError";
+  }
+  exitCode;
+};
+
+// packages/safe-bash/src/commands/network/fetch-transport.ts
+function requestBody(source, signal) {
+  if (!source) return void 0;
+  const iterator = source[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        signal.throwIfAborted();
+        const next = await iterator.next();
+        if (next.done) controller.close();
+        else controller.enqueue(next.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+}
+function createFetchTransport(options2 = {}) {
+  const fetchRequest = options2.fetch ?? globalThis.fetch;
+  if (typeof fetchRequest !== "function") throw new TypeError("Fetch is unavailable");
+  return async (input2) => {
+    input2.signal.throwIfAborted();
+    const url = new URL(input2.url);
+    if (url.protocol !== "http:" && url.protocol !== "https:") throw new CurlError(1, "Unsupported protocol");
+    const stopped = new AbortController();
+    const signal = AbortSignal.any([input2.signal, stopped.signal]);
+    const body = requestBody(input2.body, signal);
+    const headers = new Headers();
+    for (const [name2, value2] of input2.headers) headers.append(name2, value2);
+    const request = new Request(url, {
+      method: input2.method,
+      headers,
+      body,
+      credentials: "omit",
+      redirect: "manual",
+      signal,
+      ...body ? { duplex: "half" } : {}
+    });
+    let response;
+    const dispose = async () => {
+      stopped.abort();
+      if (response?.body) await response.body.cancel().catch(() => void 0);
+    };
+    input2.registerCleanup?.(dispose);
+    response = await fetchRequest(request);
+    const reader = response.body?.getReader();
+    const responseBody = reader ? (async function* () {
+      try {
+        while (true) {
+          input2.signal.throwIfAborted();
+          const next = await reader.read();
+          if (next.done) return;
+          yield next.value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    })() : (async function* () {
+    })();
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: [...response.headers.entries()],
+      body: responseBody,
+      dispose
+    };
+  };
+}
+
+// packages/safe-bash/src/commands/network/authorizer.ts
+init_platform();
+function privateHostname(input2) {
+  const hostname = input2.toLowerCase().replace(/\.$/u, "").replace(/^\[|\]$/gu, "");
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "::1") return true;
+  if (hostname.includes(":")) {
+    const first2 = hostname.split(":", 1)[0] ?? "";
+    return first2.startsWith("fc") || first2.startsWith("fd") || ["fe8", "fe9", "fea", "feb"].some((prefix2) => first2.startsWith(prefix2));
+  }
+  const parts = hostname.split(".");
+  if (parts.length !== 4 || parts.some((part) => !part || Array.from(part).some((character) => character < "0" || character > "9"))) return false;
+  const octets = parts.map(Number);
+  if (octets.some((value2) => value2 < 0 || value2 > 255)) return false;
+  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 = {}) {
+  const origins = /* @__PURE__ */ new Set();
+  const hosts = /* @__PURE__ */ new Set();
+  for (const entry of allowlist === "*" ? [] : allowlist) {
+    const value2 = entry.trim();
+    if (!value2) throw new TypeError("Origin allowlist entries must not be empty");
+    if (value2.includes("://")) {
+      const url = new URL(value2);
+      if (url.pathname !== "/" || url.search || url.hash || url.username || url.password) {
+        throw new TypeError(`Origin allowlist entry must be an origin: ${entry}`);
+      }
+      origins.add(url.origin);
+    } else {
+      if (value2.includes("/") || value2.includes("@")) throw new TypeError(`Invalid hostname allowlist entry: ${entry}`);
+      hosts.add(value2.toLowerCase().replace(/\.$/u, ""));
+    }
+  }
+  return (request) => {
+    const url = new URL(request.url);
+    const hostname = url.hostname.toLowerCase().replace(/\.$/u, "");
+    if (options2.denyPrivateNetworks && privateHostname(hostname)) return false;
+    return allowlist === "*" || origins.has(url.origin) || hosts.has(hostname);
+  };
+}
+
 // packages/safe-bash/src/browser.ts
 function createBrowserCommands() {
   return [
@@ -14467,14 +15310,18 @@ export {
   assertPathWithin,
   basename,
   browserCommands,
+  cloudflareWorkerLimits,
+  cloudflareWorkerNetworkLimits,
   collectBytes2 as collectBytes,
   collectText,
   composeMiddleware,
   createBrowserCommands,
   createBytePipe,
   createCommandArguments,
+  createFetchTransport,
   createMemoryFileSystem,
   createMountFileSystem,
+  createOriginAuthorizer,
   createOutputOperation,
   createOverlayFileSystem,
   createReadOnlyFileSystem,