@poe-platform/safe-bash 0.1.745 → 0.1.746

package/dist/safe-bash/shell/runtime.js

@@ -1,3 +1,6 @@
+import { splitSyncJqExpression } from "./sync-jq-expression.js";
+import { wcDisplayWidth } from "../commands/wc-width.js";
+import { text as awkValueText, compare as awkCompare, inputValue as awkInputValue, numeric as awkNumeric, string as awkString } from "../commands/text-programs/awk-values.js";
 import { bytesToHex, latin1Text } from "../byte-encoding.js";
 const sharedCaptureDecoder = new TextDecoder();
 const cachedCaptureAsciiBytes = new Uint8Array(4096);
@@ -10,6 +13,8 @@ import { writeDiagnostic } from "../escaping.js";
 import { cancelTurn, hasYieldCheckpoint, inheritYieldCheckpoint, monotonicNow, registerInternalYieldCheckpoint, runYieldCheckpoint, scheduleTurn, yieldTurn } from "../contracts/yield.js";
 import { ACCESS_MODES, FsError, basename, composeMiddleware, createBytePipe, dirname, normalizePath, pipeBytes, resolvePath, validateExitCode, writeBytes, writeText, } from "../contracts/index.js";
 import { createBcCommands } from "../commands/bc/index.js";
+import { createStreamInspectionCommands } from "../commands/stream-inspection/index.js";
+import { createStreamFormatCommands } from "../commands/stream-format/index.js";
 import { createSpongeCommands } from "../commands/sponge/index.js";
 import { createFdCommands } from "../commands/fd/index.js";
 import { createLessCommands } from "../commands/less/index.js";
@@ -57,7 +62,7 @@ import { invocationScope, throwCleanupFailures, InvocationScope } from "./cleanu
 import { bindFileOutputBudget, openFileOutput } from "../contracts/filesystem-output.js";
 import { outputFailure } from "../contracts/io.js";
 import { executionCommands } from "../commands/execution.js";
-import { defaultEchoExecutors, formatPrintf, printfCommand, tryFastPrintf } from "../commands/basic.js";
+import { defaultEchoExecutors, extractFastPrintfSpecifiers, formatPrintf, printfCommand, tryFastPrintf } from "../commands/basic.js";
 import { defaultMkdirExecutors, defaultRmExecutors } from "../commands/filesystem.js";
 export const customRegisteredCommands = new WeakSet();
 export const customRegisteredRegistries = new WeakSet();
@@ -2617,6 +2622,12 @@ const closedSource = { [Symbol.asyncIterator]() {
         return iterator;
     } };
 /** Internal to the shell/runtime pair; it is not exported by the package root. */
+const syncAwkArithAtom = `(?:\\$(?:[0-9]+|NF)|NR|NF|-?[0-9]+(?:\\.[0-9]+)?|[a-zA-Z_][a-zA-Z0-9_]*)`;
+const syncAwkArithPat = `(?:${syncAwkArithAtom}(?:\\s*[+*\\/%-]\\s*${syncAwkArithAtom})+)`;
+const 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]+)?))`;
+const 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_]*|"[^"$\\\\]*")`;
+const 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*$`);
+const 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");
 export class RuntimeCancellationState {
     _records;
     _diagnostics;
@@ -2916,7 +2927,7 @@ function hasGlobOrEscape(text, extglob = false) {
 let nextProcessSubstitutionId = 0;
 let defaultRuntimeMuscleMemoryMap;
 function getRuntimeMuscleMemoryCommand(name) {
-    defaultRuntimeMuscleMemoryMap ??= new Map([...createBcCommands(), ...createSpongeCommands(), ...createFdCommands(), ...createLessCommands(), ...createIdCommands(), ...createWhoamiCommands(), ...createUnameCommands(), ...createHostnameCommands(), ...createNprocCommands(), ...createShufCommands(), ...createDdCommands(), ...createNumfmtCommands(), ...createEnvsubstCommands(), ...createCalCommands(), ...createPathchkCommands(), ...createGetconfCommands(), ...createLocaleCommands(), ...createDfCommands(), ...createSqlite3Commands()].map(cmd => [cmd.name, cmd]));
+    defaultRuntimeMuscleMemoryMap ??= new Map([...createStreamFormatCommands(), ...createStreamInspectionCommands(), ...createBcCommands(), ...createSpongeCommands(), ...createFdCommands(), ...createLessCommands(), ...createIdCommands(), ...createWhoamiCommands(), ...createUnameCommands(), ...createHostnameCommands(), ...createNprocCommands(), ...createShufCommands(), ...createDdCommands(), ...createNumfmtCommands(), ...createEnvsubstCommands(), ...createCalCommands(), ...createPathchkCommands(), ...createGetconfCommands(), ...createLocaleCommands(), ...createDfCommands(), ...createSqlite3Commands()].map(cmd => [cmd.name, cmd]));
     return defaultRuntimeMuscleMemoryMap.get(name);
 }
 const fastSubScratchArgs = [];
@@ -5902,6 +5913,8 @@ export class Runtime {
                     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 === undefined && 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, undefined);
                         if (braceItems && braceItems.length <= 1500) {
@@ -13572,6 +13585,10 @@ export class Runtime {
                 if (this._syncLoopFnCheckDepth > 0 && (part.substring || getArraySelector(part)?.kind === "element"))
                     return false;
                 if (part.prefixNames !== undefined) {
+                    // Prefix @ may produce zero or multiple fields as loop state changes.
+                    // Scalar loop steps cannot preserve that argument cardinality.
+                    if (part.prefixNames === "@")
+                        return false;
                     if (part.indirect ||
                         part.specialParameter ||
                         part.length ||
@@ -13812,6 +13829,10 @@ export class Runtime {
                         }
                     }
                 }
+                // These evaluators can decline based on runtime input. Loop execution
+                // has no continuation for a declined substitution after earlier effects.
+                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;
@@ -13841,13 +13862,13 @@ export class Runtime {
                     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) : undefined)) : undefined;
+                    (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) : undefined)) : undefined;
                 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))
+                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;
@@ -13868,7 +13889,7 @@ export 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;
                     }
@@ -13877,8 +13898,8 @@ export class Runtime {
                             return false;
                         if (w0Plain === "head" || w0Plain === "tail") {
                             const validHT = opCount === 0 ||
-                                (opCount === 1 && op0 !== undefined && /^-(?:n|c)?[0-9]{1,5}$/.test(op0)) ||
-                                (opCount === 2 && (op0 === "-n" || op0 === "-c") && op1 !== undefined && /^[0-9]{1,5}$/.test(op1));
+                                (opCount === 1 && op0 !== undefined && (/^-(?: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 !== undefined && (/^[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 !== undefined && /^[0-9]{1,5}$/.test(op1))));
                             if (!validHT)
                                 return false;
                         }
@@ -13891,7 +13912,8 @@ export class Runtime {
                             plainOps.push(pw);
                         }
                         if (w0Plain === "cut") {
-                            if (plainOps.length !== opCount || this.evalSyncCut([], plainOps, byteLocale(rawState.variables)) === undefined)
+                            // Probe non-ASCII input: loop data can change after admission.
+                            if (plainOps.length !== opCount || this.evalSyncCut(["é"], plainOps, byteLocale(rawState.variables)) === undefined)
                                 return false;
                         }
                         else if (w0Plain === "sed") {
@@ -13907,19 +13929,22 @@ export class Runtime {
                                 return false;
                         }
                         else if (w0Plain === "jq") {
-                            if (plainOps.length !== opCount || this.evalSyncJq("null", plainOps) === undefined)
+                            if (plainOps.length !== opCount)
+                                return false;
+                            const jqIn = this.extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
+                            if (jqIn === undefined || this.evalSyncJq(jqIn, plainOps) === undefined)
                                 return false;
                         }
                         else if (w0Plain === "wc") {
-                            if (opCount !== 1 || (op0 !== "-l" && op0 !== "-c" && op0 !== "-w"))
+                            if (opCount !== 1 || this.normalizeSyncWcFlag(op0) === undefined)
                                 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"))
+                            if (plainOps.length !== opCount || this.evalSyncSort([], plainOps, byteLocale(rawState.variables)) === undefined)
                                 return false;
                         }
                         else if (w0Plain === "uniq") {
-                            if (opCount > 1 || (opCount === 1 && op0 !== "-d" && op0 !== "-u" && op0 !== "-c"))
+                            if (plainOps.length !== opCount || this.evalSyncUniq([], plainOps) === undefined)
                                 return false;
                         }
                         else if (w0Plain === "base64") {
@@ -13930,24 +13955,57 @@ export class Runtime {
                             if (plainOps.length !== opCount || this.evalSyncTr("", plainOps) === undefined)
                                 return false;
                         }
+                        else if (w0Plain === "nl") {
+                            if (plainOps.length !== opCount || this.evalSyncNl([], plainOps) === undefined)
+                                return false;
+                        }
+                        else if (w0Plain === "paste") {
+                            if (plainOps.length !== opCount || this.evalSyncPaste([], plainOps) === undefined)
+                                return false;
+                        }
+                        else if (w0Plain === "numfmt") {
+                            const nmCheck = this.extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
+                            if (nmCheck === undefined || plainOps.length !== opCount || this.evalSyncNumfmt(nmCheck.split("\n"), plainOps) === undefined)
+                                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 : undefined);
-                    if (fmtP === undefined || fmtP.startsWith("-") || !/^(?:[^%]|%%|%[-0]*\d*(?:\.\d+)?[sdxXouc]|\\n)*$/.test(fmtP))
+                    if (!this.isSyncPrintfCallOk(cmd, 1, rawState, this._activePrintfInductionName))
                         return false;
                 }
                 else if (w0Plain === "echo") {
-                    if (cmd.words.length > 1 && (cmd.words[1].plain === undefined ? 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;
+                    const firstArg = cmd.words[1];
+                    if (firstArg) {
+                        const prefix = firstArg.parts.find(part => part.kind !== "text" || part.value.length > 0);
+                        // Substitution execution rejects options, including those that appear
+                        // only on later iterations. Require a stable non-option prefix.
+                        if (prefix?.kind !== "text" || prefix.value.startsWith("-"))
+                            return false;
+                    }
                 }
-                else if (w0Plain === "basename") {
-                    if (cmd.words.length !== 2 && cmd.words.length !== 3 && !(cmd.words.length === 4 && cmd.words[1]?.plain === "-s"))
+                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];
+                        // Tilde prefixes depend on mutable HOME/PWD/OLDPWD; use normal expansion.
+                        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("") : undefined);
+                        if (st !== undefined) {
+                            if (st === "--")
+                                seenDoubleDash = true;
+                            simArgs.push(st);
+                        }
+                        else {
+                            // A loop operand can become an option after admission.
+                            if (!seenDoubleDash)
+                                return false;
+                            simArgs.push("x");
+                        }
+                    }
+                    if ((w0Plain === "dirname" ? this.evalSyncDirname(simArgs) : this.evalSyncBasename(simArgs)) === undefined)
                         return false;
                 }
                 else if (w0Plain === "seq") {
@@ -13971,18 +14029,20 @@ export 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;
                         // Range-aware tr and Buffer-free 76-col base64 are handled in pipeline stages.
-                        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"))
+                        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);
-                        if (!sDef || customRegisteredCommands.has(sDef.execute) || (sName !== "rev" && sName !== "tac" && !builtInDirectContextExecutors.has(sDef.execute)))
+                        const sDef = this.commands.get(sName) ?? ((sName === "rev" || sName === "tac" || sName === "nl" || sName === "paste" || sName === "jq") ? this.getExternalCommand(sName) : undefined);
+                        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;
@@ -13991,7 +14051,7 @@ export class Runtime {
                         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 : undefined);
+                            const sp = sw.plain ?? (sw.parts.length > 0 && sw.parts.every(pt => pt.kind === "text") ? sw.parts.map(pt => pt.value).join("") : undefined);
                             if (sp === undefined) {
                                 allPlainStageArgs = false;
                                 break;
@@ -14000,55 +14060,78 @@ export class Runtime {
                         }
                         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)) === undefined)
+                                return false;
+                        }
+                        else if (sName === "uniq") {
+                            if (this.evalSyncUniq([], sPlainArgs) === undefined)
+                                return false;
+                        }
+                        else if (sName === "wc") {
+                            if (sPlainArgs.length !== 1 || this.normalizeSyncWcFlag(sPlainArgs[0]) === undefined)
+                                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;
                         }
-                        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)
+                        else if (sName === "cut") {
+                            // Byte cuts may reject non-ASCII data on a later iteration.
+                            if (this.evalSyncCut(["é"], sPlainArgs, byteLocale(rawState.variables)) === undefined)
                                 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))
+                        else if (sName === "sed") {
+                            if (this.evalSyncSed([], sPlainArgs) === undefined)
                                 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)
+                        else if (sName === "awk") {
+                            if (this.evalSyncAwk([], sPlainArgs) === undefined)
                                 return false;
                         }
-                        if (sName === "jq") {
-                            // JSON types are runtime inputs: the speculative evaluator may
-                            // refuse array indexing and must leave diagnostics to jq.
-                            return false;
+                        else if (sName === "grep") {
+                            if (this.evalSyncGrep([], sPlainArgs, Boolean(rawState.errexit)) === undefined)
+                                return false;
                         }
-                        if (sName === "base64") {
-                            if (sPlainArgs.length > 1 || (sPlainArgs.length === 1 && sPlainArgs[0] !== "-d" && sPlainArgs[0] !== "--decode"))
+                        else if (sName === "tr") {
+                            if (this.evalSyncTr("", sPlainArgs) === undefined)
+                                return false;
+                        }
+                        else if (sName === "jq") {
+                            if (sIdx !== 1)
+                                return false;
+                            const jqIn = this.extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
+                            if (jqIn === undefined || this.evalSyncJq(jqIn, sPlainArgs) === undefined)
+                                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) === undefined)
+                                return false;
+                        }
+                        else if (sName === "paste") {
+                            if (this.evalSyncPaste([], sPlainArgs) === undefined)
+                                return false;
+                        }
+                        else if (sName === "numfmt") {
+                            if (sIdx !== 1)
+                                return false;
+                            const nmCheck = this.extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
+                            if (nmCheck === undefined || this.evalSyncNumfmt(nmCheck.split("\n"), sPlainArgs) === undefined)
+                                return false;
+                        }
+                        else if (sName === "rev") {
+                            if (sPlainArgs.length !== 0)
                                 return false;
                         }
-                        if ((sName === "tac" || sName === "nl") && sPlainArgs.length !== 0)
-                            return false;
                     }
                 }
                 continue;
@@ -14482,7 +14565,7 @@ export class Runtime {
                 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 undefined;
@@ -14494,7 +14577,7 @@ export class Runtime {
                         return undefined;
                     if (p.startsWith("-r"))
                         rawMode = true;
-                    exactChars = p.includes("N");
+                    exactChars ||= p.includes("N");
                     maxChars = Number(p.slice(p.startsWith("-r") ? 3 : 2));
                     argIdx++;
                 }
@@ -14707,12 +14790,12 @@ export 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))
+                    if (ifOk && cmd.otherwise && !this.canSyncLoopBody(cmd.otherwise, rawState, io, true, printfInductionName))
                         ifOk = false;
                     if (ifOk)
                         continue;
@@ -14733,7 +14816,7 @@ export 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;
                         }
@@ -15455,17 +15538,45 @@ export class Runtime {
         const condition = command.kind === "arithmetic-for" ? command.expressions[1]?.tree : undefined;
         const increment = command.kind === "arithmetic-for" ? command.expressions[2]?.tree : undefined;
         const whileCondCmd = command.kind === "while" && command.condition.lists.length === 1 && command.condition.lists[0].pipelines.length === 1 ? command.condition.lists[0].pipelines[0].commands[0] : undefined;
-        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 : undefined));
+        const whileTree = whileCondCmd?.kind === "arithmetic" && !whileCondCmd.expression.error ? whileCondCmd.expression.tree : undefined;
+        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 : undefined;
+        const whileValue = whileName === undefined ? undefined : rawState.variables[whileName];
+        const whileStart = typeof whileValue === "string" ? Number(whileValue) : NaN;
+        const whilePrintfInd = Number.isInteger(whileStart) && whileStart >= 0 && whileStart <= 2000 &&
+            String(whileStart) === whileValue ? whileName : undefined;
+        const forPrintfInd = command.kind === "for" && command.words?.length === 1 && /^\{[0-9]{1,4}\.\.[0-9]{1,4}(?:\.\.[1-9][0-9]{0,2})?\}$/.test(command.words[0].plain ?? "") ? command.name : undefined;
         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(command.body, rawState)
+            this.canSyncPrintfInductionBody(command.body, rawState, initializer.left.name)
             ? initializer.left.name
-            : (whilePrintfInd && this.canSyncPrintfInductionBody(command.body, rawState) ? whilePrintfInd : undefined);
-        if ((guestArrays(rawState) && (guestArrays(rawState).watches.size > 0 || this.budget.limits.maxExpansionBytes < 65536)) || !this.canSyncLoopBody(command.body, rawState, io, false, printfInductionName)) {
+            : (whilePrintfInd && this.canSyncPrintfInductionBody(command.body, rawState, whilePrintfInd)
+                ? whilePrintfInd
+                : (forPrintfInd && this.canSyncPrintfInductionBody(command.body, rawState, forPrintfInd) ? forPrintfInd : undefined));
+        const prevActivePrintfInd = this._activePrintfInductionName;
+        const prevActiveLoopScript = this._activeLoopBodyScript;
+        const prevActiveLoopCond = this._activeLoopCondScript;
+        const prevActiveLoopVar = this._activeLoopVarName;
+        this._activePrintfInductionName = printfInductionName;
+        this._activeLoopBodyScript = command.body;
+        this._activeLoopCondScript = command.kind === "while" ? command.condition : undefined;
+        this._activeLoopVarName = command.kind === "for" ? command.name : (printfInductionName ?? (whilePrintfInd || undefined));
+        let bodySyncOk = false;
+        try {
+            bodySyncOk = !(guestArrays(rawState) && (guestArrays(rawState).watches.size > 0 || this.budget.limits.maxExpansionBytes < 65536)) && this.canSyncLoopBody(command.body, rawState, io, false, printfInductionName);
+        }
+        finally {
+            this._activePrintfInductionName = prevActivePrintfInd;
+            this._activeLoopBodyScript = prevActiveLoopScript;
+            this._activeLoopCondScript = prevActiveLoopCond;
+            this._activeLoopVarName = prevActiveLoopVar;
+        }
+        if (!bodySyncOk) {
             command._skipTrySyncLoop = true;
             return undefined;
         }
@@ -15648,7 +15759,8 @@ export class Runtime {
                     }
                     const wordsToScan = step.arrayAssign?.kind === "compound"
                         ? step.arrayAssign.entries.map(e => e.value)
-                        : step.value ? [step.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++) {
@@ -16896,29 +17008,230 @@ export class Runtime {
         }
         return pos <= 128 ? fastRedirectScratchViews[pos] : fastRedirectScratchBytes.subarray(0, pos);
     }
-    canSyncPrintfInductionBody(script, rawState) {
-        // Arithmetic, parameter operators and functions can mutate the counter
-        // indirectly. Keep this proof to simple commands and isolated substitutions;
-        // the loop plan separately rejects direct assignments to its counter.
+    _activePrintfInductionName = undefined;
+    _activeLoopBodyScript = undefined;
+    _activeLoopCondScript = undefined;
+    _activeLoopVarName = undefined;
+    isVarUnmutatedInScript(varName, script) {
+        for (const list of script.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 p0 = w.parts[0];
+                        if (p0?.kind === "text" && !p0.quoted && (p0.value.startsWith(varName + "=") || p0.value.startsWith(varName + "+=") || p0.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(script, rawState) {
+        const visit = (value) => {
+            if (value === null || typeof value !== "object")
+                return true;
+            if (Array.isArray(value))
+                return value.every(visit);
+            const node = value;
+            if (typeof node.operator === "string" && "target" in node && !["<", "<<<", "<<", "<<-"].includes(node.operator))
+                return false;
+            if (node.kind === "simple") {
+                const cmd = value;
+                // Unknown commands (including shell functions) cannot promise read-only I/O.
+                const name = cmd.words[0]?.plain;
+                if (name === undefined && !cmd.words.every(word => this.assignment(word) || getArrayAssignment(word)))
+                    return false;
+                if (name !== undefined && (hasShellFunction(rawState, name) || !["jq", "cat", "echo", "printf", "test", "[", ":", "true", "false"].includes(name)))
+                    return false;
+            }
+            return Object.values(node).every(visit);
+        };
+        return visit(script);
+    }
+    extractLoopInvariantJqInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState) {
+        const w0 = cmd.words[0]?.plain;
+        const resolveInvariantWord = (w) => {
+            if (w.plain !== undefined)
+                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) === undefined && this.isVarUnmutatedInActiveLoop(vp.name)) {
+                    const val = rawState.variables[vp.name];
+                    if (typeof val === "string")
+                        return val;
+                }
+            }
+            return undefined;
+        };
+        if (w0 === "jq" || w0 === "numfmt") {
+            if (hasSingleHereStringRedir) {
+                const resolved = resolveInvariantWord(cmd.redirects[0].target);
+                return resolved !== undefined ? resolved.trim() : undefined;
+            }
+            if (this._fileWrites?.size || this._outputFiles?.size)
+                return undefined;
+            if ([this._activeLoopBodyScript, this._activeLoopCondScript].some(script => script && !this.isFileReadOnlyScript(script, rawState)))
+                return undefined;
+            const fPlain = hasSingleStdinRedir ? cmd.redirects[0].target.plain : cmd.words[cmd.words.length - 1]?.plain;
+            if (!fPlain || fPlain.startsWith("-") || fPlain === "/dev/stdin")
+                return undefined;
+            const vCheck = this.tryReadMemoryFileViewSync(resolvePath(rawState.cwd, fPlain), false);
+            if (!vCheck || vCheck.byteLength > 16384 || vCheck.includes(0))
+                return undefined;
+            return sharedSyncPipeDecoder.decode(vCheck).trim();
+        }
+        if (w0 === "cat") {
+            if (hasSingleHereStringRedir) {
+                const resolved = resolveInvariantWord(cmd.redirects[0].target);
+                return resolved !== undefined ? resolved.trim() : undefined;
+            }
+            if (this._fileWrites?.size || this._outputFiles?.size)
+                return undefined;
+            if ([this._activeLoopBodyScript, this._activeLoopCondScript].some(script => script && !this.isFileReadOnlyScript(script, rawState)))
+                return undefined;
+            const fPlain = hasSingleStdinRedir ? cmd.redirects[0].target.plain : cmd.words[1]?.plain;
+            if (!fPlain || fPlain.startsWith("-") || fPlain === "/dev/stdin")
+                return undefined;
+            const vCheck = this.tryReadMemoryFileViewSync(resolvePath(rawState.cwd, fPlain), false);
+            if (!vCheck || vCheck.byteLength > 16384 || vCheck.includes(0))
+                return undefined;
+            return sharedSyncPipeDecoder.decode(vCheck).trim();
+        }
+        if (w0 === "echo" && cmd.words.length === 2) {
+            const resolved = resolveInvariantWord(cmd.words[1]);
+            if (resolved !== undefined && !resolved.startsWith("-"))
+                return resolved.trim();
+            return undefined;
+        }
+        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 === undefined)
+                    return undefined;
+                args.push(r);
+            }
+            const formatted = tryFastPrintf(args);
+            return formatted !== undefined ? formatted.trim() : undefined;
+        }
+        return undefined;
+    }
+    canSyncPrintfInductionBody(script, rawState, inductionName) {
         for (const list of script.lists)
             for (const pipeline of list.pipelines)
                 for (const command of pipeline.commands) {
                     if (command.kind === "arithmetic") {
-                        if (command.redirects.length === 0 && !command.expression.error && !command.expression.hasSubscript && isSafeSmiProgram(command.expression) && command.expression.tree?.kind === "unary" && (command.expression.tree.operator === "++" || command.expression.tree.operator === "--") && command.expression.tree.operand.kind === "name")
+                        if (command.redirects.length === 0 && !command.expression.error && !command.expression.hasSubscript && isSafeSmiProgram(command.expression) && command.expression.tree?.kind === "unary" && (command.expression.tree.operator === "++" || (command.expression.tree.operator === "--" && command.expression.tree.operand.kind === "name" && command.expression.tree.operand.name !== inductionName)) && command.expression.tree.operand.kind === "name")
                             continue;
                         return false;
                     }
                     if (command.kind !== "simple" || hasShellFunction(rawState, command.words[0]?.plain ?? "") || command.words.some(word => getArrayAssignment(word) !== undefined))
                         return false;
+                    const w0 = command.words[0]?.plain;
+                    if (w0 === "let" || w0 === "declare" || w0 === "typeset" || w0 === "local" || w0 === "export" || w0 === "unset" || w0 === "mapfile" || w0 === "readarray")
+                        return false;
+                    if (inductionName !== undefined) {
+                        if (command.words.some(w => {
+                            const p0 = w.parts[0];
+                            return p0?.kind === "text" && !p0.quoted && (p0.value.startsWith(inductionName + "=") || p0.value.startsWith(inductionName + "+="));
+                        }))
+                            return false;
+                        if (w0 === "read" && (inductionName === "REPLY" || command.words.slice(1).some(w => w.plain === inductionName || w.plain === "-a" || w.plain === "-ra" || w.plain === "-ar")))
+                            return false;
+                        if (w0 === "printf" && command.words[1]?.plain === "-v" && command.words[2]?.plain === inductionName)
+                            return false;
+                    }
                     for (const word of [...command.words, ...command.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 === undefined && getArraySelector(part) === undefined)
+                            if (part.kind === "variable" &&
+                                !part.indirect &&
+                                !part.substring &&
+                                !part.prefixNames &&
+                                getArraySelector(part) === undefined &&
+                                (part.operator === undefined ||
+                                    ((part.operator === "#" || part.operator === "##" || part.operator === "%" || part.operator === "%%") &&
+                                        part.alternate !== undefined &&
+                                        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))
+                            if (part.kind === "substitution" && this.canSyncPrintfInductionBody(part.script, rawState, inductionName))
                                 continue;
                             return false;
                         }
@@ -16929,41 +17242,86 @@ export class Runtime {
         const printfDef = this.commands.get("printf");
         if (hasShellFunction(rawState, "printf") || rawState.extensions?.builtins.has("printf") || printfDef?.execute !== printfCommand.execute)
             return false;
-        // Runtime operands can leave the fast formatter's subset after earlier
-        // effects. Admit only literals and the arithmetic plan's bounded induction.
-        const args = [];
+        const effInductionName = inductionName ?? this._activePrintfInductionName;
+        // Prove unsigned arithmetic stays non-negative and within the Smi evaluator's
+        // range. Names are matched as AST nodes, never as substrings of other names.
+        const unsignedUpperBound = (tree) => {
+            if (!tree)
+                return undefined;
+            let bound;
+            if (tree.kind === "literal")
+                bound = tree.value;
+            else if (tree.kind === "name" && tree.name === effInductionName && tree.subscript === undefined)
+                bound = 2147483647n;
+            else if (tree.kind === "binary" && (tree.operator === "+" || tree.operator === "*")) {
+                const left = unsignedUpperBound(tree.left);
+                const right = unsignedUpperBound(tree.right);
+                if (left !== undefined && right !== undefined)
+                    bound = tree.operator === "+" ? left + right : left * right;
+            }
+            return bound !== undefined && bound >= 0n && bound <= 2147483647n ? bound : undefined;
+        };
         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("\t") || 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(part => part.kind !== "text" || part.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 === undefined && getArraySelector(part) === undefined) {
-                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(part => part.quoted ||
+                (part.kind === "text" && part.value.length > 0 && !part.value.includes(" ") && !part.value.includes("\t") && !part.value.includes("\n") && !part.value.includes("{") && !hasGlobOrEscape(part.value, true)));
+            if (spec === "s" && nonSplitting) {
+                args.push("");
                 continue;
             }
-            if (i > fmtWordIdx &&
-                inductionName !== undefined &&
-                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(part => part.kind !== "text" || part.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 === undefined && getArraySelector(part) === undefined) {
+                    args.push("0");
+                    continue;
+                }
+                if (part.kind === "variable" && part.length && !part.indirect && !part.prefixNames && getArraySelector(part) === undefined) {
+                    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) !== undefined)) {
+                    args.push("0");
+                    continue;
+                }
             }
             let arg = "";
-            for (const part of w.parts) {
-                if (part.kind !== "text" || (!part.quoted && (part.value.length === 0 || part.value.includes(" ") || part.value.includes("\t") || part.value.includes("\n") || part.value.includes("{") || hasGlobOrEscape(part.value, true))))
+            for (const p of w.parts) {
+                if (p.kind !== "text" || (!p.quoted && (p.value.length === 0 || p.value.includes(" ") || p.value.includes("\t") || p.value.includes("\n") || p.value.includes("{") || hasGlobOrEscape(p.value, true))))
                     return false;
-                arg += part.value;
+                arg += p.value;
             }
             args.push(arg);
         }
@@ -16975,6 +17333,15 @@ export class Runtime {
             return false;
         return w.parts.every(p => p.kind === "text" || (p.kind === "variable" && !p.indirect && !p.prefixNames && !p.length && !p.substring && p.operator === undefined && getArraySelector(p) === undefined));
     }
+    syncStringLength(value, byteCount) {
+        let length = 0;
+        for (let offset = 0; offset < value.length;) {
+            const point = value.codePointAt(offset);
+            length += byteCount ? (point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4) : 1;
+            offset += point > 0xffff ? 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";
@@ -16982,16 +17349,16 @@ export class Runtime {
         let status = 0;
         if (rs.maxChars !== undefined) {
             const fullInput = rawInput + "\n";
-            if (rs.exactChars) {
-                lineStr = fullInput.length > rs.maxChars ? fullInput.slice(0, rs.maxChars) : fullInput;
-                status = 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;
-                status = (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 count = 0;
+            while (position < end && count < rs.maxChars) {
+                position = nextCodePointOffset(fullInput, position);
+                count++;
             }
+            lineStr = fullInput.slice(0, position);
+            status = (count >= rs.maxChars || nlIdx !== -1) ? 0 : 1;
         }
         else {
             const fullInput = delim === "\n" ? rawInput : rawInput + "\n";
@@ -24600,8 +24967,8 @@ export class Runtime {
                         invalid = true;
                         break;
                     }
-                    if (flag === "n" || flag === "N")
-                        exact = flag === "N";
+                    if (flag === "N")
+                        exact = true;
                     const value = option.slice(index + 1) || names.shift();
                     if (value === undefined)
                         invalid = true;
@@ -25071,7 +25438,7 @@ export class Runtime {
         }
         if (part.kind === "variable" && part.prefixNames) {
             const ifs = state.variables.IFS ?? " ";
-            const separator = io.nameExpansionContext === "document" || io.nameExpansionContext === "conditional" && part.prefixNames === "@"
+            const separator = io.nameExpansionContext === "document" || part.prefixNames === "@" && (io.nameExpansionContext === "conditional" || ifs.length === 0)
                 ? " " : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
             const fragments = [];
             let bytes = 0;
@@ -26091,7 +26458,7 @@ export class Runtime {
                     if (pNames === undefined)
                         return undefined;
                     const ifs = rawState.variables.IFS ?? " ";
-                    const sep = io.nameExpansionContext === "document" || (io.nameExpansionContext === "conditional" && part.prefixNames === "@")
+                    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);
@@ -26406,11 +26773,7 @@ export class Runtime {
                             if (part.operator !== undefined)
                                 return undefined;
                             const s = elemVal ?? "";
-                            for (let k = 0; k < s.length; k++) {
-                                if (s.charCodeAt(k) >= 128)
-                                    return undefined;
-                            }
-                            out += String(s.length);
+                            out += String(this.syncStringLength(s, byteLocale(rawVars)));
                             continue;
                         }
                         let resolvedElem;
@@ -26560,11 +26923,7 @@ export class Runtime {
                     const val = raw === undefined ? "" : (this._syncArithRawWriteOnly && this._syncArithTouched?.has(part.name) ? raw : (monitor?.values.get(part.name, raw) ?? raw));
                     if (typeof val !== "string")
                         return undefined;
-                    for (let k = 0; k < val.length; k++) {
-                        if (val.charCodeAt(k) >= 128)
-                            return undefined;
-                    }
-                    out += String(val.length);
+                    out += String(this.syncStringLength(val, byteLocale(rawVars)));
                     continue;
                 }
                 if (part.operator !== undefined) {
@@ -26881,6 +27240,9 @@ export class Runtime {
     expandSyncTrCharArray(spec) {
         if (spec.length === 0)
             return undefined;
+        // Escaped endpoints need the tr parser before range expansion.
+        if (spec.includes("\\") && spec.includes("-"))
+            return undefined;
         const posixClasses = {
             "[:lower:]": "abcdefghijklmnopqrstuvwxyz",
             "[:upper:]": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
@@ -26921,6 +27283,16 @@ export class Runtime {
                     out.push("\r");
                 else if (next === "\\")
                     out.push("\\");
+                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 undefined;
+                    out.push(String.fromCharCode(code));
+                }
                 else
                     return undefined;
                 continue;
@@ -26941,11 +27313,125 @@ export class Runtime {
         return out;
     }
     evalSyncTr(input, opArgs) {
-        if (opArgs.length === 2 && !opArgs[0].startsWith("-") && !opArgs[1].startsWith("-")) {
-            return this.translateSyncTr(input, 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 undefined;
+            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 undefined;
+        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 undefined;
+            if (flagD && !flagS && sets.length === 1) {
+                const arr = this.expandSyncTrCharArray(sets[0]);
+                if (!arr)
+                    return undefined;
+                const keepSet = new Set(arr);
+                let out = "";
+                for (let i = 0; i < input.length; i++) {
+                    const ch = input[i];
+                    if (keepSet.has(ch))
+                        out += ch;
+                }
+                return out;
+            }
+            if (!flagD && sets.length === 2) {
+                // Delegate multi-character complements and class validation to tr.
+                if (sets[1].includes("[:"))
+                    return undefined;
+                const arr1 = this.expandSyncTrCharArray(sets[0]);
+                const arr2 = this.expandSyncTrCharArray(sets[1]);
+                if (!arr1 || !arr2 || arr2.length !== 1)
+                    return undefined;
+                const keepSet = new Set(arr1);
+                const repl = arr2[arr2.length - 1];
+                const sqSet = flagS ? new Set(arr2) : undefined;
+                let hasNonAscii = false;
+                for (let i = 0; i < input.length; i++) {
+                    if (input.charCodeAt(i) >= 128) {
+                        hasNonAscii = true;
+                        break;
+                    }
+                }
+                let out = "";
+                let prev = "";
+                if (hasNonAscii) {
+                    const bytes = fastSharedTextEncoder.encode(input);
+                    for (let i = 0; i < bytes.length; i++) {
+                        const rawCh = String.fromCharCode(bytes[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 < input.length; i++) {
+                        const rawCh = input[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 undefined;
+                const keepSet = new Set(arr1);
+                const sqSet = new Set(arr2);
+                let out = "";
+                let prev = "";
+                for (let i = 0; i < input.length; i++) {
+                    const ch = input[i];
+                    if (!keepSet.has(ch))
+                        continue;
+                    if (sqSet.has(ch) && ch === prev)
+                        continue;
+                    out += ch;
+                    prev = ch;
+                }
+                return out;
+            }
+            return undefined;
         }
-        if (opArgs.length === 2 && opArgs[0] === "-d" && !opArgs[1].startsWith("-")) {
-            const arr = this.expandSyncTrCharArray(opArgs[1]);
+        if (!flagD && !flagS && sets.length === 2) {
+            return this.translateSyncTr(input, sets[0], sets[1], flagT);
+        }
+        if (flagD && !flagS && sets.length === 1) {
+            const arr = this.expandSyncTrCharArray(sets[0]);
             if (!arr)
                 return undefined;
             const delSet = new Set(arr);
@@ -26957,8 +27443,8 @@ export class Runtime {
             }
             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 undefined;
             const sqSet = new Set(arr);
@@ -26973,140 +27459,654 @@ export class Runtime {
             }
             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(input, opArgs[1], opArgs[2])
-                : this.evalSyncTr(input, ["-d", opArgs[1]]);
+        if (sets.length === 2 && (flagS || flagD)) {
+            const stage1 = !flagD
+                ? this.translateSyncTr(input, sets[0], sets[1], flagT)
+                : this.evalSyncTr(input, ["-d", sets[0]]);
             if (stage1 === undefined)
                 return undefined;
-            return this.evalSyncTr(stage1, ["-s", opArgs[2]]);
+            return this.evalSyncTr(stage1, ["-s", sets[1]]);
         }
         return undefined;
     }
-    evalSyncJq(input, opArgs) {
-        let rawOut = 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");
-            filter = opArgs[1];
-        }
-        if (!filter)
+    evalSyncJqPathOps(item, expr) {
+        let st = expr.trim();
+        let alternatives = splitSyncJqExpression(st, "//");
+        if (!alternatives)
             return undefined;
-        const stages = filter.split("|").map(s => s.trim());
-        const compiledStages = [];
-        for (const st of stages) {
-            if (st === ".") {
-                compiledStages.push([]);
-                continue;
-            }
-            if (st === "length") {
-                compiledStages.push([{ kind: "length" }]);
-                continue;
-            }
-            if (st === "keys") {
-                compiledStages.push([{ kind: "keys" }]);
-                continue;
-            }
-            if (st === "keys[]") {
-                compiledStages.push([{ kind: "keys" }, { kind: "iter" }]);
-                continue;
-            }
-            if (!st.startsWith("."))
+        while (alternatives.wrapped) {
+            st = st.slice(1, -1).trim();
+            alternatives = splitSyncJqExpression(st, "//");
+            if (!alternatives)
                 return undefined;
-            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 (alternatives.parts.length > 1) {
+            const lhs = alternatives.parts[0];
+            const rhs = alternatives.parts.slice(1).join("//");
+            const lVals = this.evalSyncJqPathOps(item, lhs);
+            if (lVals === undefined)
+                return undefined;
+            // Validate both sides before admitting the fast path, even if lhs wins.
+            let rVals = this.evalSyncJqPathOps(item, rhs);
+            if (rVals === undefined) {
+                try {
+                    rVals = [JSON.parse(rhs)];
                 }
-                if (rest.startsWith("[]")) {
-                    ops.push({ kind: "iter" });
-                    rest = rest.slice(2);
-                    continue;
+                catch {
+                    return undefined;
                 }
-                const idxM = /^\[(-?[0-9]+)\]/.exec(rest);
-                if (idxM) {
-                    ops.push({ kind: "index", idx: Number(idxM[1]) });
-                    rest = rest.slice(idxM[0].length);
-                    continue;
+            }
+            const truthy = lVals.filter(v => v !== null && v !== undefined && v !== false);
+            return truthy.length > 0 ? truthy : rVals;
+        }
+        const pipeSplit = splitSyncJqExpression(st, "|");
+        if (pipeSplit && pipeSplit.parts.length > 1) {
+            let cur = [item];
+            for (const pStage of pipeSplit.parts) {
+                const next = [];
+                for (const it of cur) {
+                    const r = this.evalSyncJqPathOps(it, pStage);
+                    if (r === undefined)
+                        return undefined;
+                    for (const rv of r)
+                        next.push(rv);
                 }
-                return undefined;
+                cur = next;
             }
-            compiledStages.push(ops);
+            return cur;
         }
-        let parsed;
-        try {
-            parsed = JSON.parse(input);
+        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 undefined;
+            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)] : undefined;
+        if (st === "ceil")
+            return typeof item === "number" ? [Math.ceil(item)] : undefined;
+        if (st === "round")
+            return typeof item === "number" ? [Math.round(item)] : undefined;
+        if (st === "abs")
+            return typeof item === "number" ? [Math.abs(item)] : undefined;
+        if (st === "utf8bytelength")
+            return typeof item === "string" ? [Buffer.byteLength(item, "utf8")] : undefined;
+        if (st === "explode")
+            return typeof item === "string" ? [Array.from(item, c => c.codePointAt(0))] : undefined;
+        if (st === "implode") {
+            if (!Array.isArray(item) || !item.every(x => typeof x === "number" && Number.isInteger(x) && x >= 0 && x <= 0x10ffff))
+                return undefined;
+            return [String.fromCodePoint(...item)];
         }
-        catch {
+        if (st === "transpose") {
+            if (!Array.isArray(item) || !item.every(row => Array.isArray(row)))
+                return undefined;
+            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 === undefined)
+                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 undefined;
         }
-        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 === undefined)
-                            next.push(null);
-                        else if (typeof item === "object" && !Array.isArray(item))
-                            next.push(item[op.key] ?? null);
-                        else
-                            return undefined;
-                    }
-                    else if (op.kind === "index") {
-                        if (item === null || item === undefined)
-                            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 undefined;
+        if (st === "keys") {
+            if (Array.isArray(item))
+                return [item.map((_, idx) => idx)];
+            if (item && typeof item === "object")
+                return [Object.keys(item).sort()];
+            return undefined;
+        }
+        if (st === "keys[]") {
+            if (Array.isArray(item))
+                return item.map((_, idx) => idx);
+            if (item && typeof item === "object")
+                return Object.keys(item).sort();
+            return undefined;
+        }
+        if (st === "values") {
+            return item === null || item === undefined ? [] : [item];
+        }
+        if (st === "empty")
+            return [];
+        if (st === "not")
+            return [!(item !== false && item !== null && item !== undefined)];
+        if (st === "any")
+            return Array.isArray(item) ? [item.some(x => x !== false && x !== null && x !== undefined)] : undefined;
+        if (st === "all")
+            return Array.isArray(item) ? [item.every(x => x !== false && x !== null && x !== undefined)] : undefined;
+        if (st === "keys_unsorted") {
+            if (Array.isArray(item))
+                return [item.map((_, idx) => idx)];
+            if (item && typeof item === "object")
+                return [Object.keys(item)];
+            return undefined;
+        }
+        if (st === "flatten")
+            return Array.isArray(item) ? [item.flat(Infinity)] : undefined;
+        const flatM = /^flatten\(\s*([0-9]{1,2})\s*\)$/.exec(st);
+        if (flatM)
+            return Array.isArray(item) ? [item.flat(Number(flatM[1]))] : undefined;
+        if (st === "sort") {
+            if (!Array.isArray(item))
+                return undefined;
+            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 undefined;
+        }
+        if (st === "tojson")
+            return [JSON.stringify(item)];
+        if (st === "fromjson") {
+            if (typeof item !== "string")
+                return undefined;
+            try {
+                return [JSON.parse(item)];
+            }
+            catch {
+                return undefined;
+            }
+        }
+        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 undefined;
+                    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 undefined;
+                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 undefined;
+                const k0 = kv[0];
+                if (typeof k0 !== "string" && typeof k0 !== "number" && typeof k0 !== "boolean" && k0 !== null)
+                    return undefined;
+                keyed.push({ el, k: k0 });
+            }
+            const cmpK = (a, b) => {
+                const rank = (value) => value === null ? 0 : value === false ? 1 : value === true ? 2 : typeof value === "number" ? 3 : 4;
+                const typeOrder = rank(a) - rank(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] : undefined;
+        }
+        if (st === "last") {
+            return Array.isArray(item) ? [item.length > 0 ? item[item.length - 1] : null] : undefined;
+        }
+        if (st === "reverse") {
+            return Array.isArray(item) ? [[...item].reverse()] : undefined;
+        }
+        // Use the jq engine for its complete type ordering and equality semantics.
+        if (st === "unique")
+            return undefined;
+        if (st === "add") {
+            if (!Array.isArray(item))
+                return undefined;
+            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 undefined;
+        }
+        if (st === "min" || st === "max") {
+            if (!Array.isArray(item))
+                return undefined;
+            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 undefined;
+        }
+        if (st === "to_entries") {
+            if (item && typeof item === "object" && !Array.isArray(item)) {
+                return [Object.entries(item).map(([key, value]) => ({ key, value }))];
+            }
+            return undefined;
+        }
+        if (st === "from_entries") {
+            if (!Array.isArray(item))
+                return undefined;
+            const obj = {};
+            for (const el of item) {
+                if (!el || typeof el !== "object" || Array.isArray(el))
+                    return undefined;
+                const rec = el;
+                const k = rec.key ?? rec.name ?? rec.k;
+                if (typeof k !== "string")
+                    return undefined;
+                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 undefined;
+        }
+        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))] : undefined;
+        }
+        if (st === "ascii_downcase") {
+            return typeof item === "string" ? [item.replace(/[A-Z]/g, ch => String.fromCharCode(ch.charCodeAt(0) + 32))] : undefined;
+        }
+        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 undefined;
+                return [item.map(x => x === null ? "" : String(x)).join(arg)];
+            }
+            if (fn === "split")
+                return typeof item === "string" ? [item.split(arg)] : undefined;
+            if (fn === "ltrimstr")
+                return typeof item === "string" ? [item.startsWith(arg) ? item.slice(arg.length) : item] : undefined;
+            if (fn === "rtrimstr")
+                return typeof item === "string" ? [arg.length > 0 && item.endsWith(arg) ? item.slice(0, -arg.length) : item] : undefined;
+            if (fn === "startswith")
+                return typeof item === "string" ? [item.startsWith(arg)] : undefined;
+            if (fn === "endswith")
+                return typeof item === "string" ? [item.endsWith(arg)] : undefined;
+            if (fn === "contains") {
+                if (typeof item === "string")
+                    return [item.includes(arg)];
+                return undefined;
+            }
+        }
+        const hasM = /^has\(\s*"([^"\\]+)"\s*\)$/.exec(st);
+        if (hasM) {
+            if (item && typeof item === "object" && !Array.isArray(item))
+                return [Object.hasOwn(item, hasM[1])];
+            return undefined;
+        }
+        const mapM = /^map\(\s*(.+)\s*\)$/.exec(st);
+        if (mapM) {
+            if (!Array.isArray(item))
+                return undefined;
+            const mapped = [];
+            for (const el of item) {
+                const subRes = this.evalSyncJqPathOps(el, mapM[1]);
+                if (subRes === undefined)
+                    return undefined;
+                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 undefined;
+            const lv = fVals[0];
+            if (!selM[2]) {
+                return lv !== null && lv !== undefined && lv !== false ? [item] : [];
+            }
+            let rv;
+            try {
+                rv = JSON.parse(selM[3].trim());
+            }
+            catch {
+                return undefined;
+            }
+            // The full jq evaluator owns structural equality and jq ordering.
+            if ((typeof lv === "object" && lv !== null) || (typeof rv === "object" && rv !== null))
+                return undefined;
+            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 undefined;
+            return ok ? [item] : [];
+        }
+        if (!st.startsWith("."))
+            return undefined;
+        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 undefined;
+        }
+        let cur = [item];
+        for (const op of ops) {
+            const next = [];
+            for (const it of cur) {
+                if (op.kind === "prop") {
+                    if (it === null || it === undefined)
+                        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 undefined;
+                }
+                else if (op.kind === "index") {
+                    if (it === null || it === undefined)
+                        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 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 undefined;
+                    else
+                        return undefined;
+                }
+                else if (op.kind === "iter") {
+                    if (Array.isArray(it)) {
+                        for (const el of it)
+                            next.push(el);
                     }
-                    else if (op.kind === "length") {
-                        if (item === null || item === undefined)
-                            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 undefined;
+                    else if (it && typeof it === "object") {
+                        for (const k of Object.keys(it))
+                            next.push(it[k]);
                     }
-                    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 undefined;
+                    else
+                        return undefined;
+                }
+            }
+            cur = next;
+        }
+        return cur;
+    }
+    evalSyncJq(input, 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 = ["-r", "-rc", "-cr", "--raw-output"].includes(opArgs[0]);
+            compactOut = ["-c", "-rc", "-cr", "--compact-output"].includes(opArgs[0]);
+            filter = opArgs[1];
+        }
+        if (!filter)
+            return undefined;
+        let current = [];
+        try {
+            current = [JSON.parse(input)];
+        }
+        catch {
+            if (!input.includes("\n"))
+                return undefined;
+            try {
+                for (const line of input.split("\n")) {
+                    const t = line.trim();
+                    if (t.length > 0)
+                        current.push(JSON.parse(t));
+                }
+                if (current.length === 0)
+                    return undefined;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        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 undefined;
+                let subCur = [item];
+                for (const st of innerStages.parts) {
+                    const commas = splitSyncJqExpression(st, ",");
+                    if (!commas)
+                        return undefined;
+                    const commaParts = commas.parts;
+                    const next = [];
+                    for (const it of subCur) {
+                        for (const part of commaParts) {
+                            const res = this.evalSyncJqPathOps(it, part);
+                            if (res === undefined)
+                                return undefined;
+                            for (const v of res)
+                                next.push(v);
+                        }
                     }
+                    subCur = next;
                 }
-                current = next;
+                outArrays.push(subCur);
             }
+            void innerArgs;
+            return outArrays.map(val => JSON.stringify(val ?? null, null, compactOut ? undefined : 2));
         }
-        return current.map(val => (rawOut && typeof val === "string" ? val : JSON.stringify(val ?? null)));
+        const stages = splitSyncJqExpression(filter, "|");
+        if (!stages)
+            return undefined;
+        for (const st of stages.parts) {
+            const commas = splitSyncJqExpression(st, ",");
+            if (!commas)
+                return undefined;
+            const commaParts = commas.parts;
+            const next = [];
+            for (const item of current) {
+                for (const part of commaParts) {
+                    const res = this.evalSyncJqPathOps(item, part);
+                    if (res === undefined)
+                        return undefined;
+                    for (const v of res)
+                        next.push(v);
+                }
+            }
+            current = next;
+        }
+        return current.map(val => (rawOut && typeof val === "string" ? val : JSON.stringify(val ?? null, null, compactOut ? undefined : 2)));
+    }
+    evalSyncDirname(args) {
+        let idx = 0;
+        if (args[0] === "--")
+            idx = 1;
+        else if (args[0] !== undefined && args[0].startsWith("-") && args[0] !== "-")
+            return undefined;
+        if (idx >= args.length)
+            return undefined;
+        const out = [];
+        for (let i = idx; i < args.length; i++) {
+            const p = args[i];
+            if (p.includes("\0"))
+                return undefined;
+            if (idx === 0 && p.startsWith("-") && p !== "-")
+                return undefined;
+            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 suffix;
+        let idx = 0;
+        const operands = [];
+        while (idx < args.length) {
+            const a = args[idx];
+            if (a === "--") {
+                operands.push(...args.slice(idx + 1));
+                break;
+            }
+            if (!a.startsWith("-") || a === "-") {
+                operands.push(a);
+                idx++;
+                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 undefined;
+                suffix = args[idx + 1];
+                idx += 2;
+            }
+            else if (a.startsWith("-s") && a.length > 2) {
+                multiple = true;
+                suffix = a.slice(2);
+                idx++;
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (operands.length === 0)
+            return undefined;
+        if (!multiple && operands.length > 2)
+            return undefined;
+        const effSuffix = multiple ? suffix : operands[1];
+        if (effSuffix !== undefined && effSuffix.includes("\0"))
+            return undefined;
+        const paths = multiple ? operands : [operands[0]];
+        const out = [];
+        for (const p of paths) {
+            if (p.includes("\0"))
+                return undefined;
+            let res = /^\/+$/u.test(p) ? "/" : basename(p);
+            if (effSuffix && res !== effSuffix && res.endsWith(effSuffix)) {
+                res = res.slice(0, -effSuffix.length);
+            }
+            out.push(res);
+        }
+        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)) {
@@ -27152,11 +28152,28 @@ export class Runtime {
     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 undefined;
+            }
+            else if (ca === "--output-delimiter") {
+                if (ci + 1 >= opArgs.length)
+                    return undefined;
+                outDelim = opArgs[++ci];
+                if (outDelim.length === 0 || outDelim.includes("\0"))
+                    return undefined;
+            }
             else if (ca.startsWith("-sd") || ca.startsWith("-ds")) {
                 suppressNoDelim = true;
                 const rest = ca.slice(3);
@@ -27167,21 +28184,29 @@ export class Runtime {
                 else
                     return undefined;
             }
-            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)
+        if (!suppressNoDelim && outDelim === undefined && norm.length === 1 && (norm[0].startsWith("-c") || norm[0].startsWith("-b"))) {
+            const isByteMode = norm[0].startsWith("-b");
+            if (!isByteMode && byteLocaleMode)
                 return undefined;
-            const picker = this.parseSyncCutSpec(norm[0].slice(2));
-            if (!picker)
+            if (isByteMode && rawLines.some(l => { for (let i = 0; i < l.length; i++)
+                if (l.charCodeAt(i) >= 128)
+                    return true; return false; }))
                 return undefined;
+            const basePicker = this.parseSyncCutSpec(norm[0].slice(2));
+            if (!basePicker)
+                return undefined;
+            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;
             return rawLines.map(l => {
-                const chars = Array.from(l);
+                const chars = isByteMode ? l.split("") : Array.from(l);
                 const idxs = picker(chars.length);
                 return idxs.map(i => chars[i]).join("");
             });
@@ -27201,9 +28226,13 @@ export class Runtime {
         }
         if (!fArg || !fArg.startsWith("-f"))
             return undefined;
-        const picker = this.parseSyncCutSpec(fArg.slice(2));
-        if (!picker)
+        const basePicker = this.parseSyncCutSpec(fArg.slice(2));
+        if (!basePicker)
             return undefined;
+        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];
@@ -27214,146 +28243,512 @@ export class Runtime {
             }
             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 undefined;
-        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"))
+        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 undefined;
+                rawExprs.push(opArgs[++i]);
+            }
+            else if (!a.startsWith("-") && rawExprs.length === 0 && i === opArgs.length - 1) {
+                rawExprs.push(a);
+            }
+            else {
                 return undefined;
-            const startSpec = addrCmdM[1];
-            const endSpec = addrCmdM[2];
-            const patSpec = addrCmdM[3];
-            const matchLine = (l, idx1, total) => {
-                if (patSpec !== undefined) {
-                    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 === "$" ? total : Number(startSpec);
-                if (endSpec === undefined)
-                    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]);
             }
-            return out;
         }
-        if (quiet)
-            return undefined;
-        if (!expr.startsWith("s") || expr.length < 4)
-            return undefined;
-        const delim = expr[1];
-        if (!"/#|:@,;%!".includes(delim))
-            return undefined;
-        const parts = expr.slice(2).split(delim);
-        if (parts.length !== 3)
+        if (rawExprs.length === 0)
             return undefined;
-        const [pat, rep, flags] = parts;
-        if ((flags !== "" && flags !== "g") || /[&\\\n]/.test(rep))
+        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 undefined;
-        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))
+        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, total) => {
+                    if (patSpec !== undefined) {
+                        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 === "$" ? total : Number(startSpec);
+                    if (endSpec === undefined)
+                        return idx1 === sNum;
+                    const eNum = endSpec === "$" ? total : 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;
+            }
+            // Text commands need range state and independent output terminators.
+            // Let the canonical sed executor preserve those byte-level semantics.
+            if (rest.startsWith("i") || rest.startsWith("a") || rest.startsWith("c"))
+                return undefined;
+            if (rest.startsWith("y") && rest.length >= 4) {
+                const delim = rest[1];
+                if (!"/#|:@,;%!".includes(delim))
+                    return undefined;
+                const parts = rest.slice(2).split(delim);
+                if (parts.length !== 3 || parts[2] !== "")
+                    return undefined;
+                const srcStr = parts[0];
+                const dstStr = parts[1];
+                if (srcStr.includes("\\") || dstStr.includes("\\"))
+                    return undefined;
+                const srcChars = Array.from(srcStr);
+                const dstChars = Array.from(dstStr);
+                if (srcChars.length !== dstChars.length)
+                    return undefined;
+                const map = 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 undefined;
+                const parts = rest.slice(2).split(delim);
+                if (parts.length !== 3)
+                    return undefined;
+                const [pat, rep, flags] = parts;
+                if (!/^[giIp1-9]*$/.test(flags) || /\n|\\(?![1-9])/.test(rep))
+                    return undefined;
+                const nthDigits = flags.match(/[1-9]/g);
+                if (nthDigits && (nthDigits.length > 1 || flags.includes("g")))
+                    return undefined;
+                const nth = nthDigits ? Number(nthDigits[0]) : 0;
+                const global = flags.includes("g") || nth > 0;
+                const ignoreCase = flags.includes("i") || flags.includes("I");
+                const printOnMatch = flags.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 undefined;
+                let reSrc;
+                if (/^[a-zA-Z0-9_ :;,=-]*$/.test(core)) {
+                    if (/\\[1-9]/.test(rep))
+                        return undefined;
+                    reSrc = core.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                }
+                else if (core === "[ \t]*" || core === "[ \t]+" || 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 undefined;
+                    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 = undefined;
+                    }
+                }
+                if (reSrc === undefined)
+                    return undefined;
+                const fullRe = new RegExp((anchorStart ? "^" : "") + reSrc + (anchorEnd ? "$" : ""), (global ? "g" : "") + (ignoreCase ? "i" : ""));
+                steps.push({ addr, negated, kind: "s", re: fullRe, rep, printOnMatch, nth });
+                continue;
+            }
             return undefined;
-        const isGlobal = flags === "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);
-        });
+        }
+        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;
+                    // Expand only replacement tokens; inserted match bytes are literal.
+                    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 undefined;
-        const mode = opArgs.length === 2 ? opArgs[0] : "";
-        const pat = opArgs[opArgs.length - 1];
-        if (pat.startsWith("-"))
-            return undefined;
-        if (opArgs.length === 2 && mode !== "-v" && mode !== "-i" && mode !== "-c" && mode !== "-F" && mode !== "-E" && mode !== "-Ei" && mode !== "-iE" && mode !== "-Ev" && mode !== "-vE") {
+        if (errexit || opArgs.length < 1 || opArgs.length > 8)
             return undefined;
+        let mode = "";
+        let maxCount = 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 undefined;
+                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 undefined;
+                maxCount = Number(opArgs[++i]);
+            }
+            else if (a.startsWith("-m") && /^[1-9][0-9]{0,5}$/.test(a.slice(2))) {
+                maxCount = Number(a.slice(2));
+            }
+            else if (a.startsWith("--max-count=") && /^[1-9][0-9]{0,5}$/.test(a.slice(12))) {
+                maxCount = 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 undefined;
+            }
+            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 undefined;
+            }
         }
+        if (rawPatterns.length === 0 || !/^[vicFEonxw]*$/.test(mode))
+            return undefined;
+        const isLineNumber = mode.includes("n");
+        const isLineRegexp = mode.includes("x");
+        const isWordRegexp = mode.includes("w");
         const isCaseInsensitive = mode.includes("i");
+        const foldCase = (value) => value.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 (isCount && (isLineNumber || isOnlyMatching || beforeCtx > 0 || afterCtx > 0))
+            return undefined;
+        if (isOnlyMatching && (beforeCtx > 0 || afterCtx > 0))
+            return undefined;
+        if (isOnlyMatching) {
+            if (rawPatterns.length !== 1 || isInvert || isLineRegexp || isWordRegexp || isFixed)
+                return undefined;
+            const pat = rawPatterns[0];
+            const reFlags = isCaseInsensitive ? "gi" : "g";
+            let re;
+            if (isExtended && /^[a-zA-Z0-9_ :;,=.+*?|()^\-[\]]+$/.test(pat) && !/\([^)]*[+*][^)]*\)[+*?]/.test(pat)) {
+                try {
+                    re = new RegExp(pat, reFlags);
+                }
+                catch {
+                    re = undefined;
+                }
+            }
+            else {
+                const branches = isExtended ? pat.split("|") : [pat];
+                if (branches.every(b => b.length > 0 && /^[a-zA-Z0-9_ :;,/-]+$/.test(b))) {
+                    branches.sort((a, b) => b.length - a.length);
+                    re = new RegExp(branches.join("|"), reFlags);
+                }
+            }
+            if (!re)
+                return undefined;
+            const out = [];
+            for (let li = 0; li < rawLines.length; li++) {
+                const matches = rawLines[li].match(re);
+                if (matches) {
+                    for (let mi = 0; mi < matches.length; mi++) {
+                        out.push(isLineNumber ? `${li + 1}:${matches[mi]}` : matches[mi]);
+                    }
+                }
+            }
+            return { lines: out, status: out.length > 0 ? 0 : 1 };
+        }
+        if (isExtended && isFixed)
+            return undefined;
+        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 undefined;
-            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 undefined;
-            compiledBranches.push({ anchorStart, anchorEnd, needle: isCaseInsensitive ? core.toLowerCase() : core });
+            if (isFixed) {
+                if (br.includes("\0"))
+                    return undefined;
+                compiledBranches.push({ anchorStart: isLineRegexp, anchorEnd: isLineRegexp, needle: isCaseInsensitive ? foldCase(br) : br, re: undefined });
+            }
+            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: undefined });
+                }
+                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 undefined;
+                    }
+                }
+                else {
+                    return undefined;
+                }
+            }
         }
+        const isWordChar = (ch) => ch !== undefined && /^[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 !== undefined
+                    ? 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 >= maxCount)
+                    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,
@@ -27361,50 +28756,413 @@ export class Runtime {
         };
     }
     evalSyncAwk(rawLines, opArgs) {
-        if (opArgs.length < 1 || opArgs.length > 3)
+        if (opArgs.length < 1 || opArgs.length > 8)
             return undefined;
-        const norm = opArgs.length === 3 && opArgs[0] === "-F" ? ["-F" + opArgs[1], opArgs[2]] : opArgs;
         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 = 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 undefined;
+                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 undefined;
+                const kv = opArgs[++i];
+                const eq = kv.indexOf("=");
+                if (eq <= 0 || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(kv.slice(0, eq)))
+                    return undefined;
+                const k = kv.slice(0, eq);
+                const v = kv.slice(eq + 1);
+                if (v.includes("\\"))
+                    return undefined;
+                if (k === "OFS")
+                    ofs = v;
+                else if (k === "FS") {
+                    if (v.length !== 1)
+                        return undefined;
+                    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 undefined;
+                const k = kv.slice(0, eq);
+                const v = kv.slice(eq + 1);
+                if (v.includes("\\"))
+                    return undefined;
+                if (k === "OFS")
+                    ofs = v;
+                else if (k === "FS") {
+                    if (v.length !== 1)
+                        return undefined;
+                    awkSep = v;
+                }
+                else
+                    userVars.set(k, v);
+            }
+            else if (!a.startsWith("-") && i === opArgs.length - 1) {
+                awkProg = a;
+            }
+            else {
+                return undefined;
+            }
         }
         if (!awkProg)
             return undefined;
-        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 undefined;
+            }
+            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 undefined;
+            if (initVarName !== undefined && initVarName !== varName)
+                return undefined;
+            const op = sumEndM[2];
+            const fTok = sumEndM[3];
+            const constVal = sumEndM[4] !== undefined ? Number(sumEndM[4]) : undefined;
+            const initial = userVars.get(varName);
+            if (initial !== undefined && !Number.isFinite(Number(initial)))
+                return undefined;
+            let acc = initVarName === varName ? initVarVal : Number(initial ?? 0);
+            let touched = initVarName === varName || initial !== undefined;
+            for (let li = 0; li < rawLines.length; li++) {
+                const l = rawLines[li];
+                const fields = awkSep === undefined || awkSep === " "
+                    ? l.split(/[ \t]+/).filter(Boolean)
+                    : (l.length === 0 ? [] : l.split(awkSep));
+                let delta = 0;
+                if (constVal !== undefined) {
+                    delta = constVal;
+                }
+                else {
+                    const idx = fTok === "NF" ? fields.length : Number(fTok);
+                    const rawField = idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[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 ? awkValueText({ kind: "number", number: acc }) : ""];
+        }
+        if (initVarName !== undefined)
+            return undefined;
+        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] !== undefined ? userVars.get(cmpCondM[6]) : undefined;
+                if (cmpCondM[6] !== undefined && varRhs === undefined)
+                    return undefined;
+                const varAsNum = varRhs !== undefined && /^-?(?:\d+(?:\.\d*)?|\.\d+)$/.test(varRhs) ? Number(varRhs) : undefined;
+                const strRhs = cmpCondM[4] ?? (varAsNum === undefined ? varRhs : undefined);
+                const numRhs = cmpCondM[5] !== undefined ? Number(cmpCondM[5]) : varAsNum;
+                if (strRhs !== undefined && op !== "==" && op !== "!=")
+                    return undefined;
+                rowPred = (l, fields, nr) => {
+                    let rawVal;
+                    if (nrNf !== undefined)
+                        rawVal = nrNf === "NR" ? nr : fields.length;
+                    else {
+                        const idx = fTok === "NF" ? fields.length : Number(fTok);
+                        rawVal = idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[idx - 1] : "");
+                    }
+                    const left = typeof rawVal === "number" ? awkNumeric(rawVal) : awkInputValue(rawVal);
+                    const right = strRhs !== undefined ? awkString(strRhs) : awkNumeric(numRhs);
+                    const comparison = awkCompare(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 undefined;
-        const exprBody = awkM[1]?.trim();
+        const subFn = awkM[1];
+        const subPat = awkM[2];
+        const subRep = awkM[3] ?? "";
+        const subTarget = awkM[4] ?? "0";
+        // printf must consume typed values before OFMT string conversion and use
+        // the complete formatter, including integer precision and exponent parsing.
+        if (awkM[6] !== undefined)
+            return undefined;
+        const exprBody = awkM[5]?.trim();
+        let subRe;
+        if (subFn && subPat !== undefined) {
+            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] !== undefined)
-                    parts.push({ kind: "field", token: m[1] });
+                if (m[1] !== undefined) {
+                    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 undefined;
+                    parts.push({ kind: "ternary", lhs: tm[1], op: tm[2], rhs: tm[3], yes: tm[4], no: tm[5] });
+                }
                 else if (m[2] !== undefined)
-                    parts.push({ kind: "lit", text: m[2] });
+                    parts.push({ kind: "int", token: m[2] });
                 else if (m[3] !== undefined)
-                    parts.push({ kind: "lit", text: " " });
+                    parts.push({ kind: "case", fn: m[3] === "toupper" ? "upper" : "lower", token: m[4] });
+                else if (m[5] !== undefined)
+                    parts.push({ kind: "substr", token: m[5], start: Number(m[6]), len: m[7] !== undefined ? Number(m[7]) : undefined });
+                else if (m[8] !== undefined)
+                    parts.push({ kind: "index", token: m[8], sub: m[9] });
+                else if (m[10] !== undefined) {
+                    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 undefined;
+                    }
+                    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 undefined;
+                        }
+                    }
+                    parts.push({ kind: "arith", tokens: aToks });
+                }
+                else if (m[11] !== undefined) {
+                    const offset = Number(m[11]);
+                    // Refuse potentially fatal fields before loop iterations mutate state.
+                    if (offset > 0)
+                        return undefined;
+                    parts.push({ kind: "nf_minus", offset });
+                }
+                else if (m[12] !== undefined)
+                    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] !== undefined)
+                    parts.push({ kind: "var", name: m[14] });
+                else if (m[15] !== undefined)
+                    parts.push({ kind: "lit", text: m[15] });
+                else if (m[16] !== undefined) {
+                    const uv = userVars.get(m[16]);
+                    if (uv === undefined)
+                        return undefined;
+                    parts.push({ kind: "lit", text: uv });
+                }
+                else if (m[17] !== undefined)
+                    parts.push({ kind: "lit", text: ofs });
             }
         }
-        return rawLines.map(l => {
-            if (parts.length === 1 && parts[0].kind === "field" && parts[0].token === "0")
-                return l;
-            const fields = awkSep !== undefined
-                ? (awkSep === " " ? l.trim().split(/\s+/).filter(Boolean) : (l.length === 0 ? [] : l.split(awkSep)))
-                : l.trim().split(/\s+/).filter(Boolean);
+        const outLines = [];
+        for (let li = 0; li < rawLines.length; li++) {
+            let l = rawLines[li];
+            let fields = awkSep === undefined || awkSep === " "
+                ? l.split(/[ \t]+/).filter(Boolean)
+                : (l.length === 0 ? [] : l.split(awkSep));
+            if (rowPred && !rowPred(l, fields, li + 1))
+                continue;
+            if (subRe) {
+                if (subTarget === "0") {
+                    l = l.replace(subRe, matched => subRep.split("&").join(matched));
+                    fields = awkSep === undefined || awkSep === " "
+                        ? l.split(/[ \t]+/).filter(Boolean)
+                        : (l.length === 0 ? [] : l.split(awkSep));
+                }
+                else {
+                    const tIdx = subTarget === "NF" ? fields.length : Number(subTarget);
+                    if (tIdx >= 1 && tIdx <= fields.length) {
+                        fields = [...fields];
+                        fields[tIdx - 1] = fields[tIdx - 1].replace(subRe, matched => subRep.split("&").join(matched));
+                        l = fields.join(ofs);
+                    }
+                }
+            }
+            if (parts.length === 1 && parts[0].kind === "field" && parts[0].token === "0") {
+                outLines.push(l);
+                continue;
+            }
             let out = "";
             for (let pi = 0; pi < parts.length; pi++) {
                 const p = parts[pi];
                 if (p.kind === "lit")
                     out += p.text;
+                else if (p.kind === "var")
+                    out += String(p.name === "NR" ? li + 1 : fields.length);
+                else if (p.kind === "nf_minus") {
+                    const idx = fields.length - p.offset;
+                    if (idx < 0)
+                        return undefined;
+                    out += idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[idx - 1] : "");
+                }
+                else if (p.kind === "case") {
+                    const idx = p.token === "NF" ? fields.length : Number(p.token);
+                    const s = idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[idx - 1] : "");
+                    out += p.fn === "upper" ? s.toUpperCase() : s.toLowerCase();
+                }
+                else if (p.kind === "substr") {
+                    const idx = p.token === "NF" ? fields.length : Number(p.token);
+                    const s = idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[idx - 1] : "");
+                    const chars = Array.from(s);
+                    const s0 = Math.max(0, p.start - 1);
+                    out += (p.len !== undefined ? chars.slice(s0, s0 + Math.max(0, p.len)) : chars.slice(s0)).join("");
+                }
+                else if (p.kind === "index") {
+                    const idx = p.token === "NF" ? fields.length : Number(p.token);
+                    const s = idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[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" ? fields.length : Number(p.token);
+                    const s = idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[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(fields.length);
+                        if (tok.startsWith("$")) {
+                            const fIdx = tok === "$NF" ? fields.length : Number(tok.slice(1));
+                            return fIdx === 0 ? l : (fIdx >= 1 && fIdx <= fields.length ? fields[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 = fields.length;
+                            else if (tk.startsWith("$")) {
+                                const fSub = tk.slice(1);
+                                const idx = fSub === "NF" ? fields.length : Number(fSub);
+                                const rawF = idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[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 undefined;
+                            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 += awkValueText(awkNumeric(acc));
+                }
+                else if (p.kind === "length") {
+                    const idx = p.token === "NF" ? fields.length : Number(p.token);
+                    const s = idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[idx - 1] : "");
+                    out += String(Array.from(s).length);
+                }
                 else if (p.token === "0")
                     out += l;
                 else {
@@ -27412,8 +29170,9 @@ export class Runtime {
                     out += idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[idx - 1] : "");
                 }
             }
-            return out;
-        });
+            outLines.push(out);
+        }
+        return outLines;
     }
     formatSyncTransformQ(val) {
         let ansi = false;
@@ -27456,41 +29215,716 @@ export class Runtime {
         }
         return out + "'";
     }
-    sortSyncLines(rawLines, flag) {
-        const rev = flag !== undefined && flag.includes("r");
-        const num = flag !== undefined && flag.includes("n");
-        const uniq = flag !== undefined && flag.includes("u");
+    wcMaxLineWidth(text, singleByte) {
+        let columns = 0;
+        let maximum = 0;
+        for (const char of text) {
+            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] : undefined;
+                const cb = ib < b.length ? b[ib] : undefined;
+                const da = ca !== undefined && ca >= "0" && ca <= "9";
+                const db = cb !== undefined && cb >= "0" && cb <= "9";
+                if (da && db)
+                    break;
+                if (ca !== cb) {
+                    if (ca === undefined)
+                        return -1;
+                    if (cb === undefined)
+                        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 format = "rn";
+        let width = 6;
+        let sep = "\t";
+        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 undefined;
+                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 undefined;
+                format = v;
+            }
+            else if (a === "-nln" || a === "-nrn" || a === "-nrz") {
+                format = 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 undefined;
+            }
+        }
+        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 === "\t" ? " ".repeat(width + 1) : unnumberedPrefix + l);
+                continue;
+            }
+            const label = String(num);
+            const pad = Math.max(0, width - label.length);
+            let prefix;
+            if (format === "ln")
+                prefix = label + " ".repeat(pad);
+            else if (format === "rz")
+                prefix = num < 0 ? "-" + "0".repeat(pad) + label.slice(1) : "0".repeat(pad) + label;
+            else
+                prefix = " ".repeat(pad) + label;
+            out.push(prefix + sep + l);
+            num += inc;
+        }
+        return out;
+    }
+    evalSyncPaste(rawLines, opArgs) {
+        let serial = false;
+        let delims = ["\t"];
+        let literal = false;
+        const files = [];
+        const parseDelims = (s) => {
+            if (s.length === 0)
+                return [""];
+            const res = [];
+            const escapes = { b: "\b", f: "\f", n: "\n", r: "\r", t: "\t", v: "\v", "0": "" };
+            for (let i = 0; i < s.length; i++) {
+                const ch = s[i];
+                if (ch === "\\") {
+                    if (i + 1 >= s.length)
+                        return undefined;
+                    const esc = s[++i];
+                    res.push(escapes[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 undefined;
+                delims = d;
+                continue;
+            }
+            if (a.startsWith("--delimiters=")) {
+                const d = parseDelims(a.slice(13));
+                if (!d)
+                    return undefined;
+                delims = d;
+                continue;
+            }
+            if (a.startsWith("--"))
+                return undefined;
+            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] : undefined);
+                    if (rawD === undefined)
+                        return undefined;
+                    const d = parseDelims(rawD);
+                    if (!d)
+                        return undefined;
+                    delims = d;
+                    break;
+                }
+                else
+                    return undefined;
+            }
+        }
+        if (files.length === 0)
+            files.push("-");
+        if (!files.every(f => f === "-"))
+            return undefined;
+        if (serial) {
+            if (files.length !== 1)
+                return undefined;
+            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 padding = 0;
+        let suffix = "";
+        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 undefined;
+            }
+            else if (a.startsWith("--to=")) {
+                const v = a.slice(5);
+                if (v === "none" || v === "iec" || v === "iec-i" || v === "si")
+                    toScale = v;
+                else
+                    return undefined;
+            }
+            else if (a.startsWith("--padding=")) {
+                const v = a.slice(10);
+                if (!/^-?[1-9][0-9]{0,2}$/.test(v))
+                    return undefined;
+                padding = Number(v);
+            }
+            else if (a.startsWith("--suffix=")) {
+                suffix = a.slice(9);
+            }
+            else {
+                return undefined;
+            }
+        }
+        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 undefined;
+            let val = Number(m[1]);
+            const suf = m[2] ?? "";
+            if (suf.length > 0) {
+                if (fromScale === "none")
+                    return undefined;
+                const uChar = suf[0].toUpperCase();
+                const pIdx = units.indexOf(uChar) + 1;
+                if (pIdx <= 0)
+                    return undefined;
+                const hasI = suf.length === 2 && suf[1].toLowerCase() === "i";
+                if (fromScale === "iec-i" && !hasI)
+                    return undefined;
+                if ((fromScale === "iec" || fromScale === "si") && hasI)
+                    return undefined;
+                const fBase = (fromScale === "iec" || fromScale === "iec-i" || (fromScale === "auto" && hasI)) ? 1024 : 1000;
+                val = val * Math.pow(fBase, pIdx);
+            }
+            else if (fromScale === "iec-i") {
+                // plain number ok
+            }
+            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 : 1000;
+                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 += suffix;
+            if (padding !== 0) {
+                const w = Math.abs(padding);
+                if (rendered.length < w) {
+                    const pad = " ".repeat(w - rendered.length);
+                    rendered = padding < 0 ? rendered + pad : pad + rendered;
+                }
+            }
+            out.push(rendered);
+        }
+        return out;
+    }
+    evalSyncSort(rawLines, opArgs, isByteLocale) {
+        if (isByteLocale)
+            return undefined;
+        let rev = false;
+        let num = false;
+        let human = false;
+        let month = false;
+        let dict = false;
+        let uniq = false;
+        let fold = 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"))
+                    fold = 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")
+                fold = 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 !== undefined)
+                    return undefined;
+                keySpec = opArgs[++i];
+            }
+            else if (a.startsWith("-k") && a.length > 2) {
+                if (keySpec !== undefined)
+                    return undefined;
+                keySpec = a.slice(2);
+            }
+            else {
+                return undefined;
+            }
+        }
+        if (ver || keySpec?.includes("V"))
+            return undefined;
+        let startField = 1;
+        let endField;
+        let keyNum = num;
+        let keyHuman = human;
+        let keyMonth = month;
+        let keyDict = dict;
+        let keyRev = rev;
+        let keyFold = fold;
+        let keyBlanks = blanks;
+        let keyVer = ver;
+        if (keySpec !== undefined) {
+            const km = /^([1-9][0-9]{0,2})(?:,([1-9][0-9]{0,2}))?([nrbfVhMd]*)$/.exec(keySpec);
+            if (!km)
+                return undefined;
+            startField = Number(km[1]);
+            endField = km[2] !== undefined ? Number(km[2]) : undefined;
+            if (endField !== undefined && endField < startField)
+                return undefined;
+            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 === undefined
+                ? l
+                : (() => {
+                    if (sep !== undefined) {
+                        const fields = l.split(sep);
+                        return fields.slice(startField - 1, endField).join(sep);
+                    }
+                    // Default fields include their leading blanks; retain exact bytes.
+                    let offset = 0;
+                    let start = l.length;
+                    let end = l.length;
+                    for (let field = 1; offset < l.length; field++) {
+                        if (field === startField)
+                            start = offset;
+                        while (l[offset] === " " || l[offset] === "\t")
+                            offset++;
+                        while (offset < l.length && l[offset] !== " " && l[offset] !== "\t")
+                            offset++;
+                        if (field === 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);
+            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 rev ? nb - na : 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 = fold ? a.toUpperCase() : a;
+            const fb = fold ? 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])
+            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(input, set1Spec, set2Spec) {
-        if (set1Spec === "a-z" && set2Spec === "A-Z")
-            return input.toUpperCase();
-        if (set1Spec === "A-Z" && set2Spec === "a-z")
-            return input.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 undefined;
+    }
+    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 undefined;
+            }
+        }
+        const keyOf = (l) => {
+            let offset = 0;
+            for (let f = 0; f < skipFields; f++) {
+                while (offset < l.length && (l[offset] === " " || l[offset] === "\t"))
+                    offset++;
+                while (offset < l.length && l[offset] !== " " && l[offset] !== "\t")
+                    offset++;
+            }
+            if (skipChars === 0 && checkChars === Infinity) {
+                const sub = l.slice(offset);
+                return ignoreCase ? sub.toLowerCase() : sub;
+            }
+            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 count = uEnd - uIdx;
+            if ((!onlyRepeated || count > 1) && (!onlyUnique || count === 1)) {
+                outLines.push(hasCount ? `${String(count).padStart(7, " ")} ${rawLines[uIdx]}` : rawLines[uIdx]);
+            }
+            uIdx = uEnd;
+        }
+        return outLines;
+    }
+    sortSyncLines(rawLines, flag) {
+        return this.evalSyncSort(rawLines, flag !== undefined ? [flag] : [], false) ?? [...rawLines];
+    }
+    translateSyncTr(input, set1Spec, set2Spec, truncateSet1 = false) {
+        if ((set1Spec === "a-z" || set1Spec === "[:lower:]") && (set2Spec === "A-Z" || set2Spec === "[:upper:]")) {
+            return input.replace(/[a-z]/g, ch => String.fromCharCode(ch.charCodeAt(0) - 32));
+        }
+        if ((set1Spec === "A-Z" || set1Spec === "[:upper:]") && (set2Spec === "a-z" || set2Spec === "[:lower:]")) {
+            return input.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)
+        if (!rawS1 || !s2 || rawS1.length === 0 || s2.length === 0)
             return undefined;
+        const s1 = truncateSet1 ? rawS1.slice(0, s2.length) : rawS1;
+        if (s1.length === 0)
+            return input;
         if (s1.length === 1 && s2.length === 1)
             return input.split(s1[0]).join(s2[0]);
         const map = new Map();
@@ -27684,7 +30118,7 @@ export class Runtime {
                 if (!sName || hasShellFunction(rawState, sName) || rawState.extensions?.builtins.has(sName))
                     return undefined;
                 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))
+                if (!extDef || (sName !== "rev" && sName !== "tac" && sName !== "nl" && sName !== "paste" && sName !== "jq" && !builtInDirectContextExecutors.has(extDef.execute)) || customRegisteredCommands.has(extDef.execute))
                     return undefined;
                 if (!this.arePureArgWords(sCmd.words, rawState))
                     return undefined;
@@ -27704,29 +30138,32 @@ export class Runtime {
                         return undefined;
                 }
                 else if (sName === "uniq") {
-                    if (sArgs.length > 1 || (sArgs.length === 1 && sArgs[0] !== "-c" && sArgs[0] !== "-d" && sArgs[0] !== "-u" && sArgs[0] !== "-i"))
+                    if (this.evalSyncUniq([], sArgs) === undefined)
                         return undefined;
                 }
                 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"))
+                    if (this.evalSyncSort([], sArgs, byteLocale(rawState.variables)) === undefined)
                         return undefined;
                 }
                 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]))
+                    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 undefined;
                 }
                 else if (sName === "wc") {
-                    if (sArgs.length !== 1 || (sArgs[0] !== "-l" && sArgs[0] !== "-c" && sArgs[0] !== "-w"))
+                    const normWc = sArgs.length === 1 ? this.normalizeSyncWcFlag(sArgs[0]) : undefined;
+                    if (!normWc)
                         return undefined;
+                    sArgs[0] = normWc;
                 }
                 else if (sName === "sed") {
                     if (this.evalSyncSed([], sArgs) === undefined)
@@ -27745,17 +30182,33 @@ export class Runtime {
                         return undefined;
                 }
                 else if (sName === "jq") {
-                    if (this.evalSyncJq("null", sArgs) === undefined)
+                    if (sArgs.length === 0 || sArgs.length > 2)
+                        return undefined;
+                    if (sArgs.length === 1 && sArgs[0].startsWith("-"))
+                        return undefined;
+                    if (sArgs.length === 2 && !["-r", "--raw-output", "-c", "--compact-output", "-rc", "-cr"].includes(sArgs[0]))
                         return undefined;
                 }
                 else if (sName === "base64") {
                     if (sArgs.length > 1 || (sArgs.length === 1 && sArgs[0] !== "-d" && sArgs[0] !== "--decode"))
                         return undefined;
                 }
-                else if (sName === "tac" || sName === "nl") {
+                else if (sName === "tac") {
                     if (sArgs.length !== 0)
                         return undefined;
                 }
+                else if (sName === "nl") {
+                    if (this.evalSyncNl([], sArgs) === undefined)
+                        return undefined;
+                }
+                else if (sName === "paste") {
+                    if (this.evalSyncPaste([], sArgs) === undefined)
+                        return undefined;
+                }
+                else if (sName === "numfmt") {
+                    if (this.evalSyncNumfmt([], sArgs) === undefined)
+                        return undefined;
+                }
                 else {
                     return undefined;
                 }
@@ -27843,8 +30296,10 @@ export class Runtime {
                     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" ||
@@ -27861,10 +30316,13 @@ export class Runtime {
                         isInlineJq ||
                         isInlineBase64 ||
                         isInlineTac ||
-                        isInlineNl) {
+                        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(""));
                         }
@@ -27883,7 +30341,16 @@ export class Runtime {
                                 prevLen = sub.byteLength;
                                 continue;
                             }
-                            outLines = firstName === "head" ? rawLines.slice(0, count) : (count === 0 ? [] : rawLines.slice(-count));
+                            if (firstName === "tail" && stageArgs[1].startsWith("+")) {
+                                outLines = rawLines.slice(Math.max(0, count - 1));
+                            }
+                            else if (firstName === "head" && stageArgs[1].startsWith("-")) {
+                                const drop = Math.abs(count);
+                                outLines = drop === 0 ? [...rawLines] : rawLines.slice(0, Math.max(0, rawLines.length - drop));
+                            }
+                            else {
+                                outLines = firstName === "head" ? rawLines.slice(0, count) : (count === 0 ? [] : rawLines.slice(-count));
+                            }
                         }
                         else if (firstName === "wc") {
                             if (stageArgs[0] === "-l") {
@@ -27897,6 +30364,12 @@ export class Runtime {
                                 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)];
                             }
@@ -27924,28 +30397,20 @@ export class Runtime {
                             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 count = uEnd - uIdx;
-                                if (mode === "-d" ? count > 1 : mode === "-u" ? count === 1 : true) {
-                                    outLines.push(mode === "-c" ? `${String(count).padStart(7, " ")} ${rawLines[uIdx]}` : rawLines[uIdx]);
-                                }
-                                uIdx = uEnd;
-                            }
+                            const uniqRes = this.evalSyncUniq(rawLines, stageArgs);
+                            if (uniqRes === undefined)
+                                return undefined;
+                            outLines = uniqRes;
                         }
                         else if (inlineSedMatch) {
                             const sedRes = this.evalSyncSed(rawLines, stageArgs);
                             if (sedRes === undefined)
                                 return undefined;
-                            outLines = sedRes;
+                            outLines = sedRes.lines;
+                            sedTerminated = sedRes.lastInputIndex < rawLines.length - 1;
                         }
                         else if (isInlineAwk) {
                             const awkRes = this.evalSyncAwk(rawLines, stageArgs);
@@ -27968,17 +30433,22 @@ export class Runtime {
                             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 undefined;
-                                if (l.length === 0)
-                                    outLines.push("       ");
-                                else
-                                    outLines.push(String(nlNum++).padStart(6, " ") + "\t" + l);
-                            }
+                            const nlRes = this.evalSyncNl(rawLines, stageArgs);
+                            if (nlRes === undefined)
+                                return undefined;
+                            outLines = nlRes;
+                        }
+                        else if (isInlinePaste) {
+                            const pasteRes = this.evalSyncPaste(rawLines, stageArgs);
+                            if (pasteRes === undefined)
+                                return undefined;
+                            outLines = pasteRes;
+                        }
+                        else if (isInlineNumfmt) {
+                            const nmRes = this.evalSyncNumfmt(rawLines, stageArgs);
+                            if (nmRes === undefined)
+                                return undefined;
+                            outLines = nmRes;
                         }
                         else if (isInlineBase64) {
                             if (stageArgs.length === 0) {
@@ -27990,7 +30460,7 @@ export class Runtime {
                                 if (cleaned.length % 4 !== 0 || (cleaned.length > 0 && !/^[A-Za-z0-9+/]+={0,2}$/.test(cleaned)))
                                     return undefined;
                                 const decoded = this.syncBase64DecodeBytes(cleaned);
-                                if (decoded.includes(0) || decoded.byteLength > nextBuf.byteLength)
+                                if (decoded.some(byte => byte === 0 || byte >= 128) || decoded.byteLength > nextBuf.byteLength)
                                     return undefined;
                                 const nextTotalBytes = this.budget.bytes + decoded.byteLength;
                                 if (nextTotalBytes > this.budget.maxOutputBytesSmi && decoded.byteLength > this.budget.limits.maxOutputBytes - this.budget.bytes)
@@ -28010,7 +30480,7 @@ export class Runtime {
                         }
                         // These filters preserve the terminator of the final selected input line.
                         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 outStr = outLines.length > 0 ? outLines.join("\n") + (terminated ? "\n" : "") : "";
                         const outByteLen = shellValueByteLength(outStr);
                         if (outByteLen > nextBuf.byteLength)
@@ -28175,8 +30645,8 @@ export class Runtime {
             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))))) {
+            (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++) {
@@ -28216,6 +30686,12 @@ export class Runtime {
                     // Non-ASCII file inputs use normal execution, which owns their raw ShellValue.
                     if (view && view.byteLength <= 16384 && !view.includes(0) && (hasSingleHereStringRedir || view.every(byte => byte < 128))) {
                         const fileStr = hasSingleHereStringRedir ? hereStrVal : sharedSyncPipeDecoder.decode(view);
+                        // Record-based shortcuts below serialize complete newline-terminated records.
+                        // Let normal commands preserve partial final records when reading files.
+                        if (fileStr.length > 0 && !fileStr.endsWith("\n") &&
+                            (w0Plain === "head" || w0Plain === "tail" || w0Plain === "sed" || w0Plain === "cut" || w0Plain === "uniq"))
+                            return undefined;
+                        const renderLines = (lines) => lines.length === 0 ? "" : lines.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;
@@ -28225,19 +30701,36 @@ export class Runtime {
                         else if ((w0Plain === "head" || w0Plain === "tail") && opArgs.length <= 2) {
                             let count = opArgs.length === 0 ? 10 : undefined;
                             let byteCount;
-                            if (opArgs.length === 1 && opArgs[0].startsWith("-n") && /^[0-9]{1,5}$/.test(opArgs[0].slice(2)))
-                                count = Number(opArgs[0].slice(2));
-                            else if (opArgs.length === 1 && opArgs[0].startsWith("-c") && /^[0-9]{1,5}$/.test(opArgs[0].slice(2)))
-                                byteCount = Number(opArgs[0].slice(2));
+                            let countRaw = opArgs.length === 0 ? "10" : undefined;
+                            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))
+                                    byteCount = Number(sub);
+                            }
                             else if (opArgs.length === 1 && /^-[0-9]{1,5}$/.test(opArgs[0]))
-                                count = Number(opArgs[0].slice(1));
-                            else if (opArgs.length === 2 && opArgs[0] === "-n" && /^[0-9]{1,5}$/.test(opArgs[1]))
-                                count = Number(opArgs[1]);
+                                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]))
                                 byteCount = Number(opArgs[1]);
-                            if (count !== undefined) {
-                                const sliced = w0Plain === "head" ? rawLines.slice(0, count) : (count === 0 ? [] : rawLines.slice(-count));
-                                fileRes = sliced.join("\n");
+                            if (countRaw !== undefined) {
+                                count = Number(countRaw);
+                                let sliced;
+                                if (w0Plain === "tail" && countRaw.startsWith("+"))
+                                    sliced = rawLines.slice(Math.max(0, count - 1));
+                                else if (w0Plain === "head" && countRaw.startsWith("-")) {
+                                    const drop = Math.abs(count);
+                                    sliced = drop === 0 ? [...rawLines] : rawLines.slice(0, Math.max(0, rawLines.length - drop));
+                                }
+                                else {
+                                    sliced = w0Plain === "head" ? rawLines.slice(0, count) : (count === 0 ? [] : rawLines.slice(-count));
+                                }
+                                fileRes = renderLines(sliced);
                             }
                             else if (byteCount !== undefined) {
                                 const slicedBytes = w0Plain === "head"
@@ -28249,91 +30742,109 @@ export class Runtime {
                         else if (w0Plain === "jq") {
                             const jqRes = this.evalSyncJq(fileStr.trim(), opArgs);
                             if (jqRes !== undefined)
-                                fileRes = jqRes.join("\n");
+                                fileRes = renderLines(jqRes);
                         }
                         else if (w0Plain === "awk") {
                             const awkRes = this.evalSyncAwk(rawLines, opArgs);
                             if (awkRes !== undefined)
-                                fileRes = awkRes.join("\n");
+                                fileRes = renderLines(awkRes);
                         }
                         else if (w0Plain === "grep") {
                             const grepRes = this.evalSyncGrep(rawLines, opArgs, Boolean(rawState.errexit));
                             if (grepRes !== undefined) {
                                 exitStatus = grepRes.status;
-                                fileRes = grepRes.lines.join("\n");
+                                fileRes = renderLines(grepRes.lines);
                             }
                         }
                         else if (w0Plain === "sed") {
                             const sedRes = this.evalSyncSed(rawLines, opArgs);
                             if (sedRes !== undefined)
-                                fileRes = sedRes.join("\n");
+                                fileRes = renderLines(sedRes.lines);
                         }
                         else if (w0Plain === "cut") {
                             const cutRes = this.evalSyncCut(rawLines, opArgs, byteLocale(rawState.variables));
                             if (cutRes !== undefined)
-                                fileRes = cutRes.join("\n");
+                                fileRes = renderLines(cutRes);
                         }
-                        else if (w0Plain === "wc" && opArgs.length === 1 && (opArgs[0] === "-l" || opArgs[0] === "-c" || opArgs[0] === "-w")) {
+                        else if (w0Plain === "wc" && opArgs.length === 1 && this.normalizeSyncWcFlag(opArgs[0]) !== undefined) {
+                            const wcMode = this.normalizeSyncWcFlag(opArgs[0]);
                             let count = 0;
-                            if (opArgs[0] === "-l") {
+                            if (wcMode === "-l") {
                                 for (let k = 0; k < view.byteLength; k++)
                                     if (view[k] === 10)
                                         count++;
                             }
-                            else if (opArgs[0] === "-c") {
+                            else if (wcMode === "-c") {
                                 count = view.byteLength;
                             }
+                            else if (wcMode === "-m") {
+                                count = byteLocale(rawState.variables) ? view.byteLength : Array.from(fileStr).length;
+                            }
+                            else if (wcMode === "-L") {
+                                count = this.wcMaxLineWidth(fileStr, byteLocale(rawState.variables));
+                            }
                             else {
-                                const trimmed = fileStr.trim();
-                                count = trimmed.length === 0 ? 0 : trimmed.split(/\s+/).length;
-                            }
-                            fileRes = (hasSingleStdinRedir || hasSingleHereStringRedir) ? String(count) : `${count} ${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 count = uEnd - uIdx;
-                                if (mode === "-d" ? count > 1 : mode === "-u" ? count === 1 : true) {
-                                    outLines.push(mode === "-c" ? `${String(count).padStart(7, " ")} ${rawLines[uIdx]}` : rawLines[uIdx]);
-                                }
-                                uIdx = uEnd;
+                                // Unicode word separators depend on locale and POSIXLY_CORRECT.
+                                // Use the maintained command for those inputs rather than JS whitespace.
+                                if (!byteLocale(rawState.variables) && view.some(byte => byte > 127))
+                                    return undefined;
+                                count = fileStr.split(/[ \t\n\r\f\v]+/).filter(Boolean).length;
                             }
-                            fileRes = outLines.join("\n");
+                            fileRes = ((hasSingleStdinRedir || hasSingleHereStringRedir) ? String(count) : `${count} ${fileArg}`) + "\n";
+                        }
+                        else if (w0Plain === "sort" && !byteLocale(rawState.variables)) {
+                            const sortRes = this.evalSyncSort(rawLines, opArgs, false);
+                            if (sortRes !== undefined)
+                                fileRes = renderLines(sortRes);
+                        }
+                        else if (w0Plain === "uniq") {
+                            const uniqRes = this.evalSyncUniq(rawLines, opArgs);
+                            if (uniqRes !== undefined)
+                                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));
+                                fileRes = this.syncBase64Encode(view) + "\n";
+                            else {
+                                const decoded = this.syncBase64DecodeBytes(fileStr);
+                                // Text-only substitutions cannot retain binary byte provenance.
+                                if (decoded.some(byte => byte === 0 || byte >= 128))
+                                    return undefined;
+                                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");
+                            fileRes = renderLines([...rawLines].reverse());
                         }
-                        else if (hasSingleHereStringRedir && w0Plain === "nl" && opArgs.length === 0) {
-                            let lineNo = 0;
-                            fileRes = rawLines.map(l => l.length === 0 ? "       " : `${String(++lineNo).padStart(6, " ")}\t${l}`).join("\n");
+                        else if (hasSingleHereStringRedir && w0Plain === "nl") {
+                            const nlRes = this.evalSyncNl(rawLines, opArgs);
+                            if (nlRes !== undefined)
+                                fileRes = renderLines(nlRes);
+                        }
+                        else if (hasSingleHereStringRedir && w0Plain === "paste") {
+                            const pasteRes = this.evalSyncPaste(rawLines, opArgs);
+                            if (pasteRes !== undefined)
+                                fileRes = renderLines(pasteRes);
+                        }
+                        else if (hasSingleHereStringRedir && w0Plain === "numfmt") {
+                            const nmRes = this.evalSyncNumfmt(rawLines, opArgs);
+                            if (nmRes !== undefined)
+                                fileRes = renderLines(nmRes);
                         }
                         if (fileRes !== undefined) {
+                            // Charge emitted bytes before substitution removes trailing newlines.
+                            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");
@@ -28435,46 +30946,17 @@ export class Runtime {
                 if (!this.isPureArgWord(cmd.words[i], rawState))
                     return undefined;
             }
-            if (w0Plain === "dirname" && cmd.words.length === 2) {
-                const wVal = this.fastValueWord(cmd.words[1], state, io, true, false, false, true, undefined, part.line);
-                if (typeof wVal !== "string" || wVal.startsWith("-") || wVal.includes("\0"))
-                    return undefined;
-                const parent = dirname(wVal);
-                let pEnd = parent.length;
-                while (pEnd > 1 && parent[pEnd - 1] === "/")
-                    pEnd--;
-                let res = parent.slice(0, pEnd);
-                const byteLength = shellValueByteLength(res) + 1;
-                while (res.endsWith("\n"))
-                    res = res.slice(0, -1);
-                const nextBytes = this.budget.bytes + byteLength;
-                if (nextBytes > this.budget.maxOutputBytesSmi && byteLength > this.budget.limits.maxOutputBytes - this.budget.bytes)
-                    this.budget.fail("maxOutputBytes");
-                this.budget.bytes = nextBytes;
-                this.budget.tick();
-                if (fnPositional !== undefined)
-                    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] : undefined);
-                const wVal1 = this.fastValueWord(pathWord, state, io, true, false, false, true, undefined, part.line);
-                if (typeof wVal1 !== "string" || wVal1.startsWith("-") || wVal1.includes("\0"))
-                    return undefined;
-                let wVal2;
-                if (suffixWord !== undefined) {
-                    const v2 = this.fastValueWord(suffixWord, state, io, true, false, false, true, undefined, part.line);
-                    if (typeof v2 !== "string" || v2.includes("\0"))
+            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, undefined, part.line);
+                    if (typeof v !== "string")
                         return undefined;
-                    wVal2 = v2;
+                    dbArgs.push(v);
                 }
-                let res = /^\/+$/u.test(wVal1) ? "/" : basename(wVal1);
-                if (wVal2 && res !== wVal2 && res.endsWith(wVal2))
-                    res = res.slice(0, -wVal2.length);
+                let res = w0Plain === "dirname" ? this.evalSyncDirname(dbArgs) : this.evalSyncBasename(dbArgs);
+                if (res === undefined)
+                    return undefined;
                 const byteLength = shellValueByteLength(res) + 1;
                 while (res.endsWith("\n"))
                     res = res.slice(0, -1);