@poe-platform/safe-bash 0.1.726 → 0.1.727

package/dist/safe-bash/chunks/{chunk-RP5IZOOR.js → chunk-BJYV5J65.js}

@@ -2,10 +2,10 @@ import {
   assertCommandRequirements,
   inputRequirements,
   pathOf
-} from "./chunk-VGJIDLZM.js";
+} from "./chunk-KS5VSJYM.js";
 import {
   writeDiagnostic
-} from "./chunk-WTZZX4LV.js";
+} from "./chunk-A4MB2KXV.js";
 import {
   PublicDiagnostic,
   publicDiagnosticMessage
@@ -13,7 +13,7 @@ import {
 import {
   monotonicNow,
   yieldTurn
-} from "./chunk-B6YFFKYG.js";
+} from "./chunk-X4I3RHTC.js";
 import {
   FsError,
   readBytes,
@@ -44,6 +44,10 @@ var Decimal = class {
   text;
   double;
 };
+var SMALL_DECIMALS = Array.from({ length: 1025 }, (_, i) => {
+  const s = String(i);
+  return new Decimal(s, 0, false, s, i);
+});
 function isNumber(value) {
   return typeof value === "number" || value instanceof Decimal;
 }
@@ -51,6 +55,33 @@ function numberValue(value) {
   return typeof value === "number" ? value : value.double;
 }
 function numericToken(token, budget) {
+  const len = token.length;
+  if (len >= 1 && len <= 15) {
+    const first = token.charCodeAt(0);
+    if (first === 48 && len === 1) {
+      budget.step(2);
+      budget.text(token);
+      return SMALL_DECIMALS[0];
+    }
+    if (first >= 49 && first <= 57) {
+      let val = first - 48;
+      let allDigits = true;
+      for (let i = 1; i < len; i++) {
+        const c = token.charCodeAt(i);
+        if (c < 48 || c > 57) {
+          allDigits = false;
+          break;
+        }
+        val = val * 10 + (c - 48);
+      }
+      if (allDigits) {
+        budget.step(2);
+        budget.text(token);
+        if (val <= 1024) return SMALL_DECIMALS[val];
+        return new Decimal(token, 0, false, token, val);
+      }
+    }
+  }
   budget.step(Math.ceil(token.length / 32));
   const end = token.indexOf("\0");
   const text = end < 0 ? token : token.slice(0, end);
@@ -212,6 +243,26 @@ var Budget = class {
     this.steps += count;
     if (this.steps > this.limits.maxSteps) throw new JqLimitError("maxSteps");
   }
+  get currentSteps() {
+    return this.steps;
+  }
+  restoreSteps(steps) {
+    this.steps = steps;
+  }
+  needsYield() {
+    return this.steps >= this.nextYield || (this.steps & 31) === 0 && monotonicNow() - this.lastYield >= 25;
+  }
+  tickSync(count = 1) {
+    this.step(count);
+    if (this.steps >= this.nextYield || (this.steps & 31) === 0 && monotonicNow() - this.lastYield >= 25) {
+      return yieldTurn(this.signal).then(() => {
+        this.signal.throwIfAborted();
+        this.nextYield = this.steps + 1024;
+        this.lastYield = monotonicNow();
+      });
+    }
+    return void 0;
+  }
   async tick(count = 1) {
     this.step(count);
     if (this.steps >= this.nextYield || monotonicNow() - this.lastYield >= 25) {
@@ -228,41 +279,40 @@ var Budget = class {
     if (text.length > this.limits.maxValueBytes || text.length * 3 > this.limits.maxValueBytes && import_buffer.Buffer.byteLength(text) > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
   }
   value(value) {
-    let bytes2 = 0;
-    const visit = (current, depth) => {
-      this.step();
-      if (depth > this.limits.maxDepth) throw new JqLimitError("maxDepth");
-      if (current !== null && typeof current === "object" && !(current instanceof Decimal)) {
-        if (depth + 1 > this.limits.maxDepth) throw new JqLimitError("maxDepth");
-        if (Array.isArray(current)) {
-          this.collection(current.length);
-          bytes2 += 2 + Math.max(0, current.length - 1);
-          for (let index = 0; index < current.length; index++) {
-            if (bytes2 > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
-            visit(current[index], depth + 1);
-          }
-        } else {
-          const keys = keyOrders.get(current) ?? Object.keys(current);
-          this.collection(keys.length);
-          bytes2 += 2 + Math.max(0, keys.length - 1);
-          for (let index = 0; index < keys.length; index++) {
-            const key = keys[index];
-            this.text(key);
-            bytes2 += scalarJsonByteLength(key, this) + 1;
-            if (bytes2 > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
-            visit(current[key], depth + 1);
-          }
+    return this.visitValue(value, 0, 0);
+  }
+  visitValue(current, depth, bytes2) {
+    this.step();
+    if (depth > this.limits.maxDepth) throw new JqLimitError("maxDepth");
+    if (current !== null && typeof current === "object" && !(current instanceof Decimal)) {
+      if (depth + 1 > this.limits.maxDepth) throw new JqLimitError("maxDepth");
+      if (Array.isArray(current)) {
+        this.collection(current.length);
+        bytes2 += 2 + Math.max(0, current.length - 1);
+        for (let index = 0; index < current.length; index++) {
+          if (bytes2 > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+          bytes2 = this.visitValue(current[index], depth + 1, bytes2);
         }
       } else {
-        if (typeof current === "string") {
-          this.step(current.length);
-          this.text(current);
+        const keys = keyOrders.get(current) ?? Object.keys(current);
+        this.collection(keys.length);
+        bytes2 += 2 + Math.max(0, keys.length - 1);
+        for (let index = 0; index < keys.length; index++) {
+          const key = keys[index];
+          this.text(key);
+          bytes2 += scalarJsonByteLength(key, this) + 1;
+          if (bytes2 > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+          bytes2 = this.visitValue(current[key], depth + 1, bytes2);
         }
-        bytes2 += scalarJsonByteLength(current, this);
       }
-      if (bytes2 > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
-    };
-    visit(value, 0);
+    } else {
+      if (typeof current === "string") {
+        this.step(current.length);
+        this.text(current);
+      }
+      bytes2 += scalarJsonByteLength(current, this);
+    }
+    if (bytes2 > this.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
     return bytes2;
   }
 };
@@ -450,6 +500,189 @@ var JsonParser = class {
   counts = /* @__PURE__ */ new WeakMap();
   closed = /* @__PURE__ */ new WeakSet();
   lastKey = /* @__PURE__ */ new WeakMap();
+  isQuotedUnescaped() {
+    return this.quoted && !this.escaped && this.bom >= 3;
+  }
+  isUnquotedReady() {
+    return !this.quoted && this.bom >= 3;
+  }
+  isTopLevelIdle() {
+    return !this.quoted && !this.escaped && this.stack.length === 0 && this.token === "" && this.next === void 0 && !this.stream;
+  }
+  tryParseFlatLine(fullText, start, end) {
+    const byteLen = end - start;
+    if (byteLen < 2 || byteLen > this.budget.limits.maxValueBytes) return void 0;
+    if (fullText.charCodeAt(start) !== 123 || fullText.charCodeAt(end - 1) !== 125) return void 0;
+    if (this.budget.limits.maxDepth < 1) return void 0;
+    const obj = object();
+    let pos = start + 1;
+    let count = 0;
+    if (pos < end - 1) {
+      while (true) {
+        if (fullText.charCodeAt(pos) !== 34) return void 0;
+        pos++;
+        const keyStart = pos;
+        while (pos < end - 1) {
+          const c = fullText.charCodeAt(pos);
+          if (c === 34) break;
+          if (c < 32 || c >= 127 || c === 92) return void 0;
+          pos++;
+        }
+        if (pos >= end - 1) return void 0;
+        const key = fullText.slice(keyStart, pos);
+        if (Object.hasOwn(obj, key)) return void 0;
+        pos++;
+        if (fullText.charCodeAt(pos) !== 58) return void 0;
+        pos++;
+        if (pos >= end - 1) return void 0;
+        const vFirst = fullText.charCodeAt(pos);
+        let val;
+        if (vFirst === 34) {
+          pos++;
+          const vStart = pos;
+          while (pos < end - 1) {
+            const c = fullText.charCodeAt(pos);
+            if (c === 34) break;
+            if (c < 32 || c >= 127 || c === 92) return void 0;
+            pos++;
+          }
+          if (pos >= end - 1) return void 0;
+          val = fullText.slice(vStart, pos);
+          pos++;
+        } else if (vFirst === 116) {
+          if (fullText.charCodeAt(pos + 1) !== 114 || fullText.charCodeAt(pos + 2) !== 117 || fullText.charCodeAt(pos + 3) !== 101) return void 0;
+          val = true;
+          pos += 4;
+        } else if (vFirst === 102) {
+          if (fullText.charCodeAt(pos + 1) !== 97 || fullText.charCodeAt(pos + 2) !== 108 || fullText.charCodeAt(pos + 3) !== 115 || fullText.charCodeAt(pos + 4) !== 101) return void 0;
+          val = false;
+          pos += 5;
+        } else if (vFirst === 110) {
+          if (fullText.charCodeAt(pos + 1) !== 117 || fullText.charCodeAt(pos + 2) !== 108 || fullText.charCodeAt(pos + 3) !== 108) return void 0;
+          val = null;
+          pos += 4;
+        } else if (vFirst >= 48 && vFirst <= 57) {
+          const nStart = pos;
+          let num = vFirst - 48;
+          pos++;
+          if (vFirst === 48) {
+            const nextC = fullText.charCodeAt(pos);
+            if (nextC !== 44 && nextC !== 125) return void 0;
+            val = SMALL_DECIMALS[0];
+          } else {
+            while (pos < end - 1) {
+              const c = fullText.charCodeAt(pos);
+              if (c < 48 || c > 57) break;
+              num = num * 10 + (c - 48);
+              pos++;
+            }
+            if (pos - nStart > 15) return void 0;
+            const nextC = fullText.charCodeAt(pos);
+            if (nextC !== 44 && nextC !== 125) return void 0;
+            if (num <= 1024) val = SMALL_DECIMALS[num];
+            else {
+              const s = fullText.slice(nStart, pos);
+              val = new Decimal(s, 0, false, s, num);
+            }
+          }
+        } else if (vFirst === 91) {
+          pos++;
+          const arr = [];
+          if (fullText.charCodeAt(pos) === 93) {
+            pos++;
+          } else {
+            while (pos < end - 1) {
+              const eFirst = fullText.charCodeAt(pos);
+              let elem;
+              if (eFirst === 34) {
+                pos++;
+                const sStart = pos;
+                while (pos < end - 1) {
+                  const c = fullText.charCodeAt(pos);
+                  if (c === 34) break;
+                  if (c < 32 || c >= 127 || c === 92) return void 0;
+                  pos++;
+                }
+                if (pos >= end - 1) return void 0;
+                elem = fullText.slice(sStart, pos);
+                pos++;
+              } else if (eFirst >= 48 && eFirst <= 57) {
+                const nStart = pos;
+                let num = eFirst - 48;
+                pos++;
+                if (eFirst !== 48) {
+                  while (pos < end - 1) {
+                    const c = fullText.charCodeAt(pos);
+                    if (c < 48 || c > 57) break;
+                    num = num * 10 + (c - 48);
+                    pos++;
+                  }
+                }
+                if (pos - nStart > 15) return void 0;
+                const nextC = fullText.charCodeAt(pos);
+                if (nextC !== 44 && nextC !== 93) return void 0;
+                if (num <= 1024) elem = SMALL_DECIMALS[num];
+                else {
+                  const s = fullText.slice(nStart, pos);
+                  elem = new Decimal(s, 0, false, s, num);
+                }
+              } else {
+                return void 0;
+              }
+              arr.push(elem);
+              if (arr.length > this.budget.limits.maxCollectionSize) return void 0;
+              const aSep = fullText.charCodeAt(pos);
+              if (aSep === 44) {
+                pos++;
+                continue;
+              }
+              if (aSep === 93) {
+                pos++;
+                break;
+              }
+              return void 0;
+            }
+          }
+          val = arr;
+        } else {
+          return void 0;
+        }
+        count++;
+        if (count > this.budget.limits.maxCollectionSize) return void 0;
+        put(obj, key, val);
+        const sep = fullText.charCodeAt(pos);
+        if (sep === 44) {
+          pos++;
+          continue;
+        }
+        if (sep === 125 && pos === end - 1) break;
+        return void 0;
+      }
+    }
+    this.bom = 3;
+    this.offset += byteLen + 1;
+    this.line++;
+    this.column = 0;
+    this.bytes = 0;
+    this.budget.step(count * 3 + 2);
+    return obj;
+  }
+  appendQuotedSpan(span) {
+    const len = span.length;
+    this.offset += len;
+    this.column += len;
+    this.bytes += len;
+    if (this.bytes > this.budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+    this.token += span;
+  }
+  appendTokenSpan(span) {
+    const len = span.length;
+    this.offset += len;
+    this.column += len;
+    this.bytes += len;
+    if (this.bytes > this.budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+    this.token += span;
+  }
   path() {
     const path = [];
     for (const frame of this.stack) {
@@ -707,7 +940,8 @@ async function* readChunks(source, budget) {
       const newline = chunk.indexOf(10, offset);
       const end = Math.min(newline < 0 ? chunk.length : newline + 1, offset + 16384);
       budget.step(Math.ceil((end - offset) / 1024));
-      await budget.tick();
+      const p1 = budget.tickSync();
+      if (p1) await p1;
       if (newline >= 0 && end === newline + 1) {
         budget.inputLocation.line++;
         budget.inputLocation.complete = true;
@@ -737,53 +971,170 @@ async function* jsonValues(source, budget, options = {}) {
   let line = 1;
   let column = 0;
   let nulTail;
-  async function* scan(text, completeLine = false) {
-    for (const character of text) {
-      if (++scanned % 1024 === 0) await budget.tick();
-      if (!completeLine && character === "\0" && nulTail === void 0) nulTail = "";
-      if (nulTail !== void 0) {
-        nulTail += character;
-        if (nulTail.length > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
-        if (character === "\n") {
-          const tail = nulTail;
-          nulTail = void 0;
-          yield* scan(tail, true);
-        }
-        continue;
-      }
-      if (character === "\n") {
-        line++;
-        column = 0;
-      } else column++;
-      if (options.sequence && character === "") {
-        if (active && !failed) {
-          try {
-            yield* values(parser.finish({ line, column, eof: false }));
-          } catch (error) {
-            yield* failure(error, true);
+  try {
+    for await (const rawChunk of readBytes(source, budget.signal)) {
+      await budget.tick();
+      budget.inputBytes += rawChunk.byteLength;
+      if (budget.inputBytes > budget.limits.maxInputBytes) throw new JqLimitError("maxInputBytes");
+      const fullText = import_buffer.Buffer.isBuffer(rawChunk) ? rawChunk.toString("latin1") : import_buffer.Buffer.from(rawChunk.buffer, rawChunk.byteOffset, rawChunk.byteLength).toString("latin1");
+      let chunkOffset = 0;
+      while (chunkOffset < fullText.length) {
+        if (budget.inputLocation.complete) budget.inputLocation = { ...budget.inputLocation, complete: false };
+        const newline = fullText.indexOf("\n", chunkOffset);
+        const segEnd = Math.min(newline < 0 ? fullText.length : newline + 1, chunkOffset + 16384);
+        budget.step(Math.ceil((segEnd - chunkOffset) / 1024));
+        const pt = budget.tickSync();
+        if (pt) await pt;
+        if (newline >= 0 && segEnd === newline + 1) {
+          budget.inputLocation.line++;
+          budget.inputLocation.complete = true;
+          if (nulTail === void 0 && active && !failed && !options.sequence && !options.stream && !options.streamErrors && parser.isTopLevelIdle()) {
+            const fastObj = parser.tryParseFlatLine(fullText, chunkOffset, newline);
+            if (fastObj !== void 0) {
+              line++;
+              column = 0;
+              scanned += segEnd - chunkOffset;
+              if (scanned >= 1024) {
+                scanned &= 1023;
+                const p = budget.tickSync();
+                if (p) await p;
+              }
+              yield fastObj;
+              chunkOffset = segEnd;
+              continue;
+            }
           }
         }
-        parser = new JsonParser(budget, options.stream, line, column);
-        active = true;
-        failed = false;
-        continue;
-      }
-      if (!active) continue;
-      if (!failed) {
-        try {
-          yield* values(parser.feed(character));
-        } catch (error) {
-          yield* failure(error);
+        for (let index = chunkOffset; index < segEnd; index++) {
+          if ((++scanned & 1023) === 0) {
+            const p = budget.tickSync();
+            if (p) await p;
+          }
+          if (nulTail === void 0 && active && !failed) {
+            if (parser.isQuotedUnescaped()) {
+              let end = index;
+              while (end < segEnd) {
+                const code = fullText.charCodeAt(end);
+                if (code === 34 || code === 92 || code === 10 || code === 0 || code === 30) break;
+                end++;
+              }
+              if (end > index) {
+                parser.appendQuotedSpan(fullText.slice(index, end));
+                column += end - index;
+                scanned += end - index - 1;
+                index = end - 1;
+                continue;
+              }
+            } else if (parser.isUnquotedReady()) {
+              const firstCode = fullText.charCodeAt(index);
+              if (firstCode > 32 && firstCode !== 34 && firstCode !== 44 && firstCode !== 58 && firstCode !== 91 && firstCode !== 93 && firstCode !== 123 && firstCode !== 125 && firstCode !== 30) {
+                let end = index + 1;
+                while (end < segEnd) {
+                  const c = fullText.charCodeAt(end);
+                  if (c <= 32 || c === 34 || c === 44 || c === 58 || c === 91 || c === 93 || c === 123 || c === 125 || c === 30) break;
+                  end++;
+                }
+                if (end > index + 1) {
+                  parser.appendTokenSpan(fullText.slice(index, end));
+                  column += end - index;
+                  scanned += end - index - 1;
+                  index = end - 1;
+                  continue;
+                }
+              }
+            }
+          }
+          const character = fullText[index];
+          if (character === "\0" && nulTail === void 0) nulTail = "";
+          if (nulTail !== void 0) {
+            nulTail += character;
+            if (nulTail.length > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
+            if (character === "\n") {
+              const tail = nulTail;
+              nulTail = void 0;
+              for (let ti = 0; ti < tail.length; ti++) {
+                if ((++scanned & 1023) === 0) {
+                  const p = budget.tickSync();
+                  if (p) await p;
+                }
+                const tc = tail[ti];
+                if (tc === "\n") {
+                  line++;
+                  column = 0;
+                } else column++;
+                if (options.sequence && tc === "") {
+                  if (active && !failed) {
+                    try {
+                      yield* values(parser.finish({ line, column, eof: false }));
+                    } catch (error) {
+                      yield* failure(error, true);
+                    }
+                  }
+                  parser = new JsonParser(budget, options.stream, line, column);
+                  active = true;
+                  failed = false;
+                  continue;
+                }
+                if (!active) continue;
+                if (!failed) {
+                  try {
+                    const produced = parser.feed(tc);
+                    if (options.stream) {
+                      if (parser.events.length) yield* parser.events.splice(0);
+                    } else if (produced !== void 0) {
+                      yield produced;
+                    }
+                  } catch (error) {
+                    yield* failure(error);
+                  }
+                }
+                if (failed && options.streamErrors && !options.sequence && tc === "\n") {
+                  parser = new JsonParser(budget, true, line, column);
+                  failed = false;
+                }
+              }
+            }
+            continue;
+          }
+          if (character === "\n") {
+            line++;
+            column = 0;
+          } else column++;
+          if (options.sequence && character === "") {
+            if (active && !failed) {
+              try {
+                yield* values(parser.finish({ line, column, eof: false }));
+              } catch (error) {
+                yield* failure(error, true);
+              }
+            }
+            parser = new JsonParser(budget, options.stream, line, column);
+            active = true;
+            failed = false;
+            continue;
+          }
+          if (!active) continue;
+          if (!failed) {
+            try {
+              const produced = parser.feed(character);
+              if (options.stream) {
+                if (parser.events.length) yield* parser.events.splice(0);
+              } else if (produced !== void 0) {
+                yield produced;
+              }
+            } catch (error) {
+              yield* failure(error);
+            }
+          }
+          if (failed && options.streamErrors && !options.sequence && character === "\n") {
+            parser = new JsonParser(budget, true, line, column);
+            failed = false;
+          }
         }
-      }
-      if (failed && options.streamErrors && !options.sequence && character === "\n") {
-        parser = new JsonParser(budget, true, line, column);
-        failed = false;
+        chunkOffset = segEnd;
       }
     }
-  }
-  try {
-    for await (const chunk of readChunks(source, budget)) yield* scan(import_buffer.Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).toString("latin1"));
+    budget.inputLocation.complete = true;
     if (active && !failed) {
       try {
         yield* values(parser.finish(options.sequence ? { line, column, eof: true } : void 0));
@@ -945,13 +1296,65 @@ async function measureValue(value, budget, depth = 0, maxBytes = budget.limits.m
   return bytes2;
 }
 async function stringify(value, budget, format = false, maxBytes = budget.limits.maxValueBytes, limitName = "maxValueBytes", asStringValue = false) {
-  await budget.tick(0);
+  const p0 = budget.tickSync(0);
+  if (p0) await p0;
+  const isCompactPlain = !asStringValue && (format === false || typeof format === "object" && format.indent === "" && !format.ascii && !format.color);
+  if (isCompactPlain && value !== null && typeof value === "object" && !Array.isArray(value) && !isNumber(value) && budget.limits.maxDepth >= 1) {
+    let fastOk = true;
+    let out = "{";
+    let count = 0;
+    for (const key of objectKeyIterator(value)) {
+      for (let i = 0; i < key.length; i++) {
+        const c = key.charCodeAt(i);
+        if (c < 32 || c >= 127 || c === 34 || c === 92) {
+          fastOk = false;
+          break;
+        }
+      }
+      if (!fastOk) break;
+      const v = value[key];
+      let vStr;
+      if (typeof v === "number" && Number.isFinite(v)) {
+        vStr = Object.is(v, -0) ? "-0" : String(v);
+      } else if (isNumber(v) && typeof v === "object" && Number.isFinite(v.double)) {
+        vStr = v.text;
+      } else if (typeof v === "boolean") {
+        vStr = v ? "true" : "false";
+      } else if (v === null) {
+        vStr = "null";
+      } else if (typeof v === "string") {
+        for (let i = 0; i < v.length; i++) {
+          const c = v.charCodeAt(i);
+          if (c < 32 || c >= 127 || c === 34 || c === 92) {
+            fastOk = false;
+            break;
+          }
+        }
+        if (!fastOk) break;
+        vStr = `"${v}"`;
+      } else {
+        fastOk = false;
+        break;
+      }
+      if (count++) out += ",";
+      out += `"${key}":${vStr}`;
+      budget.collection(count);
+    }
+    if (fastOk) {
+      out += "}";
+      if (out.length > maxBytes) throw new JqLimitError(limitName);
+      const pEnd2 = budget.tickSync(out.length + count * 4 + 2);
+      if (pEnd2) await pEnd2;
+      return out;
+    }
+  }
   const parts = [];
   let bytes2 = 0;
   let units = 0;
   let stringBytes = 2;
   for (const fragment of jsonFragments(value, budget, format)) {
-    await budget.tick(0);
+    const pf = budget.tickSync(0);
+    if (pf) await pf;
     bytes2 += fragment.bytes;
     if (bytes2 > maxBytes) throw new JqLimitError(limitName);
     const text = renderJsonFragment(fragment, budget);
@@ -964,7 +1367,8 @@ async function stringify(value, budget, format = false, maxBytes = budget.limits
     units += text.length;
     parts.push(text);
   }
-  await budget.tick(units);
+  const pEnd = budget.tickSync(units);
+  if (pEnd) await pEnd;
   return parts.join("");
 }
 
@@ -1499,8 +1903,19 @@ var Budget6 = class {
     if ((++this.checkpoints & 255) === 0 || monotonicNow() - this.lastYield >= 25) {
       await yieldTurn(this.context.signal);
       this.lastYield = monotonicNow();
+      this.context.signal.throwIfAborted();
     }
+  }
+  checkpointSync() {
     this.context.signal.throwIfAborted();
+    const count = ++this.checkpoints;
+    if ((count & 255) === 0 || (count & 31) === 0 && monotonicNow() - this.lastYield >= 25) {
+      return yieldTurn(this.context.signal).then(() => {
+        this.lastYield = monotonicNow();
+        this.context.signal.throwIfAborted();
+      });
+    }
+    return void 0;
   }
 };
 function byteString(text) {
@@ -1529,24 +1944,27 @@ async function readProgram(context, file) {
   const contents = await context.fs.readFile(virtualPath(context, file), { signal: context.signal });
   return import_buffer.Buffer.from(contents).toString("latin1");
 }
-async function* lineRecords(context, files, budget) {
+async function* lineRecordBatches(context, files, budget) {
   const names = files.length ? files : ["-"];
   for (let fileIndex = 0; fileIndex < names.length; fileIndex++) {
     const file = names[fileIndex];
     let pending = "";
     for await (const chunk of input(context, file)) {
       budget.step();
-      const text = import_buffer.Buffer.from(chunk).toString("latin1");
+      const text = import_buffer.Buffer.isBuffer(chunk) ? chunk.toString("latin1") : import_buffer.Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength).toString("latin1");
       let start = 0;
       let end;
+      const batch = [];
       while ((end = text.indexOf("\n", start)) >= 0) {
-        yield { text: budget.check(pending + text.slice(start, end)), terminated: true, file, fileIndex };
+        const slice = pending ? pending + text.slice(start, end) : text.slice(start, end);
+        batch.push({ text: budget.check(slice), terminated: true, file, fileIndex });
         pending = "";
         start = end + 1;
       }
-      pending = budget.check(pending + text.slice(start));
+      pending = budget.check(pending ? pending + text.slice(start) : text.slice(start));
+      if (batch.length > 0) yield batch;
     }
-    if (pending) yield { text: pending, terminated: false, file, fileIndex };
+    if (pending) yield [{ text: pending, terminated: false, file, fileIndex }];
   }
 }
 function command(name, run) {
@@ -1748,7 +2166,11 @@ var Pattern = class {
     let groups = 0;
     let depth = 0;
     const closedGroups = /* @__PURE__ */ new Set();
-    const characterNode = (character) => ({ type: "character", accepts: (candidate) => ignoreCase ? candidate.toLowerCase() === character.toLowerCase() : candidate === character });
+    const characterNode = (character) => ({
+      type: "character",
+      ...ignoreCase ? {} : { literal: character },
+      accepts: (candidate) => ignoreCase ? candidate.toLowerCase() === character.toLowerCase() : candidate === character
+    });
     const escaped = () => {
       const character = source[offset++];
       if (character === void 0) throw new ProgramError("trailing backslash in regular expression");
@@ -1910,12 +2332,14 @@ var Pattern = class {
   parsed;
   anchored;
   linear = false;
+  literalMatch;
+  simpleRepeatMatch;
   backreferences = false;
   async prepare(budget) {
     if (!this.parsed) return;
     const { root, counts } = this.parsed;
     budget.step(counts.get(root) + 1);
-    await budget.checkpoint();
+    await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
     const code = [];
     const ignoreCase = this.ignoreCase;
     const emit = (instruction) => {
@@ -1925,7 +2349,7 @@ var Pattern = class {
       if (counts.get(node) === 0) return;
       yield;
       if (node.type === "character") {
-        emit({ kind: "character", accepts: node.accepts });
+        emit({ kind: "character", ...node.literal !== void 0 ? { literal: node.literal } : {}, accepts: node.accepts });
         return;
       }
       if (node.type === "backreference") {
@@ -1994,14 +2418,84 @@ var Pattern = class {
     let work = 0;
     for (const ignored of compile(root)) {
       if (++work % 64 === 0) {
-        await budget.checkpoint();
+        await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
         budget.step(0);
       }
     }
     emit({ kind: "match" });
-    await budget.checkpoint();
+    await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
     budget.step(0);
     this.linear = code.every((instruction) => instruction.kind === "character" || instruction.kind === "begin" || instruction.kind === "end" || instruction.kind === "match");
+    if (this.linear && !this.ignoreCase && this.dialect !== "jq") {
+      let validLiteral = true;
+      let anchoredStart = false;
+      let anchoredEnd = false;
+      let literalValue = "";
+      for (let i = 0; i < code.length - 1; i++) {
+        const inst = code[i];
+        if (inst.kind === "begin") {
+          if (i === 0) anchoredStart = true;
+          else {
+            validLiteral = false;
+            break;
+          }
+        } else if (inst.kind === "end") {
+          if (i === code.length - 2) anchoredEnd = true;
+          else {
+            validLiteral = false;
+            break;
+          }
+        } else if (inst.kind === "character" && inst.literal !== void 0) {
+          literalValue += inst.literal;
+        } else {
+          validLiteral = false;
+          break;
+        }
+      }
+      if (validLiteral) {
+        this.literalMatch = { value: literalValue, anchoredStart, anchoredEnd, groups: [literalValue] };
+      }
+    } else if (!this.ignoreCase && this.dialect !== "jq" && root.type === "sequence" && this.groupCount <= 1) {
+      let startIdx = 0;
+      let endIdx = root.nodes.length;
+      let anchoredStart = false;
+      let anchoredEnd = false;
+      if (startIdx < endIdx && root.nodes[startIdx]?.type === "begin") {
+        anchoredStart = true;
+        startIdx++;
+      }
+      if (startIdx < endIdx && root.nodes[endIdx - 1]?.type === "end") {
+        anchoredEnd = true;
+        endIdx--;
+      }
+      if (startIdx < endIdx) {
+        let prefix = "";
+        let prefixValid = true;
+        for (let i = startIdx; i < endIdx - 1; i++) {
+          const n = root.nodes[i];
+          if (n.type === "character" && n.literal !== void 0) {
+            prefix += n.literal;
+          } else {
+            prefixValid = false;
+            break;
+          }
+        }
+        const tail = root.nodes[endIdx - 1];
+        const captured = tail.type === "group" && tail.index === 1 && this.groupCount === 1;
+        const rawInner = captured ? tail.node : this.groupCount === 0 ? tail : void 0;
+        const repeatNode = rawInner?.type === "sequence" && rawInner.nodes.length === 1 ? rawInner.nodes[0] : rawInner;
+        if (prefixValid && (anchoredStart || prefix.length > 0) && repeatNode?.type === "repeat" && repeatNode.minimum >= 1 && repeatNode.maximum === Infinity && !repeatNode.lazy && repeatNode.node.type === "character") {
+          this.simpleRepeatMatch = {
+            prefix,
+            anchoredStart,
+            anchoredEnd,
+            captured,
+            minimum: repeatNode.minimum,
+            accepts: repeatNode.node.accepts
+          };
+        }
+      }
+    }
     this.backreferences = code.some((instruction) => instruction.kind === "backreference");
     this.code = code;
     this.parsed = void 0;
@@ -2013,7 +2507,7 @@ var Pattern = class {
       let storage = 0;
       let checkpoints = 0;
       while (pending.length) {
-        if (++checkpoints % 64 === 1) await budget.checkpoint();
+        if (++checkpoints % 64 === 1) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
         budget.step();
         const state = pending.pop();
         if (options.end !== void 0 && state.position > options.end) continue;
@@ -2079,17 +2573,219 @@ var Pattern = class {
     }
     return void 0;
   }
+  canFindSync() {
+    return this.code.length > 0 && this.dialect !== "jq" && Boolean(this.literalMatch || this.simpleRepeatMatch);
+  }
+  findSyncFast(text, budget, from = 0) {
+    if (this.simpleRepeatMatch) {
+      const { prefix, anchoredStart: anchoredStart2, anchoredEnd: anchoredEnd2, captured, minimum, accepts } = this.simpleRepeatMatch;
+      if (from > text.length || anchoredStart2 && from > 0) return void 0;
+      let found2 = -1;
+      let matchEnd = -1;
+      let groupStart = -1;
+      let groupEnd = -1;
+      if (anchoredStart2) {
+        if (text.startsWith(prefix)) {
+          const pos = prefix.length;
+          let cursor = pos;
+          while (cursor < text.length && accepts(text[cursor])) cursor++;
+          if (cursor - pos >= minimum && (!anchoredEnd2 || cursor === text.length)) {
+            found2 = 0;
+            matchEnd = cursor;
+            groupStart = pos;
+            groupEnd = cursor;
+          }
+        }
+      } else {
+        let searchFrom = from;
+        while (searchFrom <= text.length - prefix.length) {
+          const idx = text.indexOf(prefix, searchFrom);
+          if (idx < 0) break;
+          const pos = idx + prefix.length;
+          let cursor = pos;
+          while (cursor < text.length && accepts(text[cursor])) cursor++;
+          if (cursor - pos >= minimum && (!anchoredEnd2 || cursor === text.length)) {
+            found2 = idx;
+            matchEnd = cursor;
+            groupStart = pos;
+            groupEnd = cursor;
+            break;
+          }
+          searchFrom = idx + 1;
+        }
+      }
+      const positionsTried2 = anchoredStart2 ? 1 : found2 >= 0 ? found2 - from + 1 : text.length - from + 1;
+      const len2 = found2 >= 0 ? matchEnd - found2 : 0;
+      budget.step(positionsTried2 * 2 + (found2 >= 0 ? this.code.length * 2 + len2 : 0));
+      if (found2 < 0) return void 0;
+      if (len2 > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+      const full = text.slice(found2, matchEnd);
+      const groups2 = captured ? [full, text.slice(groupStart, groupEnd)] : [full];
+      return { start: found2, end: matchEnd, groups: groups2 };
+    }
+    const { value, anchoredStart, anchoredEnd, groups } = this.literalMatch;
+    const len = value.length;
+    if (from > text.length || anchoredStart && from > 0) return void 0;
+    let found = -1;
+    if (anchoredStart && anchoredEnd) {
+      if (from === 0 && text.length === len && text === value) found = 0;
+    } else if (anchoredStart) {
+      if (from === 0 && text.startsWith(value)) found = 0;
+    } else if (anchoredEnd) {
+      const candidate = text.length - len;
+      if (candidate >= from && text.endsWith(value)) found = candidate;
+    } else {
+      found = text.indexOf(value, from);
+    }
+    const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+    budget.step(positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0));
+    if (found < 0) return void 0;
+    if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    return { start: found, end: found + len, groups };
+  }
+  tryFindSync(text, budget, from = 0) {
+    if (this.code.length && this.simpleRepeatMatch && this.dialect !== "jq") {
+      const initialCheck2 = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      if (initialCheck2) return initialCheck2.then(() => this.find(text, budget, from));
+      return this.execSimpleRepeat(text, budget, from);
+    }
+    if (!this.code.length || !this.literalMatch || this.dialect === "jq") {
+      return this.find(text, budget, from);
+    }
+    const initialCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (initialCheck) return initialCheck.then(() => this.find(text, budget, from));
+    const { value, anchoredStart, anchoredEnd, groups } = this.literalMatch;
+    const len = value.length;
+    if (from > text.length || anchoredStart && from > 0) return void 0;
+    let found = -1;
+    if (anchoredStart && anchoredEnd) {
+      if (from === 0 && text.length === len && text === value) found = 0;
+    } else if (anchoredStart) {
+      if (from === 0 && text.startsWith(value)) found = 0;
+    } else if (anchoredEnd) {
+      const candidate = text.length - len;
+      if (candidate >= from && text.endsWith(value)) found = candidate;
+    } else {
+      found = text.indexOf(value, from);
+    }
+    const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+    const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
+    budget.step(stepCount);
+    if (stepCount >= 64) {
+      const midCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      if (midCheck) {
+        if (found < 0) return midCheck.then(() => void 0);
+        if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+        return midCheck.then(() => ({ start: found, end: found + len, groups }));
+      }
+    }
+    if (found < 0) return void 0;
+    if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    const endCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (endCheck) return endCheck.then(() => ({ start: found, end: found + len, groups }));
+    return { start: found, end: found + len, groups };
+  }
+  execSimpleRepeat(text, budget, from) {
+    const { prefix, anchoredStart, anchoredEnd, captured, minimum, accepts } = this.simpleRepeatMatch;
+    if (from > text.length || anchoredStart && from > 0) return void 0;
+    let found = -1;
+    let matchEnd = -1;
+    let groupStart = -1;
+    let groupEnd = -1;
+    if (anchoredStart) {
+      if (text.startsWith(prefix)) {
+        const pos = prefix.length;
+        let cursor = pos;
+        while (cursor < text.length && accepts(text[cursor])) cursor++;
+        if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
+          found = 0;
+          matchEnd = cursor;
+          groupStart = pos;
+          groupEnd = cursor;
+        }
+      }
+    } else {
+      let searchFrom = from;
+      while (searchFrom <= text.length - prefix.length) {
+        const idx = text.indexOf(prefix, searchFrom);
+        if (idx < 0) break;
+        const pos = idx + prefix.length;
+        let cursor = pos;
+        while (cursor < text.length && accepts(text[cursor])) cursor++;
+        if (cursor - pos >= minimum && (!anchoredEnd || cursor === text.length)) {
+          found = idx;
+          matchEnd = cursor;
+          groupStart = pos;
+          groupEnd = cursor;
+          break;
+        }
+        searchFrom = idx + 1;
+      }
+    }
+    const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+    const len = found >= 0 ? matchEnd - found : 0;
+    const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
+    budget.step(stepCount);
+    const finish = () => {
+      if (found < 0) return void 0;
+      if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+      const full = text.slice(found, matchEnd);
+      const groups = captured ? [full, text.slice(groupStart, groupEnd)] : [full];
+      return { start: found, end: matchEnd, groups };
+    };
+    if (stepCount >= 64) {
+      const midCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      if (midCheck) return midCheck.then(finish);
+    }
+    const endCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (endCheck) return endCheck.then(finish);
+    return finish();
+  }
   async find(text, budget, from = 0) {
     if (!this.code.length) await this.prepare(budget);
     if (this.dialect === "jq") return (await this.findJq(text, budget, from))?.match;
-    await budget.checkpoint();
+    if (this.simpleRepeatMatch) {
+      const initialCheck2 = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      if (initialCheck2) await initialCheck2;
+      return await this.execSimpleRepeat(text, budget, from);
+    }
+    const initialCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (initialCheck) await initialCheck;
+    if (this.literalMatch) {
+      const { value, anchoredStart, anchoredEnd, groups } = this.literalMatch;
+      const len = value.length;
+      if (from > text.length || anchoredStart && from > 0) return void 0;
+      let found = -1;
+      if (anchoredStart && anchoredEnd) {
+        if (from === 0 && text.length === len && text === value) found = 0;
+      } else if (anchoredStart) {
+        if (from === 0 && text.startsWith(value)) found = 0;
+      } else if (anchoredEnd) {
+        const candidate = text.length - len;
+        if (candidate >= from && text.endsWith(value)) found = candidate;
+      } else {
+        found = text.indexOf(value, from);
+      }
+      const positionsTried = anchoredStart ? 1 : found >= 0 ? found - from + 1 : text.length - from + 1;
+      const stepCount = positionsTried * 2 + (found >= 0 ? this.code.length * 2 + len : 0);
+      budget.step(stepCount);
+      if (stepCount >= 64) {
+        const midCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+        if (midCheck) await midCheck;
+      }
+      if (found < 0) return void 0;
+      if (len > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+      const endCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+      if (endCheck) await endCheck;
+      return { start: found, end: found + len, groups };
+    }
     let units = 0;
     const work = (count = 1) => {
       budget.step(count);
       units += count;
       if (units < 64) return void 0;
       units %= 64;
-      return budget.checkpoint();
+      return budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
     };
     if (this.linear) {
       for (let start = from; start <= text.length && (!this.anchored || start === 0); start++) {
@@ -2106,7 +2802,7 @@ var Pattern = class {
             const copied = work(position - start);
             if (copied) await copied;
             const match = { start, end: position, groups: [text.slice(start, position)] };
-            await budget.checkpoint();
+            await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
             return match;
           }
         }
@@ -2281,7 +2977,7 @@ var Pattern = class {
           const end = bestCaptures[index * 2 + 1];
           groups.push(begin === void 0 || end === void 0 ? void 0 : text.slice(begin, end));
         }
-        await budget.checkpoint();
+        await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
         return { start: bestStart, end: bestEnd, groups };
       }
       return void 0;
@@ -2296,7 +2992,7 @@ async function replacementLength(replacement, match, budget, available, syntax)
   let length = 0;
   let tokens = 0;
   for (let index = 0; index < replacement.length; index++) {
-    if (tokens++ % 256 === 0) await budget.checkpoint();
+    if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
     budget.step();
     const character = replacement[index];
     let size = 1;
@@ -2322,7 +3018,7 @@ async function replacementText(replacement, match, buffer, budget, syntax) {
   let literal = 0;
   let tokens = 0;
   for (let index = 0; index < replacement.length; index++) {
-    if (tokens++ % 256 === 0) await budget.checkpoint();
+    if (tokens++ % 256 === 0) await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
     budget.step();
     const character = replacement[index];
     if (character !== "&" && (character !== "\\" || index + 1 === replacement.length)) continue;
@@ -2344,7 +3040,138 @@ async function replacementText(replacement, match, buffer, budget, syntax) {
   }
   await buffer.append(replacement, literal);
 }
+function expandReplacementSync(replacement, match, budget, available, syntax) {
+  if (!replacement.includes("&") && !replacement.includes("\\")) {
+    budget.step(replacement.length * 2 + 1);
+    if (replacement.length > available) throw new ProgramError("text buffer limit exceeded");
+    return replacement;
+  }
+  let out = "";
+  for (let index = 0; index < replacement.length; index++) {
+    budget.step();
+    const character = replacement[index];
+    let piece = character;
+    if (character === "&") {
+      budget.step();
+      piece = match.groups[0] ?? "";
+    } else if (character === "\\" && index + 1 < replacement.length) {
+      budget.step();
+      const next = replacement[++index];
+      if (syntax === "awk") {
+        piece = next === "&" || next === "\\" ? next : `\\${next}`;
+      } else if (next >= "0" && next <= "9") {
+        budget.step();
+        piece = match.groups[Number(next)] ?? "";
+      } else {
+        piece = next === "n" ? "\n" : next === "t" ? "	" : next;
+      }
+    }
+    if (piece.length > available - out.length) throw new ProgramError("text buffer limit exceeded");
+    out += piece;
+  }
+  budget.step(out.length + 1);
+  return out;
+}
+function trySubstituteSync(text, pattern, replacement, budget, global, occurrence = 1, syntax = "sed") {
+  if (pattern.canFindSync() && text.length <= 4096 && replacement.length <= 256) {
+    const check = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (check) return substitute(text, pattern, replacement, budget, global, occurrence, syntax);
+    let search = 0;
+    let consumed = 0;
+    let previousEnd = -1;
+    let encountered = 0;
+    let count = 0;
+    let out = "";
+    while (search <= text.length) {
+      budget.step();
+      const match = pattern.findSyncFast(text, budget, search);
+      if (!match) break;
+      if (match.start === match.end && match.start === previousEnd) {
+        search = match.end + 1;
+        continue;
+      }
+      encountered++;
+      if (encountered >= occurrence) {
+        const prefixLen = match.start - consumed;
+        if (out.length + prefixLen > budget.maxBufferBytes) {
+          throw new ProgramError("text buffer limit exceeded");
+        }
+        if (prefixLen > 0) out += text.slice(consumed, match.start);
+        const rep = expandReplacementSync(replacement, match, budget, budget.maxBufferBytes - out.length, syntax);
+        out += rep;
+        consumed = match.end;
+        count++;
+        if (!global) break;
+      }
+      previousEnd = match.end;
+      search = match.end === match.start ? match.end + 1 : match.end;
+    }
+    if (count > 0) {
+      const tailLen = text.length - consumed;
+      if (out.length + tailLen > budget.maxBufferBytes) {
+        throw new ProgramError("text buffer limit exceeded");
+      }
+      if (tailLen > 0) out += text.slice(consumed);
+    } else {
+      out = budget.check(text);
+    }
+    const postCheck = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (postCheck) return postCheck.then(() => ({ text: out, count }));
+    return { text: out, count };
+  }
+  if (!global && occurrence === 1 && !replacement.includes("&") && !replacement.includes("\\")) {
+    const check = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (check) return substitute(text, pattern, replacement, budget, global, occurrence, syntax);
+    budget.step();
+    const matchOrPromise = pattern.tryFindSync(text, budget, 0);
+    if (matchOrPromise instanceof Promise) {
+      return matchOrPromise.then((match2) => {
+        if (!match2) {
+          budget.step(0);
+          return { text: budget.check(text), count: 0 };
+        }
+        const newLen2 = text.length - (match2.end - match2.start) + replacement.length;
+        if (newLen2 > budget.maxBufferBytes || match2.start + replacement.length > budget.maxBufferBytes) {
+          throw new ProgramError("text buffer limit exceeded");
+        }
+        budget.step(replacement.length * 2 + 1);
+        const out2 = (match2.start === 0 ? "" : text.slice(0, match2.start)) + replacement + (match2.end === text.length ? "" : text.slice(match2.end));
+        return { text: budget.check(out2), count: 1 };
+      });
+    }
+    const match = matchOrPromise;
+    if (!match) {
+      budget.step(0);
+      return { text: budget.check(text), count: 0 };
+    }
+    const newLen = text.length - (match.end - match.start) + replacement.length;
+    if (newLen > budget.maxBufferBytes || match.start + replacement.length > budget.maxBufferBytes) {
+      throw new ProgramError("text buffer limit exceeded");
+    }
+    budget.step(replacement.length * 2 + 1);
+    const out = (match.start === 0 ? "" : text.slice(0, match.start)) + replacement + (match.end === text.length ? "" : text.slice(match.end));
+    return { text: budget.check(out), count: 1 };
+  }
+  return substitute(text, pattern, replacement, budget, global, occurrence, syntax);
+}
 async function substitute(text, pattern, replacement, budget, global, occurrence = 1, syntax = "sed") {
+  if (!global && occurrence === 1 && !replacement.includes("&") && !replacement.includes("\\")) {
+    const check = budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint();
+    if (check) await check;
+    budget.step();
+    const match = await pattern.find(text, budget, 0);
+    if (!match) {
+      budget.step(0);
+      return { text: budget.check(text), count: 0 };
+    }
+    const newLen = text.length - (match.end - match.start) + replacement.length;
+    if (newLen > budget.maxBufferBytes || match.start + replacement.length > budget.maxBufferBytes) {
+      throw new ProgramError("text buffer limit exceeded");
+    }
+    budget.step(replacement.length * 2 + 1);
+    const out = (match.start === 0 ? "" : text.slice(0, match.start)) + replacement + (match.end === text.length ? "" : text.slice(match.end));
+    return { text: budget.check(out), count: 1 };
+  }
   let search = 0;
   let consumed = 0;
   let previousEnd = -1;
@@ -2353,7 +3180,7 @@ async function substitute(text, pattern, replacement, budget, global, occurrence
   const result = new ReplacementBuffer(budget);
   try {
     while (search <= text.length) {
-      await budget.checkpoint();
+      await (budget.checkpointSync ? budget.checkpointSync() : budget.checkpoint());
       budget.step();
       const match = await pattern.find(text, budget, search);
       if (!match) break;
@@ -2759,6 +3586,8 @@ async function* splitRegex(input2, source, budget) {
 
 // packages/safe-bash/src/commands/structured/interpreter.ts
 var deleted = /* @__PURE__ */ Symbol("deleted");
+var NOT_SINGLE = /* @__PURE__ */ Symbol("NOT_SINGLE");
+var EMPTY_RESULTS = [];
 var UserError = class extends JqError {
   constructor(value, message) {
     super(message);
@@ -2766,6 +3595,14 @@ var UserError = class extends JqError {
   }
   value;
 };
+function exactFiniteNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (value instanceof Object && "double" in value && "digits" in value && "exponent" in value) {
+    const d = value;
+    if (d.digits.length <= 15 && d.exponent === 0 && Number.isFinite(d.double)) return d.double;
+  }
+  return void 0;
+}
 var Interpreter = class _Interpreter {
   constructor(budget, variables, frame) {
     this.budget = budget;
@@ -2778,6 +3615,116 @@ var Interpreter = class _Interpreter {
   filters = /* @__PURE__ */ new Map();
   labels = /* @__PURE__ */ new Map();
   labelSequence = { next: 0 };
+  tryRunSync(ast, input2) {
+    const savedSteps = this.budget.currentSteps;
+    const res = this.tryRunSyncInternal(ast, input2);
+    if (res === void 0) this.budget.restoreSteps(savedSteps);
+    return res;
+  }
+  tryRunSyncInternal(ast, input2) {
+    if (this.budget.needsYield()) return void 0;
+    if (ast.kind === "binary" && ast.operator === "|") {
+      this.budget.step();
+      const leftResults = this.tryRunSyncInternal(ast.left, input2);
+      if (!leftResults) return void 0;
+      if (leftResults.length === 0) return EMPTY_RESULTS;
+      if (leftResults.length === 1) return this.tryRunSyncInternal(ast.right, leftResults[0]);
+      const out = [];
+      for (const item of leftResults) {
+        const rightResults = this.tryRunSyncInternal(ast.right, item);
+        if (!rightResults) return void 0;
+        out.push(...rightResults);
+      }
+      return out;
+    }
+    if (ast.kind === "call" && ast.name === "select" && ast.args.length === 1) {
+      this.budget.step();
+      const cond = this.tryEvalSingle(ast.args[0], input2);
+      if (cond === NOT_SINGLE) return void 0;
+      return truth(cond) ? [input2] : EMPTY_RESULTS;
+    }
+    const single = this.tryEvalSingle(ast, input2);
+    if (single !== NOT_SINGLE) return [single];
+    return void 0;
+  }
+  tryEvalSingle(ast, input2) {
+    if (this.budget.needsYield()) return NOT_SINGLE;
+    switch (ast.kind) {
+      case "identity":
+        this.budget.step();
+        return input2;
+      case "literal":
+        this.budget.step();
+        return ast.value;
+      case "index": {
+        this.budget.step();
+        const idx = this.tryEvalSingle(ast.index, input2);
+        if (typeof idx !== "string") return NOT_SINGLE;
+        const base = this.tryEvalSingle(ast.base, input2);
+        if (base === NOT_SINGLE || !(base === null || isObject(base))) return NOT_SINGLE;
+        return base === null ? null : Object.hasOwn(base, idx) ? base[idx] : null;
+      }
+      case "binary": {
+        this.budget.step();
+        const op = ast.operator;
+        if (op === "and" || op === "or") {
+          const left = this.tryEvalSingle(ast.left, input2);
+          if (left === NOT_SINGLE) return NOT_SINGLE;
+          if (op === "and" && !truth(left)) return false;
+          if (op === "or" && truth(left)) return true;
+          const right = this.tryEvalSingle(ast.right, input2);
+          if (right === NOT_SINGLE) return NOT_SINGLE;
+          return truth(right);
+        }
+        if (op === "+" || op === "-" || op === "*" || op === "==" || op === "!=" || op === "<" || op === "<=" || op === ">" || op === ">=") {
+          const rightVal = this.tryEvalSingle(ast.right, input2);
+          if (rightVal === NOT_SINGLE) return NOT_SINGLE;
+          const right = exactFiniteNumber(rightVal);
+          if (right === void 0) return NOT_SINGLE;
+          const leftVal = this.tryEvalSingle(ast.left, input2);
+          if (leftVal === NOT_SINGLE) return NOT_SINGLE;
+          const left = exactFiniteNumber(leftVal);
+          if (left === void 0) return NOT_SINGLE;
+          let res;
+          if (op === "+") res = left + right;
+          else if (op === "-") res = left - right;
+          else if (op === "*") res = left * right;
+          else if (op === "==") res = left === right;
+          else if (op === "!=") res = left !== right;
+          else if (op === "<") res = left < right;
+          else if (op === "<=") res = left <= right;
+          else if (op === ">") res = left > right;
+          else res = left >= right;
+          this.budget.step();
+          return res;
+        }
+        return NOT_SINGLE;
+      }
+      case "object": {
+        this.budget.step();
+        const result = object();
+        for (let i = 0; i < ast.fields.length; i++) {
+          const f = ast.fields[i];
+          const key = this.tryEvalSingle(f.key, input2);
+          if (typeof key !== "string") return NOT_SINGLE;
+          let val;
+          if (f.value) {
+            val = this.tryEvalSingle(f.value, input2);
+          } else if (input2 === null || isObject(input2)) {
+            val = input2 === null ? null : Object.hasOwn(input2, key) ? input2[key] : null;
+          } else {
+            return NOT_SINGLE;
+          }
+          if (val === NOT_SINGLE) return NOT_SINGLE;
+          put(result, key, val);
+        }
+        this.budget.value(result);
+        return result;
+      }
+      default:
+        return NOT_SINGLE;
+    }
+  }
   binding(name, value) {
     const depth = (this.frame?.depth ?? 0) + 1;
     if (depth > this.budget.limits.maxAstDepth) throw new JqLimitError("maxAstDepth");
@@ -2821,7 +3768,8 @@ var Interpreter = class _Interpreter {
     return result;
   }
   async *run(ast, input2) {
-    await this.budget.tick();
+    const p = this.budget.tickSync();
+    if (p) await p;
     switch (ast.kind) {
       case "parameter": {
         const filter = this.filters.get(ast);
@@ -4668,9 +5616,10 @@ export {
   write,
   input,
   readProgram,
-  lineRecords,
+  lineRecordBatches,
   command,
   Pattern,
+  trySubstituteSync,
   substitute,
   Decimal,
   isNumber,
@@ -4699,4 +5648,4 @@ export {
   moduleProgram,
   parse
 };
-//# sourceMappingURL=chunk-RP5IZOOR.js.map
+//# sourceMappingURL=chunk-BJYV5J65.js.map