@poe-platform/safe-bash 0.1.745 → 0.1.747

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

@@ -12,7 +12,7 @@ import {
   parseDate,
   prCommands,
   settings
-} from "./chunks/chunk-I3DOFJSJ.js";
+} from "./chunks/chunk-MUWJPSGN.js";
 import {
   createTsortCommand,
   createTsortCommands,
@@ -310,7 +310,7 @@ __export(core_browser_exports, {
   EreSyntaxError: () => errors_exports2.EreSyntaxError,
   EreUnsupportedError: () => errors_exports2.EreUnsupportedError,
   EreUsageUnknownError: () => errors_exports2.EreUsageUnknownError,
-  FsError: () => FsError60,
+  FsError: () => FsError61,
   MdqError: () => MdqError,
   MemoryFileSystem: () => MemoryFileSystem,
   MountFileSystem: () => MountFileSystem,
@@ -1310,6 +1310,7 @@ async function parsePrintfDirective(format3, start, signal) {
 }
 
 // packages/safe-bash/src/commands/basic.ts
+var utf8Encoder = new TextEncoder();
 var defaultEchoExecutors = /* @__PURE__ */ new WeakSet();
 function basicCommands() {
   return [
@@ -1392,7 +1393,7 @@ function basicCommands() {
         await output(context2, result + (parsed.flags.has("z") ? "\0" : "\n"));
       }
       return { exitCode: 0 };
-    }),
+    }, 1, 1),
     define("dirname", async (context2) => {
       const parsed = options(context2.args, "z", { zero: "z" });
       requireOperands(parsed.operands);
@@ -1403,7 +1404,7 @@ function basicCommands() {
         await output(context2, parent.slice(0, end) + (parsed.flags.has("z") ? "\0" : "\n"));
       }
       return { exitCode: 0 };
-    }),
+    }, 1, 1),
     printfCommand
   ].map((command7) => {
     if (command7.name === "echo") defaultEchoExecutors.add(command7.execute);
@@ -1617,6 +1618,72 @@ function tryFastPrintf(args) {
           offset += 2;
           continue;
         }
+        if (next === 97) {
+          result += "\x07";
+          offset += 2;
+          continue;
+        }
+        if (next === 98) {
+          result += "\b";
+          offset += 2;
+          continue;
+        }
+        if (next === 102) {
+          result += "\f";
+          offset += 2;
+          continue;
+        }
+        if (next === 118) {
+          result += "\v";
+          offset += 2;
+          continue;
+        }
+        if (next === 101 || next === 69) {
+          result += "\x1B";
+          offset += 2;
+          continue;
+        }
+        if (next === 34) {
+          result += '"';
+          offset += 2;
+          continue;
+        }
+        if (next === 39) {
+          result += "'";
+          offset += 2;
+          continue;
+        }
+        if (next >= 48 && next <= 55) {
+          let cur2 = offset + 1;
+          const end = Math.min(format3.length, cur2 + 3);
+          let val = 0;
+          while (cur2 < end && format3.charCodeAt(cur2) >= 48 && format3.charCodeAt(cur2) <= 55) {
+            val = val * 8 + (format3.charCodeAt(cur2++) - 48);
+          }
+          const byte = val & 255;
+          if (byte === 0 || byte >= 128) return void 0;
+          result += String.fromCharCode(byte);
+          offset = cur2;
+          continue;
+        }
+        if (next === 120) {
+          let cur2 = offset + 2;
+          const end = Math.min(format3.length, cur2 + 2);
+          let val = 0;
+          let digits = 0;
+          while (cur2 < end) {
+            const d = format3.charCodeAt(cur2);
+            const n = d >= 48 && d <= 57 ? d - 48 : d >= 65 && d <= 70 ? d - 55 : d >= 97 && d <= 102 ? d - 87 : -1;
+            if (n < 0) break;
+            val = val * 16 + n;
+            digits++;
+            cur2++;
+          }
+          if (digits === 0 || val === 0 || val >= 128) return void 0;
+          result += String.fromCharCode(val);
+          offset = cur2;
+          continue;
+        }
         return void 0;
       }
       if (ch !== 37) {
@@ -1674,12 +1741,29 @@ function tryFastPrintf(args) {
       if (conv === 115 && !zeroPad) {
         const rawVal = args[argument2++] ?? "";
         if (rawVal.includes("\0")) return void 0;
+        let val = rawVal;
+        let valByteLen = rawVal.length;
         if (precision >= 0 || width > 0) {
-          for (let i = 0; i < rawVal.length; i++) if (rawVal.charCodeAt(i) >= 128) return void 0;
+          let isAscii = true;
+          for (let i = 0; i < rawVal.length; i++) {
+            if (rawVal.charCodeAt(i) >= 128) {
+              isAscii = false;
+              break;
+            }
+          }
+          if (isAscii) {
+            if (precision >= 0 && precision < rawVal.length) {
+              val = rawVal.slice(0, precision);
+              valByteLen = val.length;
+            }
+          } else if (precision < 0) {
+            valByteLen = utf8Encoder.encode(rawVal).byteLength;
+          } else {
+            return void 0;
+          }
         }
-        const val = precision >= 0 ? rawVal.slice(0, precision) : rawVal;
-        if (width > val.length) {
-          const pad = " ".repeat(width - val.length);
+        if (width > valByteLen) {
+          const pad = " ".repeat(width - valByteLen);
           result += leftAlign ? val + pad : pad + val;
         } else {
           result += val;
@@ -1687,6 +1771,21 @@ function tryFastPrintf(args) {
         offset = cur + 1;
         continue;
       }
+      if (conv === 99 && !zeroPad) {
+        const rawVal = args[argument2++] ?? "";
+        if (rawVal.length === 0) return void 0;
+        const c0 = rawVal.charCodeAt(0);
+        if (c0 === 0 || c0 >= 128) return void 0;
+        const ch0 = rawVal[0];
+        if (width > 1) {
+          const pad = " ".repeat(width - 1);
+          result += leftAlign ? ch0 + pad : pad + ch0;
+        } else {
+          result += ch0;
+        }
+        offset = cur + 1;
+        continue;
+      }
       if (conv === 100 || conv === 105) {
         const rawVal = args[argument2++] ?? "0";
         const val = rawVal.length === 0 ? "0" : rawVal;
@@ -1765,6 +1864,115 @@ function tryFastPrintf(args) {
   } while (argument2 < args.length);
   return result;
 }
+function extractFastPrintfSpecifiers(format3) {
+  if (format3.length > 256) return void 0;
+  const specs = [];
+  for (let offset = 0; offset < format3.length; ) {
+    const ch = format3.charCodeAt(offset);
+    if (ch === 92) {
+      const next = format3.charCodeAt(offset + 1);
+      if (next === 110 || next === 116 || next === 114 || next === 92 || next === 97 || next === 98 || next === 102 || next === 118 || next === 101 || next === 69 || next === 34 || next === 39) {
+        offset += 2;
+        continue;
+      }
+      if (next >= 48 && next <= 55) {
+        let cur2 = offset + 1;
+        const end = Math.min(format3.length, cur2 + 3);
+        let val = 0;
+        while (cur2 < end && format3.charCodeAt(cur2) >= 48 && format3.charCodeAt(cur2) <= 55) {
+          val = val * 8 + (format3.charCodeAt(cur2++) - 48);
+        }
+        if ((val & 255) === 0 || (val & 255) >= 128) return void 0;
+        offset = cur2;
+        continue;
+      }
+      if (next === 120) {
+        let cur2 = offset + 2;
+        const end = Math.min(format3.length, cur2 + 2);
+        let val = 0;
+        let digits = 0;
+        while (cur2 < end) {
+          const d = format3.charCodeAt(cur2);
+          const n = d >= 48 && d <= 57 ? d - 48 : d >= 65 && d <= 70 ? d - 55 : d >= 97 && d <= 102 ? d - 87 : -1;
+          if (n < 0) break;
+          val = val * 16 + n;
+          digits++;
+          cur2++;
+        }
+        if (digits === 0 || val === 0 || val >= 128) return void 0;
+        offset = cur2;
+        continue;
+      }
+      return void 0;
+    }
+    if (ch !== 37) {
+      offset++;
+      continue;
+    }
+    const spec = format3.charCodeAt(offset + 1);
+    if (spec === 37) {
+      offset += 2;
+      continue;
+    }
+    let cur = offset + 1;
+    let leftAlign = false;
+    let zeroPad = false;
+    while (cur < format3.length) {
+      const fc = format3.charCodeAt(cur);
+      if (fc === 45) {
+        leftAlign = true;
+        cur++;
+      } else if (fc === 48) {
+        zeroPad = true;
+        cur++;
+      } else break;
+    }
+    if (leftAlign) zeroPad = false;
+    let width = 0;
+    while (cur < format3.length) {
+      const dc = format3.charCodeAt(cur);
+      if (dc < 48 || dc > 57) break;
+      width = width * 10 + (dc - 48);
+      if (width > 128) return void 0;
+      cur++;
+    }
+    let precision = -1;
+    if (format3.charCodeAt(cur) === 46) {
+      cur++;
+      precision = 0;
+      while (cur < format3.length) {
+        const dc = format3.charCodeAt(cur);
+        if (dc < 48 || dc > 57) break;
+        precision = precision * 10 + (dc - 48);
+        if (precision > 128) return void 0;
+        cur++;
+      }
+    }
+    const conv = format3.charCodeAt(cur);
+    if (conv === 115 && !zeroPad) {
+      specs.push(precision < 0 ? "s" : "s_prec");
+      offset = cur + 1;
+      continue;
+    }
+    if (conv === 99 && !zeroPad) {
+      specs.push("c");
+      offset = cur + 1;
+      continue;
+    }
+    if (conv === 100 || conv === 105) {
+      specs.push("d");
+      offset = cur + 1;
+      continue;
+    }
+    if (conv === 120 || conv === 88 || conv === 111 || conv === 117) {
+      specs.push("u");
+      offset = cur + 1;
+      continue;
+    }
+    return void 0;
+  }
+  return specs;
+}
 var printfCommand = define("printf", formatPrintf, 1, 1);
 
 // packages/safe-bash/src/commands/filesystem.ts
@@ -7759,7 +7967,7 @@ async function executeHeadTailSlow(name2, maxTailFollowHandles, context2) {
 }
 function headTail(name2, maxTailFollowHandles = Infinity) {
   return define(name2, (context2) => {
-    if (name2 === "head" || name2 === "tail") {
+    if (name2 === "head") {
       const a = context2.args;
       let fastCount = -1;
       if (a.length === 0) {
@@ -7790,55 +7998,13 @@ function headTail(name2, maxTailFollowHandles = Infinity) {
         fastCount = n;
       }
       if (fastCount >= 0) {
-        if (name2 === "head") {
-          (0, command_requirements_exports.assertCommandRequirements)(context2, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
-          try {
-            const p = prefixSyncOrAsync(context2, input(context2, "-"), fastCount, false, false, 10);
-            if (p === void 0) return RESOLVED_EXIT_ZERO;
-            return finishHeadTailPromise(context2, p);
-          } catch (error) {
-            return diagnostic(context2, error).then(RETURN_EXIT_ONE);
-          }
-        } else {
-          const req = assertInputRequirements(context2, SINGLE_STDIN_OPERAND);
-          if (!req) {
-            (0, command_requirements_exports.assertCommandRequirements)(context2, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
-            const iter = input(context2, "-")[Symbol.asyncIterator]();
-            if (typeof iter.tryNextSync === "function") {
-              try {
-                const res1 = iter.tryNextSync();
-                if (res1 !== void 0) {
-                  if (res1.done) return RESOLVED_EXIT_ZERO;
-                  const chunk = res1.value;
-                  const res2 = iter.tryNextSync();
-                  if (res2 !== void 0 && res2.done && chunk.length <= bufferLimit) {
-                    if (fastCount === 0 || chunk.length === 0) return RESOLVED_EXIT_ZERO;
-                    let pos = chunk[chunk.length - 1] === 10 ? chunk.length - 2 : chunk.length - 1;
-                    let startIdx = 0;
-                    for (let rem = fastCount; rem > 0; rem--) {
-                      if (pos < 0) {
-                        startIdx = 0;
-                        break;
-                      }
-                      const nl = chunk.lastIndexOf(10, pos);
-                      if (nl === -1) {
-                        startIdx = 0;
-                        break;
-                      }
-                      startIdx = nl + 1;
-                      pos = nl - 1;
-                    }
-                    const slice = startIdx === 0 ? chunk : chunk.subarray(startIdx);
-                    const p = output(context2, slice);
-                    if (isSyncResolved(p)) return RESOLVED_EXIT_ZERO;
-                    return finishHeadTailPromise(context2, p);
-                  }
-                }
-              } catch (error) {
-                return diagnostic(context2, error).then(RETURN_EXIT_ONE);
-              }
-            }
-          }
+        (0, command_requirements_exports.assertCommandRequirements)(context2, inspectedInputRequirements, STDIN_REQUIREMENT_MODES);
+        try {
+          const p = prefixSyncOrAsync(context2, input(context2, "-"), fastCount, false, false, 10);
+          if (p === void 0) return RESOLVED_EXIT_ZERO;
+          return finishHeadTailPromise(context2, p);
+        } catch (error) {
+          return diagnostic(context2, error).then(RETURN_EXIT_ONE);
         }
       }
     }
@@ -10685,6 +10851,7 @@ async function executeUniqGeneral(context2, preReadSource) {
   const onlyRepeated = parsed.flags.has("d");
   const onlyUnique = parsed.flags.has("u");
   const identityKey = skipFields === 0 && skipCharacters === 0 && width === Infinity && !ignoreCase;
+  const uniqDecoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
   const key = (bytes2) => {
     if (identityKey) return bytes2;
     let offset = 0;
@@ -10692,8 +10859,15 @@ async function executeUniqGeneral(context2, preReadSource) {
       while (offset < bytes2.length && (bytes2[offset] === 32 || bytes2[offset] === 9)) offset++;
       while (offset < bytes2.length && bytes2[offset] !== 32 && bytes2[offset] !== 9) offset++;
     }
-    offset += skipCharacters;
-    const result = bytes2.subarray(offset, width === Infinity ? void 0 : offset + width);
+    let result;
+    try {
+      const chars = Array.from(uniqDecoder.decode(bytes2.subarray(offset)));
+      result = encoder.encode((width === Infinity ? chars.slice(skipCharacters) : chars.slice(skipCharacters, skipCharacters + width)).join(""));
+    } catch (error) {
+      if (!(error instanceof TypeError)) throw error;
+      offset += skipCharacters;
+      result = bytes2.subarray(offset, width === Infinity ? void 0 : offset + width);
+    }
     return ignoreCase ? fold(result) : result;
   };
   const records5 = (async function* () {
@@ -44261,7 +44435,9 @@ function createJoinCommand(factory = {}) {
 // packages/safe-bash/src/commands/table-text/index.ts
 function createTableTextCommands(options2 = {}) {
   settings4(options2);
-  return [createPasteCommand(options2), createCommCommand(options2), createJoinCommand(options2)];
+  const defs = [createPasteCommand(options2), createCommCommand(options2), createJoinCommand(options2)];
+  for (let i = 0; i < defs.length; i++) builtInDirectContextExecutors.add(defs[i].execute);
+  return defs;
 }
 function tableTextCommands(options2 = {}) {
   const commands = createTableTextCommands(options2);
@@ -47323,7 +47499,8 @@ function delay(milliseconds, signal, configuration) {
     let handle;
     let armed = false;
     let settled = false;
-    let started;
+    let remaining = milliseconds;
+    let step = 0;
     let previous;
     const finish = (failed, reason) => {
       if (settled) return;
@@ -47350,20 +47527,17 @@ function delay(milliseconds, signal, configuration) {
         if (!Number.isFinite(now) || Math.abs(now) > Number.MAX_SAFE_INTEGER || previous !== void 0 && now < previous) {
           throw new RangeError("sleep scheduler must supply finite monotonic milliseconds");
         }
-        started ??= now;
+        if (previous !== void 0) remaining -= Math.max(step, now - previous);
         previous = now;
-        const remaining = milliseconds - (now - started);
         if (remaining <= 0) {
           finish(false);
           return;
         }
-        const timer = scheduler.setTimeout(
-          () => {
-            armed = false;
-            schedule();
-          },
-          Math.min(configuration.maxTimerMilliseconds, Math.max(1, Math.ceil(remaining)))
-        );
+        step = Math.min(2147483647, configuration.maxTimerMilliseconds, Math.max(1, Math.ceil(remaining)));
+        const timer = scheduler.setTimeout(() => {
+          armed = false;
+          schedule();
+        }, step);
         if (settled) scheduler.clearTimeout(timer);
         else {
           handle = timer;
@@ -48173,7 +48347,7 @@ var FileFailure = class extends Error {
 };
 var FileLimitError = class extends FileFailure {
 };
-var utf8Encoder = new TextEncoder();
+var utf8Encoder2 = new TextEncoder();
 var printableAsciiNoBackslash = /^[\x20-\x5b\x5d-\x7e]*$/;
 var hostAbortWaiters = /* @__PURE__ */ new WeakMap();
 function subscribeHostAbort(signal, fn) {
@@ -48297,7 +48471,7 @@ var SharedBudget = class {
     const size = import_buffer.Buffer.byteLength(text3);
     this.check(size, this.limits.maxOutputBytes - this.outputBytes, "output");
     this.outputBytes += size;
-    const bytes2 = utf8Encoder.encode(text3);
+    const bytes2 = utf8Encoder2.encode(text3);
     const width = Math.min(16384, this.limits.maxChunkBytes);
     for (let offset = 0; offset < bytes2.length; offset += width) {
       await (0, contracts_exports.writeBytes)(sink, bytes2.slice(offset, offset + width), signal);
@@ -48318,7 +48492,7 @@ var SharedBudget = class {
       bounded2 += character;
     }
     this.outputBytes += size;
-    const bytes2 = utf8Encoder.encode(bounded2);
+    const bytes2 = utf8Encoder2.encode(bounded2);
     const width = Math.min(16384, this.limits.maxChunkBytes);
     for (let offset = 0; offset < bytes2.length; offset += width) {
       await (0, contracts_exports.writeBytes)(this.context.stderr, bytes2.slice(offset, offset + width), this.signal);
@@ -51707,7 +51881,7 @@ Traversal and output limits apply; adapters may have their own side effects.
 
 // packages/safe-bash/src/commands/du/budget.ts
 init_platform();
-var utf8Encoder2 = new TextEncoder();
+var utf8Encoder3 = new TextEncoder();
 var DuLimitError = class extends contracts_exports.FsError {
   constructor(label) {
     super("EFBIG", { message: `du ${label} limit exceeded` });
@@ -51839,7 +52013,7 @@ var Budget24 = class {
     const size = import_buffer.Buffer.byteLength(text3);
     this.check(size, this.limits.maxOutputBytes - this.output, "output", signal);
     this.output += size;
-    const bytes2 = utf8Encoder2.encode(text3);
+    const bytes2 = utf8Encoder3.encode(text3);
     const ioSignal = signal === this.caller.signal ? this.ioSignal : this.outputSignal ??= AbortSignal.any([signal, this.cancellation.signal]);
     for (let offset = 0; offset < bytes2.length; offset += 16384) {
       this.active(signal);
@@ -53073,9 +53247,9 @@ function parseDuration(token) {
 init_platform();
 var defaultSchedulerBinding = Object.freeze({
   receiver: globalThis,
-  now: globalThis.performance.now.bind(globalThis.performance),
-  setTimeout: globalThis.setTimeout.bind(globalThis),
-  clearTimeout: globalThis.clearTimeout.bind(globalThis)
+  now: () => globalThis.performance.now(),
+  setTimeout: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
+  clearTimeout: (handle) => globalThis.clearTimeout(handle)
 });
 function clock(binding, previous) {
   const sample = Reflect.apply(binding.now, binding.receiver, []);
@@ -53092,6 +53266,7 @@ function createDeadline(binding, duration2, maximumChunk, cancel = true) {
   let expired = false;
   let remaining = duration2;
   let previous = 0;
+  let step = 0;
   let handle;
   let handleLive = false;
   let cleanupFailed = false;
@@ -53120,8 +53295,8 @@ function createDeadline(binding, duration2, maximumChunk, cancel = true) {
     controller.abort(timerFailureReason);
   };
   const arm = () => {
-    const milliseconds = Math.min(maximumChunk, Math.max(1, Math.ceil(remaining)));
-    handle = Reflect.apply(binding.setTimeout, binding.receiver, [wake, milliseconds]);
+    step = Math.min(2147483647, maximumChunk, Math.max(1, Math.ceil(remaining)));
+    handle = Reflect.apply(binding.setTimeout, binding.receiver, [wake, step]);
     handleLive = true;
   };
   const wake = () => {
@@ -53133,7 +53308,7 @@ function createDeadline(binding, duration2, maximumChunk, cancel = true) {
       failTimer();
       return;
     }
-    remaining -= sample - previous;
+    remaining -= Math.max(step, sample - previous);
     previous = sample;
     if (remaining <= 0) {
       admissionOpen = false;
@@ -53198,6 +53373,16 @@ function optionsObject(value2) {
 }
 function settings15(value2, includeReplace) {
   const options2 = optionsObject(value2);
+  const configuredLimits = optionsObject(options2?.limits);
+  const limits = {
+    maxArguments: Infinity,
+    maxArgumentBytes: Infinity,
+    maxOutputBytes: Infinity,
+    ...configuredLimits
+  };
+  for (const [name2, limit] of Object.entries(limits)) {
+    if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1)) throw new RangeError(`Invalid timeout limit: ${name2}`);
+  }
   const killAfterPolicy = options2?.killAfterPolicy;
   if (killAfterPolicy !== void 0 && typeof killAfterPolicy !== "function") throw new TypeError("Timeout killAfterPolicy must be a function");
   const invokeValue = options2?.invoke;
@@ -53223,8 +53408,8 @@ function settings15(value2, includeReplace) {
   }
   const maximum = options2?.maxTimerMilliseconds;
   if (maximum !== void 0 && typeof maximum !== "number") throw new TypeError("Timeout maxTimerMilliseconds must be a number");
-  if (maximum !== void 0 && (!Number.isInteger(maximum) || maximum < 1 || maximum > 2147483647)) {
-    throw new RangeError("Timeout maxTimerMilliseconds must be an integer from 1 through 2147483647");
+  if (maximum !== void 0 && maximum !== Infinity && (!Number.isInteger(maximum) || maximum < 1 || maximum > 2147483647)) {
+    throw new RangeError("Timeout maxTimerMilliseconds must be an integer from 1 through 2147483647 or Infinity");
   }
   let replace = false;
   if (includeReplace) {
@@ -53232,9 +53417,10 @@ function settings15(value2, includeReplace) {
     if (configured !== void 0 && typeof configured !== "boolean") throw new TypeError("Timeout replace must be a boolean");
     replace = configured ?? false;
   }
-  return { invoke, killAfterPolicy, scheduler: binding, maxTimerMilliseconds: maximum ?? 2147483647, replace };
+  return { limits, invoke, killAfterPolicy, scheduler: binding, maxTimerMilliseconds: maximum ?? 2147483647, replace };
 }
-async function status(context2, bytes2, exitCode, stdout = false) {
+async function status(configuration, context2, bytes2, exitCode, stdout = false) {
+  if (bytes2.length > configuration.limits.maxOutputBytes) throw new contracts_exports.FsError("EFBIG", { message: "timeout output limit exceeded" });
   await (0, contracts_exports.writeBytes)(stdout ? context2.stdout : context2.stderr, bytes2, context2.signal);
   return { exitCode };
 }
@@ -53250,7 +53436,16 @@ function definition2(configuration) {
     name: "timeout",
     description: "Run a virtual command with a cooperative time limit",
     async execute(context2) {
+      context2.signal.throwIfAborted();
       const originalArgs = context2.args;
+      if (originalArgs.length > configuration.limits.maxArguments) throw new contracts_exports.FsError("EFBIG", { message: "timeout argument count limit exceeded" });
+      const suppliedValues = "argumentValues" in context2 ? context2.argumentValues : void 0;
+      const ownedArguments = suppliedValues === void 0 ? void 0 : (0, contracts_exports.getCommandArguments)(context2);
+      let argumentBytes = 0;
+      for (const argument2 of ownedArguments?.values ?? originalArgs) {
+        argumentBytes += shellValueByteLength(argument2);
+        if (argumentBytes > configuration.limits.maxArgumentBytes) throw new contracts_exports.FsError("EFBIG", { message: "timeout argument limit exceeded" });
+      }
       let offset = 0;
       let preserveStatus = false;
       let verbose2 = false;
@@ -53263,8 +53458,8 @@ function definition2(configuration) {
           offset++;
           break;
         }
-        if (token === "--help") return status(context2, records3.help, 0, true);
-        if (token === "--version") return status(context2, records3.version, 0, true);
+        if (token === "--help") return status(configuration, context2, records3.help, 0, true);
+        if (token === "--version") return status(configuration, context2, records3.version, 0, true);
         if (token === "-" || !token.startsWith("-")) break;
         if (token === "--verbose") {
           verbose2 = true;
@@ -53283,19 +53478,19 @@ function definition2(configuration) {
         }
         if (token === "--kill-after" || token.startsWith("--kill-after=")) {
           const duration2 = token === "--kill-after" ? originalArgs[++offset] : token.slice(13);
-          if (duration2 === void 0) return status(context2, records3.missingDuration, 125);
+          if (duration2 === void 0) return status(configuration, context2, records3.missingDuration, 125);
           const killAfter = parseDuration(duration2);
-          if (killAfter.kind === "invalid") return status(context2, records3.invalidDuration, 125);
-          if (killAfter.kind === "overflow") return status(context2, records3.durationOverflow, 125);
+          if (killAfter.kind === "invalid") return status(configuration, context2, records3.invalidDuration, 125);
+          if (killAfter.kind === "overflow") return status(configuration, context2, records3.durationOverflow, 125);
           killAfterMilliseconds = killAfter.milliseconds;
           offset++;
           continue;
         }
         if (token === "--signal" || token.startsWith("--signal=")) {
           const signalToken = token === "--signal" ? originalArgs[++offset] : token.slice(9);
-          if (signalToken === void 0) return status(context2, records3.invalidSignal, 125);
+          if (signalToken === void 0) return status(configuration, context2, records3.invalidSignal, 125);
           const parsedSignal = parseSignal(signalToken);
-          if (parsedSignal === void 0) return status(context2, records3.invalidSignal, 125);
+          if (parsedSignal === void 0) return status(configuration, context2, records3.invalidSignal, 125);
           signalNumber = parsedSignal;
           offset++;
           continue;
@@ -53321,37 +53516,36 @@ function definition2(configuration) {
             }
             if (flag === "k") {
               const duration2 = token.slice(position + 1) || originalArgs[++offset];
-              if (duration2 === void 0) return status(context2, records3.missingDuration, 125);
+              if (duration2 === void 0) return status(configuration, context2, records3.missingDuration, 125);
               const killAfter = parseDuration(duration2);
-              if (killAfter.kind === "invalid") return status(context2, records3.invalidDuration, 125);
-              if (killAfter.kind === "overflow") return status(context2, records3.durationOverflow, 125);
+              if (killAfter.kind === "invalid") return status(configuration, context2, records3.invalidDuration, 125);
+              if (killAfter.kind === "overflow") return status(configuration, context2, records3.durationOverflow, 125);
               killAfterMilliseconds = killAfter.milliseconds;
               break;
             }
             if (flag === "s") {
               const signalToken = token.slice(position + 1) || originalArgs[++offset];
-              if (signalToken === void 0) return status(context2, records3.invalidSignal, 125);
+              if (signalToken === void 0) return status(configuration, context2, records3.invalidSignal, 125);
               const parsedSignal = parseSignal(signalToken);
-              if (parsedSignal === void 0) return status(context2, records3.invalidSignal, 125);
+              if (parsedSignal === void 0) return status(configuration, context2, records3.invalidSignal, 125);
               signalNumber = parsedSignal;
               break;
             }
-            return status(context2, records3.invalidOption, 125);
+            return status(configuration, context2, records3.invalidOption, 125);
           }
           offset++;
           continue;
         }
-        return status(context2, records3.invalidOption, 125);
+        return status(configuration, context2, records3.invalidOption, 125);
       }
       const durationToken = originalArgs[offset];
-      if (durationToken === void 0) return status(context2, records3.missingDuration, 125);
+      if (durationToken === void 0) return status(configuration, context2, records3.missingDuration, 125);
       const parsed = parseDuration(durationToken);
-      if (parsed.kind === "invalid") return status(context2, records3.invalidDuration, 125);
-      if (parsed.kind === "overflow") return status(context2, records3.durationOverflow, 125);
+      if (parsed.kind === "invalid") return status(configuration, context2, records3.invalidDuration, 125);
+      if (parsed.kind === "overflow") return status(configuration, context2, records3.durationOverflow, 125);
       const command7 = originalArgs[offset + 1];
-      if (command7 === void 0) return status(context2, records3.missingCommand, 125);
-      const suppliedValues = "argumentValues" in context2 ? context2.argumentValues : void 0;
-      const argumentValues = suppliedValues === void 0 ? void 0 : (0, contracts_exports.getCommandArguments)({ args: originalArgs, argumentValues: suppliedValues }).slice(offset + 2);
+      if (command7 === void 0) return status(configuration, context2, records3.missingCommand, 125);
+      const argumentValues = ownedArguments?.slice(offset + 2);
       const args = argumentValues?.args ?? Object.freeze(originalArgs.slice(offset + 2));
       const streams = {
         ...argumentValues === void 0 ? {} : { argumentValues },
@@ -53363,7 +53557,7 @@ function definition2(configuration) {
       const killAfterPolicy = configuration.killAfterPolicy ?? context2.capabilities?.timeoutKillAfterPolicy;
       if (killAfterMilliseconds !== void 0 && killAfterMilliseconds !== 0 && parsed.milliseconds !== 0 && parsed.milliseconds !== Infinity) {
         context2.signal.throwIfAborted();
-        if (typeof killAfterPolicy !== "function") return status(context2, records3.escalationUnavailable, 125);
+        if (typeof killAfterPolicy !== "function") return status(configuration, context2, records3.escalationUnavailable, 125);
         let result2;
         try {
           result2 = await killAfterPolicy(context2, command7, args, { signal: context2.signal, ...streams }, Object.freeze({
@@ -53383,7 +53577,7 @@ function definition2(configuration) {
       }
       const selected2 = childInvoker(context2, configuration.invoke);
       if (parsed.milliseconds === 0 || parsed.milliseconds === Infinity) {
-        if (selected2 === void 0) return status(context2, records3.invokeUnavailable, 125);
+        if (selected2 === void 0) return status(configuration, context2, records3.invokeUnavailable, 125);
         context2.signal.throwIfAborted();
         let result2;
         try {
@@ -53395,7 +53589,7 @@ function definition2(configuration) {
         context2.signal.throwIfAborted();
         return result2;
       }
-      if (selected2 === void 0) return status(context2, records3.invokeUnavailable, 125);
+      if (selected2 === void 0) return status(configuration, context2, records3.invokeUnavailable, 125);
       context2.signal.throwIfAborted();
       const deadline = createDeadline(configuration.scheduler, parsed.milliseconds, configuration.maxTimerMilliseconds, signalNumber !== 0);
       context2.registerCleanup?.(deadline.retire);
@@ -53412,7 +53606,7 @@ function definition2(configuration) {
         }
         context2.signal.throwIfAborted();
         if (retirementFailed2) throw retirementFailure2;
-        return status(context2, records3.timerSetupFailed, 125);
+        return status(configuration, context2, records3.timerSetupFailed, 125);
       }
       let returned = false;
       let result;
@@ -53435,11 +53629,11 @@ function definition2(configuration) {
       if (!returned && invocationFailure !== deadline.deadlineReason && invocationFailure !== deadline.timerFailureReason) throw invocationFailure;
       if (retirementFailed) throw retirementFailure;
       if (verbose2 && deadline.expired) {
-        await (0, contracts_exports.writeBytes)(context2.stderr, encoder4.encode(`timeout: cooperative deadline expired for command \u2018${command7}\u2019
-`), context2.signal);
+        await status(configuration, context2, encoder4.encode(`timeout: cooperative deadline expired for command \u2018${command7}\u2019
+`), 0);
       }
       if (!returned && invocationFailure === deadline.deadlineReason) return { exitCode: signalNumber === 9 || preserveStatus ? 128 + signalNumber : 124 };
-      if (deadline.signal.aborted && deadline.signal.reason === deadline.timerFailureReason) return status(context2, records3.timerSetupFailed, 125);
+      if (deadline.signal.aborted && deadline.signal.reason === deadline.timerFailureReason) return status(configuration, context2, records3.timerSetupFailed, 125);
       if (deadline.expired && (!preserveStatus || signalNumber === 9)) return { exitCode: signalNumber === 9 ? 137 : 124 };
       return result;
     }
@@ -59919,6 +60113,47 @@ var ShellInput = class _ShellInput {
 // packages/safe-bash/src/shell/runtime.ts
 init_platform();
 
+// packages/safe-bash/src/shell/sync-jq-expression.ts
+init_platform();
+function splitSyncJqExpression(expression, separator) {
+  const parts = [];
+  const stack = [];
+  let quoted2 = false;
+  let escaped3 = false;
+  let start = 0;
+  let wrapped = expression.startsWith("(");
+  for (let i = 0; i < expression.length; i++) {
+    const ch = expression[i];
+    if (quoted2) {
+      if (escaped3) escaped3 = false;
+      else if (ch === "\\") escaped3 = true;
+      else if (ch === '"') quoted2 = false;
+      continue;
+    }
+    if (ch === '"') {
+      quoted2 = true;
+      continue;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") {
+      stack.push(ch === "(" ? ")" : ch === "[" ? "]" : "}");
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      if (stack.pop() !== ch) return void 0;
+      if (stack.length === 0 && i !== expression.length - 1) wrapped = false;
+      continue;
+    }
+    if (stack.length === 0 && expression.startsWith(separator, i)) {
+      parts.push(expression.slice(start, i).trim());
+      i += separator.length - 1;
+      start = i + 1;
+    }
+  }
+  if (quoted2 || stack.length > 0) return void 0;
+  parts.push(expression.slice(start).trim());
+  return { parts, wrapped };
+}
+
 // packages/safe-bash/src/worker/runtime-context.ts
 init_platform();
 var shellDescriptorAdmissions = /* @__PURE__ */ new WeakMap();
@@ -69552,6 +69787,12 @@ var closedSource = { [Symbol.asyncIterator]() {
   };
   return iterator;
 } };
+var syncAwkArithAtom = `(?:\\$(?:[0-9]+|NF)|NR|NF|-?[0-9]+(?:\\.[0-9]+)?|[a-zA-Z_][a-zA-Z0-9_]*)`;
+var syncAwkArithPat = `(?:${syncAwkArithAtom}(?:\\s*[+*\\/%-]\\s*${syncAwkArithAtom})+)`;
+var syncAwkTernaryPat = `(?:(?:\\$(?:[0-9]+|NF)|NR|NF)\\s*(?:==|!=|>=|<=|>|<)\\s*(?:-?[0-9]+(?:\\.[0-9]+)?|"[^"$\\\\]*")\\s*\\?\\s*(?:\\$(?:[0-9]+|NF)|"[^"$\\\\]*"|-?[0-9]+(?:\\.[0-9]+)?)\\s*:\\s*(?:\\$(?:[0-9]+|NF)|"[^"$\\\\]*"|-?[0-9]+(?:\\.[0-9]+)?))`;
+var syncAwkItemPat = `(?:${syncAwkTernaryPat}|int\\(\\$(?:[0-9]+|NF)\\)|(?:toupper|tolower)\\(\\$(?:[0-9]+|NF)\\)|substr\\(\\$(?:[0-9]+|NF)\\s*,\\s*[0-9]+(?:\\s*,\\s*[0-9]+)?\\)|index\\(\\$(?:[0-9]+|NF)\\s*,\\s*"[^"$\\\\]*"\\)|${syncAwkArithPat}|\\$(?:[0-9]+|NF)|\\$\\(NF\\s*-\\s*[0-9]+\\)|length(?:\\(\\$(?:[0-9]+|NF)\\))?|NR|NF|[a-zA-Z_][a-zA-Z0-9_]*|"[^"$\\\\]*")`;
+var syncAwkPrintRe = new RegExp(`^\\{\\s*(?:(g?sub)\\(\\s*\\/(\\^?[a-zA-Z0-9_ :;,=-]+\\$?)\\/\\s*,\\s*"([^"\\\\]*)"(?:\\s*,\\s*\\$([0-9]+|NF))?\\s*\\)\\s*;\\s*)?(?:print(?:\\s+(${syncAwkItemPat}(?:\\s*,?\\s*${syncAwkItemPat})*))?|printf\\s+"([^"$\\\\]*(?:\\\\[nt\\\\"][^"$\\\\]*)*)"\\s*,\\s*(${syncAwkItemPat}(?:\\s*,\\s*${syncAwkItemPat})*))\\s*;?\\s*\\}\\s*$`);
+var syncAwkTokenRe = new RegExp(`(${syncAwkTernaryPat})|int\\(\\$([0-9]+|NF)\\)|(toupper|tolower)\\(\\$([0-9]+|NF)\\)|substr\\(\\$([0-9]+|NF)\\s*,\\s*([0-9]+)(?:\\s*,\\s*([0-9]+))?\\)|index\\(\\$([0-9]+|NF)\\s*,\\s*"([^"$\\\\]*)"\\)|(${syncAwkArithPat})|\\$\\(NF\\s*-\\s*([0-9]+)\\)|\\$([0-9]+|NF)|length\\b(?:\\(\\$([0-9]+|NF)\\))?|(NR|NF)\\b|"([^"$\\\\]*)"|([a-zA-Z_][a-zA-Z0-9_]*)|(,)`, "g");
 var RuntimeCancellationState = class {
   _records;
   _diagnostics;
@@ -69848,7 +70089,7 @@ function hasGlobOrEscape(text3, extglob = false) {
 var nextProcessSubstitutionId = 0;
 var defaultRuntimeMuscleMemoryMap;
 function getRuntimeMuscleMemoryCommand(name2) {
-  defaultRuntimeMuscleMemoryMap ??= new Map([...(0, bc_exports.createBcCommands)(), ...(0, sponge_exports.createSpongeCommands)(), ...(0, fd_exports.createFdCommands)(), ...(0, less_exports.createLessCommands)(), ...(0, id_exports.createIdCommands)(), ...(0, whoami_exports.createWhoamiCommands)(), ...(0, uname_exports.createUnameCommands)(), ...(0, hostname_exports.createHostnameCommands)(), ...(0, nproc_exports.createNprocCommands)(), ...createShufCommands2(), ...createDdCommands2(), ...(0, numfmt_exports.createNumfmtCommands)(), ...(0, envsubst_exports.createEnvsubstCommands)(), ...(0, cal_exports.createCalCommands)(), ...(0, pathchk_exports.createPathchkCommands)(), ...(0, getconf_exports.createGetconfCommands)(), ...(0, locale_exports.createLocaleCommands)(), ...(0, df_exports.createDfCommands)(), ...(0, sqlite3_exports.createSqlite3Commands)()].map((cmd) => [cmd.name, cmd]));
+  defaultRuntimeMuscleMemoryMap ??= new Map([...createStreamFormatCommands(), ...createStreamInspectionCommands(), ...(0, bc_exports.createBcCommands)(), ...(0, sponge_exports.createSpongeCommands)(), ...(0, fd_exports.createFdCommands)(), ...(0, less_exports.createLessCommands)(), ...(0, id_exports.createIdCommands)(), ...(0, whoami_exports.createWhoamiCommands)(), ...(0, uname_exports.createUnameCommands)(), ...(0, hostname_exports.createHostnameCommands)(), ...(0, nproc_exports.createNprocCommands)(), ...createShufCommands2(), ...createDdCommands2(), ...(0, numfmt_exports.createNumfmtCommands)(), ...(0, envsubst_exports.createEnvsubstCommands)(), ...(0, cal_exports.createCalCommands)(), ...(0, pathchk_exports.createPathchkCommands)(), ...(0, getconf_exports.createGetconfCommands)(), ...(0, locale_exports.createLocaleCommands)(), ...(0, df_exports.createDfCommands)(), ...(0, sqlite3_exports.createSqlite3Commands)()].map((cmd) => [cmd.name, cmd]));
   return defaultRuntimeMuscleMemoryMap.get(name2);
 }
 var fastSubScratchArgs = [];
@@ -72386,6 +72627,7 @@ var Runtime = class _Runtime {
         for (let i = 0; i < assignment.entries.length; i++) {
           const entry = assignment.entries[i];
           if (entry.append) return false;
+          if (entry.value.parts.some((p) => p.kind === "variable" && p.prefixNames === "@") && !this.canSyncArrayMembersWord(entry.value, rawState)) return false;
           if (entry.index === void 0 && rawState.braceexpand !== false && this.budget.limits.maxExpansionFields === Infinity && this.budget.limits.maxExpansionBytes === Infinity && entry.value.parts.length === 1 && !entry.value.parts[0].quoted && entry.value.parts[0].kind === "text" && entry.value.parts[0].value.includes("{")) {
             const braceItems = tryFastExpandBraceRange(entry.value, this.budget, void 0);
             if (braceItems && braceItems.length <= 1500) {
@@ -78728,6 +78970,7 @@ var Runtime = class _Runtime {
       if (part.kind === "variable") {
         if (this._syncLoopFnCheckDepth > 0 && (part.substring || getArraySelector(part)?.kind === "element")) return false;
         if (part.prefixNames !== void 0) {
+          if (part.prefixNames === "@") return false;
           if (part.indirect || part.specialParameter || part.length || part.substring || part.transform !== void 0 || part.operator !== void 0 || getArraySelector(part) !== void 0 || this.budget.limits.maxExpansionFields !== Infinity || this.budget.limits.maxExpansionBytes !== Infinity || !isShellIdentifier(part.name)) {
             return false;
           }
@@ -78869,6 +79112,7 @@ var Runtime = class _Runtime {
             }
           }
         }
+        if (w0Plain === "tac" || w0Plain === "nl" || w0Plain === "base64" && cmd.words.length > 1) return false;
         if (w0Plain === "pwd") {
           if (p.commands.length === 1 && (cmd.words.length === 1 || cmd.words.length === 2 && (cmd.words[1]?.plain === "-L" || cmd.words[1]?.plain === "--logical")) && !rawState.functions.has("pwd") && !rawState.extensions?.builtins.has("pwd")) continue;
           return false;
@@ -78879,11 +79123,11 @@ var Runtime = class _Runtime {
           }
           return false;
         }
-        const isFileCommand = w0Plain === "cat" || w0Plain === "head" || w0Plain === "tail" || w0Plain === "jq" || w0Plain === "awk" || w0Plain === "grep" || w0Plain === "sed" || w0Plain === "cut" || w0Plain === "wc" || w0Plain === "sort" || w0Plain === "uniq" || w0Plain === "tr" || hasSingleHereStringRedir && (w0Plain === "base64" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl");
-        const def = w0Plain ? this.commands.get(w0Plain) ?? (w0Plain === "rev" || w0Plain === "tac" ? this.getExternalCommand(w0Plain) : void 0) : void 0;
+        const isFileCommand = w0Plain === "cat" || w0Plain === "head" || w0Plain === "tail" || w0Plain === "jq" || w0Plain === "awk" || w0Plain === "grep" || w0Plain === "sed" || w0Plain === "cut" || w0Plain === "wc" || w0Plain === "sort" || w0Plain === "uniq" || w0Plain === "tr" || hasSingleHereStringRedir && (w0Plain === "base64" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl" || w0Plain === "paste" || w0Plain === "numfmt");
+        const def = w0Plain ? this.commands.get(w0Plain) ?? (w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl" || w0Plain === "paste" || w0Plain === "jq" ? this.getExternalCommand(w0Plain) : void 0) : void 0;
         if (!w0Plain || w0Plain !== "printf" && w0Plain !== "echo" && w0Plain !== "dirname" && w0Plain !== "basename" && w0Plain !== "seq" && !isFileCommand || !def || rawState.functions.has(w0Plain) || rawState.extensions?.builtins.has(w0Plain)) return false;
         if ((hasSingleStdinRedir || hasSingleHereStringRedir) && !isFileCommand) return false;
-        if (w0Plain === "printf" ? def.execute !== printfCommand.execute : w0Plain === "echo" ? !defaultEchoExecutors.has(def.execute) : w0Plain === "seq" || w0Plain === "rev" || w0Plain === "tac" ? !builtInDirectContextExecutors.has(def.execute) && (customRegisteredCommands.has(def.execute) || customRegisteredRegistries.has(this.commands)) : !builtInDirectContextExecutors.has(def.execute)) return false;
+        if (w0Plain === "printf" ? def.execute !== printfCommand.execute : w0Plain === "echo" ? !defaultEchoExecutors.has(def.execute) : w0Plain === "seq" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl" || w0Plain === "paste" || w0Plain === "jq" ? !builtInDirectContextExecutors.has(def.execute) && customRegisteredCommands.has(def.execute) : !builtInDirectContextExecutors.has(def.execute)) return false;
         if (!cmd.words.slice(1).every((w) => this.isPureSyncValueWord(w, rawState))) return false;
         if (isFileCommand) {
           if (w0Plain === "tr" && !hasSingleStdinRedir && !hasSingleHereStringRedir) return false;
@@ -78898,12 +79142,12 @@ var Runtime = class _Runtime {
           const opCount = opWords.length;
           const op0 = opWords[0]?.plain;
           const op1 = opWords[1]?.plain;
-          if (w0Plain === "cat" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl") {
+          if (w0Plain === "cat" || w0Plain === "rev" || w0Plain === "tac") {
             if (opCount !== 0) return false;
           } else {
             if (p.commands.length !== 1 && !hasSingleHereStringRedir) return false;
             if (w0Plain === "head" || w0Plain === "tail") {
-              const validHT = opCount === 0 || opCount === 1 && op0 !== void 0 && /^-(?:n|c)?[0-9]{1,5}$/.test(op0) || opCount === 2 && (op0 === "-n" || op0 === "-c") && op1 !== void 0 && /^[0-9]{1,5}$/.test(op1);
+              const validHT = opCount === 0 || opCount === 1 && op0 !== void 0 && (/^-(?:n|c|--lines=|--bytes=)?[0-9]{1,5}$/.test(op0) || /^--(?:lines|bytes)=[0-9]{1,5}$/.test(op0) || w0Plain === "tail" && /^(?:-n|--lines=)\+[0-9]{1,5}$/.test(op0) || w0Plain === "head" && /^(?:-n|--lines=)-[0-9]{1,5}$/.test(op0)) || opCount === 2 && (op0 === "-n" && op1 !== void 0 && (/^[0-9]{1,5}$/.test(op1) || w0Plain === "tail" && /^\+[0-9]{1,5}$/.test(op1) || w0Plain === "head" && /^-[0-9]{1,5}$/.test(op1)) || op0 === "-c" && op1 !== void 0 && /^[0-9]{1,5}$/.test(op1));
               if (!validHT) return false;
             }
             const plainOps = [];
@@ -78914,7 +79158,7 @@ var Runtime = class _Runtime {
               plainOps.push(pw);
             }
             if (w0Plain === "cut") {
-              if (plainOps.length !== opCount || this.evalSyncCut([], plainOps, byteLocale(rawState.variables)) === void 0) return false;
+              if (plainOps.length !== opCount || this.evalSyncCut(["\xE9"], plainOps, byteLocale(rawState.variables)) === void 0) return false;
             } else if (w0Plain === "sed") {
               if (plainOps.length !== opCount || this.evalSyncSed([], plainOps) === void 0) return false;
             } else if (w0Plain === "grep") {
@@ -78922,30 +79166,53 @@ var Runtime = class _Runtime {
             } else if (w0Plain === "awk") {
               if (plainOps.length !== opCount || this.evalSyncAwk([], plainOps) === void 0) return false;
             } else if (w0Plain === "jq") {
-              if (plainOps.length !== opCount || this.evalSyncJq("null", plainOps) === void 0) return false;
+              if (plainOps.length !== opCount) return false;
+              const jqIn = this.extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
+              if (jqIn === void 0 || this.evalSyncJq(jqIn, plainOps) === void 0) return false;
             } else if (w0Plain === "wc") {
-              if (opCount !== 1 || op0 !== "-l" && op0 !== "-c" && op0 !== "-w") return false;
+              if (opCount !== 1 || this.normalizeSyncWcFlag(op0) === void 0) return false;
             } else if (w0Plain === "sort") {
-              if (byteLocale(rawState.variables) || opCount > 1 || opCount === 1 && op0 !== "-r" && op0 !== "-u" && op0 !== "-n" && op0 !== "-rn" && op0 !== "-nr" && op0 !== "-ru" && op0 !== "-ur") return false;
+              if (plainOps.length !== opCount || this.evalSyncSort([], plainOps, byteLocale(rawState.variables)) === void 0) return false;
             } else if (w0Plain === "uniq") {
-              if (opCount > 1 || opCount === 1 && op0 !== "-d" && op0 !== "-u" && op0 !== "-c") return false;
+              if (plainOps.length !== opCount || this.evalSyncUniq([], plainOps) === void 0) return false;
             } else if (w0Plain === "base64") {
               if (opCount > 1 || opCount === 1 && op0 !== "-d" && op0 !== "--decode") return false;
             } else if (w0Plain === "tr") {
               if (plainOps.length !== opCount || this.evalSyncTr("", plainOps) === void 0) return false;
+            } else if (w0Plain === "nl") {
+              if (plainOps.length !== opCount || this.evalSyncNl([], plainOps) === void 0) return false;
+            } else if (w0Plain === "paste") {
+              if (plainOps.length !== opCount || this.evalSyncPaste([], plainOps) === void 0) return false;
+            } else if (w0Plain === "numfmt") {
+              const nmCheck = this.extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
+              if (nmCheck === void 0 || plainOps.length !== opCount || this.evalSyncNumfmt(nmCheck.split("\n"), plainOps) === void 0) return false;
             }
           }
         }
         if (w0Plain === "printf") {
-          const fmtW = cmd.words[1];
-          const fmtP = fmtW?.plain ?? (fmtW?.parts.length === 1 && fmtW.parts[0].kind === "text" ? fmtW.parts[0].value : void 0);
-          if (fmtP === void 0 || fmtP.startsWith("-") || !/^(?:[^%]|%%|%[-0]*\d*(?:\.\d+)?[sdxXouc]|\\n)*$/.test(fmtP)) return false;
+          if (!this.isSyncPrintfCallOk(cmd, 1, rawState, this._activePrintfInductionName)) return false;
         } else if (w0Plain === "echo") {
-          if (cmd.words.length > 1 && (cmd.words[1].plain === void 0 ? cmd.words[1].parts[0]?.kind === "text" && cmd.words[1].parts[0].value.startsWith("-") : cmd.words[1].plain.startsWith("-"))) return false;
-        } else if (w0Plain === "dirname") {
-          if (cmd.words.length !== 2) return false;
-        } else if (w0Plain === "basename") {
-          if (cmd.words.length !== 2 && cmd.words.length !== 3 && !(cmd.words.length === 4 && cmd.words[1]?.plain === "-s")) return false;
+          const firstArg = cmd.words[1];
+          if (firstArg) {
+            const prefix3 = firstArg.parts.find((part2) => part2.kind !== "text" || part2.value.length > 0);
+            if (prefix3?.kind !== "text" || prefix3.value.startsWith("-")) return false;
+          }
+        } else if (w0Plain === "dirname" || w0Plain === "basename") {
+          const simArgs = [];
+          let seenDoubleDash = false;
+          for (let wi = 1; wi < cmd.words.length; wi++) {
+            const w = cmd.words[wi];
+            if (w.parts[0]?.kind === "text" && !w.parts[0].quoted && w.parts[0].value.startsWith("~")) return false;
+            const st = w.plain ?? (w.parts.length > 0 && w.parts.every((pt) => pt.kind === "text") ? w.parts.map((pt) => pt.value).join("") : void 0);
+            if (st !== void 0) {
+              if (st === "--") seenDoubleDash = true;
+              simArgs.push(st);
+            } else {
+              if (!seenDoubleDash) return false;
+              simArgs.push("x");
+            }
+          }
+          if ((w0Plain === "dirname" ? this.evalSyncDirname(simArgs) : this.evalSyncBasename(simArgs)) === void 0) return false;
         } else if (w0Plain === "seq") {
           const isSeqIntWord = (w) => {
             if (w.plain !== void 0) return /^-?[0-9]{1,7}$/.test(w.plain);
@@ -78963,21 +79230,23 @@ var Runtime = class _Runtime {
         }
         if (p.commands.length >= 2) {
           if (w0Plain !== "printf" && w0Plain !== "echo" && w0Plain !== "seq" && w0Plain !== "cat" && !hasSingleHereStringRedir || syncPurePipelineSlotInUse || !this.budget.canSyncPurePipe || rawState.errexit || rawState.nounset) return false;
-          if (w0Plain === "printf" && !this.isSyncPrintfCallOk(cmd, 1, rawState)) return false;
+          if (w0Plain === "printf") {
+            if (!this.isSyncPrintfCallOk(cmd, 1, rawState, this._activePrintfInductionName)) return false;
+          }
           for (let sIdx = 1; sIdx < p.commands.length; sIdx++) {
             const sCmd = p.commands[sIdx];
             if (sCmd.kind !== "simple" || sCmd.redirects.length !== 0 || sCmd.words.length === 0) return false;
             const sName = sCmd.words[0].plain;
-            if (!sName || sName !== "cut" && sName !== "tr" && sName !== "sort" && sName !== "head" && sName !== "tail" && sName !== "wc" && sName !== "sed" && sName !== "uniq" && sName !== "rev" && sName !== "awk" && sName !== "grep" && sName !== "jq" && sName !== "base64" && sName !== "tac" && sName !== "nl") return false;
-            const sDef = this.commands.get(sName);
-            if (!sDef || customRegisteredCommands.has(sDef.execute) || sName !== "rev" && sName !== "tac" && !builtInDirectContextExecutors.has(sDef.execute)) return false;
+            if (!sName || sName !== "cut" && sName !== "tr" && sName !== "sort" && sName !== "head" && sName !== "tail" && sName !== "wc" && sName !== "sed" && sName !== "uniq" && sName !== "rev" && sName !== "awk" && sName !== "grep" && sName !== "jq" && sName !== "base64" && sName !== "tac" && sName !== "nl" && sName !== "paste" && sName !== "numfmt") return false;
+            const sDef = this.commands.get(sName) ?? (sName === "rev" || sName === "tac" || sName === "nl" || sName === "paste" || sName === "jq" ? this.getExternalCommand(sName) : void 0);
+            if (!sDef || customRegisteredCommands.has(sDef.execute) || sName !== "rev" && sName !== "tac" && sName !== "nl" && sName !== "paste" && sName !== "jq" && !builtInDirectContextExecutors.has(sDef.execute)) return false;
             if (rawState.functions.has(sName) || rawState.extensions?.builtins.has(sName)) return false;
             const sArgWords = sCmd.words.slice(1);
             const sPlainArgs = [];
             let allPlainStageArgs = true;
             for (let k = 0; k < sArgWords.length; k++) {
               const sw = sArgWords[k];
-              const sp = sw.plain ?? (sw.parts.length === 1 && sw.parts[0].kind === "text" ? sw.parts[0].value : void 0);
+              const sp = sw.plain ?? (sw.parts.length > 0 && sw.parts.every((pt) => pt.kind === "text") ? sw.parts.map((pt) => pt.value).join("") : void 0);
               if (sp === void 0) {
                 allPlainStageArgs = false;
                 break;
@@ -78985,43 +79254,44 @@ var Runtime = class _Runtime {
               sPlainArgs.push(sp);
             }
             if (!allPlainStageArgs) return false;
-            if (sName === "sort" && (sPlainArgs.length > 1 || sPlainArgs.length === 1 && sPlainArgs[0] !== "-r")) return false;
-            if (sName === "wc" && (sPlainArgs.length !== 1 || sPlainArgs[0] !== "-l" && sPlainArgs[0] !== "-c" && sPlainArgs[0] !== "-w")) return false;
-            if (sName === "head" || sName === "tail") {
-              const okHT = sPlainArgs.length === 2 && sPlainArgs[0] === "-n" && /^[0-9]+$/.test(sPlainArgs[1]) || sPlainArgs.length === 1 && /^-(?:n)?[0-9]+$/.test(sPlainArgs[0]);
+            if (sName === "sort") {
+              if (this.evalSyncSort([], sPlainArgs, byteLocale(rawState.variables)) === void 0) return false;
+            } else if (sName === "uniq") {
+              if (this.evalSyncUniq([], sPlainArgs) === void 0) return false;
+            } else if (sName === "wc") {
+              if (sPlainArgs.length !== 1 || this.normalizeSyncWcFlag(sPlainArgs[0]) === void 0) return false;
+            } else if (sName === "head" || sName === "tail") {
+              const okHT = sPlainArgs.length === 0 || sPlainArgs.length === 1 && (/^-(?:n|c)?[0-9]{1,5}$/.test(sPlainArgs[0]) || /^--(?:lines|bytes)=[0-9]{1,5}$/.test(sPlainArgs[0]) || sName === "tail" && /^(?:-n|--lines=)\+[0-9]{1,5}$/.test(sPlainArgs[0]) || sName === "head" && /^(?:-n|--lines=)-[0-9]{1,5}$/.test(sPlainArgs[0])) || sPlainArgs.length === 2 && (sPlainArgs[0] === "-n" && (/^[0-9]{1,5}$/.test(sPlainArgs[1]) || sName === "tail" && /^\+[0-9]{1,5}$/.test(sPlainArgs[1]) || sName === "head" && /^-[0-9]{1,5}$/.test(sPlainArgs[1])) || sPlainArgs[0] === "-c" && /^[0-9]{1,5}$/.test(sPlainArgs[1]));
               if (!okHT) return false;
+            } else if (sName === "cut") {
+              if (this.evalSyncCut(["\xE9"], sPlainArgs, byteLocale(rawState.variables)) === void 0) return false;
+            } else if (sName === "sed") {
+              if (this.evalSyncSed([], sPlainArgs) === void 0) return false;
+            } else if (sName === "awk") {
+              if (this.evalSyncAwk([], sPlainArgs) === void 0) return false;
+            } else if (sName === "grep") {
+              if (this.evalSyncGrep([], sPlainArgs, Boolean(rawState.errexit)) === void 0) return false;
+            } else if (sName === "tr") {
+              if (this.evalSyncTr("", sPlainArgs) === void 0) return false;
+            } else if (sName === "jq") {
+              if (sIdx !== 1) return false;
+              const jqIn = this.extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
+              if (jqIn === void 0 || this.evalSyncJq(jqIn, sPlainArgs) === void 0) return false;
+            } else if (sName === "base64") {
+              if (sPlainArgs.length !== 0) return false;
+            } else if (sName === "tac") {
+              if (sPlainArgs.length !== 0 || w0Plain !== "echo" && !hasSingleHereStringRedir) return false;
+            } else if (sName === "nl") {
+              if (w0Plain !== "echo" && !hasSingleHereStringRedir || this.evalSyncNl([], sPlainArgs) === void 0) return false;
+            } else if (sName === "paste") {
+              if (this.evalSyncPaste([], sPlainArgs) === void 0) return false;
+            } else if (sName === "numfmt") {
+              if (sIdx !== 1) return false;
+              const nmCheck = this.extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
+              if (nmCheck === void 0 || this.evalSyncNumfmt(nmCheck.split("\n"), sPlainArgs) === void 0) return false;
+            } else if (sName === "rev") {
+              if (sPlainArgs.length !== 0) return false;
             }
-            if (sName === "cut") {
-              const normCut = [];
-              for (let ci = 0; ci < sPlainArgs.length; ci++) {
-                const ca = sPlainArgs[ci];
-                if ((ca === "-d" || ca === "-f") && ci + 1 < sPlainArgs.length) {
-                  normCut.push(ca + sPlainArgs[++ci]);
-                } else {
-                  normCut.push(ca);
-                }
-              }
-              const vc2 = normCut.length === 2 && (normCut[0].length === 3 && normCut[0].startsWith("-d") && normCut[1].length >= 3 && normCut[1].startsWith("-f") || normCut[0] === "-c" && /^[1-9][0-9]*-[1-9][0-9]*$/.test(normCut[1]));
-              const vc1 = normCut.length === 1 && normCut[0].length >= 3 && normCut[0].startsWith("-f");
-              if (!vc1 && !vc2) return false;
-            }
-            if (sName === "awk") {
-              const normAwk = sPlainArgs.length === 3 && sPlainArgs[0] === "-F" ? ["-F" + sPlainArgs[1], sPlainArgs[2]] : sPlainArgs;
-              const awkSepOk = normAwk.length === 1 || normAwk.length === 2 && normAwk[0].length === 3 && normAwk[0].startsWith("-F") && normAwk[0][2] !== "\\";
-              const awkProg = normAwk[normAwk.length - 1] ?? "";
-              if (!awkSepOk || !/^\s*\{\s*print(?:\s+(\$(?:[0-9]+|NF)(?:\s*,\s*\$(?:[0-9]+|NF))*))?\s*;?\s*\}\s*$/.test(awkProg)) return false;
-            }
-            if (sName === "grep") {
-              const grepOk = sPlainArgs.length === 1 && !sPlainArgs[0].startsWith("-") && /^[a-zA-Z0-9_ :;,/-]+$/.test(sPlainArgs[0]) || sPlainArgs.length === 2 && (sPlainArgs[0] === "-v" || sPlainArgs[0] === "-i" || sPlainArgs[0] === "-c" || sPlainArgs[0] === "-F") && /^[a-zA-Z0-9_ :;,/-]+$/.test(sPlainArgs[1]);
-              if (!grepOk) return false;
-            }
-            if (sName === "jq") {
-              return false;
-            }
-            if (sName === "base64") {
-              if (sPlainArgs.length > 1 || sPlainArgs.length === 1 && sPlainArgs[0] !== "-d" && sPlainArgs[0] !== "--decode") return false;
-            }
-            if ((sName === "tac" || sName === "nl") && sPlainArgs.length !== 0) return false;
           }
         }
         continue;
@@ -79353,7 +79623,7 @@ var Runtime = class _Runtime {
           argIdx += 2;
         } else if (p === "-n" || p === "-rn" || p === "-nr" || p === "-N" || p === "-rN" || p === "-Nr") {
           if (p.includes("r")) rawMode = true;
-          exactChars = p.includes("N");
+          exactChars ||= p.includes("N");
           const nPlain = cmd.words[argIdx + 1]?.plain;
           if (!nPlain || !/^[1-9][0-9]{0,5}$/.test(nPlain) || byteLocale(rawState.variables)) return void 0;
           maxChars = Number(nPlain);
@@ -79361,7 +79631,7 @@ var Runtime = class _Runtime {
         } else if ((p.startsWith("-n") || p.startsWith("-rn") || p.startsWith("-N") || p.startsWith("-rN")) && /^[1-9][0-9]{0,5}$/.test(p.slice(p.startsWith("-r") ? 3 : 2))) {
           if (byteLocale(rawState.variables)) return void 0;
           if (p.startsWith("-r")) rawMode = true;
-          exactChars = p.includes("N");
+          exactChars ||= p.includes("N");
           maxChars = Number(p.slice(p.startsWith("-r") ? 3 : 2));
           argIdx++;
         } else if (p === "-ra" || p === "-ar" || p === "-a") {
@@ -79519,12 +79789,12 @@ var Runtime = class _Runtime {
               ifOk = false;
               break;
             }
-            if (!this.canSyncLoopBody(br.body, rawState, io, true)) {
+            if (!this.canSyncLoopBody(br.body, rawState, io, true, printfInductionName)) {
               ifOk = false;
               break;
             }
           }
-          if (ifOk && cmd.otherwise && !this.canSyncLoopBody(cmd.otherwise, rawState, io, true)) ifOk = false;
+          if (ifOk && cmd.otherwise && !this.canSyncLoopBody(cmd.otherwise, rawState, io, true, printfInductionName)) ifOk = false;
           if (ifOk) continue;
           return false;
         }
@@ -79542,7 +79812,7 @@ var Runtime = class _Runtime {
               caseOk = false;
               break;
             }
-            if (!this.canSyncLoopBody(cl.body, rawState, io, true)) {
+            if (!this.canSyncLoopBody(cl.body, rawState, io, true, printfInductionName)) {
               caseOk = false;
               break;
             }
@@ -80163,9 +80433,31 @@ var Runtime = class _Runtime {
     const condition = command7.kind === "arithmetic-for" ? command7.expressions[1]?.tree : void 0;
     const increment = command7.kind === "arithmetic-for" ? command7.expressions[2]?.tree : void 0;
     const whileCondCmd = command7.kind === "while" && command7.condition.lists.length === 1 && command7.condition.lists[0].pipelines.length === 1 ? command7.condition.lists[0].pipelines[0].commands[0] : void 0;
-    const whilePrintfInd = whileCondCmd?.kind === "arithmetic" && !whileCondCmd.expression.error && whileCondCmd.expression.tree?.kind === "binary" && (whileCondCmd.expression.tree.left.kind === "name" ? whileCondCmd.expression.tree.left.name : whileCondCmd.expression.tree.left.kind === "unary" && whileCondCmd.expression.tree.left.operand.kind === "name" ? whileCondCmd.expression.tree.left.operand.name : void 0);
-    const printfInductionName = initializer?.kind === "binary" && initializer.operator === "=" && initializer.left.kind === "name" && initializer.right.kind === "literal" && initializer.right.value >= 0n && initializer.right.value <= 2000n && condition?.kind === "binary" && (condition.operator === "<" || condition.operator === "<=") && condition.left.kind === "name" && condition.left.name === initializer.left.name && condition.right.kind === "literal" && condition.right.value >= 0n && condition.right.value <= 2000n && increment?.kind === "unary" && increment.operator === "++" && increment.operand.kind === "name" && increment.operand.name === initializer.left.name && this.canSyncPrintfInductionBody(command7.body, rawState) ? initializer.left.name : whilePrintfInd && this.canSyncPrintfInductionBody(command7.body, rawState) ? whilePrintfInd : void 0;
-    if (guestArrays(rawState) && (guestArrays(rawState).watches.size > 0 || this.budget.limits.maxExpansionBytes < 65536) || !this.canSyncLoopBody(command7.body, rawState, io, false, printfInductionName)) {
+    const whileTree = whileCondCmd?.kind === "arithmetic" && !whileCondCmd.expression.error ? whileCondCmd.expression.tree : void 0;
+    const whileName = whileTree?.kind === "binary" && (whileTree.operator === "<" || whileTree.operator === "<=") && whileTree.left.kind === "name" && whileTree.right.kind === "literal" && whileTree.right.value >= 0n && whileTree.right.value <= 2000n ? whileTree.left.name : void 0;
+    const whileValue = whileName === void 0 ? void 0 : rawState.variables[whileName];
+    const whileStart = typeof whileValue === "string" ? Number(whileValue) : NaN;
+    const whilePrintfInd = Number.isInteger(whileStart) && whileStart >= 0 && whileStart <= 2e3 && String(whileStart) === whileValue ? whileName : void 0;
+    const forPrintfInd = command7.kind === "for" && command7.words?.length === 1 && /^\{[0-9]{1,4}\.\.[0-9]{1,4}(?:\.\.[1-9][0-9]{0,2})?\}$/.test(command7.words[0].plain ?? "") ? command7.name : void 0;
+    const printfInductionName = initializer?.kind === "binary" && initializer.operator === "=" && initializer.left.kind === "name" && initializer.right.kind === "literal" && initializer.right.value >= 0n && initializer.right.value <= 2000n && condition?.kind === "binary" && (condition.operator === "<" || condition.operator === "<=") && condition.left.kind === "name" && condition.left.name === initializer.left.name && condition.right.kind === "literal" && condition.right.value >= 0n && condition.right.value <= 2000n && increment?.kind === "unary" && increment.operator === "++" && increment.operand.kind === "name" && increment.operand.name === initializer.left.name && this.canSyncPrintfInductionBody(command7.body, rawState, initializer.left.name) ? initializer.left.name : whilePrintfInd && this.canSyncPrintfInductionBody(command7.body, rawState, whilePrintfInd) ? whilePrintfInd : forPrintfInd && this.canSyncPrintfInductionBody(command7.body, rawState, forPrintfInd) ? forPrintfInd : void 0;
+    const prevActivePrintfInd = this._activePrintfInductionName;
+    const prevActiveLoopScript = this._activeLoopBodyScript;
+    const prevActiveLoopCond = this._activeLoopCondScript;
+    const prevActiveLoopVar = this._activeLoopVarName;
+    this._activePrintfInductionName = printfInductionName;
+    this._activeLoopBodyScript = command7.body;
+    this._activeLoopCondScript = command7.kind === "while" ? command7.condition : void 0;
+    this._activeLoopVarName = command7.kind === "for" ? command7.name : printfInductionName ?? (whilePrintfInd || void 0);
+    let bodySyncOk = false;
+    try {
+      bodySyncOk = !(guestArrays(rawState) && (guestArrays(rawState).watches.size > 0 || this.budget.limits.maxExpansionBytes < 65536)) && this.canSyncLoopBody(command7.body, rawState, io, false, printfInductionName);
+    } finally {
+      this._activePrintfInductionName = prevActivePrintfInd;
+      this._activeLoopBodyScript = prevActiveLoopScript;
+      this._activeLoopCondScript = prevActiveLoopCond;
+      this._activeLoopVarName = prevActiveLoopVar;
+    }
+    if (!bodySyncOk) {
       command7._skipTrySyncLoop = true;
       return void 0;
     }
@@ -80303,7 +80595,7 @@ var Runtime = class _Runtime {
             intSteps2[b] = intStep;
             continue;
           }
-          const wordsToScan = step.arrayAssign?.kind === "compound" ? step.arrayAssign.entries.map((e) => e.value) : step.value ? [step.value] : [];
+          const wordsToScan = step.arrayAssign?.kind === "compound" ? step.arrayAssign.entries.map((e) => e.value) : step.printfVArgs ? step.printfVArgs : step.value ? [step.value] : [];
           for (let wIdx = 0; wIdx < wordsToScan.length; wIdx++) {
             const wVal = wordsToScan[wIdx];
             for (let i = 0; i < wVal.parts.length; i++) {
@@ -81402,18 +81694,172 @@ ${s1}
     }
     return pos <= 128 ? fastRedirectScratchViews[pos] : fastRedirectScratchBytes.subarray(0, pos);
   }
-  canSyncPrintfInductionBody(script2, rawState) {
+  _activePrintfInductionName = void 0;
+  _activeLoopBodyScript = void 0;
+  _activeLoopCondScript = void 0;
+  _activeLoopVarName = void 0;
+  isVarUnmutatedInScript(varName, script2) {
+    for (const list of script2.lists) {
+      for (const pipeline of list.pipelines) {
+        for (const cmd of pipeline.commands) {
+          if (cmd.kind === "arithmetic") {
+            if (cmd.expression.hasMutation && cmd.expression.source.includes(varName)) return false;
+            continue;
+          }
+          if (cmd.kind === "if") {
+            for (const br of cmd.branches) {
+              if (!this.isVarUnmutatedInScript(varName, br.condition) || !this.isVarUnmutatedInScript(varName, br.body)) return false;
+            }
+            if (cmd.otherwise && !this.isVarUnmutatedInScript(varName, cmd.otherwise)) return false;
+            continue;
+          }
+          if (cmd.kind === "case") {
+            for (const cl of cmd.clauses) {
+              if (!this.isVarUnmutatedInScript(varName, cl.body)) return false;
+            }
+            continue;
+          }
+          if (cmd.kind === "for") {
+            if (cmd.name === varName || !this.isVarUnmutatedInScript(varName, cmd.body)) return false;
+            continue;
+          }
+          if (cmd.kind === "arithmetic-for") {
+            if (cmd.expressions.some((e) => e && e.hasMutation && e.source.includes(varName)) || !this.isVarUnmutatedInScript(varName, cmd.body)) return false;
+            continue;
+          }
+          if (cmd.kind === "while") {
+            if (!this.isVarUnmutatedInScript(varName, cmd.condition) || !this.isVarUnmutatedInScript(varName, cmd.body)) return false;
+            continue;
+          }
+          if (cmd.kind === "group" || cmd.kind === "subshell") {
+            if (!this.isVarUnmutatedInScript(varName, cmd.body)) return false;
+            continue;
+          }
+          if (cmd.kind !== "simple") return false;
+          for (const w of cmd.words) {
+            const arrAss = getArrayAssignment(w);
+            if (arrAss && arrAss.name === varName) return false;
+            const p02 = w.parts[0];
+            if (p02?.kind === "text" && !p02.quoted && (p02.value.startsWith(varName + "=") || p02.value.startsWith(varName + "+=") || p02.value.startsWith(varName + "["))) return false;
+          }
+          const w0 = cmd.words[0]?.plain;
+          if (w0 === "read" || w0 === "unset" || w0 === "declare" || w0 === "typeset" || w0 === "local" || w0 === "export" || w0 === "mapfile" || w0 === "readarray") {
+            if (w0 === "read" && varName === "REPLY") return false;
+            if (cmd.words.slice(1).some((w) => (w.plain ?? "").includes(varName))) return false;
+          }
+          if (w0 === "printf" && cmd.words[1]?.plain === "-v" && (cmd.words[2]?.plain ?? "").startsWith(varName)) return false;
+          for (const w of [...cmd.words, ...cmd.redirects.map((r) => r.target)]) {
+            for (const pt of w.parts) {
+              if (pt.kind === "arithmetic" && pt.expression.hasMutation && pt.expression.source.includes(varName)) return false;
+              if (pt.kind === "substitution" && !this.isVarUnmutatedInScript(varName, pt.script)) return false;
+            }
+          }
+        }
+      }
+    }
+    return true;
+  }
+  isVarUnmutatedInActiveLoop(varName) {
+    if (varName === this._activeLoopVarName || varName === this._activePrintfInductionName) return false;
+    if (this._activeLoopCondScript && !this.isVarUnmutatedInScript(varName, this._activeLoopCondScript)) return false;
+    if (this._activeLoopBodyScript && !this.isVarUnmutatedInScript(varName, this._activeLoopBodyScript)) return false;
+    return true;
+  }
+  isFileReadOnlyScript(script2, rawState) {
+    const visit = (value2) => {
+      if (value2 === null || typeof value2 !== "object") return true;
+      if (Array.isArray(value2)) return value2.every(visit);
+      const node = value2;
+      if (typeof node.operator === "string" && "target" in node && !["<", "<<<", "<<", "<<-"].includes(node.operator)) return false;
+      if (node.kind === "simple") {
+        const cmd = value2;
+        const name2 = cmd.words[0]?.plain;
+        if (name2 === void 0 && !cmd.words.every((word) => this.assignment(word) || getArrayAssignment(word))) return false;
+        if (name2 !== void 0 && (hasShellFunction(rawState, name2) || !["jq", "cat", "echo", "printf", "test", "[", ":", "true", "false"].includes(name2))) return false;
+      }
+      return Object.values(node).every(visit);
+    };
+    return visit(script2);
+  }
+  extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState) {
+    const w0 = cmd.words[0]?.plain;
+    const resolveInvariantWord = (w) => {
+      if (w.plain !== void 0) return w.plain;
+      if (w.parts.length > 0 && w.parts.every((pt) => pt.kind === "text")) return w.parts.map((pt) => pt.value).join("");
+      if (w.parts.length === 1 && w.parts[0].kind === "variable") {
+        const vp = w.parts[0];
+        if (!vp.indirect && !vp.operator && !vp.substring && !vp.transform && !vp.length && !vp.prefixNames && getArraySelector(vp) === void 0 && this.isVarUnmutatedInActiveLoop(vp.name)) {
+          const val = rawState.variables[vp.name];
+          if (typeof val === "string") return val;
+        }
+      }
+      return void 0;
+    };
+    if (w0 === "jq" || w0 === "numfmt") {
+      if (hasSingleHereStringRedir) {
+        const resolved = resolveInvariantWord(cmd.redirects[0].target);
+        return resolved !== void 0 ? resolved.trim() : void 0;
+      }
+      if (this._fileWrites?.size || this._outputFiles?.size) return void 0;
+      if ([this._activeLoopBodyScript, this._activeLoopCondScript].some((script2) => script2 && !this.isFileReadOnlyScript(script2, rawState))) return void 0;
+      const fPlain = hasSingleStdinRedir ? cmd.redirects[0].target.plain : cmd.words[cmd.words.length - 1]?.plain;
+      if (!fPlain || fPlain.startsWith("-") || fPlain === "/dev/stdin") return void 0;
+      const vCheck = this.tryReadMemoryFileViewSync(resolvePath(rawState.cwd, fPlain), false);
+      if (!vCheck || vCheck.byteLength > 16384 || vCheck.includes(0)) return void 0;
+      return sharedSyncPipeDecoder.decode(vCheck).trim();
+    }
+    if (w0 === "cat") {
+      if (hasSingleHereStringRedir) {
+        const resolved = resolveInvariantWord(cmd.redirects[0].target);
+        return resolved !== void 0 ? resolved.trim() : void 0;
+      }
+      if (this._fileWrites?.size || this._outputFiles?.size) return void 0;
+      if ([this._activeLoopBodyScript, this._activeLoopCondScript].some((script2) => script2 && !this.isFileReadOnlyScript(script2, rawState))) return void 0;
+      const fPlain = hasSingleStdinRedir ? cmd.redirects[0].target.plain : cmd.words[1]?.plain;
+      if (!fPlain || fPlain.startsWith("-") || fPlain === "/dev/stdin") return void 0;
+      const vCheck = this.tryReadMemoryFileViewSync(resolvePath(rawState.cwd, fPlain), false);
+      if (!vCheck || vCheck.byteLength > 16384 || vCheck.includes(0)) return void 0;
+      return sharedSyncPipeDecoder.decode(vCheck).trim();
+    }
+    if (w0 === "echo" && cmd.words.length === 2) {
+      const resolved = resolveInvariantWord(cmd.words[1]);
+      if (resolved !== void 0 && !resolved.startsWith("-")) return resolved.trim();
+      return void 0;
+    }
+    if (w0 === "printf" && cmd.words.length >= 2) {
+      const args = [];
+      for (let i = 1; i < cmd.words.length; i++) {
+        const r = resolveInvariantWord(cmd.words[i]);
+        if (r === void 0) return void 0;
+        args.push(r);
+      }
+      const formatted3 = tryFastPrintf(args);
+      return formatted3 !== void 0 ? formatted3.trim() : void 0;
+    }
+    return void 0;
+  }
+  canSyncPrintfInductionBody(script2, rawState, inductionName) {
     for (const list of script2.lists) for (const pipeline of list.pipelines) for (const command7 of pipeline.commands) {
       if (command7.kind === "arithmetic") {
-        if (command7.redirects.length === 0 && !command7.expression.error && !command7.expression.hasSubscript && isSafeSmiProgram(command7.expression) && command7.expression.tree?.kind === "unary" && (command7.expression.tree.operator === "++" || command7.expression.tree.operator === "--") && command7.expression.tree.operand.kind === "name") continue;
+        if (command7.redirects.length === 0 && !command7.expression.error && !command7.expression.hasSubscript && isSafeSmiProgram(command7.expression) && command7.expression.tree?.kind === "unary" && (command7.expression.tree.operator === "++" || command7.expression.tree.operator === "--" && command7.expression.tree.operand.kind === "name" && command7.expression.tree.operand.name !== inductionName) && command7.expression.tree.operand.kind === "name") continue;
         return false;
       }
       if (command7.kind !== "simple" || hasShellFunction(rawState, command7.words[0]?.plain ?? "") || command7.words.some((word) => getArrayAssignment(word) !== void 0)) return false;
+      const w0 = command7.words[0]?.plain;
+      if (w0 === "let" || w0 === "declare" || w0 === "typeset" || w0 === "local" || w0 === "export" || w0 === "unset" || w0 === "mapfile" || w0 === "readarray") return false;
+      if (inductionName !== void 0) {
+        if (command7.words.some((w) => {
+          const p02 = w.parts[0];
+          return p02?.kind === "text" && !p02.quoted && (p02.value.startsWith(inductionName + "=") || p02.value.startsWith(inductionName + "+="));
+        })) return false;
+        if (w0 === "read" && (inductionName === "REPLY" || command7.words.slice(1).some((w) => w.plain === inductionName || w.plain === "-a" || w.plain === "-ra" || w.plain === "-ar"))) return false;
+        if (w0 === "printf" && command7.words[1]?.plain === "-v" && command7.words[2]?.plain === inductionName) return false;
+      }
       for (const word of [...command7.words, ...command7.redirects.map((redirect) => redirect.target)]) for (const part of word.parts) {
         if (part.kind === "text") continue;
-        if (part.kind === "variable" && !part.indirect && !part.length && !part.substring && !part.transform && !part.prefixNames && part.operator === void 0 && getArraySelector(part) === void 0) continue;
+        if (part.kind === "variable" && !part.indirect && !part.substring && !part.prefixNames && getArraySelector(part) === void 0 && (part.operator === void 0 || (part.operator === "#" || part.operator === "##" || part.operator === "%" || part.operator === "%%") && part.alternate !== void 0 && part.alternate.parts.every((p) => p.kind === "text"))) continue;
         if (part.kind === "arithmetic" && !part.expression.error && !part.expression.hasMutation && !part.expression.hasSubscript && isSafeSmiProgram(part.expression) && /^[a-zA-Z0-9_ +*-]+$/.test(part.expression.source)) continue;
-        if (part.kind === "substitution" && this.canSyncPrintfInductionBody(part.script, rawState)) continue;
+        if (part.kind === "substitution" && this.canSyncPrintfInductionBody(part.script, rawState, inductionName)) continue;
         return false;
       }
     }
@@ -81422,26 +81868,66 @@ ${s1}
   isSyncPrintfCallOk(cmd, argStartIdx, rawState, inductionName) {
     const printfDef = this.commands.get("printf");
     if (hasShellFunction(rawState, "printf") || rawState.extensions?.builtins.has("printf") || printfDef?.execute !== printfCommand.execute) return false;
-    const args = [];
+    const effInductionName = inductionName ?? this._activePrintfInductionName;
+    const unsignedUpperBound = (tree) => {
+      if (!tree) return void 0;
+      let bound;
+      if (tree.kind === "literal") bound = tree.value;
+      else if (tree.kind === "name" && tree.name === effInductionName && tree.subscript === void 0) bound = 2147483647n;
+      else if (tree.kind === "binary" && (tree.operator === "+" || tree.operator === "*")) {
+        const left = unsignedUpperBound(tree.left);
+        const right = unsignedUpperBound(tree.right);
+        if (left !== void 0 && right !== void 0) bound = tree.operator === "+" ? left + right : left * right;
+      }
+      return bound !== void 0 && bound >= 0n && bound <= 2147483647n ? bound : void 0;
+    };
     const fmtWordIdx = cmd.words[argStartIdx]?.plain === "--" ? argStartIdx + 1 : argStartIdx;
     if (fmtWordIdx >= cmd.words.length) return false;
-    for (let i = argStartIdx; i < cmd.words.length; i++) {
+    const fmtWord = cmd.words[fmtWordIdx];
+    if (!this.isPureSyncValueWord(fmtWord, rawState)) return false;
+    let fmtStr = "";
+    for (const part of fmtWord.parts) {
+      if (part.kind !== "text" || !part.quoted && (part.value.length === 0 || part.value.includes(" ") || part.value.includes("	") || part.value.includes("\n") || part.value.includes("{") || hasGlobOrEscape(part.value, true))) return false;
+      fmtStr += part.value;
+    }
+    if (fmtWordIdx === argStartIdx && fmtStr.startsWith("-")) return false;
+    const specs = extractFastPrintfSpecifiers(fmtStr);
+    if (!specs) return false;
+    const args = [];
+    if (fmtWordIdx > argStartIdx) args.push("--");
+    args.push(fmtStr);
+    for (let i = fmtWordIdx + 1; i < cmd.words.length; i++) {
       const w = cmd.words[i];
       if (!this.isPureSyncValueWord(w, rawState)) return false;
-      const valueParts = w.parts.filter((part2) => part2.kind !== "text" || part2.value.length > 0);
-      const part = valueParts[0];
-      if (i > fmtWordIdx && valueParts.length === 1 && part?.kind === "variable" && part.name === inductionName && part.quoted && !part.indirect && !part.length && !part.substring && !part.transform && part.operator === void 0 && getArraySelector(part) === void 0) {
-        args.push("0");
+      const argIdx = i - fmtWordIdx - 1;
+      const spec = specs.length > 0 ? specs[argIdx % specs.length] : "s";
+      const nonSplitting = w.parts.length > 0 && w.parts.every(
+        (part2) => part2.quoted || part2.kind === "text" && part2.value.length > 0 && !part2.value.includes(" ") && !part2.value.includes("	") && !part2.value.includes("\n") && !part2.value.includes("{") && !hasGlobOrEscape(part2.value, true)
+      );
+      if (spec === "s" && nonSplitting) {
+        args.push("");
         continue;
       }
-      if (i > fmtWordIdx && inductionName !== void 0 && valueParts.length === 1 && part?.kind === "arithmetic" && part.quoted && !part.expression.error && !part.expression.hasMutation && !part.expression.hasSubscript && isSafeSmiProgram(part.expression) && /^[a-zA-Z0-9_ +*-]+$/.test(part.expression.source) && this.canSyncArithmeticWithoutFault(part.expression.tree, rawState, cmd.line ?? 1)) {
-        args.push("0");
-        continue;
+      const valueParts = w.parts.filter((part2) => part2.kind !== "text" || part2.value.length > 0);
+      const part = valueParts[0];
+      if ((spec === "d" || spec === "u") && valueParts.length === 1 && part?.quoted) {
+        if (part.kind === "variable" && part.name === effInductionName && !part.indirect && !part.length && !part.substring && !part.transform && part.operator === void 0 && getArraySelector(part) === void 0) {
+          args.push("0");
+          continue;
+        }
+        if (part.kind === "variable" && part.length && !part.indirect && !part.prefixNames && getArraySelector(part) === void 0) {
+          args.push("0");
+          continue;
+        }
+        if (part.kind === "arithmetic" && !part.expression.error && !part.expression.hasMutation && !part.expression.hasSubscript && isSafeSmiProgram(part.expression) && /^[a-zA-Z0-9_ +*-]+$/.test(part.expression.source) && this.canSyncArithmeticWithoutFault(part.expression.tree, rawState, cmd.line ?? 1) && (spec === "d" || unsignedUpperBound(part.expression.tree) !== void 0)) {
+          args.push("0");
+          continue;
+        }
       }
       let arg = "";
-      for (const part2 of w.parts) {
-        if (part2.kind !== "text" || !part2.quoted && (part2.value.length === 0 || part2.value.includes(" ") || part2.value.includes("	") || part2.value.includes("\n") || part2.value.includes("{") || hasGlobOrEscape(part2.value, true))) return false;
-        arg += part2.value;
+      for (const p of w.parts) {
+        if (p.kind !== "text" || !p.quoted && (p.value.length === 0 || p.value.includes(" ") || p.value.includes("	") || p.value.includes("\n") || p.value.includes("{") || hasGlobOrEscape(p.value, true))) return false;
+        arg += p.value;
       }
       args.push(arg);
     }
@@ -81452,6 +81938,15 @@ ${s1}
     if (!p02 || p02.kind !== "text" || p02.value.length === 0 || p02.value.startsWith("-")) return false;
     return w.parts.every((p) => p.kind === "text" || p.kind === "variable" && !p.indirect && !p.prefixNames && !p.length && !p.substring && p.operator === void 0 && getArraySelector(p) === void 0);
   }
+  syncStringLength(value2, byteCount2) {
+    let length = 0;
+    for (let offset = 0; offset < value2.length; ) {
+      const point = value2.codePointAt(offset);
+      length += byteCount2 ? point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4 : 1;
+      offset += point > 65535 ? 2 : 1;
+    }
+    return length;
+  }
   execSyncReadHereStringStep(rs, step, rawState, io, monitor, touched) {
     const rawInput = this.fastValueWord(rs.inputWord, rawState, io, false, false, false, false, 0, step.line);
     const delim = rs.delimChar ?? "\n";
@@ -81459,15 +81954,16 @@ ${s1}
     let status2 = 0;
     if (rs.maxChars !== void 0) {
       const fullInput = rawInput + "\n";
-      if (rs.exactChars) {
-        lineStr = fullInput.length > rs.maxChars ? fullInput.slice(0, rs.maxChars) : fullInput;
-        status2 = fullInput.length >= rs.maxChars ? 0 : 1;
-      } else {
-        const nlIdx = fullInput.indexOf(delim);
-        const untilDelim = nlIdx === -1 ? fullInput : fullInput.slice(0, nlIdx);
-        lineStr = untilDelim.length > rs.maxChars ? untilDelim.slice(0, rs.maxChars) : untilDelim;
-        status2 = nlIdx !== -1 || fullInput.length >= rs.maxChars ? 0 : 1;
+      const nlIdx = rs.exactChars ? -1 : fullInput.indexOf(delim);
+      const end = nlIdx === -1 ? fullInput.length : nlIdx;
+      let position = 0;
+      let count2 = 0;
+      while (position < end && count2 < rs.maxChars) {
+        position = nextCodePointOffset(fullInput, position);
+        count2++;
       }
+      lineStr = fullInput.slice(0, position);
+      status2 = count2 >= rs.maxChars || nlIdx !== -1 ? 0 : 1;
     } else {
       const fullInput = delim === "\n" ? rawInput : rawInput + "\n";
       const nlIdx = rs.isMapfile ? -1 : fullInput.indexOf(delim);
@@ -88198,7 +88694,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
             invalid = true;
             break;
           }
-          if (flag === "n" || flag === "N") exact = flag === "N";
+          if (flag === "N") exact = true;
           const value2 = option.slice(index + 1) || names.shift();
           if (value2 === void 0) invalid = true;
           else if (flag === "p") {
@@ -88603,7 +89099,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     }
     if (part.kind === "variable" && part.prefixNames) {
       const ifs = state.variables.IFS ?? " ";
-      const separator = io.nameExpansionContext === "document" || io.nameExpansionContext === "conditional" && part.prefixNames === "@" ? " " : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
+      const separator = io.nameExpansionContext === "document" || part.prefixNames === "@" && (io.nameExpansionContext === "conditional" || ifs.length === 0) ? " " : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
       const fragments2 = [];
       let bytes2 = 0;
       for await (const name2 of this.prefixNames(part.name, state)) {
@@ -89432,7 +89928,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
           const pNames = this.collectSyncPrefixNames(part.name, rawState);
           if (pNames === void 0) return void 0;
           const ifs = rawState.variables.IFS ?? " ";
-          const sep = io.nameExpansionContext === "document" || io.nameExpansionContext === "conditional" && part.prefixNames === "@" ? " " : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
+          const sep = io.nameExpansionContext === "document" || part.prefixNames === "@" && (io.nameExpansionContext === "conditional" || ifs.length === 0) ? " " : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
           const joined = pNames.join(sep);
           if (split3 && !part.quoted) {
             if (joined.length === 0 || joined.includes(" ") || joined.includes("	") || joined.includes("\n")) return void 0;
@@ -89674,10 +90170,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
             if (part.length) {
               if (part.operator !== void 0) return void 0;
               const s = elemVal ?? "";
-              for (let k = 0; k < s.length; k++) {
-                if (s.charCodeAt(k) >= 128) return void 0;
-              }
-              out += String(s.length);
+              out += String(this.syncStringLength(s, byteLocale(rawVars)));
               continue;
             }
             let resolvedElem;
@@ -89783,10 +90276,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
           this.requireParameter(raw2, part.name, state, io, part.line ?? overrideDiagnosticLine);
           const val2 = raw2 === void 0 ? "" : this._syncArithRawWriteOnly && this._syncArithTouched?.has(part.name) ? raw2 : monitor?.values.get(part.name, raw2) ?? raw2;
           if (typeof val2 !== "string") return void 0;
-          for (let k = 0; k < val2.length; k++) {
-            if (val2.charCodeAt(k) >= 128) return void 0;
-          }
-          out += String(val2.length);
+          out += String(this.syncStringLength(val2, byteLocale(rawVars)));
           continue;
         }
         if (part.operator !== void 0) {
@@ -90021,6 +90511,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   }
   expandSyncTrCharArray(spec) {
     if (spec.length === 0) return void 0;
+    if (spec.includes("\\") && spec.includes("-")) return void 0;
     const posixClasses = {
       "[:lower:]": "abcdefghijklmnopqrstuvwxyz",
       "[:upper:]": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
@@ -90052,7 +90543,15 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         else if (next === "t") out.push("	");
         else if (next === "r") out.push("\r");
         else if (next === "\\") out.push("\\");
-        else return void 0;
+        else if (next >= "0" && next <= "7") {
+          let oct = next;
+          while (oct.length < 3 && i + 1 < spec.length && spec[i + 1] >= "0" && spec[i + 1] <= "7") {
+            oct += spec[++i];
+          }
+          const code = parseInt(oct, 8);
+          if (code <= 0 || code >= 128) return void 0;
+          out.push(String.fromCharCode(code));
+        } else return void 0;
         continue;
       }
       if (i + 2 < spec.length && spec[i + 1] === "-" && spec[i + 2] !== "\\") {
@@ -90070,11 +90569,107 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     return out;
   }
   evalSyncTr(input3, opArgs) {
-    if (opArgs.length === 2 && !opArgs[0].startsWith("-") && !opArgs[1].startsWith("-")) {
-      return this.translateSyncTr(input3, opArgs[0], opArgs[1]);
+    let idx = 0;
+    let flagC = false;
+    let flagD = false;
+    let flagS = false;
+    let flagT = false;
+    while (idx < opArgs.length) {
+      const a = opArgs[idx];
+      if (a === "--") {
+        idx++;
+        break;
+      }
+      if (!a.startsWith("-") || a === "-") break;
+      if (!/^-[cCdst]+$/.test(a)) return void 0;
+      for (let k = 1; k < a.length; k++) {
+        const ch = a[k];
+        if (ch === "c" || ch === "C") flagC = true;
+        else if (ch === "d") flagD = true;
+        else if (ch === "s") flagS = true;
+        else if (ch === "t") flagT = true;
+      }
+      idx++;
+    }
+    if (flagT && flagC) return void 0;
+    const sets = opArgs.slice(idx);
+    if (flagC) {
+      if (sets.some((s) => {
+        for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) >= 128) return true;
+        return false;
+      })) return void 0;
+      if (flagD && !flagS && sets.length === 1) {
+        const arr = this.expandSyncTrCharArray(sets[0]);
+        if (!arr) return void 0;
+        const keepSet = new Set(arr);
+        let out = "";
+        for (let i = 0; i < input3.length; i++) {
+          const ch = input3[i];
+          if (keepSet.has(ch)) out += ch;
+        }
+        return out;
+      }
+      if (!flagD && sets.length === 2) {
+        if (sets[1].includes("[:")) return void 0;
+        const arr1 = this.expandSyncTrCharArray(sets[0]);
+        const arr2 = this.expandSyncTrCharArray(sets[1]);
+        if (!arr1 || !arr2 || arr2.length !== 1) return void 0;
+        const keepSet = new Set(arr1);
+        const repl = arr2[arr2.length - 1];
+        const sqSet = flagS ? new Set(arr2) : void 0;
+        let hasNonAscii = false;
+        for (let i = 0; i < input3.length; i++) {
+          if (input3.charCodeAt(i) >= 128) {
+            hasNonAscii = true;
+            break;
+          }
+        }
+        let out = "";
+        let prev = "";
+        if (hasNonAscii) {
+          const bytes2 = fastSharedTextEncoder.encode(input3);
+          for (let i = 0; i < bytes2.length; i++) {
+            const rawCh = String.fromCharCode(bytes2[i]);
+            const ch = keepSet.has(rawCh) ? rawCh : repl;
+            if (sqSet && sqSet.has(ch) && ch === prev) continue;
+            out += ch;
+            prev = ch;
+          }
+        } else {
+          for (let i = 0; i < input3.length; i++) {
+            const rawCh = input3[i];
+            const ch = keepSet.has(rawCh) ? rawCh : repl;
+            if (sqSet && sqSet.has(ch) && ch === prev) continue;
+            out += ch;
+            prev = ch;
+          }
+        }
+        return out;
+      }
+      if (flagD && flagS && sets.length === 2) {
+        const arr1 = this.expandSyncTrCharArray(sets[0]);
+        const arr2 = this.expandSyncTrCharArray(sets[1]);
+        if (!arr1 || !arr2) return void 0;
+        const keepSet = new Set(arr1);
+        const sqSet = new Set(arr2);
+        let out = "";
+        let prev = "";
+        for (let i = 0; i < input3.length; i++) {
+          const ch = input3[i];
+          if (!keepSet.has(ch)) continue;
+          if (sqSet.has(ch) && ch === prev) continue;
+          out += ch;
+          prev = ch;
+        }
+        return out;
+      }
+      return void 0;
+    }
+    if (!flagD && !flagS && sets.length === 2) {
+      return this.translateSyncTr(input3, sets[0], sets[1], flagT);
     }
-    if (opArgs.length === 2 && opArgs[0] === "-d" && !opArgs[1].startsWith("-")) {
-      const arr = this.expandSyncTrCharArray(opArgs[1]);
+    if (flagD && !flagS && sets.length === 1) {
+      const arr = this.expandSyncTrCharArray(sets[0]);
       if (!arr) return void 0;
       const delSet = new Set(arr);
       let out = "";
@@ -90084,8 +90679,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       }
       return out;
     }
-    if (opArgs.length === 2 && opArgs[0] === "-s" && !opArgs[1].startsWith("-")) {
-      const arr = this.expandSyncTrCharArray(opArgs[1]);
+    if (!flagD && flagS && sets.length === 1) {
+      const arr = this.expandSyncTrCharArray(sets[0]);
       if (!arr) return void 0;
       const sqSet = new Set(arr);
       let out = "";
@@ -90098,110 +90693,516 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       }
       return out;
     }
-    if (opArgs.length === 3 && (opArgs[0] === "-s" || opArgs[0] === "-ds" || opArgs[0] === "-sd") && !opArgs[1].startsWith("-") && !opArgs[2].startsWith("-")) {
-      const stage1 = opArgs[0] === "-s" ? this.translateSyncTr(input3, opArgs[1], opArgs[2]) : this.evalSyncTr(input3, ["-d", opArgs[1]]);
+    if (sets.length === 2 && (flagS || flagD)) {
+      const stage1 = !flagD ? this.translateSyncTr(input3, sets[0], sets[1], flagT) : this.evalSyncTr(input3, ["-d", sets[0]]);
       if (stage1 === void 0) return void 0;
-      return this.evalSyncTr(stage1, ["-s", opArgs[2]]);
+      return this.evalSyncTr(stage1, ["-s", sets[1]]);
     }
     return void 0;
   }
+  evalSyncJqPathOps(item, expr) {
+    let st = expr.trim();
+    let alternatives = splitSyncJqExpression(st, "//");
+    if (!alternatives) return void 0;
+    while (alternatives.wrapped) {
+      st = st.slice(1, -1).trim();
+      alternatives = splitSyncJqExpression(st, "//");
+      if (!alternatives) return void 0;
+    }
+    if (alternatives.parts.length > 1) {
+      const lhs = alternatives.parts[0];
+      const rhs = alternatives.parts.slice(1).join("//");
+      const lVals = this.evalSyncJqPathOps(item, lhs);
+      if (lVals === void 0) return void 0;
+      let rVals = this.evalSyncJqPathOps(item, rhs);
+      if (rVals === void 0) {
+        try {
+          rVals = [JSON.parse(rhs)];
+        } catch {
+          return void 0;
+        }
+      }
+      const truthy = lVals.filter((v) => v !== null && v !== void 0 && v !== false);
+      return truthy.length > 0 ? truthy : rVals;
+    }
+    const pipeSplit = splitSyncJqExpression(st, "|");
+    if (pipeSplit && pipeSplit.parts.length > 1) {
+      let cur2 = [item];
+      for (const pStage of pipeSplit.parts) {
+        const next = [];
+        for (const it of cur2) {
+          const r = this.evalSyncJqPathOps(it, pStage);
+          if (r === void 0) return void 0;
+          for (const rv of r) next.push(rv);
+        }
+        cur2 = next;
+      }
+      return cur2;
+    }
+    if (st === ".") return [item];
+    const dotArithM = /^\.\s*([+*\/%-])\s*(-?[0-9]+(?:\.[0-9]+)?)$/.exec(st);
+    if (dotArithM && typeof item === "number") {
+      const op = dotArithM[1];
+      const rhs = Number(dotArithM[2]);
+      if ((op === "/" || op === "%") && rhs === 0) return void 0;
+      return [op === "+" ? item + rhs : op === "-" ? item - rhs : op === "*" ? item * rhs : op === "/" ? item / rhs : item % rhs];
+    }
+    if (st === "floor") return typeof item === "number" ? [Math.floor(item)] : void 0;
+    if (st === "ceil") return typeof item === "number" ? [Math.ceil(item)] : void 0;
+    if (st === "round") return typeof item === "number" ? [Math.round(item)] : void 0;
+    if (st === "abs") return typeof item === "number" ? [Math.abs(item)] : void 0;
+    if (st === "utf8bytelength") return typeof item === "string" ? [import_buffer.Buffer.byteLength(item, "utf8")] : void 0;
+    if (st === "explode") return typeof item === "string" ? [Array.from(item, (c) => c.codePointAt(0))] : void 0;
+    if (st === "implode") {
+      if (!Array.isArray(item) || !item.every((x) => typeof x === "number" && Number.isInteger(x) && x >= 0 && x <= 1114111)) return void 0;
+      return [String.fromCodePoint(...item)];
+    }
+    if (st === "transpose") {
+      if (!Array.isArray(item) || !item.every((row) => Array.isArray(row))) return void 0;
+      const rows = item;
+      const maxCols = rows.reduce((m, r) => Math.max(m, r.length), 0);
+      const trans = [];
+      for (let c = 0; c < maxCols; c++) {
+        trans.push(rows.map((r) => c < r.length ? r[c] : null));
+      }
+      return [trans];
+    }
+    const idxFnM = /^(index|rindex|indices)\(\s*"([^"\\]*)"\s*\)$/.exec(st);
+    if (idxFnM && typeof item === "string") {
+      const fn = idxFnM[1];
+      const sub = idxFnM[2];
+      const found = [];
+      if (sub.length > 0) {
+        let pos = 0;
+        while ((pos = item.indexOf(sub, pos)) !== -1) {
+          found.push(Array.from(item.slice(0, pos)).length);
+          pos += 1;
+        }
+      }
+      if (fn === "indices") return [found];
+      if (fn === "index") return [found.length > 0 ? found[0] : null];
+      return [found.length > 0 ? found[found.length - 1] : null];
+    }
+    if (st === "length") {
+      if (item === null || item === void 0) return [0];
+      if (typeof item === "string") return [Array.from(item).length];
+      if (typeof item === "number") return [Math.abs(item)];
+      if (Array.isArray(item)) return [item.length];
+      if (typeof item === "object") return [Object.keys(item).length];
+      return void 0;
+    }
+    if (st === "keys") {
+      if (Array.isArray(item)) return [item.map((_, idx) => idx)];
+      if (item && typeof item === "object") return [Object.keys(item).sort()];
+      return void 0;
+    }
+    if (st === "keys[]") {
+      if (Array.isArray(item)) return item.map((_, idx) => idx);
+      if (item && typeof item === "object") return Object.keys(item).sort();
+      return void 0;
+    }
+    if (st === "values") {
+      return item === null || item === void 0 ? [] : [item];
+    }
+    if (st === "empty") return [];
+    if (st === "not") return [!(item !== false && item !== null && item !== void 0)];
+    if (st === "any") return Array.isArray(item) ? [item.some((x) => x !== false && x !== null && x !== void 0)] : void 0;
+    if (st === "all") return Array.isArray(item) ? [item.every((x) => x !== false && x !== null && x !== void 0)] : void 0;
+    if (st === "keys_unsorted") {
+      if (Array.isArray(item)) return [item.map((_, idx) => idx)];
+      if (item && typeof item === "object") return [Object.keys(item)];
+      return void 0;
+    }
+    if (st === "flatten") return Array.isArray(item) ? [item.flat(Infinity)] : void 0;
+    const flatM = /^flatten\(\s*([0-9]{1,2})\s*\)$/.exec(st);
+    if (flatM) return Array.isArray(item) ? [item.flat(Number(flatM[1]))] : void 0;
+    if (st === "sort") {
+      if (!Array.isArray(item)) return void 0;
+      if (item.every((x) => typeof x === "number")) return [[...item].sort((a, b) => a - b)];
+      if (item.every((x) => typeof x === "string")) return [[...item].sort()];
+      return void 0;
+    }
+    if (st === "tojson") return [JSON.stringify(item)];
+    if (st === "fromjson") {
+      if (typeof item !== "string") return void 0;
+      try {
+        return [JSON.parse(item)];
+      } catch {
+        return void 0;
+      }
+    }
+    const mvM = /^map_values\(\s*(.+)\s*\)$/.exec(st);
+    if (mvM && item && typeof item === "object") {
+      const subExpr = mvM[1];
+      if (Array.isArray(item)) {
+        const outArr = [];
+        for (const el of item) {
+          const r = this.evalSyncJqPathOps(el, subExpr);
+          if (!r || r.length !== 1) return void 0;
+          outArr.push(r[0]);
+        }
+        return [outArr];
+      }
+      const outObj = {};
+      for (const [k, v] of Object.entries(item)) {
+        const r = this.evalSyncJqPathOps(v, subExpr);
+        if (!r || r.length !== 1) return void 0;
+        outObj[k] = r[0];
+      }
+      return [outObj];
+    }
+    const byM = /^(sort_by|unique_by|group_by|min_by|max_by)\(\s*(\.[a-zA-Z_][a-zA-Z0-9_.]*)\s*\)$/.exec(st);
+    if (byM && Array.isArray(item)) {
+      const fn = byM[1];
+      const kPath = byM[2];
+      const keyed = [];
+      for (const el of item) {
+        const kv = this.evalSyncJqPathOps(el, kPath);
+        if (!kv || kv.length !== 1) return void 0;
+        const k0 = kv[0];
+        if (typeof k0 !== "string" && typeof k0 !== "number" && typeof k0 !== "boolean" && k0 !== null) return void 0;
+        keyed.push({ el, k: k0 });
+      }
+      const cmpK = (a, b) => {
+        const rank2 = (value2) => value2 === null ? 0 : value2 === false ? 1 : value2 === true ? 2 : typeof value2 === "number" ? 3 : 4;
+        const typeOrder = rank2(a) - rank2(b);
+        if (typeOrder !== 0) return typeOrder;
+        if (typeof a === "number" && typeof b === "number") return a - b;
+        const sa = String(a);
+        const sb = String(b);
+        return sa < sb ? -1 : sa > sb ? 1 : 0;
+      };
+      keyed.sort((a, b) => cmpK(a.k, b.k));
+      if (fn === "min_by") return [keyed.length > 0 ? keyed[0].el : null];
+      if (fn === "max_by") return [keyed.length > 0 ? keyed[keyed.length - 1].el : null];
+      if (fn === "sort_by") return [keyed.map((p) => p.el)];
+      if (fn === "unique_by") {
+        const u = [];
+        for (let i = 0; i < keyed.length; i++) {
+          if (i === 0 || cmpK(keyed[i].k, keyed[i - 1].k) !== 0) u.push(keyed[i].el);
+        }
+        return [u];
+      }
+      const groups = [];
+      for (let i = 0; i < keyed.length; i++) {
+        if (i === 0 || cmpK(keyed[i].k, keyed[i - 1].k) !== 0) groups.push([keyed[i].el]);
+        else groups[groups.length - 1].push(keyed[i].el);
+      }
+      return [groups];
+    }
+    if (st === "first") {
+      return Array.isArray(item) ? [item.length > 0 ? item[0] : null] : void 0;
+    }
+    if (st === "last") {
+      return Array.isArray(item) ? [item.length > 0 ? item[item.length - 1] : null] : void 0;
+    }
+    if (st === "reverse") {
+      return Array.isArray(item) ? [[...item].reverse()] : void 0;
+    }
+    if (st === "unique") return void 0;
+    if (st === "add") {
+      if (!Array.isArray(item)) return void 0;
+      if (item.length === 0) return [null];
+      if (item.every((x) => typeof x === "number")) return [item.reduce((a, b) => a + b, 0)];
+      if (item.every((x) => typeof x === "string")) return [item.join("")];
+      if (item.every((x) => Array.isArray(x))) return [item.flat()];
+      return void 0;
+    }
+    if (st === "min" || st === "max") {
+      if (!Array.isArray(item)) return void 0;
+      if (item.length === 0) return [null];
+      if (item.every((x) => typeof x === "number")) {
+        return [st === "min" ? Math.min(...item) : Math.max(...item)];
+      }
+      if (item.every((x) => typeof x === "string")) {
+        const sorted = [...item].sort();
+        return [st === "min" ? sorted[0] : sorted[sorted.length - 1]];
+      }
+      return void 0;
+    }
+    if (st === "to_entries") {
+      if (item && typeof item === "object" && !Array.isArray(item)) {
+        return [Object.entries(item).map(([key, value2]) => ({ key, value: value2 }))];
+      }
+      return void 0;
+    }
+    if (st === "from_entries") {
+      if (!Array.isArray(item)) return void 0;
+      const obj = {};
+      for (const el of item) {
+        if (!el || typeof el !== "object" || Array.isArray(el)) return void 0;
+        const rec = el;
+        const k = rec.key ?? rec.name ?? rec.k;
+        if (typeof k !== "string") return void 0;
+        obj[k] = Object.hasOwn(rec, "value") ? rec.value : Object.hasOwn(rec, "v") ? rec.v : null;
+      }
+      return [obj];
+    }
+    if (st === "tonumber") {
+      if (typeof item === "number") return [item];
+      if (typeof item === "string" && /^[ \t]*[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?[ \t]*$/.test(item)) return [Number(item)];
+      return void 0;
+    }
+    if (st === "tostring") {
+      return [typeof item === "string" ? item : JSON.stringify(item)];
+    }
+    if (st === "type") {
+      return [item === null ? "null" : Array.isArray(item) ? "array" : typeof item];
+    }
+    if (st === "ascii_upcase") {
+      return typeof item === "string" ? [item.replace(/[a-z]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 32))] : void 0;
+    }
+    if (st === "ascii_downcase") {
+      return typeof item === "string" ? [item.replace(/[A-Z]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) + 32))] : void 0;
+    }
+    const strFnM = /^(join|split|ltrimstr|rtrimstr|startswith|endswith|contains)\(\s*"([^"\\]*)"\s*\)$/.exec(st);
+    if (strFnM) {
+      const fn = strFnM[1];
+      const arg = strFnM[2];
+      if (fn === "join") {
+        if (!Array.isArray(item) || !item.every((x) => typeof x === "string" || typeof x === "number" || typeof x === "boolean" || x === null)) return void 0;
+        return [item.map((x) => x === null ? "" : String(x)).join(arg)];
+      }
+      if (fn === "split") return typeof item === "string" ? [item.split(arg)] : void 0;
+      if (fn === "ltrimstr") return typeof item === "string" ? [item.startsWith(arg) ? item.slice(arg.length) : item] : void 0;
+      if (fn === "rtrimstr") return typeof item === "string" ? [arg.length > 0 && item.endsWith(arg) ? item.slice(0, -arg.length) : item] : void 0;
+      if (fn === "startswith") return typeof item === "string" ? [item.startsWith(arg)] : void 0;
+      if (fn === "endswith") return typeof item === "string" ? [item.endsWith(arg)] : void 0;
+      if (fn === "contains") {
+        if (typeof item === "string") return [item.includes(arg)];
+        return void 0;
+      }
+    }
+    const hasM = /^has\(\s*"([^"\\]+)"\s*\)$/.exec(st);
+    if (hasM) {
+      if (item && typeof item === "object" && !Array.isArray(item)) return [Object.hasOwn(item, hasM[1])];
+      return void 0;
+    }
+    const mapM = /^map\(\s*(.+)\s*\)$/.exec(st);
+    if (mapM) {
+      if (!Array.isArray(item)) return void 0;
+      const mapped = [];
+      for (const el of item) {
+        const subRes = this.evalSyncJqPathOps(el, mapM[1]);
+        if (subRes === void 0) return void 0;
+        for (const v of subRes) mapped.push(v);
+      }
+      return [mapped];
+    }
+    const selM = /^select\(\s*(\.[a-zA-Z_][a-zA-Z0-9_.]*)\s*(?:(==|!=|>=|<=|>|<)\s*(.+))?\s*\)$/.exec(st);
+    if (selM) {
+      const fVals = this.evalSyncJqPathOps(item, selM[1]);
+      if (!fVals || fVals.length !== 1) return void 0;
+      const lv = fVals[0];
+      if (!selM[2]) {
+        return lv !== null && lv !== void 0 && lv !== false ? [item] : [];
+      }
+      let rv;
+      try {
+        rv = JSON.parse(selM[3].trim());
+      } catch {
+        return void 0;
+      }
+      if (typeof lv === "object" && lv !== null || typeof rv === "object" && rv !== null) return void 0;
+      const op = selM[2];
+      let ok = false;
+      if (op === "==") ok = lv === rv;
+      else if (op === "!=") ok = lv !== rv;
+      else if (typeof lv === "number" && typeof rv === "number") {
+        if (op === ">") ok = lv > rv;
+        else if (op === ">=") ok = lv >= rv;
+        else if (op === "<") ok = lv < rv;
+        else if (op === "<=") ok = lv <= rv;
+      } else return void 0;
+      return ok ? [item] : [];
+    }
+    if (!st.startsWith(".")) return void 0;
+    let rest = st.slice(1);
+    const ops = [];
+    while (rest.length > 0) {
+      if (rest.startsWith(".")) rest = rest.slice(1);
+      const propM = /^([a-zA-Z_][a-zA-Z0-9_]*)/.exec(rest);
+      if (propM) {
+        ops.push({ kind: "prop", key: propM[1] });
+        rest = rest.slice(propM[1].length);
+        continue;
+      }
+      if (rest.startsWith("[]")) {
+        ops.push({ kind: "iter" });
+        rest = rest.slice(2);
+        continue;
+      }
+      const idxM = /^\[(-?[0-9]+)\]/.exec(rest);
+      if (idxM) {
+        ops.push({ kind: "index", idx: Number(idxM[1]) });
+        rest = rest.slice(idxM[0].length);
+        continue;
+      }
+      return void 0;
+    }
+    let cur = [item];
+    for (const op of ops) {
+      const next = [];
+      for (const it of cur) {
+        if (op.kind === "prop") {
+          if (it === null || it === void 0) next.push(null);
+          else if (typeof it === "object" && !Array.isArray(it)) next.push(Object.hasOwn(it, op.key) ? it[op.key] ?? null : null);
+          else return void 0;
+        } else if (op.kind === "index") {
+          if (it === null || it === void 0) next.push(null);
+          else if (Array.isArray(it)) {
+            const i = op.idx < 0 ? it.length + op.idx : op.idx;
+            next.push(i >= 0 && i < it.length ? it[i] : null);
+          } else return void 0;
+        } else if (op.kind === "iter") {
+          if (Array.isArray(it)) {
+            for (const el of it) next.push(el);
+          } else if (it && typeof it === "object") {
+            for (const k of Object.keys(it)) next.push(it[k]);
+          } else return void 0;
+        }
+      }
+      cur = next;
+    }
+    return cur;
+  }
   evalSyncJq(input3, opArgs) {
     let rawOut = false;
+    let compactOut = false;
     let filter;
     if (opArgs.length === 1 && !opArgs[0].startsWith("-")) {
       filter = opArgs[0];
     } else if (opArgs.length === 2 && (opArgs[0] === "-r" || opArgs[0] === "--raw-output" || opArgs[0] === "-c" || opArgs[0] === "--compact-output" || opArgs[0] === "-rc" || opArgs[0] === "-cr")) {
-      rawOut = opArgs[0].includes("r");
+      rawOut = ["-r", "-rc", "-cr", "--raw-output"].includes(opArgs[0]);
+      compactOut = ["-c", "-rc", "-cr", "--compact-output"].includes(opArgs[0]);
       filter = opArgs[1];
     }
     if (!filter) return void 0;
-    const stages = filter.split("|").map((s) => s.trim());
-    const compiledStages = [];
-    for (const st of stages) {
-      if (st === ".") {
-        compiledStages.push([]);
-        continue;
+    let current = [];
+    try {
+      current = [JSON.parse(input3)];
+    } catch {
+      if (!input3.includes("\n")) return void 0;
+      try {
+        for (const line of input3.split("\n")) {
+          const t = line.trim();
+          if (t.length > 0) current.push(JSON.parse(t));
+        }
+        if (current.length === 0) return void 0;
+      } catch {
+        return void 0;
       }
-      if (st === "length") {
-        compiledStages.push([{ kind: "length" }]);
-        continue;
+    }
+    const trimmedFilter = filter.trim();
+    if (trimmedFilter.startsWith("[") && trimmedFilter.endsWith("]")) {
+      const innerFilter = trimmedFilter.slice(1, -1).trim();
+      const innerArgs = rawOut || compactOut ? [compactOut ? "-c" : "-r", innerFilter] : [innerFilter];
+      const outArrays = [];
+      for (const item of current) {
+        const innerStages = splitSyncJqExpression(innerFilter, "|");
+        if (!innerStages) return void 0;
+        let subCur = [item];
+        for (const st of innerStages.parts) {
+          const commas = splitSyncJqExpression(st, ",");
+          if (!commas) return void 0;
+          const commaParts = commas.parts;
+          const next = [];
+          for (const it of subCur) {
+            for (const part of commaParts) {
+              const res = this.evalSyncJqPathOps(it, part);
+              if (res === void 0) return void 0;
+              for (const v of res) next.push(v);
+            }
+          }
+          subCur = next;
+        }
+        outArrays.push(subCur);
+      }
+      void innerArgs;
+      return outArrays.map((val) => JSON.stringify(val ?? null, null, compactOut ? void 0 : 2));
+    }
+    const stages = splitSyncJqExpression(filter, "|");
+    if (!stages) return void 0;
+    for (const st of stages.parts) {
+      const commas = splitSyncJqExpression(st, ",");
+      if (!commas) return void 0;
+      const commaParts = commas.parts;
+      const next = [];
+      for (const item of current) {
+        for (const part of commaParts) {
+          const res = this.evalSyncJqPathOps(item, part);
+          if (res === void 0) return void 0;
+          for (const v of res) next.push(v);
+        }
       }
-      if (st === "keys") {
-        compiledStages.push([{ kind: "keys" }]);
-        continue;
+      current = next;
+    }
+    return current.map((val) => rawOut && typeof val === "string" ? val : JSON.stringify(val ?? null, null, compactOut ? void 0 : 2));
+  }
+  evalSyncDirname(args) {
+    let idx = 0;
+    if (args[0] === "--") idx = 1;
+    else if (args[0] !== void 0 && args[0].startsWith("-") && args[0] !== "-") return void 0;
+    if (idx >= args.length) return void 0;
+    const out = [];
+    for (let i = idx; i < args.length; i++) {
+      const p = args[i];
+      if (p.includes("\0")) return void 0;
+      if (idx === 0 && p.startsWith("-") && p !== "-") return void 0;
+      const parent = dirname(p);
+      let pEnd = parent.length;
+      while (pEnd > 1 && parent[pEnd - 1] === "/") pEnd--;
+      out.push(parent.slice(0, pEnd));
+    }
+    return out.join("\n");
+  }
+  evalSyncBasename(args) {
+    let multiple = false;
+    let suffix2;
+    let idx = 0;
+    const operands = [];
+    while (idx < args.length) {
+      const a = args[idx];
+      if (a === "--") {
+        operands.push(...args.slice(idx + 1));
+        break;
       }
-      if (st === "keys[]") {
-        compiledStages.push([{ kind: "keys" }, { kind: "iter" }]);
+      if (!a.startsWith("-") || a === "-") {
+        operands.push(a);
+        idx++;
         continue;
       }
-      if (!st.startsWith(".")) return void 0;
-      let rest = st.slice(1);
-      const ops = [];
-      while (rest.length > 0) {
-        if (rest.startsWith(".")) rest = rest.slice(1);
-        const propM = /^([a-zA-Z_][a-zA-Z0-9_]*)/.exec(rest);
-        if (propM) {
-          ops.push({ kind: "prop", key: propM[1] });
-          rest = rest.slice(propM[1].length);
-          continue;
-        }
-        if (rest.startsWith("[]")) {
-          ops.push({ kind: "iter" });
-          rest = rest.slice(2);
-          continue;
-        }
-        const idxM = /^\[(-?[0-9]+)\]/.exec(rest);
-        if (idxM) {
-          ops.push({ kind: "index", idx: Number(idxM[1]) });
-          rest = rest.slice(idxM[0].length);
-          continue;
-        }
+      if (a === "-a" || a === "--multiple") {
+        multiple = true;
+        idx++;
+      } else if (a === "-s" || a === "-as" || a === "-sa") {
+        multiple = true;
+        if (idx + 1 >= args.length) return void 0;
+        suffix2 = args[idx + 1];
+        idx += 2;
+      } else if (a.startsWith("-s") && a.length > 2) {
+        multiple = true;
+        suffix2 = a.slice(2);
+        idx++;
+      } else {
         return void 0;
       }
-      compiledStages.push(ops);
     }
-    let parsed;
-    try {
-      parsed = JSON.parse(input3);
-    } catch {
-      return void 0;
-    }
-    let current = [parsed];
-    for (const ops of compiledStages) {
-      for (const op of ops) {
-        const next = [];
-        for (const item of current) {
-          if (op.kind === "prop") {
-            if (item === null || item === void 0) next.push(null);
-            else if (typeof item === "object" && !Array.isArray(item)) next.push(item[op.key] ?? null);
-            else return void 0;
-          } else if (op.kind === "index") {
-            if (item === null || item === void 0) next.push(null);
-            else if (Array.isArray(item)) {
-              const i = op.idx < 0 ? item.length + op.idx : op.idx;
-              next.push(i >= 0 && i < item.length ? item[i] : null);
-            } else return void 0;
-          } else if (op.kind === "iter") {
-            if (Array.isArray(item)) {
-              for (const el of item) next.push(el);
-            } else if (item && typeof item === "object") {
-              for (const k of Object.keys(item)) next.push(item[k]);
-            } else return void 0;
-          } else if (op.kind === "length") {
-            if (item === null || item === void 0) next.push(0);
-            else if (typeof item === "string" || Array.isArray(item)) next.push(item.length);
-            else if (typeof item === "object") next.push(Object.keys(item).length);
-            else return void 0;
-          } else if (op.kind === "keys") {
-            if (Array.isArray(item)) next.push(item.map((_, idx) => idx));
-            else if (item && typeof item === "object") next.push(Object.keys(item).sort());
-            else return void 0;
-          }
-        }
-        current = next;
+    if (operands.length === 0) return void 0;
+    if (!multiple && operands.length > 2) return void 0;
+    const effSuffix = multiple ? suffix2 : operands[1];
+    if (effSuffix !== void 0 && effSuffix.includes("\0")) return void 0;
+    const paths = multiple ? operands : [operands[0]];
+    const out = [];
+    for (const p of paths) {
+      if (p.includes("\0")) return void 0;
+      let res = /^\/+$/u.test(p) ? "/" : basename(p);
+      if (effSuffix && res !== effSuffix && res.endsWith(effSuffix)) {
+        res = res.slice(0, -effSuffix.length);
       }
+      out.push(res);
     }
-    return current.map((val) => rawOut && typeof val === "string" ? val : JSON.stringify(val ?? null));
+    return out.join("\n");
   }
   parseSyncCutSpec(spec) {
     if (!/^(?:[1-9][0-9]{0,4}|[1-9][0-9]{0,4}-[1-9][0-9]{0,4}|[1-9][0-9]{0,4}-|-[1-9][0-9]{0,4})(?:,(?:[1-9][0-9]{0,4}|[1-9][0-9]{0,4}-[1-9][0-9]{0,4}|[1-9][0-9]{0,4}-|-[1-9][0-9]{0,4}))*$/.test(spec)) {
@@ -90243,28 +91244,50 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   evalSyncCut(rawLines, opArgs, byteLocaleMode) {
     const norm = [];
     let suppressNoDelim = false;
+    let isComplement = false;
+    let outDelim;
     for (let ci = 0; ci < opArgs.length; ci++) {
       const ca = opArgs[ci];
       if (ca === "-s" || ca === "--only-delimited") {
         suppressNoDelim = true;
+      } else if (ca === "--complement") {
+        isComplement = true;
+      } else if (ca.startsWith("--output-delimiter=")) {
+        outDelim = ca.slice("--output-delimiter=".length);
+        if (outDelim.length === 0 || outDelim.includes("\0")) return void 0;
+      } else if (ca === "--output-delimiter") {
+        if (ci + 1 >= opArgs.length) return void 0;
+        outDelim = opArgs[++ci];
+        if (outDelim.length === 0 || outDelim.includes("\0")) return void 0;
       } else if (ca.startsWith("-sd") || ca.startsWith("-ds")) {
         suppressNoDelim = true;
         const rest = ca.slice(3);
         if (rest.length > 0) norm.push("-d" + rest);
         else if (ci + 1 < opArgs.length) norm.push("-d" + opArgs[++ci]);
         else return void 0;
-      } else if ((ca === "-d" || ca === "-f" || ca === "-c") && ci + 1 < opArgs.length) {
+      } else if ((ca === "-d" || ca === "-f" || ca === "-c" || ca === "-b") && ci + 1 < opArgs.length) {
         norm.push(ca + opArgs[++ci]);
       } else {
         norm.push(ca);
       }
     }
-    if (!suppressNoDelim && norm.length === 1 && norm[0].startsWith("-c")) {
-      if (byteLocaleMode) return void 0;
-      const picker2 = this.parseSyncCutSpec(norm[0].slice(2));
-      if (!picker2) return void 0;
+    if (!suppressNoDelim && outDelim === void 0 && norm.length === 1 && (norm[0].startsWith("-c") || norm[0].startsWith("-b"))) {
+      const isByteMode = norm[0].startsWith("-b");
+      if (!isByteMode && byteLocaleMode) return void 0;
+      if (isByteMode && rawLines.some((l) => {
+        for (let i = 0; i < l.length; i++) if (l.charCodeAt(i) >= 128) return true;
+        return false;
+      })) return void 0;
+      const basePicker2 = this.parseSyncCutSpec(norm[0].slice(2));
+      if (!basePicker2) return void 0;
+      const picker2 = isComplement ? (len) => {
+        const s = new Set(basePicker2(len));
+        const r = [];
+        for (let i = 0; i < len; i++) if (!s.has(i)) r.push(i);
+        return r;
+      } : basePicker2;
       return rawLines.map((l) => {
-        const chars = Array.from(l);
+        const chars = isByteMode ? l.split("") : Array.from(l);
         const idxs = picker2(chars.length);
         return idxs.map((i) => chars[i]).join("");
       });
@@ -90282,8 +91305,15 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       }
     }
     if (!fArg || !fArg.startsWith("-f")) return void 0;
-    const picker = this.parseSyncCutSpec(fArg.slice(2));
-    if (!picker) return void 0;
+    const basePicker = this.parseSyncCutSpec(fArg.slice(2));
+    if (!basePicker) return void 0;
+    const picker = isComplement ? (len) => {
+      const s = new Set(basePicker(len));
+      const r = [];
+      for (let i = 0; i < len; i++) if (!s.has(i)) r.push(i);
+      return r;
+    } : basePicker;
+    const joinDelim = outDelim ?? delim;
     const out = [];
     for (let li = 0; li < rawLines.length; li++) {
       const l = rawLines[li];
@@ -90293,115 +91323,408 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       }
       const parts = l.split(delim);
       const idxs = picker(parts.length);
-      out.push(idxs.map((i) => parts[i]).join(delim));
+      out.push(idxs.map((i) => parts[i]).join(joinDelim));
     }
     return out;
   }
   evalSyncSed(rawLines, opArgs) {
     let quiet = false;
-    let expr;
-    if (opArgs.length === 1 && !opArgs[0].startsWith("-")) {
-      expr = opArgs[0];
-    } else if (opArgs.length === 2 && opArgs[0] === "-e") {
-      expr = opArgs[1];
-    } else if (opArgs.length === 2 && opArgs[0] === "-n") {
-      quiet = true;
-      expr = opArgs[1];
-    } else if (opArgs.length === 3 && (opArgs[0] === "-n" && opArgs[1] === "-e" || opArgs[0] === "-e" && opArgs[1] === "-n")) {
-      quiet = true;
-      expr = opArgs[2];
-    }
-    if (!expr) return void 0;
-    const addrCmdM = /^(?:([1-9][0-9]{0,4}|\$)(?:,([1-9][0-9]{0,4}|\$))?|\/(\^?[a-zA-Z0-9_ :;,.-]+\$?)\/)([dp])$/.exec(expr);
-    if (addrCmdM) {
-      const cmdChar = addrCmdM[4];
-      if (quiet && cmdChar !== "p" || !quiet && cmdChar !== "d") return void 0;
-      const startSpec = addrCmdM[1];
-      const endSpec = addrCmdM[2];
-      const patSpec = addrCmdM[3];
-      const matchLine = (l, idx1, total) => {
-        if (patSpec !== void 0) {
-          const aStart = patSpec.startsWith("^");
-          const c1 = aStart ? patSpec.slice(1) : patSpec;
-          const aEnd = c1.endsWith("$");
-          const core2 = aEnd ? c1.slice(0, -1) : c1;
-          if (aStart && aEnd) return l === core2;
-          if (aStart) return l.startsWith(core2);
-          if (aEnd) return l.endsWith(core2);
-          return l.includes(core2);
-        }
-        const sNum = startSpec === "$" ? total : Number(startSpec);
-        if (endSpec === void 0) return idx1 === sNum;
-        const eNum = endSpec === "$" ? total : Number(endSpec);
-        return idx1 >= sNum && idx1 <= eNum;
-      };
-      const out = [];
-      for (let i = 0; i < rawLines.length; i++) {
-        const hit = matchLine(rawLines[i], i + 1, rawLines.length);
-        if (cmdChar === "p" && hit) out.push(rawLines[i]);
-        else if (cmdChar === "d" && !hit) out.push(rawLines[i]);
+    let isExtended = false;
+    const rawExprs = [];
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a === "-n" || a === "--quiet" || a === "--silent") quiet = true;
+      else if (a === "-E" || a === "-r" || a === "--regexp-extended") isExtended = true;
+      else if (a === "-En" || a === "-nE" || a === "-rn" || a === "-nr") {
+        quiet = true;
+        isExtended = true;
+      } else if (a === "-e") {
+        if (i + 1 >= opArgs.length) return void 0;
+        rawExprs.push(opArgs[++i]);
+      } else if (!a.startsWith("-") && rawExprs.length === 0 && i === opArgs.length - 1) {
+        rawExprs.push(a);
+      } else {
+        return void 0;
       }
-      return out;
     }
-    if (quiet) return void 0;
-    if (!expr.startsWith("s") || expr.length < 4) return void 0;
-    const delim = expr[1];
-    if (!"/#|:@,;%!".includes(delim)) return void 0;
-    const parts = expr.slice(2).split(delim);
-    if (parts.length !== 3) return void 0;
-    const [pat, rep, flags3] = parts;
-    if (flags3 !== "" && flags3 !== "g" || /[&\\\n]/.test(rep)) return void 0;
-    const anchorStart = pat.startsWith("^");
-    const core1 = anchorStart ? pat.slice(1) : pat;
-    const anchorEnd = core1.endsWith("$");
-    const core = anchorEnd ? core1.slice(0, -1) : core1;
-    if (core.length === 0 || !/^[a-zA-Z0-9_ :;,/-]+$/.test(core)) return void 0;
-    const isGlobal = flags3 === "g";
-    return rawLines.map((l) => {
-      if (anchorStart && anchorEnd) return l === core ? rep : l;
-      if (anchorStart) return l.startsWith(core) ? rep + l.slice(core.length) : l;
-      if (anchorEnd) return l.endsWith(core) ? l.slice(0, l.length - core.length) + rep : l;
-      return isGlobal ? l.split(core).join(rep) : l.replace(core, () => rep);
-    });
+    if (rawExprs.length === 0) return void 0;
+    const subExprs = [];
+    for (const re of rawExprs) {
+      if (re.includes(";") && !re.startsWith("s;") && !re.startsWith("y;")) {
+        for (const p of re.split(";")) {
+          const t = p.trim();
+          if (t.length > 0) subExprs.push(t);
+        }
+      } else {
+        subExprs.push(re.trim());
+      }
+    }
+    if (subExprs.length === 0) return void 0;
+    const steps = [];
+    for (const rawE of subExprs) {
+      let rest = rawE;
+      let addr;
+      let negated = false;
+      const addrM = /^(?:([1-9][0-9]{0,4}|\$)(?:,([1-9][0-9]{0,4}|\$))?|\/(\^?[a-zA-Z0-9_ :;,=-]+\$?)\/)\s*/.exec(rest);
+      if (addrM) {
+        const startSpec = addrM[1];
+        const endSpec = addrM[2];
+        const patSpec = addrM[3];
+        rest = rest.slice(addrM[0].length);
+        addr = (l, idx1, total2) => {
+          if (patSpec !== void 0) {
+            const aStart = patSpec.startsWith("^");
+            const c1 = aStart ? patSpec.slice(1) : patSpec;
+            const aEnd = c1.endsWith("$");
+            const core = aEnd ? c1.slice(0, -1) : c1;
+            if (aStart && aEnd) return l === core;
+            if (aStart) return l.startsWith(core);
+            if (aEnd) return l.endsWith(core);
+            return l.includes(core);
+          }
+          const sNum = startSpec === "$" ? total2 : Number(startSpec);
+          if (endSpec === void 0) return idx1 === sNum;
+          const eNum = endSpec === "$" ? total2 : Number(endSpec);
+          return idx1 >= sNum && idx1 <= Math.max(sNum, eNum);
+        };
+      }
+      if (rest.startsWith("!")) {
+        negated = true;
+        rest = rest.slice(1).trim();
+      }
+      if (rest === "d") {
+        steps.push({ addr, negated, kind: "d" });
+        continue;
+      }
+      if (rest === "p") {
+        steps.push({ addr, negated, kind: "p" });
+        continue;
+      }
+      if (rest === "q") {
+        steps.push({ addr, negated, kind: "q" });
+        continue;
+      }
+      if (rest === "=") {
+        steps.push({ addr, negated, kind: "=" });
+        continue;
+      }
+      if (rest.startsWith("i") || rest.startsWith("a") || rest.startsWith("c")) return void 0;
+      if (rest.startsWith("y") && rest.length >= 4) {
+        const delim = rest[1];
+        if (!"/#|:@,;%!".includes(delim)) return void 0;
+        const parts = rest.slice(2).split(delim);
+        if (parts.length !== 3 || parts[2] !== "") return void 0;
+        const srcStr = parts[0];
+        const dstStr = parts[1];
+        if (srcStr.includes("\\") || dstStr.includes("\\")) return void 0;
+        const srcChars = Array.from(srcStr);
+        const dstChars = Array.from(dstStr);
+        if (srcChars.length !== dstChars.length) return void 0;
+        const map = /* @__PURE__ */ new Map();
+        for (let i = 0; i < srcChars.length; i++) {
+          if (!map.has(srcChars[i])) map.set(srcChars[i], dstChars[i]);
+        }
+        steps.push({ addr, negated, kind: "y", map });
+        continue;
+      }
+      if (rest.startsWith("s") && rest.length >= 4) {
+        const delim = rest[1];
+        if (!"/#|:@,;%!".includes(delim)) return void 0;
+        const parts = rest.slice(2).split(delim);
+        if (parts.length !== 3) return void 0;
+        const [pat, rep, flags3] = parts;
+        if (!/^[giIp1-9]*$/.test(flags3) || /\n|\\(?![1-9])/.test(rep)) return void 0;
+        const nthDigits = flags3.match(/[1-9]/g);
+        if (nthDigits && (nthDigits.length > 1 || flags3.includes("g"))) return void 0;
+        const nth = nthDigits ? Number(nthDigits[0]) : 0;
+        const global = flags3.includes("g") || nth > 0;
+        const ignoreCase = flags3.includes("i") || flags3.includes("I");
+        const printOnMatch = flags3.includes("p");
+        const anchorStart = pat.startsWith("^");
+        const core1 = anchorStart ? pat.slice(1) : pat;
+        const anchorEnd = core1.endsWith("$");
+        const core = anchorEnd ? core1.slice(0, -1) : core1;
+        if (core.length === 0 && !anchorStart && !anchorEnd) return void 0;
+        let reSrc;
+        if (/^[a-zA-Z0-9_ :;,=-]*$/.test(core)) {
+          if (/\\[1-9]/.test(rep)) return void 0;
+          reSrc = core.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        } else if (core === "[ 	]*" || core === "[ 	]+" || core === "[ \\t]*" || core === "[ \\t]+" || core === "[[:space:]]*" || core === "[[:space:]]+" || core === "[0-9]+" || core === "[0-9]*" || core === "[a-zA-Z]+" || core === "[a-zA-Z0-9_]+") {
+          if (/\\[1-9]/.test(rep)) return void 0;
+          reSrc = core.replace("[[:space:]]", "[ \\t\\r\\n\\v\\f]");
+        } else if (isExtended && /^[a-zA-Z0-9_ :;,=.+*?|()^\-[\]]+$/.test(core) && !/\([^)]*[+*][^)]*\)[+*?]/.test(core)) {
+          try {
+            const expanded = core.replace(/\[:space:\]/g, " \\t\\r\\n\\v\\f");
+            void new RegExp(expanded);
+            reSrc = expanded;
+          } catch {
+            reSrc = void 0;
+          }
+        }
+        if (reSrc === void 0) return void 0;
+        const fullRe = new RegExp((anchorStart ? "^" : "") + reSrc + (anchorEnd ? "$" : ""), (global ? "g" : "") + (ignoreCase ? "i" : ""));
+        steps.push({ addr, negated, kind: "s", re: fullRe, rep, printOnMatch, nth });
+        continue;
+      }
+      return void 0;
+    }
+    const out = [];
+    const total = rawLines.length;
+    let lastInputIndex = -1;
+    for (let i = 0; i < total; i++) {
+      let l = rawLines[i];
+      const idx1 = i + 1;
+      let deleted = false;
+      let quitNow = false;
+      for (let si = 0; si < steps.length; si++) {
+        const st = steps[si];
+        const addrMatched = st.addr ? st.addr(l, idx1, total) : true;
+        if (st.negated ? addrMatched : !addrMatched) continue;
+        if (st.kind === "d") {
+          deleted = true;
+          break;
+        }
+        if (st.kind === "p") {
+          out.push(l);
+          lastInputIndex = i;
+          continue;
+        }
+        if (st.kind === "=") {
+          out.push(String(idx1));
+          lastInputIndex = i;
+          continue;
+        }
+        if (st.kind === "q") {
+          if (!quiet) {
+            out.push(l);
+            lastInputIndex = i;
+          }
+          quitNow = true;
+          break;
+        }
+        if (st.kind === "y") {
+          l = Array.from(l).map((c) => st.map.get(c) ?? c).join("");
+          continue;
+        }
+        let matchedOnce = false;
+        let matchIdx = 0;
+        let previousEnd = -1;
+        l = l.replace(st.re, (matched, ...groups) => {
+          const offset = groups[groups.length - 2];
+          if (matched.length === 0 && offset === previousEnd) return "";
+          previousEnd = offset + matched.length;
+          matchIdx++;
+          if (st.nth > 0 && matchIdx !== st.nth) return matched;
+          matchedOnce = true;
+          let replacement = "";
+          for (let ri = 0; ri < st.rep.length; ri++) {
+            const c = st.rep[ri];
+            if (c === "&") replacement += matched;
+            else if (c === "\\" && ri + 1 < st.rep.length) {
+              const next = st.rep[++ri];
+              const group = next >= "1" && next <= "9" ? groups[Number(next) - 1] : next;
+              replacement += typeof group === "string" ? group : "";
+            } else replacement += c;
+          }
+          return replacement;
+        });
+        if (matchedOnce && st.printOnMatch) out.push(l);
+      }
+      if (quitNow) {
+        break;
+      }
+      if (!deleted && !quiet) {
+        out.push(l);
+        lastInputIndex = i;
+      }
+    }
+    return { lines: out, lastInputIndex };
   }
   evalSyncGrep(rawLines, opArgs, errexit) {
-    if (errexit || opArgs.length !== 1 && opArgs.length !== 2) return void 0;
-    const mode = opArgs.length === 2 ? opArgs[0] : "";
-    const pat = opArgs[opArgs.length - 1];
-    if (pat.startsWith("-")) return void 0;
-    if (opArgs.length === 2 && mode !== "-v" && mode !== "-i" && mode !== "-c" && mode !== "-F" && mode !== "-E" && mode !== "-Ei" && mode !== "-iE" && mode !== "-Ev" && mode !== "-vE") {
-      return void 0;
+    if (errexit || opArgs.length < 1 || opArgs.length > 8) return void 0;
+    let mode = "";
+    let maxCount2 = Infinity;
+    let beforeCtx = 0;
+    let afterCtx = 0;
+    const rawPatterns = [];
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if ((a === "-A" || a === "-B" || a === "-C") && i + 1 < opArgs.length && /^[0-9]{1,4}$/.test(opArgs[i + 1])) {
+        const n = Number(opArgs[++i]);
+        if (a === "-A" || a === "-C") afterCtx = n;
+        if (a === "-B" || a === "-C") beforeCtx = n;
+      } else if (/^-[ABC][0-9]{1,4}$/.test(a)) {
+        const n = Number(a.slice(2));
+        if (a[1] === "A" || a[1] === "C") afterCtx = n;
+        if (a[1] === "B" || a[1] === "C") beforeCtx = n;
+      } else if (/^--(?:after-context|before-context|context)=[0-9]{1,4}$/.test(a)) {
+        const eq = a.indexOf("=");
+        const n = Number(a.slice(eq + 1));
+        if (a.startsWith("--after") || a.startsWith("--context")) afterCtx = n;
+        if (a.startsWith("--before") || a.startsWith("--context")) beforeCtx = n;
+      } else if (a === "-e") {
+        if (i + 1 >= opArgs.length) return void 0;
+        rawPatterns.push(opArgs[++i]);
+      } else if (a.startsWith("-e") && a.length > 2) {
+        rawPatterns.push(a.slice(2));
+      } else if (a === "-m") {
+        if (i + 1 >= opArgs.length || !/^[1-9][0-9]{0,5}$/.test(opArgs[i + 1])) return void 0;
+        maxCount2 = Number(opArgs[++i]);
+      } else if (a.startsWith("-m") && /^[1-9][0-9]{0,5}$/.test(a.slice(2))) {
+        maxCount2 = Number(a.slice(2));
+      } else if (a.startsWith("--max-count=") && /^[1-9][0-9]{0,5}$/.test(a.slice(12))) {
+        maxCount2 = Number(a.slice(12));
+      } else if (a.startsWith("--") && a !== "--" && rawPatterns.length === 0 && i < opArgs.length - 1) {
+        if (a === "--extended-regexp") mode += "E";
+        else if (a === "--fixed-strings") mode += "F";
+        else if (a === "--ignore-case") mode += "i";
+        else if (a === "--invert-match") mode += "v";
+        else if (a === "--only-matching") mode += "o";
+        else if (a === "--line-number") mode += "n";
+        else if (a === "--count") mode += "c";
+        else if (a === "--word-regexp") mode += "w";
+        else if (a === "--line-regexp") mode += "x";
+        else return void 0;
+      } else if (a.startsWith("-") && a !== "-" && a !== "--" && rawPatterns.length === 0 && i < opArgs.length - 1) {
+        mode += a.slice(1);
+      } else if (!a.startsWith("-") && rawPatterns.length === 0 && i === opArgs.length - 1) {
+        rawPatterns.push(a);
+      } else {
+        return void 0;
+      }
     }
+    if (rawPatterns.length === 0 || !/^[vicFEonxw]*$/.test(mode)) return void 0;
+    const isLineNumber = mode.includes("n");
+    const isLineRegexp = mode.includes("x");
+    const isWordRegexp = mode.includes("w");
     const isCaseInsensitive = mode.includes("i");
+    const foldCase = (value2) => value2.replace(/[A-Z]/g, (ch) => ch.toLowerCase());
     const isInvert = mode.includes("v");
-    const isCount = mode === "-c";
+    const isCount = mode.includes("c");
     const isExtended = mode.includes("E");
     const isFixed = mode.includes("F");
-    const branches = isExtended ? pat.split("|") : [pat];
+    const isOnlyMatching = mode.includes("o");
+    if (isExtended && !isFixed && rawPatterns.some((pattern) => pattern.includes("[:") || pattern.includes("[.") || pattern.includes("[="))) return void 0;
+    if (isCount && (isLineNumber || isOnlyMatching || beforeCtx > 0 || afterCtx > 0)) return void 0;
+    if (isOnlyMatching && (beforeCtx > 0 || afterCtx > 0)) return void 0;
+    if (isOnlyMatching) {
+      if (rawPatterns.length !== 1 || isInvert || isLineRegexp || isWordRegexp || isFixed) return void 0;
+      const pat = rawPatterns[0];
+      const reFlags = isCaseInsensitive ? "gi" : "g";
+      let re;
+      if (isExtended && !pat.includes("|") && /^[a-zA-Z0-9_ :;,=.+*?()^\-[\]]+$/.test(pat) && !/\([^)]*[+*][^)]*\)[+*?]/.test(pat)) {
+        try {
+          re = new RegExp(pat, reFlags);
+        } catch {
+          re = void 0;
+        }
+      } else {
+        const branches2 = isExtended ? pat.split("|") : [pat];
+        if (branches2.every((b) => b.length > 0 && /^[a-zA-Z0-9_ :;,/-]+$/.test(b))) {
+          branches2.sort((a, b) => b.length - a.length);
+          re = new RegExp(branches2.join("|"), reFlags);
+        }
+      }
+      if (!re) return void 0;
+      const out = [];
+      for (let li = 0; li < rawLines.length; li++) {
+        const matches2 = rawLines[li].match(re);
+        if (matches2) {
+          for (let mi = 0; mi < matches2.length; mi++) {
+            out.push(isLineNumber ? `${li + 1}:${matches2[mi]}` : matches2[mi]);
+          }
+        }
+      }
+      return { lines: out, status: out.length > 0 ? 0 : 1 };
+    }
+    if (isExtended && isFixed) return void 0;
+    const branches = [];
+    for (const rp of rawPatterns) {
+      for (const b of isFixed ? rp.split("\n") : isExtended ? rp.split("|") : [rp]) {
+        branches.push(b);
+      }
+    }
     const compiledBranches = [];
     for (const br of branches) {
       if (br.length === 0) return void 0;
-      const anchorStart = !isFixed && br.startsWith("^");
-      const c1 = anchorStart ? br.slice(1) : br;
-      const anchorEnd = !isFixed && c1.endsWith("$");
-      const core = anchorEnd ? c1.slice(0, -1) : c1;
-      if (core.length === 0 || !/^[a-zA-Z0-9_ :;,/-]+$/.test(core)) return void 0;
-      compiledBranches.push({ anchorStart, anchorEnd, needle: isCaseInsensitive ? core.toLowerCase() : core });
+      if (isFixed) {
+        if (br.includes("\0")) return void 0;
+        compiledBranches.push({ anchorStart: isLineRegexp, anchorEnd: isLineRegexp, needle: isCaseInsensitive ? foldCase(br) : br, re: void 0 });
+      } else {
+        const anchorStart = isLineRegexp || br.startsWith("^");
+        const c1 = br.startsWith("^") ? br.slice(1) : br;
+        const anchorEnd = isLineRegexp || c1.endsWith("$");
+        const core = c1.endsWith("$") ? c1.slice(0, -1) : c1;
+        if (core.length > 0 && /^[a-zA-Z0-9_ :;,/-]+$/.test(core)) {
+          compiledBranches.push({ anchorStart, anchorEnd, needle: isCaseInsensitive ? foldCase(core) : core, re: void 0 });
+        } else if (isExtended && !isWordRegexp && core.length > 0 && /^[a-zA-Z0-9_ :;,=.+*?^\-[\]]+$/.test(core) && !/\([^)]*[+*][^)]*\)[+*?]/.test(core)) {
+          try {
+            const fullSrc = (anchorStart ? "^" : "") + core + (anchorEnd ? "$" : "");
+            compiledBranches.push({ anchorStart, anchorEnd, needle: "", re: new RegExp(fullSrc, isCaseInsensitive ? "i" : "") });
+          } catch {
+            return void 0;
+          }
+        } else {
+          return void 0;
+        }
+      }
     }
+    const isWordChar = (ch) => ch !== void 0 && /^[a-zA-Z0-9_]$/.test(ch);
+    const hasWordMatch = (hay, needle, aStart, aEnd) => {
+      if (aStart && aEnd) return hay === needle;
+      if (aStart) return hay.startsWith(needle) && !isWordChar(hay[needle.length]);
+      if (aEnd) return hay.endsWith(needle) && !isWordChar(hay[hay.length - needle.length - 1]);
+      let from = 0;
+      while (from <= hay.length - needle.length) {
+        const idx = hay.indexOf(needle, from);
+        if (idx === -1) return false;
+        if (!isWordChar(hay[idx - 1]) && !isWordChar(hay[idx + needle.length])) return true;
+        from = idx + 1;
+      }
+      return false;
+    };
     const matched = [];
+    const matchedIndices = [];
     for (let li = 0; li < rawLines.length; li++) {
       const l = rawLines[li];
-      const hay = isCaseInsensitive ? l.toLowerCase() : l;
+      const hay = isCaseInsensitive ? foldCase(l) : l;
       let hit = false;
       for (let bi = 0; bi < compiledBranches.length; bi++) {
         const b = compiledBranches[bi];
-        const ok = b.anchorStart && b.anchorEnd ? hay === b.needle : b.anchorStart ? hay.startsWith(b.needle) : b.anchorEnd ? hay.endsWith(b.needle) : hay.includes(b.needle);
+        const ok = b.re !== void 0 ? b.re.test(l) : isWordRegexp ? hasWordMatch(hay, b.needle, b.anchorStart, b.anchorEnd) : b.anchorStart && b.anchorEnd ? hay === b.needle : b.anchorStart ? hay.startsWith(b.needle) : b.anchorEnd ? hay.endsWith(b.needle) : hay.includes(b.needle);
         if (ok) {
           hit = true;
           break;
         }
       }
-      if (isInvert ? !hit : hit) matched.push(l);
+      if (isInvert ? !hit : hit) {
+        matchedIndices.push(li);
+        matched.push(isLineNumber ? `${li + 1}:${l}` : l);
+        if (matched.length >= maxCount2) break;
+      }
+    }
+    if ((beforeCtx > 0 || afterCtx > 0) && matchedIndices.length > 0) {
+      const matchedSet = new Set(matchedIndices);
+      const outCtx = [];
+      let prevEnd = -1;
+      for (const mIdx of matchedIndices) {
+        const start = Math.max(0, mIdx - beforeCtx);
+        const end = Math.min(rawLines.length - 1, mIdx + afterCtx);
+        if (prevEnd !== -1 && start > prevEnd + 1) {
+          outCtx.push("--");
+        }
+        const from = prevEnd !== -1 ? Math.max(start, prevEnd + 1) : start;
+        for (let k = from; k <= end; k++) {
+          const lineText = rawLines[k];
+          if (isLineNumber) {
+            outCtx.push(`${k + 1}${matchedSet.has(k) ? ":" : "-"}${lineText}`);
+          } else {
+            outCtx.push(lineText);
+          }
+        }
+        prevEnd = Math.max(prevEnd, end);
+      }
+      return { lines: outCtx, status: 0 };
     }
     return {
       lines: isCount ? [String(matched.length)] : matched,
@@ -90409,46 +91732,338 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     };
   }
   evalSyncAwk(rawLines, opArgs) {
-    if (opArgs.length < 1 || opArgs.length > 3) return void 0;
-    const norm = opArgs.length === 3 && opArgs[0] === "-F" ? ["-F" + opArgs[1], opArgs[2]] : opArgs;
+    if (opArgs.length < 1 || opArgs.length > 8) return void 0;
     let awkSep;
     let awkProg;
-    if (norm.length === 1) awkProg = norm[0];
-    else if (norm.length === 2 && norm[0].length === 3 && norm[0].startsWith("-F") && norm[0][2] !== "\\") {
-      awkSep = norm[0].slice(2);
-      awkProg = norm[1];
+    let ofs = " ";
+    const userVars = /* @__PURE__ */ new Map();
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a === "-F") {
+        if (i + 1 >= opArgs.length || opArgs[i + 1].length !== 1 || opArgs[i + 1] === "\\") return void 0;
+        awkSep = opArgs[++i];
+      } else if (a.startsWith("-F") && a.length === 3 && a[2] !== "\\") {
+        awkSep = a.slice(2);
+      } else if (a === "-v") {
+        if (i + 1 >= opArgs.length) return void 0;
+        const kv = opArgs[++i];
+        const eq = kv.indexOf("=");
+        if (eq <= 0 || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(kv.slice(0, eq))) return void 0;
+        const k = kv.slice(0, eq);
+        const v = kv.slice(eq + 1);
+        if (v.includes("\\")) return void 0;
+        if (k === "OFS") ofs = v;
+        else if (k === "FS") {
+          if (v.length !== 1) return void 0;
+          awkSep = v;
+        } else userVars.set(k, v);
+      } else if (a.startsWith("-v") && a.length > 2) {
+        const kv = a.slice(2);
+        const eq = kv.indexOf("=");
+        if (eq <= 0 || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(kv.slice(0, eq))) return void 0;
+        const k = kv.slice(0, eq);
+        const v = kv.slice(eq + 1);
+        if (v.includes("\\")) return void 0;
+        if (k === "OFS") ofs = v;
+        else if (k === "FS") {
+          if (v.length !== 1) return void 0;
+          awkSep = v;
+        } else userVars.set(k, v);
+      } else if (!a.startsWith("-") && i === opArgs.length - 1) {
+        awkProg = a;
+      } else {
+        return void 0;
+      }
     }
     if (!awkProg) return void 0;
-    const awkM = /^\s*\{\s*print(?:\s+((?:\$(?:[0-9]+|NF)|"[^"$\\]*")(?:\s*,?\s*(?:\$(?:[0-9]+|NF)|"[^"$\\]*"))*))?\s*;?\s*\}\s*$/.exec(awkProg);
+    let progRest = awkProg.trim();
+    const beginFsM = /^BEGIN\s*\{([^}]*)\}\s*/.exec(progRest);
+    let initVarName;
+    let initVarVal = 0;
+    if (beginFsM) {
+      const bStmts = beginFsM[1].split(";").map((s) => s.trim()).filter(Boolean);
+      for (const bs of bStmts) {
+        const ofsM = /^OFS\s*=\s*"([^"\\]*)"$/.exec(bs);
+        if (ofsM) {
+          ofs = ofsM[1];
+          continue;
+        }
+        const fsM = /^FS\s*=\s*"([^"\\])"$/.exec(bs);
+        if (fsM) {
+          awkSep = fsM[1];
+          continue;
+        }
+        const numInitM = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(-?[0-9]+(?:\.[0-9]+)?)$/.exec(bs);
+        if (numInitM) {
+          initVarName = numInitM[1];
+          initVarVal = Number(numInitM[2]);
+          continue;
+        }
+        return void 0;
+      }
+      progRest = progRest.slice(beginFsM[0].length).trim();
+    }
+    const sumEndM = /^\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*(\+=|-=)\s*(?:\$([0-9]+|NF)|(-?[0-9]+(?:\.[0-9]+)?))\s*;?\s*\}\s*END\s*\{\s*print\s+\1\s*;?\s*\}$/.exec(progRest);
+    if (sumEndM) {
+      const varName = sumEndM[1];
+      if (["NR", "NF", "FNR", "OFS", "FS", "ORS", "RS", "OFMT", "CONVFMT", "ARGC", "ARGIND", "FILENAME", "RSTART", "RLENGTH", "SUBSEP", "IGNORECASE", "FIELDWIDTHS", "FPAT", "BINMODE", "TEXTDOMAIN"].includes(varName)) return void 0;
+      if (initVarName !== void 0 && initVarName !== varName) return void 0;
+      const op = sumEndM[2];
+      const fTok = sumEndM[3];
+      const constVal = sumEndM[4] !== void 0 ? Number(sumEndM[4]) : void 0;
+      const initial = userVars.get(varName);
+      if (initial !== void 0 && !Number.isFinite(Number(initial))) return void 0;
+      let acc = initVarName === varName ? initVarVal : Number(initial ?? 0);
+      let touched = initVarName === varName || initial !== void 0;
+      for (let li = 0; li < rawLines.length; li++) {
+        const l = rawLines[li];
+        const fields3 = awkSep === void 0 || awkSep === " " ? l.split(/[ \t]+/).filter(Boolean) : l.length === 0 ? [] : l.split(awkSep);
+        let delta = 0;
+        if (constVal !== void 0) {
+          delta = constVal;
+        } else {
+          const idx = fTok === "NF" ? fields3.length : Number(fTok);
+          const rawField = idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+          const n = /^[ \t]*([+-]?(?:\d+(?:\.\d*)?|\.\d+))/.exec(rawField);
+          delta = n ? Number(n[1]) : 0;
+        }
+        acc = op === "+=" ? acc + delta : acc - delta;
+        touched = true;
+      }
+      return [touched ? text({ kind: "number", number: acc }) : ""];
+    }
+    if (initVarName !== void 0) return void 0;
+    let rowPred;
+    const patCondM = /^\/(\^?[a-zA-Z0-9_ :;,=-]+\$?)\/\s*/.exec(progRest);
+    if (patCondM) {
+      const pSpec = patCondM[1];
+      const aS = pSpec.startsWith("^");
+      const c1 = aS ? pSpec.slice(1) : pSpec;
+      const aE = c1.endsWith("$");
+      const core = aE ? c1.slice(0, -1) : c1;
+      rowPred = (l) => aS && aE ? l === core : aS ? l.startsWith(core) : aE ? l.endsWith(core) : l.includes(core);
+      progRest = progRest.slice(patCondM[0].length).trim();
+    } else {
+      const cmpCondM = /^(?:(NR|NF)|\$([0-9]+|NF))\s*(==|!=|>=|<=|>|<)\s*(?:"([^"\\]*)"|(-?[0-9]+(?:\.[0-9]+)?)|([a-zA-Z_][a-zA-Z0-9_]*))\s*/.exec(progRest);
+      if (cmpCondM) {
+        const nrNf = cmpCondM[1];
+        const fTok = cmpCondM[2];
+        const op = cmpCondM[3];
+        const varRhs = cmpCondM[6] !== void 0 ? userVars.get(cmpCondM[6]) : void 0;
+        if (cmpCondM[6] !== void 0 && varRhs === void 0) return void 0;
+        const varAsNum = varRhs !== void 0 && /^-?(?:\d+(?:\.\d*)?|\.\d+)$/.test(varRhs) ? Number(varRhs) : void 0;
+        const strRhs = cmpCondM[4] ?? (varAsNum === void 0 ? varRhs : void 0);
+        const numRhs = cmpCondM[5] !== void 0 ? Number(cmpCondM[5]) : varAsNum;
+        if (strRhs !== void 0 && op !== "==" && op !== "!=") return void 0;
+        rowPred = (l, fields3, nr) => {
+          let rawVal;
+          if (nrNf !== void 0) rawVal = nrNf === "NR" ? nr : fields3.length;
+          else {
+            const idx = fTok === "NF" ? fields3.length : Number(fTok);
+            rawVal = idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+          }
+          const left = typeof rawVal === "number" ? numeric2(rawVal) : inputValue(rawVal);
+          const right = strRhs !== void 0 ? string(strRhs) : numeric2(numRhs);
+          const comparison = compare2(left, right, "%.6g");
+          return op === "==" ? comparison === 0 : op === "!=" ? comparison !== 0 : op === ">=" ? comparison >= 0 : op === "<=" ? comparison <= 0 : op === ">" ? comparison > 0 : comparison < 0;
+        };
+        progRest = progRest.slice(cmpCondM[0].length).trim();
+      }
+    }
+    const awkM = syncAwkPrintRe.exec(progRest);
     if (!awkM) return void 0;
-    const exprBody = awkM[1]?.trim();
+    const subFn = awkM[1];
+    const subPat = awkM[2];
+    const subRep = awkM[3] ?? "";
+    const subTarget = awkM[4] ?? "0";
+    if (awkM[6] !== void 0) return void 0;
+    const exprBody = awkM[5]?.trim();
+    let subRe;
+    if (subFn && subPat !== void 0) {
+      const aS = subPat.startsWith("^");
+      const c1 = aS ? subPat.slice(1) : subPat;
+      const aE = c1.endsWith("$");
+      const core = aE ? c1.slice(0, -1) : c1;
+      const esc = core.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      subRe = new RegExp((aS ? "^" : "") + esc + (aE ? "$" : ""), subFn === "gsub" ? "g" : "");
+    }
     const parts = [];
     if (!exprBody) {
       parts.push({ kind: "field", token: "0" });
     } else {
-      const tokenRe = /\$([0-9]+|NF)|"([^"$\\]*)"|(,)/g;
+      syncAwkTokenRe.lastIndex = 0;
+      const tokenRe = syncAwkTokenRe;
       let m;
       while ((m = tokenRe.exec(exprBody)) !== null) {
-        if (m[1] !== void 0) parts.push({ kind: "field", token: m[1] });
-        else if (m[2] !== void 0) parts.push({ kind: "lit", text: m[2] });
-        else if (m[3] !== void 0) parts.push({ kind: "lit", text: " " });
+        if (m[1] !== void 0) {
+          const tm = /^(\$(?:[0-9]+|NF)|NR|NF)\s*(==|!=|>=|<=|>|<)\s*(-?[0-9]+(?:\.[0-9]+)?|"[^"$\\]*")\s*\?\s*(\$(?:[0-9]+|NF)|"[^"$\\]*"|-?[0-9]+(?:\.[0-9]+)?)\s*:\s*(\$(?:[0-9]+|NF)|"[^"$\\]*"|-?[0-9]+(?:\.[0-9]+)?)$/.exec(m[1].trim());
+          if (!tm) return void 0;
+          parts.push({ kind: "ternary", lhs: tm[1], op: tm[2], rhs: tm[3], yes: tm[4], no: tm[5] });
+        } else if (m[2] !== void 0) parts.push({ kind: "int", token: m[2] });
+        else if (m[3] !== void 0) parts.push({ kind: "case", fn: m[3] === "toupper" ? "upper" : "lower", token: m[4] });
+        else if (m[5] !== void 0) parts.push({ kind: "substr", token: m[5], start: Number(m[6]), len: m[7] !== void 0 ? Number(m[7]) : void 0 });
+        else if (m[8] !== void 0) parts.push({ kind: "index", token: m[8], sub: m[9] });
+        else if (m[10] !== void 0) {
+          const aToks = m[10].trim().split(/\s*([+*\/%-])\s*/);
+          for (let ti = 0; ti < aToks.length; ti += 2) {
+            const at = aToks[ti];
+            if (!at.startsWith("$") && at !== "NR" && at !== "NF" && !/^-?[0-9]+(?:\.[0-9]+)?$/.test(at) && !userVars.has(at)) return void 0;
+          }
+          for (let ti = 1; ti < aToks.length; ti += 2) {
+            if (aToks[ti] === "/" || aToks[ti] === "%") {
+              const divisor = Number(aToks[ti + 1]);
+              if (!Number.isFinite(divisor) || divisor === 0) return void 0;
+            }
+          }
+          parts.push({ kind: "arith", tokens: aToks });
+        } else if (m[11] !== void 0) {
+          const offset = Number(m[11]);
+          if (offset > 0) return void 0;
+          parts.push({ kind: "nf_minus", offset });
+        } else if (m[12] !== void 0) parts.push({ kind: "field", token: m[12] });
+        else if (m[0] === "length" || m[0].startsWith("length(")) parts.push({ kind: "length", token: m[13] ?? "0" });
+        else if (m[14] !== void 0) parts.push({ kind: "var", name: m[14] });
+        else if (m[15] !== void 0) parts.push({ kind: "lit", text: m[15] });
+        else if (m[16] !== void 0) {
+          const uv = userVars.get(m[16]);
+          if (uv === void 0) return void 0;
+          parts.push({ kind: "lit", text: uv });
+        } else if (m[17] !== void 0) parts.push({ kind: "lit", text: ofs });
+      }
+    }
+    const outLines = [];
+    for (let li = 0; li < rawLines.length; li++) {
+      let l = rawLines[li];
+      let fields3 = awkSep === void 0 || awkSep === " " ? l.split(/[ \t]+/).filter(Boolean) : l.length === 0 ? [] : l.split(awkSep);
+      if (rowPred && !rowPred(l, fields3, li + 1)) continue;
+      if (subRe) {
+        if (subTarget === "0") {
+          l = l.replace(subRe, (matched) => subRep.split("&").join(matched));
+          fields3 = awkSep === void 0 || awkSep === " " ? l.split(/[ \t]+/).filter(Boolean) : l.length === 0 ? [] : l.split(awkSep);
+        } else {
+          const tIdx = subTarget === "NF" ? fields3.length : Number(subTarget);
+          if (tIdx >= 1 && tIdx <= fields3.length) {
+            fields3 = [...fields3];
+            fields3[tIdx - 1] = fields3[tIdx - 1].replace(subRe, (matched) => subRep.split("&").join(matched));
+            l = fields3.join(ofs);
+          }
+        }
+      }
+      if (parts.length === 1 && parts[0].kind === "field" && parts[0].token === "0") {
+        outLines.push(l);
+        continue;
       }
-    }
-    return rawLines.map((l) => {
-      if (parts.length === 1 && parts[0].kind === "field" && parts[0].token === "0") return l;
-      const fields3 = awkSep !== void 0 ? awkSep === " " ? l.trim().split(/\s+/).filter(Boolean) : l.length === 0 ? [] : l.split(awkSep) : l.trim().split(/\s+/).filter(Boolean);
       let out = "";
       for (let pi = 0; pi < parts.length; pi++) {
         const p = parts[pi];
         if (p.kind === "lit") out += p.text;
-        else if (p.token === "0") out += l;
+        else if (p.kind === "var") out += String(p.name === "NR" ? li + 1 : fields3.length);
+        else if (p.kind === "nf_minus") {
+          const idx = fields3.length - p.offset;
+          if (idx < 0) return void 0;
+          out += idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+        } else if (p.kind === "case") {
+          const idx = p.token === "NF" ? fields3.length : Number(p.token);
+          const s = idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+          out += p.fn === "upper" ? s.toUpperCase() : s.toLowerCase();
+        } else if (p.kind === "substr") {
+          const idx = p.token === "NF" ? fields3.length : Number(p.token);
+          const s = idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+          const chars = Array.from(s);
+          const s0 = Math.max(0, p.start - 1);
+          out += (p.len !== void 0 ? chars.slice(s0, s0 + Math.max(0, p.len)) : chars.slice(s0)).join("");
+        } else if (p.kind === "index") {
+          const idx = p.token === "NF" ? fields3.length : Number(p.token);
+          const s = idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+          const pos = p.sub.length === 0 ? -1 : s.indexOf(p.sub);
+          out += String(pos === -1 ? 0 : pos + 1);
+        } else if (p.kind === "int") {
+          const idx = p.token === "NF" ? fields3.length : Number(p.token);
+          const s = idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+          const n = Number(/^[ \t]*([+-]?(?:\d+(?:\.\d*)?|\.\d+))/.exec(s)?.[1] ?? 0);
+          out += String(Math.trunc(n));
+        } else if (p.kind === "ternary") {
+          const resolveAtom = (tok) => {
+            if (tok.startsWith('"') && tok.endsWith('"')) return tok.slice(1, -1);
+            if (tok === "NR") return String(li + 1);
+            if (tok === "NF") return String(fields3.length);
+            if (tok.startsWith("$")) {
+              const fIdx = tok === "$NF" ? fields3.length : Number(tok.slice(1));
+              return fIdx === 0 ? l : fIdx >= 1 && fIdx <= fields3.length ? fields3[fIdx - 1] : "";
+            }
+            return tok;
+          };
+          const lv = resolveAtom(p.lhs);
+          const rv = resolveAtom(p.rhs);
+          const isStrCmp = p.rhs.startsWith('"');
+          let cond = false;
+          if (isStrCmp) {
+            cond = p.op === "==" ? lv === rv : p.op === "!=" ? lv !== rv : p.op === ">" ? lv > rv : p.op === "<" ? lv < rv : p.op === ">=" ? lv >= rv : lv <= rv;
+          } else {
+            const ln = Number(lv) || 0;
+            const rn = Number(rv) || 0;
+            cond = p.op === "==" ? ln === rn : p.op === "!=" ? ln !== rn : p.op === ">" ? ln > rn : p.op === "<" ? ln < rn : p.op === ">=" ? ln >= rn : ln <= rn;
+          }
+          out += resolveAtom(cond ? p.yes : p.no);
+        } else if (p.kind === "arith") {
+          const vals = [];
+          const ops = [];
+          for (let ti = 0; ti < p.tokens.length; ti++) {
+            const tk = p.tokens[ti];
+            if (ti % 2 === 1) {
+              ops.push(tk);
+            } else {
+              let v = 0;
+              if (tk === "NR") v = li + 1;
+              else if (tk === "NF") v = fields3.length;
+              else if (tk.startsWith("$")) {
+                const fSub = tk.slice(1);
+                const idx = fSub === "NF" ? fields3.length : Number(fSub);
+                const rawF = idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+                const nm = /^[ \t]*([+-]?(?:\d+(?:\.\d*)?|\.\d+))/.exec(rawF);
+                v = nm ? Number(nm[1]) : 0;
+              } else if (/^-?[0-9]+(?:\.[0-9]+)?$/.test(tk)) {
+                v = Number(tk);
+              } else {
+                const uv = userVars.get(tk) ?? "";
+                const nm = /^[ \t]*([+-]?(?:\d+(?:\.\d*)?|\.\d+))/.exec(uv);
+                v = nm ? Number(nm[1]) : 0;
+              }
+              vals.push(v);
+            }
+          }
+          const addVals = [vals[0]];
+          const addOps = [];
+          for (let oi = 0; oi < ops.length; oi++) {
+            const op = ops[oi];
+            const rhs = vals[oi + 1];
+            if (op === "*" || op === "/" || op === "%") {
+              if ((op === "/" || op === "%") && rhs === 0) return void 0;
+              const lhs = addVals.pop();
+              addVals.push(op === "*" ? lhs * rhs : op === "/" ? lhs / rhs : lhs % rhs);
+            } else {
+              addOps.push(op);
+              addVals.push(rhs);
+            }
+          }
+          let acc = addVals[0];
+          for (let oi = 0; oi < addOps.length; oi++) {
+            acc = addOps[oi] === "+" ? acc + addVals[oi + 1] : acc - addVals[oi + 1];
+          }
+          out += text(numeric2(acc));
+        } else if (p.kind === "length") {
+          const idx = p.token === "NF" ? fields3.length : Number(p.token);
+          const s = idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
+          out += String(Array.from(s).length);
+        } else if (p.token === "0") out += l;
         else {
           const idx = p.token === "NF" ? fields3.length : Number(p.token);
           out += idx === 0 ? l : idx >= 1 && idx <= fields3.length ? fields3[idx - 1] : "";
         }
       }
-      return out;
-    });
+      outLines.push(out);
+    }
+    return outLines;
   }
   formatSyncTransformQ(val) {
     let ansi = false;
@@ -90485,35 +92100,558 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     }
     return out + "'";
   }
-  sortSyncLines(rawLines, flag) {
-    const rev = flag !== void 0 && flag.includes("r");
-    const num = flag !== void 0 && flag.includes("n");
-    const uniq = flag !== void 0 && flag.includes("u");
+  wcMaxLineWidth(text3, singleByte) {
+    let columns = 0;
+    let maximum = 0;
+    for (const char of text3) {
+      const point = char.codePointAt(0);
+      if (point === 10 || point === 13 || point === 12) {
+        maximum = Math.max(maximum, columns);
+        columns = 0;
+      } else if (point === 9) columns += 8 - columns % 8;
+      else columns += singleByte ? Number(point >= 32 && point < 127) : wcDisplayWidth(point);
+    }
+    return Math.max(maximum, columns);
+  }
+  compareSyncVersion(a, b) {
+    let ia = 0;
+    let ib = 0;
+    while (ia < a.length || ib < b.length) {
+      while (ia < a.length && !(a[ia] >= "0" && a[ia] <= "9") || ib < b.length && !(b[ib] >= "0" && b[ib] <= "9")) {
+        const ca = ia < a.length ? a[ia] : void 0;
+        const cb = ib < b.length ? b[ib] : void 0;
+        const da = ca !== void 0 && ca >= "0" && ca <= "9";
+        const db = cb !== void 0 && cb >= "0" && cb <= "9";
+        if (da && db) break;
+        if (ca !== cb) {
+          if (ca === void 0) return -1;
+          if (cb === void 0) return 1;
+          if (da) return 1;
+          if (db) return -1;
+          return ca < cb ? -1 : 1;
+        }
+        ia++;
+        ib++;
+      }
+      const sa = ia;
+      while (ia < a.length && a[ia] >= "0" && a[ia] <= "9") ia++;
+      const sb = ib;
+      while (ib < b.length && b[ib] >= "0" && b[ib] <= "9") ib++;
+      if (sa < ia || sb < ib) {
+        const na = BigInt(sa < ia ? a.slice(sa, ia) : "0");
+        const nb = BigInt(sb < ib ? b.slice(sb, ib) : "0");
+        if (na !== nb) return na < nb ? -1 : 1;
+      }
+    }
+    return 0;
+  }
+  evalSyncNl(rawLines, opArgs) {
+    let bodyStyle = "t";
+    let format3 = "rn";
+    let width = 6;
+    let sep = "	";
+    let start = 1;
+    let inc = 1;
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if ((a === "-b" || a === "--body-numbering") && i + 1 < opArgs.length) {
+        const v = opArgs[++i];
+        if (v !== "a" && v !== "t" && v !== "n") return void 0;
+        bodyStyle = v;
+      } else if (a === "-ba" || a === "-bt" || a === "-bn") {
+        bodyStyle = a[2];
+      } else if ((a === "-n" || a === "--number-format") && i + 1 < opArgs.length) {
+        const v = opArgs[++i];
+        if (v !== "ln" && v !== "rn" && v !== "rz") return void 0;
+        format3 = v;
+      } else if (a === "-nln" || a === "-nrn" || a === "-nrz") {
+        format3 = a.slice(2);
+      } else if ((a === "-w" || a === "--number-width") && i + 1 < opArgs.length && /^[1-9][0-9]{0,2}$/.test(opArgs[i + 1])) {
+        width = Number(opArgs[++i]);
+      } else if (/^-w[1-9][0-9]{0,2}$/.test(a)) {
+        width = Number(a.slice(2));
+      } else if ((a === "-s" || a === "--number-separator") && i + 1 < opArgs.length) {
+        sep = opArgs[++i];
+      } else if (a.startsWith("-s") && a.length > 2) {
+        sep = a.slice(2);
+      } else if ((a === "-v" || a === "--starting-line-number") && i + 1 < opArgs.length && /^-?[0-9]{1,9}$/.test(opArgs[i + 1])) {
+        start = Number(opArgs[++i]);
+      } else if (/^-v-?[0-9]{1,9}$/.test(a)) {
+        start = Number(a.slice(2));
+      } else if ((a === "-i" || a === "--line-increment") && i + 1 < opArgs.length && /^-?[0-9]{1,9}$/.test(opArgs[i + 1])) {
+        inc = Number(opArgs[++i]);
+      } else if (/^-i-?[0-9]{1,9}$/.test(a)) {
+        inc = Number(a.slice(2));
+      } else {
+        return void 0;
+      }
+    }
+    const out = [];
+    let curStyle = bodyStyle;
+    let num = start;
+    const unnumberedPrefix = " ".repeat(width + sep.length);
+    for (let i = 0; i < rawLines.length; i++) {
+      const l = rawLines[i];
+      if (l === "\\:" || l === "\\:\\:" || l === "\\:\\:\\:") {
+        curStyle = l === "\\:\\:" ? bodyStyle : "n";
+        num = start;
+        out.push("");
+        continue;
+      }
+      const numbered = curStyle === "a" || curStyle === "t" && l.length > 0;
+      if (!numbered) {
+        out.push(l.length === 0 && sep === "	" ? " ".repeat(width + 1) : unnumberedPrefix + l);
+        continue;
+      }
+      const label = String(num);
+      const pad = Math.max(0, width - label.length);
+      let prefix3;
+      if (format3 === "ln") prefix3 = label + " ".repeat(pad);
+      else if (format3 === "rz") prefix3 = num < 0 ? "-" + "0".repeat(pad) + label.slice(1) : "0".repeat(pad) + label;
+      else prefix3 = " ".repeat(pad) + label;
+      out.push(prefix3 + sep + l);
+      num += inc;
+    }
+    return out;
+  }
+  evalSyncPaste(rawLines, opArgs) {
+    let serial = false;
+    let delims = ["	"];
+    let literal = false;
+    const files = [];
+    const parseDelims = (s) => {
+      if (s.length === 0) return [""];
+      const res = [];
+      const escapes2 = { b: "\b", f: "\f", n: "\n", r: "\r", t: "	", v: "\v", "0": "" };
+      for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === "\\") {
+          if (i + 1 >= s.length) return void 0;
+          const esc = s[++i];
+          res.push(escapes2[esc] ?? esc);
+        } else {
+          res.push(ch);
+        }
+      }
+      return res.length > 0 ? res : [""];
+    };
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (literal || a === "-" || !a.startsWith("-")) {
+        files.push(a);
+        continue;
+      }
+      if (a === "--") {
+        literal = true;
+        continue;
+      }
+      if (a === "--serial") {
+        serial = true;
+        continue;
+      }
+      if (a === "--delimiters" && i + 1 < opArgs.length) {
+        const d = parseDelims(opArgs[++i]);
+        if (!d) return void 0;
+        delims = d;
+        continue;
+      }
+      if (a.startsWith("--delimiters=")) {
+        const d = parseDelims(a.slice(13));
+        if (!d) return void 0;
+        delims = d;
+        continue;
+      }
+      if (a.startsWith("--")) return void 0;
+      for (let k = 1; k < a.length; k++) {
+        const f = a[k];
+        if (f === "s") serial = true;
+        else if (f === "d") {
+          const rest = a.slice(k + 1);
+          const rawD = rest.length > 0 ? rest : i + 1 < opArgs.length ? opArgs[++i] : void 0;
+          if (rawD === void 0) return void 0;
+          const d = parseDelims(rawD);
+          if (!d) return void 0;
+          delims = d;
+          break;
+        } else return void 0;
+      }
+    }
+    if (files.length === 0) files.push("-");
+    if (!files.every((f) => f === "-")) return void 0;
+    if (serial) {
+      if (files.length !== 1) return void 0;
+      if (rawLines.length === 0) return [];
+      let joined = rawLines[0];
+      for (let i = 1; i < rawLines.length; i++) {
+        joined += delims[(i - 1) % delims.length] + rawLines[i];
+      }
+      return joined.split("\n");
+    }
+    const cols = files.length;
+    const out = [];
+    for (let i = 0; i < rawLines.length; i += cols) {
+      let row = rawLines[i] ?? "";
+      for (let c = 1; c < cols; c++) {
+        row += delims[(c - 1) % delims.length] + (rawLines[i + c] ?? "");
+      }
+      out.push(row);
+    }
+    return out;
+  }
+  evalSyncNumfmt(rawLines, opArgs) {
+    let fromScale = "none";
+    let toScale = "none";
+    let padding2 = 0;
+    let suffix2 = "";
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a.startsWith("--from=")) {
+        const v = a.slice(7);
+        if (v === "none" || v === "iec" || v === "iec-i" || v === "si" || v === "auto") fromScale = v;
+        else return void 0;
+      } else if (a.startsWith("--to=")) {
+        const v = a.slice(5);
+        if (v === "none" || v === "iec" || v === "iec-i" || v === "si") toScale = v;
+        else return void 0;
+      } else if (a.startsWith("--padding=")) {
+        const v = a.slice(10);
+        if (!/^-?[1-9][0-9]{0,2}$/.test(v)) return void 0;
+        padding2 = Number(v);
+      } else if (a.startsWith("--suffix=")) {
+        suffix2 = a.slice(9);
+      } else {
+        return void 0;
+      }
+    }
+    const units = "KMGTPEZY";
+    const out = [];
+    for (let i = 0; i < rawLines.length; i++) {
+      const raw = rawLines[i].trim();
+      if (raw.length === 0) {
+        out.push("");
+        continue;
+      }
+      const m = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+))([KMGTPEZYkmgtpezy]i?)?$/.exec(raw);
+      if (!m) return void 0;
+      let val = Number(m[1]);
+      const suf = m[2] ?? "";
+      if (suf.length > 0) {
+        if (fromScale === "none") return void 0;
+        const uChar = suf[0].toUpperCase();
+        const pIdx = units.indexOf(uChar) + 1;
+        if (pIdx <= 0) return void 0;
+        const hasI = suf.length === 2 && suf[1].toLowerCase() === "i";
+        if (fromScale === "iec-i" && !hasI) return void 0;
+        if ((fromScale === "iec" || fromScale === "si") && hasI) return void 0;
+        const fBase = fromScale === "iec" || fromScale === "iec-i" || fromScale === "auto" && hasI ? 1024 : 1e3;
+        val = val * Math.pow(fBase, pIdx);
+      } else if (fromScale === "iec-i") {
+      }
+      val = val >= 0 ? Math.ceil(val - 1e-12) : -Math.ceil(Math.abs(val) - 1e-12);
+      let rendered;
+      if (toScale === "none") {
+        rendered = String(Math.trunc(val));
+      } else {
+        const tBase = toScale === "iec" || toScale === "iec-i" ? 1024 : 1e3;
+        let pIdx = 0;
+        let scaled = val;
+        while (Math.abs(scaled) >= tBase && pIdx < units.length) {
+          scaled /= tBase;
+          pIdx++;
+        }
+        if (pIdx === 0) {
+          rendered = String(Math.trunc(scaled));
+        } else {
+          if (Math.abs(scaled) < 10) {
+            scaled = (scaled >= 0 ? Math.ceil(scaled * 10 - 1e-12) : -Math.ceil(Math.abs(scaled) * 10 - 1e-12)) / 10;
+            if (Math.abs(scaled) >= tBase && pIdx < units.length) {
+              scaled /= tBase;
+              pIdx++;
+            }
+          } else {
+            scaled = scaled >= 0 ? Math.ceil(scaled - 1e-12) : -Math.ceil(Math.abs(scaled) - 1e-12);
+            if (Math.abs(scaled) >= tBase && pIdx < units.length) {
+              scaled /= tBase;
+              pIdx++;
+            }
+          }
+          const numText = Math.abs(scaled) < 10 ? scaled.toFixed(1) : scaled.toFixed(0);
+          const uText = (toScale === "si" && pIdx === 1 ? "k" : units[pIdx - 1]) + (toScale === "iec-i" ? "i" : "");
+          rendered = numText + uText;
+        }
+      }
+      rendered += suffix2;
+      if (padding2 !== 0) {
+        const w = Math.abs(padding2);
+        if (rendered.length < w) {
+          const pad = " ".repeat(w - rendered.length);
+          rendered = padding2 < 0 ? rendered + pad : pad + rendered;
+        }
+      }
+      out.push(rendered);
+    }
+    return out;
+  }
+  evalSyncSort(rawLines, opArgs, isByteLocale) {
+    if (isByteLocale) return void 0;
+    let rev = false;
+    let num = false;
+    let human = false;
+    let month = false;
+    let dict = false;
+    let uniq = false;
+    let fold2 = false;
+    let blanks = false;
+    let stable = false;
+    let ver = false;
+    let sep;
+    let keySpec;
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (/^-[runfbsVhMd]+$/.test(a)) {
+        if (a.includes("r")) rev = true;
+        if (a.includes("n")) num = true;
+        if (a.includes("h")) human = true;
+        if (a.includes("M")) month = true;
+        if (a.includes("d")) dict = true;
+        if (a.includes("u")) uniq = true;
+        if (a.includes("f")) fold2 = true;
+        if (a.includes("b")) blanks = true;
+        if (a.includes("s")) stable = true;
+        if (a.includes("V")) ver = true;
+      } else if (a === "--reverse") rev = true;
+      else if (a === "--numeric-sort") num = true;
+      else if (a === "--human-numeric-sort") human = true;
+      else if (a === "--month-sort") month = true;
+      else if (a === "--dictionary-order") dict = true;
+      else if (a === "--unique") uniq = true;
+      else if (a === "--ignore-case") fold2 = true;
+      else if (a === "--ignore-leading-blanks") blanks = true;
+      else if (a === "--stable") stable = true;
+      else if (a === "--version-sort") ver = true;
+      else if (a === "-t" && i + 1 < opArgs.length && opArgs[i + 1].length === 1) {
+        sep = opArgs[++i];
+      } else if (a.startsWith("-t") && a.length === 3) {
+        sep = a[2];
+      } else if (a.startsWith("--field-separator=") && a.length === 19) {
+        sep = a[18];
+      } else if (a === "-k" && i + 1 < opArgs.length) {
+        if (keySpec !== void 0) return void 0;
+        keySpec = opArgs[++i];
+      } else if (a.startsWith("-k") && a.length > 2) {
+        if (keySpec !== void 0) return void 0;
+        keySpec = a.slice(2);
+      } else {
+        return void 0;
+      }
+    }
+    if (ver || keySpec?.includes("V")) return void 0;
+    let startField = 1;
+    let endField;
+    let keyNum = num;
+    let keyHuman = human;
+    let keyMonth = month;
+    let keyDict = dict;
+    let keyRev = rev;
+    let keyFold = fold2;
+    let keyBlanks = blanks;
+    let keyVer = ver;
+    if (keySpec !== void 0) {
+      const km = /^([1-9][0-9]{0,2})(?:,([1-9][0-9]{0,2}))?([nrbfVhMd]*)$/.exec(keySpec);
+      if (!km) return void 0;
+      startField = Number(km[1]);
+      endField = km[2] !== void 0 ? Number(km[2]) : void 0;
+      if (endField !== void 0 && endField < startField) return void 0;
+      const kf = km[3] ?? "";
+      if (kf.includes("n")) keyNum = true;
+      if (kf.includes("h")) keyHuman = true;
+      if (kf.includes("M")) keyMonth = true;
+      if (kf.includes("d")) keyDict = true;
+      if (kf.includes("r")) keyRev = true;
+      if (kf.includes("f")) keyFold = true;
+      if (kf.includes("b")) keyBlanks = true;
+      if (kf.includes("V")) keyVer = true;
+    }
+    const extractKey = (l) => {
+      let raw = keySpec === void 0 ? l : (() => {
+        if (sep !== void 0) {
+          const fields3 = l.split(sep);
+          return fields3.slice(startField - 1, endField).join(sep);
+        }
+        let offset = 0;
+        let start = l.length;
+        let end = l.length;
+        for (let field2 = 1; offset < l.length; field2++) {
+          if (field2 === startField) start = offset;
+          while (l[offset] === " " || l[offset] === "	") offset++;
+          while (offset < l.length && l[offset] !== " " && l[offset] !== "	") offset++;
+          if (field2 === endField) {
+            end = offset;
+            break;
+          }
+        }
+        return l.slice(start, end);
+      })();
+      if (keyBlanks) raw = raw.replace(/^[ \t]+/, "");
+      if (keyDict) raw = raw.replace(/[^a-zA-Z0-9 \t]+/g, "");
+      return keyFold ? raw.toUpperCase() : raw;
+    };
     const parseNum = (s) => {
-      const m = /^[ \t]*([+-]?(?:\d+(?:\.\d*)?|\.\d+))/.exec(s);
+      const m = /^[ \t]*(-?(?:\d+(?:\.\d*)?|\.\d+))/.exec(s);
       return m ? Number(m[1]) : 0;
     };
+    const compareHuman = (sa, sb) => {
+      const parseH = (s) => {
+        const m = /^[ \t]*(-?(?:\d+(?:\.\d*)?|\.\d+))([KMGTPEZYkmgtpezy])?/.exec(s);
+        if (!m) return { sign: 0, unit: 0, val: 0 };
+        const val = Number(m[1]);
+        if (val === 0) return { sign: 0, unit: 0, val: 0 };
+        const uChar = m[2] ? m[2].toUpperCase() : "";
+        const unit = uChar === "" ? 0 : "KMGTPEZY".indexOf(uChar) + 1;
+        return { sign: val < 0 ? -1 : 1, unit, val };
+      };
+      const ha = parseH(sa);
+      const hb = parseH(sb);
+      if (ha.sign !== hb.sign) return ha.sign - hb.sign;
+      if (ha.unit !== hb.unit) return ha.sign < 0 ? hb.unit - ha.unit : ha.unit - hb.unit;
+      return ha.val - hb.val;
+    };
+    const parseMonth = (s) => {
+      const m = /^[ \t]*([a-zA-Z]{3})/.exec(s);
+      if (!m) return 0;
+      const idx = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"].indexOf(m[1].toUpperCase());
+      return idx === -1 ? 0 : idx + 1;
+    };
     const sorted = [...rawLines].sort((a, b) => {
-      if (num) {
-        const na = parseNum(a);
-        const nb = parseNum(b);
-        if (na !== nb) return rev ? nb - na : na - nb;
-      }
+      const ka = extractKey(a);
+      const kb = extractKey(b);
+      if (keyHuman) {
+        const hc = compareHuman(ka, kb);
+        if (hc !== 0) return keyRev ? -hc : hc;
+      } else if (keyMonth) {
+        const ma = parseMonth(ka);
+        const mb = parseMonth(kb);
+        if (ma !== mb) return keyRev ? mb - ma : ma - mb;
+      } else if (keyNum) {
+        const na = parseNum(ka);
+        const nb = parseNum(kb);
+        if (na !== nb) return keyRev ? nb - na : na - nb;
+      } else if (keyVer) {
+        const vc = this.compareSyncVersion(ka, kb);
+        if (vc !== 0) return keyRev ? -vc : vc;
+      } else if (ka !== kb) {
+        return ka < kb ? keyRev ? 1 : -1 : keyRev ? -1 : 1;
+      }
+      if (uniq || stable) return 0;
+      const fa = fold2 ? a.toUpperCase() : a;
+      const fb = fold2 ? b.toUpperCase() : b;
+      if (fa !== fb) return fa < fb ? rev ? 1 : -1 : rev ? -1 : 1;
       return a < b ? rev ? 1 : -1 : a > b ? rev ? -1 : 1 : 0;
     });
     if (!uniq) return sorted;
     const dedup = [];
     for (let i = 0; i < sorted.length; i++) {
-      if (i === 0 || sorted[i] !== sorted[i - 1]) dedup.push(sorted[i]);
+      if (i === 0) {
+        dedup.push(sorted[i]);
+      } else {
+        const ka = extractKey(sorted[i]);
+        const kb = extractKey(sorted[i - 1]);
+        const same = keyHuman ? compareHuman(ka, kb) === 0 : keyMonth ? parseMonth(ka) === parseMonth(kb) : keyNum ? parseNum(ka) === parseNum(kb) : keyVer ? this.compareSyncVersion(ka, kb) === 0 : ka === kb;
+        if (!same) dedup.push(sorted[i]);
+      }
     }
     return dedup;
   }
-  translateSyncTr(input3, set1Spec, set2Spec) {
-    if (set1Spec === "a-z" && set2Spec === "A-Z") return input3.toUpperCase();
-    if (set1Spec === "A-Z" && set2Spec === "a-z") return input3.toLowerCase();
-    const s1 = this.expandSyncTrCharArray(set1Spec);
+  normalizeSyncWcFlag(arg) {
+    if (arg === "-l" || arg === "--lines") return "-l";
+    if (arg === "-c" || arg === "--bytes") return "-c";
+    if (arg === "-w" || arg === "--words") return "-w";
+    if (arg === "-m" || arg === "--chars") return "-m";
+    if (arg === "-L" || arg === "--max-line-length") return "-L";
+    return void 0;
+  }
+  evalSyncUniq(rawLines, opArgs) {
+    let ignoreCase = false;
+    let hasCount = false;
+    let onlyRepeated = false;
+    let onlyUnique = false;
+    let skipFields = 0;
+    let skipChars = 0;
+    let checkChars = Infinity;
+    for (let i = 0; i < opArgs.length; i++) {
+      const a = opArgs[i];
+      if (a === "--ignore-case") ignoreCase = true;
+      else if (a === "--count") hasCount = true;
+      else if (a === "--repeated") onlyRepeated = true;
+      else if (a === "--unique") onlyUnique = true;
+      else if (/^--skip-fields=[0-9]{1,4}$/.test(a)) skipFields = Number(a.slice(14));
+      else if (/^--skip-chars=[0-9]{1,4}$/.test(a)) skipChars = Number(a.slice(13));
+      else if (/^--check-chars=[0-9]{1,4}$/.test(a)) checkChars = Number(a.slice(14));
+      else if ((a === "-f" || a === "-s" || a === "-w") && i + 1 < opArgs.length && /^[0-9]{1,4}$/.test(opArgs[i + 1])) {
+        const n = Number(opArgs[++i]);
+        if (a === "-f") skipFields = n;
+        else if (a === "-s") skipChars = n;
+        else checkChars = n;
+      } else if (/^-[fsw][0-9]{1,4}$/.test(a)) {
+        const n = Number(a.slice(2));
+        if (a[1] === "f") skipFields = n;
+        else if (a[1] === "s") skipChars = n;
+        else checkChars = n;
+      } else if (/^-[cdui]+$/.test(a)) {
+        for (let k = 1; k < a.length; k++) {
+          const ch = a[k];
+          if (ch === "i") ignoreCase = true;
+          else if (ch === "c") hasCount = true;
+          else if (ch === "d") onlyRepeated = true;
+          else if (ch === "u") onlyUnique = true;
+        }
+      } else {
+        return void 0;
+      }
+    }
+    const keyOf = (l) => {
+      let offset = 0;
+      for (let f = 0; f < skipFields; f++) {
+        while (offset < l.length && (l[offset] === " " || l[offset] === "	")) offset++;
+        while (offset < l.length && l[offset] !== " " && l[offset] !== "	") offset++;
+      }
+      if (skipChars === 0 && checkChars === Infinity) {
+        const sub2 = l.slice(offset);
+        return ignoreCase ? sub2.toLowerCase() : sub2;
+      }
+      const chars = Array.from(l.slice(offset));
+      const sub = (checkChars === Infinity ? chars.slice(skipChars) : chars.slice(skipChars, skipChars + checkChars)).join("");
+      return ignoreCase ? sub.toLowerCase() : sub;
+    };
+    const outLines = [];
+    let uIdx = 0;
+    while (uIdx < rawLines.length) {
+      const k0 = keyOf(rawLines[uIdx]);
+      let uEnd = uIdx + 1;
+      while (uEnd < rawLines.length && keyOf(rawLines[uEnd]) === k0) uEnd++;
+      const count2 = uEnd - uIdx;
+      if ((!onlyRepeated || count2 > 1) && (!onlyUnique || count2 === 1)) {
+        outLines.push(hasCount ? `${String(count2).padStart(7, " ")} ${rawLines[uIdx]}` : rawLines[uIdx]);
+      }
+      uIdx = uEnd;
+    }
+    return outLines;
+  }
+  sortSyncLines(rawLines, flag) {
+    return this.evalSyncSort(rawLines, flag !== void 0 ? [flag] : [], false) ?? [...rawLines];
+  }
+  translateSyncTr(input3, set1Spec, set2Spec, truncateSet1 = false) {
+    if ((set1Spec === "a-z" || set1Spec === "[:lower:]") && (set2Spec === "A-Z" || set2Spec === "[:upper:]")) {
+      return input3.replace(/[a-z]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 32));
+    }
+    if ((set1Spec === "A-Z" || set1Spec === "[:upper:]") && (set2Spec === "a-z" || set2Spec === "[:lower:]")) {
+      return input3.replace(/[A-Z]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) + 32));
+    }
+    const rawS1 = this.expandSyncTrCharArray(set1Spec);
     const s2 = this.expandSyncTrCharArray(set2Spec);
-    if (!s1 || !s2 || s1.length === 0 || s2.length === 0) return void 0;
+    if (!rawS1 || !s2 || rawS1.length === 0 || s2.length === 0) return void 0;
+    const s1 = truncateSet1 ? rawS1.slice(0, s2.length) : rawS1;
+    if (s1.length === 0) return input3;
     if (s1.length === 1 && s2.length === 1) return input3.split(s1[0]).join(s2[0]);
     const map = /* @__PURE__ */ new Map();
     for (let i = 0; i < s1.length; i++) {
@@ -90657,7 +92795,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         const sName = sCmd.words[0].plain;
         if (!sName || hasShellFunction(rawState, sName) || rawState.extensions?.builtins.has(sName)) return void 0;
         const extDef = this.getExternalCommand(sName);
-        if (!extDef || sName !== "rev" && sName !== "tac" && !builtInDirectContextExecutors.has(extDef.execute) || (sName === "rev" || sName === "tac") && customRegisteredRegistries.has(this.commands) || customRegisteredCommands.has(extDef.execute)) return void 0;
+        if (!extDef || sName !== "rev" && sName !== "tac" && sName !== "nl" && sName !== "paste" && sName !== "jq" && !builtInDirectContextExecutors.has(extDef.execute) || customRegisteredCommands.has(extDef.execute)) return void 0;
         if (!this.arePureArgWords(sCmd.words, rawState)) return void 0;
         const sArgs = [];
         for (let w = 1; w < sCmd.words.length; w++) {
@@ -90670,21 +92808,24 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         } else if (sName === "tr") {
           if (this.evalSyncTr("", sArgs) === void 0) return void 0;
         } else if (sName === "uniq") {
-          if (sArgs.length > 1 || sArgs.length === 1 && sArgs[0] !== "-c" && sArgs[0] !== "-d" && sArgs[0] !== "-u" && sArgs[0] !== "-i") return void 0;
+          if (this.evalSyncUniq([], sArgs) === void 0) return void 0;
         } else if (sName === "sort") {
-          if (sArgs.length > 1 || sArgs.length === 1 && sArgs[0] !== "-r" && sArgs[0] !== "-u" && sArgs[0] !== "-n" && sArgs[0] !== "-rn" && sArgs[0] !== "-nr" && sArgs[0] !== "-ru" && sArgs[0] !== "-ur") return void 0;
+          if (this.evalSyncSort([], sArgs, byteLocale(rawState.variables)) === void 0) return void 0;
         } else if (sName === "head" || sName === "tail") {
           if (sArgs.length === 0) {
             sArgs.push("-n", "10");
-          } else if (sArgs.length === 1 && /^-(?:n|c)?[0-9]+$/.test(sArgs[0])) {
-            const flag = sArgs[0].startsWith("-c") ? "-c" : "-n";
-            const numStr = sArgs[0].startsWith("-n") || sArgs[0].startsWith("-c") ? sArgs[0].slice(2) : sArgs[0].slice(1);
+          } else if (sArgs.length === 1 && (/^-(?:n|c)?[0-9]+$/.test(sArgs[0]) || /^--(?:lines|bytes)=[0-9]+$/.test(sArgs[0]) || sName === "tail" && /^(?:-n|--lines=)\+[0-9]+$/.test(sArgs[0]) || sName === "head" && /^(?:-n|--lines=)-[0-9]+$/.test(sArgs[0]))) {
+            const flag = sArgs[0].startsWith("-c") || sArgs[0].startsWith("--bytes=") ? "-c" : "-n";
+            const numStr = sArgs[0].startsWith("--") ? sArgs[0].slice(sArgs[0].indexOf("=") + 1) : sArgs[0].startsWith("-n") || sArgs[0].startsWith("-c") ? sArgs[0].slice(2) : sArgs[0].slice(1);
             sArgs.length = 0;
             sArgs.push(flag, numStr);
           }
-          if (sArgs.length !== 2 || sArgs[0] !== "-n" && sArgs[0] !== "-c" || !/^[0-9]+$/.test(sArgs[1])) return void 0;
+          const validNum = sArgs.length === 2 && (sArgs[0] === "-n" && (/^[0-9]+$/.test(sArgs[1]) || sName === "tail" && /^\+[0-9]+$/.test(sArgs[1]) || sName === "head" && /^-[0-9]+$/.test(sArgs[1])) || sArgs[0] === "-c" && /^[0-9]+$/.test(sArgs[1]));
+          if (!validNum) return void 0;
         } else if (sName === "wc") {
-          if (sArgs.length !== 1 || sArgs[0] !== "-l" && sArgs[0] !== "-c" && sArgs[0] !== "-w") return void 0;
+          const normWc = sArgs.length === 1 ? this.normalizeSyncWcFlag(sArgs[0]) : void 0;
+          if (!normWc) return void 0;
+          sArgs[0] = normWc;
         } else if (sName === "sed") {
           if (this.evalSyncSed([], sArgs) === void 0) return void 0;
         } else if (sName === "rev") {
@@ -90694,11 +92835,19 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         } else if (sName === "grep") {
           if (this.evalSyncGrep([], sArgs, Boolean(rawState.errexit)) === void 0) return void 0;
         } else if (sName === "jq") {
-          if (this.evalSyncJq("null", sArgs) === void 0) return void 0;
+          if (sArgs.length === 0 || sArgs.length > 2) return void 0;
+          if (sArgs.length === 1 && sArgs[0].startsWith("-")) return void 0;
+          if (sArgs.length === 2 && !["-r", "--raw-output", "-c", "--compact-output", "-rc", "-cr"].includes(sArgs[0])) return void 0;
         } else if (sName === "base64") {
           if (sArgs.length > 1 || sArgs.length === 1 && sArgs[0] !== "-d" && sArgs[0] !== "--decode") return void 0;
-        } else if (sName === "tac" || sName === "nl") {
+        } else if (sName === "tac") {
           if (sArgs.length !== 0) return void 0;
+        } else if (sName === "nl") {
+          if (this.evalSyncNl([], sArgs) === void 0) return void 0;
+        } else if (sName === "paste") {
+          if (this.evalSyncPaste([], sArgs) === void 0) return void 0;
+        } else if (sName === "numfmt") {
+          if (this.evalSyncNumfmt([], sArgs) === void 0) return void 0;
         } else {
           return void 0;
         }
@@ -90776,13 +92925,16 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
           const isInlineBase64 = firstName === "base64";
           const isInlineTac = firstName === "tac";
           const isInlineNl = firstName === "nl";
-          const isInlineSort = firstName === "sort" && !byteLocale(rawState.variables) && (stageArgs.length === 0 || stageArgs.length === 1 && (stageArgs[0] === "-r" || stageArgs[0] === "-u" || stageArgs[0] === "-n" || stageArgs[0] === "-rn" || stageArgs[0] === "-nr" || stageArgs[0] === "-ru" || stageArgs[0] === "-ur"));
-          const isInlineUniq = firstName === "uniq" && (stageArgs.length === 0 || stageArgs.length === 1 && (stageArgs[0] === "-d" || stageArgs[0] === "-u" || stageArgs[0] === "-c"));
+          const isInlinePaste = firstName === "paste";
+          const isInlineNumfmt = firstName === "numfmt";
+          const isInlineSort = firstName === "sort" && !byteLocale(rawState.variables);
+          const isInlineUniq = firstName === "uniq";
           const inlineSedMatch = firstName === "sed";
-          if (firstName === "rev" || firstName === "head" || firstName === "tail" || firstName === "wc" || firstName === "cut" && stageArgs.length === 2 && stageArgs[0] === "-c" || isInlineCutField || isInlineTr || isInlineSort || isInlineUniq || inlineSedMatch || isInlineAwk || isInlineGrep || isInlineJq || isInlineBase64 || isInlineTac || isInlineNl) {
+          if (firstName === "rev" || firstName === "head" || firstName === "tail" || firstName === "wc" || firstName === "cut" && stageArgs.length === 2 && stageArgs[0] === "-c" || isInlineCutField || isInlineTr || isInlineSort || isInlineUniq || inlineSedMatch || isInlineAwk || isInlineGrep || isInlineJq || isInlineBase64 || isInlineTac || isInlineNl || isInlinePaste || isInlineNumfmt) {
             const inStr = prevLen === 0 ? "" : sharedSyncPipeDecoder.decode(prevBuf.subarray(0, prevLen));
             const rawLines = inStr.length === 0 ? [] : inStr.endsWith("\n") ? inStr.slice(0, -1).split("\n") : inStr.split("\n");
             let outLines = [];
+            let sedTerminated = false;
             if (firstName === "rev") {
               outLines = rawLines.map((l) => Array.from(l).reverse().join(""));
             } else if (firstName === "head" || firstName === "tail") {
@@ -90797,7 +92949,14 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
                 prevLen = sub.byteLength;
                 continue;
               }
-              outLines = firstName === "head" ? rawLines.slice(0, count2) : count2 === 0 ? [] : rawLines.slice(-count2);
+              if (firstName === "tail" && stageArgs[1].startsWith("+")) {
+                outLines = rawLines.slice(Math.max(0, count2 - 1));
+              } else if (firstName === "head" && stageArgs[1].startsWith("-")) {
+                const drop = Math.abs(count2);
+                outLines = drop === 0 ? [...rawLines] : rawLines.slice(0, Math.max(0, rawLines.length - drop));
+              } else {
+                outLines = firstName === "head" ? rawLines.slice(0, count2) : count2 === 0 ? [] : rawLines.slice(-count2);
+              }
             } else if (firstName === "wc") {
               if (stageArgs[0] === "-l") {
                 let nl = 0;
@@ -90806,6 +92965,10 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
               } else if (stageArgs[0] === "-w") {
                 const trimmed = inStr.trim();
                 outLines = [String(trimmed.length === 0 ? 0 : trimmed.split(/[ \t\n\r\f\v]+/).length)];
+              } else if (stageArgs[0] === "-m") {
+                outLines = [String(byteLocale(rawState.variables) ? prevLen : Array.from(inStr).length)];
+              } else if (stageArgs[0] === "-L") {
+                outLines = [String(this.wcMaxLineWidth(inStr, byteLocale(rawState.variables)))];
               } else {
                 outLines = [String(prevLen)];
               }
@@ -90826,24 +92989,16 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
               prevLen = written2;
               continue;
             } else if (isInlineSort) {
-              outLines = this.sortSyncLines(rawLines, stageArgs[0]);
+              outLines = this.evalSyncSort(rawLines, stageArgs, false) ?? [];
             } else if (isInlineUniq) {
-              const mode = stageArgs[0];
-              outLines = [];
-              let uIdx = 0;
-              while (uIdx < rawLines.length) {
-                let uEnd = uIdx + 1;
-                while (uEnd < rawLines.length && rawLines[uEnd] === rawLines[uIdx]) uEnd++;
-                const count2 = uEnd - uIdx;
-                if (mode === "-d" ? count2 > 1 : mode === "-u" ? count2 === 1 : true) {
-                  outLines.push(mode === "-c" ? `${String(count2).padStart(7, " ")} ${rawLines[uIdx]}` : rawLines[uIdx]);
-                }
-                uIdx = uEnd;
-              }
+              const uniqRes = this.evalSyncUniq(rawLines, stageArgs);
+              if (uniqRes === void 0) return void 0;
+              outLines = uniqRes;
             } else if (inlineSedMatch) {
               const sedRes = this.evalSyncSed(rawLines, stageArgs);
               if (sedRes === void 0) return void 0;
-              outLines = sedRes;
+              outLines = sedRes.lines;
+              sedTerminated = sedRes.lastInputIndex < rawLines.length - 1;
             } else if (isInlineAwk) {
               const awkRes = this.evalSyncAwk(rawLines, stageArgs);
               if (awkRes === void 0) return void 0;
@@ -90858,14 +93013,17 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
               if (inStr.length > 0 && !inStr.endsWith("\n")) return void 0;
               outLines = [...rawLines].reverse();
             } else if (isInlineNl) {
-              outLines = [];
-              let nlNum = 1;
-              for (let li = 0; li < rawLines.length; li++) {
-                const l = rawLines[li];
-                if (l === "\\:" || l === "\\:\\:" || l === "\\:\\:\\:") return void 0;
-                if (l.length === 0) outLines.push("       ");
-                else outLines.push(String(nlNum++).padStart(6, " ") + "	" + l);
-              }
+              const nlRes = this.evalSyncNl(rawLines, stageArgs);
+              if (nlRes === void 0) return void 0;
+              outLines = nlRes;
+            } else if (isInlinePaste) {
+              const pasteRes = this.evalSyncPaste(rawLines, stageArgs);
+              if (pasteRes === void 0) return void 0;
+              outLines = pasteRes;
+            } else if (isInlineNumfmt) {
+              const nmRes = this.evalSyncNumfmt(rawLines, stageArgs);
+              if (nmRes === void 0) return void 0;
+              outLines = nmRes;
             } else if (isInlineBase64) {
               if (stageArgs.length === 0) {
                 const b64Wrapped = this.syncBase64Encode(prevBuf.subarray(0, prevLen));
@@ -90874,7 +93032,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
                 const cleaned = inStr.replace(/[ \t\r\n]+/g, "");
                 if (cleaned.length % 4 !== 0 || cleaned.length > 0 && !/^[A-Za-z0-9+/]+={0,2}$/.test(cleaned)) return void 0;
                 const decoded = this.syncBase64DecodeBytes(cleaned);
-                if (decoded.includes(0) || decoded.byteLength > nextBuf.byteLength) return void 0;
+                if (decoded.some((byte) => byte === 0 || byte >= 128) || decoded.byteLength > nextBuf.byteLength) return void 0;
                 const nextTotalBytes2 = this.budget.bytes + decoded.byteLength;
                 if (nextTotalBytes2 > this.budget.maxOutputBytesSmi && decoded.byteLength > this.budget.limits.maxOutputBytes - this.budget.bytes) this.budget.fail("maxOutputBytes");
                 this.budget.bytes = nextTotalBytes2;
@@ -90889,7 +93047,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
               outLines = jqRes;
             }
             const preservesTerminator = firstName === "head" || firstName === "tail" || firstName === "rev" || firstName === "sed";
-            const terminated = !preservesTerminator || inStr.endsWith("\n") || firstName === "head" && outLines.length < rawLines.length;
+            const terminated = sedTerminated || !preservesTerminator || inStr.endsWith("\n") || firstName === "head" && outLines.length < rawLines.length;
             const outStr2 = outLines.length > 0 ? outLines.join("\n") + (terminated ? "\n" : "") : "";
             const outByteLen = shellValueByteLength(outStr2);
             if (outByteLen > nextBuf.byteLength) return void 0;
@@ -91012,8 +93170,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     if (cmd.kind !== "simple" || cmd.redirects.length > 0 && !hasSingleStdinRedir && !hasSingleHereStringRedir || cmd.words.length === 0) return void 0;
     let w0Plain = cmd.words[0].plain;
     if (!w0Plain || rawState.extensions?.builtins.has(w0Plain)) return void 0;
-    const isSingleFileTool = w0Plain === "cat" || w0Plain === "head" || w0Plain === "tail" || w0Plain === "jq" || w0Plain === "awk" || w0Plain === "grep" || w0Plain === "sed" || w0Plain === "cut" || w0Plain === "wc" || w0Plain === "sort" || w0Plain === "uniq" || w0Plain === "tr" || hasSingleHereStringRedir && (w0Plain === "base64" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl");
-    if (isSingleFileTool && !hasShellFunction(rawState, w0Plain) && (this.commands.has(w0Plain) || (w0Plain === "rev" || w0Plain === "tac") && Boolean(this.getExternalCommand(w0Plain)))) {
+    const isSingleFileTool = w0Plain === "cat" || w0Plain === "head" || w0Plain === "tail" || w0Plain === "jq" || w0Plain === "awk" || w0Plain === "grep" || w0Plain === "sed" || w0Plain === "cut" || w0Plain === "wc" || w0Plain === "sort" || w0Plain === "uniq" || w0Plain === "tr" || hasSingleHereStringRedir && (w0Plain === "base64" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl" || w0Plain === "paste" || w0Plain === "numfmt");
+    if (isSingleFileTool && !hasShellFunction(rawState, w0Plain) && (this.commands.has(w0Plain) || (w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl" || w0Plain === "paste") && Boolean(this.getExternalCommand(w0Plain)))) {
       const allArgs = [];
       let fOk = true;
       for (let i = 1; i < cmd.words.length; i++) {
@@ -91046,6 +93204,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
           const view = hasSingleHereStringRedir ? fastSharedTextEncoder.encode(hereStrVal) : this.tryReadMemoryFileViewSync(resolvePath(rawState.cwd, fileArg));
           if (view && view.byteLength <= 16384 && !view.includes(0) && (hasSingleHereStringRedir || view.every((byte) => byte < 128))) {
             const fileStr = hasSingleHereStringRedir ? hereStrVal : sharedSyncPipeDecoder.decode(view);
+            if (fileStr.length > 0 && !fileStr.endsWith("\n") && (w0Plain === "head" || w0Plain === "tail" || w0Plain === "sed" || w0Plain === "cut" || w0Plain === "uniq")) return void 0;
+            const renderLines = (lines3) => lines3.length === 0 ? "" : lines3.join("\n") + "\n";
             const rawLines = fileStr.endsWith("\n") ? fileStr.slice(0, -1).split("\n") : fileStr.length === 0 ? [] : fileStr.split("\n");
             let fileRes;
             let exitStatus = 0;
@@ -91054,81 +93214,99 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
             } else if ((w0Plain === "head" || w0Plain === "tail") && opArgs.length <= 2) {
               let count2 = opArgs.length === 0 ? 10 : void 0;
               let byteCount2;
-              if (opArgs.length === 1 && opArgs[0].startsWith("-n") && /^[0-9]{1,5}$/.test(opArgs[0].slice(2))) count2 = Number(opArgs[0].slice(2));
-              else if (opArgs.length === 1 && opArgs[0].startsWith("-c") && /^[0-9]{1,5}$/.test(opArgs[0].slice(2))) byteCount2 = Number(opArgs[0].slice(2));
-              else if (opArgs.length === 1 && /^-[0-9]{1,5}$/.test(opArgs[0])) count2 = Number(opArgs[0].slice(1));
-              else if (opArgs.length === 2 && opArgs[0] === "-n" && /^[0-9]{1,5}$/.test(opArgs[1])) count2 = Number(opArgs[1]);
+              let countRaw = opArgs.length === 0 ? "10" : void 0;
+              if (opArgs.length === 1 && (opArgs[0].startsWith("-n") || opArgs[0].startsWith("--lines="))) {
+                const sub = opArgs[0].startsWith("--lines=") ? opArgs[0].slice(8) : opArgs[0].slice(2);
+                if (/^[0-9]{1,5}$/.test(sub) || w0Plain === "tail" && /^\+[0-9]{1,5}$/.test(sub) || w0Plain === "head" && /^-[0-9]{1,5}$/.test(sub)) countRaw = sub;
+              } else if (opArgs.length === 1 && (opArgs[0].startsWith("-c") || opArgs[0].startsWith("--bytes="))) {
+                const sub = opArgs[0].startsWith("--bytes=") ? opArgs[0].slice(8) : opArgs[0].slice(2);
+                if (/^[0-9]{1,5}$/.test(sub)) byteCount2 = Number(sub);
+              } else if (opArgs.length === 1 && /^-[0-9]{1,5}$/.test(opArgs[0])) countRaw = opArgs[0].slice(1);
+              else if (opArgs.length === 2 && opArgs[0] === "-n" && (/^[0-9]{1,5}$/.test(opArgs[1]) || w0Plain === "tail" && /^\+[0-9]{1,5}$/.test(opArgs[1]) || w0Plain === "head" && /^-[0-9]{1,5}$/.test(opArgs[1]))) countRaw = opArgs[1];
               else if (opArgs.length === 2 && opArgs[0] === "-c" && /^[0-9]{1,5}$/.test(opArgs[1])) byteCount2 = Number(opArgs[1]);
-              if (count2 !== void 0) {
-                const sliced = w0Plain === "head" ? rawLines.slice(0, count2) : count2 === 0 ? [] : rawLines.slice(-count2);
-                fileRes = sliced.join("\n");
+              if (countRaw !== void 0) {
+                count2 = Number(countRaw);
+                let sliced;
+                if (w0Plain === "tail" && countRaw.startsWith("+")) sliced = rawLines.slice(Math.max(0, count2 - 1));
+                else if (w0Plain === "head" && countRaw.startsWith("-")) {
+                  const drop = Math.abs(count2);
+                  sliced = drop === 0 ? [...rawLines] : rawLines.slice(0, Math.max(0, rawLines.length - drop));
+                } else {
+                  sliced = w0Plain === "head" ? rawLines.slice(0, count2) : count2 === 0 ? [] : rawLines.slice(-count2);
+                }
+                fileRes = renderLines(sliced);
               } else if (byteCount2 !== void 0) {
                 const slicedBytes = w0Plain === "head" ? view.subarray(0, Math.min(view.byteLength, byteCount2)) : byteCount2 === 0 ? view.subarray(0, 0) : view.subarray(Math.max(0, view.byteLength - byteCount2), view.byteLength);
                 fileRes = sharedSyncPipeDecoder.decode(slicedBytes);
               }
             } else if (w0Plain === "jq") {
               const jqRes = this.evalSyncJq(fileStr.trim(), opArgs);
-              if (jqRes !== void 0) fileRes = jqRes.join("\n");
+              if (jqRes !== void 0) fileRes = renderLines(jqRes);
             } else if (w0Plain === "awk") {
               const awkRes = this.evalSyncAwk(rawLines, opArgs);
-              if (awkRes !== void 0) fileRes = awkRes.join("\n");
+              if (awkRes !== void 0) fileRes = renderLines(awkRes);
             } else if (w0Plain === "grep") {
               const grepRes = this.evalSyncGrep(rawLines, opArgs, Boolean(rawState.errexit));
               if (grepRes !== void 0) {
                 exitStatus = grepRes.status;
-                fileRes = grepRes.lines.join("\n");
+                fileRes = renderLines(grepRes.lines);
               }
             } else if (w0Plain === "sed") {
               const sedRes = this.evalSyncSed(rawLines, opArgs);
-              if (sedRes !== void 0) fileRes = sedRes.join("\n");
+              if (sedRes !== void 0) fileRes = renderLines(sedRes.lines);
             } else if (w0Plain === "cut") {
               const cutRes = this.evalSyncCut(rawLines, opArgs, byteLocale(rawState.variables));
-              if (cutRes !== void 0) fileRes = cutRes.join("\n");
-            } else if (w0Plain === "wc" && opArgs.length === 1 && (opArgs[0] === "-l" || opArgs[0] === "-c" || opArgs[0] === "-w")) {
+              if (cutRes !== void 0) fileRes = renderLines(cutRes);
+            } else if (w0Plain === "wc" && opArgs.length === 1 && this.normalizeSyncWcFlag(opArgs[0]) !== void 0) {
+              const wcMode = this.normalizeSyncWcFlag(opArgs[0]);
               let count2 = 0;
-              if (opArgs[0] === "-l") {
+              if (wcMode === "-l") {
                 for (let k = 0; k < view.byteLength; k++) if (view[k] === 10) count2++;
-              } else if (opArgs[0] === "-c") {
+              } else if (wcMode === "-c") {
                 count2 = view.byteLength;
+              } else if (wcMode === "-m") {
+                count2 = byteLocale(rawState.variables) ? view.byteLength : Array.from(fileStr).length;
+              } else if (wcMode === "-L") {
+                count2 = this.wcMaxLineWidth(fileStr, byteLocale(rawState.variables));
               } else {
-                const trimmed = fileStr.trim();
-                count2 = trimmed.length === 0 ? 0 : trimmed.split(/\s+/).length;
-              }
-              fileRes = hasSingleStdinRedir || hasSingleHereStringRedir ? String(count2) : `${count2} ${fileArg}`;
-            } else if (w0Plain === "sort" && !byteLocale(rawState.variables) && (opArgs.length === 0 || opArgs.length === 1 && (opArgs[0] === "-r" || opArgs[0] === "-u" || opArgs[0] === "-n" || opArgs[0] === "-rn" || opArgs[0] === "-nr" || opArgs[0] === "-ru" || opArgs[0] === "-ur"))) {
-              fileRes = this.sortSyncLines(rawLines, opArgs[0]).join("\n");
-            } else if (w0Plain === "uniq" && (opArgs.length === 0 || opArgs.length === 1 && (opArgs[0] === "-d" || opArgs[0] === "-u" || opArgs[0] === "-c"))) {
-              const mode = opArgs[0];
-              const outLines = [];
-              let uIdx = 0;
-              while (uIdx < rawLines.length) {
-                let uEnd = uIdx + 1;
-                while (uEnd < rawLines.length && rawLines[uEnd] === rawLines[uIdx]) uEnd++;
-                const count2 = uEnd - uIdx;
-                if (mode === "-d" ? count2 > 1 : mode === "-u" ? count2 === 1 : true) {
-                  outLines.push(mode === "-c" ? `${String(count2).padStart(7, " ")} ${rawLines[uIdx]}` : rawLines[uIdx]);
-                }
-                uIdx = uEnd;
+                if (!byteLocale(rawState.variables) && view.some((byte) => byte > 127)) return void 0;
+                count2 = fileStr.split(/[ \t\n\r\f\v]+/).filter(Boolean).length;
               }
-              fileRes = outLines.join("\n");
+              fileRes = (hasSingleStdinRedir || hasSingleHereStringRedir ? String(count2) : `${count2} ${fileArg}`) + "\n";
+            } else if (w0Plain === "sort" && !byteLocale(rawState.variables)) {
+              const sortRes = this.evalSyncSort(rawLines, opArgs, false);
+              if (sortRes !== void 0) fileRes = renderLines(sortRes);
+            } else if (w0Plain === "uniq") {
+              const uniqRes = this.evalSyncUniq(rawLines, opArgs);
+              if (uniqRes !== void 0) fileRes = renderLines(uniqRes);
             } else if (w0Plain === "tr" && (hasSingleStdinRedir || hasSingleHereStringRedir)) {
               fileRes = this.evalSyncTr(fileStr, opArgs);
             } else if (hasSingleHereStringRedir && w0Plain === "base64" && (opArgs.length === 0 || opArgs.length === 1 && (opArgs[0] === "-d" || opArgs[0] === "--decode"))) {
-              if (opArgs.length === 0) fileRes = this.syncBase64Encode(view);
-              else fileRes = sharedSyncPipeDecoder.decode(this.syncBase64DecodeBytes(fileStr));
+              if (opArgs.length === 0) fileRes = this.syncBase64Encode(view) + "\n";
+              else {
+                const decoded = this.syncBase64DecodeBytes(fileStr);
+                if (decoded.some((byte) => byte === 0 || byte >= 128)) return void 0;
+                fileRes = sharedSyncPipeDecoder.decode(decoded);
+              }
             } else if (hasSingleHereStringRedir && w0Plain === "rev" && opArgs.length === 0) {
-              fileRes = rawLines.map((l) => Array.from(l).reverse().join("")).join("\n");
+              fileRes = renderLines(rawLines.map((l) => Array.from(l).reverse().join("")));
             } else if (hasSingleHereStringRedir && w0Plain === "tac" && opArgs.length === 0) {
-              fileRes = [...rawLines].reverse().join("\n");
-            } else if (hasSingleHereStringRedir && w0Plain === "nl" && opArgs.length === 0) {
-              let lineNo = 0;
-              fileRes = rawLines.map((l) => l.length === 0 ? "       " : `${String(++lineNo).padStart(6, " ")}	${l}`).join("\n");
+              fileRes = renderLines([...rawLines].reverse());
+            } else if (hasSingleHereStringRedir && w0Plain === "nl") {
+              const nlRes = this.evalSyncNl(rawLines, opArgs);
+              if (nlRes !== void 0) fileRes = renderLines(nlRes);
+            } else if (hasSingleHereStringRedir && w0Plain === "paste") {
+              const pasteRes = this.evalSyncPaste(rawLines, opArgs);
+              if (pasteRes !== void 0) fileRes = renderLines(pasteRes);
+            } else if (hasSingleHereStringRedir && w0Plain === "numfmt") {
+              const nmRes = this.evalSyncNumfmt(rawLines, opArgs);
+              if (nmRes !== void 0) fileRes = renderLines(nmRes);
             }
             if (fileRes !== void 0) {
+              const outBytes = shellValueByteLength(fileRes);
               let end = fileRes.length;
               while (end > 0 && fileRes.charCodeAt(end - 1) === 10) end--;
               if (end < fileRes.length) fileRes = fileRes.slice(0, end);
-              const outBytes = (fileRes.length * 3 > 127 ? shellValueByteLength(fileRes) : fileRes.length) + 1;
               const nextTotalBytes = this.budget.bytes + outBytes;
               if (nextTotalBytes > this.budget.maxOutputBytesSmi && outBytes > this.budget.limits.maxOutputBytes - this.budget.bytes) this.budget.fail("maxOutputBytes");
               this.budget.bytes = nextTotalBytes;
@@ -91208,38 +93386,15 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       for (let i = 0; i < cmd.words.length; i++) {
         if (!this.isPureArgWord(cmd.words[i], rawState)) return void 0;
       }
-      if (w0Plain === "dirname" && cmd.words.length === 2) {
-        const wVal = this.fastValueWord(cmd.words[1], state, io, true, false, false, true, void 0, part.line);
-        if (typeof wVal !== "string" || wVal.startsWith("-") || wVal.includes("\0")) return void 0;
-        const parent = dirname(wVal);
-        let pEnd = parent.length;
-        while (pEnd > 1 && parent[pEnd - 1] === "/") pEnd--;
-        let res = parent.slice(0, pEnd);
-        const byteLength2 = shellValueByteLength(res) + 1;
-        while (res.endsWith("\n")) res = res.slice(0, -1);
-        const nextBytes2 = this.budget.bytes + byteLength2;
-        if (nextBytes2 > this.budget.maxOutputBytesSmi && byteLength2 > this.budget.limits.maxOutputBytes - this.budget.bytes) this.budget.fail("maxOutputBytes");
-        this.budget.bytes = nextBytes2;
-        this.budget.tick();
-        if (fnPositional !== void 0) this.budget.tick();
-        rawState.substitutionStatus = 0;
-        rawState.status = 0;
-        return res;
-      }
-      if (w0Plain === "basename" && (cmd.words.length === 2 || cmd.words.length === 3 || cmd.words.length === 4 && cmd.words[1]?.plain === "-s")) {
-        const isFlagS = cmd.words.length === 4 && cmd.words[1]?.plain === "-s";
-        const pathWord = isFlagS ? cmd.words[3] : cmd.words[1];
-        const suffixWord = isFlagS ? cmd.words[2] : cmd.words.length === 3 ? cmd.words[2] : void 0;
-        const wVal1 = this.fastValueWord(pathWord, state, io, true, false, false, true, void 0, part.line);
-        if (typeof wVal1 !== "string" || wVal1.startsWith("-") || wVal1.includes("\0")) return void 0;
-        let wVal2;
-        if (suffixWord !== void 0) {
-          const v2 = this.fastValueWord(suffixWord, state, io, true, false, false, true, void 0, part.line);
-          if (typeof v2 !== "string" || v2.includes("\0")) return void 0;
-          wVal2 = v2;
-        }
-        let res = /^\/+$/u.test(wVal1) ? "/" : basename(wVal1);
-        if (wVal2 && res !== wVal2 && res.endsWith(wVal2)) res = res.slice(0, -wVal2.length);
+      if (w0Plain === "dirname" || w0Plain === "basename") {
+        const dbArgs = [];
+        for (let i = 1; i < cmd.words.length; i++) {
+          const v = this.fastValueWord(cmd.words[i], state, io, true, false, false, true, void 0, part.line);
+          if (typeof v !== "string") return void 0;
+          dbArgs.push(v);
+        }
+        let res = w0Plain === "dirname" ? this.evalSyncDirname(dbArgs) : this.evalSyncBasename(dbArgs);
+        if (res === void 0) return void 0;
         const byteLength2 = shellValueByteLength(res) + 1;
         while (res.endsWith("\n")) res = res.slice(0, -1);
         const nextBytes2 = this.budget.bytes + byteLength2;
@@ -94091,7 +96246,7 @@ import * as safe_bash_command_xz_star from "../safe-bash-command-xz/index.js";
 __reExport(core_browser_exports, core_exports);
 import { CommandArgumentIdentityError, createCommandArguments as createCommandArguments5, getCommandArguments as getCommandArguments16, commandRuntimeIdentity as commandRuntimeIdentity2, CommandRegistry as CommandRegistry3, validateExitCode as validateExitCode2 } from "../safe-bash-contracts/command.js";
 import { evaluateCommandSupport, assertCommandRequirements as assertCommandRequirements16 } from "../safe-bash-contracts/command-requirements.js";
-import { isErrnoCode, isFsError as isFsError11, toFsError, FsError as FsError60 } from "../safe-bash-contracts/errors.js";
+import { isErrnoCode, isFsError as isFsError11, toFsError, FsError as FsError61 } from "../safe-bash-contracts/errors.js";
 import { ACCESS_MODES as ACCESS_MODES3 } from "../safe-bash-contracts/filesystem.js";
 import { collectBytes as collectBytes14, readBytes as readBytes29, toByteSource as toByteSource7, outputFailure as outputFailure3, createBytePipe as createBytePipe2, writeText as writeText4, writeBytes as writeBytes30, pipeBytes as pipeBytes2, collectText } from "../safe-bash-contracts/io.js";
 import { createOutputOperation as createOutputOperation10 } from "../safe-bash-contracts/output.js";
@@ -94255,7 +96410,7 @@ export {
   export_EreSyntaxError as EreSyntaxError,
   export_EreUnsupportedError as EreUnsupportedError,
   export_EreUsageUnknownError as EreUsageUnknownError,
-  FsError60 as FsError,
+  FsError61 as FsError,
   MdqError,
   MemoryFileSystem,
   MountFileSystem,