@poe-platform/safe-bash 0.1.434 → 0.1.436

package/dist/safe-bash/browser.js

@@ -9219,7 +9219,7 @@ var InvocationScope = class _InvocationScope {
   failures;
   parent;
   #children = /* @__PURE__ */ new Set();
-  #callbacks = [];
+  #callbacks = /* @__PURE__ */ new Map();
   #finalizers = [];
   #work = /* @__PURE__ */ new Set();
   #controller = new AbortController();
@@ -9246,7 +9246,11 @@ var InvocationScope = class _InvocationScope {
   register(cleanup) {
     this.assertOpen();
     if (typeof cleanup !== "function") throw new TypeError("Cleanup must be callable");
-    this.#callbacks.push(cleanup);
+    const registration = /* @__PURE__ */ Symbol();
+    this.#callbacks.set(registration, cleanup);
+    return () => {
+      this.#callbacks.delete(registration);
+    };
   }
   run(operation) {
     this.assertOpen();
@@ -9279,9 +9283,11 @@ var InvocationScope = class _InvocationScope {
   close() {
     if (!this.#drain) {
       this.#drain = Promise.resolve().then(async () => {
+        const callbacks = [...this.#callbacks.values()];
+        this.#callbacks.clear();
         try {
           await Promise.all([
-            ...this.#callbacks.splice(0).map((cleanup) => this.cleanup(cleanup)),
+            ...callbacks.map((cleanup) => this.cleanup(cleanup)),
             ...[...this.#children].map((child) => child.close()),
             ...this.#work
           ]);
@@ -9308,6 +9314,39 @@ function throwCleanupFailures(failures) {
 
 // packages/safe-bash/src/shell/getopts.ts
 init_platform();
+var ownedInputs = /* @__PURE__ */ new WeakMap();
+function getoptsInputAllocationSize(argumentsCount) {
+  return { bytes: 256 + argumentsCount * 8, slots: argumentsCount + 2 };
+}
+async function createGetoptsInput(args, allocation, controls2) {
+  const work = new ScanWork(controls2);
+  if (!Array.isArray(args)) throw new GetoptsError("INVALID_INPUT", "Getopts requires an argument array");
+  const length = args.length;
+  if (length > work.maxArguments) throw new GetoptsError("ARGUMENT_LIMIT", "Getopts argument limit exceeded");
+  const size = getoptsInputAllocationSize(length);
+  const reservation = allocation?.reserve(size.bytes, size.slots);
+  try {
+    const snapshot = [];
+    for (let index = 0; index < length; index++) {
+      const waiting = work.step();
+      if (waiting) await waiting;
+      snapshot.push(args[index]);
+    }
+    await work.flush();
+    if (args.length !== length) throw new GetoptsError("INVALID_INPUT", "Getopts argument extent changed during admission");
+    const input3 = Object.freeze({ args: Object.freeze(snapshot) });
+    reservation?.commit(input3);
+    ownedInputs.set(input3, {});
+    return input3;
+  } catch (error) {
+    try {
+      reservation?.release();
+    } catch (cleanup) {
+      throw new AggregateError([error, cleanup], "Getopts input allocation and release failed");
+    }
+    throw error;
+  }
+}
 var GetoptsError = class extends Error {
   constructor(code, message2) {
     super(message2);
@@ -9372,6 +9411,9 @@ var ScanWork = class {
   check() {
     this.signal?.throwIfAborted();
   }
+  get inputBytes() {
+    return this.bytes;
+  }
   step() {
     this.check();
     if (this.steps === this.maxSteps) throw new GetoptsError("STEP_LIMIT", "Getopts work step limit exceeded");
@@ -9428,19 +9470,25 @@ async function validateString(value2, work, optstring = false) {
     else work.addBytes(3);
   }
 }
-async function scanGetopts(state, optstring, args, options3) {
+async function scanGetopts(state, optstring, input3, 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);
+  const owned = ownedInputs.get(input3);
+  const args = owned ? input3.args : input3;
   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");
   const starting = work.step();
   if (starting) await starting;
   await validateString(optstring, work, true);
-  for (let argument = 0; argument < args.length; argument++) {
-    const waiting = work.step();
-    if (waiting) await waiting;
-    await validateString(args[argument], work);
+  const specificationBytes = work.inputBytes;
+  if (owned?.bytes !== void 0) work.addBytes(owned.bytes);
+  else {
+    for (let argument = 0; argument < args.length; argument++) {
+      const waiting = work.step();
+      if (waiting) await waiting;
+      await validateString(args[argument], work);
+    }
   }
   const silent = optstring.startsWith(":");
   const specification = new Int8Array(128).fill(-1);
@@ -9456,6 +9504,7 @@ async function scanGetopts(state, optstring, args, options3) {
     const waiting = work.step();
     if (waiting) await waiting;
     await work.flush();
+    if (owned) owned.bytes = work.inputBytes - specificationBytes;
     return { state: active === void 0 ? { index } : { index, active: { ...active } }, kind, status: kind === "end" ? 1 : 0, option: option2, optind: index, argument, diagnostic: diagnostic3 };
   };
   const end = () => {
@@ -10603,7 +10652,7 @@ var StateMonitor = class {
     monitors.set(raw, this);
     monitors.set(this.proxy, this);
     if (session.monitors) session.monitors.add(this);
-    else session.scope.register(async () => {
+    else this.#retireCleanup = session.scope.register(async () => {
       await session.scope.drainWork();
       this.closeValues();
     });
@@ -10622,18 +10671,46 @@ var StateMonitor = class {
   #internalEnrollment;
   #restorations;
   #overlays;
+  #retireCleanup;
+  #positionalRevision = {};
+  #getoptsInput;
   closeValues() {
     this.values.close();
     this.positionals.close();
+    this.invalidateGetoptsInput();
+    this.#retireCleanup?.();
+    this.#retireCleanup = void 0;
+  }
+  get positionalRevision() {
+    return this.#positionalRevision;
+  }
+  get getoptsInput() {
+    return this.#getoptsInput?.input;
+  }
+  retainGetoptsInput(revision, input3, allocation) {
+    this.session.scope.assertOpen();
+    if (revision !== this.#positionalRevision) return false;
+    this.#getoptsInput?.allocation.close();
+    this.#getoptsInput = { input: input3, allocation };
+    return true;
+  }
+  invalidateGetoptsInput() {
+    this.#getoptsInput?.allocation.close();
+    this.#getoptsInput = void 0;
+    this.#positionalRevision = {};
   }
   changedValue(target, field, key) {
     if (field === "state") {
       if (key === "variables") this.values.invalidate();
-      if (key === "positional") this.positionals.invalidate();
+      if (key === "positional") {
+        this.positionals.invalidate();
+        this.invalidateGetoptsInput();
+      }
     } else if (field === "variables" && (this.raw.variables === target || this.raw.variables === this.#wrapped.get(target))) {
       this.values.invalidate(String(key));
     } else if (field === "positional" && (this.raw.positional === target || this.raw.positional === this.#wrapped.get(target))) {
       this.positionals.invalidate();
+      this.invalidateGetoptsInput();
     }
   }
   internalOwner() {
@@ -12592,7 +12669,7 @@ var InvocationCancellationOwner = class {
     this.finalized = new Promise((resolve) => {
       this.#resolveFinalized = resolve;
     });
-    parent.register(async () => {
+    this.#retireCleanup = parent.register(async () => {
       this.requestClose();
       await this.finalized;
     });
@@ -12602,6 +12679,7 @@ var InvocationCancellationOwner = class {
   #failures;
   #outcomes;
   #publicPromise;
+  #retireCleanup;
   #resolveFinalized;
   #admissionOpen = true;
   #boundary;
@@ -12678,6 +12756,7 @@ var InvocationCancellationOwner = class {
       this.#outcomes.discard(this.#record);
       this.#closeBoundary();
       this.#resolveFinalized();
+      this.#retireCleanup();
     }
   }
   async #finishOnce(barrier, captured) {
@@ -12690,6 +12769,7 @@ var InvocationCancellationOwner = class {
       return selection;
     } finally {
       this.#resolveFinalized();
+      this.#retireCleanup();
     }
   }
   #closeBoundary() {
@@ -14044,10 +14124,18 @@ var Runtime = class _Runtime {
               if (--file.references === 0 && this.outputFiles.get(path) === file) this.outputFiles.delete(path);
             };
             let target2;
+            let outputScope;
             try {
-              target2 = await openFileOutput({ fs: this.fs, signal: this.signal, registerCleanup: (cleanup) => io[invocationScope].register(cleanup) }, path, append ? "a" : "w", random ? incremental : void 0);
+              outputScope = io[invocationScope].child();
+              target2 = await openFileOutput({ fs: this.fs, signal: this.signal, registerCleanup: (cleanup) => {
+                outputScope.register(cleanup);
+              } }, path, append ? "a" : "w", random ? incremental : void 0);
             } catch (error) {
-              release();
+              try {
+                await outputScope?.close();
+              } finally {
+                release();
+              }
               throw error;
             }
             outputs.add(async (completion) => {
@@ -14063,7 +14151,11 @@ var Runtime = class _Runtime {
                   }
                 }
               } finally {
-                release();
+                try {
+                  await outputScope?.close();
+                } finally {
+                  release();
+                }
               }
             });
             const output2 = this.budget.sink(target2.sink, this.signal);
@@ -14304,7 +14396,9 @@ var Runtime = class _Runtime {
       fs: this.fs,
       signal: this.commandSignal,
       executionScope: this.budget.executionScope,
-      registerCleanup: (cleanup) => scope.register(cleanup),
+      registerCleanup: (cleanup) => {
+        scope.register(cleanup);
+      },
       invoke: (name3, args, options3) => {
         const invocation = this.invoke(name3, args, options3, context, state, scope);
         void invocation.catch(() => void 0);
@@ -14911,7 +15005,9 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         stdout: this.budget.sink(incoming.stdout, runtime.signal),
         stderr: this.budget.sink(incoming.stderr, runtime.signal),
         signal: this.commandSignal,
-        registerCleanup: (cleanup) => scope.register(cleanup),
+        registerCleanup: (cleanup) => {
+          scope.register(cleanup);
+        },
         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);
@@ -15489,26 +15585,49 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     }
     const optstring = context.args[offset];
     const name2 = context.args[offset + 1];
-    const args = context.args.length > offset + 2 ? context.args.slice(offset + 2) : state.positional;
-    if (args.length > fields) this.budget.fail("maxExpansionFields");
-    for (let index = 0; index < args.length; index++) {
-      this.signal.throwIfAborted();
-      admit2(args[index]);
-      if ((index + 1) % 128 === 0) await checkpoint();
-    }
-    const maxBytes = saturatedProduct(bytes2, saturatedSum(args.length, 1));
-    const maxSteps = saturatedSum(saturatedProduct(maxBytes, 2), saturatedSum(args.length, 2));
-    state.getopts ??= cloneGetoptsBinding(state);
+    const explicit = context.args.length > offset + 2;
+    const monitor = explicit ? void 0 : stateMonitor(state);
+    const revision = monitor?.positionalRevision;
+    const supplied = explicit ? context.args.slice(offset + 2) : state.positional;
+    if (supplied.length > fields) this.budget.fail("maxExpansionFields");
+    const maxBytes = saturatedProduct(bytes2, saturatedSum(supplied.length, 1));
+    const maxSteps = saturatedSum(saturatedProduct(maxBytes, 2), saturatedSum(supplied.length, 2));
+    const work = { maxArguments: fields, maxBytes, maxSteps, yieldEvery: 128, signal: this.signal, checkpoint };
+    let input3 = monitor?.getoptsInput;
+    let allocation;
     let result;
     try {
-      result = await scanGetopts(state.getopts.cursor, optstring, args, {
-        reportErrors: state.variables.OPTERR === void 0 || state.variables.OPTERR === "" || decimalIndex(state.variables.OPTERR) !== 0,
-        work: { maxArguments: fields, maxBytes, maxSteps, yieldEvery: 128, signal: this.signal, checkpoint }
-      });
-    } catch (error) {
+      if (!input3 && monitor) {
+        const size = getoptsInputAllocationSize(supplied.length);
+        const arena = this.budget.values;
+        const usage = arena.usage;
+        if (size.bytes + 64 <= arena.maximumBytes - usage.bytes && size.slots + 1 <= arena.maximumSlots - usage.slots) {
+          allocation = arena.scope();
+          input3 = await createGetoptsInput(supplied, allocation, work);
+        }
+      }
+      const args = input3?.args ?? supplied;
+      if (!input3 || allocation) for (let index = 0; index < args.length; index++) {
+        this.signal.throwIfAborted();
+        admit2(args[index]);
+        if ((index + 1) % 128 === 0) await checkpoint();
+      }
+      state.getopts ??= cloneGetoptsBinding(state);
+      try {
+        result = await scanGetopts(state.getopts.cursor, optstring, input3 ?? args, {
+          reportErrors: state.variables.OPTERR === void 0 || state.variables.OPTERR === "" || decimalIndex(state.variables.OPTERR) !== 0,
+          work
+        });
+      } catch (error) {
+        this.signal.throwIfAborted();
+        if (error instanceof GetoptsError && (error.code === "NON_ASCII_OPTION" || error.code === "INVALID_INPUT")) throw new CommandFailure(`getopts: ${error.message}`, 2);
+        throw error;
+      }
       this.signal.throwIfAborted();
-      if (error instanceof GetoptsError && (error.code === "NON_ASCII_OPTION" || error.code === "INVALID_INPUT")) throw new CommandFailure(`getopts: ${error.message}`, 2);
-      throw error;
+      if (monitor && monitor.positionalRevision !== revision) throw new CommandFailure("getopts: positional arguments changed during validation", 2);
+      if (allocation && monitor.retainGetoptsInput(revision, input3, allocation)) allocation = void 0;
+    } finally {
+      allocation?.close();
     }
     this.signal.throwIfAborted();
     state.getopts.cursor = result.state;
@@ -18829,10 +18948,32 @@ function extendedSource(source) {
   }
   return result;
 }
+var NfaStorage = class {
+  constructor(budget) {
+    this.budget = budget;
+  }
+  budget;
+  used = 0;
+  reserve(bytes2) {
+    this.budget.step(0);
+    if (!Number.isSafeInteger(bytes2) || bytes2 < 0 || bytes2 > this.budget.maxBufferBytes - this.used) {
+      throw new ProgramError("regular expression state buffer limit exceeded");
+    }
+    this.used += bytes2;
+  }
+  release(bytes2) {
+    if (!Number.isSafeInteger(bytes2) || bytes2 < 0 || bytes2 > this.used) throw new ProgramError("invalid regular expression state accounting");
+    this.used -= bytes2;
+  }
+  clear() {
+    this.used = 0;
+  }
+};
 var Pattern = class {
   groupCount;
   code = [];
   anchored;
+  linear;
   constructor(source, extended = true, ignoreCase = false) {
     if (source.length > 8192) throw new ProgramError("regular expression exceeds 8192 bytes");
     if (!extended) source = extendedSource(source);
@@ -18999,92 +19140,188 @@ var Pattern = class {
     };
     compile(root);
     emit({ kind: "match" });
+    this.linear = this.code.every((instruction) => instruction.kind === "character" || instruction.kind === "begin" || instruction.kind === "end" || instruction.kind === "match");
   }
-  find(text, budget, from = 0) {
-    for (let start = from; start <= text.length && (!this.anchored || start === 0); start++) {
-      const positions = /* @__PURE__ */ new Map([[start, [{ pc: 0, captures: [] }]]]);
-      let best;
-      let bestCaptures = [];
-      let queued = 1;
-      const preferCaptures = (captures) => {
-        for (let index = 1; index <= this.groupCount; index++) {
-          const begin = captures[index * 2];
-          const end = captures[index * 2 + 1];
-          const priorBegin = bestCaptures[index * 2];
-          const priorEnd = bestCaptures[index * 2 + 1];
-          const length = begin === void 0 || end === void 0 ? -1 : end - begin;
-          const priorLength = priorBegin === void 0 || priorEnd === void 0 ? -1 : priorEnd - priorBegin;
-          if (length !== priorLength) return length > priorLength;
-        }
-        return false;
-      };
-      for (let position = start; positions.size && position <= text.length; position++) {
-        budget.step();
-        const pending = positions.get(position)?.reverse() ?? [];
-        positions.delete(position);
-        queued -= pending.length;
-        const visited = /* @__PURE__ */ new Set();
-        let stateBytes = 0;
-        const enqueue = (destination, thread) => {
-          if (destination === position) pending.push(thread);
-          else {
-            const waiting = positions.get(destination);
-            if (waiting) waiting.push(thread);
-            else positions.set(destination, [thread]);
-            queued++;
-          }
-          if ((queued + pending.length) * (32 + this.groupCount * 16) > budget.maxBufferBytes) throw new ProgramError("regular expression state buffer limit exceeded");
-        };
-        while (pending.length) {
-          budget.step();
-          const thread = pending.pop();
-          const state = this.groupCount ? `${thread.pc}:${thread.captures.join(",")}` : thread.pc;
-          if (visited.has(state)) continue;
-          visited.add(state);
-          stateBytes += typeof state === "string" ? state.length * 2 + 32 : 16;
-          if (stateBytes > budget.maxBufferBytes) throw new ProgramError("regular expression state buffer limit exceeded");
-          const instruction = this.code[thread.pc];
+  async find(text, budget, from = 0) {
+    await budget.checkpoint();
+    let units = 0;
+    const work = (count2 = 1) => {
+      budget.step(count2);
+      units += count2;
+      if (units < 64) return void 0;
+      units %= 64;
+      return budget.checkpoint();
+    };
+    if (this.linear) {
+      for (let start = from; start <= text.length && (!this.anchored || start === 0); start++) {
+        let position = start;
+        for (const instruction of this.code) {
+          const paused = work(2);
+          if (paused) await paused;
           if (instruction.kind === "character") {
-            if (position < text.length && instruction.accepts(text[position])) enqueue(position + 1, { pc: thread.pc + 1, captures: thread.captures });
-          } else if (instruction.kind === "backreference") {
-            const begin = thread.captures[instruction.index * 2];
-            const end = thread.captures[instruction.index * 2 + 1];
-            if (begin === void 0 || end === void 0 || position + end - begin > text.length) continue;
-            let matches = true;
-            for (let offset = 0; offset < end - begin; offset++) {
-              budget.step();
-              const expected = text[begin + offset];
-              const actual = text[position + offset];
-              if (instruction.ignoreCase ? expected.toLowerCase() !== actual.toLowerCase() : expected !== actual) {
-                matches = false;
-                break;
+            if (position >= text.length || !instruction.accepts(text[position])) break;
+            position++;
+          } else if (instruction.kind === "begin" && position !== 0 || instruction.kind === "end" && position !== text.length) break;
+          else if (instruction.kind === "match") {
+            if (position - start > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+            const copied = work(position - start);
+            if (copied) await copied;
+            const match = { start, end: position, groups: [text.slice(start, position)] };
+            await budget.checkpoint();
+            return match;
+          }
+        }
+      }
+      return void 0;
+    }
+    const storage = new NfaStorage(budget);
+    const positionDigits = String(text.length).length;
+    const instructionDigits = String(this.code.length).length;
+    try {
+      for (let start = from; start <= text.length && (!this.anchored || start === 0); start++) {
+        storage.reserve(256);
+        const positions = /* @__PURE__ */ new Map([[start, [{ pc: 0, captures: [], bytes: 64 }]]]);
+        let bestEnd;
+        let bestCaptures = [];
+        let bestBytes = 0;
+        try {
+          for (let position = start; positions.size && position <= text.length; position++) {
+            const advanced = work();
+            if (advanced) await advanced;
+            const pending = positions.get(position);
+            if (!pending) continue;
+            const reversed = work(pending.length);
+            if (reversed) await reversed;
+            pending.reverse();
+            positions.delete(position);
+            const visited = /* @__PURE__ */ new Set();
+            let stateBytes = 0;
+            const enqueue = (destination, pc, captures, saveSlot) => {
+              const length = saveSlot === void 0 ? captures.length : Math.max(captures.length, saveSlot + 1);
+              const bytes2 = 64 + length * 8;
+              const waiting = destination === position ? pending : positions.get(destination);
+              storage.reserve(bytes2 + (waiting ? 0 : 64));
+              const saved = saveSlot === void 0 ? captures : [...captures];
+              if (saveSlot !== void 0) saved[saveSlot] = position;
+              const thread = { pc, captures: saved, bytes: bytes2 };
+              if (waiting) waiting.push(thread);
+              else positions.set(destination, [thread]);
+            };
+            while (pending.length) {
+              const paused = work();
+              if (paused) await paused;
+              const thread = pending.pop();
+              try {
+                let state = thread.pc;
+                let bytes2 = 32;
+                if (this.groupCount) {
+                  const joinedLength = Math.max(0, thread.captures.length - 1) + thread.captures.length * positionDigits;
+                  const stateLength = instructionDigits + 1 + joinedLength;
+                  const serialized = work(stateLength);
+                  if (serialized) await serialized;
+                  const reserved = 32 + joinedLength * 2 + 64 + stateLength * 2;
+                  storage.reserve(reserved);
+                  state = `${thread.pc}:${thread.captures.join(",")}`;
+                  bytes2 = 64 + state.length * 2;
+                  storage.release(reserved - bytes2);
+                } else storage.reserve(bytes2);
+                if (visited.has(state)) {
+                  storage.release(bytes2);
+                  continue;
+                }
+                visited.add(state);
+                stateBytes += bytes2;
+                const instruction = this.code[thread.pc];
+                if (instruction.kind === "character") {
+                  if (position < text.length && instruction.accepts(text[position])) enqueue(position + 1, thread.pc + 1, thread.captures);
+                } else if (instruction.kind === "backreference") {
+                  const begin = thread.captures[instruction.index * 2];
+                  const end = thread.captures[instruction.index * 2 + 1];
+                  if (begin === void 0 || end === void 0 || position + end - begin > text.length) continue;
+                  let matches = true;
+                  for (let offset = 0; offset < end - begin; offset++) {
+                    const compared = work();
+                    if (compared) await compared;
+                    const expected = text[begin + offset];
+                    const actual = text[position + offset];
+                    if (instruction.ignoreCase ? expected.toLowerCase() !== actual.toLowerCase() : expected !== actual) {
+                      matches = false;
+                      break;
+                    }
+                  }
+                  if (matches) enqueue(position + end - begin, thread.pc + 1, thread.captures);
+                } else if (instruction.kind === "match") {
+                  let preferred2 = bestEnd === void 0 || position > bestEnd;
+                  if (position === bestEnd) for (let index = 1; index <= this.groupCount; index++) {
+                    const compared = work();
+                    if (compared) await compared;
+                    const begin = thread.captures[index * 2];
+                    const end = thread.captures[index * 2 + 1];
+                    const priorBegin = bestCaptures[index * 2];
+                    const priorEnd = bestCaptures[index * 2 + 1];
+                    const length = begin === void 0 || end === void 0 ? -1 : end - begin;
+                    const priorLength = priorBegin === void 0 || priorEnd === void 0 ? -1 : priorEnd - priorBegin;
+                    if (length !== priorLength) {
+                      preferred2 = length > priorLength;
+                      break;
+                    }
+                  }
+                  if (preferred2) {
+                    const retained = 32 + thread.captures.length * 8;
+                    storage.reserve(retained);
+                    bestEnd = position;
+                    bestCaptures = thread.captures;
+                    storage.release(bestBytes);
+                    bestBytes = retained;
+                  }
+                } else if (instruction.kind === "split") {
+                  enqueue(position, instruction.second, thread.captures);
+                  enqueue(position, instruction.first, thread.captures);
+                } else if (instruction.kind === "jump") enqueue(position, instruction.target, thread.captures);
+                else if (instruction.kind === "save") {
+                  const copied = work(Math.max(thread.captures.length, instruction.slot + 1));
+                  if (copied) await copied;
+                  enqueue(position, thread.pc + 1, thread.captures, instruction.slot);
+                } else if (instruction.kind === "begin" ? position === 0 : position === text.length) enqueue(position, thread.pc + 1, thread.captures);
+              } finally {
+                storage.release(thread.bytes);
               }
             }
-            if (matches) enqueue(position + end - begin, { pc: thread.pc + 1, captures: thread.captures });
-          } else if (instruction.kind === "match") {
-            if (!best || position > best.end || position === best.end && preferCaptures(thread.captures)) {
-              const groups = [text.slice(start, position)];
-              for (let index = 1; index <= this.groupCount; index++) {
-                const begin = thread.captures[index * 2];
-                const end = thread.captures[index * 2 + 1];
-                groups.push(begin === void 0 || end === void 0 ? void 0 : text.slice(begin, end));
-              }
-              best = { start, end: position, groups };
-              bestCaptures = thread.captures;
+            visited.clear();
+            storage.release(stateBytes + 64);
+          }
+          if (bestEnd !== void 0) {
+            let characters = bestEnd - start;
+            for (let index = 1; index <= this.groupCount; index++) {
+              const counted = work();
+              if (counted) await counted;
+              const begin = bestCaptures[index * 2];
+              const end = bestCaptures[index * 2 + 1];
+              if (begin !== void 0 && end !== void 0) characters += end - begin;
             }
-          } else if (instruction.kind === "split") {
-            pending.push({ pc: instruction.second, captures: thread.captures }, { pc: instruction.first, captures: thread.captures });
-          } else if (instruction.kind === "jump") pending.push({ pc: instruction.target, captures: thread.captures });
-          else if (instruction.kind === "save") {
-            const captures = [...thread.captures];
-            captures[instruction.slot] = position;
-            pending.push({ pc: thread.pc + 1, captures });
-          } else if (instruction.kind === "begin" ? position === 0 : position === text.length) pending.push({ pc: thread.pc + 1, captures: thread.captures });
+            const copied = work(characters);
+            if (copied) await copied;
+            storage.reserve(64 + (this.groupCount + 1) * 40 + characters * 2);
+            const groups = [text.slice(start, bestEnd)];
+            for (let index = 1; index <= this.groupCount; index++) {
+              const materialized = work();
+              if (materialized) await materialized;
+              const begin = bestCaptures[index * 2];
+              const end = bestCaptures[index * 2 + 1];
+              groups.push(begin === void 0 || end === void 0 ? void 0 : text.slice(begin, end));
+            }
+            await budget.checkpoint();
+            return { start, end: bestEnd, groups };
+          }
+        } finally {
+          positions.clear();
+          storage.clear();
         }
       }
-      if (best) return best;
+      return void 0;
+    } finally {
+      storage.clear();
     }
-    return void 0;
   }
 };
 async function replacementLength(replacement, match, budget, available) {
@@ -19146,7 +19383,7 @@ async function substitute(text, pattern, replacement, budget, global, occurrence
     while (search <= text.length) {
       await budget.checkpoint();
       budget.step();
-      const match = pattern.find(text, budget, search);
+      const match = await pattern.find(text, budget, search);
       if (!match) break;
       if (match.start === match.end && match.start === previousEnd) {
         search = match.end + 1;
@@ -19479,7 +19716,7 @@ async function execute(program, context, files, quiet, budget, separator, output
         if (terminated) outputState.unterminatedFiles.delete(path);
         else outputState.unterminatedFiles.add(path);
       };
-      const matches = async (address) => address.kind === "number" ? number === address.number : address.kind === "last" ? (await peekNext()).done === true : getPattern(address.pattern).find(pattern, budget) !== void 0;
+      const matches = async (address) => address.kind === "number" ? number === address.number : address.kind === "last" ? (await peekNext()).done === true : await getPattern(address.pattern).find(pattern, budget) !== void 0;
       for (let pc = 0; pc < program.length; ) {
         budget.step();
         await budget.checkpoint();