@poe-platform/safe-bash 0.1.749 → 0.1.751

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

@@ -9439,7 +9439,8 @@ export class Runtime {
                         }
                         return !rem.associative && rem.references === 1;
                     }
-                    return this.isPureSyncValueWord(e.left, rawState) && (e.operator === "==" || e.operator === "=" || e.operator === "!=" ? this.canSyncPatternWordParts(e.right, rawState) : this.isPureSyncValueWord(e.right, rawState));
+                    // Unquoted patterns may need the asynchronous matcher after values change.
+                    return this.isPureSyncValueWord(e.left, rawState) && this.isPureSyncValueWord(e.right, rawState) && (!(e.operator === "==" || e.operator === "=" || e.operator === "!=") || (e.right.parts.length > 0 && e.right.parts.every(p => p.quoted)));
                 }
                 if (e.kind === "not")
                     return checkCondNoFile(e.operand);
@@ -9795,10 +9796,19 @@ 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, rawState) !== undefined;
+                return !requireTotal && 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;
+                if (requireTotal) {
+                    // Variable patterns can change during the loop. Only admit a static
+                    // pattern whose synchronous matcher is guaranteed to return a result.
+                    if (!expr.right.parts.every((p, idx) => p.kind === "text" && !p.byteValue && (p.quoted || idx > 0 || !p.value.startsWith("~"))))
+                        return false;
+                    const pattern = expr.right.parts.map(p => p.kind === "text" ? (p.quoted ? p.value.replace(/[\\*?[\]()]/g, "\\$&") : p.value) : "").join("");
+                    const work = { remaining: 4096, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+                    return tryMatchesPatternSync(pattern, "", work, false, true) !== undefined;
+                }
                 if (expr.right.parts.length > 0 && expr.right.parts.every((p, idx) => (p.kind === "text" && !p.byteValue && (p.quoted || idx > 0 || !p.value.startsWith("~"))) || (p.kind === "variable" && !p.indirect && !p.prefixNames && !p.length && !p.substring && !p.transform && p.operator === undefined && getArraySelector(p) === undefined)))
                     return true;
                 return false;
@@ -9987,7 +9997,10 @@ export class Runtime {
                     return undefined;
                 const syncTouched = this._syncArithRawWriteOnly ? this._syncArithTouched : undefined;
                 const lTrim = left.trim() || "0";
-                let lNum = resolveSimpleArithOperand(lTrim, rawState, monitor, store, syncTouched);
+                // Preserve all signed 64-bit literal digits instead of rounding through Number.
+                let lNum = lTrim.length > 13 && /^-?[0-9]{1,19}$/.test(lTrim)
+                    ? BigInt.asIntN(64, BigInt(lTrim))
+                    : resolveSimpleArithOperand(lTrim, rawState, monitor, store, syncTouched);
                 if (lNum === undefined) {
                     const lExpr = tryEvalSimpleExpandedArith(lTrim, rawState, monitor, store, syncTouched);
                     if (lExpr !== undefined)
@@ -9996,7 +10009,9 @@ export class Runtime {
                 if (lNum === undefined)
                     return undefined;
                 const rTrim = right.trim() || "0";
-                let rNum = resolveSimpleArithOperand(rTrim, rawState, monitor, store, syncTouched);
+                let rNum = rTrim.length > 13 && /^-?[0-9]{1,19}$/.test(rTrim)
+                    ? BigInt.asIntN(64, BigInt(rTrim))
+                    : resolveSimpleArithOperand(rTrim, rawState, monitor, store, syncTouched);
                 if (rNum === undefined) {
                     const rExpr = tryEvalSimpleExpandedArith(rTrim, rawState, monitor, store, syncTouched);
                     if (rExpr !== undefined)
@@ -10004,6 +10019,10 @@ export class Runtime {
                 }
                 if (rNum === undefined)
                     return undefined;
+                if (typeof lNum !== typeof rNum) {
+                    lNum = BigInt(lNum);
+                    rNum = BigInt(rNum);
+                }
                 let ok;
                 switch (expr.operator) {
                     case "-eq":
@@ -13025,7 +13044,6 @@ export class Runtime {
                         rawState.substitutionStatus = 0;
                         if (rawState.variables._ !== undefined)
                             delete rawState.variables._;
-                        rawState.lastArgument = fnArgs.length > 0 ? fnArgs[fnArgs.length - 1] : w0Plain;
                         const positional = rawState.positional;
                         let fnArgsBytes = 0;
                         for (let i = 0; i < fnArgs.length; i++)
@@ -13075,6 +13093,7 @@ export class Runtime {
                                     positionalSetVersion,
                                     savedPositionals: resumeSavedPos,
                                     callerLoopDepth,
+                                    lastArgument: fnArgs.at(-1) ?? w0Plain,
                                     listIndex: bodyRes.listIndex,
                                     pipelineIndex: bodyRes.pipelineIndex,
                                 });
@@ -13139,6 +13158,7 @@ export class Runtime {
                             this.setSyncPipeStatusCell(activeExisting, statusStr);
                             activeStore.changed(monitor.chargeInternal(syncPipeStatusCharge, syncPipeStatusTickets), "PIPESTATUS");
                         }
+                        rawState.lastArgument = fnArgs.at(-1) ?? w0Plain;
                         rawState.status = exitStatus;
                         if (exitStatus !== 0 && !ignored && rawState.errexit)
                             throw new Flow("exit", exitStatus);
@@ -13237,7 +13257,6 @@ export class Runtime {
                                 rawState.substitutionStatus = 0;
                                 if (rawState.variables._ !== undefined)
                                     delete rawState.variables._;
-                                rawState.lastArgument = lastCmdArg;
                                 rawState.depth++;
                                 let evalStatus;
                                 try {
@@ -13247,6 +13266,7 @@ export class Runtime {
                                     rawState.depth--;
                                 }
                                 if (typeof evalStatus === "number") {
+                                    rawState.lastArgument = lastCmdArg;
                                     if (cachedUnit.script.lists.length === 0) {
                                         const activeStore = monitor.store;
                                         const activeExisting = activeStore?.get("PIPESTATUS");
@@ -13586,6 +13606,11 @@ export class Runtime {
                 continue;
             }
             if (part.kind === "variable") {
+                // Unsubscripted array references expand element zero through the normal
+                // evaluator. fastValueWord cannot guarantee that expansion throughout
+                // a loop, so reject it before executing any loop effects.
+                if (stateMonitor(rawState)?.store?.get(part.name))
+                    return false;
                 // These expansions can require multiple fields or asynchronous quoting
                 // as loop state changes. Decide before the loop produces any effects.
                 if (this._syncLoopFnCheckDepth > 0 && (part.substring || getArraySelector(part)?.kind === "element"))
@@ -13736,25 +13761,12 @@ export class Runtime {
                 if (list.terminator || list.pipelines.length !== 1)
                     return false;
                 const p = list.pipelines[0];
-                if (p.negate || p.commands.length < 1 || p.commands.length > 5)
+                // Pipeline buffers can overflow after variable or stage expansion.
+                // A synchronous loop cannot resume after earlier body effects, so keep
+                // bounded pipelines on the normal substitution execution path.
+                if (p.negate || p.commands.length !== 1)
                     return false;
                 let cmd = p.commands[0];
-                const hasSingleStdinRedir = cmd.kind === "simple" &&
-                    cmd.redirects.length === 1 &&
-                    cmd.redirects[0].operator === "<" &&
-                    (cmd.redirects[0].descriptor === undefined || cmd.redirects[0].descriptor === 0) &&
-                    !cmd.redirects[0].move &&
-                    !cmd.redirects[0].document &&
-                    cmd.redirects[0].target.plain !== undefined &&
-                    !cmd.redirects[0].target.plain.startsWith("-") &&
-                    cmd.redirects[0].target.plain !== "/dev/stdin";
-                const hasSingleHereStringRedir = cmd.kind === "simple" &&
-                    cmd.redirects.length === 1 &&
-                    cmd.redirects[0].operator === "<<<" &&
-                    (cmd.redirects[0].descriptor === undefined || cmd.redirects[0].descriptor === 0) &&
-                    !cmd.redirects[0].move &&
-                    !cmd.redirects[0].document &&
-                    this.isPureSyncValueWord(cmd.redirects[0].target, rawState);
                 // 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")
@@ -13762,7 +13774,7 @@ export class Runtime {
                 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)
+                if (cmd.kind !== "simple" || cmd.redirects.length > 0 || cmd.words.length === 0)
                     return false;
                 let w0Plain = cmd.words[0].plain;
                 // Range-aware tr and Buffer-free 76-col base64 are handled below.
@@ -13777,10 +13789,10 @@ export class Runtime {
                         fnBody.body.lists[0].pipelines[0].commands.length === 1 &&
                         fnBody.body.lists[0].pipelines[0].commands[0].kind === "simple" &&
                         fnBody.body.lists[0].pipelines[0].commands[0].redirects.length === 0 &&
-                        cmd.words.slice(1).every(w => this.isPureSyncValueWord(w, rawState))) {
+                        cmd.words.slice(1).every(w => this.isPureSyncValueWord(w, rawState) && w.parts.length > 0 && w.parts.every(part => part.quoted || (part.kind === "text" && part.value.length > 0 && !part.value.includes(" ") && !part.value.includes("\t") && !part.value.includes("\n") && !part.value.includes("{") && !hasGlobOrEscape(part.value, true))))) {
                         const innerCmd = fnBody.body.lists[0].pipelines[0].commands[0];
                         const innerW0 = innerCmd.words[0]?.plain;
-                        if (innerW0 && !rawState.functions.has(innerW0) && !rawState.extensions?.builtins.has(innerW0)) {
+                        if (innerW0 && (innerW0 === "echo" || innerW0 === "printf" || innerW0 === "dirname" || innerW0 === "basename" || innerW0 === "pwd" || innerW0 === "command" || innerW0 === "type" || innerW0 === "seq") && !rawState.functions.has(innerW0) && !rawState.extensions?.builtins.has(innerW0)) {
                             cmd = innerCmd;
                             w0Plain = innerW0;
                         }
@@ -13796,143 +13808,23 @@ export class Runtime {
                     return false;
                 }
                 if ((w0Plain === "command" && cmd.words[1]?.plain === "-v") || (w0Plain === "type" && cmd.words[1]?.plain === "-t")) {
-                    if (p.commands.length === 1 &&
-                        cmd.words.length === 3 &&
-                        !rawState.functions.has(w0Plain) &&
-                        !rawState.extensions?.builtins.has(w0Plain) &&
-                        this.isPureSyncValueWord(cmd.words[2], rawState) &&
-                        ((cmd.words[2].plain !== undefined && this.tryResolveSyncDiscovery(w0Plain === "command" ? "name" : "kind", cmd.words[2].plain, rawState) !== undefined) ||
-                            (this._isMemoryBackingFs && this.backingFs?.capabilities?.permissions !== true))) {
-                        continue;
-                    }
+                    // PATH entries can change after admission, making discovery decline.
                     return false;
                 }
-                const isFileCommand = w0Plain === "cat" ||
-                    w0Plain === "head" ||
-                    w0Plain === "tail" ||
-                    w0Plain === "jq" ||
-                    w0Plain === "awk" ||
-                    w0Plain === "grep" ||
-                    w0Plain === "sed" ||
-                    w0Plain === "cut" ||
-                    w0Plain === "wc" ||
-                    w0Plain === "sort" ||
-                    w0Plain === "uniq" ||
-                    w0Plain === "tr" ||
-                    (hasSingleHereStringRedir && (w0Plain === "base64" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl" || w0Plain === "paste" || w0Plain === "numfmt"));
-                const def = w0Plain ? (this.commands.get(w0Plain) ?? ((w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl" || w0Plain === "paste" || w0Plain === "jq") ? this.getExternalCommand(w0Plain) : undefined)) : undefined;
-                if (!w0Plain || (w0Plain !== "printf" && w0Plain !== "echo" && w0Plain !== "dirname" && w0Plain !== "basename" && w0Plain !== "seq" && !isFileCommand) || !def || rawState.functions.has(w0Plain) || rawState.extensions?.builtins.has(w0Plain))
+                // File and here-string evaluators can decline on mutable input. Keep
+                // these on the normal path, which can handle arbitrary input sizes.
+                const def = w0Plain ? this.commands.get(w0Plain) : undefined;
+                if (!w0Plain || (w0Plain !== "printf" && w0Plain !== "echo" && w0Plain !== "dirname" && w0Plain !== "basename" && w0Plain !== "seq") || !def || rawState.functions.has(w0Plain) || rawState.extensions?.builtins.has(w0Plain))
                     return false;
-                if ((hasSingleStdinRedir || hasSingleHereStringRedir) && !isFileCommand)
-                    return false;
-                if (w0Plain === "printf" ? def.execute !== printfCommand.execute : w0Plain === "echo" ? !defaultEchoExecutors.has(def.execute) : (w0Plain === "seq" || w0Plain === "rev" || w0Plain === "tac" || w0Plain === "nl" || w0Plain === "paste" || w0Plain === "jq") ? (!builtInDirectContextExecutors.has(def.execute) && customRegisteredCommands.has(def.execute)) : !builtInDirectContextExecutors.has(def.execute))
+                if (w0Plain === "printf" ? def.execute !== printfCommand.execute : w0Plain === "echo" ? !defaultEchoExecutors.has(def.execute) : w0Plain === "seq" ? (!builtInDirectContextExecutors.has(def.execute) && customRegisteredCommands.has(def.execute)) : !builtInDirectContextExecutors.has(def.execute))
                     return false;
                 if (!cmd.words.slice(1).every(w => this.isPureSyncValueWord(w, rawState)))
                     return false;
-                if (isFileCommand) {
-                    if (w0Plain === "tr" && !hasSingleStdinRedir && !hasSingleHereStringRedir)
-                        return false;
-                    if (w0Plain === "grep" && rawState.errexit)
-                        return false;
-                    if (!hasSingleHereStringRedir) {
-                        const fPlain = hasSingleStdinRedir ? cmd.redirects[0].target.plain : cmd.words[cmd.words.length - 1]?.plain;
-                        if (!fPlain || fPlain.startsWith("-") || fPlain === "/dev/stdin")
-                            return false;
-                        const vCheck = this.tryReadMemoryFileViewSync(resolvePath(rawState.cwd, fPlain), false);
-                        if (!vCheck || vCheck.byteLength > 16384 || vCheck.includes(0))
-                            return false;
-                    }
-                    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") {
-                        if (opCount !== 0)
-                            return false;
-                    }
-                    else {
-                        if (p.commands.length !== 1 && !hasSingleHereStringRedir)
-                            return false;
-                        if (w0Plain === "head" || w0Plain === "tail") {
-                            const validHT = opCount === 0 ||
-                                (opCount === 1 && op0 !== undefined && (/^-(?:n|c|--lines=|--bytes=)?[0-9]{1,5}$/.test(op0) || /^--(?:lines|bytes)=[0-9]{1,5}$/.test(op0) || (w0Plain === "tail" && /^(?:-n|--lines=)\+[0-9]{1,5}$/.test(op0)) || (w0Plain === "head" && /^(?:-n|--lines=)-[0-9]{1,5}$/.test(op0)))) ||
-                                (opCount === 2 && ((op0 === "-n" && op1 !== undefined && (/^[0-9]{1,5}$/.test(op1) || (w0Plain === "tail" && /^\+[0-9]{1,5}$/.test(op1)) || (w0Plain === "head" && /^-[0-9]{1,5}$/.test(op1)))) || (op0 === "-c" && op1 !== undefined && /^[0-9]{1,5}$/.test(op1))));
-                            if (!validHT)
-                                return false;
-                        }
-                        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") {
-                            // Probe non-ASCII input: loop data can change after admission.
-                            if (plainOps.length !== opCount || this.evalSyncCut(["é"], plainOps, byteLocale(rawState.variables)) === undefined)
-                                return false;
-                        }
-                        else if (w0Plain === "sed") {
-                            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") {
-                            const input = this.extractLoopInvariantInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
-                            if (plainOps.length !== opCount || input === undefined)
-                                return false;
-                            const lines = input.length === 0 ? [] : input.split("\n");
-                            if (input.endsWith("\n"))
-                                lines.pop();
-                            if (this.evalSyncAwk(lines, plainOps) === undefined)
-                                return false;
-                        }
-                        else if (w0Plain === "jq") {
-                            if (plainOps.length !== opCount)
-                                return false;
-                            const jqIn = this.extractLoopInvariantInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState)?.trim();
-                            if (jqIn === undefined || this.evalSyncJq(jqIn, plainOps) === undefined)
-                                return false;
-                        }
-                        else if (w0Plain === "wc") {
-                            if (opCount !== 1 || this.normalizeSyncWcFlag(op0) === undefined)
-                                return false;
-                        }
-                        else if (w0Plain === "sort") {
-                            if (plainOps.length !== opCount || this.evalSyncSort([], plainOps, byteLocale(rawState.variables)) === undefined)
-                                return false;
-                        }
-                        else if (w0Plain === "uniq") {
-                            if (plainOps.length !== opCount || this.evalSyncUniq([], plainOps) === undefined)
-                                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;
-                        }
-                        else if (w0Plain === "nl") {
-                            if (plainOps.length !== opCount || this.evalSyncNl([], plainOps) === undefined)
-                                return false;
-                        }
-                        else if (w0Plain === "paste") {
-                            if (plainOps.length !== opCount || this.evalSyncPaste([], plainOps) === undefined)
-                                return false;
-                        }
-                        else if (w0Plain === "numfmt") {
-                            const nmCheck = this.extractLoopInvariantInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState)?.trim();
-                            if (nmCheck === undefined || plainOps.length !== opCount || this.evalSyncNumfmt(nmCheck.split("\n"), plainOps) === undefined)
-                                return false;
-                        }
-                    }
-                }
+                // These substitutions consume one value per word. Unquoted expansions
+                // can split, glob, or disappear, including after loop admission.
+                if ((w0Plain === "echo" || w0Plain === "basename" || w0Plain === "dirname") &&
+                    !cmd.words.slice(1).every(w => w.parts.length > 0 && w.parts.every(part => part.quoted || (part.kind === "text" && part.value.length > 0 && !part.value.includes(" ") && !part.value.includes("\t") && !part.value.includes("\n") && !part.value.includes("{") && !hasGlobOrEscape(part.value, true)))))
+                    return false;
                 if (w0Plain === "printf") {
                     if (!this.isSyncPrintfCallOk(cmd, 1, rawState, this._activePrintfInductionName))
                         return false;
@@ -13972,138 +13864,18 @@ export class Runtime {
                         return false;
                 }
                 else if (w0Plain === "seq") {
-                    const isSeqIntWord = (w) => {
-                        if (w.plain !== undefined)
-                            return /^-?[0-9]{1,7}$/.test(w.plain);
-                        if (w.parts.length === 1) {
-                            const p0 = w.parts[0];
-                            if (p0.kind === "arithmetic")
-                                return true;
-                            if (p0.kind === "variable" && !p0.indirect && !p0.prefixNames && !p0.substring && !p0.transform && p0.operator === undefined && getArraySelector(p0) === undefined) {
-                                const cur = rawState.variables[p0.name];
-                                return cur !== undefined && /^-?[0-9]{1,7}$/.test(cur);
-                            }
-                        }
+                    // Literal operands cannot change after admission. Arithmetic and
+                    // variables use the normal path, where seq can report invalid input.
+                    if (cmd.words.length < 2 || cmd.words.length > 4)
                         return false;
-                    };
-                    if (cmd.words.length < 2 || cmd.words.length > 4 || !cmd.words.slice(1).every(isSeqIntWord))
+                    const operands = cmd.words.slice(1).map(w => w.plain);
+                    if (!operands.every(value => value !== undefined && Number.isInteger(Number(value)) && String(Number(value)) === value && Math.abs(Number(value)) <= 9999999))
                         return false;
-                }
-                if (p.commands.length >= 2) {
-                    if ((w0Plain !== "printf" && w0Plain !== "echo" && w0Plain !== "seq" && w0Plain !== "cat" && !hasSingleHereStringRedir) || syncPurePipelineSlotInUse || !this.budget.canSyncPurePipe || rawState.errexit || rawState.nounset)
+                    const first = operands.length === 1 ? 1 : Number(operands[0]);
+                    const increment = operands.length === 3 ? Number(operands[1]) : 1;
+                    const last = Number(operands[operands.length - 1]);
+                    if (increment === 0 || Math.abs((last - first) / increment) > 1024)
                         return false;
-                    if (w0Plain === "printf") {
-                        if (!this.isSyncPrintfCallOk(cmd, 1, rawState, this._activePrintfInductionName))
-                            return false;
-                    }
-                    for (let sIdx = 1; sIdx < p.commands.length; sIdx++) {
-                        const sCmd = p.commands[sIdx];
-                        if (sCmd.kind !== "simple" || sCmd.redirects.length !== 0 || sCmd.words.length === 0)
-                            return false;
-                        const sName = sCmd.words[0].plain;
-                        // Range-aware tr and Buffer-free 76-col base64 are handled in pipeline stages.
-                        if (!sName || (sName !== "cut" && sName !== "tr" && sName !== "sort" && sName !== "head" && sName !== "tail" && sName !== "wc" && sName !== "sed" && sName !== "uniq" && sName !== "rev" && sName !== "awk" && sName !== "grep" && sName !== "jq" && sName !== "base64" && sName !== "tac" && sName !== "nl" && sName !== "paste" && sName !== "numfmt"))
-                            return false;
-                        const sDef = this.commands.get(sName) ?? ((sName === "rev" || sName === "tac" || sName === "nl" || sName === "paste" || sName === "jq") ? this.getExternalCommand(sName) : undefined);
-                        if (!sDef || customRegisteredCommands.has(sDef.execute) || (sName !== "rev" && sName !== "tac" && sName !== "nl" && sName !== "paste" && sName !== "jq" && !builtInDirectContextExecutors.has(sDef.execute)))
-                            return false;
-                        if (rawState.functions.has(sName) || rawState.extensions?.builtins.has(sName))
-                            return false;
-                        const sArgWords = sCmd.words.slice(1);
-                        const sPlainArgs = [];
-                        let allPlainStageArgs = true;
-                        for (let k = 0; k < sArgWords.length; k++) {
-                            const sw = sArgWords[k];
-                            const sp = sw.plain ?? (sw.parts.length > 0 && sw.parts.every(pt => pt.kind === "text") ? sw.parts.map(pt => pt.value).join("") : undefined);
-                            if (sp === undefined) {
-                                allPlainStageArgs = false;
-                                break;
-                            }
-                            sPlainArgs.push(sp);
-                        }
-                        if (!allPlainStageArgs)
-                            return false;
-                        if (sName === "sort") {
-                            if (this.evalSyncSort([], sPlainArgs, byteLocale(rawState.variables)) === undefined)
-                                return false;
-                        }
-                        else if (sName === "uniq") {
-                            if (this.evalSyncUniq([], sPlainArgs) === undefined)
-                                return false;
-                        }
-                        else if (sName === "wc") {
-                            if (sPlainArgs.length !== 1 || this.normalizeSyncWcFlag(sPlainArgs[0]) === undefined)
-                                return false;
-                        }
-                        else if (sName === "head" || sName === "tail") {
-                            const okHT = sPlainArgs.length === 0 || (sPlainArgs.length === 1 && (/^-(?:n|c)?[0-9]{1,5}$/.test(sPlainArgs[0]) || /^--(?:lines|bytes)=[0-9]{1,5}$/.test(sPlainArgs[0]) || (sName === "tail" && /^(?:-n|--lines=)\+[0-9]{1,5}$/.test(sPlainArgs[0])) || (sName === "head" && /^(?:-n|--lines=)-[0-9]{1,5}$/.test(sPlainArgs[0])))) || (sPlainArgs.length === 2 && ((sPlainArgs[0] === "-n" && (/^[0-9]{1,5}$/.test(sPlainArgs[1]) || (sName === "tail" && /^\+[0-9]{1,5}$/.test(sPlainArgs[1])) || (sName === "head" && /^-[0-9]{1,5}$/.test(sPlainArgs[1])))) || (sPlainArgs[0] === "-c" && /^[0-9]{1,5}$/.test(sPlainArgs[1]))));
-                            if (!okHT)
-                                return false;
-                        }
-                        else if (sName === "cut") {
-                            // Byte cuts may reject non-ASCII data on a later iteration.
-                            if (this.evalSyncCut(["é"], sPlainArgs, byteLocale(rawState.variables)) === undefined)
-                                return false;
-                        }
-                        else if (sName === "sed") {
-                            if (this.evalSyncSed([], sPlainArgs) === undefined)
-                                return false;
-                        }
-                        else if (sName === "awk") {
-                            if (sIdx !== 1)
-                                return false;
-                            const input = this.extractLoopInvariantInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState);
-                            if (input === undefined)
-                                return false;
-                            const lines = input.length === 0 ? [] : input.split("\n");
-                            if (input.endsWith("\n"))
-                                lines.pop();
-                            if (this.evalSyncAwk(lines, sPlainArgs) === undefined)
-                                return false;
-                        }
-                        else if (sName === "grep") {
-                            if (this.evalSyncGrep([], sPlainArgs, Boolean(rawState.errexit)) === undefined)
-                                return false;
-                        }
-                        else if (sName === "tr") {
-                            if (this.evalSyncTr("", sPlainArgs) === undefined)
-                                return false;
-                        }
-                        else if (sName === "jq") {
-                            if (sIdx !== 1)
-                                return false;
-                            const jqIn = this.extractLoopInvariantInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState)?.trim();
-                            if (jqIn === undefined || this.evalSyncJq(jqIn, sPlainArgs) === undefined)
-                                return false;
-                        }
-                        else if (sName === "base64") {
-                            if (sPlainArgs.length !== 0)
-                                return false;
-                        }
-                        else if (sName === "tac") {
-                            if (sPlainArgs.length !== 0 || (w0Plain !== "echo" && !hasSingleHereStringRedir))
-                                return false;
-                        }
-                        else if (sName === "nl") {
-                            if ((w0Plain !== "echo" && !hasSingleHereStringRedir) || this.evalSyncNl([], sPlainArgs) === undefined)
-                                return false;
-                        }
-                        else if (sName === "paste") {
-                            if (this.evalSyncPaste([], sPlainArgs) === undefined)
-                                return false;
-                        }
-                        else if (sName === "numfmt") {
-                            if (sIdx !== 1)
-                                return false;
-                            const nmCheck = this.extractLoopInvariantInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState)?.trim();
-                            if (nmCheck === undefined || this.evalSyncNumfmt(nmCheck.split("\n"), sPlainArgs) === undefined)
-                                return false;
-                        }
-                        else if (sName === "rev") {
-                            if (sPlainArgs.length !== 0)
-                                return false;
-                        }
-                    }
                 }
                 continue;
             }
@@ -14137,11 +13909,11 @@ export class Runtime {
                 if (isNumOp && checkIntVars) {
                     const isGuaranteedIntWord = (w) => {
                         if (w.plain !== undefined)
-                            return /^-?[0-9]+$/.test(w.plain);
+                            return /^-?[0-9]{1,16}$/.test(w.plain);
                         if (w.parts.length === 1) {
                             const p0 = w.parts[0];
                             if (p0.kind === "arithmetic")
-                                return true;
+                                return false;
                             if (p0.kind === "variable" && !p0.indirect && !p0.prefixNames && !p0.substring && !p0.transform && p0.operator === undefined && getArraySelector(p0) === undefined) {
                                 if (script) {
                                     for (const lst of script.lists) {
@@ -14149,14 +13921,14 @@ export class Runtime {
                                             const c0 = pl.commands[0];
                                             if (c0?.kind === "simple" && c0.words.length === 1) {
                                                 const asg = this.assignment(c0.words[0]);
-                                                if (asg?.name === p0.name && (!asg.value.plain || !/^-?[0-9]+$/.test(asg.value.plain)))
+                                                if (asg?.name === p0.name && (!asg.value.plain || !/^-?[0-9]{1,16}$/.test(asg.value.plain)))
                                                     return false;
                                             }
                                         }
                                     }
                                 }
                                 const cur = rawState.variables[p0.name];
-                                return cur === undefined || /^-?[0-9]+$/.test(cur);
+                                return cur === undefined || /^-?[0-9]{1,16}$/.test(cur);
                             }
                         }
                         return false;
@@ -14646,7 +14418,8 @@ export class Runtime {
                                     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));
+                            // A synchronous loop cannot hand off an unsupported pattern mid-iteration.
+                            return this.isPureSyncValueWord(e.left, rawState) && this.isPureSyncValueWord(e.right, rawState) && (!(e.operator === "==" || e.operator === "=" || e.operator === "!=") || (e.right.parts.length > 0 && e.right.parts.every(p => p.quoted)));
                         }
                         if (e.kind === "not")
                             return checkLeaf(e.operand);
@@ -14807,6 +14580,8 @@ export class Runtime {
                 // Nested step execution does not implement redirects; use normal execution.
                 if (nested && cmd.redirects.length !== 0)
                     return false;
+                if (cmd.words.length === 0)
+                    return false;
                 if (cmd.redirects.length === 1) {
                     const r0Check = cmd.redirects[0];
                     const w0DevPlain = cmd.words[0].plain;
@@ -14824,11 +14599,16 @@ export class Runtime {
                         (w0DevPlain === "pwd" || this.commands.has(w0DevPlain))) {
                         const devWordOk = (w) => this.isPureSyncValueWord(w, rawState) &&
                             w.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)));
+                        // Only a nonempty literal prefix proves an expansion cannot become an option.
+                        const devOperandOk = (w) => {
+                            const first = w.parts[0];
+                            return first?.kind === "text" && first.value.length > 0 && !first.value.startsWith("-") && devWordOk(w);
+                        };
                         const devShapeOk = (w0DevPlain === "pwd" && cmd.words.length === 1) ||
-                            ((w0DevPlain === "dirname" || w0DevPlain === "echo") && cmd.words.length === 2 && !cmd.words[1].plain?.startsWith("-") && devWordOk(cmd.words[1])) ||
-                            (w0DevPlain === "basename" && ((cmd.words.length === 2 && !cmd.words[1].plain?.startsWith("-") && devWordOk(cmd.words[1])) ||
-                                (cmd.words.length === 3 && !cmd.words[1].plain?.startsWith("-") && devWordOk(cmd.words[1]) && devWordOk(cmd.words[2])) ||
-                                (cmd.words.length === 4 && cmd.words[1].plain === "-s" && cmd.words[2].plain !== undefined && !cmd.words[3].plain?.startsWith("-") && devWordOk(cmd.words[3]))));
+                            ((w0DevPlain === "dirname" || w0DevPlain === "echo") && cmd.words.length === 2 && devOperandOk(cmd.words[1])) ||
+                            (w0DevPlain === "basename" && ((cmd.words.length === 2 && devOperandOk(cmd.words[1])) ||
+                                (cmd.words.length === 3 && devOperandOk(cmd.words[1]) && devWordOk(cmd.words[2])) ||
+                                (cmd.words.length === 4 && cmd.words[1].plain === "-s" && cmd.words[2].plain !== undefined && devOperandOk(cmd.words[3]))));
                         if (devShapeOk)
                             continue;
                     }
@@ -15480,22 +15260,13 @@ export class Runtime {
                 ? whilePrintfInd
                 : (forPrintfInd && this.canSyncPrintfInductionBody(command.body, rawState, forPrintfInd) ? forPrintfInd : undefined));
         const prevActivePrintfInd = this._activePrintfInductionName;
-        const prevActiveLoopScript = this._activeLoopBodyScript;
-        const prevActiveLoopCond = this._activeLoopCondScript;
-        const prevActiveLoopVar = this._activeLoopVarName;
         this._activePrintfInductionName = printfInductionName;
-        this._activeLoopBodyScript = command.body;
-        this._activeLoopCondScript = command.kind === "while" ? command.condition : undefined;
-        this._activeLoopVarName = command.kind === "for" ? command.name : (printfInductionName ?? (whilePrintfInd || undefined));
         let bodySyncOk = false;
         try {
             bodySyncOk = !(guestArrays(rawState) && (guestArrays(rawState).watches.size > 0 || this.budget.limits.maxExpansionBytes < 65536)) && this.canSyncLoopBody(command.body, rawState, io, false, printfInductionName);
         }
         finally {
             this._activePrintfInductionName = prevActivePrintfInd;
-            this._activeLoopBodyScript = prevActiveLoopScript;
-            this._activeLoopCondScript = prevActiveLoopCond;
-            this._activeLoopVarName = prevActiveLoopVar;
         }
         if (!bodySyncOk) {
             command._skipTrySyncLoop = true;
@@ -16101,7 +15872,7 @@ export class Runtime {
                                 !monitor.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));
+                        return this.isPureSyncValueWord(e.left, rawState) && this.isPureSyncValueWord(e.right, rawState) && (!(e.operator === "==" || e.operator === "=" || e.operator === "!=") || (e.right.parts.length > 0 && e.right.parts.every(p => p.quoted)));
                     }
                     if (e.kind === "not")
                         return checkWhileCond(e.operand, depth + 1);
@@ -16432,7 +16203,7 @@ export class Runtime {
                 store.epoch = restEpoch;
             return loopStatus;
         }
-        if (!isShellIdentifier(command.name) || command.name === "OPTIND" || command.name.includes("[") || store?.get(command.name) || (command.words && (command.words.length === 0 || command.words.length > 64)) || rawState.braceexpand === false) {
+        if (!isShellIdentifier(command.name) || command.name === "OPTIND" || controlNames.has(command.name) || command.name === "LC_COLLATE" || command.name.includes("[") || store?.get(command.name) || (command.words && (command.words.length === 0 || command.words.length > 64)) || rawState.braceexpand === false) {
             return undefined;
         }
         const activeValScope = io[valueScope];
@@ -16931,187 +16702,6 @@ export class Runtime {
         return pos <= 128 ? fastRedirectScratchViews[pos] : fastRedirectScratchBytes.subarray(0, pos);
     }
     _activePrintfInductionName = undefined;
-    _activeLoopBodyScript = undefined;
-    _activeLoopCondScript = undefined;
-    _activeLoopVarName = undefined;
-    isVarUnmutatedInScript(varName, script) {
-        for (const list of script.lists) {
-            for (const pipeline of list.pipelines) {
-                for (const cmd of pipeline.commands) {
-                    if (cmd.kind === "arithmetic") {
-                        if (cmd.expression.hasMutation && cmd.expression.source.includes(varName))
-                            return false;
-                        continue;
-                    }
-                    if (cmd.kind === "if") {
-                        for (const br of cmd.branches) {
-                            if (!this.isVarUnmutatedInScript(varName, br.condition) || !this.isVarUnmutatedInScript(varName, br.body))
-                                return false;
-                        }
-                        if (cmd.otherwise && !this.isVarUnmutatedInScript(varName, cmd.otherwise))
-                            return false;
-                        continue;
-                    }
-                    if (cmd.kind === "case") {
-                        for (const cl of cmd.clauses) {
-                            if (!this.isVarUnmutatedInScript(varName, cl.body))
-                                return false;
-                        }
-                        continue;
-                    }
-                    if (cmd.kind === "for") {
-                        if (cmd.name === varName || !this.isVarUnmutatedInScript(varName, cmd.body))
-                            return false;
-                        continue;
-                    }
-                    if (cmd.kind === "arithmetic-for") {
-                        if (cmd.expressions.some(e => e && e.hasMutation && e.source.includes(varName)) || !this.isVarUnmutatedInScript(varName, cmd.body))
-                            return false;
-                        continue;
-                    }
-                    if (cmd.kind === "while") {
-                        if (!this.isVarUnmutatedInScript(varName, cmd.condition) || !this.isVarUnmutatedInScript(varName, cmd.body))
-                            return false;
-                        continue;
-                    }
-                    if (cmd.kind === "group" || cmd.kind === "subshell") {
-                        if (!this.isVarUnmutatedInScript(varName, cmd.body))
-                            return false;
-                        continue;
-                    }
-                    if (cmd.kind !== "simple")
-                        return false;
-                    for (const w of cmd.words) {
-                        const arrAss = getArrayAssignment(w);
-                        if (arrAss && arrAss.name === varName)
-                            return false;
-                        const p0 = w.parts[0];
-                        if (p0?.kind === "text" && !p0.quoted && (p0.value.startsWith(varName + "=") || p0.value.startsWith(varName + "+=") || p0.value.startsWith(varName + "[")))
-                            return false;
-                    }
-                    const w0 = cmd.words[0]?.plain;
-                    if (w0 === "read" || w0 === "unset" || w0 === "declare" || w0 === "typeset" || w0 === "local" || w0 === "export" || w0 === "mapfile" || w0 === "readarray") {
-                        if (w0 === "read" && varName === "REPLY")
-                            return false;
-                        if (cmd.words.slice(1).some(w => (w.plain ?? "").includes(varName)))
-                            return false;
-                    }
-                    if (w0 === "printf" && cmd.words[1]?.plain === "-v" && (cmd.words[2]?.plain ?? "").startsWith(varName))
-                        return false;
-                    for (const w of [...cmd.words, ...cmd.redirects.map(r => r.target)]) {
-                        for (const pt of w.parts) {
-                            if (pt.kind === "arithmetic" && pt.expression.hasMutation && pt.expression.source.includes(varName))
-                                return false;
-                            if (pt.kind === "substitution" && !this.isVarUnmutatedInScript(varName, pt.script))
-                                return false;
-                        }
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    isVarUnmutatedInActiveLoop(varName) {
-        if (varName === this._activeLoopVarName || varName === this._activePrintfInductionName)
-            return false;
-        if (this._activeLoopCondScript && !this.isVarUnmutatedInScript(varName, this._activeLoopCondScript))
-            return false;
-        if (this._activeLoopBodyScript && !this.isVarUnmutatedInScript(varName, this._activeLoopBodyScript))
-            return false;
-        return true;
-    }
-    isFileReadOnlyScript(script, rawState) {
-        const visit = (value) => {
-            if (value === null || typeof value !== "object")
-                return true;
-            if (Array.isArray(value))
-                return value.every(visit);
-            const node = value;
-            if (typeof node.operator === "string" && "target" in node && !["<", "<<<", "<<", "<<-"].includes(node.operator))
-                return false;
-            if (node.kind === "simple") {
-                const cmd = value;
-                // Unknown commands (including shell functions) cannot promise read-only I/O.
-                const name = cmd.words[0]?.plain;
-                if (name === undefined && !cmd.words.every(word => this.assignment(word) || getArrayAssignment(word)))
-                    return false;
-                if (name !== undefined && (hasShellFunction(rawState, name) || !["jq", "cat", "echo", "printf", "test", "[", ":", "true", "false"].includes(name)))
-                    return false;
-            }
-            return Object.values(node).every(visit);
-        };
-        return visit(script);
-    }
-    extractLoopInvariantInput(cmd, hasSingleStdinRedir, hasSingleHereStringRedir, rawState) {
-        const w0 = cmd.words[0]?.plain;
-        const resolveInvariantWord = (w) => {
-            if (w.plain !== undefined)
-                return w.plain;
-            if (w.parts.length > 0 && w.parts.every(pt => pt.kind === "text"))
-                return w.parts.map(pt => pt.value).join("");
-            if (w.parts.length === 1 && w.parts[0].kind === "variable") {
-                const vp = w.parts[0];
-                if (!vp.indirect && !vp.operator && !vp.substring && !vp.transform && !vp.length && !vp.prefixNames && getArraySelector(vp) === undefined && this.isVarUnmutatedInActiveLoop(vp.name)) {
-                    const val = rawState.variables[vp.name];
-                    if (typeof val === "string")
-                        return val;
-                }
-            }
-            return undefined;
-        };
-        if (w0 === "jq" || w0 === "numfmt" || w0 === "awk") {
-            if (hasSingleHereStringRedir) {
-                const resolved = resolveInvariantWord(cmd.redirects[0].target);
-                return resolved !== undefined ? resolved + "\n" : undefined;
-            }
-            if (this._fileWrites?.size || this._outputFiles?.size)
-                return undefined;
-            if ([this._activeLoopBodyScript, this._activeLoopCondScript].some(script => script && !this.isFileReadOnlyScript(script, rawState)))
-                return undefined;
-            const fPlain = hasSingleStdinRedir ? cmd.redirects[0].target.plain : cmd.words[cmd.words.length - 1]?.plain;
-            if (!fPlain || fPlain.startsWith("-") || fPlain === "/dev/stdin")
-                return undefined;
-            const vCheck = this.tryReadMemoryFileViewSync(resolvePath(rawState.cwd, fPlain), false);
-            if (!vCheck || vCheck.byteLength > 16384 || vCheck.includes(0))
-                return undefined;
-            return sharedSyncPipeDecoder.decode(vCheck);
-        }
-        if (w0 === "cat") {
-            if (hasSingleHereStringRedir) {
-                const resolved = resolveInvariantWord(cmd.redirects[0].target);
-                return resolved !== undefined ? resolved + "\n" : undefined;
-            }
-            if (this._fileWrites?.size || this._outputFiles?.size)
-                return undefined;
-            if ([this._activeLoopBodyScript, this._activeLoopCondScript].some(script => script && !this.isFileReadOnlyScript(script, rawState)))
-                return undefined;
-            const fPlain = hasSingleStdinRedir ? cmd.redirects[0].target.plain : cmd.words[1]?.plain;
-            if (!fPlain || fPlain.startsWith("-") || fPlain === "/dev/stdin")
-                return undefined;
-            const vCheck = this.tryReadMemoryFileViewSync(resolvePath(rawState.cwd, fPlain), false);
-            if (!vCheck || vCheck.byteLength > 16384 || vCheck.includes(0))
-                return undefined;
-            return sharedSyncPipeDecoder.decode(vCheck);
-        }
-        if (w0 === "echo" && cmd.words.length === 2) {
-            const resolved = resolveInvariantWord(cmd.words[1]);
-            if (resolved !== undefined && !resolved.startsWith("-"))
-                return resolved + "\n";
-            return undefined;
-        }
-        if (w0 === "printf" && cmd.words.length >= 2) {
-            const args = [];
-            for (let i = 1; i < cmd.words.length; i++) {
-                const r = resolveInvariantWord(cmd.words[i]);
-                if (r === undefined)
-                    return undefined;
-                args.push(r);
-            }
-            const formatted = tryFastPrintf(args);
-            return formatted;
-        }
-        return undefined;
-    }
     canSyncPrintfInductionBody(script, rawState, inductionName) {
         for (const list of script.lists)
             for (const pipeline of list.pipelines)
@@ -17123,7 +16713,24 @@ export class Runtime {
                     }
                     if (command.kind !== "simple" || hasShellFunction(rawState, command.words[0]?.plain ?? "") || command.words.some(word => getArrayAssignment(word) !== undefined))
                         return false;
-                    const w0 = command.words[0]?.plain;
+                    let commandIndex = 0;
+                    while (commandIndex < command.words.length && this.assignment(command.words[commandIndex]))
+                        commandIndex++;
+                    const commandWord = command.words[commandIndex];
+                    if (!commandWord?.parts.every(part => part.kind === "text"))
+                        return false;
+                    const w0 = commandWord.parts.map(part => part.kind === "text" ? part.value : "").join("");
+                    // read targets and printf -v targets may be quoted or expanded. Both can
+                    // invalidate the integer assumption used by induction formatting.
+                    if (w0 === "read")
+                        return false;
+                    if (w0 === "printf") {
+                        const option = command.words[commandIndex + 1];
+                        if (!option?.parts.every(part => part.kind === "text"))
+                            return false;
+                        if (option.parts.map(part => part.kind === "text" ? part.value : "").join("") === "-v")
+                            return false;
+                    }
                     if (w0 === "let" || w0 === "declare" || w0 === "typeset" || w0 === "local" || w0 === "export" || w0 === "unset" || w0 === "mapfile" || w0 === "readarray")
                         return false;
                     if (inductionName !== undefined) {
@@ -17132,10 +16739,6 @@ export class Runtime {
                             return p0?.kind === "text" && !p0.quoted && (p0.value.startsWith(inductionName + "=") || p0.value.startsWith(inductionName + "+="));
                         }))
                             return false;
-                        if (w0 === "read" && (inductionName === "REPLY" || command.words.slice(1).some(w => w.plain === inductionName || w.plain === "-a" || w.plain === "-ra" || w.plain === "-ar")))
-                            return false;
-                        if (w0 === "printf" && command.words[1]?.plain === "-v" && command.words[2]?.plain === inductionName)
-                            return false;
                     }
                     for (const word of [...command.words, ...command.redirects.map(redirect => redirect.target)])
                         for (const part of word.parts) {
@@ -17414,6 +17017,7 @@ export class Runtime {
     execSyncLocalDeclStep(decl, rawState, io, monitor, touched, line) {
         const locals = (decl.kind === "local" || decl.kind === "declare") && rawState.locals.length > 0 ? rawState.locals[rawState.locals.length - 1] : undefined;
         let lastArg = decl.kind;
+        const values = decl.items.map(item => item.value === undefined ? undefined : this.fastValueWord(item.value, rawState, io, false, false, false, rawState.braceexpand !== false, 0, line));
         for (let i = 0; i < decl.items.length; i++) {
             const item = decl.items[i];
             const isNewLocal = locals ? !locals.has(item.name) : false;
@@ -17431,7 +17035,7 @@ export class Runtime {
                 touched.add(item.name);
             }
             if (item.value !== undefined) {
-                const val = this.fastValueWord(item.value, rawState, io, false, false, false, rawState.braceexpand !== false, 0, line);
+                const val = values[i];
                 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));
@@ -17441,7 +17045,7 @@ export class Runtime {
                     rawState.variables[item.name] = val;
                 }
                 touched.add(item.name);
-                lastArg = `${item.name}=${rawState.variables[item.name]}`;
+                lastArg = `${item.name}${item.append ? "+=" : "="}${val}`;
             }
             else {
                 lastArg = item.name;
@@ -17540,7 +17144,28 @@ export class Runtime {
         if (this._syncStdoutBatch.length >= 8192)
             this.flushSyncStdoutBatch(io);
     }
+    runSyncDiscardStep(step, rawState, io) {
+        this.budget.fileSystemOperation();
+        const args = step.discardWords.map(word => this.fastValueWord(word, rawState, io, false, false, false, false, 0, step.line));
+        const cmdName = step.cmd.words[0].plain;
+        let output;
+        if (cmdName === "pwd")
+            output = rawState.variables.PWD ?? rawState.cwd;
+        else if (cmdName === "echo")
+            output = args[0];
+        else if (cmdName === "dirname")
+            output = this.evalSyncDirname(args);
+        else
+            output = this.evalSyncBasename(step.discardSuffix === undefined ? args : ["-s", step.discardSuffix, ...args]);
+        const bytes = shellValueByteLength(output) + 1;
+        if (this.budget.bytes + bytes > this.budget.maxOutputBytesSmi && bytes > this.budget.limits.maxOutputBytes - this.budget.bytes)
+            this.budget.fail("maxOutputBytes");
+        this.budget.bytes += bytes;
+        return args[args.length - 1] ?? cmdName;
+    }
     writeSyncRedirectStep(step, encoded, append, mode, rawState, io) {
+        if (this.budget.bytes + encoded.byteLength > this.budget.maxOutputBytesSmi && encoded.byteLength > this.budget.limits.maxOutputBytes - this.budget.bytes)
+            this.budget.fail("maxOutputBytes");
         // The memory fast writer may retain its input; the encoder scratch is reused.
         encoded = encoded.slice();
         if (step.targetDirPrefix !== undefined && step.targetNamePrefix !== undefined) {
@@ -17704,31 +17329,7 @@ export class Runtime {
                     lastArg = pLastArg;
                 }
                 else if (step.isDiscardDevNull && step.discardWords !== undefined) {
-                    this.budget.fileSystemOperation();
-                    const dw = step.discardWords;
-                    const cmdName = step.cmd.words[0].plain;
-                    let evalFirst = "";
-                    let evalLast = cmdName;
-                    for (let wi = 0; wi < dw.length; wi++) {
-                        const v = this.fastValueWord(dw[wi], rawState, io, false, false, false, false, 0, step.line);
-                        if (wi === 0)
-                            evalFirst = v;
-                        evalLast = v;
-                    }
-                    let outChars = 0;
-                    if (cmdName === "pwd")
-                        outChars = (rawState.variables.PWD ?? rawState.cwd).length + 1;
-                    else if (cmdName === "echo")
-                        outChars = evalFirst.length + 1;
-                    else if (cmdName === "dirname")
-                        outChars = dirname(evalFirst).length + 1;
-                    else if (cmdName === "basename") {
-                        const sfx = step.discardSuffix !== undefined ? step.discardSuffix : (dw.length === 2 ? evalLast : undefined);
-                        const baseStr = /^\/+$/u.test(evalFirst) ? "/" : basename(evalFirst);
-                        outChars = (sfx && baseStr !== sfx && baseStr.endsWith(sfx) ? baseStr.length - sfx.length : baseStr.length) + 1;
-                    }
-                    this.budget.bytes += outChars;
-                    lastArg = step.discardSuffix !== undefined ? evalLast : (dw.length > 0 ? evalLast : cmdName);
+                    lastArg = this.runSyncDiscardStep(step, rawState, io);
                 }
                 else if (step.name !== undefined && step.value !== undefined) {
                     rawState.substitutionStatus = 0;
@@ -17806,6 +17407,10 @@ export class Runtime {
         return check(tree);
     }
     canSyncErrorArithmeticStmt(expr, rawState) {
+        // Expansion can introduce array, attributed, or control-variable references.
+        // Their reads and writes require the full arithmetic evaluator.
+        if (expr.source.includes("$"))
+            return false;
         if (expr.source.includes("/") || expr.source.includes("%") || expr.source.includes("<<") || expr.source.includes(">>") || expr.source.includes("**") || expr.source.includes("["))
             return false;
         try {
@@ -17968,19 +17573,34 @@ export class Runtime {
         const prevFastSubPos = this._fastSubPositional;
         rawState.positional = fnArgs;
         this._fastSubPositional = fnArgs;
-        const savedLocals = new Array(fnCall.locals.length);
+        const savedLocals = [];
+        const seenLocals = new Set();
         try {
-            for (let i = 0; i < fnCall.locals.length; i++) {
-                const loc = fnCall.locals[i];
-                if (loc.isFirstInCmd)
-                    this.budget.tick();
-                savedLocals[i] = { name: loc.name, val: rawState.variables[loc.name], wasTouched: touched.has(loc.name) };
-                if (loc.valueWord !== undefined) {
-                    rawState.variables[loc.name] = this.fastValueWord(loc.valueWord, rawState, io, false, false, false, false, 0, step.line);
-                    touched.add(loc.name);
-                }
-                else {
-                    delete rawState.variables[loc.name];
+            for (let i = 0; i < fnCall.locals.length;) {
+                this.budget.tick();
+                let end = i + 1;
+                while (end < fnCall.locals.length && !fnCall.locals[end].isFirstInCmd)
+                    end++;
+                // Expand the entire simple command before any of its bindings change.
+                const values = fnCall.locals.slice(i, end).map(loc => loc.valueWord === undefined
+                    ? undefined
+                    : this.fastValueWord(loc.valueWord, rawState, io, false, false, false, false, 0, step.line));
+                const start = i;
+                for (; i < end; i++) {
+                    const loc = fnCall.locals[i];
+                    const alreadyLocal = seenLocals.has(loc.name);
+                    if (!alreadyLocal) {
+                        savedLocals.push({ name: loc.name, val: rawState.variables[loc.name], wasTouched: touched.has(loc.name) });
+                        seenLocals.add(loc.name);
+                    }
+                    const value = values[i - start];
+                    if (value !== undefined) {
+                        rawState.variables[loc.name] = value;
+                        touched.add(loc.name);
+                    }
+                    else if (!alreadyLocal) {
+                        delete rawState.variables[loc.name];
+                    }
                 }
             }
             if (fnCall.steps.length > 0) {
@@ -17988,11 +17608,12 @@ export class Runtime {
             }
             else {
                 rawState.status = 0;
-                onUpdate({ lastCmd: step.cmd, lastArg: fnArgs.length > 0 ? fnArgs[fnArgs.length - 1] : fnCall.name });
             }
+            rawState.lastArgument = fnArgs.at(-1) ?? fnCall.name;
+            onUpdate({ lastCmd: step.cmd, lastArg: rawState.lastArgument });
         }
         finally {
-            for (let i = fnCall.locals.length - 1; i >= 0; i--) {
+            for (let i = savedLocals.length - 1; i >= 0; i--) {
                 const saved = savedLocals[i];
                 if (saved.val !== undefined) {
                     rawState.variables[saved.name] = saved.val;
@@ -18268,31 +17889,7 @@ export class Runtime {
                 lastArg = pLastArg;
             }
             else if (step.isDiscardDevNull && step.discardWords !== undefined) {
-                this.budget.fileSystemOperation();
-                const dw = step.discardWords;
-                const cmdName = step.cmd.words[0].plain;
-                let evalFirst = "";
-                let evalLast = cmdName;
-                for (let wi = 0; wi < dw.length; wi++) {
-                    const v = this.fastValueWord(dw[wi], rawState, io, false, false, false, false, 0, step.line);
-                    if (wi === 0)
-                        evalFirst = v;
-                    evalLast = v;
-                }
-                let outChars = 0;
-                if (cmdName === "pwd")
-                    outChars = (rawState.variables.PWD ?? rawState.cwd).length + 1;
-                else if (cmdName === "echo")
-                    outChars = evalFirst.length + 1;
-                else if (cmdName === "dirname")
-                    outChars = dirname(evalFirst).length + 1;
-                else if (cmdName === "basename") {
-                    const sfx = step.discardSuffix !== undefined ? step.discardSuffix : (dw.length === 2 ? evalLast : undefined);
-                    const baseStr = /^\/+$/u.test(evalFirst) ? "/" : basename(evalFirst);
-                    outChars = (sfx && baseStr !== sfx && baseStr.endsWith(sfx) ? baseStr.length - sfx.length : baseStr.length) + 1;
-                }
-                this.budget.bytes += outChars;
-                lastArg = step.discardSuffix !== undefined ? evalLast : (dw.length > 0 ? evalLast : cmdName);
+                lastArg = this.runSyncDiscardStep(step, rawState, io);
             }
             else if (step.name !== undefined && step.value !== undefined) {
                 rawState.substitutionStatus = 0;
@@ -18448,31 +18045,7 @@ export class Runtime {
                     lastArg = pLastArg;
                 }
                 else if (step.isDiscardDevNull && step.discardWords !== undefined) {
-                    this.budget.fileSystemOperation();
-                    const dw = step.discardWords;
-                    const cmdName = step.cmd.words[0].plain;
-                    let evalFirst = "";
-                    let evalLast = cmdName;
-                    for (let wi = 0; wi < dw.length; wi++) {
-                        const v = this.fastValueWord(dw[wi], rawState, io, false, false, false, false, 0, step.line);
-                        if (wi === 0)
-                            evalFirst = v;
-                        evalLast = v;
-                    }
-                    let outChars = 0;
-                    if (cmdName === "pwd")
-                        outChars = (rawState.variables.PWD ?? rawState.cwd).length + 1;
-                    else if (cmdName === "echo")
-                        outChars = evalFirst.length + 1;
-                    else if (cmdName === "dirname")
-                        outChars = dirname(evalFirst).length + 1;
-                    else if (cmdName === "basename") {
-                        const sfx = step.discardSuffix !== undefined ? step.discardSuffix : (dw.length === 2 ? evalLast : undefined);
-                        const baseStr = /^\/+$/u.test(evalFirst) ? "/" : basename(evalFirst);
-                        outChars = (sfx && baseStr !== sfx && baseStr.endsWith(sfx) ? baseStr.length - sfx.length : baseStr.length) + 1;
-                    }
-                    this.budget.bytes += outChars;
-                    lastArg = step.discardSuffix !== undefined ? evalLast : (dw.length > 0 ? evalLast : cmdName);
+                    lastArg = this.runSyncDiscardStep(step, rawState, io);
                 }
                 else if (step.name !== undefined && step.value !== undefined) {
                     rawState.substitutionStatus = 0;
@@ -19407,8 +18980,6 @@ export class Runtime {
                         const rawState = stateMonitor(state)?.raw ?? state;
                         if (rawState.variables._ !== undefined)
                             delete rawState.variables._;
-                        rawState.lastArgument = wordValues[wordValues.length - 1] ?? w0Plain;
-                        state.lastArgument = rawState.lastArgument;
                         return await this.dispatchFastFunction(w0Plain, state.functions.get(w0Plain), wordValues.slice(1), state, originalIO);
                     }
                 }
@@ -20682,8 +20253,10 @@ export class Runtime {
                     const rawState = stateMonitor(state)?.raw ?? state;
                     if (!state._readOnlyStage && rawState.variables._ !== undefined)
                         delete rawState.variables._;
-                    rawState.lastArgument = words.length > 0 ? words[words.length - 1] : "";
-                    state.lastArgument = rawState.lastArgument;
+                    if (!state.functions.has(words[0] ?? "") && !["eval", ".", "source"].includes(words[declarationIndex] ?? "")) {
+                        rawState.lastArgument = words.at(-1) ?? "";
+                        state.lastArgument = rawState.lastArgument;
+                    }
                     if (!words.length)
                         return state.substitutionStatus;
                     const args = words.slice(1);
@@ -20947,8 +20520,10 @@ export class Runtime {
                 const rawState = stateMonitor(state)?.raw ?? state;
                 if (rawState.variables._ !== undefined && !assignments.some(assignment => assignment.name === "_"))
                     delete rawState.variables._;
-                rawState.lastArgument = words.length > 0 ? words[words.length - 1] : "";
-                state.lastArgument = rawState.lastArgument;
+                if (!functionCommand && !["eval", ".", "source"].includes(words[declarationIndex] ?? "")) {
+                    rawState.lastArgument = words.at(-1) ?? "";
+                    state.lastArgument = rawState.lastArgument;
+                }
             }
             if (!words.length)
                 return state.substitutionStatus;
@@ -21282,6 +20857,7 @@ export class Runtime {
             }
             if (hasThrown)
                 throw thrownError;
+            state.lastArgument = pendingResume?.lastArgument ?? args.at(-1) ?? name;
             return exitStatus;
         }
         finally {
@@ -21801,6 +21377,7 @@ export class Runtime {
                         }
                         if (outcome.kind === "throw")
                             throw outcome.reason;
+                        state.lastArgument = context.args.at(-1) ?? context.command;
                         return outcome.value;
                     }
                     if (selectedKind === "builtin" && !(state.externalInvocation && this.commands.has(context.command))) {
@@ -21817,10 +21394,16 @@ export class Runtime {
                         }
                         if (context.command === "command" || context.command === "builtin" || context.command === "type")
                             return { exitCode: await this.discoveryBuiltin(context, state, io, assignments, defaultPath) };
-                        if (context.command === "." || context.command === "source")
-                            return { exitCode: await this.sourceBuiltin(context, state, { ...io, ...context }, special) };
-                        if (context.command === "eval")
-                            return { exitCode: await this.evalBuiltin(context, state, { ...io, ...context }, special) };
+                        if (context.command === "." || context.command === "source") {
+                            const exitCode = await this.sourceBuiltin(context, state, { ...io, ...context }, special);
+                            state.lastArgument = context.args.at(-1) ?? context.command;
+                            return { exitCode };
+                        }
+                        if (context.command === "eval") {
+                            const exitCode = await this.evalBuiltin(context, state, { ...io, ...context }, special);
+                            state.lastArgument = context.args.at(-1) ?? context.command;
+                            return { exitCode };
+                        }
                         const builtinWork = this.builtin({ ...context, [declarationArrays]: io[declarationArrays] }, state, assignments, (error, diagnostic) => { builtinFailure = { error, diagnostic }; }, bypassFunctions);
                         const builtin = await interruptible(builtinWork, this.signal);
                         if (builtin !== undefined) {
@@ -27162,6 +26745,10 @@ export class Runtime {
     expandSyncTrCharArray(spec) {
         if (spec.length === 0)
             return undefined;
+        // Non-ASCII sets require the byte-oriented tr parser.
+        for (let i = 0; i < spec.length; i++)
+            if (spec.charCodeAt(i) >= 128)
+                return undefined;
         // Escaped endpoints need the tr parser before range expansion.
         if (spec.includes("\\") && spec.includes("-"))
             return undefined;
@@ -27694,10 +27281,10 @@ export class Runtime {
                 if (!el || typeof el !== "object" || Array.isArray(el))
                     return undefined;
                 const rec = el;
-                const k = rec.key ?? rec.name ?? rec.k;
+                const k = [rec.key, rec.Key, rec.name, rec.Name].find(value => value !== undefined && value !== null && value !== false);
                 if (typeof k !== "string")
                     return undefined;
-                obj[k] = Object.hasOwn(rec, "value") ? rec.value : (Object.hasOwn(rec, "v") ? rec.v : null);
+                obj[k] = Object.hasOwn(rec, "value") ? rec.value : (Object.hasOwn(rec, "Value") ? rec.Value : null);
             }
             return [obj];
         }
@@ -27730,7 +27317,7 @@ export class Runtime {
                 return [item.map(x => x === null ? "" : String(x)).join(arg)];
             }
             if (fn === "split")
-                return typeof item === "string" ? [item.split(arg)] : undefined;
+                return typeof item === "string" ? [arg === "" ? Array.from(item) : item.split(arg)] : undefined;
             if (fn === "ltrimstr")
                 return typeof item === "string" ? [item.startsWith(arg) ? item.slice(arg.length) : item] : undefined;
             if (fn === "rtrimstr")
@@ -27992,9 +27579,8 @@ export class Runtime {
                 break;
             }
             if (!a.startsWith("-") || a === "-") {
-                operands.push(a);
-                idx++;
-                continue;
+                operands.push(...args.slice(idx));
+                break;
             }
             if (a === "-a" || a === "--multiple") {
                 multiple = true;
@@ -28320,6 +27906,10 @@ export class Runtime {
                 const core = anchorEnd ? core1.slice(0, -1) : core1;
                 if (core.length === 0 && !anchorStart && !anchorEnd)
                     return undefined;
+                // POSIX-only brackets and leftmost-longest alternatives belong to sed's matcher.
+                if (core.includes("[:") || core.includes("[.") || core.includes("[=") ||
+                    core.includes("[]") || core.includes("[^]") || isExtended && core.includes("|"))
+                    return undefined;
                 let reSrc;
                 if (/^[a-zA-Z0-9_ :;,=-]*$/.test(core)) {
                     if (/\\[1-9]/.test(rep))
@@ -28376,7 +27966,9 @@ export class Runtime {
                 }
                 if (st.kind === "=") {
                     out.push(String(idx1));
-                    lastInputIndex = i;
+                    // Line numbers are generated records, always terminated, even when
+                    // the final input record is partial. Later prints can override this.
+                    lastInputIndex = -1;
                     continue;
                 }
                 if (st.kind === "q") {
@@ -28419,8 +28011,10 @@ export class Runtime {
                     }
                     return replacement;
                 });
-                if (matchedOnce && st.printOnMatch)
+                if (matchedOnce && st.printOnMatch) {
                     out.push(l);
+                    lastInputIndex = i;
+                }
             }
             if (quitNow) {
                 break;
@@ -28529,7 +28123,9 @@ export class Runtime {
         const isOnlyMatching = mode.includes("o");
         // POSIX bracket classes, collating symbols and equivalence classes have
         // different meanings in JS RegExp. Let the command matcher parse them.
-        if (isExtended && !isFixed && rawPatterns.some(pattern => pattern.includes("[:") || pattern.includes("[.") || pattern.includes("[=")))
+        if (!isFixed && rawPatterns.some(pattern => pattern.includes("[:") || pattern.includes("[.") || pattern.includes("[=") ||
+            pattern.includes("[]") || pattern.includes("[^]") ||
+            isExtended && pattern.includes("[") && pattern.includes("|")))
             return undefined;
         if (isCount && (isLineNumber || isOnlyMatching || beforeCtx > 0 || afterCtx > 0))
             return undefined;
@@ -28562,15 +28158,19 @@ export class Runtime {
             if (!re)
                 return undefined;
             const out = [];
+            let matched = false;
             for (let li = 0; li < rawLines.length; li++) {
                 const matches = rawLines[li].match(re);
                 if (matches) {
+                    matched = true;
                     for (let mi = 0; mi < matches.length; mi++) {
+                        if (matches[mi].length === 0)
+                            continue;
                         out.push(isLineNumber ? `${li + 1}:${matches[mi]}` : matches[mi]);
                     }
                 }
             }
-            return { lines: out, status: out.length > 0 ? 0 : 1 };
+            return { lines: out, status: matched ? 0 : 1 };
         }
         if (isExtended && isFixed)
             return undefined;
@@ -29606,22 +29206,16 @@ export class Runtime {
             if (endField !== undefined && endField < startField)
                 return undefined;
             const kf = km[3] ?? "";
-            if (kf.includes("n"))
-                keyNum = true;
-            if (kf.includes("h"))
-                keyHuman = true;
-            if (kf.includes("M"))
-                keyMonth = true;
-            if (kf.includes("d"))
-                keyDict = true;
-            if (kf.includes("r"))
-                keyRev = true;
-            if (kf.includes("f"))
-                keyFold = true;
-            if (kf.includes("b"))
-                keyBlanks = true;
-            if (kf.includes("V"))
-                keyVer = true;
+            if (kf.length > 0) {
+                keyNum = kf.includes("n");
+                keyHuman = kf.includes("h");
+                keyMonth = kf.includes("M");
+                keyDict = kf.includes("d");
+                keyRev = kf.includes("r");
+                keyFold = kf.includes("f");
+                keyBlanks = kf.includes("b");
+                keyVer = kf.includes("V");
+            }
         }
         const extractKey = (l) => {
             let raw = keySpec === undefined
@@ -29653,7 +29247,14 @@ export class Runtime {
                 raw = raw.replace(/^[ \t]+/, "");
             if (keyDict)
                 raw = raw.replace(/[^a-zA-Z0-9 \t]+/g, "");
-            return keyFold ? raw.toUpperCase() : raw;
+            if (!keyFold)
+                return raw;
+            let folded = "";
+            for (let i = 0; i < raw.length; i++) {
+                const code = raw.charCodeAt(i);
+                folded += code >= 97 && code <= 122 ? String.fromCharCode(code - 32) : raw[i];
+            }
+            return folded;
         };
         const parseNum = (s) => {
             const m = /^[ \t]*(-?(?:\d+(?:\.\d*)?|\.\d+))/.exec(s);
@@ -29686,6 +29287,24 @@ export class Runtime {
             const idx = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"].indexOf(m[1].toUpperCase());
             return idx === -1 ? 0 : idx + 1;
         };
+        const encoded = new Map();
+        const bytesOf = (line) => {
+            let bytes = encoded.get(line);
+            if (bytes === undefined) {
+                bytes = fastSharedTextEncoder.encode(line);
+                encoded.set(line, bytes);
+            }
+            return bytes;
+        };
+        const compareBytes = (left, right) => {
+            const a = bytesOf(left);
+            const b = bytesOf(right);
+            for (let i = 0; i < Math.min(a.length, b.length); i++) {
+                if (a[i] !== b[i])
+                    return a[i] - b[i];
+            }
+            return a.length - b.length;
+        };
         const sorted = [...rawLines].sort((a, b) => {
             const ka = extractKey(a);
             const kb = extractKey(b);
@@ -29712,15 +29331,13 @@ export class Runtime {
                     return keyRev ? -vc : vc;
             }
             else if (ka !== kb) {
-                return ka < kb ? (keyRev ? 1 : -1) : (keyRev ? -1 : 1);
+                const comparison = compareBytes(ka, kb);
+                return keyRev ? -comparison : comparison;
             }
             if (uniq || stable)
                 return 0;
-            const fa = fold ? a.toUpperCase() : a;
-            const fb = fold ? b.toUpperCase() : b;
-            if (fa !== fb)
-                return fa < fb ? (rev ? 1 : -1) : (rev ? -1 : 1);
-            return a < b ? (rev ? 1 : -1) : a > b ? (rev ? -1 : 1) : 0;
+            const comparison = compareBytes(a, b);
+            return rev ? -comparison : comparison;
         });
         if (!uniq)
             return sorted;
@@ -29846,6 +29463,11 @@ export class Runtime {
         return this.evalSyncSort(rawLines, flag !== undefined ? [flag] : [], false) ?? [...rawLines];
     }
     translateSyncTr(input, set1Spec, set2Spec, truncateSet1 = false) {
+        // Other string2 classes require the tr parser's class and alignment validation.
+        if (set2Spec.includes("[:") &&
+            !(set1Spec === "[:lower:]" && set2Spec === "[:upper:]") &&
+            !(set1Spec === "[:upper:]" && set2Spec === "[:lower:]"))
+            return undefined;
         if ((set1Spec === "a-z" || set1Spec === "[:lower:]") && (set2Spec === "A-Z" || set2Spec === "[:upper:]")) {
             return input.replace(/[a-z]/g, ch => String.fromCharCode(ch.charCodeAt(0) - 32));
         }
@@ -30221,7 +29843,7 @@ export class Runtime {
                     const firstName = stageNames[sIdx];
                     const extDef = stageDefs[sIdx];
                     const stageArgs = stageArgsList[sIdx];
-                    const nextBuf = (index & 1) === 0 ? sharedSyncPipeBuf0 : sharedSyncPipeBuf1;
+                    let nextBuf = (index & 1) === 0 ? sharedSyncPipeBuf0 : sharedSyncPipeBuf1;
                     const isInlineCutField = firstName === "cut";
                     const isInlineTr = firstName === "tr";
                     const isInlineAwk = firstName === "awk";
@@ -30270,6 +29892,8 @@ export class Runtime {
                                 if (nextTotalBytes > this.budget.maxOutputBytesSmi && sub.byteLength > this.budget.limits.maxOutputBytes - this.budget.bytes)
                                     this.budget.fail("maxOutputBytes");
                                 this.budget.bytes = nextTotalBytes;
+                                if (sub.byteLength > nextBuf.byteLength)
+                                    nextBuf = new Uint8Array(sub.byteLength);
                                 nextBuf.set(sub, 0);
                                 prevBuf = nextBuf;
                                 prevLen = sub.byteLength;
@@ -30319,12 +29943,12 @@ export class Runtime {
                             if (transformed === undefined)
                                 return undefined;
                             const outByteLen = shellValueByteLength(transformed);
-                            if (outByteLen > nextBuf.byteLength)
-                                return undefined;
                             const nextTotalBytes = this.budget.bytes + outByteLen;
                             if (nextTotalBytes > this.budget.maxOutputBytesSmi && outByteLen > this.budget.limits.maxOutputBytes - this.budget.bytes)
                                 this.budget.fail("maxOutputBytes");
                             this.budget.bytes = nextTotalBytes;
+                            if (outByteLen > nextBuf.byteLength)
+                                nextBuf = new Uint8Array(outByteLen);
                             const written = transformed.length === 0 ? 0 : fastSharedTextEncoder.encodeInto(transformed, nextBuf).written;
                             prevBuf = nextBuf;
                             prevLen = written;
@@ -30362,9 +29986,10 @@ export class Runtime {
                             outLines = grepRes.lines;
                         }
                         else if (isInlineTac) {
-                            if (inStr.length > 0 && !inStr.endsWith("\n"))
-                                return undefined;
                             outLines = [...rawLines].reverse();
+                            if (!inStr.endsWith("\n") && outLines.length > 1) {
+                                outLines.splice(0, 2, outLines[0] + outLines[1]);
+                            }
                         }
                         else if (isInlineNl) {
                             const nlRes = this.evalSyncNl(rawLines, stageArgs);
@@ -30394,12 +30019,14 @@ export class Runtime {
                                 if (cleaned.length % 4 !== 0 || (cleaned.length > 0 && !/^[A-Za-z0-9+/]+={0,2}$/.test(cleaned)))
                                     return undefined;
                                 const decoded = this.syncBase64DecodeBytes(cleaned);
-                                if (decoded.some(byte => byte === 0 || byte >= 128) || decoded.byteLength > nextBuf.byteLength)
+                                if (decoded.some(byte => byte === 0 || byte >= 128))
                                     return undefined;
                                 const nextTotalBytes = this.budget.bytes + decoded.byteLength;
                                 if (nextTotalBytes > this.budget.maxOutputBytesSmi && decoded.byteLength > this.budget.limits.maxOutputBytes - this.budget.bytes)
                                     this.budget.fail("maxOutputBytes");
                                 this.budget.bytes = nextTotalBytes;
+                                if (decoded.byteLength > nextBuf.byteLength)
+                                    nextBuf = new Uint8Array(decoded.byteLength);
                                 nextBuf.set(decoded, 0);
                                 prevBuf = nextBuf;
                                 prevLen = decoded.byteLength;
@@ -30414,15 +30041,15 @@ export class Runtime {
                         }
                         // These filters preserve the terminator of the final selected input line.
                         const preservesTerminator = firstName === "head" || firstName === "tail" || firstName === "rev" || firstName === "sed";
-                        const terminated = sedTerminated || !preservesTerminator || inStr.endsWith("\n") || firstName === "head" && outLines.length < rawLines.length;
+                        const terminated = isInlineTac ? inStr.includes("\n") : sedTerminated || !preservesTerminator || inStr.endsWith("\n") || firstName === "head" && outLines.length < rawLines.length;
                         const outStr = outLines.length > 0 ? outLines.join("\n") + (terminated ? "\n" : "") : "";
                         const outByteLen = shellValueByteLength(outStr);
-                        if (outByteLen > nextBuf.byteLength)
-                            return undefined;
                         const nextTotalBytes = this.budget.bytes + outByteLen;
                         if (nextTotalBytes > this.budget.maxOutputBytesSmi && outByteLen > this.budget.limits.maxOutputBytes - this.budget.bytes)
                             this.budget.fail("maxOutputBytes");
                         this.budget.bytes = nextTotalBytes;
+                        if (outByteLen > nextBuf.byteLength)
+                            nextBuf = new Uint8Array(outByteLen);
                         const written = outStr.length === 0 ? 0 : fastSharedTextEncoder.encodeInto(outStr, nextBuf).written;
                         prevBuf = nextBuf;
                         prevLen = written;