@poe-platform/safe-bash 0.1.799 → 0.1.800

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

@@ -133,6 +133,7 @@ function hasActiveExtensions(state) {
 }
 const memberPatternOperators = ["#", "##", "%", "%%", "/", "//", "/#", "/%", "^", "^^", ",", ",,"];
 const defaultParameterOperators = ["-", "+", "=", "?", ":-", ":+", ":=", ":?"];
+const printfSlowTargets = new Set([...controlNames, "FUNCNAME", "RANDOM", "SECONDS", "PIPESTATUS", "_"]);
 async function signedLong(argument, budget, signal) {
     const checkpoint = async () => {
         budget.cpuCheckpoint();
@@ -184,6 +185,7 @@ export const defaultLimits = {
     maxPipelineStages: Infinity,
     maxLoopIterations: Infinity,
     maxSubstitutionDepth: Infinity,
+    maxFunctionDepth: Infinity,
     maxSourceBytes: Infinity,
     maxExpansionFields: Infinity,
     maxExpansionBytes: Infinity,
@@ -2088,7 +2090,7 @@ async function cloneState(state, signal, scope, inheritLocals = true) {
                         const token = await textToken(savedOwner, name, signal);
                         const admission = savedOwner.reserve({ slots: 1, metadata: 32, work: 5 });
                         binding = typed.binding?.retain();
-                        typedSavedVariables.set(copied, { owner: savedOwner, binding, tickets, prepared: { name: token, admission }, watch, scalarLegacy: typed.scalarLegacy });
+                        typedSavedVariables.set(copied, { owner: savedOwner, binding, tickets, prepared: { ...typed.prepared, name: token, admission }, watch, scalarLegacy: typed.scalarLegacy });
                         tickets.cleanup = () => {
                             if (typedSavedVariables.delete(copied) && scope)
                                 releaseBinding = scope.cleanup(async () => { await binding?.release(); });
@@ -3541,6 +3543,10 @@ function resolveSimpleArithOperand(tok, rawState, monitor, activeArrayStore, syn
         return Number(elemVal);
     }
     tok = resolveSyncNameref(rawState, tok);
+    // These values come from execution context or lazy shell bindings, not raw variables.
+    // Decline after resolving namerefs so aliases use the same full evaluator.
+    if (tok === "LINENO" || tok === "_" || tok === "FUNCNAME" || tok === "PIPESTATUS")
+        return undefined;
     if (rawState.nounset || activeArrayStore?.bindings.has(tok) || monitor?.hasOverlay(tok) || activeArrayStore?.watches.has(tok))
         return undefined;
     const raw = rawState.variables[tok];
@@ -3737,6 +3743,7 @@ export class Runtime {
     _syncPendingEvalResume;
     _syncReadOnlyArithRefs;
     _activeSyncLoopAssignedVars;
+    _activeSyncArrayLoopWords;
     _activeSyncLoopHasFileMutations = false;
     _inSyncLoopPreflight = false;
     _activeSyncLoopIO;
@@ -4543,16 +4550,18 @@ export class Runtime {
                         const rawSub = this._syncArithRawVars[subVar];
                         if (typeof rawSub !== "string" || rawSub.length === 0)
                             throw new ArrayFailure("empty var subscript in sync arithmetic");
-                        resolvedSub = shellValueText(stateMonitor(st)?.values.get(subVar, rawSub) ?? rawSub);
+                        resolvedSub = this._syncArithRawWriteOnly && this._syncArithTouched?.has(subVar)
+                            ? rawSub
+                            : shellValueText(stateMonitor(st)?.values.get(subVar, rawSub) ?? rawSub);
                     }
                     else if (/^[a-zA-Z_][a-zA-Z_0-9]*$/.test(resolvedSub)) {
                         const st = this._syncArithState;
                         const binding = arrayStore(st)?.get(variable);
                         if (!binding || !binding.associative) {
-                            if (st.nounset || arrayStore(st)?.get(resolvedSub) || stateMonitor(st)?.hasOverlay(resolvedSub))
+                            const index = resolveSimpleArithOperand(resolvedSub, st, stateMonitor(st), arrayStore(st), this._syncArithRawWriteOnly ? this._syncArithTouched : undefined);
+                            if (index === undefined)
                                 throw new ArrayFailure("complex indexed ident subscript in sync arithmetic");
-                            const rawSub = this._syncArithRawVars[resolvedSub];
-                            resolvedSub = rawSub === undefined || rawSub === "" ? "0" : shellValueText(stateMonitor(st)?.values.get(resolvedSub, rawSub) ?? rawSub);
+                            resolvedSub = String(index);
                         }
                     }
                     else {
@@ -5062,6 +5071,8 @@ export class Runtime {
             return binding.get(binding.associative ? binding.keys.get("30")?.index ?? -1 : 0);
         if (name === "DIRSTACK")
             return state.cwd;
+        if (name === "BASH_SUBSHELL")
+            return state.variables.BASH_SUBSHELL ?? "0";
         if (name === "FUNCNAME" && state.variables.FUNCNAME === undefined)
             return state.functionNames?.[0];
         if (name === "_" && state.variables._ === undefined)
@@ -5193,7 +5204,7 @@ export class Runtime {
             if (!watch.valid())
                 throw new ArrayFailure("stale binding");
             binding = scalarLegacy ? undefined : store.get(name)?.retain();
-            typedSavedVariables.set(saved, { owner, binding, tickets, prepared: { name: token, admission }, watch, scalarLegacy });
+            typedSavedVariables.set(saved, { owner, binding, tickets, prepared: { name: token, admission, identity: store.bindings.get(name)?.identity }, watch, scalarLegacy });
             tickets.cleanup = () => { typedSavedVariables.delete(saved); };
         }
         catch (error) {
@@ -5889,6 +5900,22 @@ export class Runtime {
         }
         return p0.operator !== undefined ? this.applySyncArrayMemberOperator(out, p0, rawState) : out;
     }
+    syncArraySubscriptWord(index, state) {
+        if (byteLocale(state.variables) || state.depth >= 24)
+            return undefined;
+        const cached = index;
+        const word = index.word ?? (cached._cachedSyntax === state.extensions?.syntax ? cached._cachedWord : undefined);
+        if (word)
+            return word;
+        try {
+            cached._cachedWord = parseArraySubscript(index.source ?? index.decimal, this.budget.parsing, false, state.depth, false, state.extensions?.syntax);
+            cached._cachedSyntax = state.extensions?.syntax;
+            return cached._cachedWord;
+        }
+        catch {
+            return undefined;
+        }
+    }
     tryFastArrayAssignmentSync(assignment, state, io, diagnosticLine, declaration, associative, ignoreYield = false) {
         if (!ignoreYield && hasYieldCheckpoint(this.signal))
             return false;
@@ -6198,20 +6225,9 @@ export class Runtime {
             return false;
         }
         if (assignment.kind === "element" && current?.associative) {
-            const cachedIdx = assignment.index;
-            let word = assignment.index.word ?? (cachedIdx._cachedSyntax === rawState.extensions?.syntax ? cachedIdx._cachedWord : undefined);
-            if (!word) {
-                if (byteLocale(rawState.variables) || rawState.depth >= 24)
-                    return false;
-                try {
-                    word = parseArraySubscript(assignment.index.source ?? assignment.index.decimal, this.budget.parsing, false, rawState.depth, false, rawState.extensions?.syntax);
-                    cachedIdx._cachedWord = word;
-                    cachedIdx._cachedSyntax = rawState.extensions?.syntax;
-                }
-                catch {
-                    return false;
-                }
-            }
+            const word = this.syncArraySubscriptWord(assignment.index, rawState);
+            if (!word)
+                return false;
             let keyVal;
             let val;
             try {
@@ -6977,7 +6993,7 @@ export class Runtime {
             if (closed)
                 throw new ArrayFailure("indexed writer is closed");
             owner.assertOpen();
-            if (arrayStore(state) !== store || store.owner !== owner || identity !== undefined && store.bindings.get(name) !== identity)
+            if (arrayStore(state) !== store || store.owner !== owner || identity !== undefined && store.bindings.get(name)?.identity !== identity)
                 throw new ArrayFailure("incremental target identity changed");
             if (localIdentity() !== admittedLocal)
                 throw new ArrayFailure("incremental target local identity changed");
@@ -7032,8 +7048,8 @@ export class Runtime {
                             await prepared.close();
                         }
                     }
-                    identity = store.bindings.get(name);
-                    if (!identity)
+                    identity = store.bindings.get(name)?.identity;
+                    if (identity === undefined)
                         throw new ArrayFailure("incremental target is not indexed");
                     validate();
                 }
@@ -9342,7 +9358,7 @@ export class Runtime {
                                     targetOk = true;
                                 }
                             }
-                            else if (isShellIdentifier(w2Plain) && !controlNames.has(w2Plain) && !rawState.readonlyVariables?.has(w2Plain) && !rawState.variableAttributes?.get(w2Plain) && !st?.get(w2Plain) && !mon.hasOverlay(w2Plain)) {
+                            else if (isShellIdentifier(w2Plain) && !printfSlowTargets.has(w2Plain) && !rawState.readonlyVariables?.has(w2Plain) && !rawState.variableAttributes?.get(w2Plain) && !st?.get(w2Plain) && !mon.hasOverlay(w2Plain)) {
                                 targetOk = true;
                             }
                         }
@@ -11260,7 +11276,7 @@ export class Runtime {
                         const isSubTarget = openBr > 0 && targetSpec.endsWith("]") && targetSpec.length > openBr + 2;
                         const rawTargetVar = isSubTarget ? targetSpec.slice(0, openBr) : targetSpec;
                         const targetVar = isShellIdentifier(rawTargetVar) ? resolveSyncNameref(rawState, rawTargetVar) : "";
-                        if (targetVar && isShellIdentifier(targetVar) && targetVar !== "OPTIND" && targetVar !== "PIPESTATUS" && targetVar !== "_" && !rawState.readonlyVariables?.has(targetVar) && !rawState.variableAttributes?.get(targetVar) && !monitor.hasOverlay(targetVar) && (isSubTarget ? Boolean(store?.get(targetVar)) : !store?.get(targetVar))) {
+                        if (targetVar && isShellIdentifier(targetVar) && !printfSlowTargets.has(targetVar) && !rawState.readonlyVariables?.has(targetVar) && !rawState.variableAttributes?.get(targetVar) && !monitor.hasOverlay(targetVar) && (isSubTarget ? Boolean(store?.get(targetVar)) : !store?.get(targetVar))) {
                             fastSubScratchArgs.length = 0;
                             let allStrings = true;
                             try {
@@ -12151,6 +12167,7 @@ export class Runtime {
                         let simpleRead = true;
                         let readDelim = 10;
                         let arrayTarget;
+                        let readLastArgument = command.words[command.words.length - 1].plain;
                         while (readWordIdx < command.words.length) {
                             const p = command.words[readWordIdx].plain;
                             if (p === undefined) {
@@ -12184,6 +12201,8 @@ export class Runtime {
                                                     delimStr = undefined;
                                                 }
                                             }
+                                            if (readWordIdx === command.words.length - 1)
+                                                readLastArgument = delimStr;
                                         }
                                         if (delimStr !== undefined && delimStr.length >= 1 && delimStr.charCodeAt(0) > 0 && delimStr.charCodeAt(0) < 128) {
                                             readDelim = delimStr.charCodeAt(0);
@@ -12449,7 +12468,7 @@ export class Runtime {
                                     rawState.substitutionStatus = 0;
                                     if (rawState.variables._ !== undefined)
                                         delete rawState.variables._;
-                                    rawState.lastArgument = command.words[command.words.length - 1].plain;
+                                    rawState.lastArgument = readLastArgument;
                                     if (io.assignmentDiagnosticContext)
                                         io.assignmentDiagnosticContext.name = undefined;
                                     if (!existing) {
@@ -13156,6 +13175,8 @@ export class Runtime {
                         }
                     }
                     if (canSyncFn) {
+                        if (rawState.functionDepth >= this.budget.limits.maxFunctionDepth)
+                            this.budget.fail("maxFunctionDepth");
                         const prevCommands = this.budget.commands;
                         this.budget.tick();
                         rawState.substitutionStatus = 0;
@@ -13507,12 +13528,12 @@ export class Runtime {
                     return undefined;
                 }
                 const def = this.commands.get("printf");
-                const isPlainTargetId = targetSpec !== undefined && /^[a-zA-Z_][a-zA-Z_0-9]*$/.test(targetSpec) && targetSpec !== "OPTIND" && targetSpec !== "PIPESTATUS";
+                const isPlainTargetId = targetSpec !== undefined && isShellIdentifier(targetSpec) && !printfSlowTargets.has(targetSpec);
                 const isScalarTarget = isPlainTargetId && !store?.get(targetSpec);
                 const brkIdx = targetSpec !== undefined && !isPlainTargetId && targetSpec.endsWith("]") ? targetSpec.indexOf("[") : -1;
                 const arrName = isPlainTargetId && !isScalarTarget ? targetSpec : (brkIdx > 0 ? targetSpec.slice(0, brkIdx) : undefined);
                 const subExpr = isPlainTargetId && !isScalarTarget ? "0" : (brkIdx > 0 ? targetSpec.slice(brkIdx + 1, -1) : undefined);
-                const isArrayTarget = arrName !== undefined && /^[a-zA-Z_][a-zA-Z_0-9]*$/.test(arrName) && !controlNames.has(arrName) && subExpr !== undefined && subExpr.length > 0 && !subExpr.includes("$") && !subExpr.includes("\x60");
+                const isArrayTarget = arrName !== undefined && isShellIdentifier(arrName) && !printfSlowTargets.has(arrName) && subExpr !== undefined && subExpr.length > 0 && !subExpr.includes("$") && !subExpr.includes("\x60");
                 if (def?.execute === printfCommand.execute && (isScalarTarget || isArrayTarget) && command.words.length <= this.budget.maxExpansionFieldsSmi) {
                     fastSubScratchArgs.length = 0;
                     let allStrings = true;
@@ -13973,7 +13994,201 @@ export class Runtime {
         this._syncLoopInvariantSubMap.set(part, { text: res, outBytes, exitStatus: 0, dynamic: usesInduction });
         return true;
     }
+    admitSyncArrayLoop(command, state) {
+        const monitor = stateMonitor(state);
+        const store = monitor?.store;
+        if (!store || store.watches.size || hasUnpreparedLocals(state) || state.depth >= 24 || byteLocale(state.variables) || state.nounset || hasActiveVariableAttributes(state) || this.budget.limits.maxExpansionBytes !== Infinity || this.budget.limits.maxExpansionFields !== Infinity)
+            return undefined;
+        const initializer = command.expressions[0]?.tree;
+        if (initializer?.kind !== "binary" || initializer.operator !== "=" || initializer.left.kind !== "name")
+            return undefined;
+        const induction = initializer.left.name;
+        const dynamicNames = new Set(["PIPESTATUS", "LINENO", "_", "FUNCNAME", "DIRSTACK", "BASH_SUBSHELL"]);
+        const assignments = [];
+        const appends = new Map();
+        for (const list of command.body.lists) {
+            if (list.terminator || list.pipelines.length !== 1)
+                return undefined;
+            const pipeline = list.pipelines[0];
+            const cmd = pipeline.commands[0];
+            if (pipeline.negate || pipeline.commands.length !== 1 || cmd?.kind !== "simple" || cmd.redirects.length || cmd.words.length !== 1)
+                return undefined;
+            const assignment = getArrayAssignment(cmd.words[0]) ?? this.assignment(cmd.words[0]);
+            if (!assignment || assignment.name === induction || controlNames.has(assignment.name) || dynamicNames.has(assignment.name) || monitor.hasOverlay(assignment.name) || state.readonlyVariables?.has(assignment.name))
+                return undefined;
+            if ("kind" in assignment) {
+                const binding = store.get(assignment.name);
+                if (!binding || binding.references !== 1 || state.exported.has(assignment.name))
+                    return undefined;
+                if (assignment.kind === "element") {
+                    if (!binding.associative || assignment.append)
+                        return undefined;
+                }
+                else {
+                    if (binding.associative || !assignment.append || assignment.entries.some(entry => entry.index || entry.append))
+                        return undefined;
+                    appends.set(assignment.name, (appends.get(assignment.name) ?? 0) + assignment.entries.length);
+                }
+            }
+            else if (assignment.append || store.get(assignment.name) || ["IFS", "LC_ALL", "LC_CTYPE", "LC_COLLATE", "LANG"].includes(assignment.name))
+                return undefined;
+            assignments.push(assignment);
+        }
+        if (assignments.length > 30 || !assignments.some(assignment => "kind" in assignment && assignment.kind === "element"))
+            return undefined;
+        const integer = { min: 1, max: 20, integer: true }; // Signed shell arithmetic is 64 bit.
+        const decimal = (value) => {
+            if (value === "")
+                return true; // Unset/empty arithmetic operands are zero.
+            let i = value[0] === "-" ? 1 : 0;
+            if (i === value.length || value.length > 20 || (value[i] === "0" && i + 1 !== value.length))
+                return false;
+            for (; i < value.length; i++)
+                if (value[i] < "0" || value[i] > "9")
+                    return false;
+            return true;
+        };
+        const literalShape = (value) => {
+            if (typeof value !== "string")
+                return undefined;
+            for (let i = 0; i < value.length; i++)
+                if (value.charCodeAt(i) >= 128)
+                    return undefined;
+            return { min: value.length, max: value.length, integer: decimal(value) };
+        };
+        const integerArrays = new Set();
+        for (const [name, { binding }] of store.bindings) {
+            if (!binding.associative)
+                continue;
+            if (![...binding.values.values()].every(slot => typeof slot.text.shellValue === "string" && decimal(slot.text.shellValue)))
+                continue;
+            const writesInteger = assignments.every(assignment => {
+                if (assignment.name !== name || !("kind" in assignment) || assignment.kind !== "element")
+                    return true;
+                const parts = assignment.value.parts.filter(part => part.kind !== "text" || part.value !== "");
+                return parts.length === 1 && parts[0].kind === "arithmetic" || parts.every(part => part.kind === "text") && decimal(parts.map(part => part.value).join(""));
+            });
+            if (writesInteger)
+                integerArrays.add(name);
+        }
+        const entry = new Map();
+        for (const assignment of assignments) {
+            if ("kind" in assignment)
+                continue;
+            const raw = state.variables[assignment.name];
+            const shape = literalShape(raw === undefined ? "" : monitor.values.get(assignment.name, raw) ?? raw);
+            if (!shape)
+                return undefined;
+            entry.set(assignment.name, shape);
+        }
+        // Find an invariant over successive iterations. Growing strings or unknown
+        // key bounds decline before execution; no speculative writes or replay.
+        for (let pass = 0; pass < 32; pass++) {
+            const values = new Map(entry);
+            values.set(induction, integer);
+            const words = new WeakSet();
+            const integerWords = new WeakSet();
+            const scalar = (name) => {
+                if (!isShellIdentifier(name) || controlNames.has(name) || dynamicNames.has(name) || store.get(name) || monitor.hasOverlay(name) || hasUnpreparedLocal(state, name))
+                    return undefined;
+                const known = values.get(name);
+                if (known)
+                    return known;
+                const raw = state.variables[name];
+                return literalShape(raw === undefined ? "" : monitor.values.get(name, raw) ?? raw);
+            };
+            const shapeWord = (word, key = false) => {
+                if (!word.parts.length)
+                    return undefined;
+                const shapes = [];
+                for (const part of word.parts) {
+                    let shape;
+                    if (part.kind === "text") {
+                        if (part.byteValue || invokedValues.has(part) || !part.quoted && part.value.includes("~"))
+                            return undefined;
+                        shape = literalShape(part.value);
+                    }
+                    else if (part.kind === "arithmetic") {
+                        const names = new Set();
+                        if (!collectPureReadOnlySmiNames(part.expression, names) || [...names].some(name => !scalar(name)?.integer))
+                            return undefined;
+                        shape = integer;
+                    }
+                    else if (part.kind === "variable") {
+                        if (part.indirect || part.specialParameter || part.prefixNames || part.length || part.substring || part.transform || part.keys || dynamicNames.has(part.name))
+                            return undefined;
+                        const selector = getArraySelector(part);
+                        if (selector) {
+                            if (key || selector.kind !== "element" || !store.get(part.name)?.associative || monitor.hasOverlay(part.name) || controlNames.has(part.name))
+                                return undefined;
+                            const index = this.syncArraySubscriptWord(selector.index, state);
+                            if (!index || !shapeWord(index, true))
+                                return undefined;
+                            shape = { min: 0, max: integerArrays.has(part.name) ? 20 : Infinity, integer: integerArrays.has(part.name) };
+                            if (part.operator !== undefined) {
+                                if ((part.operator !== "-" && part.operator !== ":-") || !part.alternate || !part.alternate.parts.every(p => p.kind === "text"))
+                                    return undefined;
+                                const alternate = shapeWord(part.alternate);
+                                if (!alternate)
+                                    return undefined;
+                                shape = { min: part.operator === ":-" ? Math.min(1, alternate.min) : 0, max: Math.max(shape.max, alternate.max), integer: shape.integer && alternate.integer };
+                            }
+                        }
+                        else {
+                            if (part.operator !== undefined)
+                                return undefined;
+                            shape = scalar(part.name);
+                        }
+                    }
+                    else
+                        return undefined;
+                    if (!shape)
+                        return undefined;
+                    shapes.push(shape);
+                }
+                const nonempty = shapes.filter(shape => shape.max !== 0);
+                const result = { min: shapes.reduce((sum, shape) => sum + shape.min, 0), max: shapes.reduce((sum, shape) => sum + shape.max, 0), integer: nonempty.length === 0 || nonempty.length === 1 && nonempty[0].integer };
+                if (key && (result.min === 0 || result.max > 4096))
+                    return undefined;
+                words.add(word);
+                if (result.integer)
+                    integerWords.add(word);
+                return result;
+            };
+            for (const assignment of assignments) {
+                if ("kind" in assignment && assignment.kind === "compound") {
+                    if (assignment.entries.some(entry => !entry.value.parts.every(part => part.quoted) || !shapeWord(entry.value)))
+                        return undefined;
+                }
+                else {
+                    if ("kind" in assignment) {
+                        const index = this.syncArraySubscriptWord(assignment.index, state);
+                        if (!index || !shapeWord(index, true))
+                            return undefined;
+                    }
+                    const shape = shapeWord(assignment.value);
+                    if (!shape)
+                        return undefined;
+                    if (!("kind" in assignment))
+                        values.set(assignment.name, shape);
+                }
+            }
+            let stable = true;
+            for (const [name, before] of entry) {
+                const after = values.get(name);
+                const merged = { min: Math.min(before.min, after.min), max: Math.max(before.max, after.max), integer: before.integer && after.integer };
+                if (merged.min !== before.min || merged.max !== before.max || merged.integer !== before.integer)
+                    stable = false;
+                entry.set(name, merged);
+            }
+            if (stable)
+                return { words, integerWords, appends };
+        }
+        return undefined;
+    }
     isPureSyncValueWord(word, rawState, allowAt = false) {
+        if (this._activeSyncArrayLoopWords?.has(word))
+            return true;
         if (word.parts.length === 0)
             return false;
         for (let i = 0; i < word.parts.length; i++) {
@@ -15080,8 +15295,7 @@ export class Runtime {
                     if (!hasActiveVariableAttributes(rawState) &&
                         vName !== undefined &&
                         isShellIdentifier(vName) &&
-                        !controlNames.has(vName) &&
-                        vName !== "OPTIND" &&
+                        !printfSlowTargets.has(vName) &&
                         !rawState.readonlyVariables?.has(vName) &&
                         !rawState.variableAttributes?.get(vName) &&
                         !store?.get(vName) &&
@@ -15129,14 +15343,19 @@ export class Runtime {
                     if (hasUnpreparedLocals(rawState))
                         return false;
                     // 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)) {
+                    if (!curArr || curArr.references !== 1 || activeArrStore?.watches.has(arrAssign.name) || rawState.readonlyVariables?.has(arrAssign.name) || rawState.variableAttributes?.has(arrAssign.name) || rawState.exported.has(arrAssign.name) || controlNames.has(arrAssign.name)) {
                         return false;
                     }
+                    if (arrAssign.kind === "element") {
+                        // Only the whole-loop proof can admit associative keys. Indexed
+                        // arithmetic and relative subscripts retain normal evaluation.
+                        const index = curArr.associative ? this.syncArraySubscriptWord(arrAssign.index, rawState) : undefined;
+                        if (!index || !this._activeSyncArrayLoopWords?.has(index) || !this.isPureSyncValueWord(index, rawState) || !this.isPureSyncValueWord(arrAssign.value, rawState))
+                            return false;
+                        continue;
+                    }
                     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++) {
@@ -15554,7 +15773,7 @@ export class Runtime {
         }
         return res;
     }
-    syncLoopArithmeticReadsRemainInteger(steps, rawState) {
+    syncLoopArithmeticReadsRemainInteger(steps, rawState, integerWords) {
         const reads = new Set();
         const seen = new WeakSet();
         // Inspect words in commands, conditions, substitutions, and inlined functions.
@@ -15577,7 +15796,7 @@ export class Runtime {
         const safeWrites = (items) => items.every(step => {
             if (step.name && reads.has(step.name)) {
                 const literal = step.value?.plain;
-                if (step.append || (!this.extractIntLoopStep(step, rawState) && (literal === undefined || !/^-?[0-9]+$/.test(literal))))
+                if (step.append || (!integerWords?.has(step.value) && !this.extractIntLoopStep(step, rawState) && (literal === undefined || !/^-?[0-9]+$/.test(literal))))
                     return false;
             }
             if (step.readHereString?.varNames.some(name => reads.has(name)) || (step.readHereString?.arrayTarget && reads.has(step.readHereString.arrayTarget)))
@@ -15736,6 +15955,9 @@ export class Runtime {
         const prevAssignedVars = this._activeSyncLoopAssignedVars;
         const prevLoopIO = this._activeSyncLoopIO;
         const prevInvMap = this._syncLoopInvariantSubMap;
+        const prevArrayWords = this._activeSyncArrayLoopWords;
+        const arrayLoop = command.kind === "arithmetic-for" ? this.admitSyncArrayLoop(command, rawState) : undefined;
+        this._activeSyncArrayLoopWords = arrayLoop?.words;
         this._activePrintfInductionName = printfInductionName;
         this._activeSyncLoopAssignedVars = this.collectSyncLoopAssignedVars(command, rawState);
         this._activeSyncLoopIO = io;
@@ -15750,6 +15972,7 @@ export class Runtime {
             this._activeSyncLoopAssignedVars = prevAssignedVars;
             this._activeSyncLoopIO = prevLoopIO;
             this._syncLoopInvariantSubMap = prevInvMap;
+            this._activeSyncArrayLoopWords = prevArrayWords;
         }
         if (!bodySyncOk) {
             command._skipTrySyncLoop = true;
@@ -15788,7 +16011,7 @@ export class Runtime {
         this._syncLoopInvariantSubMap = localInvMap;
         try {
             const { steps: bodyAssignments, redirectCount } = this.buildSyncLoopBody(command, rawState, io);
-            if (bodyAssignments.length > 30 || !this.syncLoopArithmeticReadsRemainInteger(bodyAssignments, rawState))
+            if (bodyAssignments.length > 30 || !this.syncLoopArithmeticReadsRemainInteger(bodyAssignments, rawState, arrayLoop?.integerWords))
                 return undefined;
             const touched = this._syncArithRawWriteOnly ? new Set() : sharedSyncLoopTouched;
             touched.clear();
@@ -15940,6 +16163,10 @@ export class Runtime {
                                 : step.value ? [step.value] : [];
                         for (let wIdx = 0; wIdx < wordsToScan.length; wIdx++) {
                             const wVal = wordsToScan[wIdx];
+                            // The array-loop proof tracks integer values at each statement,
+                            // including scalars loaded from arrays earlier in the same iteration.
+                            if (arrayLoop?.words.has(wVal))
+                                continue;
                             for (let i = 0; i < wVal.parts.length; i++) {
                                 const part = wVal.parts[i];
                                 if (part.kind === "text" || part.kind === "variable")
@@ -16028,6 +16255,14 @@ export class Runtime {
                     return undefined;
                 }
                 const { e0, e1, e2, iterations, inductionName, startVal, limitVal, isLe, isSimpleLiteralAsc, arithNamesList, intSteps, allIntStepsReady, hasSubIntStep, hasDeferredSteps, deferredMask, touchedIntNamesList, } = plan;
+                if (arrayLoop?.appends.size) {
+                    if (!isSimpleLiteralAsc)
+                        return undefined;
+                    for (const [name, count] of arrayLoop.appends) {
+                        if (store.get(name).maximum + iterations * count > 2147483647)
+                            return undefined;
+                    }
+                }
                 if (inductionName === "OPTIND" || controlNames.has(inductionName) || monitor.hasOverlay(inductionName) || hasUnpreparedLocal(rawState, inductionName) || store?.get(inductionName) || rawState.readonlyVariables?.has(inductionName) || rawState.variableAttributes?.get(inductionName))
                     return undefined;
                 if (!isSimpleLiteralAsc && (!this.canSyncArithmeticWithoutFault(e0.tree, rawState, diagnosticLine) || !this.canSyncArithmeticWithoutFault(e1.tree, rawState, diagnosticLine) || !this.canSyncArithmeticWithoutFault(e2.tree, rawState, diagnosticLine)))
@@ -16035,6 +16270,8 @@ export class Runtime {
                 if (arithNamesList.length > 0) {
                     for (let a = 0; a < arithNamesList.length; a++) {
                         const refName = arithNamesList[a];
+                        if (store?.get(refName))
+                            return undefined;
                         if (refName === inductionName)
                             continue;
                         const initial = rawState.variables[refName];
@@ -18711,6 +18948,7 @@ export class Runtime {
             signal.throwIfAborted();
             child.extensions = forkExtensions(state.extensions, "subshell");
             child.isolated = true;
+            child.variables.BASH_SUBSHELL = String(Number(state.variables.BASH_SUBSHELL ?? 0) + 1);
             child.depth++;
             const allocation = this.budget.values.scope();
             scope.register(() => allocation.close());
@@ -18905,6 +19143,9 @@ export class Runtime {
                                             })
                                             : (tryCloneStateSync(state) ?? await cloneState(state, this.signal));
                                         preparedChild = child;
+                                        if (child._readOnlyStage)
+                                            child.variables = { ...child.variables };
+                                        child.variables.BASH_SUBSHELL = String(Number(state.variables.BASH_SUBSHELL ?? 0) + 1);
                                         if (!child._readOnlyStage) {
                                             child.extensions = undefined;
                                             child.extensions = forkExtensions(state.extensions, "pipeline");
@@ -19841,6 +20082,7 @@ export class Runtime {
                 try {
                     child.extensions = forkExtensions(state.extensions, "subshell");
                     child.isolated = true;
+                    child.variables.BASH_SUBSHELL = String(Number(state.variables.BASH_SUBSHELL ?? 0) + 1);
                     child.loopDepth = 0;
                     if (state.extensions?.checkpoints.length)
                         await this.extensionCheckpoint("child-job-install", state, io);
@@ -21188,6 +21430,8 @@ export class Runtime {
     async dispatchFastFunction(name, body, args, state, io, pendingResume) {
         if (!pendingResume && state.depth >= this.budget.limits.maxSubstitutionDepth)
             this.budget.fail("maxSubstitutionDepth");
+        if (!pendingResume && state.functionDepth >= this.budget.limits.maxFunctionDepth)
+            this.budget.fail("maxFunctionDepth");
         const scope = io[invocationScope].child();
         try {
             const monitor = stateMonitor(state);
@@ -21700,6 +21944,8 @@ export class Runtime {
                         ensureRuntimeContext();
                         if (state.depth >= this.budget.limits.maxSubstitutionDepth)
                             this.budget.fail("maxSubstitutionDepth");
+                        if (state.functionDepth >= this.budget.limits.maxFunctionDepth)
+                            this.budget.fail("maxFunctionDepth");
                         const positional = state.positional;
                         const savedPositionals = stateMonitor(state).positionals.clone();
                         const positionalSetVersion = state.positionalSetVersion ?? 0;
@@ -22267,13 +22513,20 @@ export class Runtime {
             const option = args.shift();
             if (option === "--" || option === "-")
                 break;
+            if (option === "--version") {
+                await writeDiagnostic(context.stdout, "safe-bash (poe-code)\n");
+                return 0;
+            }
+            if (option === "--login" || option === "--norc" || option === "--noprofile" || option === "--posix") {
+                continue;
+            }
             const enabled = option[0] === "-";
             if ((option === "-o" || option === "+o") && Object.hasOwn(options, args[0] ?? "")) {
                 options[args.shift()] = enabled;
                 continue;
             }
             const flags = option.slice(1);
-            if (!flags.length || [...flags].some(flag => !Object.hasOwn(flagsByName, flag) && !(enabled && (flag === "c" || flag === "s")))) {
+            if (!flags.length || [...flags].some(flag => !Object.hasOwn(flagsByName, flag) && !(enabled && (flag === "c" || flag === "s" || flag === "l" || flag === "i")))) {
                 await writeDiagnostic(context.stderr, `${context.command}: ${option}: unsupported option; supported flags are -c, -s, +/-a, +/-e, +/-u, +/-n, +/-B, +/-f, +/-C and +/-o ${Object.keys(options).join(", ")}\n`);
                 return 2;
             }
@@ -23796,6 +24049,9 @@ export class Runtime {
                 await writeDiagnostic(context.stderr, `printf: ${name}: readonly variable\n`);
                 return 1;
             }
+            // Bash ignores assignments to its function-stack variable.
+            if (name === "FUNCNAME")
+                return status;
             if (index || arrayStore(state)?.get(name)) {
                 const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
                 const decode = (bytes) => {
@@ -24722,7 +24978,8 @@ export class Runtime {
                             let shadow;
                             try {
                                 const tickets = operation.reserve({ generation: true, version: true, epoch: true, work: 8 });
-                                shadow = IndexedBinding.create(store.owner);
+                                if (enabled.has("I"))
+                                    shadow = await store.get(name).copy(this.signal);
                                 this.signal.throwIfAborted();
                                 if (state.readonlyVariables?.has(name))
                                     throw new ArrayFailure("readonly binding");
@@ -24731,7 +24988,7 @@ export class Runtime {
                                 let released;
                                 stateMonitor(state).publish(tickets, name, () => {
                                     locals.set(name, saved);
-                                    released = store.publish(name, shadow, tickets);
+                                    released = shadow ? store.publish(name, shadow, tickets) : store.remove(name, tickets);
                                 });
                                 shadow = undefined;
                                 await released;
@@ -25627,6 +25884,7 @@ export class Runtime {
                 const capture = new Capture();
                 const child = await cloneState(state, this.signal);
                 child.isolated = true;
+                child.variables.BASH_SUBSHELL = String(Number(state.variables.BASH_SUBSHELL ?? 0) + 1);
                 child.extensions = forkExtensions(state.extensions, "substitution");
                 if (state.profile !== "sh")
                     child.errexit = false;
@@ -25680,6 +25938,7 @@ export class Runtime {
                 }
                 const child = await cloneState(state, this.signal);
                 child.isolated = true;
+                child.variables.BASH_SUBSHELL = String(Number(state.variables.BASH_SUBSHELL ?? 0) + 1);
                 child.extensions = forkExtensions(state.extensions, "substitution");
                 if (state.profile !== "sh")
                     child.errexit = false;
@@ -25733,6 +25992,7 @@ export class Runtime {
             const capture = new Capture();
             const child = await cloneState(state, this.signal);
             child.isolated = true;
+            child.variables.BASH_SUBSHELL = String(Number(state.variables.BASH_SUBSHELL ?? 0) + 1);
             child.extensions = forkExtensions(state.extensions, "substitution");
             if (state.profile !== "sh")
                 child.errexit = false;
@@ -25835,7 +26095,7 @@ export class Runtime {
             if (part.length)
                 return String(binding?.values.size ?? (part.name === "FUNCNAME" && state.variables.FUNCNAME === undefined ? state.functionNames?.length ?? 0 : state.variables[part.name] === undefined ? 0 : 1));
             const values = await this.arrayMembers(part.name, state, io, selector.kind === "keys" || part.keys === true, part.substring);
-            const space = (selector.kind === "keys" || part.keys === true) ? Boolean(hereDocument || (selector.separator === "@" ? !part.quoted && !split || state.variables.IFS === "" : !part.quoted && split && state.variables.IFS === "")) : (!split && selector.separator === "@");
+            const space = (selector.kind === "keys" || part.keys === true) ? Boolean(hereDocument || (selector.separator === "@" ? !part.quoted && !split || state.variables.IFS === "" : !part.quoted && split && state.variables.IFS === "")) : (!split && selector.separator === "@" && (!part.substring || !part.quoted || state.variables.IFS === ""));
             return this.arrayJoin(store.owner, values, space ? " " : this.ifsSeparator(state, io));
         }
         if (part.substring && (part.name === "@" || part.name === "*")) {
@@ -26477,7 +26737,7 @@ export class Runtime {
                 }
                 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")
+                if (part.name === "@" || part.name === "*" || part.name === "PIPESTATUS" || part.name === "LINENO" || part.name === "BASH_SUBSHELL" || part.name === "_" || part.name === "FUNCNAME" || part.name === "DIRSTACK")
                     return undefined;
                 if (!isShellIdentifier(part.name))
                     return undefined;
@@ -26558,7 +26818,7 @@ export class Runtime {
                             }
                             const ifsVal = monitor?.values.get("IFS", rawVars.IFS ?? " ") ?? rawVars.IFS ?? " ";
                             if (validElemOp && typeof ifsVal === "string" && (ifsVal.length === 0 || ifsVal.charCodeAt(0) < 128)) {
-                                const sep = selector.separator === "@" && (ifsVal.length === 0 || !isKeys && part.operator === undefined) ? " " : ifsVal.length > 0 ? ifsVal[0] : "";
+                                const sep = selector.separator === "@" && (ifsVal.length === 0 || !isKeys && part.operator === undefined && !part.substring) ? " " : ifsVal.length > 0 ? ifsVal[0] : "";
                                 const parameterLine = part.line ?? overrideDiagnosticLine;
                                 const evalSliceInt = (w) => {
                                     if (w.parts.length === 0)
@@ -26673,20 +26933,9 @@ export class Runtime {
                         return undefined;
                     }
                     if (selector.kind === "element") {
-                        const cachedSub = selector.index;
-                        let subWord = selector.index.word ?? (cachedSub._cachedSyntax === rawState.extensions?.syntax ? cachedSub._cachedWord : undefined);
-                        if (!subWord) {
-                            if (byteLocale(rawVars) || rawState.depth >= 24)
-                                return undefined;
-                            try {
-                                subWord = parseArraySubscript(selector.index.source ?? selector.index.decimal, this.budget.parsing, false, rawState.depth, false, rawState.extensions?.syntax);
-                                cachedSub._cachedWord = subWord;
-                                cachedSub._cachedSyntax = rawState.extensions?.syntax;
-                            }
-                            catch {
-                                return undefined;
-                            }
-                        }
+                        const subWord = this.syncArraySubscriptWord(selector.index, rawState);
+                        if (!subWord)
+                            return undefined;
                         const subVal = this.fastValueWord(subWord, rawState, io, false, false, false, false, undefined, part.line ?? overrideDiagnosticLine);
                         if (typeof subVal !== "string")
                             return undefined;
@@ -26861,6 +27110,14 @@ export class Runtime {
                     if (part.length || part.operator !== undefined || this.budget.limits.maxExpansionBytes !== Infinity || rawState.depth + (io.parameterDepth ?? 0) >= 60 || !part.substring.offset.parts.every(p => p.kind === "text" || p.kind === "arithmetic" || (p.kind === "variable" && !p.operator && !p.substring)) || (part.substring.length && !part.substring.length.parts.every(p => p.kind === "text" || p.kind === "arithmetic" || (p.kind === "variable" && !p.operator && !p.substring))) || ValueScope.prototype.reserve !== defaultValueScopeReserve || String.prototype.codePointAt !== defaultStringCodePointAt || globalThis.Float64Array !== defaultFloat64Array || (!part.substring.offset.parts.length && !part.substring.length)) {
                         return undefined;
                     }
+                    // Resolve the parameter before expanding either arithmetic operand.
+                    const raw = rawVars[part.name];
+                    this.requireParameter(raw, part.name, state, io, part.line ?? overrideDiagnosticLine);
+                    if (raw === undefined) {
+                        if (split && !part.quoted)
+                            return undefined;
+                        continue;
+                    }
                     const parameterLine = part.line ?? overrideDiagnosticLine;
                     const evalSubInt = (w) => {
                         if (w.parts.length === 0)
@@ -26886,13 +27143,6 @@ export class Runtime {
                     const lenNum = part.substring.length ? evalSubInt(part.substring.length) : undefined;
                     if (part.substring.length && lenNum === undefined)
                         return undefined;
-                    const raw = rawVars[part.name];
-                    this.requireParameter(raw, part.name, state, io, part.line ?? overrideDiagnosticLine);
-                    if (raw === undefined) {
-                        if (split && !part.quoted)
-                            return undefined;
-                        continue;
-                    }
                     const val = this._syncArithRawWriteOnly && this._syncArithTouched?.has(part.name) ? raw : (monitor?.values.get(part.name, raw) ?? raw);
                     if (typeof val !== "string" || val.length > this.budget.limits.maxExpansionBytes)
                         return undefined;
@@ -35921,6 +36171,8 @@ export class Runtime {
             if (p.kind === "text")
                 continue;
             if (p.kind === "variable") {
+                if (p.name === "BASH_SUBSHELL")
+                    return false;
                 if (!p.indirect && !p.prefixNames && !p.length && !p.substring && !p.transform && p.operator === undefined && getArraySelector(p) === undefined && (p.name === "?" || p.name === "#" || (p.name.length === 1 && p.name >= "1" && p.name <= "9"))) {
                     const activePos = this._fastSubPositional ?? rawState.positional;
                     if (rawState.nounset && p.name >= "1" && p.name <= "9" && activePos[p.name.charCodeAt(0) - 49] === undefined)