@poe-platform/safe-bash 0.1.726 → 0.1.727

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

@@ -2,35 +2,35 @@ import {
   createGetoptCommand,
   createGetoptCommands,
   getoptCommands
-} from "./chunks/chunk-YR5RZBWS.js";
+} from "./chunks/chunk-6TBFZ5JE.js";
 import {
   createHdCommand,
   createHexdumpCommand,
   createHexdumpCommands,
   hexdumpCommands
-} from "./chunks/chunk-5X4SOSTT.js";
+} from "./chunks/chunk-UJHE5PTK.js";
 import {
   createIconvCommand,
   createIconvCommands,
   iconvCommands
-} from "./chunks/chunk-DPHRNHPT.js";
+} from "./chunks/chunk-H6KJ4L22.js";
 import {
   createDos2unixCommand,
   createLineEndingCommands,
   createUnix2dosCommand,
   lineEndingCommands
-} from "./chunks/chunk-Q4I754TV.js";
+} from "./chunks/chunk-THOBFD5C.js";
 import {
   createXmlCommands,
   defaultXmlQueryLimits,
   jqCommand,
   xmlCommands
-} from "./chunks/chunk-SME47P4B.js";
+} from "./chunks/chunk-DV6EZOKM.js";
 import {
   createYqCommand,
   createYqCommands,
   yqCommands
-} from "./chunks/chunk-LZ7FUN6K.js";
+} from "./chunks/chunk-RHHDOA67.js";
 import {
   Budget,
   Pattern,
@@ -42,15 +42,16 @@ import {
   defaultJqLimits,
   grepRequirements,
   input as input2,
-  lineRecords,
+  lineRecordBatches,
   readProgram,
   requiredFileInput,
   searchRequirements,
   sedRequirements,
   substitute,
+  trySubstituteSync,
   virtualPath,
   write
-} from "./chunks/chunk-VV24PRPB.js";
+} from "./chunks/chunk-AZQOEGP3.js";
 import {
   CurlError,
   cloudflareWorkerNetworkLimits,
@@ -63,7 +64,7 @@ import {
   curlCommands,
   defaultNetworkLimits,
   networkCommands
-} from "./chunks/chunk-FOOJWH7J.js";
+} from "./chunks/chunk-GO5OKPBO.js";
 import {
   SafeJsCommandLimitError,
   createSafeJsNodeCommand,
@@ -74,9 +75,8 @@ import {
   safeJsNodeCommands,
   stringValue,
   withSignal
-} from "./chunks/chunk-PO3Z7W3A.js";
+} from "./chunks/chunk-MUHYGUFD.js";
 import {
-  AvailableRecords,
   EreLedger,
   EreProfileLimitError,
   EreSyntaxError,
@@ -95,8 +95,9 @@ import {
   exprMatchCeilings,
   matchEre,
   reverseEmacsSteps,
+  trustedInputRows,
   withRegexSession
-} from "./chunks/chunk-7UJW7TYR.js";
+} from "./chunks/chunk-TD6NWAUK.js";
 import {
   openFileOutput,
   writeFileOutput
@@ -115,17 +116,17 @@ import {
   parseDate,
   prCommands,
   settings
-} from "./chunks/chunk-6VZX7ESE.js";
+} from "./chunks/chunk-26N7BLXE.js";
 import {
   createTsortCommand,
   createTsortCommands,
   tsortCommands
-} from "./chunks/chunk-Z3CCN6Y2.js";
+} from "./chunks/chunk-6J5FUESH.js";
 import {
   createFactorCommand,
   createFactorCommands,
   factorCommands
-} from "./chunks/chunk-6HJNJ625.js";
+} from "./chunks/chunk-7MMYQG3P.js";
 import {
   shellValueByteLength,
   value_exports
@@ -179,7 +180,7 @@ import {
   swap32IfBE,
   swap8IfBE,
   u32
-} from "./chunks/chunk-646RTREQ.js";
+} from "./chunks/chunk-EEDOYIPC.js";
 import {
   bindFileOutputBudget,
   openCommandFile
@@ -191,7 +192,7 @@ import {
 import {
   createLlmCommands,
   llmCommands
-} from "./chunks/chunk-LTREB3HX.js";
+} from "./chunks/chunk-54MC6XF5.js";
 import {
   RecordBuffer,
   UsageError,
@@ -220,24 +221,25 @@ import {
   requireOperands,
   textOutputRequirements,
   value
-} from "./chunks/chunk-OTM5RCWZ.js";
+} from "./chunks/chunk-QNEDWYC2.js";
 import {
   escapeText,
   quoteShellOperand,
   writeDiagnostic
-} from "./chunks/chunk-ZZ7JQBPX.js";
+} from "./chunks/chunk-4A2OLEML.js";
 import {
   PublicDiagnostic,
   publicDiagnosticMessage
 } from "./chunks/chunk-ITX6SBN6.js";
 import {
   cancelTurn,
+  hasYieldCheckpoint,
   inheritYieldCheckpoint,
   monotonicNow,
   registerYieldCheckpoint,
   scheduleTurn,
   yieldTurn
-} from "./chunks/chunk-YOK5UHA7.js";
+} from "./chunks/chunk-XKXFX3RH.js";
 import {
   command_requirements_exports,
   contracts_exports,
@@ -285,7 +287,7 @@ __export(core_browser_exports, {
   EreSyntaxError: () => EreSyntaxError,
   EreUnsupportedError: () => EreUnsupportedError,
   EreUsageUnknownError: () => EreUsageUnknownError,
-  FsError: () => FsError61,
+  FsError: () => FsError62,
   MemoryFileSystem: () => MemoryFileSystem,
   MountFileSystem: () => MountFileSystem,
   OverlayFileSystem: () => OverlayFileSystem,
@@ -5791,10 +5793,10 @@ async function suffix(context2, source2, count2, bytes3, omit, delimiter) {
     let pendingLines = [];
     let start2 = 0;
     let size2 = 0;
-    for await (const line of lines(source2, delimiter)) {
-      context2.signal.throwIfAborted();
-      const lineLength = line.bytes.length + (line.terminated ? 1 : 0);
-      pendingLines.push(line);
+    const pending2 = new RecordBuffer(bufferLimit);
+    const pushLine = async (lineBytes, terminated) => {
+      const lineLength = lineBytes.length + (terminated ? 1 : 0);
+      pendingLines.push({ bytes: lineBytes, terminated });
       size2 += lineLength;
       while (pendingLines.length - start2 > count2) {
         const first = pendingLines[start2++];
@@ -5806,6 +5808,23 @@ async function suffix(context2, source2, count2, bytes3, omit, delimiter) {
         pendingLines = pendingLines.slice(start2);
         start2 = 0;
       }
+    };
+    try {
+      for await (const chunk of source2) {
+        context2.signal.throwIfAborted();
+        let lineStart = 0;
+        for (let offset = chunk.indexOf(delimiter); offset !== -1; offset = chunk.indexOf(delimiter, lineStart)) {
+          await pushLine(pending2.finish(void 0, chunk, lineStart, offset), true);
+          lineStart = offset + 1;
+        }
+        if (lineStart < chunk.length) pending2.append(chunk, lineStart);
+      }
+      if (pending2.size) {
+        context2.signal.throwIfAborted();
+        await pushLine(pending2.finish(), false);
+      }
+    } finally {
+      pending2.clear();
     }
     if (!omit) {
       for (let index = start2; index < pendingLines.length; index++) {
@@ -6235,6 +6254,8 @@ Concatenate FILEs to standard output. With no FILE, or FILE -, read standard inp
             inWord = true;
           }
         };
+        const needsText = parsed.flags.has("w") || parsed.flags.has("m") || parsed.flags.has("L");
+        const needsLines = parsed.flags.has("l");
         const utf82 = wcUtf8((point) => {
           if (point !== void 0) counts.m++;
           word(point !== void 0 && wcSpace(point, posix), point !== void 0 && point >= 32 && !(point >= 127 && point < 160));
@@ -6244,6 +6265,12 @@ Concatenate FILEs to standard output. With no FILE, or FILE -, read standard inp
           for await (const chunk of input(context2, name2)) {
             context2.signal.throwIfAborted();
             counts.c += chunk.length;
+            if (!needsText) {
+              if (needsLines) {
+                for (let pos = chunk.indexOf(10); pos !== -1; pos = chunk.indexOf(10, pos + 1)) counts.l++;
+              }
+              continue;
+            }
             for (const byte of chunk) {
               if (byte === 10) counts.l++;
               if (singleByte) word(byte === 32 || byte >= 9 && byte <= 13, byte >= 32 && byte < 127);
@@ -6252,7 +6279,7 @@ Concatenate FILEs to standard output. With no FILE, or FILE -, read standard inp
             if (singleByte) counts.m += chunk.length;
             else utf82.write(chunk);
           }
-          if (!singleByte) utf82.finish();
+          if (needsText && !singleByte) utf82.finish();
           counts.L = Math.max(counts.L, columns);
           for (const field2 of ["l", "w", "m", "c"]) totals[field2] += counts[field2];
           totals.L = Math.max(totals.L, counts.L);
@@ -6353,21 +6380,29 @@ Concatenate FILEs to standard output. With no FILE, or FILE -, read standard inp
       const second = parsed.operands[1] === void 0 ? [] : characterSet(parsed.operands[1], translating ? first.length : 0);
       if (translating && parsed.flags.has("t")) first = first.slice(0, second.length);
       if (translating && !second.length && !parsed.flags.has("t")) throw new UsageError("second character set must not be empty");
-      const mapping = Array.from({ length: 256 }, (_, offset) => offset);
+      const mapping = new Uint8Array(256);
+      for (let offset = 0; offset < 256; offset++) mapping[offset] = offset;
       if (translating) first.forEach((byte, index) => {
         mapping[byte] = second[Math.min(index, second.length - 1)];
       });
-      const removed = new Set(deleting ? first : []);
-      const squeezed = new Set(squeezing ? parsed.operands.length === 2 ? second : first : []);
+      const removed = new Uint8Array(256);
+      if (deleting) for (const byte of first) removed[byte] = 1;
+      const squeezed = new Uint8Array(256);
+      if (squeezing) for (const byte of parsed.operands.length === 2 ? second : first) squeezed[byte] = 1;
       let previous = -1;
       for await (const chunk of input(context2)) {
         context2.signal.throwIfAborted();
         const transformed = new Uint8Array(chunk.length);
+        if (!deleting && !squeezing) {
+          for (let index = 0; index < chunk.length; index++) transformed[index] = mapping[chunk[index]];
+          if (chunk.length) await output(context2, transformed);
+          continue;
+        }
         let count2 = 0;
         for (const byte of chunk) {
-          if (removed.has(byte)) continue;
+          if (removed[byte]) continue;
           const translated = mapping[byte];
-          if (translated === previous && squeezed.has(translated)) continue;
+          if (translated === previous && squeezed[translated]) continue;
           transformed[count2++] = translated;
           previous = translated;
         }
@@ -6511,7 +6546,16 @@ var CutOutput = class {
   work;
   #buffer = new Uint8Array(64 * 1024);
   #used = 0;
-  async write(bytes3) {
+  write(bytes3) {
+    if (bytes3.length <= 4096 && this.#used + bytes3.length < this.#buffer.length) {
+      const checkpoint = this.work.charge(bytes3.length);
+      this.#buffer.set(bytes3, this.#used);
+      this.#used += bytes3.length;
+      return checkpoint;
+    }
+    return this.#writeSlow(bytes3);
+  }
+  async #writeSlow(bytes3) {
     for (let offset = 0; offset < bytes3.length; ) {
       const length = Math.min(4096, bytes3.length - offset, this.#buffer.length - this.#used);
       const checkpoint = this.work.charge(length);
@@ -6538,7 +6582,16 @@ var CutOutput = class {
     await output(this.context, bytes3);
   }
 };
-async function cutFieldBoundary(record3, separator, start, work) {
+function cutFieldBoundary(record3, separator, start, work) {
+  if (record3.length - start <= 4096) {
+    const found = separator.length === 1 ? record3.indexOf(separator[0], start) : record3.indexOf(separator, start);
+    const charged = found < 0 ? record3.length - start : found - start + separator.length;
+    const checkpoint = work.charge(charged);
+    return checkpoint ? checkpoint.then(() => found) : found;
+  }
+  return cutFieldBoundarySlow(record3, separator, start, work);
+}
+async function cutFieldBoundarySlow(record3, separator, start, work) {
   for (let offset = start; offset < record3.length; offset += 4096) {
     const window = record3.subarray(offset, Math.min(record3.length, offset + 4096 + separator.length - 1));
     const found = window.indexOf(separator);
@@ -6595,13 +6648,35 @@ function fold(bytes3) {
   return bytes3.map((byte) => byte >= 97 && byte <= 122 ? byte - 32 : byte);
 }
 function parseNumericSync(bytes3, human = false) {
-  const match = /^[ \t]*(-?)([0-9]*)(?:\.([0-9]*))?/u.exec(import_buffer.Buffer.from(bytes3.buffer, bytes3.byteOffset, bytes3.byteLength).toString("latin1"));
-  const whole = (match[2] ?? "").replace(/^0+/u, "") || "0";
-  const fraction = (match[3] ?? "").replace(/0+$/u, "");
+  const buf = import_buffer.Buffer.from(bytes3);
+  const len = bytes3.length;
+  let i = 0;
+  while (i < len && (bytes3[i] === 32 || bytes3[i] === 9)) i++;
+  let neg = false;
+  if (i < len && bytes3[i] === 45) {
+    neg = true;
+    i++;
+  }
+  let wholeStart = i;
+  while (wholeStart < len && bytes3[wholeStart] === 48) wholeStart++;
+  let wholeEnd = wholeStart;
+  while (wholeEnd < len && bytes3[wholeEnd] >= 48 && bytes3[wholeEnd] <= 57) wholeEnd++;
+  i = wholeEnd;
+  let fracStart = 0;
+  let fracEnd = 0;
+  if (i < len && bytes3[i] === 46) {
+    i++;
+    fracStart = i;
+    while (i < len && bytes3[i] >= 48 && bytes3[i] <= 57) i++;
+    fracEnd = i;
+    while (fracEnd > fracStart && bytes3[fracEnd - 1] === 48) fracEnd--;
+  }
+  const whole = wholeEnd > wholeStart ? buf.toString("latin1", wholeStart, wholeEnd) : "0";
+  const fraction = fracEnd > fracStart ? buf.toString("latin1", fracStart, fracEnd) : "";
   const nonzero = whole !== "0" || fraction !== "";
-  const suffix2 = bytes3[match[0].length];
+  const suffix2 = bytes3[i];
   const suffixRank = human && nonzero ? "KMGTPEZYRQ".indexOf(String.fromCharCode(suffix2 === 107 ? 75 : suffix2 ?? 0)) + 1 : 0;
-  return { whole, fraction, negative: match[1] === "-" && nonzero, suffixRank };
+  return { whole, fraction, negative: neg && nonzero, suffixRank };
 }
 function parseNumeric(bytes3, work, human = false) {
   const checkpoint = work.charge(bytes3.length);
@@ -6853,6 +6928,45 @@ async function mergeSortRuns(runs, compare6, work) {
   }
   return runs[0] ?? [];
 }
+function keyBytesSync(line, key, separator, blanks, work) {
+  if (line.length > 1024) return keyBytes(line, key, separator, blanks, work);
+  const fields4 = [];
+  if (separator !== void 0) {
+    let start2 = 0;
+    for (let offset = 0; offset <= line.length; offset++) {
+      if (offset === line.length || line[offset] === separator) {
+        fields4.push({ start: start2, end: offset });
+        start2 = offset + 1;
+      }
+    }
+  } else {
+    let offset = 0;
+    while (offset < line.length) {
+      const leading = offset;
+      while (offset < line.length && (line[offset] === 32 || line[offset] === 9)) offset++;
+      const start2 = leading;
+      if (offset === line.length) break;
+      while (offset < line.length && line[offset] !== 32 && line[offset] !== 9) offset++;
+      fields4.push({ start: start2, end: offset });
+    }
+  }
+  let extraCharge = line.length;
+  const fieldStart = (field2, skipBlanks) => {
+    let offset = field2?.start ?? line.length;
+    if (skipBlanks) while (offset < (field2?.end ?? line.length) && (line[offset] === 32 || line[offset] === 9)) {
+      extraCharge++;
+      offset++;
+    }
+    return offset;
+  };
+  const inheritBlanks = key.flags.size === 0 && blanks;
+  const start = fieldStart(fields4[key.start - 1], key.startBlanks || inheritBlanks) + key.startCharacter - 1;
+  const last = key.end === void 0 ? void 0 : fields4[key.end - 1];
+  const end = key.end === void 0 ? line.length : last === void 0 ? line.length : key.endCharacter === void 0 ? last.end : Math.min(line.length, fieldStart(last, key.endBlanks || inheritBlanks) + key.endCharacter);
+  const result = line.subarray(Math.min(start, line.length), Math.max(start, end));
+  const checkpoint = work.charge(extraCharge);
+  return checkpoint ? checkpoint.then(() => result) : result;
+}
 async function keyBytes(line, key, separator, blanks, work) {
   const fields4 = [];
   if (separator !== void 0) {
@@ -6924,8 +7038,9 @@ async function collectSortRecords(source2, delimiter, budget, signal, accept) {
   try {
     for await (const chunk of source2) {
       let start = 0;
-      for (let offset = 0; offset < chunk.length; offset++) {
-        if (chunk[offset] !== delimiter) continue;
+      while (start < chunk.length) {
+        const offset = chunk.indexOf(delimiter, start);
+        if (offset < 0) break;
         const accepted = accept(pending.finish(admit2, chunk, start, offset));
         if ((accepted instanceof Promise ? await accepted : accepted) === false) return false;
         start = offset + 1;
@@ -7039,8 +7154,20 @@ function textCommands() {
           const cached = keyedNumericValues.get(record3);
           if (cached !== void 0) return cached;
           context2.signal.throwIfAborted();
+          const bytesOrPromise = keyBytesSync(record3, numericKey, separator, false, work);
+          if (!(bytesOrPromise instanceof Promise)) {
+            const charge2 = 6 * bytesOrPromise.length + 10;
+            const parsedOrPromise = parseNumeric(bytesOrPromise, work, numericKeyFlags.has("h"));
+            if (!(parsedOrPromise instanceof Promise)) {
+              if (keyedNumericValues.size < 16384 && charge2 <= 1048576 - retainedKeyBytes) {
+                keyedNumericValues.set(record3, parsedOrPromise);
+                retainedKeyBytes += charge2;
+              }
+              return parsedOrPromise;
+            }
+          }
           return (async () => {
-            const bytes3 = await keyBytes(record3, numericKey, separator, false, work);
+            const bytes3 = await bytesOrPromise;
             const charge2 = 6 * bytes3.length + 10;
             if (keyedNumericValues.size >= 16384 || charge2 > 1048576 - retainedKeyBytes) return await parseNumeric(bytes3, work, numericKeyFlags.has("h"));
             const parsedValue = await parseNumeric(bytes3, work, numericKeyFlags.has("h"));
@@ -7273,10 +7400,12 @@ function textCommands() {
               };
               if (mode === "f") {
                 const record3 = import_buffer.Buffer.from(line.bytes.buffer, line.bytes.byteOffset, line.bytes.byteLength);
-                let boundary = await cutFieldBoundary(record3, separator, 0, work);
+                const b0 = cutFieldBoundary(record3, separator, 0, work);
+                let boundary = typeof b0 === "number" ? b0 : await b0;
                 if (boundary < 0) {
                   if (parsed.flags.has("s")) continue;
-                  await writer.write(line.bytes);
+                  const w = writer.write(line.bytes);
+                  if (w) await w;
                 } else {
                   let field2 = 1;
                   let start = 0;
@@ -7285,13 +7414,18 @@ function textCommands() {
                     const checkpoint = work.charge();
                     if (checkpoint) await checkpoint;
                     if (selected2(field2++) >= 0) {
-                      if (emitted) await writer.write(outputDelimiterBytes);
-                      await writer.write(record3.subarray(start, boundary < 0 ? record3.length : boundary));
+                      if (emitted) {
+                        const w1 = writer.write(outputDelimiterBytes);
+                        if (w1) await w1;
+                      }
+                      const w2 = writer.write(record3.subarray(start, boundary < 0 ? record3.length : boundary));
+                      if (w2) await w2;
                       emitted = true;
                     }
-                    if (boundary < 0) break;
+                    if (boundary < 0 || !complement && cursor >= ranges2.length) break;
                     start = boundary + separator.length;
-                    boundary = await cutFieldBoundary(record3, separator, start, work);
+                    const bn = cutFieldBoundary(record3, separator, start, work);
+                    boundary = typeof bn === "number" ? bn : await bn;
                   }
                 }
               } else if (byteSelection) {
@@ -7348,7 +7482,8 @@ function textCommands() {
                   if (start >= 0) await writer.text(text3.slice(start));
                 }
               }
-              await writer.write(recordDelimiterBytes);
+              const wd = writer.write(recordDelimiterBytes);
+              if (wd) await wd;
             }
           } finally {
             await writer.flush();
@@ -14120,6 +14255,8 @@ ${error.extra}${error.help ? "Try 'numfmt --help' for more information.\n" : ""}
 }
 
 // packages/safe-bash/src/commands/standard.ts
+var defaultBaseStandardCommands;
+var defaultTailStandardCommands;
 function createStandardCommandsWithGrep(options2, grep) {
   const commands = [];
   const execute3 = directExecutor(options2.execute ?? (async (context2) => {
@@ -14128,6 +14265,29 @@ function createStandardCommandsWithGrep(options2, grep) {
     await diagnostic(context2, new PublicDiagnostic("command not found"));
     return { exitCode: 127 };
   }));
+  if (options2.maxDirectoryEntries === void 0 && options2.maxTeeTargets === void 0 && options2.maxTailFollowHandles === void 0 && options2.predicateIdentity === void 0) {
+    defaultBaseStandardCommands ??= Object.freeze([
+      ...basicCommands(),
+      ...filesystemCommands(void 0),
+      ...streamCommands(void 0, void 0),
+      ...textCommands()
+    ]);
+    defaultTailStandardCommands ??= Object.freeze([
+      ...predicateCommands(void 0),
+      cmpCommand(),
+      fmtCommand(),
+      shufCommand(),
+      numfmtCommand()
+    ]);
+    commands.push(
+      ...defaultBaseStandardCommands,
+      ...grep,
+      ...defaultTailStandardCommands,
+      ...executionCommands(execute3, options2.execution),
+      ...findCommands(execute3, void 0)
+    );
+    return commands;
+  }
   commands.push(...basicCommands(), ...filesystemCommands(options2.maxDirectoryEntries), ...streamCommands(options2.maxTeeTargets, options2.maxTailFollowHandles), ...textCommands(), ...grep, ...predicateCommands(options2.predicateIdentity), ...executionCommands(execute3, options2.execution), ...findCommands(execute3, options2.maxDirectoryEntries));
   commands.push(cmpCommand(), fmtCommand(), shufCommand(), numfmtCommand());
   return commands;
@@ -14460,30 +14620,90 @@ async function* nullRecords(context2, files, budget) {
   }
 }
 async function execute(program, context2, files, quiet, budget, separator, outputState, lineLength) {
-  const source2 = separator === "\0" ? nullRecords(context2, files, budget) : lineRecords(context2, files, budget);
-  let current = await source2.next();
-  let following;
-  const peekNext = async () => following ??= await source2.next();
-  const readNext = async () => {
-    const next = await peekNext();
-    following = void 0;
-    return next;
+  const useBatches = separator !== "\0";
+  const batchSource = useBatches ? lineRecordBatches(context2, files, budget) : void 0;
+  const singleSource = useBatches ? void 0 : nullRecords(context2, files, budget);
+  let currentBatch = [];
+  let batchIndex = 0;
+  let currentRecord;
+  let followingRecord;
+  if (batchSource) {
+    const firstBatch = await batchSource.next();
+    if (!firstBatch.done && firstBatch.value.length > 0) {
+      currentBatch = firstBatch.value;
+      currentRecord = currentBatch[0];
+      batchIndex = 1;
+    }
+  } else {
+    const first = await singleSource.next();
+    if (!first.done) currentRecord = first.value;
+  }
+  const peekNextRecord = async () => {
+    if (followingRecord !== void 0) return followingRecord ?? void 0;
+    if (batchSource) {
+      if (batchIndex < currentBatch.length) {
+        followingRecord = currentBatch[batchIndex];
+        return followingRecord;
+      }
+      const nextBatch = await batchSource.next();
+      if (nextBatch.done || nextBatch.value.length === 0) {
+        followingRecord = null;
+        return void 0;
+      }
+      currentBatch = nextBatch.value;
+      batchIndex = 0;
+      followingRecord = currentBatch[0];
+      return followingRecord;
+    }
+    const next = await singleSource.next();
+    followingRecord = next.done ? null : next.value;
+    return followingRecord ?? void 0;
+  };
+  const readNextRecord = async () => {
+    if (followingRecord !== void 0) {
+      const next2 = followingRecord ?? void 0;
+      followingRecord = void 0;
+      if (batchSource && next2 !== void 0 && batchIndex < currentBatch.length && currentBatch[batchIndex] === next2) {
+        batchIndex++;
+      }
+      return next2;
+    }
+    if (batchSource) {
+      if (batchIndex < currentBatch.length) return currentBatch[batchIndex++];
+      const nextBatch = await batchSource.next();
+      if (nextBatch.done || nextBatch.value.length === 0) return void 0;
+      currentBatch = nextBatch.value;
+      batchIndex = 1;
+      return currentBatch[0];
+    }
+    const next = await singleSource.next();
+    return next.done ? void 0 : next.value;
   };
-  const prepareRecord = async (record3) => {
-    if (record3.terminated || files.length < 2) return record3;
-    const next = await peekNext();
-    return !next.done && next.value.fileIndex !== record3.fileIndex ? { ...record3, terminated: true } : record3;
+  const prepareRecord = async (record4) => {
+    if (record4.terminated || files.length < 2) return record4;
+    const next = await peekNextRecord();
+    return next !== void 0 && next.fileIndex !== record4.fileIndex ? { ...record4, terminated: true } : record4;
   };
   let number6 = 0;
   let hold = "";
   let holdTerminated = true;
+  let stdoutBuffer = "";
+  const flushStdout = async () => {
+    if (stdoutBuffer.length > 0) {
+      const chunk = stdoutBuffer;
+      stdoutBuffer = "";
+      await write(context2, chunk);
+    }
+  };
   const joinSpace = (left, right) => {
     if (left.length + separator.length + right.length > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
     return left + separator + right;
   };
-  const emit2 = async (text3, terminated = true) => {
-    await write(context2, (outputState.stdoutUnterminated ? separator : "") + text3);
+  const emit2 = (text3, terminated = true) => {
+    stdoutBuffer += (outputState.stdoutUnterminated ? separator : "") + text3;
     outputState.stdoutUnterminated = !terminated;
+    if (stdoutBuffer.length >= 16384) return flushStdout();
+    return void 0;
   };
   let lastPattern;
   const active = /* @__PURE__ */ new Set();
@@ -14491,69 +14711,101 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
     const first = program[pc].first;
     if (first?.kind === "number" && first.number === 0) active.add(pc);
   }
-  const getPattern = (pattern) => {
-    if (pattern) lastPattern = pattern;
+  const getPattern = (pattern2) => {
+    if (pattern2) lastPattern = pattern2;
     if (!lastPattern) throw new ProgramError("no previous regular expression");
     return lastPattern;
   };
+  const appended = [];
+  let appendedSize = 0;
+  const append = (item) => {
+    appendedSize += (item.text ?? item.file ?? "").length + 32;
+    if (appendedSize > budget.maxBufferBytes) throw new ProgramError("append queue buffer limit exceeded");
+    appended.push(item);
+  };
+  let record3;
+  let pattern = "";
+  let substituted = false;
+  let deleted = false;
+  let quit = false;
+  let status2 = 0;
+  const print = () => emit2(pattern + (record3.terminated ? separator : ""), record3.terminated);
+  const flushSlow = async (printPattern) => {
+    if (appended.length > 0) {
+      await assertPathRequirements(context2, sedRequirements, ["script-read"], appended.flatMap((item) => item.file === void 0 ? [] : [item.file]));
+    }
+    if (printPattern && !quiet && !deleted) {
+      const p = print();
+      if (p) await p;
+    }
+    if (outputState.stdoutUnterminated && (appended.length || quit)) {
+      stdoutBuffer += separator;
+      if (stdoutBuffer.length >= 16384) await flushStdout();
+      outputState.stdoutUnterminated = false;
+    }
+    for (const item of appended) {
+      if (item.text !== void 0) {
+        stdoutBuffer += item.text;
+        if (stdoutBuffer.length >= 16384) await flushStdout();
+        continue;
+      }
+      await flushStdout();
+      const path = virtualPath(context2, item.file);
+      try {
+        for await (const chunk of requiredFileInput(context2, sedRequirements, "script-read", path, budget.maxBufferBytes)) {
+          budget.step();
+          const pendingCheck = budget.checkpointSync();
+          if (pendingCheck) await pendingCheck;
+          if (chunk.byteLength > budget.maxBufferBytes) throw new ProgramError("read buffer limit exceeded");
+          await (0, contracts_exports.writeBytes)(context2.stdout, chunk, context2.signal);
+        }
+      } catch (error) {
+        context2.signal.throwIfAborted();
+        if (!(error instanceof contracts_exports.FsError) || !["ENOENT", "EACCES", "EPERM", "EISDIR", "ENOTDIR"].includes(error.code)) throw error;
+      }
+    }
+    appended.length = 0;
+    appendedSize = 0;
+  };
+  const flush = (printPattern = true) => {
+    if (appended.length === 0 && (!outputState.stdoutUnterminated || !quit)) {
+      if (printPattern && !quiet && !deleted) return print();
+      return void 0;
+    }
+    return flushSlow(printPattern);
+  };
+  const writeFile = async (file) => {
+    const path = virtualPath(context2, file);
+    const terminated = record3.terminated || separator === "\n";
+    const text3 = (outputState.unterminatedFiles.has(path) ? separator : "") + pattern + (terminated ? separator : "");
+    await writeFileOutput(context2, bytes(text3), (chunk) => context2.fs.appendFile(path, chunk, { signal: context2.signal }));
+    if (terminated) outputState.unterminatedFiles.delete(path);
+    else outputState.unterminatedFiles.add(path);
+  };
+  const matches2 = (address) => {
+    if (address.kind === "number") return number6 === address.number;
+    if (address.kind === "last") {
+      if (batchSource && batchIndex < currentBatch.length) return false;
+      return peekNextRecord().then((next) => next === void 0);
+    }
+    const found = getPattern(address.pattern).tryFindSync(pattern, budget);
+    if (found instanceof Promise) return found.then((res) => res !== void 0);
+    return found !== void 0;
+  };
   try {
-    while (!current.done) {
+    while (currentRecord !== void 0) {
       budget.step();
       number6++;
-      let record3 = await prepareRecord(current.value);
-      let pattern = record3.text;
-      const appended = [];
-      let appendedSize = 0;
-      const append = (item) => {
-        appendedSize += (item.text ?? item.file ?? "").length + 32;
-        if (appendedSize > budget.maxBufferBytes) throw new ProgramError("append queue buffer limit exceeded");
-        appended.push(item);
-      };
-      let substituted = false;
-      let deleted = false;
-      let quit = false;
-      let status2 = 0;
-      const print = () => emit2(pattern + (record3.terminated ? separator : ""), record3.terminated);
-      const flush = async (printPattern = true) => {
-        await assertPathRequirements(context2, sedRequirements, ["script-read"], appended.flatMap((item) => item.file === void 0 ? [] : [item.file]));
-        if (printPattern && !quiet && !deleted) await print();
-        if (outputState.stdoutUnterminated && (appended.length || quit)) {
-          await write(context2, separator);
-          outputState.stdoutUnterminated = false;
-        }
-        for (const item of appended) {
-          if (item.text !== void 0) {
-            await write(context2, item.text);
-            continue;
-          }
-          const path = virtualPath(context2, item.file);
-          try {
-            for await (const chunk of requiredFileInput(context2, sedRequirements, "script-read", path, budget.maxBufferBytes)) {
-              budget.step();
-              await budget.checkpoint();
-              if (chunk.byteLength > budget.maxBufferBytes) throw new ProgramError("read buffer limit exceeded");
-              await (0, contracts_exports.writeBytes)(context2.stdout, chunk, context2.signal);
-            }
-          } catch (error) {
-            context2.signal.throwIfAborted();
-            if (!(error instanceof contracts_exports.FsError) || !["ENOENT", "EACCES", "EPERM", "EISDIR", "ENOTDIR"].includes(error.code)) throw error;
-          }
-        }
-        appended.length = 0;
-        appendedSize = 0;
-      };
-      const writeFile = async (file) => {
-        const path = virtualPath(context2, file);
-        const terminated = record3.terminated || separator === "\n";
-        const text3 = (outputState.unterminatedFiles.has(path) ? separator : "") + pattern + (terminated ? separator : "");
-        await writeFileOutput(context2, bytes(text3), (chunk) => context2.fs.appendFile(path, chunk, { signal: context2.signal }));
-        if (terminated) outputState.unterminatedFiles.delete(path);
-        else outputState.unterminatedFiles.add(path);
-      };
-      const matches2 = async (address) => address.kind === "number" ? number6 === address.number : address.kind === "last" ? (await peekNext()).done === true : await getPattern(address.pattern).find(pattern, budget) !== void 0;
+      record3 = currentRecord.terminated || files.length < 2 ? currentRecord : await prepareRecord(currentRecord);
+      pattern = record3.text;
+      substituted = false;
+      deleted = false;
+      quit = false;
+      status2 = 0;
       for (let pc = 0; pc < program.length; ) {
         budget.step();
-        await budget.checkpoint();
+        const pendingCheck = budget.checkpointSync();
+        if (pendingCheck) await pendingCheck;
         const instruction = program[pc];
         let selected2 = true;
         let ending = false;
@@ -14561,16 +14813,21 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
           if (instruction.second) {
             if (active.has(pc)) {
               if (instruction.second.kind === "number" && number6 > instruction.second.number) selected2 = false;
-              ending = instruction.second.kind === "number" ? number6 >= instruction.second.number : await matches2(instruction.second);
+              const endMatch = instruction.second.kind === "number" ? number6 >= instruction.second.number : matches2(instruction.second);
+              ending = endMatch instanceof Promise ? await endMatch : endMatch;
               if (ending) active.delete(pc);
             } else {
-              selected2 = await matches2(instruction.first);
+              const firstMatch = matches2(instruction.first);
+              selected2 = firstMatch instanceof Promise ? await firstMatch : firstMatch;
               if (selected2) {
-                ending = instruction.second.kind === "number" && number6 >= instruction.second.number || instruction.second.kind === "last" && (await peekNext()).done === true;
+                ending = instruction.second.kind === "number" && number6 >= instruction.second.number || instruction.second.kind === "last" && await peekNextRecord() === void 0;
                 if (!ending) active.add(pc);
               }
             }
-          } else selected2 = await matches2(instruction.first);
+          } else {
+            const firstMatch = matches2(instruction.first);
+            selected2 = firstMatch instanceof Promise ? await firstMatch : firstMatch;
+          }
         }
         if (instruction.negate) selected2 = !selected2;
         if (!selected2) {
@@ -14578,23 +14835,28 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
           continue;
         }
         switch (instruction.kind) {
-          case "p":
-            await print();
+          case "p": {
+            const p = print();
+            if (p) await p;
             break;
+          }
           case "P": {
             const end = pattern.indexOf(separator);
-            await emit2(end < 0 ? pattern + (record3.terminated ? separator : "") : pattern.slice(0, end + 1), end >= 0 || record3.terminated);
+            const p = emit2(end < 0 ? pattern + (record3.terminated ? separator : "") : pattern.slice(0, end + 1), end >= 0 || record3.terminated);
+            if (p) await p;
             break;
           }
-          case "=":
-            await emit2(`${number6}${separator}`);
+          case "=": {
+            const p = emit2(`${number6}${separator}`);
+            if (p) await p;
             break;
+          }
           case "l": {
             const escapes2 = { "\x07": "\\a", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r", "	": "\\t", "\v": "\\v", "\\": "\\\\" };
             let line = "";
             for (let offset = 0; offset <= pattern.length; offset++) {
               budget.step();
-              await budget.checkpoint();
+              await budget.checkpointSync();
               const character = pattern[offset];
               const lineEnd = character === "\n" && separator === "\n";
               const token = character === void 0 || lineEnd ? "$" : escapes2[character] ?? (character.charCodeAt(0) < 32 || character.charCodeAt(0) >= 127 ? `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}` : character);
@@ -14644,7 +14906,7 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
             await emit2(instruction.text);
             break;
           case "c":
-            if (!instruction.second || ending || instruction.negate || (await peekNext()).done) await emit2(instruction.text);
+            if (!instruction.second || ending || instruction.negate || await peekNextRecord() === void 0) await emit2(instruction.text);
             deleted = true;
             pc = program.length;
             continue;
@@ -14674,11 +14936,15 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
           case "s": {
             const expression = getPattern(instruction.pattern);
             if (instruction.replacementGroupCount > expression.groupCount) throw new ProgramError("replacement references an undefined capture group");
-            const changed = await substitute(pattern, expression, instruction.replacement, budget, instruction.global ?? false, instruction.occurrence ?? 1);
+            const changedOrPromise = trySubstituteSync(pattern, expression, instruction.replacement, budget, instruction.global ?? false, instruction.occurrence ?? 1);
+            const changed = changedOrPromise instanceof Promise ? await changedOrPromise : changedOrPromise;
             pattern = changed.text;
             if (changed.count) {
               substituted = true;
-              if (instruction.print) await print();
+              if (instruction.print) {
+                const p = print();
+                if (p) await p;
+              }
               if (instruction.file) await writeFile(instruction.file);
             }
             break;
@@ -14687,7 +14953,7 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
             budget.step(pattern.length);
             const translated = import_buffer.Buffer.allocUnsafe(pattern.length);
             for (let index = 0; index < pattern.length; index++) {
-              if (index % 256 === 0) await budget.checkpoint();
+              if (index % 256 === 0) await budget.checkpointSync();
               translated[index] = (instruction.translation.get(pattern[index]) ?? pattern[index]).charCodeAt(0);
             }
             pattern = translated.toString("latin1");
@@ -14708,14 +14974,22 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
           }
           case "n":
           case "N": {
-            if (instruction.kind === "n") await flush();
-            else if (separator === "\0" && !(await peekNext()).done) await flush(false);
-            const next = await readNext();
-            if (next.done) {
-              if (instruction.kind === "N") await flush();
+            if (instruction.kind === "n") {
+              const p = flush();
+              if (p) await p;
+            } else if (separator === "\0" && await peekNextRecord() !== void 0) {
+              const p = flush(false);
+              if (p) await p;
+            }
+            const next = await readNextRecord();
+            if (next === void 0) {
+              if (instruction.kind === "N") {
+                const p = flush();
+                if (p) await p;
+              }
               return { status: 0, quit: false };
             }
-            record3 = await prepareRecord(next.value);
+            record3 = next.terminated || files.length < 2 ? next : await prepareRecord(next);
             number6++;
             pattern = instruction.kind === "N" ? joinSpace(pattern, record3.text) : record3.text;
             substituted = false;
@@ -14724,13 +14998,16 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
         }
         pc++;
       }
-      await flush();
+      const flushPending = flush();
+      if (flushPending) await flushPending;
       if (quit) return { status: status2, quit: true };
-      current = await readNext();
+      currentRecord = followingRecord === void 0 && batchSource && batchIndex < currentBatch.length ? currentBatch[batchIndex++] : await readNextRecord();
     }
     return { status: 0, quit: false };
   } finally {
-    await source2.return(void 0);
+    if (stdoutBuffer.length > 0) await flushStdout();
+    if (batchSource) await batchSource.return(void 0);
+    else if (singleSource) await singleSource.return(void 0);
   }
 }
 function sedCommand(options2 = {}) {
@@ -14881,6 +15158,25 @@ var unset = Object.freeze({ kind: "unset" });
 var numeric2 = (number6) => ({ kind: "number", number: number6 });
 var string = (text3) => ({ kind: "string", text: text3 });
 function inputValue(text3) {
+  const len = text3.length;
+  if (len === 0) return string(text3);
+  const first = text3.charCodeAt(0);
+  if (first >= 48 && first <= 57 && len <= 15) {
+    let num = first - 48;
+    let allDigits = true;
+    for (let i = 1; i < len; i++) {
+      const c = text3.charCodeAt(i);
+      if (c < 48 || c > 57) {
+        allDigits = false;
+        break;
+      }
+      num = num * 10 + (c - 48);
+    }
+    if (allDigits) return { kind: "numeric", text: text3, number: num };
+  }
+  if (first > 57 || first < 48 && first !== 32 && first !== 9 && first !== 10 && first !== 13 && first !== 43 && first !== 45 && first !== 46) {
+    return string(text3);
+  }
   return /^[ \t\r\n]*[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?[ \t\r\n]*$/u.test(text3) ? { kind: "numeric", text: text3, number: Number(text3) } : string(text3);
 }
 function scalar(value2) {
@@ -15646,6 +15942,12 @@ var AwkRetention = class {
   get retainedBytes() {
     return this.retained;
   }
+  admit(previousBytes, nextBytes) {
+    this.signal?.throwIfAborted();
+    if (!Number.isSafeInteger(previousBytes) || previousBytes < 0 || previousBytes > this.retained || !Number.isSafeInteger(nextBytes) || nextBytes < 0) throw new ProgramError("invalid retained text accounting");
+    if (nextBytes > this.capacity - this.retained + previousBytes) throw new ProgramError("awk retained text limit exceeded");
+    this.retained += nextBytes - previousBytes;
+  }
   replace(previousBytes, nextBytes, create) {
     this.signal?.throwIfAborted();
     if (!Number.isSafeInteger(previousBytes) || previousBytes < 0 || previousBytes > this.retained || !Number.isSafeInteger(nextBytes) || nextBytes < 0) throw new ProgramError("invalid retained text accounting");
@@ -15692,7 +15994,7 @@ var Reader = class {
     if (length > this.budget.maxBufferBytes - this.buffered) throw new ProgramError("text buffer limit exceeded");
     if (length === 0) return;
     const block = this.retention.replace(0, length, () => {
-      const owned = new Uint8Array(length);
+      const owned = import_buffer.Buffer.allocUnsafe(length);
       owned.set(next.value);
       return owned;
     });
@@ -15729,7 +16031,13 @@ var Reader = class {
     }
   }
   finish(length, consumed) {
-    const bytes3 = new Uint8Array(length);
+    const firstBlock = this.blocks[this.head];
+    if (length <= firstBlock.length - this.offset) {
+      const record4 = firstBlock.toString("latin1", this.offset, this.offset + length);
+      this.consume(consumed);
+      return record4;
+    }
+    const bytes3 = import_buffer.Buffer.allocUnsafe(length);
     let written = 0;
     for (let index = this.head; written < length; index++) {
       const block = this.blocks[index];
@@ -15738,7 +16046,7 @@ var Reader = class {
       bytes3.set(block.subarray(start, start + count2), written);
       written += count2;
     }
-    const record3 = import_buffer.Buffer.from(bytes3.buffer, bytes3.byteOffset, bytes3.byteLength).toString("latin1");
+    const record3 = bytes3.toString("latin1");
     this.consume(consumed);
     return record3;
   }
@@ -15775,9 +16083,34 @@ var Reader = class {
     }
     return void 0;
   }
+  readSync(separator) {
+    this.budget.context.signal.throwIfAborted();
+    if (separator.length > 1) throw new ProgramError("RS must be one byte or empty for paragraph records");
+    if (separator.length === 1 && !this.closed && this.head < this.blocks.length) {
+      const headBlock = this.blocks[this.head];
+      const idx = headBlock.indexOf(separator.charCodeAt(0), this.offset);
+      if (idx >= 0 && idx - this.offset < 4096) {
+        this.budget.step();
+        const record3 = headBlock.toString("latin1", this.offset, idx);
+        this.consume(idx - this.offset + 1);
+        return record3;
+      }
+    }
+    return this.read(separator);
+  }
   async read(separator) {
     this.budget.context.signal.throwIfAborted();
     if (separator.length > 1) throw new ProgramError("RS must be one byte or empty for paragraph records");
+    if (separator.length === 1 && !this.closed && this.head < this.blocks.length) {
+      const headBlock = this.blocks[this.head];
+      const idx = headBlock.indexOf(separator.charCodeAt(0), this.offset);
+      if (idx >= 0 && idx - this.offset < 4096) {
+        this.budget.step();
+        const record3 = headBlock.toString("latin1", this.offset, idx);
+        this.consume(idx - this.offset + 1);
+        return record3;
+      }
+    }
     if (separator === "") {
       while (!this.closed) {
         this.budget.step();
@@ -15786,7 +16119,8 @@ var Reader = class {
           if (this.ended) return void 0;
           await this.fill();
         }
-        await this.budget.checkpoint();
+        const pendingCheck = this.budget.checkpointSync();
+        if (pendingCheck) await pendingCheck;
       }
     }
     const state = { block: this.head, offset: this.offset, bytes: 0, newline: -1, paragraphEnd: -1 };
@@ -15803,7 +16137,8 @@ var Reader = class {
         }
         await this.fill();
       }
-      await this.budget.checkpoint();
+      const pendingCheck = this.budget.checkpointSync();
+      if (pendingCheck) await pendingCheck;
     }
   }
   close() {
@@ -15826,7 +16161,7 @@ function textSize(value2) {
   return value2 && !(value2 instanceof AwkArray) && (value2.kind === "string" || value2.kind === "numeric") ? value2.text.length : 0;
 }
 function ownScalar(value2) {
-  return value2.kind === "string" || value2.kind === "numeric" ? { ...value2, text: import_buffer.Buffer.from(value2.text, "latin1").toString("latin1") } : value2;
+  return value2.kind === "string" || value2.kind === "numeric" ? { ...value2, text: value2.text.length < 13 ? value2.text : import_buffer.Buffer.from(value2.text, "latin1").toString("latin1") } : value2;
 }
 var Flow = class {
   constructor(kind, value2 = unset) {
@@ -15896,6 +16231,8 @@ var AwkRuntime = class {
     return scalar(this.get(name2));
   }
   asText(value2) {
+    if (value2.kind === "string" || value2.kind === "numeric") return value2.text;
+    if (value2.kind === "unset") return "";
     return text(value2, text(this.getScalar("CONVFMT"), void 0, this.budget), this.budget);
   }
   varText(name2) {
@@ -15907,8 +16244,8 @@ var AwkRuntime = class {
   }
   storeScalar(store, name2, value2) {
     if (value2.kind === "string" || value2.kind === "numeric") this.budget.check(value2.text);
-    const owned = this.retention.replace(textSize(store.get(name2)), textSize(value2), () => ownScalar(value2));
-    store.set(name2, owned);
+    this.retention.admit(textSize(store.get(name2)), textSize(value2));
+    store.set(name2, ownScalar(value2));
   }
   bindArray(store, name2, array) {
     let allocation = this.arrays.get(array);
@@ -15955,14 +16292,13 @@ var AwkRuntime = class {
   arraySet(array, key, value2) {
     this.budget.check(key);
     if (value2.kind === "string" || value2.kind === "numeric") this.budget.check(value2.text);
-    const existing2 = array.entries.has(key);
+    const existingValue = array.entries.get(key);
+    const existing2 = existingValue !== void 0 || array.entries.has(key);
     if (!existing2 && this.entries >= (this.budget.options.maxArrayEntries ?? Infinity)) throw new ProgramError("array entry limit exceeded");
-    const previous = textSize(array.entries.get(key)), next = textSize(value2) + (existing2 ? 0 : key.length);
-    const owned = this.retention.replace(previous, next, () => ({
-      key: existing2 ? key : import_buffer.Buffer.from(key, "latin1").toString("latin1"),
-      value: ownScalar(value2)
-    }));
-    array.entries.set(owned.key, owned.value);
+    const previous = textSize(existingValue), next = textSize(value2) + (existing2 ? 0 : key.length);
+    this.retention.admit(previous, next);
+    const ownedKey = existing2 || key.length < 13 ? key : import_buffer.Buffer.from(key, "latin1").toString("latin1");
+    array.entries.set(ownedKey, ownScalar(value2));
     this.arrays.get(array).bytes += next - previous;
     if (!existing2) this.entries++;
   }
@@ -15978,6 +16314,44 @@ var AwkRuntime = class {
   async regex(expression) {
     return expression.kind === "regex" ? expression.pattern : this.pattern(this.asText(await this.scalarExpression(expression)));
   }
+  splitSync(value2, separator, paragraph) {
+    if (!paragraph && value2.length < 256 && (separator === " " || separator.length === 1)) {
+      this.budget.step(value2.length);
+      const maxFields = this.budget.options.maxFields ?? Infinity;
+      const parts = [];
+      if (separator === " ") {
+        let start = -1;
+        for (let index = 0; index < value2.length; index++) {
+          const ch = value2.charCodeAt(index);
+          if (ch === 32 || ch === 9 || ch === 10) {
+            if (start >= 0) {
+              if (parts.length >= maxFields) throw new ProgramError("field count limit exceeded");
+              parts.push(inputValue(value2.slice(start, index)));
+              start = -1;
+            }
+          } else if (start < 0) start = index;
+        }
+        if (start >= 0) {
+          if (parts.length >= maxFields) throw new ProgramError("field count limit exceeded");
+          parts.push(inputValue(value2.slice(start, value2.length)));
+        }
+        return parts;
+      }
+      if (value2 !== "") {
+        let start = 0;
+        let idx;
+        while ((idx = value2.indexOf(separator, start)) >= 0) {
+          if (parts.length >= maxFields) throw new ProgramError("field count limit exceeded");
+          parts.push(inputValue(value2.slice(start, idx)));
+          start = idx + 1;
+        }
+        if (parts.length >= maxFields) throw new ProgramError("field count limit exceeded");
+        parts.push(inputValue(value2.slice(start, value2.length)));
+      }
+      return parts;
+    }
+    return this.split(value2, separator, paragraph);
+  }
   async split(value2, separator, paragraph = false) {
     this.budget.step(value2.length);
     const parts = [];
@@ -15988,7 +16362,7 @@ var AwkRuntime = class {
     if (separator === " ") {
       let start = -1;
       for (let index = 0; index < value2.length; index++) {
-        if (index % 256 === 0) await this.budget.checkpoint();
+        if (index % 256 === 0) await this.budget.checkpointSync();
         if (" 	\n".includes(value2[index])) {
           if (start >= 0) {
             append(start, index);
@@ -16000,13 +16374,28 @@ var AwkRuntime = class {
     } else if (separator === "") {
       if (value2.length > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("field count limit exceeded");
       for (let index = 0; index < value2.length; index++) {
-        if (index % 256 === 0) await this.budget.checkpoint();
+        if (index % 256 === 0) await this.budget.checkpointSync();
         append(index, index + 1);
       }
     } else if (typeof separator === "string" && separator.length === 1) {
+      if (!paragraph && value2.length < 256) {
+        if (value2 !== "") {
+          let start2 = 0;
+          let idx;
+          while ((idx = value2.indexOf(separator, start2)) >= 0) {
+            append(start2, idx);
+            start2 = idx + 1;
+          }
+          append(start2, value2.length);
+        }
+        return parts;
+      }
       let start = 0;
       for (let index = 0; index < value2.length; index++) {
-        if (index % 256 === 0) await this.budget.checkpoint();
+        if (index > 0 && index % 256 === 0) {
+          const p = this.budget.checkpointSync();
+          if (p) await p;
+        }
         if (value2[index] === separator || paragraph && value2[index] === "\n") {
           append(start, index);
           start = index + 1;
@@ -16017,7 +16406,7 @@ var AwkRuntime = class {
       const matcher = typeof separator === "string" ? this.pattern(separator) : separator;
       const segment2 = async (start, end) => {
         if (paragraph) for (let index = start; index < end; index++) {
-          if (index % 256 === 0) await this.budget.checkpoint();
+          if (index % 256 === 0) await this.budget.checkpointSync();
           if (value2[index] === "\n") {
             append(start, index);
             start = index + 1;
@@ -16028,7 +16417,7 @@ var AwkRuntime = class {
       let consumed = 0;
       let search = 0;
       while (search <= value2.length) {
-        await this.budget.checkpoint();
+        await this.budget.checkpointSync();
         const match = await matcher.find(value2, this.budget, search);
         if (!match) break;
         if (match.start === match.end) {
@@ -16043,10 +16432,19 @@ var AwkRuntime = class {
     }
     return parts;
   }
-  async setRecord(record3, value2 = inputValue(record3)) {
+  setRecordSync(record3, value2 = inputValue(record3)) {
     this.budget.check(record3);
-    const fields4 = await this.split(record3, this.varText("FS"), this.varText("RS") === "");
-    this.replaceRecord(record3, fields4, value2);
+    const fields4 = this.splitSync(record3, this.varText("FS"), this.varText("RS") === "");
+    if (!(fields4 instanceof Promise)) {
+      this.replaceRecord(record3, fields4, value2);
+      return;
+    }
+    return fields4.then((resolved) => {
+      this.replaceRecord(record3, resolved, value2);
+    });
+  }
+  async setRecord(record3, value2 = inputValue(record3)) {
+    await this.setRecordSync(record3, value2);
   }
   replaceRecord(record3, fields4, value2 = string(record3)) {
     let fieldBytes = 0;
@@ -16054,12 +16452,9 @@ var AwkRuntime = class {
       if (field2.kind === "string" || field2.kind === "numeric") this.budget.check(field2.text);
       fieldBytes += textSize(field2);
     }
-    const owned = this.retention.replace(this.record.length + this.fieldBytes, record3.length + fieldBytes, () => ({
-      record: import_buffer.Buffer.from(record3, "latin1").toString("latin1"),
-      fields: fields4.map((field2, index) => field2 === this.fields[index] ? field2 : ownScalar(field2))
-    }));
-    this.record = owned.record;
-    this.fields = owned.fields;
+    this.retention.admit(this.record.length + this.fieldBytes, record3.length + fieldBytes);
+    this.record = record3;
+    this.fields = fields4;
     this.fieldBytes = fieldBytes;
     this.recordValue = value2.kind === "string" || value2.kind === "numeric" ? { ...value2, text: this.record } : value2;
     this.variables.set("NF", numeric2(fields4.length));
@@ -16084,7 +16479,20 @@ var AwkRuntime = class {
     const record3 = this.join(fields4.map((value2) => this.asText(value2)), this.varText("OFS"));
     this.replaceRecord(record3, fields4);
   }
-  async key(items) {
+  key(items) {
+    if (items.length === 1) {
+      const first = this.scalarExpression(items[0]);
+      if (!(first instanceof Promise)) {
+        const k = this.asText(first);
+        this.budget.step(2);
+        if (k.length > this.budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+        this.budget.step(k.length);
+        return k;
+      }
+    }
+    return this.keySlow(items);
+  }
+  async keySlow(items) {
     const pieces = [];
     for (const item of items) pieces.push(this.asText(await this.scalarExpression(item)));
     return this.join(pieces, this.varText("SUBSEP"));
@@ -16121,10 +16529,11 @@ var AwkRuntime = class {
     if (!Number.isFinite(result)) throw new ProgramError("non-finite arithmetic result");
     return result;
   }
-  async scalarExpression(expression) {
-    return scalar(await this.evaluate(expression));
+  scalarExpression(expression) {
+    const val = this.evaluate(expression);
+    return val instanceof Promise ? val.then(scalar) : scalar(val);
   }
-  async evaluate(expression) {
+  evaluate(expression) {
     this.budget.step();
     switch (expression.kind) {
       case "number":
@@ -16132,71 +16541,220 @@ var AwkRuntime = class {
       case "string":
         return string(expression.value);
       case "regex":
-        return numeric2(await expression.pattern.find(this.record, this.budget) ? 1 : 0);
+        return expression.pattern.find(this.record, this.budget).then((m) => numeric2(m ? 1 : 0));
       case "variable":
         return this.get(expression.name);
-      case "field":
-      case "array":
-        return (await this.reference(expression)).get();
+      case "field": {
+        const idxVal = this.scalarExpression(expression.index);
+        if (!(idxVal instanceof Promise)) {
+          const index = Math.trunc(number(idxVal));
+          if (!Number.isSafeInteger(index) || index < 0 || index > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("invalid or excessive field index");
+          return index === 0 ? this.recordValue : this.fields[index - 1] ?? unset;
+        }
+        return idxVal.then((resolved) => {
+          const index = Math.trunc(number(resolved));
+          if (!Number.isSafeInteger(index) || index < 0 || index > (this.budget.options.maxFields ?? Infinity)) throw new ProgramError("invalid or excessive field index");
+          return index === 0 ? this.recordValue : this.fields[index - 1] ?? unset;
+        });
+      }
+      case "array": {
+        const array = this.array(expression.name);
+        const k = this.key(expression.indexes);
+        if (!(k instanceof Promise)) {
+          let existing2 = array.entries.get(k);
+          if (existing2 === void 0 && !array.entries.has(k)) {
+            this.arraySet(array, k, unset);
+            existing2 = unset;
+          }
+          return existing2;
+        }
+        return k.then((resolvedKey) => {
+          let existing2 = array.entries.get(resolvedKey);
+          if (existing2 === void 0 && !array.entries.has(resolvedKey)) {
+            this.arraySet(array, resolvedKey, unset);
+            existing2 = unset;
+          }
+          return existing2;
+        });
+      }
       case "getline":
         return this.getline(expression);
       case "tuple":
         throw new ProgramError("tuple is only valid as an array membership key");
-      case "conditional":
-        return this.evaluate(truth(await this.scalarExpression(expression.condition)) ? expression.yes : expression.no);
+      case "conditional": {
+        const cond = this.scalarExpression(expression.condition);
+        return cond instanceof Promise ? cond.then((c) => this.evaluate(truth(c) ? expression.yes : expression.no)) : this.evaluate(truth(cond) ? expression.yes : expression.no);
+      }
       case "unary": {
         if (expression.operator === "++" || expression.operator === "--") {
-          const reference = await this.reference(expression.operand);
-          const previous = number(scalar(reference.get()));
-          const next = previous + (expression.operator === "++" ? 1 : -1);
-          await reference.set(numeric2(next));
-          return numeric2(expression.postfix ? previous : next);
+          if (expression.operand.kind === "variable") {
+            const name2 = expression.operand.name;
+            const previous = number(scalar(this.get(name2)));
+            const next = previous + (expression.operator === "++" ? 1 : -1);
+            this.set(name2, numeric2(next));
+            return numeric2(expression.postfix ? previous : next);
+          }
+          if (expression.operand.kind === "array") {
+            const array = this.array(expression.operand.name);
+            const k = this.key(expression.operand.indexes);
+            if (!(k instanceof Promise)) {
+              let current = array.entries.get(k);
+              if (current === void 0 && !array.entries.has(k)) {
+                this.arraySet(array, k, unset);
+                current = unset;
+              }
+              const previous = number(scalar(current));
+              const next = previous + (expression.operator === "++" ? 1 : -1);
+              this.arraySet(array, k, numeric2(next));
+              return numeric2(expression.postfix ? previous : next);
+            }
+            return k.then((resolvedKey) => {
+              let current = array.entries.get(resolvedKey);
+              if (current === void 0 && !array.entries.has(resolvedKey)) {
+                this.arraySet(array, resolvedKey, unset);
+                current = unset;
+              }
+              const previous = number(scalar(current));
+              const next = previous + (expression.operator === "++" ? 1 : -1);
+              this.arraySet(array, resolvedKey, numeric2(next));
+              return numeric2(expression.postfix ? previous : next);
+            });
+          }
+          return this.evaluateUnarySlow(expression);
+        }
+        const operand = this.scalarExpression(expression.operand);
+        if (!(operand instanceof Promise)) {
+          return numeric2(expression.operator === "!" ? truth(operand) ? 0 : 1 : expression.operator === "-" ? -number(operand) : number(operand));
         }
-        const operand = await this.scalarExpression(expression.operand);
-        return numeric2(expression.operator === "!" ? truth(operand) ? 0 : 1 : expression.operator === "-" ? -number(operand) : number(operand));
+        return operand.then((op) => numeric2(expression.operator === "!" ? truth(op) ? 0 : 1 : expression.operator === "-" ? -number(op) : number(op)));
       }
       case "binary": {
         const operator = expression.operator;
-        if (["=", "+=", "-=", "*=", "/=", "%=", "^="].includes(operator)) {
-          const reference = await this.reference(expression.left);
-          const previous = operator === "=" ? unset : scalar(reference.get());
-          let value2 = await this.scalarExpression(expression.right);
-          if (operator !== "=") value2 = numeric2(this.arithmetic(operator[0], number(previous), number(value2)));
-          await reference.set(value2);
-          return value2;
-        }
-        if (operator === "in") {
-          const array = this.array(expression.right.name);
-          const key = expression.left.kind === "tuple" ? await this.key(expression.left.items) : this.asText(await this.scalarExpression(expression.left));
-          return numeric2(array.entries.has(key) ? 1 : 0);
-        }
-        const left = await this.scalarExpression(expression.left);
+        if (operator === "=" || operator === "+=" || operator === "-=" || operator === "*=" || operator === "/=" || operator === "%=" || operator === "^=") {
+          if (expression.left.kind === "variable") {
+            const name2 = expression.left.name;
+            const previous = operator === "=" ? unset : scalar(this.get(name2));
+            const rightVal = this.scalarExpression(expression.right);
+            if (!(rightVal instanceof Promise)) {
+              const value2 = operator === "=" ? rightVal : numeric2(this.arithmetic(operator[0], number(previous), number(rightVal)));
+              this.set(name2, value2);
+              return value2;
+            }
+            return rightVal.then((resolved) => {
+              const value2 = operator === "=" ? resolved : numeric2(this.arithmetic(operator[0], number(previous), number(resolved)));
+              this.set(name2, value2);
+              return value2;
+            });
+          } else if (expression.left.kind === "array") {
+            const array = this.array(expression.left.name);
+            const k = this.key(expression.left.indexes);
+            if (!(k instanceof Promise)) {
+              let current = operator === "=" ? unset : array.entries.get(k);
+              if (operator !== "=" && current === void 0 && !array.entries.has(k)) {
+                this.arraySet(array, k, unset);
+                current = unset;
+              }
+              const previous = scalar(current);
+              const rightVal = this.scalarExpression(expression.right);
+              if (!(rightVal instanceof Promise)) {
+                const value2 = operator === "=" ? rightVal : numeric2(this.arithmetic(operator[0], number(previous), number(rightVal)));
+                this.arraySet(array, k, value2);
+                return value2;
+              }
+              return rightVal.then((resolved) => {
+                const value2 = operator === "=" ? resolved : numeric2(this.arithmetic(operator[0], number(previous), number(resolved)));
+                this.arraySet(array, k, value2);
+                return value2;
+              });
+            }
+            return k.then(async (resolvedKey) => {
+              let current = operator === "=" ? unset : array.entries.get(resolvedKey);
+              if (operator !== "=" && current === void 0 && !array.entries.has(resolvedKey)) {
+                this.arraySet(array, resolvedKey, unset);
+                current = unset;
+              }
+              const previous = scalar(current);
+              const resolved = await this.scalarExpression(expression.right);
+              const value2 = operator === "=" ? resolved : numeric2(this.arithmetic(operator[0], number(previous), number(resolved)));
+              this.arraySet(array, resolvedKey, value2);
+              return value2;
+            });
+          }
+          return this.evaluateBinarySlow(expression);
+        }
+        if (operator === "in" || operator === "~" || operator === "!~") {
+          return this.evaluateBinarySlow(expression);
+        }
+        const left = this.scalarExpression(expression.left);
+        if (left instanceof Promise) return this.evaluateBinaryWithLeftPromise(expression, left);
         if (operator === "&&" && !truth(left)) return numeric2(0);
         if (operator === "||" && truth(left)) return numeric2(1);
-        if (operator === "~" || operator === "!~") {
-          const matched = await (await this.regex(expression.right)).find(this.asText(left), this.budget) !== void 0;
-          return numeric2((operator === "~" ? matched : !matched) ? 1 : 0);
-        }
-        const right = await this.scalarExpression(expression.right);
-        if (operator === "&&" || operator === "||") return numeric2(truth(right) ? 1 : 0);
-        if (operator === "concat") {
-          const leftText = this.asText(left);
-          const rightText = this.asText(right);
-          this.budget.step(0);
-          if (rightText.length > this.budget.maxBufferBytes - leftText.length) throw new ProgramError("text buffer limit exceeded");
-          this.budget.step(leftText.length + rightText.length);
-          return string(leftText + rightText);
-        }
-        if (["==", "!=", "<", "<=", ">", ">="].includes(operator)) {
-          const order = compare3(left, right, this.varText("CONVFMT"), this.budget);
-          return numeric2((operator === "==" ? order === 0 : operator === "!=" ? order !== 0 : operator === "<" ? order < 0 : operator === "<=" ? order <= 0 : operator === ">" ? order > 0 : order >= 0) ? 1 : 0);
-        }
-        return numeric2(this.arithmetic(operator, number(left), number(right)));
+        const right = this.scalarExpression(expression.right);
+        if (right instanceof Promise) return right.then((r) => this.evaluateBinarySyncOperands(operator, left, r));
+        return this.evaluateBinarySyncOperands(operator, left, right);
       }
       case "call":
         return this.call(expression.name, expression.args);
     }
   }
+  evaluateBinarySyncOperands(operator, left, right) {
+    if (operator === "&&" || operator === "||") return numeric2(truth(right) ? 1 : 0);
+    if (operator === "concat") {
+      const leftText = this.asText(left);
+      const rightText = this.asText(right);
+      this.budget.step(0);
+      if (rightText.length > this.budget.maxBufferBytes - leftText.length) throw new ProgramError("text buffer limit exceeded");
+      this.budget.step(leftText.length + rightText.length);
+      return string(leftText + rightText);
+    }
+    if (operator === "==" || operator === "!=" || operator === "<" || operator === "<=" || operator === ">" || operator === ">=") {
+      const order = compare3(left, right, this.varText("CONVFMT"), this.budget);
+      return numeric2((operator === "==" ? order === 0 : operator === "!=" ? order !== 0 : operator === "<" ? order < 0 : operator === "<=" ? order <= 0 : operator === ">" ? order > 0 : order >= 0) ? 1 : 0);
+    }
+    return numeric2(this.arithmetic(operator, number(left), number(right)));
+  }
+  async evaluateBinaryWithLeftPromise(expression, leftPromise) {
+    const operator = expression.operator;
+    const left = await leftPromise;
+    if (operator === "&&" && !truth(left)) return numeric2(0);
+    if (operator === "||" && truth(left)) return numeric2(1);
+    const right = await this.scalarExpression(expression.right);
+    return this.evaluateBinarySyncOperands(operator, left, right);
+  }
+  async evaluateUnarySlow(expression) {
+    if (expression.operator === "++" || expression.operator === "--") {
+      const reference = await this.reference(expression.operand);
+      const previous = number(scalar(reference.get()));
+      const next = previous + (expression.operator === "++" ? 1 : -1);
+      await reference.set(numeric2(next));
+      return numeric2(expression.postfix ? previous : next);
+    }
+    const operand = await this.scalarExpression(expression.operand);
+    return numeric2(expression.operator === "!" ? truth(operand) ? 0 : 1 : expression.operator === "-" ? -number(operand) : number(operand));
+  }
+  async evaluateBinarySlow(expression) {
+    const operator = expression.operator;
+    if (["=", "+=", "-=", "*=", "/=", "%=", "^="].includes(operator)) {
+      const reference = await this.reference(expression.left);
+      const previous = operator === "=" ? unset : scalar(reference.get());
+      let value2 = await this.scalarExpression(expression.right);
+      if (operator !== "=") value2 = numeric2(this.arithmetic(operator[0], number(previous), number(value2)));
+      await reference.set(value2);
+      return value2;
+    }
+    if (operator === "in") {
+      const array = this.array(expression.right.name);
+      const key = expression.left.kind === "tuple" ? await this.key(expression.left.items) : this.asText(await this.scalarExpression(expression.left));
+      return numeric2(array.entries.has(key) ? 1 : 0);
+    }
+    const left = await this.scalarExpression(expression.left);
+    if (operator === "~" || operator === "!~") {
+      const matched = await (await this.regex(expression.right)).find(this.asText(left), this.budget) !== void 0;
+      return numeric2((operator === "~" ? matched : !matched) ? 1 : 0);
+    }
+    const right = await this.scalarExpression(expression.right);
+    return this.evaluateBinarySyncOperands(operator, left, right);
+  }
   async getline(expression) {
     if (!expression.file) {
       const record4 = await this.readMainRecord();
@@ -16227,7 +16785,7 @@ var AwkRuntime = class {
         if (useStdin) yield* context2.stdin;
         else {
           budget.step();
-          await budget.checkpoint();
+          await budget.checkpointSync();
           const capabilities = await context2.fs.capabilitiesFor?.(name2, { signal: context2.signal }) ?? context2.fs.capabilities;
           context2.signal.throwIfAborted();
           if (context2.fs.readStream && capabilities.streamingRead !== false) yield* context2.fs.readStream(name2, { signal: context2.signal });
@@ -16377,10 +16935,49 @@ var AwkRuntime = class {
     if (!Number.isFinite(result)) throw new ProgramError(`invalid mathematical result in '${name2}'`);
     return numeric2(result);
   }
+  executeSync(statement) {
+    if (!this.inspection) {
+      const p = this.budget.checkpointSync();
+      if (!p) {
+        if (statement.kind === "expression") {
+          this.budget.step();
+          const val = this.evaluate(statement.expression);
+          return val instanceof Promise ? val.then(() => void 0) : void 0;
+        }
+        if (statement.kind === "block") {
+          this.budget.step();
+          for (let i = 0; i < statement.body.length; i++) {
+            const res = this.executeSync(statement.body[i]);
+            if (res instanceof Promise) {
+              return this.executeBlockRemainder(statement.body, i + 1, res);
+            }
+          }
+          return void 0;
+        }
+        if (statement.kind === "if") {
+          this.budget.step();
+          const cond = this.scalarExpression(statement.condition);
+          if (!(cond instanceof Promise)) {
+            const branch = truth(cond) ? statement.yes : statement.no;
+            return branch ? this.executeSync(branch) : void 0;
+          }
+        }
+      }
+    }
+    return this.execute(statement);
+  }
+  async executeBlockRemainder(body, startIndex2, current) {
+    await current;
+    for (let i = startIndex2; i < body.length; i++) {
+      const res = this.executeSync(body[i]);
+      if (res instanceof Promise) await res;
+    }
+  }
   async execute(statement) {
     this.budget.step();
     if (this.inspection) await this.inspection.observe(statement, this.phase);
-    await this.budget.checkpoint();
+    const p = this.budget.checkpointSync();
+    if (p) await p;
     switch (statement.kind) {
       case "block":
         for (const child of statement.body) await this.execute(child);
@@ -16521,6 +17118,47 @@ var AwkRuntime = class {
     return status2;
   }
   async readMainRecord() {
+    const syncRes = this.readMainRecordSync();
+    return syncRes instanceof Promise ? await syncRes : syncRes;
+  }
+  incrementCounter(name2) {
+    const current = this.variables.get(name2);
+    if (current && !(current instanceof AwkArray) && current.kind === "number" && !this.frames.at(-1)?.has(name2)) {
+      this.retention.admit(0, 0);
+      this.variables.set(name2, numeric2(current.number + 1));
+      return;
+    }
+    this.set(name2, numeric2(number(this.getScalar(name2)) + 1));
+  }
+  readMainRecordSync() {
+    if (this.mainReader) {
+      this.budget.step();
+      const record3 = this.mainReader.readSync(this.varText("RS"));
+      if (typeof record3 === "string") {
+        this.incrementCounter("NR");
+        this.incrementCounter("FNR");
+        return record3;
+      }
+      if (record3 instanceof Promise) {
+        return record3.then((resolved) => {
+          if (resolved !== void 0) {
+            this.incrementCounter("NR");
+            this.incrementCounter("FNR");
+            return resolved;
+          }
+          return this.readMainRecordSlowAfterEof();
+        });
+      }
+      return this.readMainRecordSlowAfterEof();
+    }
+    return this.readMainRecordSlow();
+  }
+  async readMainRecordSlowAfterEof() {
+    await this.mainReader?.close();
+    this.mainReader = void 0;
+    return this.readMainRecordSlow();
+  }
+  async readMainRecordSlow() {
     while (true) {
       this.budget.step();
       if (!this.mainReader) {
@@ -16529,7 +17167,8 @@ var AwkRuntime = class {
           this.budget.step();
           const argumentOptions = this.budget.options;
           if (this.argument > (argumentOptions?.maxArguments ?? Infinity)) throw new ProgramError("argument count limit exceeded");
-          await this.budget.checkpoint();
+          const p = this.budget.checkpointSync();
+          if (p) await p;
           const next = this.asText(this.array("ARGV").entries.get(String(this.argument++)) ?? unset);
           if (!next) continue;
           if (this.operandAssignments && /^[A-Za-z_][A-Za-z0-9_]*=/u.test(next)) {
@@ -16555,8 +17194,8 @@ var AwkRuntime = class {
         this.mainReader = void 0;
         continue;
       }
-      this.set("NR", numeric2(number(this.getScalar("NR")) + 1));
-      this.set("FNR", numeric2(number(this.getScalar("FNR")) + 1));
+      this.incrementCounter("NR");
+      this.incrementCounter("FNR");
       return record3;
     }
   }
@@ -16574,19 +17213,27 @@ var AwkRuntime = class {
     const ranges2 = /* @__PURE__ */ new Set();
     if (!stopped && (this.program.rules.length || this.program.end.length)) while (true) {
       this.budget.step();
-      const record3 = await this.readMainRecord();
+      const recOrPromise = this.readMainRecordSync();
+      const record3 = recOrPromise instanceof Promise ? await recOrPromise : recOrPromise;
       if (record3 === void 0) break;
-      await this.setRecord(record3);
+      const setRecPromise = this.setRecordSync(record3);
+      if (setRecPromise instanceof Promise) await setRecPromise;
       try {
         for (let index = 0; index < this.program.rules.length; index++) {
           const rule = this.program.rules[index];
-          const selected2 = !rule.pattern || ranges2.has(index) || truth(await this.scalarExpression(rule.pattern));
+          let selected2 = !rule.pattern || ranges2.has(index);
+          if (!selected2) {
+            const patVal = this.scalarExpression(rule.pattern);
+            selected2 = truth(patVal instanceof Promise ? await patVal : patVal);
+          }
           if (!selected2) continue;
           if (rule.end) {
-            if (truth(await this.scalarExpression(rule.end))) ranges2.delete(index);
+            const endVal = this.scalarExpression(rule.end);
+            if (truth(endVal instanceof Promise ? await endVal : endVal)) ranges2.delete(index);
             else ranges2.add(index);
           }
-          await this.execute(rule.action);
+          const execRes = this.executeSync(rule.action);
+          if (execRes instanceof Promise) await execRes;
         }
       } catch (error) {
         if (!(error instanceof Flow)) throw error;
@@ -17666,6 +18313,7 @@ var Matcher = class {
   session;
   descriptor;
   async batch(rows2) {
+    trustedInputRows.add(rows2);
     try {
       return await this.session.run(this.descriptor, rows2);
     } catch (error) {
@@ -17716,7 +18364,8 @@ var Limits = class {
   signal;
   tick() {
     this.context.signal.throwIfAborted();
-    if (++this.ticks % 128 === 0) return yieldTurn(this.context.signal);
+    const interval = hasYieldCheckpoint(this.context.signal) ? 128 : 2048;
+    if (++this.ticks % interval === 0) return yieldTurn(this.context.signal);
     return void 0;
   }
   async write(chunk) {
@@ -17766,8 +18415,14 @@ async function* lineBatches(source2, limits, state, binary3, nullData, maxRecord
       return;
     }
     let start = 0;
-    for (let end = 0; end < chunk.length; end++) {
-      if (chunk[end] !== delimiter && chunk[end] !== extraDelimiter) continue;
+    let next = extraDelimiter === -1 ? chunk.indexOf(delimiter, 0) : (() => {
+      for (let scan = 0; scan < chunk.length; scan++) {
+        if (chunk[scan] === delimiter || chunk[scan] === extraDelimiter) return scan;
+      }
+      return -1;
+    })();
+    while (next >= 0) {
+      const end = next;
       if (pending.length + end - start > limits.maxLineBytes) throw new SearchError("line byte limit exceeded");
       let content;
       let bytes3;
@@ -17784,13 +18439,12 @@ async function* lineBatches(source2, limits, state, binary3, nullData, maxRecord
       offset += bytes3.length;
       pending = emptyBuffer;
       start = end + 1;
-      let next = -1;
-      for (let scan = start; scan < chunk.length; scan++) {
-        if (chunk[scan] === delimiter || chunk[scan] === extraDelimiter) {
-          next = scan;
-          break;
+      next = extraDelimiter === -1 ? chunk.indexOf(delimiter, start) : (() => {
+        for (let scan = start; scan < chunk.length; scan++) {
+          if (chunk[scan] === delimiter || chunk[scan] === extraDelimiter) return scan;
         }
-      }
+        return -1;
+      })();
       if (batch.length >= maxRecords() || batchBytes >= 64 * 1024 || next < 0 || batchBytes + next - start > 64 * 1024 || next - start > limits.maxLineBytes) {
         yield batch;
         batch = [];
@@ -18561,6 +19215,54 @@ async function* grepFiles(context2, parsed, filters, report2) {
 }
 
 // packages/safe-bash/src/commands/search/grep.ts
+async function* grepLineBatches(source2, separator, maxLineBytes, maxRecords) {
+  const pending = new RecordBuffer(bufferLimit);
+  let batch = [];
+  let bytes3 = 0;
+  try {
+    for await (const rawChunk of source2) {
+      const chunk = Uint8Array.from(rawChunk);
+      let start = 0;
+      while (start < chunk.length) {
+        const end = chunk.indexOf(separator, start);
+        if (end < 0) break;
+        let line;
+        if (pending.size === 0) {
+          const tailLength = end - start;
+          if (tailLength > bufferLimit) {
+            throw new contracts_exports.FsError("EFBIG", { message: "line buffer limit exceeded" });
+          }
+          line = {
+            bytes: chunk.subarray(start, end),
+            raw: chunk.subarray(start, end + 1),
+            terminated: true
+          };
+        } else {
+          line = {
+            bytes: pending.finish(void 0, chunk, start, end),
+            terminated: true
+          };
+        }
+        start = end + 1;
+        batch.push(line);
+        bytes3 += line.bytes.length;
+        const next = chunk.indexOf(separator, start);
+        if (batch.length >= maxRecords() || bytes3 >= 64 * 1024 || next < 0 || bytes3 + next - start > 64 * 1024 || next - start > maxLineBytes) {
+          yield batch;
+          batch = [];
+          bytes3 = 0;
+        }
+      }
+      pending.append(chunk, start);
+    }
+    if (pending.size) {
+      batch.push({ bytes: pending.finish(), terminated: false });
+    }
+    if (batch.length) yield batch;
+  } finally {
+    pending.clear();
+  }
+}
 function createGrepCommands(executor, limits = {}) {
   for (const value2 of Object.values(limits)) {
     if (!Number.isSafeInteger(value2) || value2 < 1) throw new RangeError("grep limits must be positive safe integers");
@@ -18714,6 +19416,31 @@ inspect the resulting state before repeating the action.
       const maxCount = value(parsed, "m") === void 0 ? Infinity : integer(value(parsed, "m"));
       const batchSize = Number.isFinite(maxCount) || parsed.flags.has("q") || parsed.flags.has("l") || parsed.flags.has("L") ? 1 : 128;
       const delimiter = parsed.flags.has("z") ? "\0" : "\n";
+      const delimiterBytes = encoder.encode(delimiter);
+      const lineBuffered = parsed.flags.has("line-buffered");
+      let outBuffer;
+      let outUsed = 0;
+      const flushOut = async () => {
+        if (!outBuffer || outUsed === 0) return;
+        const view = outBuffer.subarray(0, outUsed);
+        outUsed = 0;
+        await output(context2, view);
+      };
+      const writeOut = async (chunk) => {
+        const bytes3 = typeof chunk === "string" ? chunk.length === 0 ? void 0 : encoder.encode(chunk) : chunk.length === 0 ? void 0 : chunk;
+        if (!bytes3) return;
+        if (lineBuffered || bytes3.length > 64 * 1024) {
+          await flushOut();
+          await output(context2, bytes3);
+          return;
+        }
+        outBuffer ??= new Uint8Array(64 * 1024);
+        if (outUsed + bytes3.length > outBuffer.length) {
+          await flushOut();
+        }
+        outBuffer.set(bytes3, outUsed);
+        outUsed += bytes3.length;
+      };
       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 = [...contextLengths.values()].some((length) => length > 0) && displayLines && !(parsed.flags.has("o") && parsed.flags.has("v"));
@@ -18737,17 +19464,18 @@ inspect the resulting state before repeating the action.
         const prefix3 = (lineNumber = false, position = number6, separator = ":", offset = byteOffset) => `${!parsed.flags.has("h") && (parsed.flags.has("H") || multipleFiles || nested) ? `${named2}${parsed.flags.has("Z") ? "\0" : separator}` : ""}${lineNumber && parsed.flags.has("n") ? `${position}${separator}` : ""}${lineNumber && parsed.flags.has("b") ? `${offset}${separator}` : ""}${lineNumber && parsed.flags.has("initial-tab") && (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 output(context2, prefix3(true, position, "-", offset));
-            await output(context2, line.bytes);
-            await output(context2, delimiter);
+            await writeOut(prefix3(true, position, "-", offset));
+            await writeOut(line.bytes);
+            await writeOut(delimiterBytes);
           }
           lastCovered = position;
         };
         try {
-          const available2 = new AvailableRecords(parsed.flags.has("z") ? 0 : 10, limits.maxLineBytes ?? Infinity);
           const source2 = name2 === "-" ? input(context2) : requiredFileInput(context2, grepRequirements, "file", name2, limits.maxFileBytes ?? Infinity);
-          records: if (maxCount > 0) for await (const batch of available2.batches(lines(available2.source(source2), parsed.flags.has("z") ? 0 : 10), (line) => line.bytes.length, () => batchSize)) {
-            const results = await session.run(descriptor, batch.map((line) => ({ bytes: line.bytes, all: extractMatches, terminated: line.terminated })));
+          records: if (maxCount > 0) for await (const batch of grepLineBatches(source2, parsed.flags.has("z") ? 0 : 10, limits.maxLineBytes ?? Infinity, () => batchSize)) {
+            const rows2 = batch.map((line) => ({ bytes: line.bytes, all: extractMatches, terminated: line.terminated }));
+            trustedInputRows.add(rows2);
+            const results = await session.run(descriptor, rows2);
             for (let index = 0; index < batch.length; index++) {
               const line = batch[index];
               context2.signal.throwIfAborted();
@@ -18781,7 +19509,7 @@ inspect the resulting state before repeating the action.
               if (!parsed.flags.has("c")) {
                 if (withContext) {
                   const first = pending.keys().next().value ?? number6;
-                  if (!parsed.flags.has("no-group-separator") && emittedGroup && (lastCovered === 0 || first > lastCovered + 1)) await output(context2, (value(parsed, "group-separator") ?? "--") + delimiter);
+                  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;
@@ -18794,26 +19522,32 @@ inspect the resulting state before repeating the action.
                     let end = -1;
                     for (const match of found) {
                       if (match.start === match.end || match.start < end) continue;
-                      await output(context2, prefix3(true, number6, ":", byteOffset + match.start));
-                      await output(context2, line.bytes.subarray(match.start, match.end));
-                      await output(context2, delimiter);
+                      await writeOut(prefix3(true, number6, ":", byteOffset + match.start));
+                      await writeOut(line.bytes.subarray(match.start, match.end));
+                      await writeOut(delimiterBytes);
                       end = match.end;
                     }
                   }
                 } else {
-                  await output(context2, prefix3(true));
-                  await output(context2, line.bytes);
-                  await output(context2, delimiter);
+                  const p = prefix3(true);
+                  if (p) await writeOut(p);
+                  if (line.raw) await writeOut(line.raw);
+                  else {
+                    await writeOut(line.bytes);
+                    await writeOut(delimiterBytes);
+                  }
                 }
               }
               if (count2 >= maxCount && remainingAfter === 0) break records;
             }
           }
+          await flushOut();
           if (parsed.flags.has("q")) continue;
           if (parsed.flags.has("l") && count2 > 0 || parsed.flags.has("L") && count2 === 0) {
             await output(context2, named2 + (parsed.flags.has("Z") ? "\0" : "\n"));
           } else if (parsed.flags.has("c") && !parsed.flags.has("l") && !parsed.flags.has("L")) await output(context2, prefix3() + count2 + delimiter);
         } catch (error) {
+          await flushOut();
           context2.signal.throwIfAborted();
           if (error instanceof RegexExecutionError) throw error;
           failed = true;
@@ -47067,11 +47801,70 @@ function commandExecutor(lookup) {
     return { exitCode: 127 };
   };
 }
-function composeAgentCommands(options2, executors) {
+var cachedDefaultStatelessFamilies;
+function getDefaultStatelessFamilies() {
+  return cachedDefaultStatelessFamilies ??= {
+    beforeAliases: Object.freeze([
+      ...createTextProgramCommands({}),
+      ...createStructuredCommands({}),
+      ...createByteCommands(void 0),
+      ...createDiffPatchCommands({}),
+      ...createMetadataCommands({}),
+      ...createArchiveCommands({}),
+      ...createTableTextCommands({}),
+      ...createStreamInspectionCommands({}),
+      ...createStreamFormatCommands({}),
+      ...createSplitCommands({}),
+      ...createTimeEnvCommands({}),
+      ...createTreeCommands({}),
+      ...createFileCommands({})
+    ]),
+    beforeExpr: Object.freeze([
+      ...createColumnCommands({}),
+      ...createHtmlToMarkdownCommands({}),
+      ...createDuCommands({})
+    ]),
+    beforeCsplit: Object.freeze([
+      ...createWhichCommands({}),
+      ...createTimeoutCommands(void 0),
+      ...createApplyPatchCommands({}),
+      ...createXmlCommands({})
+    ]),
+    afterCsplit: Object.freeze([
+      ...createPrCommands({}),
+      ...createTsortCommands({}),
+      ...createFactorCommands({}),
+      ...createGetoptCommands({}),
+      ...createHexdumpCommands({}),
+      ...createIconvCommands({}),
+      ...createLineEndingCommands({})
+    ])
+  };
+}
+function hasCustomFamilyOptions(options2) {
+  return options2.text !== void 0 || options2.structured !== void 0 || options2.bytes !== void 0 || options2.diffPatch !== void 0 || options2.metadata !== void 0 || options2.archive !== void 0 || options2.tableText !== void 0 || options2.streamInspection !== void 0 || options2.streamFormat !== void 0 || options2.split !== void 0 || options2.timeEnv !== void 0 || options2.tree !== void 0 || options2.file !== void 0 || options2.column !== void 0 || options2.htmlToMarkdown !== void 0 || options2.du !== void 0 || options2.which !== void 0 || options2.timeout !== void 0 || options2.applyPatch !== void 0 || options2.xml !== void 0 || options2.pr !== void 0 || options2.tsort !== void 0 || options2.factor !== void 0 || options2.getopt !== void 0 || options2.hexdump !== void 0 || options2.iconv !== void 0 || options2.lineEndings !== void 0;
+}
+function composeRawAgentCommands(options2, executors) {
   const commands = [];
   const grep = createGrepCommands(executors.grep);
   const exprLimits = options2.expr?.limits;
   const csplitLimits = options2.csplit?.limits;
+  if (!hasCustomFamilyOptions(options2)) {
+    const defaults = getDefaultStatelessFamilies();
+    const aliasesGrep = executors.aliases === executors.grep ? grep[0] : createGrepCommands(executors.aliases)[0];
+    commands.push(
+      ...createStandardCommandsWithGrep({ execute: options2.execute ?? commandExecutor((name2) => commands.find((command7) => command7.name === name2)), ...options2.execution === void 0 ? {} : { execution: options2.execution }, ...options2.regex === void 0 ? {} : { regex: options2.regex }, ...options2.maxDirectoryEntries === void 0 ? {} : { maxDirectoryEntries: options2.maxDirectoryEntries }, ...options2.maxTeeTargets === void 0 ? {} : { maxTeeTargets: options2.maxTeeTargets }, ...options2.maxTailFollowHandles === void 0 ? {} : { maxTailFollowHandles: options2.maxTailFollowHandles } }, grep),
+      ...defaults.beforeAliases,
+      createRgCommand(executors.search, options2.search),
+      ...createGrepAliases(aliasesGrep),
+      ...defaults.beforeExpr,
+      createExprCommandWithExecutor(executors.expr, exprLimits === void 0 ? {} : { limits: exprLimits }),
+      ...defaults.beforeCsplit,
+      createCsplitCommandWithExecutor(executors.csplit, csplitLimits === void 0 ? {} : { limits: csplitLimits }),
+      ...defaults.afterCsplit
+    );
+    return commands;
+  }
   const prOptions = options2.pr;
   const prLimits = prOptions?.limits;
   const prClock = prOptions?.clock;
@@ -47124,7 +47917,10 @@ function composeAgentCommands(options2, executors) {
     ...createIconvCommands(iconvLimits === void 0 ? {} : { limits: iconvLimits }),
     ...createLineEndingCommands(lineEndingLimits === void 0 ? {} : { limits: lineEndingLimits })
   );
-  return new contracts_exports.CommandRegistry(commands).list();
+  return commands;
+}
+function composeAgentCommands(options2, executors) {
+  return new contracts_exports.CommandRegistry(composeRawAgentCommands(options2, executors)).list();
 }
 
 // packages/safe-bash/src/plugins/index.ts
@@ -47146,7 +47942,7 @@ function agentCommands(options2 = {}) {
     setup(host2) {
       if (disposal) throw new Error("Agent commands are disposed");
       host2.provideCapabilities?.({ regex: { executor: executors.grep.provider, limits: regex } });
-      const definitions = composeAgentCommands({ ...options2, execute: options2.execute ?? commandExecutor((name2) => host2.commands.get(name2)) }, executors);
+      const definitions = composeRawAgentCommands({ ...options2, execute: options2.execute ?? commandExecutor((name2) => host2.commands.get(name2)) }, executors);
       if (!options2.replace) for (const definition3 of definitions) {
         if (host2.commands.has(definition3.name)) throw new Error(`Command already registered: ${definition3.name}`);
       }
@@ -67225,7 +68021,7 @@ function makeSafeJsShellModule(executor, options2) {
 __reExport(core_browser_exports, core_exports);
 import { CommandArgumentIdentityError, createCommandArguments as createCommandArguments5, getCommandArguments as getCommandArguments16, commandRuntimeIdentity as commandRuntimeIdentity3, CommandRegistry as CommandRegistry3, validateExitCode as validateExitCode2 } from "../safe-bash-contracts/command.js";
 import { evaluateCommandSupport, assertCommandRequirements as assertCommandRequirements11 } from "../safe-bash-contracts/command-requirements.js";
-import { isErrnoCode, isFsError as isFsError10, toFsError, FsError as FsError61 } from "../safe-bash-contracts/errors.js";
+import { isErrnoCode, isFsError as isFsError10, toFsError, FsError as FsError62 } from "../safe-bash-contracts/errors.js";
 import { ACCESS_MODES as ACCESS_MODES3 } from "../safe-bash-contracts/filesystem.js";
 import { collectBytes as collectBytes11, readBytes as readBytes33, toByteSource as toByteSource8, outputFailure as outputFailure3, createBytePipe as createBytePipe2, writeText as writeText4, writeBytes as writeBytes32, pipeBytes as pipeBytes2, collectText } from "../safe-bash-contracts/io.js";
 import { createOutputOperation as createOutputOperation11 } from "../safe-bash-contracts/output.js";
@@ -67241,7 +68037,7 @@ export {
   EreSyntaxError,
   EreUnsupportedError,
   EreUsageUnknownError,
-  FsError61 as FsError,
+  FsError62 as FsError,
   MemoryFileSystem,
   MountFileSystem,
   OverlayFileSystem,