@poe-platform/safe-bash 0.1.433 → 0.1.435

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
           ]);
@@ -10603,7 +10609,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,9 +10628,12 @@ var StateMonitor = class {
   #internalEnrollment;
   #restorations;
   #overlays;
+  #retireCleanup;
   closeValues() {
     this.values.close();
     this.positionals.close();
+    this.#retireCleanup?.();
+    this.#retireCleanup = void 0;
   }
   changedValue(target, field, key) {
     if (field === "state") {
@@ -12592,7 +12601,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 +12611,7 @@ var InvocationCancellationOwner = class {
   #failures;
   #outcomes;
   #publicPromise;
+  #retireCleanup;
   #resolveFinalized;
   #admissionOpen = true;
   #boundary;
@@ -12678,6 +12688,7 @@ var InvocationCancellationOwner = class {
       this.#outcomes.discard(this.#record);
       this.#closeBoundary();
       this.#resolveFinalized();
+      this.#retireCleanup();
     }
   }
   async #finishOnce(barrier, captured) {
@@ -12690,6 +12701,7 @@ var InvocationCancellationOwner = class {
       return selection;
     } finally {
       this.#resolveFinalized();
+      this.#retireCleanup();
     }
   }
   #closeBoundary() {
@@ -14044,10 +14056,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 +14083,11 @@ var Runtime = class _Runtime {
                   }
                 }
               } finally {
-                release();
+                try {
+                  await outputScope?.close();
+                } finally {
+                  release();
+                }
               }
             });
             const output2 = this.budget.sink(target2.sink, this.signal);
@@ -14304,7 +14328,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 +14937,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);
@@ -18829,10 +18857,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 +19049,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;
+            }
+            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));
             }
-          } 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 });
+            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 +19292,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 +19625,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();