@poe-platform/safe-bash 0.1.800 → 0.1.801

package/dist/safe-bash-regex-engine/ere/matcher.js

@@ -20,6 +20,23 @@ import {
 
 // packages/safe-bash-regex-engine/src/ere/matcher.ts
 init_buffer();
+function spanStateKey(position, task, nodeIds) {
+  let key = String(position);
+  for (let current = task; current; current = current.next) {
+    if (current.kind === "close") return `${key}/close`;
+    let id = nodeIds.get(current.node);
+    if (id === void 0) {
+      id = nodeIds.size;
+      nodeIds.set(current.node, id);
+    }
+    key += `/${id}`;
+    if (current.kind === "repeat") {
+      const count = current.node.max === Infinity ? Math.min(current.count, Math.max(1, current.node.min)) : current.count;
+      key += `:${count}:${current.previous === position ? 1 : 0}`;
+    }
+  }
+  return key;
+}
 var initialCharacters = /* @__PURE__ */ new WeakMap();
 var sequenceNullNextTasks = /* @__PURE__ */ new WeakMap();
 var SINGLE_NULL_CAPTURES = Object.freeze([null]);
@@ -317,9 +334,14 @@ function tryMatchEreAsciiRangeNfaSync(root, initial, buf, rStart, rLen, ledger,
   }
   if (unbounded) {
     if (signal?.aborted) throw signal.reason;
+    const nodeIds = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
     const pendingPos = [];
     const pendingTask = [];
     const push2 = (position, next) => {
+      const key = spanStateKey(position, next, nodeIds);
+      if (seen.has(key)) return;
+      seen.add(key);
       pendingPos.push(position);
       pendingTask.push(next);
     };
@@ -327,6 +349,8 @@ function tryMatchEreAsciiRangeNfaSync(root, initial, buf, rStart, rLen, ledger,
     const anchored = root.kind === "start" || root.kind === "sequence" && root.children[0]?.kind === "start";
     const maxStart2 = anchored ? 0 : rLen;
     for (let start = 0; start <= maxStart2; start++) {
+      if (ledger.workAllowanceUntilCheckpoint(signal) < 1) return null;
+      ledger.chargeWork(1, signal);
       if (firstLitCode >= 0 && !anchored) {
         const found = buf.indexOf(firstLitCode, rStart + start);
         if (found < 0 || found >= rStart + rLen) break;
@@ -337,14 +361,17 @@ function tryMatchEreAsciiRangeNfaSync(root, initial, buf, rStart, rLen, ledger,
       }
       if (word && start > 0 && isAsciiWord(buf[rStart + start - 1])) continue;
       if (secondLitCode >= 0 && (start + 1 >= rLen || buf[rStart + start + 1] !== secondLitCode)) continue;
+      seen.clear();
       push2(start, rootTask2);
       let bestPos = -1;
       while (pendingPos.length > 0) {
+        if (ledger.workAllowanceUntilCheckpoint(signal) < 1) return null;
+        ledger.chargeWork(1, signal);
         const statePos = pendingPos.pop();
         const current = pendingTask.pop();
         if (current === null) {
           if (word && statePos < rLen && isAsciiWord(buf[rStart + statePos])) continue;
-          if (leftmostFirst) {
+          if (leftmostFirst || statePos === rLen) {
             bestPos = statePos;
             pendingPos.length = 0;
             pendingTask.length = 0;
@@ -363,11 +390,14 @@ function tryMatchEreAsciiRangeNfaSync(root, initial, buf, rStart, rLen, ledger,
             }
             const minDotPos = statePos + node2.min;
             if (minDotPos <= maxDotPos) {
+              const scanWork = maxDotPos - minDotPos + 1;
+              if (ledger.workAllowanceUntilCheckpoint(signal) < scanWork) return null;
+              ledger.chargeWork(scanWork, signal);
               const nextTask = current.next;
               if (nextTask && nextTask.kind === "node" && nextTask.node.kind === "literal" && !nextTask.node.insensitive) {
                 const targetCode = nextTask.node.code;
                 const afterLit = nextTask.next;
-                for (let p = minDotPos; p < maxDotPos; p++) {
+                for (let p = minDotPos; p <= maxDotPos && p < rLen; p++) {
                   if (buf[rStart + p] === targetCode) push2(p + 1, afterLit);
                 }
               } else {
@@ -776,8 +806,22 @@ function admitSynchronousWork(ledger, amount, signal) {
   ledger.chargeWork(amount, signal);
   return true;
 }
-function compileEreLinearChain(root, ledger, signal) {
-  if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
+function* chargeLinearWork(ledger, amount, signal) {
+  while (amount > 0) {
+    const allowance = ledger.workAllowanceUntilCheckpoint(signal);
+    if (allowance === 0) {
+      if (ledger.usage.work >= ledger.limits.work) ledger.chargeWork(1, signal);
+      yield;
+      continue;
+    }
+    const charged = Math.min(amount, allowance);
+    ledger.chargeWork(charged, signal);
+    amount -= charged;
+    if (amount > 0) yield;
+  }
+}
+function* compileEreLinearChain(root, ledger, signal) {
+  if (!admitSynchronousWork(ledger, 1, signal)) yield* chargeLinearWork(ledger, 1, signal);
   const cached = ereLinearChainCache.get(root);
   if (cached !== void 0) return cached;
   ledger.charge("allocationUnits", 3, signal);
@@ -788,7 +832,7 @@ function compileEreLinearChain(root, ledger, signal) {
   const pending = [root];
   let supported = true;
   while (pending.length > 0 && supported) {
-    if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
+    if (!admitSynchronousWork(ledger, 1, signal)) yield* chargeLinearWork(ledger, 1, signal);
     const node = pending.pop();
     switch (node.kind) {
       case "start":
@@ -802,7 +846,7 @@ function compileEreLinearChain(root, ledger, signal) {
         anchoredEnd = true;
         break;
       case "sequence":
-        if (!admitSynchronousWork(ledger, node.children.length, signal)) return void 0;
+        if (!admitSynchronousWork(ledger, node.children.length, signal)) yield* chargeLinearWork(ledger, node.children.length, signal);
         ledger.charge("allocationUnits", node.children.length, signal);
         for (let i = node.children.length - 1; i >= 0; i--) pending.push(node.children[i]);
         break;
@@ -844,16 +888,16 @@ function compileEreLinearChain(root, ledger, signal) {
   }
   let firstAtom;
   for (let i = steps.length - 1; supported && i >= 0; i--) {
-    if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
+    if (!admitSynchronousWork(ledger, 1, signal)) yield* chargeLinearWork(ledger, 1, signal);
     const step = steps[i];
     if (step.kind !== "char" && step.kind !== "repeat") continue;
     if (step.kind === "repeat" && firstAtom) {
-      if (!admitSynchronousWork(ledger, 129, signal)) return void 0;
+      if (!admitSynchronousWork(ledger, 129, signal)) yield* chargeLinearWork(ledger, 129, signal);
       if (!ereAtomsDisjoint(step.atom, firstAtom)) supported = false;
     }
     firstAtom = step.atom;
   }
-  if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
+  if (!admitSynchronousWork(ledger, 1, signal)) yield* chargeLinearWork(ledger, 1, signal);
   ledger.charge("allocationUnits", supported && seenConsuming ? 6 : 2, signal);
   if (!supported || !seenConsuming) {
     ereLinearChainCache.set(root, null);
@@ -863,11 +907,11 @@ function compileEreLinearChain(root, ledger, signal) {
   ereLinearChainCache.set(root, compiled);
   return compiled;
 }
-function tryMatchEreLinearChainSync(program, root, subject, ledger, signal) {
-  const chain = compileEreLinearChain(root, ledger, signal);
+function* matchEreLinearChain(program, root, subject, ledger, signal) {
+  const chain = yield* compileEreLinearChain(root, ledger, signal);
   if (!chain) return void 0;
   const width = program.groups + 1;
-  if (!admitSynchronousWork(ledger, width * 2, signal)) return void 0;
+  if (!admitSynchronousWork(ledger, width * 2, signal)) yield* chargeLinearWork(ledger, width * 2, signal);
   ledger.charge("allocationUnits", width * 2 + 2, signal);
   const groupStarts = new Int32Array(width);
   const groupEnds = new Int32Array(width);
@@ -875,7 +919,7 @@ function tryMatchEreLinearChainSync(program, root, subject, ledger, signal) {
   const steps = chain.steps;
   const stepsLen = steps.length;
   for (let start = 0; start <= maxStart; start++) {
-    if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
+    if (!admitSynchronousWork(ledger, 1, signal)) yield* chargeLinearWork(ledger, 1, signal);
     ledger.charge("states", 1, signal);
     if (chain.firstAtom) {
       if (start >= subject.length) break;
@@ -883,13 +927,13 @@ function tryMatchEreLinearChainSync(program, root, subject, ledger, signal) {
         continue;
       }
     }
-    if (!admitSynchronousWork(ledger, width * 2, signal)) return void 0;
+    if (!admitSynchronousWork(ledger, width * 2, signal)) yield* chargeLinearWork(ledger, width * 2, signal);
     groupStarts.fill(-1);
     groupEnds.fill(-1);
     let pos = start;
     let ok = true;
     for (let s = 0; s < stepsLen; s++) {
-      if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
+      if (!admitSynchronousWork(ledger, 1, signal)) yield* chargeLinearWork(ledger, 1, signal);
       ledger.charge("states", 1, signal);
       const step = steps[s];
       if (step.kind === "groupOpen") {
@@ -905,7 +949,7 @@ function tryMatchEreLinearChainSync(program, root, subject, ledger, signal) {
       } else {
         let count = 0;
         while (pos < subject.length) {
-          if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
+          if (!admitSynchronousWork(ledger, 1, signal)) yield* chargeLinearWork(ledger, 1, signal);
           ledger.charge("states", 1, signal);
           if (!ereAtomMatchesCode(step.atom, subject.charCodeAt(pos))) break;
           pos++;
@@ -918,14 +962,14 @@ function tryMatchEreLinearChainSync(program, root, subject, ledger, signal) {
       }
     }
     if (!ok || chain.anchoredEnd && pos !== subject.length) continue;
-    if (!admitSynchronousWork(ledger, width, signal)) return void 0;
+    if (!admitSynchronousWork(ledger, width, signal)) yield* chargeLinearWork(ledger, width, signal);
     let bytes = pos - start;
     for (let g = 1; g < width; g++) {
       if (groupStarts[g] >= 0 && groupEnds[g] >= groupStarts[g]) {
         bytes += groupEnds[g] - groupStarts[g];
       }
     }
-    if (!admitSynchronousWork(ledger, width * 3 + bytes, signal)) return void 0;
+    if (!admitSynchronousWork(ledger, width * 3 + bytes, signal)) yield* chargeLinearWork(ledger, width * 3 + bytes, signal);
     ledger.charge("captureSlots", width, signal);
     ledger.charge("captureBytes", bytes, signal);
     ledger.charge("allocationUnits", width * 4 + bytes + 6, signal);
@@ -947,32 +991,50 @@ function tryMatchEreLinearChainSync(program, root, subject, ledger, signal) {
     ledger.check(signal);
     return Object.freeze({ matched: true, captures: Object.freeze(captures), values: Object.freeze(values) });
   }
-  if (!admitSynchronousWork(ledger, 1, signal)) return void 0;
+  if (!admitSynchronousWork(ledger, 1, signal)) yield* chargeLinearWork(ledger, 1, signal);
   ledger.charge("allocationUnits", 4, signal);
   ledger.check(signal);
   return Object.freeze({ matched: false, captures: Object.freeze([]), values: Object.freeze([]) });
 }
+var linearContinuations = /* @__PURE__ */ new WeakMap();
 function tryMatchEreSync(program, subject, ledger, signal) {
   ledger.check(signal);
   const root = resolveEreProgram(program, ledger);
-  if (subject.length > ledger.limits.subjectBytes || ledger.workAllowanceUntilCheckpoint(signal) < subject.length + 16) {
-    return void 0;
-  }
+  const pending = linearContinuations.get(ledger);
+  if (pending?.program === program && pending.subject === subject && pending.signal === signal) return void 0;
+  linearContinuations.delete(ledger);
+  if (subject.length > ledger.limits.subjectBytes || ledger.workAllowanceUntilCheckpoint(signal) < subject.length + 16) return void 0;
   ledger.admitInput("subjectBytes", subject.length, signal);
   const adm = admitAscii(subject, ledger, signal);
   if (adm) return void 0;
-  return tryMatchEreLinearChainSync(program, root, subject, ledger, signal);
+  const iterator = matchEreLinearChain(program, root, subject, ledger, signal);
+  const next = iterator.next();
+  if (next.done) return next.value;
+  linearContinuations.set(ledger, { program, subject, signal, iterator });
+  return void 0;
 }
 async function matchEre(program, subject, ledger, signal) {
   ledger.check(signal);
-  resolveEreProgram(program, ledger);
-  ledger.admitInput("subjectBytes", subject.length, signal);
   const root = resolveEreProgram(program, ledger);
-  const adm = admitAscii(subject, ledger, signal);
-  if (adm) await adm;
-  const fastLinear = tryMatchEreLinearChainSync(program, root, subject, ledger, signal);
-  if (fastLinear !== void 0) return fastLinear;
-  return runMatcher(program, subject, ledger, signal, 0, true);
+  const pending = linearContinuations.get(ledger);
+  linearContinuations.delete(ledger);
+  let iterator;
+  if (pending?.program === program && pending.subject === subject && pending.signal === signal) {
+    iterator = pending.iterator;
+    const checkpoint = ledger.checkpoint(signal);
+    if (checkpoint) await checkpoint;
+  } else {
+    ledger.admitInput("subjectBytes", subject.length, signal);
+    const adm = admitAscii(subject, ledger, signal);
+    if (adm) await adm;
+    iterator = matchEreLinearChain(program, root, subject, ledger, signal);
+  }
+  for (; ; ) {
+    const next = iterator.next();
+    if (next.done) return next.value ?? runMatcher(program, subject, ledger, signal, 0, true);
+    const checkpoint = ledger.checkpoint(signal);
+    if (checkpoint) await checkpoint;
+  }
 }
 async function createEreSpanMatcher(program, subject, ledger, signal) {
   ledger.check(signal);
@@ -1051,16 +1113,26 @@ async function runMatcher(program, subject, ledger, signal, from, materialize, l
   const emptyCaptures = Object.freeze(new Array(width).fill(null));
   const emptyHistories = Object.freeze(new Array(width).fill(null));
   const pending = [];
+  const seen = program.groups === 0 ? /* @__PURE__ */ new Set() : void 0;
+  const nodeIds = /* @__PURE__ */ new Map();
   const task = (create) => {
     ledger.charge("allocationUnits", 5, signal);
     return create();
   };
   const push = (position, next, captures, histories) => {
+    if (seen) {
+      const key = spanStateKey(position, next, nodeIds);
+      ledger.charge("work", key.length, signal);
+      ledger.charge("allocationUnits", key.length + 2, signal);
+      if (seen.has(key)) return;
+      seen.add(key);
+    }
     ledger.charge("states", 1, signal);
     ledger.charge("allocationUnits", 5, signal);
     pending.push({ position, task: next, captures, histories });
   };
   for (let start = from; start <= subject.length; start++) {
+    seen?.clear();
     if (initial) {
       ledger.charge("work", 1, signal);
       const pendingCheck = ledger.checkpoint(signal);

package/dist/safe-bash-regex-engine/execution/bounded-provider.js

@@ -6,7 +6,7 @@ import {
   trustedInputRows,
   trustedWorkerReplies,
   trustedWorkerRequests
-} from "../../safe-bash/command-chunks/chunk-L6SU4S26.js";
+} from "../../safe-bash/command-chunks/chunk-6B7WQIKB.js";
 import {
   matchExprSteps,
   searchBreSteps
@@ -48,12 +48,6 @@ var byteBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").
 var emptyFloat64 = new Float64Array(0);
 var emptyFloat64Results = [];
 var emptyMatchRow = [];
-var reusableTrustedReply = {
-  id: 0,
-  results: emptyFloat64Results,
-  directMatches: []
-};
-trustedWorkerReplies.add(reusableTrustedReply);
 function fail(kind, message) {
   throw new PublicDiagnostic(`bounded regex ${kind}: ${message}`);
 }
@@ -186,12 +180,7 @@ function admit(input, limits, signal, allowSharedLedger = true) {
   if (allowSharedLedger && knownTrustedRows) {
     const ledger2 = sharedSyncLedger.resetWithLimits(getPrevalidatedEreLimits(limits, selected.fixed));
     ledger2.charge("allocationUnits", bytes + input.rows.length * 12 + selected.patterns.length * 2 + 16, signal);
-    sharedOwnedRequest.id = input.id;
-    sharedOwnedRequest.descriptor = selected;
-    sharedOwnedRequest.rows = input.rows;
-    sharedOwnedRequest.ledger = ledger2;
-    sharedOwnedRequest.limits = limits;
-    return sharedOwnedRequest;
+    return { id: input.id, descriptor: selected, rows: input.rows, ledger: ledger2, limits };
   }
   const ledger = selected.kind !== "glob" ? EreLedger.withPrevalidatedLimits(getPrevalidatedEreLimits(limits, selected.fixed)) : new EreLedger({ maxExpansionBytes: Infinity, maxExpansionFields: Infinity }, {
     patternBytes: Infinity,
@@ -600,20 +589,18 @@ async function enumerate(input, row, finders, usage, signal) {
   await ledger.checkpoint(signal);
   return new Float64Array(ranges);
 }
-var lastLiteralCache;
-var lastEreCache;
 function ereCacheKeyFor(selected, fold) {
   if (selected.patterns.length !== 1 || selected.patterns[0].length > 128) return void 0;
   return `${selected.kind}:${fold ? 1 : 0}:${selected.kind === "rg" && selected.nullData ? 1 : 0}:${selected.kind === "grep" && !selected.extended ? 1 : 0}:${selected.whole ? 1 : 0}:${selected.patterns[0]}`;
 }
-function tryExecuteEreSync(input, signal, fold) {
+function tryExecuteEreSync(input, signal, fold, cache) {
   const { descriptor: selected, rows, ledger } = input;
   if (selected.patterns.length !== 1) return void 0;
   const pattern0 = selected.patterns[0];
-  if (lastEreCache === void 0 || lastEreCache.kind !== selected.kind || lastEreCache.fold !== fold || lastEreCache.nullData !== (selected.kind === "rg" && selected.nullData) || lastEreCache.bre !== (selected.kind === "grep" && !selected.extended) || lastEreCache.whole !== selected.whole || lastEreCache.pattern0 !== pattern0) {
+  if (cache.ere === void 0 || cache.ere.kind !== selected.kind || cache.ere.fold !== fold || cache.ere.nullData !== (selected.kind === "rg" && selected.nullData) || cache.ere.bre !== (selected.kind === "grep" && !selected.extended) || cache.ere.whole !== selected.whole || cache.ere.pattern0 !== pattern0) {
     return void 0;
   }
-  const programs = lastEreCache.programs;
+  const programs = cache.ere.programs;
   const unboundedLedger = ledger.limits.work === Infinity && ledger.limits.states === Infinity && ledger.limits.allocationUnits === Infinity;
   if (!unboundedLedger) {
     for (let p = 0; p < programs.length; p++) {
@@ -632,21 +619,21 @@ function tryExecuteEreSync(input, signal, fold) {
     batchWork += rLen * 4 + 5 + patLen;
     batchAllocUnits += rLen * 11 + 23;
   }
-  const estimatedWork = lastEreCache.work + batchWork + 256;
+  const estimatedWork = cache.ere.work + batchWork + 256;
   if (ledger.workAllowanceUntilCheckpoint(signal) < estimatedWork) {
     return void 0;
   }
   ledger.admitInput("subjectBytes", maxSubjectLen, signal);
-  ledger.charge("work", lastEreCache.work + batchWork, signal);
-  ledger.charge("patternBytes", lastEreCache.patternBytes, signal);
-  ledger.charge("states", lastEreCache.states, signal);
-  ledger.charge("allocationUnits", lastEreCache.allocationUnits + 3 + batchAllocUnits, signal);
+  ledger.charge("work", cache.ere.work + batchWork, signal);
+  ledger.charge("patternBytes", cache.ere.patternBytes, signal);
+  ledger.charge("states", cache.ere.states, signal);
+  ledger.charge("allocationUnits", cache.ere.allocationUnits + 3 + batchAllocUnits, signal);
   runYieldCheckpoint(signal);
   if (rows.length === 0) {
     signal.throwIfAborted();
-    reusableTrustedReply.id = input.id;
-    reusableTrustedReply.directMatches = [];
-    return reusableTrustedReply;
+    const reply2 = { id: input.id, results: emptyFloat64Results, directMatches: [] };
+    trustedWorkerReplies.add(reply2);
+    return reply2;
   }
   const directMatches = new Array(rows.length);
   let matchCount = 0;
@@ -681,7 +668,7 @@ function tryExecuteEreSync(input, signal, fold) {
       if (matchCount >= maxMatches) fail("limit", "total match or result byte limit exceeded");
       matchCount++;
       if (bestSpan.start === 0 && bestSpan.end < 128) {
-        const byEnd = lastEreCache.singleMatchByEnd ??= [];
+        const byEnd = cache.ere.singleMatchByEnd ??= [];
         directMatches[r] = byEnd[bestSpan.end] ??= [bestSpan];
       } else {
         directMatches[r] = [{ start: bestSpan.start, end: bestSpan.end }];
@@ -691,9 +678,9 @@ function tryExecuteEreSync(input, signal, fold) {
     }
   }
   signal.throwIfAborted();
-  reusableTrustedReply.id = input.id;
-  reusableTrustedReply.directMatches = directMatches;
-  return reusableTrustedReply;
+  const reply = { id: input.id, results: emptyFloat64Results, directMatches };
+  trustedWorkerReplies.add(reply);
+  return reply;
 }
 var sharedSyncLedger = EreLedger.withPrevalidatedLimits(Object.freeze({
   patternBytes: Infinity,
@@ -704,13 +691,6 @@ var sharedSyncLedger = EreLedger.withPrevalidatedLimits(Object.freeze({
   captureBytes: Infinity,
   captureSlots: Infinity
 }));
-var sharedOwnedRequest = {
-  id: 0,
-  descriptor: void 0,
-  rows: [],
-  ledger: sharedSyncLedger,
-  limits: void 0
-};
 var cachedWorkerLimitsRef;
 var cachedFixedEreLimits;
 var cachedRegexEreLimits;
@@ -780,7 +760,7 @@ function literalStartRangeSync(program, buf, rStart, rEnd, whole, word) {
   lastRangeSyncWork = work;
   return -1;
 }
-function tryExecuteLiteralSync(input, signal, fold) {
+function tryExecuteLiteralSync(input, signal, fold, cache) {
   const { descriptor: selected, rows, ledger } = input;
   for (let i = 0; i < rows.length; i++) {
     if (rows[i].all) return void 0;
@@ -789,7 +769,7 @@ function tryExecuteLiteralSync(input, signal, fold) {
   const pattern0 = selected.patterns[0];
   if (pattern0.length > 128) return void 0;
   const nullData = selected.kind === "rg" && selected.nullData;
-  if (lastLiteralCache?.kind !== selected.kind || lastLiteralCache.fold !== fold || lastLiteralCache.nullData !== nullData || lastLiteralCache.pattern0 !== pattern0) {
+  if (cache.literal?.kind !== selected.kind || cache.literal.fold !== fold || cache.literal.nullData !== nullData || cache.literal.pattern0 !== pattern0) {
     const snapBefore = ledger.usage;
     const compiled = [];
     for (const pattern of selected.patterns) {
@@ -801,7 +781,7 @@ function tryExecuteLiteralSync(input, signal, fold) {
       compiled.push(progOrPromise);
     }
     const snapAfter = ledger.usage;
-    lastLiteralCache = {
+    cache.literal = {
       kind: selected.kind,
       fold,
       nullData,
@@ -813,11 +793,11 @@ function tryExecuteLiteralSync(input, signal, fold) {
       allocationUnits: snapAfter.allocationUnits - snapBefore.allocationUnits | 0
     };
   } else {
-    if (ledger.workAllowanceUntilCheckpoint(signal) < lastLiteralCache.work) return void 0;
-    ledger.charge("work", lastLiteralCache.work, signal);
-    ledger.charge("patternBytes", lastLiteralCache.patternBytes, signal);
-    ledger.charge("states", lastLiteralCache.states, signal);
-    ledger.charge("allocationUnits", lastLiteralCache.allocationUnits, signal);
+    if (ledger.workAllowanceUntilCheckpoint(signal) < cache.literal.work) return void 0;
+    ledger.charge("work", cache.literal.work, signal);
+    ledger.charge("patternBytes", cache.literal.patternBytes, signal);
+    ledger.charge("states", cache.literal.states, signal);
+    ledger.charge("allocationUnits", cache.literal.allocationUnits, signal);
   }
   const workPerByte = selected.kind === "grep" ? 2 : 3;
   let estimatedWork = 3;
@@ -830,7 +810,7 @@ function tryExecuteLiteralSync(input, signal, fold) {
     return void 0;
   }
   runYieldCheckpoint(signal);
-  const programs = lastLiteralCache.programs;
+  const programs = cache.literal.programs;
   ledger.charge("allocationUnits", 3, signal);
   const directMatches = new Array(rows.length);
   let matchCount = 0;
@@ -907,11 +887,11 @@ function tryExecuteLiteralSync(input, signal, fold) {
   }
   if (batchWork > 0) ledger.chargeWork(batchWork, signal);
   else signal.throwIfAborted();
-  reusableTrustedReply.id = input.id;
-  reusableTrustedReply.directMatches = directMatches;
-  return reusableTrustedReply;
+  const reply = { id: input.id, results: emptyFloat64Results, directMatches };
+  trustedWorkerReplies.add(reply);
+  return reply;
 }
-function tryExecuteSync(input, signal) {
+function tryExecuteSync(input, signal, cache) {
   const { descriptor: selected, ledger } = input;
   const foldOrPromise = insensitive(selected, ledger, signal);
   if (typeof foldOrPromise !== "boolean") return void 0;
@@ -931,20 +911,20 @@ function tryExecuteSync(input, signal) {
       }
     }
   }
-  if (!literal) return tryExecuteEreSync(input, signal, foldOrPromise);
-  return tryExecuteLiteralSync(input, signal, foldOrPromise);
+  if (!literal) return tryExecuteEreSync(input, signal, foldOrPromise, cache);
+  return tryExecuteLiteralSync(input, signal, foldOrPromise, cache);
 }
-async function executeLiteral(input, signal, fold) {
+async function executeLiteral(input, signal, fold, cache) {
   const { descriptor: selected, rows, ledger } = input;
   const pattern0 = selected.patterns.length === 1 && selected.patterns[0].length <= 128 ? selected.patterns[0] : void 0;
   const nullData = selected.kind === "rg" && selected.nullData;
   let programs;
-  if (pattern0 !== void 0 && lastLiteralCache?.kind === selected.kind && lastLiteralCache.fold === fold && lastLiteralCache.nullData === nullData && lastLiteralCache.pattern0 === pattern0 && ledger.workAllowanceUntilCheckpoint(signal) >= lastLiteralCache.work) {
-    ledger.charge("work", lastLiteralCache.work, signal);
-    ledger.charge("patternBytes", lastLiteralCache.patternBytes, signal);
-    ledger.charge("states", lastLiteralCache.states, signal);
-    ledger.charge("allocationUnits", lastLiteralCache.allocationUnits, signal);
-    programs = lastLiteralCache.programs;
+  if (pattern0 !== void 0 && cache.literal?.kind === selected.kind && cache.literal.fold === fold && cache.literal.nullData === nullData && cache.literal.pattern0 === pattern0 && ledger.workAllowanceUntilCheckpoint(signal) >= cache.literal.work) {
+    ledger.charge("work", cache.literal.work, signal);
+    ledger.charge("patternBytes", cache.literal.patternBytes, signal);
+    ledger.charge("states", cache.literal.states, signal);
+    ledger.charge("allocationUnits", cache.literal.allocationUnits, signal);
+    programs = cache.literal.programs;
   } else {
     const snapBefore = ledger.usage;
     const compiled = [];
@@ -958,7 +938,7 @@ async function executeLiteral(input, signal, fold) {
     programs = compiled;
     if (pattern0 !== void 0) {
       const snapAfter = ledger.usage;
-      lastLiteralCache = {
+      cache.literal = {
         kind: selected.kind,
         fold,
         nullData,
@@ -1043,7 +1023,7 @@ async function insensitiveAsync(selected, ledger, signal) {
   }
   return true;
 }
-async function execute(input, signal) {
+async function execute(input, signal, cache) {
   const { descriptor: selected, rows, ledger } = input;
   const foldOrPromise = insensitive(selected, ledger, signal);
   const fold = typeof foldOrPromise === "boolean" ? foldOrPromise : await foldOrPromise;
@@ -1063,7 +1043,7 @@ async function execute(input, signal) {
       }
     }
   }
-  if (literal) return executeLiteral(input, signal, fold);
+  if (literal) return executeLiteral(input, signal, fold, cache);
   const ereKey = ereCacheKeyFor(selected, fold);
   const snapBeforeEre = ledger.usage;
   const programs = [];
@@ -1096,8 +1076,13 @@ async function execute(input, signal) {
       const buf = hasRange ? rWithRange.chunk : row.bytes;
       const rStart = hasRange ? rWithRange.start : 0;
       const rEnd = hasRange ? rWithRange.searchEnd : buf.length;
-      let ascii = true;
-      for (let i = rStart; i < rEnd; i++) {
+      let ascii = rEnd - rStart <= 16384;
+      if (ascii) {
+        ledger.chargeWork(rEnd - rStart + 1, signal);
+        const pending = ledger.checkpoint(signal);
+        if (pending) await pending;
+      }
+      for (let i = rStart; ascii && i < rEnd; i++) {
         const b = buf[i];
         if (b === 0 || b >= 128) {
           ascii = false;
@@ -1162,7 +1147,7 @@ async function execute(input, signal) {
     for (const prog of programs) {
       if (canFastSyncEreProgram(prog)) await warmEreProgram(prog);
     }
-    lastEreCache = {
+    cache.ere = {
       key: ereKey,
       kind: selected.kind,
       fold,
@@ -1190,6 +1175,7 @@ var CooperativeWorker = class {
   }
   limits;
   release;
+  cache = {};
   controller;
   listeners = /* @__PURE__ */ new Map();
   singleMessageListener;
@@ -1289,7 +1275,7 @@ var CooperativeWorker = class {
     if (isTrusted && owned && !("subject" in owned) && owned.descriptor.kind !== "glob") {
       try {
         signal.throwIfAborted();
-        const syncReply = tryExecuteSync(owned, signal);
+        const syncReply = tryExecuteSync(owned, signal, this.cache);
         if (syncReply !== void 0) {
           owned = void 0;
           if (!this.closing) this.emit(syncReply);
@@ -1322,7 +1308,7 @@ var CooperativeWorker = class {
       let reply;
       try {
         signal.throwIfAborted();
-        reply = owned ? "subject" in owned ? await executeExpr(owned, signal) : owned.descriptor.kind === "glob" ? await executeBoundedGlobs(owned, signal) : await execute(owned, signal) : { id, error: failure };
+        reply = owned ? "subject" in owned ? await executeExpr(owned, signal) : owned.descriptor.kind === "glob" ? await executeBoundedGlobs(owned, signal) : await execute(owned, signal, this.cache) : { id, error: failure };
         if (owned && !("subject" in owned) && !("error" in reply)) {
           trustedWorkerReplies.add(reply);
         }
@@ -1349,6 +1335,8 @@ var CooperativeWorker = class {
   terminate() {
     if (!this.closing) {
       this.closing = Promise.allSettled([...this.tasks]).then(() => {
+        this.cache = {};
+        this.singleMessageListener = void 0;
         this.listeners.clear();
         this.tasks.clear();
         this.release();

package/dist/safe-bash-regex-engine/execution/portable.d.ts

@@ -15,7 +15,6 @@ declare class Slot {
     idleTimer: ReturnType<typeof setTimeout> | undefined;
     private receiver;
     private failure;
-    private static readonly syncResultBox;
     private syncSettled;
     private syncRejected;
     private syncValue;

package/dist/safe-bash-regex-engine/execution/portable.js

@@ -4,7 +4,6 @@ import {
   inProcessRegexWorkers,
   inputBytes,
   policy,
-  reusableTrustedRequest,
   trustedInputRows,
   trustedWorkerReplies,
   trustedWorkerRequests,
@@ -13,7 +12,7 @@ import {
   validateExprInput,
   validateExprReply,
   validateReply
-} from "../../safe-bash/command-chunks/chunk-L6SU4S26.js";
+} from "../../safe-bash/command-chunks/chunk-6B7WQIKB.js";
 import {
   init_buffer
 } from "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
@@ -161,7 +160,7 @@ async function withRegexSessionSlow(context, executor, execute) {
   if (hasCleanupFailure) throw cleanupError;
   return result;
 }
-var Slot = class _Slot {
+var Slot = class {
   constructor(owner) {
     this.owner = owner;
     this.worker = owner.provider.createWorker(owner.options);
@@ -184,7 +183,6 @@ var Slot = class _Slot {
   idleTimer;
   receiver;
   failure;
-  static syncResultBox = { sync: true, value: void 0 };
   syncSettled = false;
   syncRejected = false;
   syncValue;
@@ -289,8 +287,7 @@ var Slot = class _Slot {
       const val = this.syncValue;
       this.syncValue = void 0;
       if (this.syncRejected) return { sync: false, promise: Promise.reject(val) };
-      _Slot.syncResultBox.value = val;
-      return _Slot.syncResultBox;
+      return { sync: true, value: val };
     }
     return this.awaitInProcessAsync(timeout, signal);
   }
@@ -498,10 +495,9 @@ var RegexExecutor = class {
         readySlot.busy = true;
         let ex;
         if (readySlot.inProcess) {
-          reusableTrustedRequest.id = id;
-          reusableTrustedRequest.descriptor = descriptor;
-          reusableTrustedRequest.rows = rows;
-          ex = readySlot.postInProcessSync(reusableTrustedRequest, this.options.requestTimeoutMs, signal);
+          const request = { id, descriptor, rows };
+          trustedWorkerRequests.add(request);
+          ex = readySlot.postInProcessSync(request, this.options.requestTimeoutMs, signal);
         } else {
           ex = this.exchangeOutOfProcessSyncOrAsync(readySlot, id, descriptor, rows, session._ensureAsyncState());
         }