poe-code 14.0.28 → 14.0.30

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

@@ -3432,6 +3432,7 @@ function createDirectoryReader(maxEntries = 1e4) {
 }
 
 // packages/safe-bash/src/commands/filesystem.ts
+var MAX_RECURSIVE_DIRECTORY_DEPTH = 1024;
 async function preflightOperands(context, operands, check) {
   for (const operand of operands) {
     try {
@@ -3514,11 +3515,19 @@ async function copy(context, source, target, flags, readDirectory, top = true, a
     if (isPathWithin(physicalSource, physicalTarget)) throw new FsError("EINVAL", { path: target, message: "cannot copy a directory into itself" });
     if (ancestors.has(physicalSource)) throw new FsError("ELOOP", { path: source });
     if (targetStat && targetStat.type !== "directory") throw new FsError("ENOTDIR", { path: target });
+    context.signal.throwIfAborted();
+    if (ancestors.size > MAX_RECURSIVE_DIRECTORY_DEPTH) {
+      throw new FsError("ELOOP", { path: source, message: `cp directory depth limit exceeded (${MAX_RECURSIVE_DIRECTORY_DEPTH})` });
+    }
     await admitFilesystemModes(context, "cp", ["recursive"], [target]);
-    if (!targetStat && !preflight) await context.fs.mkdir(target, { mode: sourceStat.mode & 511, signal: context.signal });
-    const next = new Set(ancestors).add(physicalSource);
-    for (const entry of await readDirectory(context, source, true)) {
-      await copy(context, joinPath(source, entry.name), joinPath(target, entry.name), flags, readDirectory, false, next, preflight);
+    ancestors.add(physicalSource);
+    try {
+      if (!targetStat && !preflight) await context.fs.mkdir(target, { mode: sourceStat.mode & 511, signal: context.signal });
+      for (const entry of await readDirectory(context, source, true)) {
+        await copy(context, joinPath(source, entry.name), joinPath(target, entry.name), flags, readDirectory, false, ancestors, preflight);
+      }
+    } finally {
+      ancestors.delete(physicalSource);
     }
   } else if (preserveLink) {
     await admitFilesystemModes(context, "cp", ["symlink"], [target]);
@@ -3856,25 +3865,33 @@ function filesystemCommands(maxDirectoryEntries) {
         await admitFilesystemModes(context, "ls", ["directory"], [path]);
         const physical = await context.fs.realpath(path, { signal: context.signal });
         if (ancestors.has(physical)) throw new FsError("ELOOP", { path });
-        const next = new Set(ancestors).add(physical);
-        if (header) {
-          await output(context, `${headerWritten ? "\n" : ""}${display}:
-`);
-          headerWritten = true;
-        }
-        const entries = await readDirectory(context, path, true);
-        const names = entries.map((entry) => entry.name).filter((name2) => parsed.flags.has("a") || parsed.flags.has("A") || !name2.startsWith("."));
-        if (parsed.flags.has("a")) for (const name2 of [".", ".."]) {
-          const index = names.findIndex((entry) => entry > name2);
-          names.splice(index < 0 ? names.length : index, 0, name2);
+        context.signal.throwIfAborted();
+        if (ancestors.size > MAX_RECURSIVE_DIRECTORY_DEPTH) {
+          throw new FsError("ELOOP", { path, message: `ls directory depth limit exceeded (${MAX_RECURSIVE_DIRECTORY_DEPTH})` });
         }
-        if (parsed.flags.has("r")) names.reverse();
-        for (const name2 of names) await render(joinPath(path, name2), name2);
-        if (parsed.flags.has("R")) for (const name2 of names) {
-          if (name2 === "." || name2 === "..") continue;
-          const child = joinPath(path, name2);
-          const childStat = await context.fs[parsed.flags.has("L") ? "stat" : "lstat"](child, { signal: context.signal });
-          if (childStat.type === "directory") await list(child, `${display.replace(/\/$/u, "")}/${name2}`, true, next);
+        ancestors.add(physical);
+        try {
+          if (header) {
+            await output(context, `${headerWritten ? "\n" : ""}${display}:
+`);
+            headerWritten = true;
+          }
+          const entries = await readDirectory(context, path, true);
+          const names = entries.map((entry) => entry.name).filter((name2) => parsed.flags.has("a") || parsed.flags.has("A") || !name2.startsWith("."));
+          if (parsed.flags.has("a")) for (const name2 of [".", ".."]) {
+            const index = names.findIndex((entry) => entry > name2);
+            names.splice(index < 0 ? names.length : index, 0, name2);
+          }
+          if (parsed.flags.has("r")) names.reverse();
+          for (const name2 of names) await render(joinPath(path, name2), name2);
+          if (parsed.flags.has("R")) for (const name2 of names) {
+            if (name2 === "." || name2 === "..") continue;
+            const child = joinPath(path, name2);
+            const childStat = await context.fs[parsed.flags.has("L") ? "stat" : "lstat"](child, { signal: context.signal });
+            if (childStat.type === "directory") await list(child, `${display.replace(/\/$/u, "")}/${name2}`, true, ancestors);
+          }
+        } finally {
+          ancestors.delete(physical);
         }
       };
       return eachOperand(context, operands, (operand) => list(pathOf(context, operand), operand, operands.length > 1 || parsed.flags.has("R")));
@@ -4656,6 +4673,103 @@ async function sortRecords(records, compare, work) {
   }
   return source;
 }
+async function cutRanges(list, work) {
+  const ranges = [];
+  let tokenStart = 0;
+  let dash = -1;
+  let start = 0;
+  let end = 0;
+  let invalid = false;
+  for (let index = 0; index <= list.length; index++) {
+    const checkpoint = work.charge();
+    if (checkpoint) await checkpoint;
+    const character = list[index];
+    if (character === "," || character === " " || index === list.length) {
+      if (index === tokenStart) {
+        if (index === 0 || index === list.length) throw new UsageError("invalid range ''");
+        tokenStart = index + 1;
+        continue;
+      }
+      if (invalid || dash === tokenStart && dash === index - 1) throw new UsageError(`invalid range '${list.slice(tokenStart, index)}'`);
+      if (dash === tokenStart) start = 1;
+      if (dash < 0) end = start;
+      const openEnd = dash >= 0 && dash === index - 1;
+      if (openEnd) end = Infinity;
+      if (!Number.isSafeInteger(start) || start < 1) throw new UsageError(`invalid number '${list.slice(tokenStart, dash < 0 ? index : dash)}'`);
+      if (!openEnd && (!Number.isSafeInteger(end) || end < 1)) throw new UsageError(`invalid number '${list.slice(dash < 0 ? tokenStart : dash + 1, index)}'`);
+      if (end < start) throw new UsageError(`decreasing range '${list.slice(tokenStart, index)}'`);
+      ranges.push({ start, end });
+      tokenStart = index + 1;
+      dash = -1;
+      start = 0;
+      end = 0;
+      invalid = false;
+    } else if (character === "-" && dash < 0) {
+      dash = index;
+    } else {
+      const digit2 = list.charCodeAt(index) - 48;
+      if (digit2 < 0 || digit2 > 9) invalid = true;
+      else if (dash < 0) start = start * 10 + digit2;
+      else end = end * 10 + digit2;
+    }
+  }
+  const ordered = await sortRecords(ranges, async (left, right) => left.start - right.start, work);
+  const normalized = [];
+  for (const range of ordered) {
+    const checkpoint = work.charge();
+    if (checkpoint) await checkpoint;
+    const previous = normalized.at(-1);
+    if (previous && range.start <= previous.end + 1) previous.end = Math.max(previous.end, range.end);
+    else normalized.push(range);
+  }
+  return normalized;
+}
+var CutOutput = class {
+  constructor(context, work) {
+    this.context = context;
+    this.work = work;
+  }
+  context;
+  work;
+  #buffer = new Uint8Array(64 * 1024);
+  #used = 0;
+  async write(bytes2) {
+    for (let offset = 0; offset < bytes2.length; ) {
+      const length = Math.min(4096, bytes2.length - offset, this.#buffer.length - this.#used);
+      const checkpoint = this.work.charge(length);
+      if (checkpoint) await checkpoint;
+      this.#buffer.set(bytes2.subarray(offset, offset + length), this.#used);
+      this.#used += length;
+      offset += length;
+      if (this.#used === this.#buffer.length) await this.flush();
+    }
+  }
+  async text(text) {
+    for (let offset = 0; offset < text.length; ) {
+      let end = Math.min(offset + 4096, text.length);
+      const last = text.charCodeAt(end - 1);
+      if (end < text.length && last >= 55296 && last <= 56319) end--;
+      await this.write(encoder2.encode(text.slice(offset, end)));
+      offset = end;
+    }
+  }
+  async flush() {
+    if (!this.#used) return;
+    const bytes2 = this.#buffer.slice(0, this.#used);
+    this.#used = 0;
+    await output(this.context, bytes2);
+  }
+};
+async function cutFieldBoundary(record4, separator, start, work) {
+  for (let offset = start; offset < record4.length; offset += 4096) {
+    const window = record4.subarray(offset, Math.min(record4.length, offset + 4096 + separator.length - 1));
+    const found = window.indexOf(separator);
+    const checkpoint = work.charge(found < 0 ? Math.min(4096, window.length) : found + separator.length);
+    if (checkpoint) await checkpoint;
+    if (found >= 0) return offset + found;
+  }
+  return -1;
+}
 async function compareSortBytes(left, right, work) {
   const length = Math.min(left.length, right.length);
   for (let offset = 0; offset < length; offset += 1024) {
@@ -5015,85 +5129,104 @@ function textCommands() {
       if (modes.length !== 1) throw new UsageError("exactly one byte, character, or field list is required");
       const mode = modes[0];
       if (mode !== "f" && (parsed.flags.has("d") || parsed.flags.has("s"))) throw new UsageError("delimiter options require field mode");
-      const ranges = value(parsed, mode).split(/[ ,]+/u).map((part) => {
-        const match = /^(?:([0-9]+)(?:-([0-9]*))?|-([0-9]+))$/u.exec(part);
-        if (!match) throw new UsageError(`invalid range '${part}'`);
-        const start = match[3] === void 0 ? integer(match[1], 1) : 1;
-        const end = match[3] !== void 0 ? integer(match[3], 1) : match[2] === void 0 ? start : match[2] === "" ? Infinity : integer(match[2], 1);
-        if (end < start) throw new UsageError(`decreasing range '${part}'`);
-        return { start, end };
-      });
-      const selected = (position) => ranges.some((range) => position >= range.start && position <= range.end) !== parsed.flags.has("C");
+      const work = new SortWork(context.signal);
+      const ranges = await cutRanges(value(parsed, mode), work);
+      const complement = parsed.flags.has("C");
       const delimiter = value(parsed, "d") ?? "	";
-      if ([...delimiter].length !== 1) throw new UsageError("delimiter must be a single character");
+      if (delimiter.length !== (delimiter.codePointAt(0) > 65535 ? 2 : 1)) throw new UsageError("delimiter must be a single character");
       const outputDelimiter = value(parsed, "o");
       const recordDelimiter = parsed.flags.has("z") ? 0 : 10;
+      const separator = import_buffer.Buffer.from(delimiter);
+      const writer = new CutOutput(context, work);
       let exitCode = 0;
       for (const name2 of parsed.operands.length ? parsed.operands : ["-"]) {
         try {
           for await (const line of lines(input(context, name2), recordDelimiter)) {
             context.signal.throwIfAborted();
-            let bytes2;
+            let cursor = 0;
+            const selected = (position) => {
+              while (cursor < ranges.length && position > ranges[cursor].end) cursor++;
+              return (cursor < ranges.length && position >= ranges[cursor].start) !== complement;
+            };
             if (mode === "f") {
               const record4 = import_buffer.Buffer.from(line.bytes.buffer, line.bytes.byteOffset, line.bytes.byteLength);
-              const separator = import_buffer.Buffer.from(delimiter);
-              let boundary = record4.indexOf(separator);
+              let boundary = await cutFieldBoundary(record4, separator, 0, work);
               if (boundary < 0) {
                 if (parsed.flags.has("s")) continue;
-                bytes2 = line.bytes;
+                await writer.write(line.bytes);
               } else {
-                const pieces = [];
-                const joiner = encoder2.encode(outputDelimiter ?? delimiter);
                 let field = 1;
                 let start = 0;
                 let emitted = false;
                 while (true) {
+                  const checkpoint = work.charge();
+                  if (checkpoint) await checkpoint;
                   if (selected(field++)) {
-                    if (emitted) pieces.push(joiner);
-                    pieces.push(record4.subarray(start, boundary < 0 ? record4.length : boundary));
+                    if (emitted) await writer.text(outputDelimiter ?? delimiter);
+                    await writer.write(record4.subarray(start, boundary < 0 ? record4.length : boundary));
                     emitted = true;
                   }
                   if (boundary < 0) break;
                   start = boundary + separator.length;
-                  boundary = record4.indexOf(separator, start);
+                  boundary = await cutFieldBoundary(record4, separator, start, work);
                 }
-                bytes2 = concatenate(pieces);
               }
             } else if (mode === "b") {
-              const chunks = [];
-              let start = -1;
               let emitted = false;
-              for (let index = 0; index <= line.bytes.length; index++) {
-                const included = index < line.bytes.length && selected(index + 1);
-                if (included && start < 0) start = index;
-                if (!included && start >= 0) {
-                  if (emitted && outputDelimiter !== void 0) chunks.push(encoder2.encode(outputDelimiter));
-                  chunks.push(line.bytes.subarray(start, index));
-                  emitted = true;
-                  start = -1;
+              let previousIncluded = false;
+              for (let offset = 0; offset < line.bytes.length; offset += 4096) {
+                const end = Math.min(line.bytes.length, offset + 4096);
+                const checkpoint = work.charge(end - offset);
+                if (checkpoint) await checkpoint;
+                let start = -1;
+                for (let index = offset; index < end; index++) {
+                  const included = selected(index + 1);
+                  if (included && start < 0) {
+                    if (!previousIncluded && emitted && outputDelimiter !== void 0) await writer.text(outputDelimiter);
+                    start = index;
+                    emitted = true;
+                  }
+                  if (!included && start >= 0) {
+                    await writer.write(line.bytes.subarray(start, index));
+                    start = -1;
+                  }
+                  previousIncluded = included;
                 }
+                if (start >= 0) await writer.write(line.bytes.subarray(start, end));
               }
-              bytes2 = concatenate(chunks);
             } else {
-              const text = new TextDecoder().decode(line.bytes);
-              const pieces = [];
+              const decoder3 = new TextDecoder();
               let index = 0;
-              let offset = 0;
-              let start = -1;
-              for (const character of text) {
-                const included = selected(++index);
-                if (included && start < 0) start = offset;
-                if (!included && start >= 0) {
-                  pieces.push(text.slice(start, offset));
-                  start = -1;
+              let emitted = false;
+              let previousIncluded = false;
+              for (let offset = 0; offset < line.bytes.length; offset += 4096) {
+                const end = Math.min(line.bytes.length, offset + 4096);
+                const checkpoint = work.charge(end - offset);
+                if (checkpoint) await checkpoint;
+                const text = decoder3.decode(line.bytes.subarray(offset, end), { stream: end < line.bytes.length });
+                let start = -1;
+                let position = 0;
+                for (const character of text) {
+                  const checkpoint2 = work.charge();
+                  if (checkpoint2) await checkpoint2;
+                  const included = selected(++index);
+                  if (included && start < 0) {
+                    if (!previousIncluded && emitted && outputDelimiter !== void 0) await writer.text(outputDelimiter);
+                    start = position;
+                    emitted = true;
+                  }
+                  if (!included && start >= 0) {
+                    await writer.text(text.slice(start, position));
+                    start = -1;
+                  }
+                  position += character.length;
+                  previousIncluded = included;
                 }
-                offset += character.length;
+                if (start >= 0) await writer.text(text.slice(start));
               }
-              if (start >= 0) pieces.push(text.slice(start));
-              bytes2 = encoder2.encode(pieces.join(outputDelimiter ?? ""));
             }
-            await output(context, bytes2);
-            await output(context, Uint8Array.of(recordDelimiter));
+            await writer.write(Uint8Array.of(recordDelimiter));
+            await writer.flush();
           }
         } catch (error) {
           await diagnostic(context, error);
@@ -5152,6 +5285,33 @@ var ShellLimitError = class extends Error {
   limit;
 };
 
+// packages/safe-bash/src/shell/parse-budget.ts
+init_platform();
+var defaultMaxParseUnits = 262144;
+var ParseBudget = class {
+  constructor(maximum = defaultMaxParseUnits, signal, onLimit) {
+    this.signal = signal;
+    this.onLimit = onLimit;
+    if (!Number.isSafeInteger(maximum) || maximum < 0) throw new RangeError("maxParseUnits must be a nonnegative safe integer");
+    this.#remaining = maximum;
+  }
+  signal;
+  onLimit;
+  #remaining;
+  #failure;
+  admit(units = 1) {
+    this.signal?.throwIfAborted();
+    if (this.#failure) throw this.#failure;
+    if (!Number.isSafeInteger(units) || units < 0) throw new RangeError("Parse admission must be a nonnegative safe integer");
+    if (units > this.#remaining) {
+      const error = this.#failure = new ShellLimitError("maxParseUnits");
+      this.onLimit?.(error);
+      throw error;
+    }
+    this.#remaining -= units;
+  }
+};
+
 // packages/safe-bash/src/shell/arithmetic.ts
 init_platform();
 var ArithmeticFailure = class extends Error {
@@ -5161,11 +5321,13 @@ var ArithmeticFailure = class extends Error {
   }
   offset;
 };
-function prepareArithmetic(source) {
+function prepareArithmetic(source, budget = new ParseBudget()) {
+  budget.admit();
   try {
-    return { source, tree: parseArithmetic(source) };
+    return { source, tree: parseArithmetic(source, 0, budget) };
   } catch (error) {
     if (!(error instanceof ShellSyntaxError) || /nesting/u.test(error.reason)) throw error;
+    budget.admit();
     return { source, error };
   }
 }
@@ -5220,7 +5382,7 @@ function integer2(text) {
   }
   return value2;
 }
-function parseArithmetic(source, offset = 0) {
+function parseArithmetic(source, offset = 0, budget = new ParseBudget()) {
   const tokens2 = [];
   let position = 0;
   while (position < source.length) {
@@ -5230,6 +5392,7 @@ function parseArithmetic(source, offset = 0) {
     }
     const value2 = /^(?:\d+#[\da-zA-Z@_]+|0[xX][\da-fA-F]+|\d+|[a-zA-Z_][a-zA-Z_0-9]*|<<=|>>=|\*\*|\+\+|--|&&|\|\||<<|>>|[+*/%&^|!<>=-]=|[()+*/%~!<>=&^|?:,\-])/u.exec(source.slice(position))?.[0];
     if (!value2) throw new ShellSyntaxError("Unsupported arithmetic token", offset + position);
+    budget.admit();
     tokens2.push({ value: value2, offset: offset + position });
     position += value2.length;
   }
@@ -5246,6 +5409,7 @@ function parseArithmetic(source, offset = 0) {
     const token = current();
     cursor++;
     if (["+", "-", "!", "~", "++", "--"].includes(token)) {
+      budget.admit();
       const operand = expression(15);
       if (["++", "--"].includes(token) && operand.kind !== "name") error("Arithmetic assignment requires a variable");
       left = { kind: "unary", operator: token, operand, postfix: false };
@@ -5253,8 +5417,11 @@ function parseArithmetic(source, offset = 0) {
       left = expression();
       if (current() !== ")") error("Unclosed arithmetic parenthesis");
       cursor++;
-    } else if (/^[a-zA-Z_]/u.test(token)) left = { kind: "name", name: token };
-    else {
+    } else if (/^[a-zA-Z_]/u.test(token)) {
+      budget.admit();
+      left = { kind: "name", name: token };
+    } else {
+      budget.admit();
       try {
         left = { kind: "literal", value: BigInt.asIntN(64, integer2(token)) };
       } catch {
@@ -5267,12 +5434,14 @@ function parseArithmetic(source, offset = 0) {
       if (operator === "++" || operator === "--") {
         if (left.kind !== "name") error("Arithmetic assignment requires a variable");
         cursor++;
+        budget.admit();
         left = { kind: "unary", operator, operand: left, postfix: true, start };
         continue;
       }
       const priority = Object.hasOwn(precedence, operator) ? precedence[operator] : 0;
       if (priority < minimum || priority === 0) break;
       cursor++;
+      budget.admit();
       if (operator === "?") {
         const yes = expression();
         if (current() !== ":") error("Expected arithmetic colon");
@@ -5288,7 +5457,10 @@ function parseArithmetic(source, offset = 0) {
     depth--;
     return left;
   };
-  if (!tokens2.length) return { kind: "literal", value: 0n };
+  if (!tokens2.length) {
+    budget.admit();
+    return { kind: "literal", value: 0n };
+  }
   const tree = expression();
   if (cursor < tokens2.length) error("Unexpected arithmetic token");
   return tree;
@@ -5305,7 +5477,7 @@ function arithmeticEnd(source, start) {
   }
   throw new ShellSyntaxError("Unterminated arithmetic expression", start);
 }
-function evaluateArithmetic(program, variables) {
+function evaluateArithmetic(program, variables, budget = new ParseBudget()) {
   const visiting = /* @__PURE__ */ new Set();
   let steps = 0;
   const binary = (operator, left, right, offset) => {
@@ -5373,7 +5545,7 @@ function evaluateArithmetic(program, variables) {
         else if (node.kind === "name") {
           if (visiting.has(node.name) || visiting.size >= 64) throw new Error("Arithmetic variable recursion");
           visiting.add(node.name);
-          pending.push({ kind: "variable", name: node.name }, { kind: "evaluate", node: parseArithmetic(variables[node.name] ?? "0") });
+          pending.push({ kind: "variable", name: node.name }, { kind: "evaluate", node: parseArithmetic(variables[node.name] ?? "0", 0, budget) });
         } else if (node.kind === "conditional") {
           pending.push({ kind: "conditional", node }, { kind: "evaluate", node: node.condition });
         } else if (node.kind === "unary") {
@@ -5439,21 +5611,23 @@ function setQuoteMarker(part, synthetic) {
 function isQuoteMarker(part) {
   return quoteMarkers.has(part);
 }
-function literalIndex(source, offset) {
+function literalIndex(source, offset, budget = new ParseBudget()) {
   let decimal = source;
   if (source[0] === "'" || source[0] === '"') {
     if (source.length < 2 || source.at(-1) !== source[0]) throw new ShellSyntaxError("Unsupported indexed-array subscript", offset);
     decimal = source.slice(1, -1);
   }
   if (!/^(?:0|[1-9][0-9]*)$/u.test(decimal)) throw new ShellSyntaxError("Unsupported indexed-array subscript", offset);
+  budget.admit();
   return { decimal };
 }
 function numericIndex(index) {
   if (index.decimal.length > 10 || index.decimal.length === 10 && index.decimal > "2147483647") return void 0;
   return Number(index.decimal);
 }
-function arraySelector(source, offset) {
-  return source === "@" || source === "*" ? { kind: "members", separator: source } : { kind: "element", index: literalIndex(source, offset) };
+function arraySelector(source, offset, budget = new ParseBudget()) {
+  budget.admit();
+  return source === "@" || source === "*" ? { kind: "members", separator: source } : { kind: "element", index: literalIndex(source, offset, budget) };
 }
 function setArraySelector(part, selector) {
   selectors.set(part, selector);
@@ -5473,7 +5647,8 @@ function setArrayAssignment(word, assignment) {
 function getArrayAssignment(word) {
   return assignments.get(word);
 }
-function removePrefix(word, length) {
+function removePrefix(word, length, budget) {
+  budget.admit();
   const parts = [];
   for (const part of word.parts) {
     if (length === 0) parts.push(part);
@@ -5481,6 +5656,7 @@ function removePrefix(word, length) {
       if (part.kind !== "text") throw new ShellSyntaxError("Unsupported indexed-array subscript", word.offset);
       if (part.value.length <= length) length -= part.value.length;
       else {
+        budget.admit();
         parts.push({ ...part, value: part.value.slice(length) });
         length = 0;
       }
@@ -5489,7 +5665,7 @@ function removePrefix(word, length) {
   if (length !== 0) throw new ShellSyntaxError("Invalid indexed-array assignment", word.offset);
   return { offset: word.offset, parts };
 }
-function elementAssignment(word) {
+function elementAssignment(word, budget = new ParseBudget()) {
   const source = word.spelling;
   const first = word.parts[0];
   if (source === void 0 || first?.kind !== "text" || first.quoted) return void 0;
@@ -5500,19 +5676,23 @@ function elementAssignment(word) {
     if (source.includes("=")) throw new ShellSyntaxError("Invalid indexed-array assignment", word.offset);
     return void 0;
   }
-  const index = literalIndex(source.slice(name2.length + 1, end), word.offset + name2.length + 1);
+  budget.admit();
+  const index = literalIndex(source.slice(name2.length + 1, end), word.offset + name2.length + 1, budget);
   const append = source[end + 1] === "+";
-  const value2 = removePrefix(word, name2.length + index.decimal.length + (append ? 4 : 3));
+  const value2 = removePrefix(word, name2.length + index.decimal.length + (append ? 4 : 3), budget);
   return { kind: "element", name: name2, index, append, value: value2 };
 }
-function compoundHead(word) {
+function compoundHead(word, budget = new ParseBudget()) {
   if (word.parts.length !== 1) return void 0;
   const first = word.parts[0];
   if (first?.kind !== "text" || first.quoted) return void 0;
   const match = /^([a-zA-Z_][a-zA-Z_0-9]*)(\+?)=$/u.exec(first.value);
-  return match ? { name: match[1], append: match[2] === "+" } : void 0;
+  if (!match) return void 0;
+  budget.admit();
+  return { name: match[1], append: match[2] === "+" };
 }
-function compoundEntry(word) {
+function compoundEntry(word, budget = new ParseBudget()) {
+  budget.admit();
   const source = word.spelling;
   const first = word.parts[0];
   if (source === void 0 || source[0] !== "[" || first?.kind !== "text" || first.quoted) return { value: word };
@@ -5521,8 +5701,8 @@ function compoundEntry(word) {
     if (source.includes("=")) throw new ShellSyntaxError("Invalid indexed-array entry", word.offset);
     return { value: word };
   }
-  const index = literalIndex(source.slice(1, end), word.offset + 1);
-  return { index, value: removePrefix(word, index.decimal.length + 3) };
+  const index = literalIndex(source.slice(1, end), word.offset + 1, budget);
+  return { index, value: removePrefix(word, index.decimal.length + 3, budget) };
 }
 function scalarAssignmentName(word) {
   const first = word.parts[0];
@@ -5842,7 +6022,8 @@ var HereDocumentSyntaxError = class extends Error {
   }
   diagnostic;
 };
-function printedSimpleLines(lists, separators) {
+function printedSimpleLines(lists, separators, budget) {
+  budget.admit();
   const printedLines = /* @__PURE__ */ new Map();
   let line = 1;
   for (let index = 0; index < lists.length; index++) {
@@ -5860,7 +6041,8 @@ function printedSimpleLines(lists, separators) {
 var IncompleteShellInput = class extends Error {
 };
 var Lexer = class {
-  constructor(source, depth, warnings = [], lineOffset = 0, byteLocale2 = false, documentLine, partial = false) {
+  constructor(budget, source, depth, warnings = [], lineOffset = 0, byteLocale2 = false, documentLine, partial = false) {
+    this.budget = budget;
     this.source = source;
     this.depth = depth;
     this.warnings = warnings;
@@ -5871,6 +6053,7 @@ var Lexer = class {
     if (depth > 64) throw new ShellSyntaxError("Syntax nesting exceeds 64", 0);
     for (let offset = source.indexOf("\n"); offset !== -1; offset = source.indexOf("\n", offset + 1)) this.newlineOffsets.push(offset);
   }
+  budget;
   source;
   depth;
   warnings;
@@ -5900,6 +6083,7 @@ var Lexer = class {
     throw new ShellSyntaxError(message2, this.position, 2, void 0, unclosedQuote);
   }
   next() {
+    this.budget.admit();
     while (this.position < this.source.length) {
       const current = this.source[this.position];
       if (current === " " || current === "	" || this.conditional && current === "\n") {
@@ -5941,6 +6125,7 @@ var Lexer = class {
     if (this.position <= offset) this.error("Tokenizer made no progress");
     let document;
     if (delimiterOperator) {
+      this.budget.admit();
       document = {
         delimiter: word.parts.map((part) => part.kind === "text" ? part.value : "").join(""),
         quoted: word.parts.some((part) => part.quoted),
@@ -5952,6 +6137,7 @@ var Lexer = class {
       };
       this.documents.push(document);
     }
+    this.budget.admit();
     return { kind: "word", value: word.plain ?? "", offset, end: this.position, word: { ...word, spelling: this.source.slice(offset, this.position) }, ...document ? { document } : {} };
   }
   readDocuments() {
@@ -5986,10 +6172,12 @@ var Lexer = class {
       const current = this.source[this.position];
       if (current === "$" || current === "`") {
         if (text) {
+          this.budget.admit(2);
           yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] };
           text = "";
         }
         const offset = this.position;
+        this.budget.admit();
         const parts = [];
         try {
           this.expansion(parts, true);
@@ -6013,11 +6201,15 @@ var Lexer = class {
         this.position++;
       }
       if (text.length >= 1024) {
+        this.budget.admit(2);
         yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] };
         text = "";
       }
     }
-    if (text) yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] };
+    if (text) {
+      this.budget.admit(2);
+      yield { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] };
+    }
   }
   documentSubstitutionError(source, error, backtick = false) {
     const line = this.documentLine + source.slice(0, error.offset).split("\n").length;
@@ -6064,6 +6256,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
     this.error("Unterminated delimiter expansion syntax");
   }
   word(terminator, enclosingQuoted = false, literal = false, arithmetic = false) {
+    this.budget.admit();
     const offset = this.position;
     const reduction = this.printedNewlineReduction;
     const unprinted = this.unprintedWords;
@@ -6088,6 +6281,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         previous.value += value2;
         if (!synthetic) setQuoteMarker(previous, false);
       } else {
+        this.budget.admit();
         const part = { kind: "text", value: projection, quoted, ...typeof value2 === "string" ? {} : { byteValue: value2 } };
         setQuoteMarker(part, synthetic);
         parts.push(part);
@@ -6195,6 +6389,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
           return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(raw);
         } catch (error) {
           if (!(error instanceof TypeError) || !("code" in error) || error.code !== "ERR_ENCODING_INVALID_ENCODED_DATA") throw error;
+          this.budget.admit(2);
           return shellValueFromBytes(raw);
         }
       }
@@ -6237,6 +6432,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
     this.error("Unterminated ANSI-C quote", { quote: "'", line: quoteLine });
   }
   expansion(parts, quoted) {
+    this.budget.admit();
     const line = this.documentLine ?? this.lineAt(this.position);
     if (this.source[this.position] === "`") {
       this.position++;
@@ -6248,9 +6444,10 @@ shell: command substitution: line ${line}: \`${sourceLine}'
       if (this.source[this.position] !== "`") this.error("Unterminated command substitution");
       this.position++;
       try {
-        parts.push({ kind: "substitution", script: parseSource(source, this.depth + 1, this.warnings, line - 1, this.byteLocale), line, quoted });
+        parts.push({ kind: "substitution", script: parseSource(source, this.depth + 1, this.warnings, line - 1, this.byteLocale, this.budget), line, quoted });
       } catch (error) {
         if (this.documentLine === void 0 || !(error instanceof ShellSyntaxError) || /nesting|exceeds/u.test(error.reason)) throw error;
+        this.budget.admit();
         parts.push({ kind: "failed-substitution", diagnostic: this.documentSubstitutionError(source, error, true).diagnostic, quoted });
       }
       return;
@@ -6261,14 +6458,15 @@ shell: command substitution: line ${line}: \`${sourceLine}'
       const start = this.position + 2;
       const end = arithmeticEnd(this.source, start);
       const source = this.source.slice(start, end);
-      parts.push({ kind: "arithmetic", expression: prepareArithmetic(source), source, line, quoted });
+      parts.push({ kind: "arithmetic", expression: prepareArithmetic(source, this.budget), source, line, quoted });
       this.position = end + 2;
     } else if (this.source[this.position] === "(") {
       const start = this.position + 1;
       let nested;
       let script;
       try {
-        nested = new Parser(this.source.slice(start), this.depth + 1, this.warnings, this.lineAt(start) - 1, void 0, this.byteLocale);
+        this.budget.admit();
+        nested = new Parser(this.budget, this.source.slice(start), this.depth + 1, this.warnings, this.lineAt(start) - 1, void 0, this.byteLocale);
         script = nested.script(/* @__PURE__ */ new Set([")"]));
       } catch (error) {
         if (this.documentLine !== void 0 && error instanceof ShellSyntaxError && !/nesting|exceeds/u.test(error.reason)) throw this.documentSubstitutionError(this.source.slice(start), error);
@@ -6298,7 +6496,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         const start = ++this.position;
         const end = this.source.indexOf("]", start);
         if (end < 0) this.error("Unterminated indexed-array subscript");
-        selector = arraySelector(this.source.slice(start, end), start);
+        selector = arraySelector(this.source.slice(start, end), start, this.budget);
         this.position = end + 1;
         if (this.source[this.position] !== "}") this.error("Unsupported indexed-array operator");
       }
@@ -6323,6 +6521,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
           this.position++;
           substringLength = this.word("}", true, false, true);
         }
+        this.budget.admit();
         substring = { offset, ...substringLength ? { length: substringLength } : {}, source: this.source.slice(parameterStart, this.position + 1) };
       }
       if (this.source[this.position] !== "}") this.error("Unterminated or unsupported parameter expansion");
@@ -6340,17 +6539,20 @@ shell: command substitution: line ${line}: \`${sourceLine}'
   }
 };
 var Parser = class {
+  constructor(budget, source, depth, warnings = [], lineOffset = 0, position, byteLocale2 = false, partial = false) {
+    this.budget = budget;
+    if (position === void 0 && depth === 0 && source.includes("\0")) throw new ShellSyntaxError("NUL bytes are not valid shell source", source.indexOf("\0"));
+    budget.admit();
+    this.lexer = new Lexer(budget, source, depth, warnings, lineOffset, byteLocale2, void 0, partial);
+    this.lexer.position = position ?? 0;
+    this.current = this.lexer.next();
+  }
+  budget;
   lexer;
   current;
   lookahead;
   nesting = 0;
   openCommands = [];
-  constructor(source, depth, warnings = [], lineOffset = 0, position, byteLocale2 = false, partial = false) {
-    if (position === void 0 && depth === 0 && source.includes("\0")) throw new ShellSyntaxError("NUL bytes are not valid shell source", source.indexOf("\0"));
-    this.lexer = new Lexer(source, depth, warnings, lineOffset, byteLocale2, void 0, partial);
-    this.lexer.position = position ?? 0;
-    this.current = this.lexer.next();
-  }
   error(message2) {
     const command2 = this.current.kind === "end" ? this.openCommands.findLast((command3) => ["{", "if", "while", "until", "for", "case"].includes(command3.name)) : void 0;
     throw new ShellSyntaxError(message2, this.current.offset, 2, command2);
@@ -6378,11 +6580,13 @@ var Parser = class {
     while (this.is("\n")) this.advance();
   }
   script(stops = /* @__PURE__ */ new Set(), inputUnit = false) {
+    this.budget.admit();
     const lists = [];
     const separators = [];
     this.newlines();
     const line = this.lexer.lineAt(this.current.offset);
     while (this.current.kind !== "end" && !stops.has(this.current.value)) {
+      this.budget.admit();
       const pipelines = [this.pipeline()];
       const operators = [];
       while (this.is("&&") || this.is("||")) {
@@ -6399,21 +6603,25 @@ var Parser = class {
         this.newlines();
       } else if (!this.isEnd() && !this.is(")") && !(stops.has(this.current.value) && [";;", ";&", ";;&"].includes(this.current.value))) this.error("Expected command separator");
     }
-    const printed = printedSimpleLines(lists, separators);
+    const printed = printedSimpleLines(lists, separators, this.budget);
     return { lists, line, ...printed };
   }
   pipeline() {
+    this.budget.admit();
     const negate = this.is("!");
     if (negate) this.advance();
     const commands = [this.command()];
     while (this.is("|") || this.is("|&")) {
       const operator = this.advance();
-      if (operator.value === "|&") commands.at(-1).redirects.push({
-        descriptor: 2,
-        operator: ">&",
-        implicitPipeline: true,
-        target: { offset: operator.offset, plain: "1", spelling: "1", parts: [{ kind: "text", value: "1", quoted: false }] }
-      });
+      if (operator.value === "|&") {
+        this.budget.admit(3);
+        commands.at(-1).redirects.push({
+          descriptor: 2,
+          operator: ">&",
+          implicitPipeline: true,
+          target: { offset: operator.offset, plain: "1", spelling: "1", parts: [{ kind: "text", value: "1", quoted: false }] }
+        });
+      }
       this.newlines();
       commands.push(this.command());
     }
@@ -6421,10 +6629,12 @@ var Parser = class {
   }
   command() {
     if (++this.nesting + this.lexer.depth > 64) this.error("Syntax nesting exceeds 64");
+    this.budget.admit();
     const line = this.lexer.lineAt(this.current.offset);
     this.openCommands.push({ name: this.current.value, line });
     try {
       const command2 = this.commandInner();
+      this.budget.admit();
       return { ...command2, line: command2.line ?? line };
     } finally {
       this.nesting--;
@@ -6432,6 +6642,7 @@ var Parser = class {
     }
   }
   commandInner() {
+    this.budget.admit();
     let command2;
     if (this.is("[[")) {
       const start = this.current.end;
@@ -6453,7 +6664,9 @@ var Parser = class {
           admit2();
           this.advance();
           const expression2 = primary(depth + 1);
-          return expression2.kind === "not" && !grouped.has(expression2) ? expression2.operand : { kind: "not", operand: expression2 };
+          if (expression2.kind === "not" && !grouped.has(expression2)) return expression2.operand;
+          this.budget.admit();
+          return { kind: "not", operand: expression2 };
         }
         if (this.is("(")) {
           this.advance();
@@ -6463,6 +6676,7 @@ var Parser = class {
           return expression2;
         }
         admit2();
+        this.budget.admit();
         const first = operand();
         if (conditionalBinary.has(this.current.value)) {
           const operator = this.current.value;
@@ -6478,6 +6692,7 @@ var Parser = class {
         let expression2 = primary(depth);
         while (this.is("&&")) {
           admit2();
+          this.budget.admit();
           this.advance();
           expression2 = { kind: "and", left: expression2, right: primary(depth) };
         }
@@ -6487,6 +6702,7 @@ var Parser = class {
         let expression2 = conjunction(depth);
         while (this.is("||")) {
           admit2();
+          this.budget.admit();
           this.advance();
           expression2 = { kind: "or", left: expression2, right: conjunction(depth) };
         }
@@ -6502,7 +6718,7 @@ var Parser = class {
       const start = this.current.offset + 2;
       const end = arithmeticEnd(this.lexer.source, start);
       const source = this.lexer.source.slice(start, end);
-      command2 = { kind: "arithmetic", expression: prepareArithmetic(source), source, redirects: [] };
+      command2 = { kind: "arithmetic", expression: prepareArithmetic(source, this.budget), source, redirects: [] };
       this.lexer.position = end + 2;
       this.lookahead = void 0;
       this.current = this.lexer.next();
@@ -6520,6 +6736,7 @@ var Parser = class {
         const condition = this.nonemptyScript(/* @__PURE__ */ new Set(["then"]));
         this.expect("then");
         const body = this.nonemptyScript(/* @__PURE__ */ new Set(["elif", "else", "fi"]));
+        this.budget.admit();
         branches.push({ condition, body });
         if (!this.is("elif")) break;
         this.advance();
@@ -6552,6 +6769,7 @@ var Parser = class {
         const body = this.script(/* @__PURE__ */ new Set([";;", ";&", ";;&", "esac"]));
         if (![";;", ";&", ";;&", "esac"].includes(this.current.value)) this.error("Expected case terminator");
         const terminator = this.current.value;
+        this.budget.admit();
         clauses.push({ patterns: patterns2, body, terminator });
         if (terminator === "esac") break;
         this.advance();
@@ -6595,7 +6813,7 @@ var Parser = class {
       this.newlines();
       if (!this.is("{")) this.error("Expected brace function body");
       command2 = { kind: "function", name: name2, body: this.command(), redirects: [] };
-    } else if (this.current.kind === "word" && !compoundHead(this.current.word) && this.peek().value === "(") {
+    } else if (this.current.kind === "word" && !compoundHead(this.current.word, this.budget) && this.peek().value === "(") {
       const name2 = this.advance().value;
       if (!/^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(name2)) this.error("Invalid function name");
       this.expect("(");
@@ -6617,21 +6835,22 @@ var Parser = class {
         } else if (this.current.kind === "word") {
           line ??= wordLine;
           let word = this.advance().word;
-          const head = compoundHead(word);
+          const head = compoundHead(word, this.budget);
           if (head && this.is("(")) {
             this.advance();
             const entries = [];
             this.newlines();
             while (this.current.kind === "word") {
-              entries.push(compoundEntry(this.advance().word));
+              entries.push(compoundEntry(this.advance().word, this.budget));
               this.newlines();
             }
             if (!this.is(")")) this.error("Unsupported indexed-array compound assignment");
             const end = this.advance().end;
+            this.budget.admit(2);
             word = { offset: word.offset, parts: word.parts, spelling: this.lexer.source.slice(word.offset, end) };
             setArrayAssignment(word, { kind: "compound", ...head, entries });
           } else {
-            const assignment = words.every((previous) => getArrayAssignment(previous) || scalarAssignmentName(previous)) ? elementAssignment(word) : void 0;
+            const assignment = words.every((previous) => getArrayAssignment(previous) || scalarAssignmentName(previous)) ? elementAssignment(word, this.budget) : void 0;
             if (assignment) setArrayAssignment(word, assignment);
           }
           words.push(word);
@@ -6657,6 +6876,7 @@ var Parser = class {
       if (/^(?:>|>>|<|<<|<<-|<<<|>&|<&|>\|)$/u.test(next.value) && this.current.end === next.offset) descriptor2 = Number(this.advance().value);
     }
     if (!/^(?:>|>>|<|<<|<<-|<<<|>&|<&|>\||&>)$/u.test(this.current.value) || this.current.kind !== "operator") return void 0;
+    this.budget.admit();
     const operator = this.advance().value;
     descriptor2 ??= operator.startsWith("<") ? 0 : 1;
     if (!Number.isSafeInteger(descriptor2) || descriptor2 > 255) this.error("File descriptor must be between 0 and 255");
@@ -6665,29 +6885,40 @@ var Parser = class {
     return { descriptor: descriptor2, operator, target: target.word, line: this.lexer.lineAt(Math.max(target.offset, target.end - 1)), ...(operator === "<&" || operator === ">&") && this.lexer.source[target.end - 1] === "-" ? { move: true } : {}, ...target.document ? { document: target.document } : {} };
   }
 };
-function parseShell(source, depth = 0) {
+function parseShell(source, depth = 0, options3 = {}) {
+  const budget = new ParseBudget(options3.maxParseUnits);
   const warnings = [];
-  const script = parseSource(source, depth, warnings);
+  const script = parseSource(source, depth, warnings, 0, false, budget);
+  budget.admit();
   return { ...script, ...warnings.length ? { warnings } : {} };
 }
-function* hereDocumentWords(document, line, byteLocale2, warnings) {
-  if (document.quoted) yield { offset: document.offset, parts: [{ kind: "text", value: document.body, quoted: true }] };
-  else yield* new Lexer(document.body, document.depth, warnings, line - 1, byteLocale2, line).documentWords();
+function* hereDocumentWords(document, line, byteLocale2, warnings, budget = new ParseBudget()) {
+  if (document.quoted) {
+    budget.admit(2);
+    yield { offset: document.offset, parts: [{ kind: "text", value: document.body, quoted: true }] };
+  } else {
+    budget.admit();
+    yield* new Lexer(budget, document.body, document.depth, warnings, line - 1, byteLocale2, line).documentWords();
+  }
 }
-function parseShellUnit(source, position = 0, byteLocale2 = false) {
+function parseShellUnit(source, position = 0, byteLocale2 = false, budget = new ParseBudget()) {
   const warnings = [];
-  const parser = new Parser(source, 0, warnings, 0, position, byteLocale2);
+  budget.admit();
+  const parser = new Parser(budget, source, 0, warnings, 0, position, byteLocale2);
   const script = parser.script(/* @__PURE__ */ new Set(), true);
   const next = parser.current.end;
   const nul = source.indexOf("\0", position);
   if (nul >= 0 && nul < next) throw new ShellSyntaxError("NUL bytes are not valid shell source", nul);
+  budget.admit(2);
   return { script: { ...script, ...warnings.length ? { warnings } : {} }, next };
 }
-function parseShellInputUnit(source, byteLocale2 = false) {
+function parseShellInputUnit(source, byteLocale2 = false, budget = new ParseBudget()) {
   const warnings = [];
   try {
-    const parser = new Parser(source, 0, warnings, 0, 0, byteLocale2, true);
+    budget.admit();
+    const parser = new Parser(budget, source, 0, warnings, 0, 0, byteLocale2, true);
     const script = parser.script(/* @__PURE__ */ new Set(), true);
+    budget.admit(2);
     return { script: { ...script, ...warnings.length ? { warnings } : {} }, next: parser.current.end };
   } catch (error) {
     if (error instanceof IncompleteShellInput) return void 0;
@@ -6695,8 +6926,9 @@ function parseShellInputUnit(source, byteLocale2 = false) {
     throw error;
   }
 }
-function parseSource(source, depth, warnings, lineOffset = 0, byteLocale2 = false) {
-  const parser = new Parser(source, depth, warnings, lineOffset, void 0, byteLocale2);
+function parseSource(source, depth, warnings, lineOffset, byteLocale2, budget) {
+  budget.admit();
+  const parser = new Parser(budget, source, depth, warnings, lineOffset, void 0, byteLocale2);
   const script = parser.script();
   if (parser.current.kind !== "end") parser.error("Unexpected token");
   return script;
@@ -7101,7 +7333,7 @@ function evaluatePositionalArithmetic(program, options3, evaluate) {
     reserve(bytes2);
     const expanded = chunks.join("");
     options3.checkpoint();
-    return evaluate(prepareArithmetic(expanded));
+    return evaluate(prepareArithmetic(expanded, options3.parseBudget));
   } finally {
     for (let position = admissions.length - 1; position >= 0; position--) admissions[position].release();
     header?.release();
@@ -10063,6 +10295,7 @@ async function matchEre(program, subject, ledger, signal) {
 
 // packages/safe-bash/src/shell/runtime.ts
 var defaultLimits = {
+  maxParseUnits: defaultMaxParseUnits,
   maxInputBytes: 32 * 1024 * 1024,
   maxOutputBytes: 16 * 1024 * 1024,
   maxCommands: 1e4,
@@ -10153,11 +10386,13 @@ var Budget = class {
   constructor(limits, signal) {
     this.limits = limits;
     this.signal = signal ? AbortSignal.any([signal, this.controller.signal]) : this.controller.signal;
+    this.parsing = new ParseBudget(limits.maxParseUnits, this.signal, (error) => this.controller.abort(error));
     this.values = new ValueArena(limits.maxExpansionBytes, limits.maxExpansionFields, () => this.signal.throwIfAborted(), (limit) => this.fail(limit));
     this.#wallClockDeadline = Date.now() + limits.maxWallClockMs;
     this.#armWallClock();
   }
   limits;
+  parsing;
   values;
   commands = 0;
   iterations = 0;
@@ -11297,7 +11532,7 @@ var Runtime = class _Runtime {
     if (shellValueByteLength(value2) > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
     if (name2 === "OPTIND" && state.getopts?.integer && origin !== "arithmetic") {
       try {
-        value2 = String(evaluateArithmetic(prepareArithmetic(shellValueText(value2) || "0"), this.arithmeticVariables(state)));
+        value2 = String(evaluateArithmetic(prepareArithmetic(shellValueText(value2) || "0", this.budget.parsing), this.arithmeticVariables(state), this.budget.parsing));
       } catch (error) {
         this.rethrowArithmeticControl(error);
         throw new ExpansionFailure(message(error));
@@ -12003,6 +12238,7 @@ var Runtime = class _Runtime {
         if (command2.kind === "arithmetic") {
           try {
             return Number(evaluatePositionalArithmetic(command2.expression, {
+              parseBudget: this.budget.parsing,
               positional: state.positional,
               arg0: state.arg0 ?? "virtual-bash",
               owner: arrayStore(state)?.owner,
@@ -12010,7 +12246,7 @@ var Runtime = class _Runtime {
               checkpoint: () => this.signal.throwIfAborted(),
               requireParameter: (name2, value2) => this.requireParameter(value2, name2, state, io),
               limit: () => this.budget.fail("maxExpansionBytes")
-            }, (prepared) => evaluateArithmetic(prepared, this.arithmeticVariables(state, io.diagnosticLine))) === 0n);
+            }, (prepared) => evaluateArithmetic(prepared, this.arithmeticVariables(state, io.diagnosticLine), this.budget.parsing)) === 0n);
           } catch (error) {
             this.rethrowArithmeticControl(error);
             throw new Error(`((: ${message(error)}`);
@@ -12164,7 +12400,7 @@ var Runtime = class _Runtime {
     let words = 0;
     const warnings = [];
     try {
-      for (const word of hereDocumentWords(document, line, byteLocale(state.variables), warnings)) {
+      for (const word of hereDocumentWords(document, line, byteLocale(state.variables), warnings, this.budget.parsing)) {
         this.signal.throwIfAborted();
         for (const warning of warnings.splice(0)) await writeText(io.stderr, `shell: warning: ${warning}
 `);
@@ -13056,7 +13292,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     try {
       do {
         this.signal.throwIfAborted();
-        const unit = parseShellUnit(source, position, byteLocale(state.variables));
+        const unit = parseShellUnit(source, position, byteLocale(state.variables), this.budget.parsing);
         for (const warning of unit.script.warnings ?? []) await writeText(io.stderr, `${io.scriptName}: warning: ${warning}
 `);
         if (unit.script.lists.length) {
@@ -13093,7 +13329,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       if (bytes2) source += this.sourceText(bytes2, io.scriptName ?? "shell");
       const unitIO = { ...io, diagnosticOffset: offset };
       try {
-        const unit = eof ? parseShellUnit(source, 0, byteLocale(state.variables)) : parseShellInputUnit(source, byteLocale(state.variables));
+        const unit = eof ? parseShellUnit(source, 0, byteLocale(state.variables), this.budget.parsing) : parseShellInputUnit(source, byteLocale(state.variables), this.budget.parsing);
         if (unit) {
           for (const warning of unit.script.warnings ?? []) await writeText(io.stderr, `${io.scriptName}: warning: ${warning}
 `);
@@ -13357,7 +13593,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       let position = 0;
       do {
         this.signal.throwIfAborted();
-        const unit = parseShellUnit(source, position, byteLocale(context.env));
+        const unit = parseShellUnit(source, position, byteLocale(context.env), this.budget.parsing);
         units.push(unit.script);
         position = unit.next;
       } while (position < source.length);
@@ -13390,7 +13626,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     try {
       do {
         this.signal.throwIfAborted();
-        const unit = parseShellUnit(source, position, byteLocale(state.variables));
+        const unit = parseShellUnit(source, position, byteLocale(state.variables), this.budget.parsing);
         for (const warning of unit.script.warnings ?? []) await writeText(io.stderr, `${io.scriptName ?? "shell"}: warning: ${warning}
 `);
         if (unit.script.lists.length) {
@@ -13704,7 +13940,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     for (let index = offset; index < args.length; index++) {
       this.signal.throwIfAborted();
       try {
-        value2 = evaluateArithmetic(prepareArithmetic(args[index]), variables);
+        value2 = evaluateArithmetic(prepareArithmetic(args[index], this.budget.parsing), variables, this.budget.parsing);
       } catch (error) {
         this.rethrowArithmeticControl(error);
         throw new Error(`let: ${message(error)}`);
@@ -14369,8 +14605,10 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
           else {
             let index;
             try {
-              index = numericIndex(literalIndex(selector, 0));
-            } catch {
+              index = numericIndex(literalIndex(selector, 0, this.budget.parsing));
+            } catch (error) {
+              this.signal.throwIfAborted();
+              if (error instanceof ShellLimitError) throw error;
               await this.diagnostic(context, "indexed array: unsupported subscript");
               status = 2;
               continue;
@@ -14574,6 +14812,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     if (part.kind === "arithmetic") {
       try {
         return String(evaluatePositionalArithmetic(part.expression, {
+          parseBudget: this.budget.parsing,
           positional: state.positional,
           arg0: state.arg0 ?? "virtual-bash",
           owner: arrayStore(state)?.owner,
@@ -14581,7 +14820,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
           checkpoint: () => this.signal.throwIfAborted(),
           requireParameter: (name2, value3) => this.requireParameter(value3, name2, state, io, part.line),
           limit: () => this.budget.fail("maxExpansionBytes")
-        }, (prepared) => evaluateArithmetic(prepared, this.arithmeticVariables(state, io.diagnosticLine ?? part.line))));
+        }, (prepared) => evaluateArithmetic(prepared, this.arithmeticVariables(state, io.diagnosticLine ?? part.line), this.budget.parsing)));
       } catch (error) {
         this.rethrowArithmeticControl(error);
         throw new ExpansionFailure(message(error), io.diagnosticLine ?? part.line);
@@ -14720,7 +14959,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       }
       this.signal.throwIfAborted();
       try {
-        return { value: evaluateArithmetic(prepareArithmetic(source), variables), source };
+        return { value: evaluateArithmetic(prepareArithmetic(source, this.budget.parsing), variables, this.budget.parsing), source };
       } catch (error) {
         this.rethrowArithmeticControl(error);
         throw new ExpansionFailure(`${part.name}: ${message(error)}`, line);
@@ -14850,29 +15089,67 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
     const arrayOwned = word.parts.some((part) => part.kind === "variable" && (getArraySelector(part) !== void 0 || arrayStore(state)?.get(part.name) !== void 0));
     const owner = arrayOwned ? requireArrays(state).owner : void 0;
     const holding = owner?.hold();
+    const scratch = !owner && split && state.variables.IFS !== "" && word.parts.some((part) => !part.quoted && part.kind !== "text") ? this.budget.values.scope() : void 0;
     try {
       if (owner) await this.prepareArrayObservers(state, owner);
       owner?.reserve({ metadata: 128 + word.parts.length * 32, allocatedSlots: word.parts.length + 1, work: word.parts.length + 5 });
-      const fields = [{ value: "", fragments: [], bytes: false, pattern: "", present: false }];
+      scratch?.reserve(word.parts.length * 32, 0);
+      const fields = [];
+      const addField = () => {
+        if (fields.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
+        scratch?.reserve(32, 0);
+        owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
+        fields.push({ fragments: [], bytes: false, patterns: void 0, present: false });
+      };
+      addField();
       let expansionBytes = 0;
       const append = (value2, glob, present) => {
         const text = shellValueText(value2);
         const size = shellValueByteLength(value2);
         if (size > this.budget.limits.maxExpansionBytes - expansionBytes) this.budget.fail("maxExpansionBytes");
         expansionBytes += size;
-        regexAppend?.(text, !glob);
         const field = fields.at(-1);
-        if (owner) owner.reserve({ payload: exactSum(import_buffer.Buffer.byteLength(field.value) + size, import_buffer.Buffer.byteLength(field.pattern) + (glob ? size : size * 2)), metadata: 64, work: text.length + 8 });
+        let escapes = 0;
+        if (!glob) {
+          const special2 = conditionalPattern ? "\\*?[]-^()|+!@" : "\\*?[]-^";
+          for (const character of text) if (special2.includes(character)) escapes++;
+        }
+        scratch?.reserve(32, 0);
+        if (owner) owner.reserve({ payload: size + (escapes ? size + escapes : 0), metadata: 64, work: text.length + 8 });
+        if (escapes) {
+          scratch?.reserve((field.patterns ? 32 : 32 * (field.fragments.length + 1)) + (text.length + escapes) * 2, 0);
+          field.patterns ??= field.fragments.map(shellValueText);
+          field.patterns.push(text.replace(conditionalPattern ? /[\\*?[\]\-^()|+!@]/gu : /[\\*?[\]\-^]/gu, "\\$&"));
+        } else if (field.patterns) {
+          scratch?.reserve(32, 0);
+          field.patterns.push(text);
+        }
         if (typeof value2 !== "string" || field.bytes) {
-          io[valueScope]?.reserve(32 * (field.bytes ? 1 : field.fragments.length + 1), field.bytes ? 1 : field.fragments.length + 1);
+          if (!scratch) io[valueScope]?.reserve(32 * (field.bytes ? 1 : field.fragments.length + 1), field.bytes ? 1 : field.fragments.length + 1);
           if (typeof value2 !== "string") io[valueScope]?.hold(value2);
           field.bytes = true;
         }
+        regexAppend?.(text, !glob);
         field.fragments.push(value2);
-        field.value += text;
-        field.pattern += glob ? text : text.replace(conditionalPattern ? /[\\*?[\]\-^()|+!@]/gu : /[\\*?[\]\-^]/gu, "\\$&");
         field.present ||= present;
       };
+      const appendSplit = async (value2) => {
+        const separators = state.variables.IFS ?? " 	\n";
+        let boundary = false;
+        for await (const piece of this.splitValue(value2, separators, io, scratch)) {
+          if (typeof piece === "string" && separators.includes(piece)) {
+            if (!" 	\n".includes(piece)) {
+              fields.at(-1).present = true;
+              addField();
+            } else if (fields.at(-1).present) boundary = true;
+          } else {
+            if (boundary) addField();
+            boundary = false;
+            append(piece, true, true);
+          }
+        }
+        if (boundary) addField();
+      };
       const parts = word.parts.map((part) => ({ part, splitText: false }));
       for (let index = 0; index < parts.length; index++) {
         const { part, splitText } = parts[index];
@@ -14881,6 +15158,7 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
           const value2 = this.variable(state, part.name);
           const missing = value2 === void 0 || part.operator.startsWith(":") && value2 === "";
           if (part.operator.endsWith("+") ? !missing : missing) {
+            scratch?.reserve(part.alternate.parts.length * 32, 0);
             const alternate = part.alternate.parts.map((entry) => ({ part: copyArraySelector(entry, { ...entry, quoted: entry.quoted || part.quoted }), splitText: true }));
             if (!alternate.length && part.quoted) append("", false, true);
             parts.splice(index + 1, 0, ...alternate);
@@ -14891,37 +15169,10 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
         if (part.kind === "variable" && selector?.kind === "members" && !part.length && split && (!part.quoted || selector.separator === "@")) {
           const members = await this.arrayMembers(part.name, state);
           for (let position = 0; position < members.length; position++) {
-            if (position > 0) {
-              owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
-              fields.push({ value: "", fragments: [], bytes: false, pattern: "", present: false });
-            }
+            if (position > 0) addField();
             const value2 = members[position];
             if (part.quoted || state.variables.IFS === "") append(value2, !part.quoted, part.quoted || value2.length > 0);
-            else {
-              const separators = state.variables.IFS ?? " 	\n";
-              let boundary = false;
-              for (const character of value2) {
-                if (separators.includes(character)) {
-                  if (!/[ \t\n]/u.test(character)) {
-                    fields.at(-1).present = true;
-                    owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
-                    fields.push({ value: "", fragments: [], bytes: false, pattern: "", present: false });
-                  } else if (fields.at(-1).present) boundary = true;
-                } else {
-                  if (boundary) {
-                    owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
-                    fields.push({ value: "", fragments: [], bytes: false, pattern: "", present: false });
-                  }
-                  boundary = false;
-                  append(character, true, true);
-                }
-                await owner.ledger.checkpoint(this.signal);
-              }
-              if (boundary) {
-                owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
-                fields.push({ value: "", fragments: [], bytes: false, pattern: "", present: false });
-              }
-            }
+            else await appendSplit(value2);
           }
         } else if (part.kind === "text" && !splitText) {
           let value2 = invokedValues.get(part) ?? part.byteValue ?? part.value;
@@ -14929,32 +15180,14 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
           append(value2, !part.quoted, quotedPresence || shellValueByteLength(value2) > 0);
         } else if (part.kind === "variable" && part.name === "@" && part.quoted && !part.operator && split) {
           for (let position = 0; position < state.positional.length; position++) {
-            if (position > 0) fields.push({ value: "", fragments: [], bytes: false, pattern: "", present: false });
+            if (position > 0) addField();
             append(stateMonitor(state)?.positionals.get(String(position), state.positional[position]) ?? state.positional[position], false, true);
           }
           if (state.positional.length === 0 && word.parts.every((entry) => entry.kind === "text" && entry.value === "" || entry === part)) fields[0].present = false;
         } else {
           const value2 = part.kind === "text" ? part.byteValue ?? part.value : await this.valuePart(part, state, io, hereString);
           if (part.quoted || !split || state.variables.IFS === "") append(value2, !part.quoted, quotedPresence || !split || shellValueByteLength(value2) > 0);
-          else {
-            const separators = state.variables.IFS ?? " 	\n";
-            let boundary = false;
-            const pieces = this.splitValue(value2, separators, io);
-            for (const character of pieces) {
-              const text = shellValueText(character);
-              if (typeof character === "string" && separators.includes(character)) {
-                if (!/[ \t\n]/u.test(text)) {
-                  fields.at(-1).present = true;
-                  fields.push({ value: "", fragments: [], bytes: false, pattern: "", present: false });
-                } else if (fields.at(-1).present) boundary = true;
-              } else {
-                if (boundary) fields.push({ value: "", fragments: [], bytes: false, pattern: "", present: false });
-                boundary = false;
-                append(character, true, true);
-              }
-            }
-            if (boundary) fields.push({ value: "", fragments: [], bytes: false, pattern: "", present: false });
-          }
+          else await appendSplit(value2);
         }
         if (fields.length > this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
         if (owner) await owner.ledger.checkpoint(this.signal);
@@ -14963,14 +15196,23 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       let resultBytes = 0;
       for (const field of fields) {
         if (!field.present && split) continue;
+        if (scratch && field.fragments.length > 1 && !field.bytes) scratch.reserve(field.fragments.reduce((bytes2, value2) => bytes2 + shellValueText(value2).length * 2, 0), 0);
         const assembled = concatShellValues(field.fragments, io[valueScope]);
         const projection = shellValueText(assembled);
-        const expanded = split ? await this.glob(projection, field.pattern, state) : [pattern ? field.pattern : projection];
+        if (field.bytes && field.fragments.length > 1 && !field.patterns) {
+          scratch?.reserve(field.fragments.length * 32, 0);
+          field.patterns = field.fragments.map(shellValueText);
+        }
+        if (scratch && field.patterns && field.patterns.length > 1) scratch.reserve(field.patterns.reduce((bytes2, text) => bytes2 + text.length * 2, 0), 0);
+        const fieldPattern = field.patterns ? field.patterns.join("") : projection;
+        const expanded = split ? await this.glob(projection, fieldPattern, state) : [pattern ? fieldPattern : projection];
         for (const text of expanded) {
+          if (result.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
           const value2 = !pattern && expanded.length === 1 && text === projection ? assembled : text;
           const size = shellValueByteLength(value2);
           if (size > this.budget.limits.maxExpansionBytes - resultBytes) this.budget.fail("maxExpansionBytes");
           resultBytes += size;
+          scratch?.reserve(32, 0);
           owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
           result.push(value2);
         }
@@ -14978,17 +15220,50 @@ ${prefix2} line ${offset + line}: \`${source.split("\n")[line - 1] ?? ""}'
       }
       return result;
     } finally {
+      scratch?.close();
       holding?.release();
     }
   }
-  *splitValue(value2, separators, io) {
+  splitWork;
+  async *splitValue(value2, separators, io, scratch) {
+    this.budget.cpuCheckpoint();
+    const work = this.splitWork ??= { scanned: 0 };
     if (typeof value2 === "string" || Array.from(separators).some((character) => character.charCodeAt(0) > 127)) {
-      yield* shellValueText(value2);
+      const text = shellValueText(value2);
+      const slice = (start3, end) => {
+        if (start3 === 0 && end === text.length) return text;
+        scratch?.reserve((end - start3) * 2, 0);
+        return text.slice(start3, end);
+      };
+      let start2 = 0;
+      for (let index = 0; index < text.length; ) {
+        const character = String.fromCodePoint(text.codePointAt(index));
+        const end = index + character.length;
+        if (separators.includes(character)) {
+          if (start2 < index) yield slice(start2, index);
+          yield character;
+          start2 = end;
+        } else if (end - start2 >= 4096) {
+          yield slice(start2, end);
+          start2 = end;
+        }
+        work.scanned += character.length;
+        index = end;
+        if (work.scanned >= 4096) {
+          work.scanned = 0;
+          await yieldTurn(this.signal);
+        }
+      }
+      if (start2 < text.length) yield slice(start2, text.length);
       return;
     }
     const bytes2 = shellValueBytes(value2, io[valueScope]);
     let start = 0;
     for (let index = 0; index < bytes2.length; index++) {
+      if (++work.scanned >= 4096) {
+        work.scanned = 0;
+        await yieldTurn(this.signal);
+      }
       const byte = bytes2[index];
       if (byte > 127 || !separators.includes(String.fromCharCode(byte))) continue;
       if (start < index) yield shellValueFromBytes(bytes2.subarray(start, index), io[valueScope]);
@@ -15679,7 +15954,7 @@ var Shell = class {
     let failed = false;
     try {
       try {
-        let unit = parseShellUnit(source, 0, byteLocale({ ...this.#options.env, ...options3.env }));
+        let unit = parseShellUnit(source, 0, byteLocale({ ...this.#options.env, ...options3.env }), budget.parsing);
         stdin = new ShellInput(typeof options3.stdin === "string" || options3.stdin instanceof Uint8Array ? toByteSource(options3.stdin) : options3.stdin ?? toByteSource(""), budget);
         io.stdin = stdin;
         await interruptible(this.#ready, budget.signal);
@@ -15736,7 +16011,7 @@ var Shell = class {
           }
           if (unit.next >= source.length) break;
           budget.signal.throwIfAborted();
-          unit = parseShellUnit(source, unit.next, byteLocale(state.variables));
+          unit = parseShellUnit(source, unit.next, byteLocale(state.variables), budget.parsing);
         }
       } catch (error) {
         if (!(error instanceof ShellSyntaxError)) throw error;
@@ -15813,6 +16088,7 @@ shell: -c: line ${line}: \`${source.split("\n")[line - 1] ?? ""}'
 // packages/safe-bash/src/shell/worker-limits.ts
 init_platform();
 var cloudflareWorkerLimits = Object.freeze({
+  maxParseUnits: 65536,
   maxInputBytes: 4 * 1024 * 1024,
   maxOutputBytes: 4 * 1024 * 1024,
   maxCommands: 1e3,
@@ -18696,7 +18972,7 @@ function descriptor(value2, limits) {
   for (const flag of flags) if (typeof value2[flag] !== "boolean") fail("protocol", `invalid ${flag} flag`);
   if (kind.value === "rg" && !["sensitive", "insensitive", "smart"].includes(value2.case)) fail("protocol", "invalid case flag");
   if (value2.word || kind.value === "grep" && value2.insensitive || kind.value === "rg" && value2.case !== "sensitive") fail("unsupported", "only case-sensitive, non-word selection is supported");
-  if (kind.value === "rg" && !value2.fixed) fail("unsupported", "rg regex and Unicode modes are unsupported; use fixed ASCII patterns");
+  if (kind.value === "rg" && !value2.fixed) fail("unsupported", "rg regex modes are unsupported; use fixed UTF-8 patterns");
   array(value2.patterns, limits.maxPatterns, "pattern");
   let bytes2 = 0;
   for (let index = 0; index < value2.patterns.length; index++) {
@@ -18724,7 +19000,7 @@ function admit(input3, limits, signal) {
     bytes2 += length;
   }
   const ledger = new EreLedger({ maxExpansionBytes: 1048576, maxExpansionFields: 8192 }, {
-    patternBytes: limits.maxPatternBytes + 4,
+    patternBytes: limits.maxPatternBytes + (selected.fixed ? 0 : 4),
     subjectBytes: limits.maxInputBytes,
     work: limits.maxWork,
     allocationUnits: limits.maxAllocationUnits,
@@ -18770,8 +19046,116 @@ async function admitBre(pattern, ledger, signal) {
     }
   }
 }
+async function validateUtf8(input3, ledger, signal) {
+  for (let index = 0; index < input3.length; ) {
+    const first = typeof input3 === "string" ? input3.charCodeAt(index) : input3[index];
+    const width = first < 128 ? 1 : first >= 194 && first <= 223 ? 2 : first >= 224 && first <= 239 ? 3 : first >= 240 && first <= 244 ? 4 : 0;
+    ledger.charge("work", Math.max(width, 1), signal);
+    if (first === 0 || width === 0 || width > input3.length - index) fail("unsupported", "literal patterns and subjects require valid non-NUL UTF-8 bytes");
+    for (let continuation = 1; continuation < width; continuation++) {
+      const byte = typeof input3 === "string" ? input3.charCodeAt(index + continuation) : input3[index + continuation];
+      if (byte < 128 || byte > 191 || continuation === 1 && (first === 224 && byte < 160 || first === 237 && byte > 159 || first === 240 && byte < 144 || first === 244 && byte > 143)) fail("unsupported", "literal patterns and subjects require valid non-NUL UTF-8 bytes");
+    }
+    index += width;
+    await ledger.checkpoint(signal);
+  }
+}
+async function literalBytes(pattern, selected, ledger, signal) {
+  const { kind } = selected;
+  let length = 0;
+  if (kind === "grep") {
+    await validateUtf8(pattern, ledger, signal);
+    length = pattern.length;
+  } else {
+    for (let index = 0; index < pattern.length; ) {
+      const scalar = pattern.codePointAt(index);
+      const units = scalar > 65535 ? 2 : 1;
+      ledger.charge("work", units, signal);
+      if (scalar === 0 || scalar >= 55296 && scalar <= 57343) fail("unsupported", "rg literal patterns require non-NUL Unicode scalars for UTF-8");
+      if (scalar === 10 && selected.kind === "rg" && !selected.nullData) fail("unsupported", "rg multiline matching is unsupported");
+      length += scalar < 128 ? 1 : scalar < 2048 ? 2 : scalar < 65536 ? 3 : 4;
+      index += units;
+      await ledger.checkpoint(signal);
+    }
+  }
+  ledger.charge("patternBytes", length, signal);
+  ledger.charge("allocationUnits", length + 1, signal);
+  const bytes2 = new Uint8Array(length);
+  let offset = 0;
+  for (let index = 0; index < pattern.length; ) {
+    const scalar = kind === "grep" ? pattern.charCodeAt(index) : pattern.codePointAt(index);
+    const width = kind === "grep" || scalar < 128 ? 1 : scalar < 2048 ? 2 : scalar < 65536 ? 3 : 4;
+    ledger.charge("work", width, signal);
+    if (width === 1) bytes2[offset++] = scalar;
+    else {
+      bytes2[offset++] = width === 2 ? 192 | scalar >> 6 : width === 3 ? 224 | scalar >> 12 : 240 | scalar >> 18;
+      if (width === 4) bytes2[offset++] = 128 | scalar >> 12 & 63;
+      if (width >= 3) bytes2[offset++] = 128 | scalar >> 6 & 63;
+      bytes2[offset++] = 128 | scalar & 63;
+    }
+    index += kind === "rg" && scalar > 65535 ? 2 : 1;
+    await ledger.checkpoint(signal);
+  }
+  return bytes2;
+}
+async function compileLiteral(bytes2, ledger, signal) {
+  ledger.charge("states", bytes2.length, signal);
+  ledger.charge("allocationUnits", bytes2.length * 4 + 3, signal);
+  const fallback = new Uint32Array(bytes2.length);
+  for (let index = 1, prefix2 = 0; index < bytes2.length; ) {
+    ledger.charge("work", 1, signal);
+    if (bytes2[index] === bytes2[prefix2]) fallback[index++] = ++prefix2;
+    else if (prefix2 > 0) prefix2 = fallback[prefix2 - 1];
+    else index++;
+    await ledger.checkpoint(signal);
+  }
+  return { bytes: bytes2, fallback };
+}
+async function literalStart(program, subject, whole, ledger, signal) {
+  const { bytes: bytes2, fallback } = program;
+  ledger.charge("work", 1, signal);
+  await ledger.checkpoint(signal);
+  if (whole && bytes2.length !== subject.length || bytes2.length > subject.length) return -1;
+  if (bytes2.length === 0) return 0;
+  for (let index = 0, prefix2 = 0; index < subject.length; ) {
+    ledger.charge("work", 1, signal);
+    if (subject[index] === bytes2[prefix2]) {
+      index++;
+      if (++prefix2 === bytes2.length) return index - prefix2;
+    } else if (prefix2 > 0) prefix2 = fallback[prefix2 - 1];
+    else index++;
+    await ledger.checkpoint(signal);
+  }
+  return -1;
+}
+async function executeLiteral(input3, signal) {
+  const { descriptor: selected, rows, ledger } = input3;
+  const programs2 = [];
+  for (const pattern of selected.patterns) {
+    programs2.push(await compileLiteral(await literalBytes(pattern, selected, ledger, signal), ledger, signal));
+  }
+  const results = [];
+  for (const row of rows) {
+    await validateUtf8(row.bytes, ledger, signal);
+    let start = -1;
+    let end = -1;
+    for (const program of programs2) {
+      const candidate = await literalStart(program, row.bytes, selected.whole, ledger, signal);
+      if (candidate < 0) continue;
+      if (start < 0 || candidate < start) {
+        start = candidate;
+        end = start + program.bytes.length;
+      }
+      if (selected.kind === "grep") break;
+    }
+    signal.throwIfAborted();
+    results.push(start < 0 ? new Float64Array() : new Float64Array([start, end]));
+  }
+  return { id: input3.id, results };
+}
 async function execute2(input3, signal) {
   const { descriptor: selected, rows, ledger } = input3;
+  if (selected.fixed) return executeLiteral(input3, signal);
   const programs2 = [];
   for (const pattern of selected.patterns) {
     if (selected.kind === "grep" && !selected.fixed && !selected.extended) await admitBre(pattern, ledger, signal);