@poe-platform/safe-bash 0.1.800 → 0.1.802

package/dist/safe-bash-search-engine/grep.js

@@ -14,7 +14,7 @@ import {
 
 // packages/safe-bash-search-engine/src/grep.ts
 init_buffer();
-import { equalBytes, latin1Text } from "../safe-bash-io-engine/byte-encoding.js";
+import { latin1Text } from "../safe-bash-io-engine/byte-encoding.js";
 import { shellValueByteLength } from "../safe-bash-contracts/value.js";
 import { tryReadMemoryFileViewSync } from "@poe-platform/safe-fs/core";
 import { assertCommandRequirements } from "../safe-bash-contracts/command-requirements.js";
@@ -51,15 +51,6 @@ var PooledGrepLine = class {
 };
 var EMPTY_GREP_ROWS = Object.freeze([]);
 trustedInputRows.add(EMPTY_GREP_ROWS);
-var sharedGrepOutBuffer = new Uint8Array(64 * 1024);
-var sharedGrepOutInUse = false;
-var cachedGrepOutBuffer = new Uint8Array(32768);
-var lastGrepRawBuf;
-var lastGrepPat = "";
-var lastGrepAnchored = false;
-var lastGrepMaxLineLen = 0;
-var lastGrepOutUsed = -1;
-var lastGrepAnySelected = false;
 var syncResolved = /* @__PURE__ */ Symbol.for("safe-bash.syncResolved");
 function isSyncResolved(promise) {
   return Boolean(promise && typeof promise === "object" && promise[syncResolved]);
@@ -265,7 +256,7 @@ function hasNulOrNonAscii(buf, start, end) {
   return false;
 }
 function tryFastGrepAscii(context, limits, pat, fileArg, anchoredStart) {
-  if (fileArg !== void 0 && fileArg !== "-" && !sharedGrepOutInUse) {
+  if (fileArg !== void 0 && fileArg !== "-") {
     const fastBacking = context._fastMemoryBackingFs;
     const path = pathOf(context, fileArg);
     const backing = fastBacking ?? getRuntimeBackingFileSystem(context.fs) ?? context.fs;
@@ -276,29 +267,18 @@ function tryFastGrepAscii(context, limits, pat, fileArg, anchoredStart) {
         else chargeRuntimeFileSystemOperation(context.fs);
         const maxFileBytes = Number.isFinite(limits.maxFileBytes) ? limits.maxFileBytes : void 0;
         const raw = tryReadMemoryFileViewSync(backing, path, maxFileBytes, context.signal);
-        if (raw !== void 0 && lastGrepOutUsed >= 0 && lastGrepRawBuf !== void 0 && raw.byteLength === lastGrepRawBuf.byteLength && pat === lastGrepPat && anchoredStart === lastGrepAnchored && lastGrepMaxLineLen <= Math.min(internalBufferLimit, limits.maxLineBytes ?? Infinity) && equalBytes(lastGrepRawBuf, raw)) {
-          context.signal.throwIfAborted();
-          if (!lastGrepOutUsed) {
-            return lastGrepAnySelected ? RESOLVED_EXIT_ZERO : RESOLVED_EXIT_ONE;
-          }
-          const pending = outputRange(context, cachedGrepOutBuffer, lastGrepOutUsed);
-          if (isSyncResolved(pending)) {
-            return lastGrepAnySelected ? RESOLVED_EXIT_ZERO : RESOLVED_EXIT_ONE;
-          }
-          return pending.then(lastGrepAnySelected ? RETURN_EXIT_ZERO : RETURN_EXIT_ONE);
-        }
-        if (raw !== void 0 && raw.length < sharedGrepOutBuffer.length && !hasNulOrNonAscii(raw, 0, raw.length)) {
+        if (raw !== void 0) context.inputBudget?.check(raw.byteLength);
+        if (raw !== void 0 && raw.length < 65536 && !hasNulOrNonAscii(raw, 0, raw.length)) {
           const literalStart = anchoredStart ? 1 : 0;
           const litLen = pat.length - literalStart;
           const firstByte = pat.charCodeAt(literalStart);
           const lineLimit = Math.min(internalBufferLimit, limits.maxLineBytes ?? Infinity);
-          const outBuffer = sharedGrepOutBuffer;
+          const outBuffer = new Uint8Array(64 * 1024);
           let outUsed = 0;
           let anySelected = false;
           let linesScanned = 0;
           let lineStart = 0;
           let exceededLines = false;
-          let maxSeenLineLen = 0;
           while (lineStart < raw.length) {
             if ((linesScanned & 63) === 0) context.signal.throwIfAborted();
             if ((++linesScanned & 4095) === 0) {
@@ -308,7 +288,6 @@ function tryFastGrepAscii(context, limits, pat, fileArg, anchoredStart) {
             let lineEnd = raw.indexOf(10, lineStart);
             if (lineEnd < 0) lineEnd = raw.length;
             const lineLen = lineEnd - lineStart;
-            if (lineLen > maxSeenLineLen) maxSeenLineLen = lineLen;
             if (lineLen > lineLimit) {
               throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
             }
@@ -348,15 +327,6 @@ function tryFastGrepAscii(context, limits, pat, fileArg, anchoredStart) {
             lineStart = lineEnd + 1;
           }
           if (!exceededLines) {
-            if (raw.byteLength >= 256 && outUsed <= 32768) {
-              lastGrepRawBuf = new Uint8Array(raw);
-              lastGrepPat = pat;
-              lastGrepAnchored = anchoredStart;
-              lastGrepMaxLineLen = maxSeenLineLen;
-              lastGrepOutUsed = outUsed;
-              lastGrepAnySelected = anySelected;
-              cachedGrepOutBuffer.set(outBuffer.subarray(0, outUsed));
-            }
             if (!outUsed) {
               return anySelected ? RESOLVED_EXIT_ZERO : RESOLVED_EXIT_ONE;
             }
@@ -367,6 +337,7 @@ function tryFastGrepAscii(context, limits, pat, fileArg, anchoredStart) {
             return pending.then(anySelected ? RETURN_EXIT_ZERO : RETURN_EXIT_ONE);
           }
         }
+        if (raw !== void 0) return tryFastGrepAsciiAsync(context, limits, pat, fileArg, anchoredStart, raw);
       } catch (error) {
         context.signal.throwIfAborted();
         if (error instanceof RegexExecutionError) return Promise.reject(error);
@@ -376,13 +347,11 @@ function tryFastGrepAscii(context, limits, pat, fileArg, anchoredStart) {
   }
   return tryFastGrepAsciiAsync(context, limits, pat, fileArg, anchoredStart);
 }
-async function tryFastGrepAsciiAsync(context, limits, pat, fileArg, anchoredStart) {
+async function tryFastGrepAsciiAsync(context, limits, pat, fileArg, anchoredStart, admittedBytes) {
   const literalStart = anchoredStart ? 1 : 0;
   const litLen = pat.length - literalStart;
   const firstByte = pat.charCodeAt(literalStart);
-  const ownsSharedOut = !sharedGrepOutInUse;
-  if (ownsSharedOut) sharedGrepOutInUse = true;
-  const outBuffer = ownsSharedOut ? sharedGrepOutBuffer : new Uint8Array(64 * 1024);
+  const outBuffer = new Uint8Array(64 * 1024);
   let outUsed = 0;
   let anySelected = false;
   let subjectLedger;
@@ -400,9 +369,10 @@ async function tryFastGrepAsciiAsync(context, limits, pat, fileArg, anchoredStar
       const backing = getRuntimeBackingFileSystem(context.fs) ?? context.fs;
       if (backing !== void 0 && backing.capabilitiesFor === void 0 && path !== "/dev" && !path.startsWith("/dev/") && context.fs.capabilities.streamingRead !== false && context.fs.capabilities.read !== false && Object.getPrototypeOf(backing)?.constructor?.name === "MemoryFileSystem" && !Object.prototype.hasOwnProperty.call(backing, "readStream") && !Object.prototype.hasOwnProperty.call(backing, "readFile")) {
         assertCommandRequirements(context, grepRequirements, ["file"]);
-        chargeRuntimeFileSystemOperation(context.fs);
+        if (admittedBytes === void 0) chargeRuntimeFileSystemOperation(context.fs);
         const maxFileBytes = Number.isFinite(limits.maxFileBytes) ? limits.maxFileBytes : void 0;
-        const raw = tryReadMemoryFileViewSync(backing, path, maxFileBytes, context.signal);
+        const raw = admittedBytes ?? tryReadMemoryFileViewSync(backing, path, maxFileBytes, context.signal);
+        if (admittedBytes === void 0 && raw !== void 0) context.inputBudget?.check(raw.byteLength);
         if (raw !== void 0) {
           const lineLimit = Math.min(internalBufferLimit, limits.maxLineBytes ?? Infinity);
           let lineStart = 0;
@@ -541,8 +511,6 @@ async function tryFastGrepAsciiAsync(context, limits, pat, fileArg, anchoredStar
     if (error instanceof RegexExecutionError) throw error;
     await diagnostic(context, error);
     return { exitCode: 2 };
-  } finally {
-    if (ownsSharedOut) sharedGrepOutInUse = false;
   }
 }
 async function executeGrepWithSession(context, session, limits, maxPatternCount, bufferLimit) {
@@ -787,8 +755,6 @@ inspect the resulting state before repeating the action.
     const delimiter = parsed.flags.has("z") ? "\0" : "\n";
     const delimiterBytes = parsed.flags.has("z") ? NUL_BYTES : NEWLINE_BYTES;
     const lineBuffered = parsed.flags.has("line-buffered") || parsed.flags.has("o");
-    const ownsSharedOut = !sharedGrepOutInUse;
-    if (ownsSharedOut) sharedGrepOutInUse = true;
     let outBuffer;
     let outStart = 0;
     let outUsed = 0;
@@ -821,7 +787,7 @@ inspect the resulting state before repeating the action.
         await output(context, bytes);
         return;
       }
-      outBuffer ??= ownsSharedOut ? sharedGrepOutBuffer : new Uint8Array(64 * 1024);
+      outBuffer ??= new Uint8Array(64 * 1024);
       if (outUsed + bytes.length > outBuffer.length) {
         await flushOut();
         outBuffer = new Uint8Array(64 * 1024);
@@ -831,199 +797,195 @@ inspect the resulting state before repeating the action.
       outBuffer.set(bytes, outUsed);
       outUsed += bytes.length;
     };
-    try {
-      const extractMatches = parsed.flags.has("o") && !["c", "q", "l", "L", "v"].some((flag) => parsed.flags.has(flag));
-      const displayLines = !["c", "q", "l", "L"].some((flag) => parsed.flags.has(flag));
-      const withContext = (beforeContext > 0 || afterContext > 0) && displayLines && !(parsed.flags.has("o") && parsed.flags.has("v"));
-      const before = withContext ? beforeContext : 0;
-      const after = withContext ? afterContext : 0;
-      let emittedGroup = false;
-      let anySelected = false;
-      let failed = false;
-      const targets = parsed.operands.length === 0 && directoriesAction === void 0 && !parsed.flags.has("r") && !parsed.flags.has("R") && !parsed.values.has("d") && !parsed.values.has("D") && filters.length === 0 ? SINGLE_STDIN_FILE : grepFiles(context, parsed, filters, () => {
-        failed = true;
-      }, directoriesAction);
-      for await (const { name, nested } of targets) {
-        let count = 0;
-        let number = 0;
-        let byteOffset = 0;
-        let nextOffset = 0;
-        let lastCovered = 0;
-        let remainingAfter = 0;
-        let pendingBytes = 0;
-        const pending = withContext ? /* @__PURE__ */ new Map() : void 0;
-        const named = name === "-" ? value(parsed, "label") ?? "(standard input)" : name;
-        const hasLinePrefix = !parsed.flags.has("h") && (parsed.flags.has("H") || multipleFiles || nested) || parsed.flags.has("n") || parsed.flags.has("b");
-        const delimiterByte = delimiterBytes[0];
-        const prefix = (lineNumber = false, position = number, separator = ":", offset = byteOffset) => `${!parsed.flags.has("h") && (parsed.flags.has("H") || multipleFiles || nested) ? `${named}${parsed.flags.has("Z") ? "\0" : separator}` : ""}${lineNumber && parsed.flags.has("n") ? `${position}${separator}` : ""}${lineNumber && parsed.flags.has("b") ? `${offset}${separator}` : ""}${lineNumber && parsed.flags.has("T") && (parsed.flags.has("n") || parsed.flags.has("b") || !parsed.flags.has("h") && (parsed.flags.has("H") || multipleFiles || nested)) ? "	" : ""}`;
-        const emitContext = async (line, position, offset = byteOffset) => {
-          if (!parsed.flags.has("o")) {
-            await writeOut(prefix(true, position, "-", offset));
-            await writeOut(line.bytes);
-            await writeOut(delimiterBytes);
-          }
-          lastCovered = position;
-        };
-        try {
-          const source = name === "-" ? input(context) : requiredFileInput(context, grepRequirements, "file", name, limits.maxFileBytes ?? Infinity);
-          let earlyExitZero = false;
-          const invertMatch = parsed.flags.has("v");
-          const isQuiet = parsed.flags.has("q");
-          const isListFiles = parsed.flags.has("l") || parsed.flags.has("L");
-          const isCountOnly = parsed.flags.has("c");
-          const isOnlyMatching = parsed.flags.has("o");
-          const canFastBufferLines = !isQuiet && !isListFiles && !isCountOnly && !withContext && !isOnlyMatching && !hasLinePrefix && !lineBuffered && binaryFiles.mode !== "without-match";
-          const processBatchSlow = async (batch, endOfChunk, resultsPromise, startIdx = 0, precomputedResults) => {
-            const results = precomputedResults ?? await resultsPromise;
-            for (let index = startIdx; index < batch.length; index++) {
-              const line = batch[index];
-              context.signal.throwIfAborted();
-              number++;
-              byteOffset = nextOffset;
-              const curLineLen = line.searchEnd !== void 0 ? line.searchEnd - line.start : line.bytes.length;
-              nextOffset += curLineLen + (line.terminated ? 1 : 0);
-              const found = results[index];
-              const selected = count < maxCount && found.length > 0 !== invertMatch;
-              if (!selected) {
-                if (remainingAfter > 0) {
-                  await emitContext(line, number);
-                  remainingAfter--;
-                  if (count >= maxCount && remainingAfter === 0) return false;
-                } else if (before > 0) {
-                  if (pending.size >= before) {
-                    const oldest = pending.keys().next().value;
-                    pendingBytes -= pending.get(oldest).bytes.length + 1;
-                    pending.delete(oldest);
-                  }
-                  const size = line.bytes.length + 1;
-                  if (size > (limits.maxContextBytes ?? Infinity) - pendingBytes) throw new UsageError(`context byte limit exceeded (${limits.maxContextBytes} bytes)`);
-                  pending.set(number, { bytes: Uint8Array.from(line.bytes), terminated: line.terminated, offset: byteOffset });
-                  pendingBytes += size;
+    const extractMatches = parsed.flags.has("o") && !["c", "q", "l", "L", "v"].some((flag) => parsed.flags.has(flag));
+    const displayLines = !["c", "q", "l", "L"].some((flag) => parsed.flags.has(flag));
+    const withContext = (beforeContext > 0 || afterContext > 0) && displayLines && !(parsed.flags.has("o") && parsed.flags.has("v"));
+    const before = withContext ? beforeContext : 0;
+    const after = withContext ? afterContext : 0;
+    let emittedGroup = false;
+    let anySelected = false;
+    let failed = false;
+    const targets = parsed.operands.length === 0 && directoriesAction === void 0 && !parsed.flags.has("r") && !parsed.flags.has("R") && !parsed.values.has("d") && !parsed.values.has("D") && filters.length === 0 ? SINGLE_STDIN_FILE : grepFiles(context, parsed, filters, () => {
+      failed = true;
+    }, directoriesAction);
+    for await (const { name, nested } of targets) {
+      let count = 0;
+      let number = 0;
+      let byteOffset = 0;
+      let nextOffset = 0;
+      let lastCovered = 0;
+      let remainingAfter = 0;
+      let pendingBytes = 0;
+      const pending = withContext ? /* @__PURE__ */ new Map() : void 0;
+      const named = name === "-" ? value(parsed, "label") ?? "(standard input)" : name;
+      const hasLinePrefix = !parsed.flags.has("h") && (parsed.flags.has("H") || multipleFiles || nested) || parsed.flags.has("n") || parsed.flags.has("b");
+      const delimiterByte = delimiterBytes[0];
+      const prefix = (lineNumber = false, position = number, separator = ":", offset = byteOffset) => `${!parsed.flags.has("h") && (parsed.flags.has("H") || multipleFiles || nested) ? `${named}${parsed.flags.has("Z") ? "\0" : separator}` : ""}${lineNumber && parsed.flags.has("n") ? `${position}${separator}` : ""}${lineNumber && parsed.flags.has("b") ? `${offset}${separator}` : ""}${lineNumber && parsed.flags.has("T") && (parsed.flags.has("n") || parsed.flags.has("b") || !parsed.flags.has("h") && (parsed.flags.has("H") || multipleFiles || nested)) ? "	" : ""}`;
+      const emitContext = async (line, position, offset = byteOffset) => {
+        if (!parsed.flags.has("o")) {
+          await writeOut(prefix(true, position, "-", offset));
+          await writeOut(line.bytes);
+          await writeOut(delimiterBytes);
+        }
+        lastCovered = position;
+      };
+      try {
+        const source = name === "-" ? input(context) : requiredFileInput(context, grepRequirements, "file", name, limits.maxFileBytes ?? Infinity);
+        let earlyExitZero = false;
+        const invertMatch = parsed.flags.has("v");
+        const isQuiet = parsed.flags.has("q");
+        const isListFiles = parsed.flags.has("l") || parsed.flags.has("L");
+        const isCountOnly = parsed.flags.has("c");
+        const isOnlyMatching = parsed.flags.has("o");
+        const canFastBufferLines = !isQuiet && !isListFiles && !isCountOnly && !withContext && !isOnlyMatching && !hasLinePrefix && !lineBuffered && binaryFiles.mode !== "without-match";
+        const processBatchSlow = async (batch, endOfChunk, resultsPromise, startIdx = 0, precomputedResults) => {
+          const results = precomputedResults ?? await resultsPromise;
+          for (let index = startIdx; index < batch.length; index++) {
+            const line = batch[index];
+            context.signal.throwIfAborted();
+            number++;
+            byteOffset = nextOffset;
+            const curLineLen = line.searchEnd !== void 0 ? line.searchEnd - line.start : line.bytes.length;
+            nextOffset += curLineLen + (line.terminated ? 1 : 0);
+            const found = results[index];
+            const selected = count < maxCount && found.length > 0 !== invertMatch;
+            if (!selected) {
+              if (remainingAfter > 0) {
+                await emitContext(line, number);
+                remainingAfter--;
+                if (count >= maxCount && remainingAfter === 0) return false;
+              } else if (before > 0) {
+                if (pending.size >= before) {
+                  const oldest = pending.keys().next().value;
+                  pendingBytes -= pending.get(oldest).bytes.length + 1;
+                  pending.delete(oldest);
                 }
-                continue;
+                const size = line.bytes.length + 1;
+                if (size > (limits.maxContextBytes ?? Infinity) - pendingBytes) throw new UsageError(`context byte limit exceeded (${limits.maxContextBytes} bytes)`);
+                pending.set(number, { bytes: Uint8Array.from(line.bytes), terminated: line.terminated, offset: byteOffset });
+                pendingBytes += size;
               }
-              count++;
-              anySelected = true;
-              if (isQuiet) {
-                earlyExitZero = true;
-                return false;
+              continue;
+            }
+            count++;
+            anySelected = true;
+            if (isQuiet) {
+              earlyExitZero = true;
+              return false;
+            }
+            if (isListFiles) return false;
+            if (!isCountOnly) {
+              if (withContext) {
+                const first = pending.keys().next().value ?? number;
+                if (!parsed.flags.has("no-group-separator") && emittedGroup && (lastCovered === 0 || first > lastCovered + 1)) await writeOut((value(parsed, "group-separator") ?? "--") + delimiter);
+                for (const [position, previous] of pending) await emitContext(previous, position, previous.offset);
+                pending.clear();
+                pendingBytes = 0;
+                remainingAfter = after;
+                lastCovered = number;
+                emittedGroup = true;
               }
-              if (isListFiles) return false;
-              if (!isCountOnly) {
-                if (withContext) {
-                  const first = pending.keys().next().value ?? number;
-                  if (!parsed.flags.has("no-group-separator") && emittedGroup && (lastCovered === 0 || first > lastCovered + 1)) await writeOut((value(parsed, "group-separator") ?? "--") + delimiter);
-                  for (const [position, previous] of pending) await emitContext(previous, position, previous.offset);
-                  pending.clear();
-                  pendingBytes = 0;
-                  remainingAfter = after;
-                  lastCovered = number;
-                  emittedGroup = true;
-                }
-                if (isOnlyMatching) {
-                  if (!invertMatch) {
-                    let end = -1;
-                    for (const match of found) {
-                      if (match.start === match.end || match.start < end) continue;
-                      await writeOut(prefix(true, number, ":", byteOffset + match.start));
-                      await writeOut(line.bytes.subarray(match.start, match.end));
-                      await writeOut(delimiterBytes);
-                      end = match.end;
-                    }
+              if (isOnlyMatching) {
+                if (!invertMatch) {
+                  let end = -1;
+                  for (const match of found) {
+                    if (match.start === match.end || match.start < end) continue;
+                    await writeOut(prefix(true, number, ":", byteOffset + match.start));
+                    await writeOut(line.bytes.subarray(match.start, match.end));
+                    await writeOut(delimiterBytes);
+                    end = match.end;
                   }
-                } else {
-                  if (!hasLinePrefix && !lineBuffered && line.chunk !== void 0 && line.start !== void 0 && line.searchEnd !== void 0) {
-                    const lStart = line.start;
-                    const lEnd = line.searchEnd;
-                    const lLen = lEnd - lStart;
-                    outBuffer ??= ownsSharedOut ? sharedGrepOutBuffer : new Uint8Array(64 * 1024);
-                    if (outUsed + lLen + 1 <= outBuffer.length) {
-                      const c = line.chunk;
-                      let dst = outUsed;
-                      for (let i = lStart; i < lEnd; i++) outBuffer[dst++] = c[i];
-                      outBuffer[dst++] = delimiterByte;
-                      outUsed = dst;
-                      if (count >= maxCount && remainingAfter === 0) return false;
-                      continue;
-                    }
+                }
+              } else {
+                if (!hasLinePrefix && !lineBuffered && line.chunk !== void 0 && line.start !== void 0 && line.searchEnd !== void 0) {
+                  const lStart = line.start;
+                  const lEnd = line.searchEnd;
+                  const lLen = lEnd - lStart;
+                  outBuffer ??= new Uint8Array(64 * 1024);
+                  if (outUsed + lLen + 1 <= outBuffer.length) {
+                    const c = line.chunk;
+                    let dst = outUsed;
+                    for (let i = lStart; i < lEnd; i++) outBuffer[dst++] = c[i];
+                    outBuffer[dst++] = delimiterByte;
+                    outUsed = dst;
+                    if (count >= maxCount && remainingAfter === 0) return false;
+                    continue;
                   }
-                  const p = hasLinePrefix ? prefix(true) : "";
-                  if (p) await writeOut(p);
-                  await writeOut(line.bytes);
-                  await writeOut(delimiterBytes);
                 }
+                const p = hasLinePrefix ? prefix(true) : "";
+                if (p) await writeOut(p);
+                await writeOut(line.bytes);
+                await writeOut(delimiterBytes);
               }
-              if (count >= maxCount && remainingAfter === 0) return false;
-            }
-            if (endOfChunk || lineBuffered || outUsed - outStart >= 8192) await flushOut();
-            return true;
-          };
-          if (maxCount > 0) await forEachGrepLineBatch(source, parsed.flags.has("z") ? 0 : 10, limits.maxLineBytes ?? Infinity, () => batchSize, extractMatches, (batch, endOfChunk) => {
-            if (binaryFiles.mode === "without-match" && batch.some((line) => line.bytes.includes(0))) {
-              count = 0;
-              return false;
             }
-            const resOrPromise = runGrepBatch(batch);
-            if (resOrPromise instanceof Promise || !canFastBufferLines) {
-              return resOrPromise instanceof Promise ? processBatchSlow(batch, endOfChunk, resOrPromise) : processBatchSlow(batch, endOfChunk, void 0, 0, resOrPromise);
-            }
-            const results = resOrPromise;
-            for (let index = 0; index < batch.length; index++) {
-              const line = batch[index];
-              context.signal.throwIfAborted();
-              number++;
-              byteOffset = nextOffset;
-              const curLineLen = line.searchEnd !== void 0 ? line.searchEnd - line.start : line.bytes.length;
-              nextOffset += curLineLen + (line.terminated ? 1 : 0);
-              const found = results[index];
-              const selected = count < maxCount && found.length > 0 !== invertMatch;
-              if (!selected) continue;
-              if (line.chunk !== void 0 && line.start !== void 0 && line.searchEnd !== void 0) {
-                const lStart = line.start;
-                const lEnd = line.searchEnd;
-                const lLen = lEnd - lStart;
-                outBuffer ??= ownsSharedOut ? sharedGrepOutBuffer : new Uint8Array(64 * 1024);
-                if (outUsed + lLen + 1 <= outBuffer.length) {
-                  count++;
-                  anySelected = true;
-                  const c = line.chunk;
-                  let dst = outUsed;
-                  for (let i = lStart; i < lEnd; i++) outBuffer[dst++] = c[i];
-                  outBuffer[dst++] = delimiterByte;
-                  outUsed = dst;
-                  if (count >= maxCount) return false;
-                  continue;
-                }
+            if (count >= maxCount && remainingAfter === 0) return false;
+          }
+          if (endOfChunk || lineBuffered || outUsed - outStart >= 8192) await flushOut();
+          return true;
+        };
+        if (maxCount > 0) await forEachGrepLineBatch(source, parsed.flags.has("z") ? 0 : 10, limits.maxLineBytes ?? Infinity, () => batchSize, extractMatches, (batch, endOfChunk) => {
+          if (binaryFiles.mode === "without-match" && batch.some((line) => line.bytes.includes(0))) {
+            count = 0;
+            return false;
+          }
+          const resOrPromise = runGrepBatch(batch);
+          if (resOrPromise instanceof Promise || !canFastBufferLines) {
+            return resOrPromise instanceof Promise ? processBatchSlow(batch, endOfChunk, resOrPromise) : processBatchSlow(batch, endOfChunk, void 0, 0, resOrPromise);
+          }
+          const results = resOrPromise;
+          for (let index = 0; index < batch.length; index++) {
+            const line = batch[index];
+            context.signal.throwIfAborted();
+            number++;
+            byteOffset = nextOffset;
+            const curLineLen = line.searchEnd !== void 0 ? line.searchEnd - line.start : line.bytes.length;
+            nextOffset += curLineLen + (line.terminated ? 1 : 0);
+            const found = results[index];
+            const selected = count < maxCount && found.length > 0 !== invertMatch;
+            if (!selected) continue;
+            if (line.chunk !== void 0 && line.start !== void 0 && line.searchEnd !== void 0) {
+              const lStart = line.start;
+              const lEnd = line.searchEnd;
+              const lLen = lEnd - lStart;
+              outBuffer ??= new Uint8Array(64 * 1024);
+              if (outUsed + lLen + 1 <= outBuffer.length) {
+                count++;
+                anySelected = true;
+                const c = line.chunk;
+                let dst = outUsed;
+                for (let i = lStart; i < lEnd; i++) outBuffer[dst++] = c[i];
+                outBuffer[dst++] = delimiterByte;
+                outUsed = dst;
+                if (count >= maxCount) return false;
+                continue;
               }
-              number--;
-              nextOffset = byteOffset;
-              return processBatchSlow(batch, endOfChunk, void 0, index, results);
-            }
-            if ((endOfChunk || outUsed - outStart >= 8192) && outUsed > outStart) {
-              const p = flushOutSyncOrAsync();
-              return p ? p.then(() => true) : true;
             }
-            return true;
-          });
-          if (earlyExitZero) return { exitCode: 0 };
-          const finalFlush = flushOutSyncOrAsync();
-          if (finalFlush) await finalFlush;
-          if (parsed.flags.has("q")) continue;
-          if (parsed.flags.has("l") && count > 0 || parsed.flags.has("L") && count === 0) {
-            await output(context, named + (parsed.flags.has("Z") ? "\0" : "\n"));
-          } else if (parsed.flags.has("c") && !parsed.flags.has("l") && !parsed.flags.has("L")) await output(context, prefix() + count + delimiter);
-        } catch (error) {
-          await flushOut();
-          context.signal.throwIfAborted();
-          if (error instanceof RegexExecutionError) throw error;
-          failed = true;
-          if (!parsed.flags.has("s")) await diagnostic(context, error);
-        }
+            number--;
+            nextOffset = byteOffset;
+            return processBatchSlow(batch, endOfChunk, void 0, index, results);
+          }
+          if ((endOfChunk || outUsed - outStart >= 8192) && outUsed > outStart) {
+            const p = flushOutSyncOrAsync();
+            return p ? p.then(() => true) : true;
+          }
+          return true;
+        });
+        if (earlyExitZero) return { exitCode: 0 };
+        const finalFlush = flushOutSyncOrAsync();
+        if (finalFlush) await finalFlush;
+        if (parsed.flags.has("q")) continue;
+        if (parsed.flags.has("l") && count > 0 || parsed.flags.has("L") && count === 0) {
+          await output(context, named + (parsed.flags.has("Z") ? "\0" : "\n"));
+        } else if (parsed.flags.has("c") && !parsed.flags.has("l") && !parsed.flags.has("L")) await output(context, prefix() + count + delimiter);
+      } catch (error) {
+        await flushOut();
+        context.signal.throwIfAborted();
+        if (error instanceof RegexExecutionError) throw error;
+        failed = true;
+        if (!parsed.flags.has("s")) await diagnostic(context, error);
       }
-      return { exitCode: failed ? 2 : anySelected ? 0 : 1 };
-    } finally {
-      if (ownsSharedOut) sharedGrepOutInUse = false;
     }
+    return { exitCode: failed ? 2 : anySelected ? 0 : 1 };
   } catch (error) {
     context.signal.throwIfAborted();
     await diagnostic(context, error);

package/dist/safe-bash-table-text-engine/table-text/internal.d.ts

@@ -19,7 +19,7 @@ export declare const empty: Uint8Array<ArrayBuffer>;
 export declare const encode: (value: string) => Uint8Array;
 export declare function settings(options: TableTextCommandsOptions): TableTextLimits;
 export declare function fail(message: string): never;
-export declare function command(name: string, handler: CommandHandler): CommandDefinition;
+export declare function command(name: string, limits: TableTextLimits, handler: (context: CommandContext, budget: Budget) => ReturnType<CommandHandler>): CommandDefinition;
 export declare function compare(left: Uint8Array, right: Uint8Array, fold?: boolean): number;
 export declare class Budget {
     readonly context: CommandContext;
@@ -27,8 +27,6 @@ export declare class Budget {
     private inputBytes;
     private outputBytes;
     steps: number;
-    private signalAborted;
-    private readonly pollBaseSignal;
     constructor(context: CommandContext, limits: TableTextLimits, outputChunkBytes?: number);
     check(value: number | bigint, maximum: number, label: string): void;
     step(): void | Promise<void>;
@@ -73,10 +71,14 @@ export type OrderMode = "default" | "check" | "none";
 export declare class OrderCheck {
     readonly mode: OrderMode;
     readonly context: CommandContext;
-    unpaired: boolean;
+    readonly budget: Budget;
+    private unpaired;
     failed: boolean;
     private warned;
-    constructor(mode: OrderMode, context: CommandContext);
+    private pending;
+    constructor(mode: OrderMode, context: CommandContext, budget: Budget);
+    markUnpaired(): Promise<void>;
     check(previous: Uint8Array | undefined, next: Uint8Array | undefined, file: number, fold?: boolean): void | Promise<void>;
+    private report;
     finish(): Promise<void>;
 }