@poe-platform/safe-bash 0.1.744 → 0.1.745

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

@@ -3771,7 +3771,7 @@ export class Runtime {
             throw new NounsetDiagnosticFailure(reason);
         }
     }
-    extractSimpleErePattern(pattern) {
+    extractSimpleErePattern(pattern, state) {
         const cached = pattern._cachedSimpleEre;
         if (cached !== undefined)
             return cached ?? undefined;
@@ -3781,8 +3781,35 @@ export class Runtime {
         }
         if (pattern.parts.length === 1) {
             const p0 = pattern.parts[0];
+            if (state !== undefined &&
+                p0.kind === "variable" &&
+                !p0.quoted &&
+                !p0.operator &&
+                !p0.substring &&
+                !p0.length &&
+                !p0.indirect &&
+                !p0.prefixNames &&
+                !p0.specialParameter &&
+                !p0.transform &&
+                getArraySelector(p0) === undefined &&
+                isShellIdentifier(p0.name) &&
+                !stateMonitor(state)?.store?.get(p0.name)) {
+                const raw = state.variables[p0.name];
+                const val = this._syncArithRawWriteOnly && this._syncArithTouched?.has(p0.name)
+                    ? raw
+                    : (raw === undefined ? undefined : (stateMonitor(state)?.values.get(p0.name, raw) ?? raw));
+                if (typeof val !== "string" || val.length === 0 || val.includes("\\") || val.includes("~"))
+                    return undefined;
+                const varCache = pattern._cachedVarEre;
+                if (varCache && varCache.text === val)
+                    return varCache;
+                const nextVarCache = { text: val, literal: false, isVar: p0.name };
+                pattern._cachedVarEre = nextVarCache;
+                return nextVarCache;
+            }
             if (p0.kind !== "text" || p0.byteValue || p0.value.includes("\\") || p0.value.includes("~")) {
-                pattern._cachedSimpleEre = null;
+                if (p0.kind !== "variable")
+                    pattern._cachedSimpleEre = null;
                 return undefined;
             }
             const res = { text: p0.value, literal: !!p0.quoted };
@@ -3803,7 +3830,7 @@ export class Runtime {
         return res;
     }
     getFastAnchoredEreRegex(pattern, state) {
-        const pat = this.extractSimpleErePattern(pattern);
+        const pat = this.extractSimpleErePattern(pattern, state);
         if (!pat || pat.literal || state.nocasematch || this.budget.limits.maxExpansionBytes !== Infinity || this.budget.limits.maxExpansionFields !== Infinity) {
             return undefined;
         }
@@ -3831,6 +3858,8 @@ export class Runtime {
                 }
             }
             if (caretOk &&
+                !pat.text.includes("|") &&
+                !/[*+?][*+?]/.test(pat.text) &&
                 /^[\^a-zA-Z0-9_.\-/:@()\[\]+?*,;=| $]+$/.test(pat.text) &&
                 !pat.text.includes("[:") &&
                 !pat.text.includes("[.") &&
@@ -3853,7 +3882,7 @@ export class Runtime {
         return patWithCache._fastAnchoredRe ?? undefined;
     }
     trySyncEre(subject, pattern, state, ignoreYield = false) {
-        const pat = this.extractSimpleErePattern(pattern);
+        const pat = this.extractSimpleErePattern(pattern, state);
         if (!pat)
             return undefined;
         const monitor = stateMonitor(state);
@@ -5820,7 +5849,7 @@ export class Runtime {
                     if (!entry.index || entry.append)
                         return false;
                     const kSrc = entry.index.source ?? entry.index.decimal;
-                    if (kSrc.length === 0 || kSrc.length > 4096 || /[$\x60\\"']/.test(kSrc))
+                    if (kSrc.length === 0 || kSrc.length > 4096 || kSrc.startsWith("~") || /[$\x60\\"']/.test(kSrc))
                         return false;
                     let val = "";
                     if (entry.value.parts.length > 0) {
@@ -5904,6 +5933,34 @@ export class Runtime {
                             }
                             continue;
                         }
+                        if (entry.value.parts.length === 1 &&
+                            !entry.value.parts[0].quoted &&
+                            (entry.value.parts[0].kind === "variable" || entry.value.parts[0].kind === "substitution") &&
+                            (rawState.variables.IFS === undefined || rawState.variables.IFS === " \t\n") &&
+                            !rawState.noglob &&
+                            this.budget.limits.maxExpansionFields === Infinity &&
+                            this.budget.limits.maxExpansionBytes === Infinity) {
+                            let unsplit;
+                            try {
+                                unsplit = this.fastValueWord(entry.value, rawState, io, false, false, false, false, undefined, diagnosticLine);
+                            }
+                            catch {
+                                return false;
+                            }
+                            if (typeof unsplit !== "string" || hasGlobOrEscape(unsplit, !!rawState.extglob))
+                                return false;
+                            const cw = entry.value;
+                            const splitWords = (cw._cachedSplitSrc === unsplit && cw._cachedSplitWords !== undefined)
+                                ? cw._cachedSplitWords
+                                : (cw._cachedSplitSrc = unsplit, cw._cachedSplitWords = unsplit.split(/[ \t\n]+/).filter(w => w.length > 0));
+                            if (splitWords.length > 1500)
+                                return false;
+                            for (let swIdx = 0; swIdx < splitWords.length; swIdx++) {
+                                const sw = splitWords[swIdx];
+                                items.push({ explicitIdx: undefined, val: sw, bLen: shellValueByteLength(sw) });
+                            }
+                            continue;
+                        }
                         if (entry.value.parts.length === 0 || !entry.value.parts.every(p => p.quoted || (p.kind === "text" && p.value.length > 0 && !p.value.includes(" ") && !p.value.includes("\t") && !p.value.includes("\n") && !p.value.includes("{") && !hasGlobOrEscape(p.value, true)))) {
                             return false;
                         }
@@ -5941,18 +5998,16 @@ export class Runtime {
                 }
                 try {
                     if (!assignment.append && target.values.size > 0) {
-                        if (!(target.values.size === keepIndices.size && target.maximum === resolved.length - 1)) {
-                            for (const k of target.values.keys()) {
-                                if (!keepIndices.has(k))
-                                    target.remove(k);
-                            }
-                            let newMax = -1;
-                            for (const k of target.values.keys()) {
-                                if (k > newMax)
-                                    newMax = k;
-                            }
-                            target.maximum = newMax;
+                        for (const k of target.values.keys()) {
+                            if (!keepIndices.has(k))
+                                target.remove(k);
                         }
+                        let newMax = -1;
+                        for (const k of target.values.keys()) {
+                            if (k > newMax)
+                                newMax = k;
+                        }
+                        target.maximum = newMax;
                     }
                     for (let i = 0; i < resolved.length; i++) {
                         const { idx, val, bLen } = resolved[i];
@@ -8804,7 +8859,7 @@ export class Runtime {
                                 return false;
                             if (isAssoc) {
                                 const kSrc = e.index ? (e.index.source ?? e.index.decimal) : "";
-                                return kSrc.length > 0 && !/[$\x60\\"']/.test(kSrc) && isNoBraceSyncAssignWord(e.value);
+                                return kSrc.length > 0 && !kSrc.startsWith("~") && !/[$\x60\\"']/.test(kSrc) && isNoBraceSyncAssignWord(e.value);
                             }
                             if (e.index !== undefined) {
                                 const kSrc = (e.index.source ?? e.index.decimal).trim();
@@ -9019,7 +9074,7 @@ export class Runtime {
                                 return false;
                             if (wantAssoc) {
                                 const kSrc = e.index ? (e.index.source ?? e.index.decimal) : "";
-                                return kSrc.length > 0 && !/[$\x60\\"']/.test(kSrc) && isNoBraceSyncAssignWord(e.value);
+                                return kSrc.length > 0 && !kSrc.startsWith("~") && !/[$\x60\\"']/.test(kSrc) && isNoBraceSyncAssignWord(e.value);
                             }
                             if (e.index !== undefined) {
                                 const kSrc = (e.index.source ?? e.index.decimal).trim();
@@ -9346,7 +9401,7 @@ export class Runtime {
                     return (e.operator === "-n" || e.operator === "-z" || e.operator === "-v" || (syncConditionalFileUnaryOps.has(e.operator) && this._isMemoryBackingFs && this.canFastMemoryRedirect && this.budget.limits.maxFileSystemOperations >= 1000 && (this._fileWrites === undefined || this._fileWrites.size === 0) && (this._outputFiles === undefined || this._outputFiles.size === 0))) && this.isPureSyncValueWord(e.operand, rawState);
                 if (e.kind === "binary") {
                     if (e.operator === "=~") {
-                        if (!this.isPureSyncValueWord(e.left, rawState) || !this.extractSimpleErePattern(e.right) || rawState.readonlyVariables?.has("BASH_REMATCH") || rawState.exported.has("BASH_REMATCH") || hasUnpreparedLocal(rawState, "BASH_REMATCH"))
+                        if (!this.isPureSyncValueWord(e.left, rawState) || !this.extractSimpleErePattern(e.right, rawState) || rawState.readonlyVariables?.has("BASH_REMATCH") || rawState.exported.has("BASH_REMATCH") || hasUnpreparedLocal(rawState, "BASH_REMATCH"))
                             return false;
                         const mon = stateMonitor(rawState);
                         if (!mon || (this.budget.limits.maxExpansionBytes !== Infinity || this.budget.limits.maxExpansionFields !== Infinity) || mon.hasOverlay("BASH_REMATCH"))
@@ -9721,7 +9776,7 @@ export class Runtime {
             // Matching publishes BASH_REMATCH. A sibling may still require fallback,
             // so only a standalone match can be attempted without replaying writes.
             if (expr.operator === "=~")
-                return depth === 0 && this.extractSimpleErePattern(expr.right) !== undefined;
+                return depth === 0 && this.extractSimpleErePattern(expr.right, rawState) !== undefined;
             if (expr.operator === "==" || expr.operator === "=" || expr.operator === "!=") {
                 if (expr.right.parts.length > 0 && expr.right.parts.every(p => p.quoted))
                     return true;
@@ -9845,7 +9900,7 @@ export class Runtime {
             if (expr.operator === "=~") {
                 if (depth !== 0)
                     return undefined;
-                if (!this.extractSimpleErePattern(expr.right))
+                if (!this.extractSimpleErePattern(expr.right, rawState))
                     return undefined;
                 let subject;
                 try {
@@ -11202,7 +11257,7 @@ export class Runtime {
                     catch {
                         scanArgs = undefined;
                     }
-                    if (typeof optstring === "string" && scanArgs !== undefined) {
+                    if (typeof optstring === "string" && (!optstring.startsWith("-") || optstring === "-") && scanArgs !== undefined) {
                         rawState.getopts ??= cloneGetoptsBinding(rawState);
                         const res = scanGetoptsSync(rawState.getopts.cursor, optstring, scanArgs);
                         if (res !== undefined) {
@@ -12279,10 +12334,11 @@ export class Runtime {
                     const ops = [];
                     for (let ui = uStart; ui < command.words.length; ui++) {
                         const wu = command.words[ui];
+                        const canSkipGlobUnset = Boolean(wu.parts[0]?.quoted || rawState.noglob || (!rawState.nullglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0));
                         let tExpanded;
                         try {
-                            const fv = this.fastValueWord(wu, rawState, io, true, false, false, true, undefined, diagnosticLine);
-                            if (typeof fv === "string")
+                            const fv = this.fastValueWord(wu, rawState, io, !canSkipGlobUnset, false, false, true, undefined, diagnosticLine);
+                            if (typeof fv === "string" && (!canSkipGlobUnset || (!fv.includes(" ") && !fv.includes("\t") && !fv.includes("\n"))))
                                 tExpanded = fv;
                         }
                         catch { }
@@ -13515,8 +13571,42 @@ export class Runtime {
                 // as loop state changes. Decide before the loop produces any effects.
                 if (this._syncLoopFnCheckDepth > 0 && (part.substring || getArraySelector(part)?.kind === "element"))
                     return false;
-                if (part.prefixNames !== undefined || part.transform !== undefined)
-                    return false;
+                if (part.prefixNames !== undefined) {
+                    if (part.indirect ||
+                        part.specialParameter ||
+                        part.length ||
+                        part.substring ||
+                        part.transform !== undefined ||
+                        part.operator !== undefined ||
+                        getArraySelector(part) !== undefined ||
+                        this.budget.limits.maxExpansionFields !== Infinity ||
+                        this.budget.limits.maxExpansionBytes !== Infinity ||
+                        !isShellIdentifier(part.name)) {
+                        return false;
+                    }
+                    continue;
+                }
+                if (part.transform !== undefined) {
+                    if ((part.transform !== "U" && part.transform !== "L" && part.transform !== "u" && (part.transform !== "Q" || byteLocale(rawState.variables))) ||
+                        part.indirect ||
+                        part.specialParameter ||
+                        part.length ||
+                        part.substring ||
+                        part.operator !== undefined ||
+                        getArraySelector(part) !== undefined ||
+                        this.budget.limits.maxExpansionBytes !== Infinity ||
+                        !isShellIdentifier(part.name) ||
+                        stateMonitor(rawState)?.store?.get(part.name) ||
+                        part.name === "PIPESTATUS" ||
+                        part.name === "LINENO" ||
+                        part.name === "_" ||
+                        part.name === "FUNCNAME" ||
+                        part.name === "DIRSTACK" ||
+                        (rawState.nounset && rawState.variables[part.name] === undefined)) {
+                        return false;
+                    }
+                    continue;
+                }
                 if (!part.indirect && !part.prefixNames && !part.length && !part.substring && !part.transform && part.operator === undefined && getArraySelector(part) === undefined && (part.name === "?" || part.name === "#" || (part.name.length === 1 && part.name >= "1" && part.name <= "9"))) {
                     if (rawState.nounset && part.name >= "1" && part.name <= "9" && rawState.positional[part.name.charCodeAt(0) - 49] === undefined)
                         return false;
@@ -13691,11 +13781,12 @@ export class Runtime {
                     !cmd.redirects[0].move &&
                     !cmd.redirects[0].document &&
                     this.isPureSyncValueWord(cmd.redirects[0].target, rawState);
-                if (p.commands.length === 1 && (cmd.kind === "for" || cmd.kind === "arithmetic-for") && cmd.redirects.length === 0) {
-                    if (cmd.body.lists.length === 1 && !cmd.body.lists[0].terminator && cmd.body.lists[0].pipelines.every(pl => pl.commands.length === 1 && pl.commands[0].kind === "simple" && pl.commands[0].redirects.length === 0 && (pl.commands[0].words[0]?.plain === "echo" ? this.isSyncEchoCallOk(pl.commands[0], rawState) : (pl.commands[0].words[0]?.plain === "printf" && pl.commands[0].words[1]?.plain !== "-v" && this.isSyncPrintfCallOk(pl.commands[0], 1, rawState, cmd.kind === "for" ? cmd.name : undefined))))) {
-                        continue;
-                    }
+                // Loop substitutions require a real subshell: header admission can
+                // decline at runtime, and induction writes also change export attributes.
+                if (cmd.kind === "for" || cmd.kind === "arithmetic-for" || cmd.kind === "while")
                     return false;
+                if (p.commands.length === 1 && (cmd.kind === "if" || cmd.kind === "case") && this.isPureSyncSubIfOrCase(cmd, rawState)) {
+                    continue;
                 }
                 if (cmd.kind !== "simple" || (cmd.redirects.length > 0 && !hasSingleStdinRedir && !hasSingleHereStringRedir) || cmd.words.length === 0)
                     return false;
@@ -13748,14 +13839,15 @@ export class Runtime {
                     w0Plain === "cut" ||
                     w0Plain === "wc" ||
                     w0Plain === "sort" ||
+                    w0Plain === "uniq" ||
                     w0Plain === "tr" ||
                     (hasSingleHereStringRedir && (w0Plain === "base64" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl"));
-                if (!w0Plain || (w0Plain !== "printf" && w0Plain !== "echo" && w0Plain !== "dirname" && w0Plain !== "basename" && w0Plain !== "seq" && !isFileCommand) || rawState.functions.has(w0Plain) || rawState.extensions?.builtins.has(w0Plain))
+                const def = w0Plain ? (this.commands.get(w0Plain) ?? ((w0Plain === "rev" || w0Plain === "tac") ? 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;
-                const def = this.commands.get(w0Plain);
-                if (!def || (w0Plain === "printf" ? def.execute !== printfCommand.execute : w0Plain === "echo" ? !defaultEchoExecutors.has(def.execute) : w0Plain === "seq" ? (!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") ? (!builtInDirectContextExecutors.has(def.execute) && (customRegisteredCommands.has(def.execute) || customRegisteredRegistries.has(this.commands))) : !builtInDirectContextExecutors.has(def.execute))
                     return false;
                 if (!cmd.words.slice(1).every(w => this.isPureSyncValueWord(w, rawState)))
                     return false;
@@ -13772,7 +13864,10 @@ export class Runtime {
                         if (!vCheck || vCheck.byteLength > 16384 || vCheck.includes(0))
                             return false;
                     }
-                    const opCount = (hasSingleStdinRedir || hasSingleHereStringRedir) ? cmd.words.length - 1 : cmd.words.length - 2;
+                    const opWords = (hasSingleStdinRedir || hasSingleHereStringRedir) ? cmd.words.slice(1) : cmd.words.slice(1, -1);
+                    const opCount = opWords.length;
+                    const op0 = opWords[0]?.plain;
+                    const op1 = opWords[1]?.plain;
                     if (w0Plain === "cat" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl") {
                         if (opCount !== 0)
                             return false;
@@ -13780,18 +13875,61 @@ export class Runtime {
                     else {
                         if (p.commands.length !== 1 && !hasSingleHereStringRedir)
                             return false;
-                        if ((w0Plain === "head" || w0Plain === "tail") && opCount > 2)
-                            return false;
-                        if ((w0Plain === "jq" || w0Plain === "awk" || w0Plain === "grep" || w0Plain === "sed") && (opCount < 1 || opCount > 3))
-                            return false;
-                        if (w0Plain === "cut" && (opCount < 1 || opCount > 4))
-                            return false;
-                        if (w0Plain === "wc" && opCount !== 1)
-                            return false;
-                        if ((w0Plain === "sort" || w0Plain === "base64") && (opCount > 1 || (w0Plain === "sort" && byteLocale(rawState.variables))))
-                            return false;
-                        if (w0Plain === "tr" && opCount !== 2)
-                            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));
+                            if (!validHT)
+                                return false;
+                        }
+                        const plainOps = [];
+                        for (let oi = 0; oi < opCount; oi++) {
+                            const ow = opWords[oi];
+                            const pw = ow.plain ?? (ow.parts.length > 0 && ow.parts.every(pt => pt.kind === "text") ? ow.parts.map(pt => pt.value).join("") : undefined);
+                            if (pw === undefined)
+                                break;
+                            plainOps.push(pw);
+                        }
+                        if (w0Plain === "cut") {
+                            if (plainOps.length !== opCount || this.evalSyncCut([], plainOps, byteLocale(rawState.variables)) === undefined)
+                                return false;
+                        }
+                        else if (w0Plain === "sed") {
+                            if (plainOps.length !== opCount || this.evalSyncSed([], plainOps) === undefined)
+                                return false;
+                        }
+                        else if (w0Plain === "grep") {
+                            if (plainOps.length !== opCount || this.evalSyncGrep([], plainOps, Boolean(rawState.errexit)) === undefined)
+                                return false;
+                        }
+                        else if (w0Plain === "awk") {
+                            if (plainOps.length !== opCount || this.evalSyncAwk([], plainOps) === undefined)
+                                return false;
+                        }
+                        else if (w0Plain === "jq") {
+                            if (plainOps.length !== opCount || this.evalSyncJq("null", plainOps) === undefined)
+                                return false;
+                        }
+                        else if (w0Plain === "wc") {
+                            if (opCount !== 1 || (op0 !== "-l" && op0 !== "-c" && op0 !== "-w"))
+                                return false;
+                        }
+                        else if (w0Plain === "sort") {
+                            if (byteLocale(rawState.variables) || opCount > 1 || (opCount === 1 && op0 !== "-r" && op0 !== "-u" && op0 !== "-n" && op0 !== "-rn" && op0 !== "-nr" && op0 !== "-ru" && op0 !== "-ur"))
+                                return false;
+                        }
+                        else if (w0Plain === "uniq") {
+                            if (opCount > 1 || (opCount === 1 && op0 !== "-d" && op0 !== "-u" && op0 !== "-c"))
+                                return false;
+                        }
+                        else if (w0Plain === "base64") {
+                            if (opCount > 1 || (opCount === 1 && op0 !== "-d" && op0 !== "--decode"))
+                                return false;
+                        }
+                        else if (w0Plain === "tr") {
+                            if (plainOps.length !== opCount || this.evalSyncTr("", plainOps) === undefined)
+                                return false;
+                        }
                     }
                 }
                 if (w0Plain === "printf") {
@@ -13833,6 +13971,8 @@ 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;
                     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)
@@ -13899,9 +14039,9 @@ export class Runtime {
                                 return false;
                         }
                         if (sName === "jq") {
-                            const jqFilter = sPlainArgs.length === 1 ? sPlainArgs[0] : (sPlainArgs.length === 2 && (sPlainArgs[0] === "-r" || sPlainArgs[0] === "--raw-output") ? sPlainArgs[1] : undefined);
-                            if (!jqFilter || !/^\.[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/.test(jqFilter))
-                                return false;
+                            // JSON types are runtime inputs: the speculative evaluator may
+                            // refuse array indexing and must leave diagnostics to jq.
+                            return false;
                         }
                         if (sName === "base64") {
                             if (sPlainArgs.length > 1 || (sPlainArgs.length === 1 && sPlainArgs[0] !== "-d" && sPlainArgs[0] !== "--decode"))
@@ -13978,6 +14118,53 @@ export class Runtime {
         }
         return undefined;
     }
+    execSyncUnsetStep(step, rawState, io, monitor, touched) {
+        const uVars = step.unsetVars;
+        const store = monitor.store;
+        let lastExpanded = "";
+        for (let ui = 0; ui < uVars.length; ui++) {
+            const uvn = uVars[ui];
+            if (uvn.charCodeAt(0) === 64) {
+                const wIdx = Number(uvn.slice(1));
+                const wu = step.cmd.words[wIdx];
+                const tExpanded = this.fastValueWord(wu, rawState, io, false, false, false, false, 0, step.line);
+                lastExpanded = tExpanded;
+                const bracket = tExpanded.indexOf("[");
+                if (bracket > 0 && tExpanded.endsWith("]") && store) {
+                    const arrName = tExpanded.slice(0, bracket);
+                    const subStr = tExpanded.slice(bracket + 1, -1);
+                    const binding = store.get(arrName);
+                    if (binding) {
+                        if (binding.associative) {
+                            const id = fastStringHexIdentity(subStr);
+                            const existingKey = binding.keys.get(id);
+                            if (existingKey !== undefined) {
+                                binding.remove(existingKey.index);
+                                store.changed(monitor.chargeInternal(syncRestorationCharge, syncRestorationTickets), arrName);
+                            }
+                        }
+                        else {
+                            const idxNum = /^(?:0|[1-9][0-9]{0,8})$/.test(subStr)
+                                ? Number(subStr)
+                                : resolveSimpleArithOperand(subStr, rawState, monitor, store, this._syncArithRawWriteOnly ? this._syncArithTouched : undefined);
+                            const resolvedIdx = idxNum !== undefined ? (idxNum >= 0 ? idxNum : binding.maximum + 1 + idxNum) : undefined;
+                            if (resolvedIdx !== undefined && resolvedIdx >= 0 && binding.values.has(resolvedIdx)) {
+                                binding.remove(resolvedIdx);
+                                store.changed(monitor.chargeInternal(syncRestorationCharge, syncRestorationTickets), arrName);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                delete rawState.variables[uvn];
+                monitor.proxy.exported.delete(uvn);
+                touched.add(uvn);
+                lastExpanded = uvn;
+            }
+        }
+        return lastExpanded;
+    }
     extractSyncUnsetVars(cmd, rawState) {
         if (this._syncLoopFnCheckDepth > 0 || cmd.redirects.length !== 0 || cmd.words.length < 2 || cmd.words.length > 16 || cmd.words[0].plain !== "unset")
             return undefined;
@@ -13998,6 +14185,26 @@ export class Runtime {
             if (vn && startIdx === 1 && hasShellFunction(rawState, vn))
                 return undefined;
             if (!vn || vn.startsWith("-") || !isShellIdentifier(vn) || controlNames.has(vn) || vn === "OPTIND" || rawState.readonlyVariables?.has(vn) || rawState.variableAttributes?.get(vn) || store?.get(vn) || stateMonitor(rawState)?.hasOverlay(vn) || rawState.locals.some(f => f.has(vn))) {
+                const wu = cmd.words[i];
+                const p0 = wu.parts[0];
+                const pLast = wu.parts[wu.parts.length - 1];
+                const m = p0?.kind === "text" ? /^([a-zA-Z_][a-zA-Z0-9_]*)\[/.exec(p0.value) : undefined;
+                const arrName = m?.[1];
+                const b = arrName ? store?.get(arrName) : undefined;
+                if (arrName &&
+                    b &&
+                    b.references === 1 &&
+                    !store.watches.has(arrName) &&
+                    !rawState.readonlyVariables?.has(arrName) &&
+                    !hasUnpreparedLocal(rawState, arrName) &&
+                    !stateMonitor(rawState)?.hasOverlay(arrName) &&
+                    pLast?.kind === "text" &&
+                    pLast.value.endsWith("]") &&
+                    this.isPureSyncValueWord(wu, rawState) &&
+                    (p0.quoted || rawState.noglob || (!rawState.nullglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0))) {
+                    vars.push(`@${i}`);
+                    continue;
+                }
                 return undefined;
             }
             vars.push(vn);
@@ -14026,14 +14233,11 @@ export class Runtime {
             return undefined;
         if (w0Plain === "local" && rawState.locals.length === 0)
             return undefined;
-        let startIdx = 1;
-        let attr;
+        const startIdx = 1;
         const w1Plain = cmd.words[1]?.plain;
         if (w0Plain !== "export" && (w1Plain === "-u" || w1Plain === "-l" || w1Plain === "-i")) {
-            if (cmd.words.length < 3)
-                return undefined;
-            attr = w1Plain.slice(1);
-            startIdx = 2;
+            // Attribute changes invalidate the assumptions used to plan later loop steps.
+            return undefined;
         }
         const store = stateMonitor(rawState)?.store;
         const items = [];
@@ -14069,7 +14273,7 @@ export class Runtime {
                 return undefined;
             }
         }
-        return { kind: w0Plain === "export" ? "export" : w0Plain === "local" ? "local" : "declare", attr, items };
+        return { kind: w0Plain === "export" ? "export" : w0Plain === "local" ? "local" : "declare", items };
     }
     isQuotedAtWord(w) {
         const p0 = w.parts.length === 1 ? w.parts[0] : (w.parts.length === 2 && w.parts[0].kind === "text" && w.parts[0].value === "" ? w.parts[1] : undefined);
@@ -14082,22 +14286,14 @@ export class Runtime {
             return false;
         if (words.length === 1 && this.isQuotedAtWord(words[0]))
             return true;
-        const store = stateMonitor(rawState)?.store;
+        // Unquoted expansions need splitting and globbing against the state at
+        // execution time. The loop body can change IFS or the expansion value.
         if (words.length === 1) {
             const w0 = words[0];
             if (rawState.braceexpand !== false && tryFastExpandBraceRange(w0, this.budget, undefined) !== undefined)
                 return true;
             if (io !== undefined && this.tryExpandSyncArrayMembersWord(w0, rawState, io, line) !== undefined)
                 return true;
-            const p0 = w0.parts.length === 1 ? w0.parts[0] : (w0.parts.length === 2 && w0.parts[0].kind === "text" && w0.parts[0].value === "" ? w0.parts[1] : undefined);
-            if (p0 && (rawState.variables.IFS === undefined || rawState.variables.IFS === " \t\n") && !rawState.noglob) {
-                if (p0.kind === "variable" && !p0.quoted && !p0.indirect && !p0.prefixNames && !p0.length && !p0.substring && !p0.transform && p0.operator === undefined && getArraySelector(p0) === undefined && isShellIdentifier(p0.name) && !store?.get(p0.name) && !stateMonitor(rawState)?.hasOverlay(p0.name)) {
-                    return true;
-                }
-                if (p0.kind === "substitution" && !p0.quoted && this.isPureSyncValueWord(w0, rawState)) {
-                    return true;
-                }
-            }
         }
         const stdIfs = (rawState.variables.IFS ?? " \t\n") === " \t\n";
         for (let i = 0; i < words.length; i++) {
@@ -14134,9 +14330,10 @@ export class Runtime {
                 return arrMembers;
             const p0 = w0.parts.length === 1 ? w0.parts[0] : (w0.parts.length === 2 && w0.parts[0].kind === "text" && w0.parts[0].value === "" ? w0.parts[1] : undefined);
             if (p0 && !p0.quoted && (rawState.variables.IFS === undefined || rawState.variables.IFS === " \t\n") && !rawState.noglob) {
-                if (p0.kind === "variable" && !p0.indirect && !p0.prefixNames && !p0.length && !p0.substring && !p0.transform && p0.operator === undefined && getArraySelector(p0) === undefined) {
-                    const curRaw = rawState.variables[p0.name];
-                    const rawVal = curRaw === undefined ? "" : (touched.has(p0.name) ? curRaw : (monitor.values.get(p0.name, curRaw) ?? curRaw));
+                if (p0.kind === "variable" && !p0.indirect && !p0.prefixNames && !p0.length && !p0.transform && getArraySelector(p0) === undefined) {
+                    const rawVal = (p0.operator === undefined && !p0.substring)
+                        ? (rawState.variables[p0.name] === undefined ? "" : (touched.has(p0.name) ? rawState.variables[p0.name] : (monitor.values.get(p0.name, rawState.variables[p0.name]) ?? rawState.variables[p0.name])))
+                        : this.fastValueWord(w0, rawState, io, false, false, false, false, 0, line);
                     if (typeof rawVal === "string") {
                         const cw = w0;
                         if (cw._cachedSplitSrc === rawVal && cw._cachedSplitWords !== undefined)
@@ -14250,6 +14447,8 @@ export class Runtime {
         let rawMode = false;
         let arrayTarget;
         let delimChar;
+        let maxChars;
+        let exactChars;
         if (isMapfile) {
             rawMode = true;
             arrayTarget = cmd.words[2]?.plain ?? "MAPFILE";
@@ -14280,6 +14479,25 @@ export class Runtime {
                     delimChar = dPlain;
                     argIdx += 2;
                 }
+                else if (p === "-n" || p === "-rn" || p === "-nr" || p === "-N" || p === "-rN" || p === "-Nr") {
+                    if (p.includes("r"))
+                        rawMode = true;
+                    exactChars = p.includes("N");
+                    const nPlain = cmd.words[argIdx + 1]?.plain;
+                    if (!nPlain || !/^[1-9][0-9]{0,5}$/.test(nPlain) || byteLocale(rawState.variables))
+                        return undefined;
+                    maxChars = Number(nPlain);
+                    argIdx += 2;
+                }
+                else if ((p.startsWith("-n") || p.startsWith("-rn") || p.startsWith("-N") || p.startsWith("-rN")) && /^[1-9][0-9]{0,5}$/.test(p.slice(p.startsWith("-r") ? 3 : 2))) {
+                    if (byteLocale(rawState.variables))
+                        return undefined;
+                    if (p.startsWith("-r"))
+                        rawMode = true;
+                    exactChars = p.includes("N");
+                    maxChars = Number(p.slice(p.startsWith("-r") ? 3 : 2));
+                    argIdx++;
+                }
                 else if (p === "-ra" || p === "-ar" || p === "-a") {
                     if (p.includes("r"))
                         rawMode = true;
@@ -14297,7 +14515,7 @@ export class Runtime {
                     return undefined;
                 }
             }
-            if (!rawMode || (delimChar !== undefined && arrayTarget !== undefined))
+            if (!rawMode || ((delimChar !== undefined || maxChars !== undefined) && arrayTarget !== undefined))
                 return undefined;
         }
         const monitor = stateMonitor(rawState);
@@ -14317,36 +14535,9 @@ export class Runtime {
                 return undefined;
             }
             const arrStore = store ?? requireArrays(rawState);
-            let existingArr = arrStore.get(arrayTarget);
-            if (existingArr && (existingArr.associative || existingArr.references !== 1 || arrStore.watches.has(arrayTarget)))
-                return undefined;
-            if (!existingArr && !arrStore.watches.has(arrayTarget)) {
-                const recTickets = arrStore.owner.charge({ generation: true, version: true, epoch: true, work: 8 });
-                const recBinding = arrStore.takeRecycled(arrayTarget, false, recTickets);
-                if (recBinding) {
-                    if (monitor)
-                        monitor.epoch = recTickets.epoch;
-                    existingArr = recBinding;
-                }
-                else {
-                    try {
-                        const created = IndexedBinding.create(arrStore.owner, false);
-                        const prepared = arrStore.prepareExistingName(arrayTarget, shellValueByteLength(arrayTarget), arrStore.owner, this.signal);
-                        if (prepared) {
-                            const initTickets = arrStore.owner.charge({ generation: true, version: true, epoch: true, work: 8 });
-                            arrStore.publish(arrayTarget, created, initTickets, prepared, false, arrStore.owner);
-                            if (monitor)
-                                monitor.epoch = initTickets.epoch;
-                            existingArr = created;
-                        }
-                        else {
-                            void created.release();
-                        }
-                    }
-                    catch { }
-                }
-            }
-            if (!existingArr)
+            // Planning must not publish bindings: the read may never execute.
+            const existingArr = arrStore.get(arrayTarget);
+            if (!existingArr || existingArr.associative || existingArr.references !== 1 || arrStore.watches.has(arrayTarget))
                 return undefined;
             return { ifsWord, varNames: [], arrayTarget, ...(isMapfile ? { isMapfile: true } : {}), isBareReply: false, inputWord: r0.target };
         }
@@ -14364,7 +14555,67 @@ export class Runtime {
                 return undefined;
             varNames.push("REPLY");
         }
-        return { ifsWord, varNames, isBareReply, inputWord: r0.target, ...(delimChar !== undefined ? { delimChar } : {}) };
+        return { ifsWord, varNames, isBareReply, inputWord: r0.target, ...(delimChar !== undefined ? { delimChar } : {}), ...(maxChars !== undefined ? { maxChars } : {}), ...(exactChars !== undefined ? { exactChars } : {}) };
+    }
+    isPureSyncSubIfOrCase(cmd, rawState) {
+        if (cmd.redirects.length !== 0)
+            return false;
+        const isSimpleEchoOrPrintf = (s) => {
+            if (s.lists.length !== 1 || s.lists[0].terminator || s.lists[0].pipelines.length !== 1)
+                return false;
+            const pl = s.lists[0].pipelines[0];
+            if (pl.negate || pl.commands.length !== 1)
+                return false;
+            const sc = pl.commands[0];
+            if (sc.kind !== "simple" || sc.redirects.length !== 0 || sc.words.length === 0)
+                return false;
+            const w0 = sc.words[0]?.plain;
+            if (w0 === "echo")
+                return this.isSyncEchoCallOk(sc, rawState);
+            if (w0 === "printf" && sc.words[1]?.plain !== "-v")
+                return this.isSyncPrintfCallOk(sc, 1, rawState);
+            return false;
+        };
+        if (cmd.kind === "if") {
+            for (const br of cmd.branches) {
+                if (br.condition.lists.length !== 1 || br.condition.lists[0].terminator || br.condition.lists[0].pipelines.length !== 1)
+                    return false;
+                const bp = br.condition.lists[0].pipelines[0];
+                if (bp.negate || bp.commands.length !== 1)
+                    return false;
+                const bc = bp.commands[0];
+                if (bc.kind === "arithmetic") {
+                    if (bc.redirects.length !== 0 || bc.expression.error || bc.expression.hasMutation || bc.expression.hasSubscript || !isSafeSmiProgram(bc.expression) || !this.canSyncArithmeticWithoutFault(bc.expression.tree, rawState, bc.line ?? 1))
+                        return false;
+                }
+                else if (bc.kind === "conditional") {
+                    if (bc.redirects.length !== 0 || rawState.nocasematch || byteLocale(rawState.variables) || !this.canSyncConditional(bc.expression, 0, rawState))
+                        return false;
+                    if (bc.expression.kind === "binary" && bc.expression.operator === "=~")
+                        return false;
+                }
+                else if (!this.extractPosixBracketCondExpr(bc, rawState, true, br.body)) {
+                    return false;
+                }
+                if (!isSimpleEchoOrPrintf(br.body))
+                    return false;
+            }
+            if (cmd.otherwise && !isSimpleEchoOrPrintf(cmd.otherwise))
+                return false;
+            return true;
+        }
+        if (rawState.nocasematch || rawState.extglob || !this.isPureSyncValueWord(cmd.subject, rawState))
+            return false;
+        const work = { remaining: 4096, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+        for (const cl of cmd.clauses) {
+            if (cl.terminator !== ";;" && cl.terminator !== "esac")
+                return false;
+            if (!cl.patterns.every(pw => pw.plain !== undefined && tryMatchesPatternSync(pw.plain, "", work, false, false) !== undefined))
+                return false;
+            if (!isSimpleEchoOrPrintf(cl.body))
+                return false;
+        }
+        return true;
     }
     canSyncLoopBody(script, rawState, io, nested = false, printfInductionName) {
         if (script.lists.length === 0)
@@ -14388,8 +14639,13 @@ export class Runtime {
                         if (e.kind === "unary")
                             return (e.operator === "-n" || e.operator === "-z" || e.operator === "-v" || (syncConditionalFileUnaryOps.has(e.operator) && this._isMemoryBackingFs && this.canFastMemoryRedirect && this.budget.limits.maxFileSystemOperations >= 1000 && (this._fileWrites === undefined || this._fileWrites.size === 0) && (this._outputFiles === undefined || this._outputFiles.size === 0))) && this.isPureSyncValueWord(e.operand, rawState);
                         if (e.kind === "binary") {
-                            if (e.operator === "=~")
+                            if (e.operator === "=~") {
+                                const patInfo = this.extractSimpleErePattern(e.right, rawState);
+                                // A variable pattern can change through expansions or called functions.
+                                if (patInfo?.isVar)
+                                    return false;
                                 return this.isPureSyncValueWord(e.left, rawState) && this.getFastAnchoredEreRegex(e.right, rawState) !== undefined && !rawState.readonlyVariables?.has("BASH_REMATCH") && !rawState.exported.has("BASH_REMATCH") && !stateMonitor(rawState)?.hasOverlay("BASH_REMATCH") && !(store ?? requireArrays(rawState))?.watches.has("BASH_REMATCH");
+                            }
                             return this.isPureSyncValueWord(e.left, rawState) && (e.operator === "==" || e.operator === "=" || e.operator === "!=" ? this.canSyncPatternWordParts(e.right, rawState) : this.isPureSyncValueWord(e.right, rawState));
                         }
                         if (e.kind === "not")
@@ -14642,7 +14898,8 @@ export class Runtime {
                     }
                     return false;
                 }
-                if (this.extractSyncUnsetVars(cmd, rawState) !== undefined || this.extractSyncLocalDeclStep(cmd, rawState) !== undefined || this.extractSyncShiftCount(cmd, rawState) !== undefined) {
+                const declaration = this.extractSyncLocalDeclStep(cmd, rawState);
+                if (this.extractSyncUnsetVars(cmd, rawState) !== undefined || declaration !== undefined || this.extractSyncShiftCount(cmd, rawState) !== undefined) {
                     continue;
                 }
                 if (cmd.redirects.length === 0 && cmd.words.length >= 1 && cmd.words.length <= 16 && this.extractSyncLoopFnSpec(cmd, rawState, io) !== undefined) {
@@ -14668,56 +14925,39 @@ export class Runtime {
                         return false;
                     if (hasUnpreparedLocals(rawState))
                         return false;
-                    let curArr = store?.get(arrAssign.name);
-                    if (!curArr &&
-                        (arrAssign.kind === "compound" || arrAssign.kind === "element") &&
-                        this.budget.limits.maxExpansionBytes === Infinity &&
-                        this.budget.limits.maxExpansionFields === Infinity &&
-                        isShellIdentifier(arrAssign.name) &&
-                        rawState.variables[arrAssign.name] === undefined &&
-                        !rawState.readonlyVariables?.has(arrAssign.name) &&
-                        !rawState.exported.has(arrAssign.name) &&
-                        !rawState.variableAttributes?.get(arrAssign.name) &&
-                        !controlNames.has(arrAssign.name) &&
-                        !stateMonitor(rawState)?.hasOverlay(arrAssign.name)) {
-                        const monitor = stateMonitor(rawState);
-                        const arrStore = monitor?.store ?? (monitor ? requireArrays(rawState) : undefined);
-                        if (arrStore && !arrStore.watches.has(arrAssign.name)) {
-                            const recTickets = arrStore.owner.charge({ generation: true, version: true, epoch: true, work: 8 });
-                            const recBinding = arrStore.takeRecycled(arrAssign.name, false, recTickets);
-                            if (recBinding) {
-                                if (monitor)
-                                    monitor.epoch = recTickets.epoch;
-                                curArr = recBinding;
-                            }
-                            else {
-                                try {
-                                    const created = IndexedBinding.create(arrStore.owner, false);
-                                    const prepared = arrStore.prepareExistingName(arrAssign.name, shellValueByteLength(arrAssign.name), arrStore.owner, this.signal);
-                                    if (prepared) {
-                                        const initTickets = arrStore.owner.charge({ generation: true, version: true, epoch: true, work: 8 });
-                                        arrStore.publish(arrAssign.name, created, initTickets, prepared, false, arrStore.owner);
-                                        if (monitor)
-                                            monitor.epoch = initTickets.epoch;
-                                        curArr = created;
-                                    }
-                                    else {
-                                        void created.release();
-                                    }
-                                }
-                                catch { }
-                            }
-                        }
-                    }
+                    // Eligibility checks must not create bindings: the loop may never run.
+                    // Element subscripts need the normal arithmetic and relative-index evaluator.
+                    if (arrAssign.kind === "element")
+                        return false;
+                    const curArr = store?.get(arrAssign.name);
                     const activeArrStore = store ?? stateMonitor(rawState)?.store;
                     if (!curArr || curArr.references !== 1 || activeArrStore?.watches.has(arrAssign.name) || rawState.readonlyVariables?.has(arrAssign.name) || rawState.exported.has(arrAssign.name) || controlNames.has(arrAssign.name)) {
                         return false;
                     }
-                    if (arrAssign.kind === "compound" && !curArr.associative && arrAssign.entries.length <= 16 && arrAssign.entries.every(e => !e.index && !e.append)) {
+                    if (arrAssign.kind === "compound" && arrAssign.entries.length <= 16 && arrAssign.entries.every(e => !e.append)) {
                         let allEntriesOk = true;
                         for (let ei = 0; ei < arrAssign.entries.length; ei++) {
-                            const ev = arrAssign.entries[ei].value;
-                            if (!this.isPureSyncValueWord(ev, rawState) || !ev.parts.every(p => p.quoted || (p.kind === "text" && p.value.length > 0 && !p.value.includes(" ") && !p.value.includes("\t") && !p.value.includes("\n") && !p.value.includes("{") && !hasGlobOrEscape(p.value, true)))) {
+                            const entry = arrAssign.entries[ei];
+                            const ev = entry.value;
+                            if (curArr.associative) {
+                                const kSrc = entry.index ? (entry.index.source ?? entry.index.decimal) : "";
+                                if (kSrc.length === 0 || kSrc.length > 4096 || kSrc.startsWith("~") || /[$\x60\\"']/.test(kSrc) || !this.isPureSyncValueWord(ev, rawState)) {
+                                    allEntriesOk = false;
+                                    break;
+                                }
+                                continue;
+                            }
+                            if (entry.index !== undefined) {
+                                const kSrc = (entry.index.source ?? entry.index.decimal).trim();
+                                const original = compoundEntryWords.get(entry);
+                                const hasBraceInOriginal = rawState.braceexpand !== false && Boolean(original?.parts.some(p => p.kind === "text" && !p.quoted && p.value.includes("{")));
+                                if (!/^(?:0|[1-9][0-9]{0,8})$/.test(kSrc) || hasBraceInOriginal || (rawState.braceexpand !== false && ev.parts.some(p => !p.quoted && p.kind === "text" && p.value.includes("{"))) || !this.isPureSyncValueWord(ev, rawState)) {
+                                    allEntriesOk = false;
+                                    break;
+                                }
+                                continue;
+                            }
+                            if (!this.isPureSyncValueWord(ev, rawState) || (!ev.parts.every(p => p.quoted || (p.kind === "text" && p.value.length > 0 && !p.value.includes(" ") && !p.value.includes("\t") && !p.value.includes("\n") && !p.value.includes("{") && !hasGlobOrEscape(p.value, true))))) {
                                 allEntriesOk = false;
                                 break;
                             }
@@ -14726,19 +14966,6 @@ export class Runtime {
                             continue;
                         return false;
                     }
-                    if (arrAssign.kind === "element" && (!arrAssign.append || this.budget.limits.maxExpansionBytes === Infinity) && curArr.associative) {
-                        const kSrc = arrAssign.index.source ?? arrAssign.index.decimal;
-                        if (kSrc.trim().length > 0 && !kSrc.includes("`") && !kSrc.includes("$(") && this.isPureSyncValueWord(arrAssign.value, rawState))
-                            continue;
-                        return false;
-                    }
-                    if (arrAssign.kind === "element" && !curArr.associative) {
-                        const subSrc = (arrAssign.index.source ?? arrAssign.index.decimal).trim();
-                        if (subSrc.length > 0 && subSrc.length <= 64 && /^[$a-zA-Z0-9_ +*-]+$/.test(subSrc) && !subSrc.includes("/") && !subSrc.includes("%") && !subSrc.includes("=") && !subSrc.includes("++") && !subSrc.includes("--") && this.isPureSyncValueWord(arrAssign.value, rawState)) {
-                            continue;
-                        }
-                        return false;
-                    }
                     return false;
                 }
                 const assignment = this.assignment(w0);
@@ -15194,6 +15421,8 @@ export class Runtime {
         return 0;
     }
     trySyncLoop(command, pipeline, rawState, monitor, store, existing, elem0, canMutatePipeStatus, io, diagnosticLine, syncReadInputText) {
+        if (!syncSinks.get(io.stderr))
+            return undefined;
         // Substitution callers also need to refuse before effects when status
         // publication requires array admission. Cleanup cannot start async fallback.
         if (store && !existing) {
@@ -15225,13 +15454,17 @@ export class Runtime {
         const initializer = command.kind === "arithmetic-for" ? command.expressions[0]?.tree : undefined;
         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 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) ? initializer.left.name : undefined;
+            this.canSyncPrintfInductionBody(command.body, rawState)
+            ? 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)) {
             command._skipTrySyncLoop = true;
             return undefined;
@@ -15246,7 +15479,7 @@ export class Runtime {
             if (!existing || !elem0)
                 return undefined;
         }
-        for (const v of Object.values(rawState.variables)) {
+        for (const v of [...Object.values(rawState.variables), ...rawState.positional]) {
             if (typeof v === "string") {
                 for (let k = 0; k < v.length; k++) {
                     if (v.charCodeAt(k) >= 128)
@@ -15254,10 +15487,22 @@ export class Runtime {
                 }
             }
         }
+        // The loop evaluator assumes ASCII, including values reached through array elements.
+        if (store) {
+            for (const { binding } of store.bindings.values()) {
+                for (const slot of binding.values.values()) {
+                    const value = slot.text.value;
+                    for (let k = 0; k < value.length; k++) {
+                        if (value.charCodeAt(k) >= 128)
+                            return undefined;
+                    }
+                }
+            }
+        }
         const { steps: bodyAssignments, redirectCount } = this.buildSyncLoopBody(command, rawState, io);
         if (bodyAssignments.length > 30)
             return undefined;
-        const touched = sharedSyncLoopTouched;
+        const touched = this._syncArithRawWriteOnly ? new Set() : sharedSyncLoopTouched;
         touched.clear();
         let lastCmd;
         let lastArg = "";
@@ -15350,7 +15595,7 @@ export class Runtime {
                     const stepMutatesInduction = (st) => {
                         // Integer declarations evaluate arithmetic strings, which can mutate
                         // any variable. Array reads can also replace the scalar counter.
-                        if (st.name === inductionName || st.readHereString?.varNames.includes(inductionName) || st.readHereString?.arrayTarget === inductionName || st.unsetVars?.includes(inductionName) || st.localDecl?.attr === "i" || st.localDecl?.items.some(it => it.name === inductionName))
+                        if (st.name === inductionName || st.readHereString?.varNames.includes(inductionName) || st.readHereString?.arrayTarget === inductionName || st.unsetVars?.includes(inductionName) || st.localDecl?.items.some(it => it.name === inductionName))
                             return true;
                         if (st.arithStmt?.hasMutation && arithTreeMutatesVar(st.arithStmt.tree, inductionName))
                             return true;
@@ -15401,9 +15646,13 @@ export class Runtime {
                         intSteps[b] = intStep;
                         continue;
                     }
-                    if (step.value) {
-                        for (let i = 0; i < step.value.parts.length; i++) {
-                            const part = step.value.parts[i];
+                    const wordsToScan = step.arrayAssign?.kind === "compound"
+                        ? step.arrayAssign.entries.map(e => e.value)
+                        : 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++) {
+                            const part = wVal.parts[i];
                             if (part.kind === "text" || part.kind === "variable")
                                 continue;
                             if (part.kind === "arithmetic") {
@@ -15525,7 +15774,7 @@ export class Runtime {
                 let lastInductionVal;
                 const intBudgetSnapshot = this.budget.parsing.snapshot();
                 // Empty loops must evaluate the header without publishing unexecuted body registers or command state.
-                let canUseIntRegisters = iterations > 0 && allIntStepsReady && (!hasSubIntStep || (this.middleware.length === 0 && rawState.depth < this.budget.maxSubstitutionDepthSmi)) && !this.budget.hasCpuLimit && this.budget.maxExpansionFieldsSmi >= 1 && this.budget.maxExpansionBytesSmi >= 32 && !store?.get(inductionName) && inductionName !== "LINENO" && inductionName !== "_" && inductionName !== "FUNCNAME";
+                let canUseIntRegisters = !prevRawWrite && iterations > 0 && allIntStepsReady && (!hasSubIntStep || (this.middleware.length === 0 && rawState.depth < this.budget.maxSubstitutionDepthSmi)) && !this.budget.hasCpuLimit && this.budget.maxExpansionFieldsSmi >= 1 && this.budget.maxExpansionBytesSmi >= 32 && !store?.get(inductionName) && inductionName !== "LINENO" && inductionName !== "_" && inductionName !== "FUNCNAME";
                 if (canUseIntRegisters && arithNamesList.length > 0) {
                     for (let a = 0; a < arithNamesList.length; a++) {
                         const refName = arithNamesList[a];
@@ -15807,6 +16056,10 @@ export class Runtime {
                         return (e.operator === "-n" || e.operator === "-z" || e.operator === "-v") && this.isPureSyncValueWord(e.operand, rawState);
                     if (e.kind === "binary") {
                         if (e.operator === "=~") {
+                            const patInfo = this.extractSimpleErePattern(e.right, rawState);
+                            // Nested branches cannot prove a variable pattern is invariant.
+                            if (patInfo?.isVar)
+                                return false;
                             return (depth === 0 &&
                                 this.isPureSyncValueWord(e.left, rawState) &&
                                 this.getFastAnchoredEreRegex(e.right, rawState) !== undefined &&
@@ -16257,9 +16510,11 @@ export class Runtime {
                 if (asciiOk)
                     fastLoopWords = arrMembers;
             }
-            else if (p0.kind === "variable" && !p0.quoted && !p0.indirect && !p0.prefixNames && !p0.length && !p0.substring && !p0.transform && p0.operator === undefined && getArraySelector(p0) === undefined && (rawState.variables.IFS === undefined || rawState.variables.IFS === " \t\n") && !rawState.noglob && !store?.get(p0.name) && !monitor.hasOverlay(p0.name)) {
-                const rawVal = rawState.variables[p0.name] ?? "";
-                if (rawVal.length <= 32768 && !/[*?[\]\\]/.test(rawVal)) {
+            else if (p0.kind === "variable" && !p0.quoted && !p0.indirect && !p0.prefixNames && !p0.length && !p0.transform && getArraySelector(p0) === undefined && (rawState.variables.IFS === undefined || rawState.variables.IFS === " \t\n") && !rawState.noglob && !store?.get(p0.name) && !monitor.hasOverlay(p0.name) && ((p0.operator === undefined && !p0.substring) || this.isPureSyncValueWord(command.words[0], rawState))) {
+                const rawVal = (p0.operator === undefined && !p0.substring)
+                    ? (rawState.variables[p0.name] ?? "")
+                    : this.fastValueWord(command.words[0], rawState, io, false, false, false, false, 0, diagnosticLine);
+                if (typeof rawVal === "string" && rawVal.length <= 32768 && !/[*?[\]\\]/.test(rawVal)) {
                     let asciiOk = true;
                     for (let j = 0; j < rawVal.length; j++) {
                         if (rawVal.charCodeAt(j) >= 128) {
@@ -16648,6 +16903,11 @@ export class Runtime {
         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")
+                            continue;
+                        return false;
+                    }
                     if (command.kind !== "simple" || hasShellFunction(rawState, command.words[0]?.plain ?? "") || command.words.some(word => getArrayAssignment(word) !== undefined))
                         return false;
                     for (const word of [...command.words, ...command.redirects.map(redirect => redirect.target)])
@@ -16656,6 +16916,8 @@ export class Runtime {
                                 continue;
                             if (part.kind === "variable" && !part.indirect && !part.length && !part.substring && !part.transform && !part.prefixNames && part.operator === undefined && getArraySelector(part) === undefined)
                                 continue;
+                            if (part.kind === "arithmetic" && !part.expression.error && !part.expression.hasMutation && !part.expression.hasSubscript && isSafeSmiProgram(part.expression) && /^[a-zA-Z0-9_ +*-]+$/.test(part.expression.source))
+                                continue;
                             if (part.kind === "substitution" && this.canSyncPrintfInductionBody(part.script, rawState))
                                 continue;
                             return false;
@@ -16683,6 +16945,20 @@ export class Runtime {
                 args.push("0");
                 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;
+            }
             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))))
@@ -16699,6 +16975,39 @@ 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));
     }
+    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";
+        let lineStr;
+        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;
+            }
+        }
+        else {
+            const fullInput = delim === "\n" ? rawInput : rawInput + "\n";
+            const nlIdx = rs.isMapfile ? -1 : fullInput.indexOf(delim);
+            lineStr = nlIdx === -1 ? fullInput : fullInput.slice(0, nlIdx);
+            status = (!rs.isMapfile && delim !== "\n" && nlIdx === -1) ? 1 : 0;
+        }
+        const ifsStr = rs.exactChars
+            ? ""
+            : rs.ifsWord !== undefined
+                ? this.fastValueWord(rs.ifsWord, rawState, io, false, false, false, false, 0, step.line)
+                : (rawState.variables.IFS ?? " \t\n");
+        this.splitSyncReadLine(lineStr, ifsStr, rs.varNames, rs.isBareReply, rawState, touched, rs.arrayTarget, monitor, rs.isMapfile);
+        rawState.status = status;
+        return step.cmd.words[step.cmd.words.length - 1].plain;
+    }
     splitSyncReadLine(lineStr, ifsStr, varNames, isBareReply, rawState, touched, arrayTarget, monitor, isMapfile = false) {
         if (arrayTarget !== undefined && monitor !== undefined) {
             const arrStore = monitor.store ?? requireArrays(rawState);
@@ -16833,17 +17142,8 @@ export class Runtime {
                 touched.add(item.name);
             }
             if (item.value !== undefined) {
-                let val = this.fastValueWord(item.value, rawState, io, false, false, false, rawState.braceexpand !== false, 0, line);
-                if (decl.attr === "u")
-                    val = val.toUpperCase();
-                else if (decl.attr === "l")
-                    val = val.toLowerCase();
-                else if (decl.attr === "i") {
-                    const curRaw = item.append ? rawState.variables[item.name] : undefined;
-                    const curStr = curRaw === undefined ? "" : (touched.has(item.name) ? curRaw : (monitor.values.get(item.name, curRaw) ?? curRaw));
-                    val = applySyncScalarAttributes("i", val, typeof curStr === "string" ? curStr : "", item.append, rawState, monitor, arrayStore(rawState), touched) ?? "0";
-                }
-                if (item.append && decl.attr !== "i") {
+                const val = this.fastValueWord(item.value, rawState, io, false, false, false, rawState.braceexpand !== false, 0, line);
+                if (item.append) {
                     const curRaw = rawState.variables[item.name];
                     const curStr = curRaw === undefined ? "" : (touched.has(item.name) ? curRaw : (monitor.values.get(item.name, curRaw) ?? curRaw));
                     rawState.variables[item.name] = (typeof curStr === "string" ? curStr : "") + val;
@@ -16857,9 +17157,6 @@ export class Runtime {
             else {
                 lastArg = item.name;
             }
-            if (decl.attr !== undefined) {
-                (this._syncPendingVarAttrs ??= new Map()).set(item.name, decl.attr);
-            }
             if (decl.kind === "export") {
                 rawState.exported.add(item.name);
             }
@@ -16867,20 +17164,12 @@ export class Runtime {
         return lastArg;
     }
     _syncTouchedPositionals = false;
-    _syncPendingVarAttrs = undefined;
     flushSyncPositionals(rawState) {
         if (this._syncTouchedPositionals) {
             this._syncTouchedPositionals = false;
             this._fastSubPositional = undefined;
             this.replacePositionals(rawState, rawState.positional);
         }
-        if (this._syncPendingVarAttrs && this._syncPendingVarAttrs.size > 0) {
-            rawState.variableAttributes ??= new Map();
-            for (const [k, v] of this._syncPendingVarAttrs) {
-                rawState.variableAttributes.set(k, v);
-            }
-            this._syncPendingVarAttrs.clear();
-        }
     }
     execSyncShiftStep(shiftCount, cmd, rawState) {
         const activePos = this._fastSubPositional ?? rawState.positional;
@@ -17006,13 +17295,7 @@ export class Runtime {
                     break;
                 }
                 if (step.unsetVars !== undefined) {
-                    for (let ui = 0; ui < step.unsetVars.length; ui++) {
-                        const uvn = step.unsetVars[ui];
-                        delete rawState.variables[uvn];
-                        monitor.proxy.exported.delete(uvn);
-                        touched.add(uvn);
-                    }
-                    lastArg = step.cmd.words[step.cmd.words.length - 1].plain;
+                    lastArg = this.execSyncUnsetStep(step, rawState, io, monitor, touched);
                     rawState.status = 0;
                     continue;
                 }
@@ -17028,16 +17311,7 @@ export class Runtime {
                     continue;
                 }
                 if (step.readHereString !== undefined) {
-                    const rs = step.readHereString;
-                    const rawInput = this.fastValueWord(rs.inputWord, rawState, io, false, false, false, false, 0, step.line);
-                    const delim = rs.delimChar ?? "\n";
-                    const fullInput = delim === "\n" ? rawInput : rawInput + "\n";
-                    const nlIdx = rs.isMapfile ? -1 : fullInput.indexOf(delim);
-                    const lineStr = nlIdx === -1 ? fullInput : fullInput.slice(0, nlIdx);
-                    const ifsStr = rs.ifsWord !== undefined ? this.fastValueWord(rs.ifsWord, rawState, io, false, false, false, false, 0, step.line) : (rawState.variables.IFS ?? " \t\n");
-                    this.splitSyncReadLine(lineStr, ifsStr, rs.varNames, rs.isBareReply, rawState, touched, rs.arrayTarget, monitor, rs.isMapfile);
-                    lastArg = step.cmd.words[step.cmd.words.length - 1].plain;
-                    rawState.status = (!rs.isMapfile && delim !== "\n" && nlIdx === -1) ? 1 : 0;
+                    lastArg = this.execSyncReadHereStringStep(step.readHereString, step, rawState, io, monitor, touched);
                     continue;
                 }
                 if (deferredMask & (1 << b)) {
@@ -17092,7 +17366,9 @@ export class Runtime {
                     lastArg = pLastArg;
                 }
                 else if (step.arrayAssign !== undefined) {
-                    this.tryFastArrayAssignmentSync(step.arrayAssign, rawState, io, step.line, undefined, undefined, true);
+                    if (!this.tryFastArrayAssignmentSync(step.arrayAssign, rawState, io, step.line, undefined, undefined, true)) {
+                        throw new Error("Synchronous loop array assignment was not executable");
+                    }
                     lastArg = "";
                 }
                 else if (step.caseClauses !== undefined) {
@@ -17270,44 +17546,56 @@ export class Runtime {
         }
     }
     evalSyncLoopArithStmt(expr, rawState, io, touched, line) {
-        if (!expr.error)
-            return this.syncShellArithmeticNonZero(expr, rawState, line);
-        const cachedExpr = expr;
-        const expWord = cachedExpr._cachedArithWord ?? parseArithmeticExpansion(expr.source, this.budget.parsing, false, 0, undefined, rawState.extensions?.syntax);
-        cachedExpr._cachedArithWord = expWord;
-        const fastSrc = this.fastValueWord(expWord, rawState, io, false, false, true, false, 0, line);
-        const scalarMutMatch = fastSrc.length <= 64 ? SIMPLE_SCALAR_MUT_RE.exec(fastSrc) : null;
-        if (scalarMutMatch) {
-            const varName = resolveSyncNameref(rawState, scalarMutMatch[1]);
-            const binOp = scalarMutMatch[2];
-            const rhs1 = Number(scalarMutMatch[3]);
-            const rhsOp = scalarMutMatch[4];
-            const rhs2 = scalarMutMatch[5] !== undefined ? Number(scalarMutMatch[5]) : 0;
-            const rhsNum = rhsOp === "+" ? rhs1 + rhs2 : rhsOp === "-" ? rhs1 - rhs2 : rhsOp === "*" ? rhs1 * rhs2 : rhs1;
-            const curVal = rawState.variables[varName] ?? "0";
-            if (curVal === "" || /^-?(?:0|[1-9][0-9]{0,12})$/.test(curVal)) {
-                const curNum = curVal === "" ? 0 : Number(curVal);
-                const nextNum = binOp === "=" ? rhsNum : binOp === "+=" ? curNum + rhsNum : curNum - rhsNum;
-                if (Number.isSafeInteger(nextNum)) {
+        try {
+            if (!expr.error)
+                return this.syncShellArithmeticNonZero(expr, rawState, line);
+            const cachedExpr = expr;
+            const expWord = cachedExpr._cachedArithWord ?? parseArithmeticExpansion(expr.source, this.budget.parsing, false, 0, undefined, rawState.extensions?.syntax);
+            cachedExpr._cachedArithWord = expWord;
+            const fastSrc = this.fastValueWord(expWord, rawState, io, false, false, true, false, 0, line);
+            const scalarMutMatch = fastSrc.length <= 64 ? SIMPLE_SCALAR_MUT_RE.exec(fastSrc) : null;
+            if (scalarMutMatch) {
+                const varName = resolveSyncNameref(rawState, scalarMutMatch[1]);
+                const binOp = scalarMutMatch[2];
+                const rhs1 = Number(scalarMutMatch[3]);
+                const rhsOp = scalarMutMatch[4];
+                const rhs2 = scalarMutMatch[5] !== undefined ? Number(scalarMutMatch[5]) : 0;
+                const rhsNum = rhsOp === "+" ? rhs1 + rhs2 : rhsOp === "-" ? rhs1 - rhs2 : rhsOp === "*" ? rhs1 * rhs2 : rhs1;
+                const curVal = rawState.variables[varName] ?? "0";
+                if (curVal === "" || /^-?(?:0|[1-9][0-9]{0,12})$/.test(curVal)) {
+                    const curNum = curVal === "" ? 0 : Number(curVal);
+                    const nextNum = binOp === "=" ? rhsNum : binOp === "+=" ? curNum + rhsNum : curNum - rhsNum;
+                    if (Number.isSafeInteger(nextNum)) {
+                        this.budget.parsing.admit(4);
+                        rawState.variables[varName] = intToStr(nextNum);
+                        touched.add(varName);
+                        return nextNum !== 0;
+                    }
+                }
+            }
+            const binCmpMatch = fastSrc.length <= 64 ? /^\s*(-?(?:0|[1-9][0-9]{0,12}))\s*(==|!=|<|<=|>|>=)\s*(-?(?:0|[1-9][0-9]{0,12}))\s*$/.exec(fastSrc) : null;
+            if (binCmpMatch) {
+                const lhs = Number(binCmpMatch[1]);
+                const op = binCmpMatch[2];
+                const rhs = Number(binCmpMatch[3]);
+                if (Number.isSafeInteger(lhs) && Number.isSafeInteger(rhs)) {
                     this.budget.parsing.admit(4);
-                    rawState.variables[varName] = intToStr(nextNum);
-                    touched.add(varName);
-                    return nextNum !== 0;
+                    return op === ">" ? lhs > rhs : op === ">=" ? lhs >= rhs : op === "<" ? lhs < rhs : op === "<=" ? lhs <= rhs : op === "==" ? lhs === rhs : lhs !== rhs;
                 }
             }
+            const dynProg = prepareArithmetic(fastSrc, this.budget.parsing);
+            return this.syncShellArithmeticNonZero(dynProg, rawState, line);
         }
-        const binCmpMatch = fastSrc.length <= 64 ? /^\s*(-?(?:0|[1-9][0-9]{0,12}))\s*(==|!=|<|<=|>|>=)\s*(-?(?:0|[1-9][0-9]{0,12}))\s*$/.exec(fastSrc) : null;
-        if (binCmpMatch) {
-            const lhs = Number(binCmpMatch[1]);
-            const op = binCmpMatch[2];
-            const rhs = Number(binCmpMatch[3]);
-            if (Number.isSafeInteger(lhs) && Number.isSafeInteger(rhs)) {
-                this.budget.parsing.admit(4);
-                return op === ">" ? lhs > rhs : op === ">=" ? lhs >= rhs : op === "<" ? lhs < rhs : op === "<=" ? lhs <= rhs : op === "==" ? lhs === rhs : lhs !== rhs;
-            }
+        catch (error) {
+            if (!(error instanceof PublicDiagnostic))
+                throw error;
+            const write = syncSinks.get(io.stderr);
+            if (!write)
+                throw error;
+            write(fastSharedTextEncoder.encode(`${io.scriptName ?? "shell"}: line ${line}: ((: ${error.message}\n`));
+            rawState.status = 1;
+            return undefined;
         }
-        const dynProg = prepareArithmetic(fastSrc, this.budget.parsing);
-        return this.syncShellArithmeticNonZero(dynProg, rawState, line);
     }
     extractSyncLoopFnSpec(cmd, rawState, io) {
         if (this._syncLoopFnCheckDepth > 0 || (rawState.locals && rawState.locals.length > 0))
@@ -17585,13 +17873,7 @@ export class Runtime {
                 break;
             }
             if (step.unsetVars !== undefined) {
-                for (let ui = 0; ui < step.unsetVars.length; ui++) {
-                    const uvn = step.unsetVars[ui];
-                    delete rawState.variables[uvn];
-                    monitor.proxy.exported.delete(uvn);
-                    touched.add(uvn);
-                }
-                lastArg = step.cmd.words[step.cmd.words.length - 1].plain;
+                lastArg = this.execSyncUnsetStep(step, rawState, io, monitor, touched);
                 rawState.status = 0;
                 onUpdate({ lastCmd, lastArg });
                 continue;
@@ -17610,16 +17892,7 @@ export class Runtime {
                 continue;
             }
             if (step.readHereString !== undefined) {
-                const rs = step.readHereString;
-                const rawInput = this.fastValueWord(rs.inputWord, rawState, io, false, false, false, false, 0, step.line);
-                const delim = rs.delimChar ?? "\n";
-                const fullInput = delim === "\n" ? rawInput : rawInput + "\n";
-                const nlIdx = rs.isMapfile ? -1 : fullInput.indexOf(delim);
-                const lineStr = nlIdx === -1 ? fullInput : fullInput.slice(0, nlIdx);
-                const ifsStr = rs.ifsWord !== undefined ? this.fastValueWord(rs.ifsWord, rawState, io, false, false, false, false, 0, step.line) : (rawState.variables.IFS ?? " \t\n");
-                this.splitSyncReadLine(lineStr, ifsStr, rs.varNames, rs.isBareReply, rawState, touched, rs.arrayTarget, monitor, rs.isMapfile);
-                lastArg = step.cmd.words[step.cmd.words.length - 1].plain;
-                rawState.status = (!rs.isMapfile && delim !== "\n" && nlIdx === -1) ? 1 : 0;
+                lastArg = this.execSyncReadHereStringStep(step.readHereString, step, rawState, io, monitor, touched);
                 onUpdate({ lastCmd, lastArg });
                 continue;
             }
@@ -17694,7 +17967,9 @@ export class Runtime {
                 lastArg = pLastArg;
             }
             else if (step.arrayAssign !== undefined) {
-                this.tryFastArrayAssignmentSync(step.arrayAssign, rawState, io, step.line, undefined, undefined, true);
+                if (!this.tryFastArrayAssignmentSync(step.arrayAssign, rawState, io, step.line, undefined, undefined, true)) {
+                    throw new Error("Synchronous loop array assignment was not executable");
+                }
                 lastArg = "";
             }
             else if (step.printfVArgs !== undefined && step.name !== undefined) {
@@ -17783,13 +18058,7 @@ export class Runtime {
                     break;
                 }
                 if (step.unsetVars !== undefined) {
-                    for (let ui = 0; ui < step.unsetVars.length; ui++) {
-                        const uvn = step.unsetVars[ui];
-                        delete rawState.variables[uvn];
-                        monitor.proxy.exported.delete(uvn);
-                        touched.add(uvn);
-                    }
-                    lastArg = step.cmd.words[step.cmd.words.length - 1].plain;
+                    lastArg = this.execSyncUnsetStep(step, rawState, io, monitor, touched);
                     rawState.status = 0;
                     continue;
                 }
@@ -17805,16 +18074,7 @@ export class Runtime {
                     continue;
                 }
                 if (step.readHereString !== undefined) {
-                    const rs = step.readHereString;
-                    const rawInput = this.fastValueWord(rs.inputWord, rawState, io, false, false, false, false, 0, step.line);
-                    const delim = rs.delimChar ?? "\n";
-                    const fullInput = delim === "\n" ? rawInput : rawInput + "\n";
-                    const nlIdx = rs.isMapfile ? -1 : fullInput.indexOf(delim);
-                    const lineStr = nlIdx === -1 ? fullInput : fullInput.slice(0, nlIdx);
-                    const ifsStr = rs.ifsWord !== undefined ? this.fastValueWord(rs.ifsWord, rawState, io, false, false, false, false, 0, step.line) : (rawState.variables.IFS ?? " \t\n");
-                    this.splitSyncReadLine(lineStr, ifsStr, rs.varNames, rs.isBareReply, rawState, touched, rs.arrayTarget, monitor, rs.isMapfile);
-                    lastArg = step.cmd.words[step.cmd.words.length - 1].plain;
-                    rawState.status = (!rs.isMapfile && delim !== "\n" && nlIdx === -1) ? 1 : 0;
+                    lastArg = this.execSyncReadHereStringStep(step.readHereString, step, rawState, io, monitor, touched);
                     continue;
                 }
                 if (step.coalesceNext) {
@@ -17882,7 +18142,9 @@ export class Runtime {
                     continue;
                 }
                 else if (step.arrayAssign !== undefined) {
-                    this.tryFastArrayAssignmentSync(step.arrayAssign, rawState, io, step.line, undefined, undefined, true);
+                    if (!this.tryFastArrayAssignmentSync(step.arrayAssign, rawState, io, step.line, undefined, undefined, true)) {
+                        throw new Error("Synchronous loop array assignment was not executable");
+                    }
                     lastArg = "";
                 }
                 else if (step.arithStmt !== undefined) {
@@ -19153,7 +19415,7 @@ export class Runtime {
                 try {
                     status = await evaluateConditional(command.expression, {
                         fs: this.fs, cwd: state.cwd, signal: this.signal, predicateIdentity: io.capabilities?.predicateIdentity, reference: name => state.variableAttributes?.get(name)?.includes("n") ?? false, locale: state.variables.LC_ALL || state.variables.LC_COLLATE || state.variables.LANG || "C", characterLocale: state.variables.LC_ALL || state.variables.LC_CTYPE || state.variables.LANG || "C", ignoreCase: !!state.nocasematch, extglob: true, work: { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes"), allocation }, expand: async (word, pattern = false) => {
-                            const fast = !pattern ? this.fastValueWord(word, state, io, false, false, false, false) : undefined;
+                            const fast = !pattern ? this.fastValueWord(word, state, { ...io, nameExpansionContext: "conditional" }, false, false, false, false) : undefined;
                             if (typeof fast === "string")
                                 return fast;
                             return (await this.word(word, state, { ...io, nameExpansionContext: "conditional" }, false, pattern, false, pattern)).join("");
@@ -24338,8 +24600,8 @@ export class Runtime {
                         invalid = true;
                         break;
                     }
-                    if (flag === "N")
-                        exact = true;
+                    if (flag === "n" || flag === "N")
+                        exact = flag === "N";
                     const value = option.slice(index + 1) || names.shift();
                     if (value === undefined)
                         invalid = true;
@@ -25782,25 +26044,27 @@ export class Runtime {
                         return undefined;
                     let transformed;
                     if (part.transform === "Q") {
-                        for (let k = 0; k < val.length; k++) {
-                            const c = val.charCodeAt(k);
-                            if (c < 32 || c >= 127)
-                                return undefined;
-                        }
-                        transformed = "'" + (val.includes("'") ? val.split("'").join("'\\''") : val) + "'";
+                        if (byteLocale(rawState.variables))
+                            return undefined;
+                        transformed = this.formatSyncTransformQ(val);
                     }
                     else {
-                        for (let k = 0; k < val.length; k++) {
-                            if (val.charCodeAt(k) >= 128)
-                                return undefined;
+                        if (part.transform === "U") {
+                            transformed = val.toUpperCase();
+                        }
+                        else if (part.transform === "L") {
+                            transformed = val.toLowerCase();
+                        }
+                        else if (val.length === 0) {
+                            transformed = "";
+                        }
+                        else if (val.charCodeAt(0) < 128) {
+                            transformed = val[0].toUpperCase() + val.slice(1);
+                        }
+                        else {
+                            const first = [...val][0];
+                            transformed = first.toUpperCase() + val.slice(first.length);
                         }
-                        transformed = part.transform === "U"
-                            ? val.toUpperCase()
-                            : part.transform === "L"
-                                ? val.toLowerCase()
-                                : val.length === 0
-                                    ? ""
-                                    : val[0].toUpperCase() + val.slice(1);
                     }
                     if (split && !part.quoted) {
                         if (transformed.length === 0 || transformed.includes(" ") || transformed.includes("\t") || transformed.includes("\n") || (!rawState.noglob && hasGlobOrEscape(transformed, !!rawState.extglob)))
@@ -25809,8 +26073,35 @@ export class Runtime {
                     out += transformed;
                     continue;
                 }
-                if (part.prefixNames !== undefined)
-                    return undefined;
+                if (part.prefixNames !== undefined) {
+                    if ((split && !(part.quoted && part.prefixNames === "*")) ||
+                        part.indirect ||
+                        part.specialParameter ||
+                        part.length ||
+                        part.substring ||
+                        part.transform !== undefined ||
+                        part.operator !== undefined ||
+                        getArraySelector(part) !== undefined ||
+                        this.budget.limits.maxExpansionFields !== Infinity ||
+                        this.budget.limits.maxExpansionBytes !== Infinity ||
+                        !isShellIdentifier(part.name)) {
+                        return undefined;
+                    }
+                    const pNames = this.collectSyncPrefixNames(part.name, rawState);
+                    if (pNames === undefined)
+                        return undefined;
+                    const ifs = rawState.variables.IFS ?? " ";
+                    const sep = io.nameExpansionContext === "document" || (io.nameExpansionContext === "conditional" && part.prefixNames === "@")
+                        ? " "
+                        : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
+                    const joined = pNames.join(sep);
+                    if (split && !part.quoted) {
+                        if (joined.length === 0 || joined.includes(" ") || joined.includes("\t") || joined.includes("\n"))
+                            return undefined;
+                    }
+                    out += joined;
+                    continue;
+                }
                 if (part.indirect || part.specialParameter)
                     return undefined;
                 if (part.name === "@" || part.name === "*" || part.name === "PIPESTATUS" || part.name === "LINENO" || part.name === "_" || part.name === "FUNCNAME" || part.name === "DIRSTACK")
@@ -26587,12 +26878,638 @@ export class Runtime {
             this.budget.fail("maxExpansionBytes");
         return out;
     }
-    expandSyncTrCharSet(spec) {
-        const out = new Set();
+    expandSyncTrCharArray(spec) {
+        if (spec.length === 0)
+            return undefined;
+        const posixClasses = {
+            "[:lower:]": "abcdefghijklmnopqrstuvwxyz",
+            "[:upper:]": "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+            "[:digit:]": "0123456789",
+            "[:alpha:]": "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+            "[:alnum:]": "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+            "[:space:]": "\t\n\v\f\r ",
+            "[:blank:]": "\t ",
+            "[:xdigit:]": "0123456789ABCDEFabcdef",
+            "[:punct:]": "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+        };
+        const out = [];
         for (let i = 0; i < spec.length; i++) {
-            if (i + 2 < spec.length && spec[i + 1] === "-") {
-                const start = spec.charCodeAt(i);
-                const end = spec.charCodeAt(i + 2);
+            if (spec[i] === "[" && spec[i + 1] === ":") {
+                const close = spec.indexOf(":]", i + 2);
+                if (close === -1)
+                    return undefined;
+                const cls = spec.slice(i, close + 2);
+                const exp = posixClasses[cls];
+                if (!exp)
+                    return undefined;
+                for (let k = 0; k < exp.length; k++)
+                    out.push(exp[k]);
+                i = close + 1;
+                continue;
+            }
+            if (spec[i] === "[")
+                return undefined;
+            if (spec[i] === "\\") {
+                if (i + 1 >= spec.length)
+                    return undefined;
+                const next = spec[++i];
+                if (next === "n")
+                    out.push("\n");
+                else if (next === "t")
+                    out.push("\t");
+                else if (next === "r")
+                    out.push("\r");
+                else if (next === "\\")
+                    out.push("\\");
+                else
+                    return undefined;
+                continue;
+            }
+            if (i + 2 < spec.length && spec[i + 1] === "-" && spec[i + 2] !== "\\") {
+                const start = spec.charCodeAt(i);
+                const end = spec.charCodeAt(i + 2);
+                if (start <= end && end - start <= 256) {
+                    for (let c = start; c <= end; c++)
+                        out.push(String.fromCharCode(c));
+                    i += 2;
+                    continue;
+                }
+                return undefined;
+            }
+            out.push(spec[i]);
+        }
+        return out;
+    }
+    evalSyncTr(input, opArgs) {
+        if (opArgs.length === 2 && !opArgs[0].startsWith("-") && !opArgs[1].startsWith("-")) {
+            return this.translateSyncTr(input, opArgs[0], opArgs[1]);
+        }
+        if (opArgs.length === 2 && opArgs[0] === "-d" && !opArgs[1].startsWith("-")) {
+            const arr = this.expandSyncTrCharArray(opArgs[1]);
+            if (!arr)
+                return undefined;
+            const delSet = new Set(arr);
+            let out = "";
+            for (let i = 0; i < input.length; i++) {
+                const ch = input[i];
+                if (!delSet.has(ch))
+                    out += ch;
+            }
+            return out;
+        }
+        if (opArgs.length === 2 && opArgs[0] === "-s" && !opArgs[1].startsWith("-")) {
+            const arr = this.expandSyncTrCharArray(opArgs[1]);
+            if (!arr)
+                return undefined;
+            const sqSet = new Set(arr);
+            let out = "";
+            let prev = "";
+            for (let i = 0; i < input.length; i++) {
+                const ch = input[i];
+                if (sqSet.has(ch) && ch === prev)
+                    continue;
+                out += ch;
+                prev = ch;
+            }
+            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 (stage1 === undefined)
+                return undefined;
+            return this.evalSyncTr(stage1, ["-s", opArgs[2]]);
+        }
+        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)
+            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("."))
+                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;
+            }
+            compiledStages.push(ops);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(input);
+        }
+        catch {
+            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;
+                    }
+                    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 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 (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;
+                    }
+                }
+                current = next;
+            }
+        }
+        return current.map(val => (rawOut && typeof val === "string" ? val : JSON.stringify(val ?? null)));
+    }
+    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)) {
+            return undefined;
+        }
+        const ranges = [];
+        for (const part of spec.split(",")) {
+            const dash = part.indexOf("-");
+            if (dash === -1) {
+                const n = Number(part);
+                ranges.push([n, n]);
+            }
+            else if (dash === 0) {
+                const end = Number(part.slice(1));
+                ranges.push([1, end]);
+            }
+            else if (dash === part.length - 1) {
+                const start = Number(part.slice(0, -1));
+                ranges.push([start, Infinity]);
+            }
+            else {
+                const start = Number(part.slice(0, dash));
+                const end = Number(part.slice(dash + 1));
+                if (start > end)
+                    return undefined;
+                ranges.push([start, end]);
+            }
+        }
+        return (len) => {
+            const out = [];
+            for (let i = 1; i <= len; i++) {
+                for (let r = 0; r < ranges.length; r++) {
+                    const [s, e] = ranges[r];
+                    if (i >= s && i <= e) {
+                        out.push(i - 1);
+                        break;
+                    }
+                }
+            }
+            return out;
+        };
+    }
+    evalSyncCut(rawLines, opArgs, byteLocaleMode) {
+        const norm = [];
+        let suppressNoDelim = false;
+        for (let ci = 0; ci < opArgs.length; ci++) {
+            const ca = opArgs[ci];
+            if (ca === "-s" || ca === "--only-delimited") {
+                suppressNoDelim = true;
+            }
+            else if (ca.startsWith("-sd") || ca.startsWith("-ds")) {
+                suppressNoDelim = true;
+                const rest = ca.slice(3);
+                if (rest.length > 0)
+                    norm.push("-d" + rest);
+                else if (ci + 1 < opArgs.length)
+                    norm.push("-d" + opArgs[++ci]);
+                else
+                    return undefined;
+            }
+            else if ((ca === "-d" || ca === "-f" || ca === "-c") && ci + 1 < opArgs.length) {
+                norm.push(ca + opArgs[++ci]);
+            }
+            else {
+                norm.push(ca);
+            }
+        }
+        if (!suppressNoDelim && norm.length === 1 && norm[0].startsWith("-c")) {
+            if (byteLocaleMode)
+                return undefined;
+            const picker = this.parseSyncCutSpec(norm[0].slice(2));
+            if (!picker)
+                return undefined;
+            return rawLines.map(l => {
+                const chars = Array.from(l);
+                const idxs = picker(chars.length);
+                return idxs.map(i => chars[i]).join("");
+            });
+        }
+        let delim = "\t";
+        let fArg;
+        if (norm.length === 1 && norm[0].startsWith("-f")) {
+            fArg = norm[0];
+        }
+        else if (norm.length === 2) {
+            const dCandidate = norm[0].startsWith("-d") ? norm[0] : (norm[1].startsWith("-d") ? norm[1] : undefined);
+            const fCandidate = norm[0].startsWith("-f") ? norm[0] : (norm[1].startsWith("-f") ? norm[1] : undefined);
+            if (dCandidate && dCandidate.length === 3 && fCandidate) {
+                delim = dCandidate[2];
+                fArg = fCandidate;
+            }
+        }
+        if (!fArg || !fArg.startsWith("-f"))
+            return undefined;
+        const picker = this.parseSyncCutSpec(fArg.slice(2));
+        if (!picker)
+            return undefined;
+        const out = [];
+        for (let li = 0; li < rawLines.length; li++) {
+            const l = rawLines[li];
+            if (!l.includes(delim)) {
+                if (!suppressNoDelim)
+                    out.push(l);
+                continue;
+            }
+            const parts = l.split(delim);
+            const idxs = picker(parts.length);
+            out.push(idxs.map(i => parts[i]).join(delim));
+        }
+        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"))
+                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)
+            return undefined;
+        const [pat, rep, flags] = parts;
+        if ((flags !== "" && flags !== "g") || /[&\\\n]/.test(rep))
+            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))
+            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);
+        });
+    }
+    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") {
+            return undefined;
+        }
+        const isCaseInsensitive = mode.includes("i");
+        const isInvert = mode.includes("v");
+        const isCount = mode === "-c";
+        const isExtended = mode.includes("E");
+        const isFixed = mode.includes("F");
+        const branches = isExtended ? pat.split("|") : [pat];
+        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 });
+        }
+        const matched = [];
+        for (let li = 0; li < rawLines.length; li++) {
+            const l = rawLines[li];
+            const hay = isCaseInsensitive ? l.toLowerCase() : 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);
+                if (ok) {
+                    hit = true;
+                    break;
+                }
+            }
+            if (isInvert ? !hit : hit)
+                matched.push(l);
+        }
+        return {
+            lines: isCount ? [String(matched.length)] : matched,
+            status: matched.length > 0 ? 0 : 1,
+        };
+    }
+    evalSyncAwk(rawLines, opArgs) {
+        if (opArgs.length < 1 || opArgs.length > 3)
+            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];
+        }
+        if (!awkProg)
+            return undefined;
+        const awkM = /^\s*\{\s*print(?:\s+((?:\$(?:[0-9]+|NF)|"[^"$\\]*")(?:\s*,?\s*(?:\$(?:[0-9]+|NF)|"[^"$\\]*"))*))?\s*;?\s*\}\s*$/.exec(awkProg);
+        if (!awkM)
+            return undefined;
+        const exprBody = awkM[1]?.trim();
+        const parts = [];
+        if (!exprBody) {
+            parts.push({ kind: "field", token: "0" });
+        }
+        else {
+            const tokenRe = /\$([0-9]+|NF)|"([^"$\\]*)"|(,)/g;
+            let m;
+            while ((m = tokenRe.exec(exprBody)) !== null) {
+                if (m[1] !== undefined)
+                    parts.push({ kind: "field", token: m[1] });
+                else if (m[2] !== undefined)
+                    parts.push({ kind: "lit", text: m[2] });
+                else if (m[3] !== undefined)
+                    parts.push({ kind: "lit", text: " " });
+            }
+        }
+        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);
+            let out = "";
+            for (let pi = 0; pi < parts.length; pi++) {
+                const p = parts[pi];
+                if (p.kind === "lit")
+                    out += p.text;
+                else if (p.token === "0")
+                    out += l;
+                else {
+                    const idx = p.token === "NF" ? fields.length : Number(p.token);
+                    out += idx === 0 ? l : (idx >= 1 && idx <= fields.length ? fields[idx - 1] : "");
+                }
+            }
+            return out;
+        });
+    }
+    formatSyncTransformQ(val) {
+        let ansi = false;
+        for (let i = 0; i < val.length; i++) {
+            const c = val.charCodeAt(i);
+            if (c < 32 || c === 127) {
+                ansi = true;
+                break;
+            }
+            if (c >= 128) {
+                const cp = val.codePointAt(i);
+                if (/[\p{Cc}\p{Cf}\p{Cn}]/u.test(String.fromCodePoint(cp))) {
+                    ansi = true;
+                    break;
+                }
+                if (cp > 0xffff)
+                    i++;
+            }
+        }
+        if (!ansi) {
+            return "'" + (val.includes("'") ? val.split("'").join("'\\''") : val) + "'";
+        }
+        const escMap = { 7: "\\a", 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r", 27: "\\E" };
+        let out = "$'";
+        for (const ch of val) {
+            const cp = ch.codePointAt(0);
+            if (escMap[cp] !== undefined)
+                out += escMap[cp];
+            else if (cp === 39)
+                out += "\\'";
+            else if (cp === 92)
+                out += "\\\\";
+            else if ((cp >= 32 && cp < 127) || (cp >= 128 && !/[\p{Cc}\p{Cf}\p{Cn}]/u.test(ch)))
+                out += ch;
+            else {
+                const bytes = fastSharedTextEncoder.encode(ch);
+                for (let bi = 0; bi < bytes.length; bi++)
+                    out += "\\" + bytes[bi].toString(8).padStart(3, "0");
+            }
+        }
+        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");
+        const parseNum = (s) => {
+            const m = /^[ \t]*([+-]?(?:\d+(?:\.\d*)?|\.\d+))/.exec(s);
+            return m ? Number(m[1]) : 0;
+        };
+        const sorted = [...rawLines].sort((a, b) => {
+            if (num) {
+                const na = parseNum(a);
+                const nb = parseNum(b);
+                if (na !== nb)
+                    return rev ? nb - na : na - nb;
+            }
+            return a < b ? (rev ? 1 : -1) : a > b ? (rev ? -1 : 1) : 0;
+        });
+        if (!uniq)
+            return sorted;
+        const dedup = [];
+        for (let i = 0; i < sorted.length; i++) {
+            if (i === 0 || sorted[i] !== sorted[i - 1])
+                dedup.push(sorted[i]);
+        }
+        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);
+        const s2 = this.expandSyncTrCharArray(set2Spec);
+        if (!s1 || !s2 || s1.length === 0 || s2.length === 0)
+            return undefined;
+        if (s1.length === 1 && s2.length === 1)
+            return input.split(s1[0]).join(s2[0]);
+        const map = new Map();
+        for (let i = 0; i < s1.length; i++) {
+            map.set(s1[i], s2[Math.min(i, s2.length - 1)]);
+        }
+        let out = "";
+        for (let i = 0; i < input.length; i++) {
+            const ch = input[i];
+            out += map.get(ch) ?? ch;
+        }
+        return out;
+    }
+    expandSyncTrCharSet(spec) {
+        const out = new Set();
+        for (let i = 0; i < spec.length; i++) {
+            if (i + 2 < spec.length && spec[i + 1] === "-") {
+                const start = spec.charCodeAt(i);
+                const end = spec.charCodeAt(i + 2);
                 if (start <= end && end - start <= 256) {
                     for (let c = start; c <= end; c++)
                         out.add(String.fromCharCode(c));
@@ -26779,35 +27696,11 @@ export class Runtime {
                     sArgs.push(v);
                 }
                 if (sName === "cut") {
-                    const normCut = [];
-                    for (let ci = 0; ci < sArgs.length; ci++) {
-                        const ca = sArgs[ci];
-                        if ((ca === "-d" || ca === "-f") && ci + 1 < sArgs.length) {
-                            normCut.push(ca + sArgs[++ci]);
-                        }
-                        else {
-                            normCut.push(ca);
-                        }
-                    }
-                    sArgs.length = 0;
-                    for (let ci = 0; ci < normCut.length; ci++)
-                        sArgs.push(normCut[ci]);
-                    const validCut2 = sArgs.length === 2 && ((sArgs[0].length === 3 && sArgs[0].startsWith("-d") && sArgs[1].length >= 3 && sArgs[1].startsWith("-f")) || (sArgs[0] === "-c" && /^[1-9][0-9]*-[1-9][0-9]*$/.test(sArgs[1])));
-                    const validCut1 = sArgs.length === 1 && sArgs[0].length >= 3 && sArgs[0].startsWith("-f");
-                    if (!validCut2 && !validCut1)
+                    if (this.evalSyncCut([], sArgs, byteLocale(rawState.variables)) === undefined)
                         return undefined;
-                    if (sArgs[0] === "-c") {
-                        if (byteLocale(rawState.variables))
-                            return undefined;
-                        const [start, end] = sArgs[1].split("-").map(Number);
-                        if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start > end)
-                            return undefined;
-                    }
                 }
                 else if (sName === "tr") {
-                    const validTr2 = sArgs.length === 2 && ((!sArgs[0].startsWith("-") && !sArgs[1].startsWith("-")) || ((sArgs[0] === "-d" || sArgs[0] === "-s") && !sArgs[1].startsWith("-")));
-                    const validTr3 = sArgs.length === 3 && (sArgs[0] === "-ds" || sArgs[0] === "-sd" || sArgs[0] === "-s") && !sArgs[1].startsWith("-") && !sArgs[2].startsWith("-");
-                    if (!validTr2 && !validTr3)
+                    if (this.evalSyncTr("", sArgs) === undefined)
                         return undefined;
                 }
                 else if (sName === "uniq") {
@@ -26815,16 +27708,20 @@ export class Runtime {
                         return undefined;
                 }
                 else if (sName === "sort") {
-                    if (sArgs.length > 1 || (sArgs.length === 1 && sArgs[0] !== "-r"))
+                    if (sArgs.length > 1 || (sArgs.length === 1 && sArgs[0] !== "-r" && sArgs[0] !== "-u" && sArgs[0] !== "-n" && sArgs[0] !== "-rn" && sArgs[0] !== "-nr" && sArgs[0] !== "-ru" && sArgs[0] !== "-ur"))
                         return undefined;
                 }
                 else if (sName === "head" || sName === "tail") {
-                    if (sArgs.length === 1 && /^-(?:n)?[0-9]+$/.test(sArgs[0])) {
-                        const numStr = sArgs[0].startsWith("-n") ? sArgs[0].slice(2) : sArgs[0].slice(1);
+                    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);
                         sArgs.length = 0;
-                        sArgs.push("-n", numStr);
+                        sArgs.push(flag, numStr);
                     }
-                    if (sArgs.length !== 2 || sArgs[0] !== "-n" || !/^[0-9]+$/.test(sArgs[1]))
+                    if (sArgs.length !== 2 || (sArgs[0] !== "-n" && sArgs[0] !== "-c") || !/^[0-9]+$/.test(sArgs[1]))
                         return undefined;
                 }
                 else if (sName === "wc") {
@@ -26832,9 +27729,7 @@ export class Runtime {
                         return undefined;
                 }
                 else if (sName === "sed") {
-                    const validSed1 = sArgs.length === 1 && sArgs[0].startsWith("s");
-                    const validSed2 = sArgs.length === 2 && sArgs[0] === "-e" && sArgs[1].startsWith("s");
-                    if (!validSed1 && !validSed2)
+                    if (this.evalSyncSed([], sArgs) === undefined)
                         return undefined;
                 }
                 else if (sName === "rev") {
@@ -26842,23 +27737,15 @@ export class Runtime {
                         return undefined;
                 }
                 else if (sName === "awk") {
-                    if (sArgs.length === 3 && sArgs[0] === "-F") {
-                        sArgs.splice(0, 2, "-F" + sArgs[1]);
-                    }
-                    const awkSepOk = sArgs.length === 1 || (sArgs.length === 2 && sArgs[0].length === 3 && sArgs[0].startsWith("-F") && sArgs[0][2] !== "\\");
-                    const awkProg = sArgs[sArgs.length - 1] ?? "";
-                    if (!awkSepOk || !/^\s*\{\s*print(?:\s+(\$(?:[0-9]+|NF)(?:\s*,\s*\$(?:[0-9]+|NF))*))?\s*;?\s*\}\s*$/.test(awkProg))
+                    if (this.evalSyncAwk([], sArgs) === undefined)
                         return undefined;
                 }
                 else if (sName === "grep") {
-                    const grepOk = (sArgs.length === 1 && !sArgs[0].startsWith("-") && /^[a-zA-Z0-9_ :;,/-]+$/.test(sArgs[0])) ||
-                        (sArgs.length === 2 && (sArgs[0] === "-v" || sArgs[0] === "-i" || sArgs[0] === "-c" || sArgs[0] === "-F") && /^[a-zA-Z0-9_ :;,/-]+$/.test(sArgs[1]));
-                    if (!grepOk)
+                    if (this.evalSyncGrep([], sArgs, Boolean(rawState.errexit)) === undefined)
                         return undefined;
                 }
                 else if (sName === "jq") {
-                    const jqFilter = sArgs.length === 1 ? sArgs[0] : (sArgs.length === 2 && (sArgs[0] === "-r" || sArgs[0] === "--raw-output") ? sArgs[1] : undefined);
-                    if (!jqFilter || !/^\.[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/.test(jqFilter))
+                    if (this.evalSyncJq("null", sArgs) === undefined)
                         return undefined;
                 }
                 else if (sName === "base64") {
@@ -26948,23 +27835,17 @@ export class Runtime {
                     const extDef = stageDefs[sIdx];
                     const stageArgs = stageArgsList[sIdx];
                     const nextBuf = (index & 1) === 0 ? sharedSyncPipeBuf0 : sharedSyncPipeBuf1;
-                    const isInlineCutField = firstName === "cut" && ((stageArgs.length === 1 && /^-[f][1-9][0-9]*(?:,[1-9][0-9]*)*$/.test(stageArgs[0])) ||
-                        (stageArgs.length === 2 && stageArgs[0].length === 3 && stageArgs[0].startsWith("-d") && /^-[f][1-9][0-9]*(?:,[1-9][0-9]*)*$/.test(stageArgs[1])));
-                    const isInlineTr = firstName === "tr" && stageArgs.length === 2 && ((stageArgs[0] === "a-z" && stageArgs[1] === "A-Z") ||
-                        (stageArgs[0] === "A-Z" && stageArgs[1] === "a-z") ||
-                        (stageArgs[0] === "-d" && /^[a-zA-Z0-9_ :;,./-]+$/.test(stageArgs[1])) ||
-                        (stageArgs[0] === "-s" && stageArgs[1].length === 1));
+                    const isInlineCutField = firstName === "cut";
+                    const isInlineTr = firstName === "tr";
                     const isInlineAwk = firstName === "awk";
                     const isInlineGrep = firstName === "grep";
                     const isInlineJq = firstName === "jq";
                     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"));
-                    const isInlineUniq = firstName === "uniq" && (stageArgs.length === 0 || (stageArgs.length === 1 && (stageArgs[0] === "-d" || stageArgs[0] === "-u")));
-                    const inlineSedMatch = firstName === "sed"
-                        ? /^s\/([a-zA-Z0-9_ :;,-]+)\/([a-zA-Z0-9_ :;,./-]*)\/(g?)$/.exec(stageArgs.length === 1 ? stageArgs[0] : (stageArgs.length === 2 && stageArgs[0] === "-e" ? stageArgs[1] : ""))
-                        : null;
+                    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 inlineSedMatch = firstName === "sed";
                     if (firstName === "rev" ||
                         firstName === "head" ||
                         firstName === "tail" ||
@@ -26974,7 +27855,7 @@ export class Runtime {
                         isInlineTr ||
                         isInlineSort ||
                         isInlineUniq ||
-                        inlineSedMatch !== null ||
+                        inlineSedMatch ||
                         isInlineAwk ||
                         isInlineGrep ||
                         isInlineJq ||
@@ -26987,16 +27868,22 @@ export class Runtime {
                         if (firstName === "rev") {
                             outLines = rawLines.map(l => Array.from(l).reverse().join(""));
                         }
-                        else if (firstName === "head") {
-                            outLines = rawLines.slice(0, Number(stageArgs[1]));
-                        }
-                        else if (firstName === "tail") {
-                            const nTail = Number(stageArgs[1]);
-                            outLines = nTail === 0 ? [] : rawLines.slice(-nTail);
-                        }
-                        else if (firstName === "cut" && stageArgs[0] === "-c") {
-                            const [cStart, cEnd] = stageArgs[1].split("-").map(Number);
-                            outLines = rawLines.map(l => Array.from(l).slice(cStart - 1, cEnd).join(""));
+                        else if (firstName === "head" || firstName === "tail") {
+                            const count = Number(stageArgs[1]);
+                            if (stageArgs[0] === "-c") {
+                                const sub = firstName === "head"
+                                    ? prevBuf.subarray(0, Math.min(prevLen, count))
+                                    : (count === 0 ? prevBuf.subarray(0, 0) : prevBuf.subarray(Math.max(0, prevLen - count), prevLen));
+                                const nextTotalBytes = this.budget.bytes + sub.byteLength;
+                                if (nextTotalBytes > this.budget.maxOutputBytesSmi && sub.byteLength > this.budget.limits.maxOutputBytes - this.budget.bytes)
+                                    this.budget.fail("maxOutputBytes");
+                                this.budget.bytes = nextTotalBytes;
+                                nextBuf.set(sub, 0);
+                                prevBuf = nextBuf;
+                                prevLen = sub.byteLength;
+                                continue;
+                            }
+                            outLines = firstName === "head" ? rawLines.slice(0, count) : (count === 0 ? [] : rawLines.slice(-count));
                         }
                         else if (firstName === "wc") {
                             if (stageArgs[0] === "-l") {
@@ -27015,60 +27902,16 @@ export class Runtime {
                             }
                         }
                         else if (isInlineCutField) {
-                            const delim = stageArgs.length === 2 ? stageArgs[0][2] : "\t";
-                            const fSpec = (stageArgs.length === 2 ? stageArgs[1] : stageArgs[0]).slice(2);
-                            const fIndices = Array.from(new Set(fSpec.split(",").map(Number))).sort((a, b) => a - b);
-                            outLines = rawLines.map(l => {
-                                if (!l.includes(delim))
-                                    return l;
-                                const parts = l.split(delim);
-                                const picked = [];
-                                for (let fi = 0; fi < fIndices.length; fi++) {
-                                    const idx = fIndices[fi] - 1;
-                                    if (idx >= 0 && idx < parts.length)
-                                        picked.push(parts[idx]);
-                                }
-                                return picked.join(delim);
-                            });
+                            const cutRes = this.evalSyncCut(rawLines, stageArgs, byteLocale(rawState.variables));
+                            if (cutRes === undefined)
+                                return undefined;
+                            outLines = cutRes;
                         }
                         else if (isInlineTr) {
-                            let transformed = inStr;
-                            if (stageArgs[0] === "a-z" && stageArgs[1] === "A-Z") {
-                                transformed = inStr.replace(/[a-z]/g, ch => String.fromCharCode(ch.charCodeAt(0) - 32));
-                            }
-                            else if (stageArgs[0] === "A-Z" && stageArgs[1] === "a-z") {
-                                transformed = inStr.replace(/[A-Z]/g, ch => String.fromCharCode(ch.charCodeAt(0) + 32));
-                            }
-                            else if (stageArgs[0] === "-s") {
-                                const sq = stageArgs[1];
-                                let out = "";
-                                let prevSq = false;
-                                for (let ci = 0; ci < inStr.length; ci++) {
-                                    const ch = inStr[ci];
-                                    if (ch === sq) {
-                                        if (!prevSq) {
-                                            out += ch;
-                                            prevSq = true;
-                                        }
-                                    }
-                                    else {
-                                        out += ch;
-                                        prevSq = false;
-                                    }
-                                }
-                                transformed = out;
-                            }
-                            else if (stageArgs[0] === "-d") {
-                                const delSet = this.expandSyncTrCharSet(stageArgs[1]);
-                                let out = "";
-                                for (let ci = 0; ci < inStr.length; ci++) {
-                                    const ch = inStr[ci];
-                                    if (!delSet.has(ch))
-                                        out += ch;
-                                }
-                                transformed = out;
-                            }
-                            const outByteLen = transformed.length * 3 > 127 ? shellValueByteLength(transformed) : transformed.length;
+                            const transformed = this.evalSyncTr(inStr, stageArgs);
+                            if (transformed === undefined)
+                                return undefined;
+                            const outByteLen = shellValueByteLength(transformed);
                             if (outByteLen > nextBuf.byteLength)
                                 return undefined;
                             const nextTotalBytes = this.budget.bytes + outByteLen;
@@ -27081,8 +27924,7 @@ export class Runtime {
                             continue;
                         }
                         else if (isInlineSort) {
-                            const revSort = stageArgs[0] === "-r";
-                            outLines = [...rawLines].sort((a, b) => (a < b ? (revSort ? 1 : -1) : a > b ? (revSort ? -1 : 1) : 0));
+                            outLines = this.sortSyncLines(rawLines, stageArgs[0]);
                         }
                         else if (isInlineUniq) {
                             const mode = stageArgs[0];
@@ -27094,69 +27936,31 @@ export class Runtime {
                                     uEnd++;
                                 const count = uEnd - uIdx;
                                 if (mode === "-d" ? count > 1 : mode === "-u" ? count === 1 : true) {
-                                    outLines.push(rawLines[uIdx]);
+                                    outLines.push(mode === "-c" ? `${String(count).padStart(7, " ")} ${rawLines[uIdx]}` : rawLines[uIdx]);
                                 }
                                 uIdx = uEnd;
                             }
                         }
-                        else if (inlineSedMatch !== null) {
-                            const pat = inlineSedMatch[1];
-                            const rep = inlineSedMatch[2];
-                            const isGlobal = inlineSedMatch[3] === "g";
-                            outLines = rawLines.map(l => (isGlobal ? l.split(pat).join(rep) : l.replace(pat, () => rep)));
+                        else if (inlineSedMatch) {
+                            const sedRes = this.evalSyncSed(rawLines, stageArgs);
+                            if (sedRes === undefined)
+                                return undefined;
+                            outLines = sedRes;
                         }
                         else if (isInlineAwk) {
-                            const awkSep = stageArgs.length === 2 ? stageArgs[0].slice(2) : undefined;
-                            const awkProg = stageArgs[stageArgs.length - 1];
-                            const awkM = /^\s*\{\s*print(?:\s+(\$(?:[0-9]+|NF)(?:\s*,\s*\$(?:[0-9]+|NF))*))?\s*;?\s*\}\s*$/.exec(awkProg);
-                            if (!awkM)
+                            const awkRes = this.evalSyncAwk(rawLines, stageArgs);
+                            if (awkRes === undefined)
                                 return undefined;
-                            const toks = awkM[1] ? awkM[1].split(",").map(t => t.trim().slice(1)) : ["0"];
-                            outLines = [];
-                            for (let li = 0; li < rawLines.length; li++) {
-                                const l = rawLines[li];
-                                if (toks.length === 1 && toks[0] === "0") {
-                                    outLines.push(l);
-                                    continue;
-                                }
-                                let fields;
-                                if (awkSep === undefined || awkSep === " ") {
-                                    const tr = l.replace(/^[ \t]+|[ \t]+$/g, "");
-                                    fields = tr.length === 0 ? [] : tr.split(/[ \t]+/);
-                                }
-                                else {
-                                    fields = l.length === 0 ? [] : l.split(awkSep);
-                                }
-                                const vals = [];
-                                for (let ti = 0; ti < toks.length; ti++) {
-                                    const tk = toks[ti];
-                                    if (tk === "0")
-                                        vals.push(l);
-                                    else if (tk === "NF")
-                                        vals.push(fields.length > 0 ? fields[fields.length - 1] : l);
-                                    else {
-                                        const idx = Number(tk);
-                                        vals.push(idx >= 1 && idx <= fields.length ? fields[idx - 1] : "");
-                                    }
-                                }
-                                outLines.push(vals.join(" "));
-                            }
+                            outLines = awkRes;
                         }
                         else if (isInlineGrep) {
-                            const gMode = stageArgs.length === 2 ? stageArgs[0] : "";
-                            const gPat = stageArgs[stageArgs.length - 1];
-                            const gPatLower = gMode === "-i" ? gPat.toLowerCase() : gPat;
-                            const matched = [];
-                            for (let li = 0; li < rawLines.length; li++) {
-                                const l = rawLines[li];
-                                const hit = gMode === "-i" ? l.toLowerCase().includes(gPatLower) : l.includes(gPat);
-                                if (gMode === "-v" ? !hit : hit)
-                                    matched.push(l);
-                            }
-                            stageStatus = matched.length === 0 ? 1 : 0;
+                            const grepRes = this.evalSyncGrep(rawLines, stageArgs, Boolean(rawState.errexit));
+                            if (grepRes === undefined)
+                                return undefined;
+                            stageStatus = grepRes.status;
                             if (stageStatus !== 0)
                                 failureStatus = stageStatus;
-                            outLines = gMode === "-c" ? [String(matched.length)] : matched;
+                            outLines = grepRes.lines;
                         }
                         else if (isInlineTac) {
                             if (inStr.length > 0 && !inStr.endsWith("\n"))
@@ -27199,49 +28003,10 @@ export class Runtime {
                             }
                         }
                         else if (isInlineJq) {
-                            const rawOut = stageArgs.length === 2;
-                            const filter = stageArgs[stageArgs.length - 1];
-                            const trimmedJson = inStr.trim();
-                            if (!trimmedJson.startsWith("{") || trimmedJson.includes("\n"))
-                                return undefined;
-                            let parsedObj;
-                            try {
-                                parsedObj = JSON.parse(trimmedJson);
-                            }
-                            catch {
-                                return undefined;
-                            }
-                            if (!parsedObj || typeof parsedObj !== "object" || Array.isArray(parsedObj))
-                                return undefined;
-                            const keys = filter.slice(1).split(".");
-                            let cur = parsedObj;
-                            for (let ki = 0; ki < keys.length; ki++) {
-                                if (cur === null || cur === undefined || typeof cur !== "object") {
-                                    cur = undefined;
-                                    break;
-                                }
-                                if (Array.isArray(cur))
-                                    return undefined;
-                                cur = Object.hasOwn(cur, keys[ki]) ? cur[keys[ki]] : undefined;
-                            }
-                            if (cur !== null && cur !== undefined && typeof cur === "object")
+                            const jqRes = this.evalSyncJq(inStr.trim(), stageArgs);
+                            if (jqRes === undefined)
                                 return undefined;
-                            if (rawOut) {
-                                if (typeof cur === "string") {
-                                    if (cur.includes("\n"))
-                                        return undefined;
-                                    outLines = [cur];
-                                }
-                                else if (typeof cur === "number" || typeof cur === "boolean") {
-                                    outLines = [String(cur)];
-                                }
-                                else {
-                                    outLines = ["null"];
-                                }
-                            }
-                            else {
-                                outLines = [JSON.stringify(cur ?? null)];
-                            }
+                            outLines = jqRes;
                         }
                         // These filters preserve the terminator of the final selected input line.
                         const preservesTerminator = firstName === "head" || firstName === "tail" || firstName === "rev" || firstName === "sed";
@@ -27318,62 +28083,66 @@ export class Runtime {
         if (pipeline.commands.length !== 1)
             return undefined;
         let cmd = pipeline.commands[0];
-        if ((cmd.kind === "arithmetic-for" || cmd.kind === "for") && cmd.redirects.length === 0 && !rawState.errexit && !rawState.nounset && !rawState.readonlyVariables?.size) {
+        if ((cmd.kind === "if" || cmd.kind === "case") && this.isPureSyncSubIfOrCase(cmd, rawState)) {
             const monitor = stateMonitor(state);
-            if (monitor) {
-                const store = arrayStore(rawState);
-                const existing = store?.get("PIPESTATUS");
-                const elem0 = existing ? existing.values.get(0) : undefined;
-                const canMutatePipeStatus = !existing || (!existing.associative && existing.references === 1 && existing.values.size === 1 && existing.maximum === 0 && elem0 !== undefined && elem0.text.references === 1 && elem0.text.bytes === 1 && !store.watches.has("PIPESTATUS") && !monitor.hasOverlay("PIPESTATUS") && !rawState.readonlyVariables?.has("PIPESTATUS"));
-                if (canMutatePipeStatus) {
-                    const capture = new Capture();
-                    capture.budget = this.budget;
-                    capture.signal = this.signal;
-                    const { descriptors: ignoredDescriptors, ...ioRest } = io;
-                    const subIO = { ...ioRest, stdout: capture };
-                    if (this.canSyncLoopBody(cmd.body, rawState, subIO)) {
-                        const { steps: bodySteps } = this.buildSyncLoopBody(cmd, rawState, subIO);
-                        if (bodySteps.length > 0 && bodySteps.every(s => s.isStdoutEcho === true)) {
-                            const indName = cmd.kind === "for" ? cmd.name : /^([a-zA-Z_][a-zA-Z_0-9]*)\s*=/.exec(cmd.expressions[0].source.trim())?.[1];
-                            if (indName && !store?.get(indName)) {
-                                const hadInd = Object.prototype.hasOwnProperty.call(rawState.variables, indName);
-                                const prevInd = rawState.variables[indName];
-                                const prevLastArg = rawState.lastArgument;
-                                let loopRes;
-                                rawState.depth++;
-                                try {
-                                    loopRes = this.trySyncLoop(cmd, pipeline, rawState, monitor, store, existing, elem0, true, subIO, part.line);
-                                }
-                                finally {
-                                    rawState.depth--;
-                                    if (prevLastArg !== undefined)
-                                        rawState.lastArgument = prevLastArg;
-                                    else
-                                        delete rawState.lastArgument;
-                                    if (hadInd && prevInd !== undefined)
-                                        monitor.publishStringVariable(indName, prevInd);
-                                    else {
-                                        delete rawState.variables[indName];
-                                        monitor.values.invalidate(indName);
-                                    }
-                                }
-                                if (loopRes !== undefined) {
-                                    rawState.substitutionStatus = loopRes;
-                                    rawState.status = loopRes;
-                                    const bytes = capture.takeBytes();
-                                    let str = sharedSyncPipeDecoder.decode(bytes);
-                                    let end = str.length;
-                                    while (end > 0 && str.charCodeAt(end - 1) === 10)
-                                        end--;
-                                    if (end < str.length)
-                                        str = str.slice(0, end);
-                                    return str;
-                                }
-                            }
+            if (!monitor)
+                return undefined;
+            let selectedBody;
+            if (cmd.kind === "if") {
+                for (const br of cmd.branches) {
+                    const bc = br.condition.lists[0].pipelines[0].commands[0];
+                    let condOk = false;
+                    if (bc.kind === "arithmetic") {
+                        condOk = this.evalSyncLoopArithStmt(bc.expression, rawState, io, this._syncArithTouched ?? new Set(), bc.line ?? part.line) === true;
+                    }
+                    else if (bc.kind === "conditional") {
+                        const st = this.tryEvalConditionalSync(bc.expression, rawState, monitor, arrayStore(rawState), io, bc.line ?? part.line);
+                        if (st === undefined)
+                            return undefined;
+                        condOk = st === 0;
+                    }
+                    else {
+                        const bExpr = this.extractPosixBracketCondExpr(bc, rawState, true, br.body);
+                        if (!bExpr)
+                            return undefined;
+                        const st = this.tryEvalConditionalSync(bExpr, rawState, monitor, arrayStore(rawState), io, bc.line ?? part.line);
+                        if (st === undefined)
+                            return undefined;
+                        condOk = st === 0;
+                    }
+                    if (condOk) {
+                        selectedBody = br.body;
+                        break;
+                    }
+                }
+                if (!selectedBody)
+                    selectedBody = cmd.otherwise;
+            }
+            else {
+                const subj = this.fastValueWord(cmd.subject, rawState, io, false, false, false, false, undefined, part.line);
+                if (typeof subj !== "string")
+                    return undefined;
+                const work = { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+                for (const cl of cmd.clauses) {
+                    let matched = false;
+                    for (const pw of cl.patterns) {
+                        if (pw.plain !== undefined && tryMatchesPatternSync(pw.plain, subj, work, false, false) === true) {
+                            matched = true;
+                            break;
                         }
                     }
+                    if (matched) {
+                        selectedBody = cl.body;
+                        break;
+                    }
                 }
             }
+            if (!selectedBody) {
+                rawState.substitutionStatus = 0;
+                rawState.status = 0;
+                return "";
+            }
+            cmd = selectedBody.lists[0].pipelines[0].commands[0];
         }
         const hasSingleStdinRedir = cmd.kind === "simple" &&
             cmd.redirects.length === 1 &&
@@ -27404,9 +28173,10 @@ export class Runtime {
             w0Plain === "cut" ||
             w0Plain === "wc" ||
             w0Plain === "sort" ||
+            w0Plain === "uniq" ||
             w0Plain === "tr" ||
             (hasSingleHereStringRedir && (w0Plain === "base64" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl"));
-        if (isSingleFileTool && !hasShellFunction(rawState, w0Plain) && this.commands.has(w0Plain)) {
+        if (isSingleFileTool && !hasShellFunction(rawState, w0Plain) && (this.commands.has(w0Plain) || ((w0Plain === "rev" || w0Plain === "tac") && Boolean(this.getExternalCommand(w0Plain))))) {
             const allArgs = [];
             let fOk = true;
             for (let i = 1; i < cmd.words.length; i++) {
@@ -27454,130 +28224,55 @@ 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));
                             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]);
+                            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");
                             }
-                        }
-                        else if (w0Plain === "jq" && (opArgs.length === 1 || opArgs.length === 2)) {
-                            const rawMode = opArgs.length === 2 && (opArgs[0] === "-r" || opArgs[0] === "--raw-output");
-                            const jqFilter = opArgs.length === 1 ? opArgs[0] : (rawMode ? opArgs[1] : "");
-                            if (/^\.[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*$/.test(jqFilter)) {
-                                try {
-                                    let cur = JSON.parse(fileStr.trim());
-                                    const keys = jqFilter.slice(1).split(".");
-                                    let validJq = true;
-                                    for (const k of keys) {
-                                        if (cur !== null && typeof cur === "object" && !Array.isArray(cur)) {
-                                            cur = cur[k];
-                                        }
-                                        else {
-                                            validJq = false;
-                                            break;
-                                        }
-                                    }
-                                    if (validJq && cur !== undefined && (cur === null || typeof cur === "string" || typeof cur === "number" || typeof cur === "boolean")) {
-                                        fileRes = cur === null ? "null" : typeof cur === "string" ? (rawMode ? cur : JSON.stringify(cur)) : String(cur);
-                                    }
-                                }
-                                catch { }
+                            else if (byteCount !== undefined) {
+                                const slicedBytes = w0Plain === "head"
+                                    ? view.subarray(0, Math.min(view.byteLength, byteCount))
+                                    : (byteCount === 0 ? view.subarray(0, 0) : view.subarray(Math.max(0, view.byteLength - byteCount), view.byteLength));
+                                fileRes = sharedSyncPipeDecoder.decode(slicedBytes);
                             }
                         }
-                        else if (w0Plain === "awk" && (opArgs.length >= 1 && opArgs.length <= 3)) {
-                            const normAwk = opArgs.length === 3 && opArgs[0] === "-F" ? ["-F" + opArgs[1], opArgs[2]] : opArgs;
-                            let awkSep;
-                            let awkProg;
-                            if (normAwk.length === 1)
-                                awkProg = normAwk[0];
-                            else if (normAwk.length === 2 && normAwk[0].length === 3 && normAwk[0].startsWith("-F") && normAwk[0][2] !== "\\") {
-                                awkSep = normAwk[0].slice(2);
-                                awkProg = normAwk[1];
-                            }
-                            const awkM = awkProg ? /^\s*\{\s*print(?:\s+(\$(?:[0-9]+|NF)(?:\s*,\s*\$(?:[0-9]+|NF))*))?\s*;?\s*\}\s*$/.exec(awkProg) : null;
-                            if (awkM) {
-                                const toks = awkM[1] ? awkM[1].split(",").map(t => t.trim().slice(1)) : ["0"];
-                                const outLines = [];
-                                for (let li = 0; li < rawLines.length; li++) {
-                                    const l = rawLines[li];
-                                    if (toks.length === 1 && toks[0] === "0") {
-                                        outLines.push(l);
-                                    }
-                                    else {
-                                        const fields = awkSep !== undefined ? (awkSep === " " ? l.trim().split(/\s+/).filter(Boolean) : l.split(awkSep)) : l.trim().split(/\s+/).filter(Boolean);
-                                        const vals = toks.map(tk => {
-                                            if (tk === "0")
-                                                return l;
-                                            const idx = tk === "NF" ? fields.length : Number(tk);
-                                            if (idx === 0)
-                                                return l;
-                                            return idx >= 1 && idx <= fields.length ? fields[idx - 1] : "";
-                                        });
-                                        outLines.push(vals.join(" "));
-                                    }
-                                }
-                                fileRes = outLines.join("\n");
-                            }
-                        }
-                        else if (w0Plain === "grep" && !rawState.errexit && (opArgs.length === 1 || opArgs.length === 2)) {
-                            const mode = opArgs.length === 2 ? opArgs[0] : "";
-                            const pat = opArgs[opArgs.length - 1];
-                            if ((opArgs.length === 1 || mode === "-v" || mode === "-i" || mode === "-c" || mode === "-F") && /^[a-zA-Z0-9_ :;,/-]+$/.test(pat)) {
-                                const needle = mode === "-i" ? pat.toLowerCase() : pat;
-                                const matched = [];
-                                for (let li = 0; li < rawLines.length; li++) {
-                                    const l = rawLines[li];
-                                    const hay = mode === "-i" ? l.toLowerCase() : l;
-                                    const ok = hay.includes(needle);
-                                    if (mode === "-v" ? !ok : ok)
-                                        matched.push(l);
-                                }
-                                exitStatus = matched.length > 0 ? 0 : 1;
-                                fileRes = mode === "-c" ? String(matched.length) : matched.join("\n");
-                            }
+                        else if (w0Plain === "jq") {
+                            const jqRes = this.evalSyncJq(fileStr.trim(), opArgs);
+                            if (jqRes !== undefined)
+                                fileRes = jqRes.join("\n");
                         }
-                        else if (w0Plain === "sed" && (opArgs.length === 1 || (opArgs.length === 2 && opArgs[0] === "-e"))) {
-                            const sedExpr = opArgs[opArgs.length - 1];
-                            const sedM = /^s\/([a-zA-Z0-9_ :;,-]+)\/([a-zA-Z0-9_ :;,./-]*)\/(g?)$/.exec(sedExpr);
-                            if (sedM) {
-                                const pat = sedM[1];
-                                const rep = sedM[2];
-                                const isGlobal = sedM[3] === "g";
-                                fileRes = rawLines.map(l => (isGlobal ? l.split(pat).join(rep) : l.replace(pat, () => rep))).join("\n");
-                            }
+                        else if (w0Plain === "awk") {
+                            const awkRes = this.evalSyncAwk(rawLines, opArgs);
+                            if (awkRes !== undefined)
+                                fileRes = awkRes.join("\n");
                         }
-                        else if (w0Plain === "cut" && opArgs.length >= 1 && opArgs.length <= 4) {
-                            const normCut = [];
-                            for (let ci = 0; ci < opArgs.length; ci++) {
-                                const ca = opArgs[ci];
-                                if ((ca === "-d" || ca === "-f") && ci + 1 < opArgs.length)
-                                    normCut.push(ca + opArgs[++ci]);
-                                else
-                                    normCut.push(ca);
-                            }
-                            if (normCut.length === 2 && normCut[0] === "-c" && /^[1-9][0-9]*-[1-9][0-9]*$/.test(normCut[1])) {
-                                const [cStart, cEnd] = normCut[1].split("-").map(Number);
-                                fileRes = rawLines.map(l => Array.from(l).slice(cStart - 1, cEnd).join("")).join("\n");
-                            }
-                            else {
-                                const delim = normCut.length === 2 && normCut[0].length === 3 && normCut[0].startsWith("-d") ? normCut[0][2] : (normCut.length === 1 ? "\t" : undefined);
-                                const fSpec = normCut.length === 2 ? normCut[1] : normCut[0];
-                                if (delim !== undefined && fSpec && fSpec.startsWith("-f") && /^[1-9][0-9]*(?:,[1-9][0-9]*)*$/.test(fSpec.slice(2))) {
-                                    const fIdxs = fSpec.slice(2).split(",").map(s => Number(s) - 1);
-                                    fileRes = rawLines.map(l => {
-                                        if (!l.includes(delim))
-                                            return l;
-                                        const parts = l.split(delim);
-                                        return fIdxs.map(idx => (idx < parts.length ? parts[idx] : "")).join(delim);
-                                    }).join("\n");
-                                }
+                        else if (w0Plain === "grep") {
+                            const grepRes = this.evalSyncGrep(rawLines, opArgs, Boolean(rawState.errexit));
+                            if (grepRes !== undefined) {
+                                exitStatus = grepRes.status;
+                                fileRes = grepRes.lines.join("\n");
                             }
                         }
+                        else if (w0Plain === "sed") {
+                            const sedRes = this.evalSyncSed(rawLines, opArgs);
+                            if (sedRes !== undefined)
+                                fileRes = sedRes.join("\n");
+                        }
+                        else if (w0Plain === "cut") {
+                            const cutRes = this.evalSyncCut(rawLines, opArgs, byteLocale(rawState.variables));
+                            if (cutRes !== undefined)
+                                fileRes = cutRes.join("\n");
+                        }
                         else if (w0Plain === "wc" && opArgs.length === 1 && (opArgs[0] === "-l" || opArgs[0] === "-c" || opArgs[0] === "-w")) {
                             let count = 0;
                             if (opArgs[0] === "-l") {
@@ -27594,44 +28289,27 @@ export class Runtime {
                             }
                             fileRes = (hasSingleStdinRedir || hasSingleHereStringRedir) ? String(count) : `${count} ${fileArg}`;
                         }
-                        else if (w0Plain === "sort" && !byteLocale(rawState.variables) && (opArgs.length === 0 || (opArgs.length === 1 && opArgs[0] === "-r"))) {
-                            const revSort = opArgs[0] === "-r";
-                            fileRes = [...rawLines].sort((a, b) => (a < b ? (revSort ? 1 : -1) : a > b ? (revSort ? -1 : 1) : 0)).join("\n");
-                        }
-                        else if (w0Plain === "tr" && (hasSingleStdinRedir || hasSingleHereStringRedir) && opArgs.length === 2) {
-                            if (opArgs[0] === "a-z" && opArgs[1] === "A-Z")
-                                fileRes = fileStr.toUpperCase();
-                            else if (opArgs[0] === "A-Z" && opArgs[1] === "a-z")
-                                fileRes = fileStr.toLowerCase();
-                            else if (opArgs[0] === "-d" && /^[a-zA-Z0-9_ :;,./-]+$/.test(opArgs[1])) {
-                                const delSet = this.expandSyncTrCharSet(opArgs[1]);
-                                let out = "";
-                                for (let ci = 0; ci < fileStr.length; ci++) {
-                                    const ch = fileStr[ci];
-                                    if (!delSet.has(ch))
-                                        out += ch;
-                                }
-                                fileRes = out;
-                            }
-                            else if (opArgs[0] === "-s" && opArgs[1].length === 1) {
-                                const sq = opArgs[1];
-                                let out = "";
-                                let prevSq = false;
-                                for (let ci = 0; ci < fileStr.length; ci++) {
-                                    const ch = fileStr[ci];
-                                    if (ch === sq) {
-                                        if (!prevSq) {
-                                            out += ch;
-                                            prevSq = true;
-                                        }
-                                    }
-                                    else {
-                                        out += ch;
-                                        prevSq = false;
-                                    }
+                        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]);
                                 }
-                                fileRes = out;
+                                uIdx = uEnd;
                             }
+                            fileRes = outLines.join("\n");
+                        }
+                        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)