@poe-platform/safe-bash 0.1.802 → 0.1.804

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

@@ -28,6 +28,8 @@ import { MemoryFileSystem, isCleanAbsolutePath, retargetScopedFileSystem, scopeF
 import { collectPureReadOnlySmiNames, compilePureSmiProgram, evaluateArithmetic, evaluateArithmeticReferences, evaluateArithmeticSync, evaluateArithmeticSyncNonZero, evaluateArithmeticSyncString, fastSafeInt, intToStr, isSafeSmiProgram, prepareArithmetic, runIntArithForLoop, runIntForLoop, sharedLoopIntRegs } from "./arithmetic.js";
 import { ParseBudget } from "./parse-budget.js";
 import { BraceExpansionFailure, expandBraces, tryFastExpandBraceRange } from "./brace-expansion.js";
+import { createAliasCommand } from "../../safe-bash-command-alias/index.js";
+import { createUnaliasCommand } from "../../safe-bash-command-unalias/index.js";
 import { expandTildes } from "./tilde-expansion.js";
 import { evaluatePositionalArithmetic } from "./arithmetic-parameters.js";
 import { compilePattern, compilePatternBoundaries, matchesPattern, tryMatchesPatternSync } from "./pattern.js";
@@ -163,6 +165,7 @@ export const defaultLimits = {
     maxPathnameComponents: Infinity,
     maxRedirects: Infinity,
     maxPipelineStages: Infinity,
+    maxPipelineBytes: Infinity,
     maxLoopIterations: Infinity,
     maxSubstitutionDepth: Infinity,
     maxFunctionDepth: Infinity,
@@ -177,7 +180,7 @@ export const defaultLimits = {
     pipeHighWaterMark: 64 * 1024,
 };
 const shellBuiltinNames = new Set([
-    ":", "true", "false", "pwd", "cd", "set", "shift", "export", "local", "unset", "read", "declare", "typeset", "mapfile", "readarray", "umask", "exit", "return", "break", "continue", "command", "builtin", "type", "readonly", "echo", "printf", "test", "[", ".", "source", "eval", "getopts", "let", "pushd", "dirs", "popd", "shopt", "hash",
+    ":", "true", "false", "pwd", "cd", "set", "shift", "export", "local", "unset", "read", "declare", "typeset", "mapfile", "readarray", "umask", "exit", "return", "break", "continue", "command", "builtin", "type", "readonly", "echo", "printf", "test", "[", ".", "source", "eval", "exec", "getopts", "let", "pushd", "dirs", "popd", "shopt", "hash", "alias", "unalias",
 ]);
 const implementedBuiltins = new Set([...shellBuiltinNames].filter(name => !["echo", "printf", "test", "["].includes(name)));
 const extensionExitFailures = new WeakMap();
@@ -228,9 +231,10 @@ function publishCommandSpelling(state, description) {
     (monitor?.raw ?? state).variables.BASH_COMMAND = description;
 }
 export function resolveLimits(...limits) {
-    const result = Object.assign({}, defaultLimits, ...limits);
+    const definedLimits = limits.map(layer => Object.fromEntries(Object.entries(layer ?? {}).filter(([, value]) => value !== undefined)));
+    const result = Object.assign({}, defaultLimits, ...definedLimits);
     const commandLimits = resolveCommandLimits(...limits.map(value => value?.commandLimits));
-    for (const [key, value] of Object.entries(Object.assign({}, ...limits))) {
+    for (const [key, value] of Object.entries(Object.assign({}, ...definedLimits))) {
         if (key === "commandLimits")
             continue;
         if ((value !== Infinity || key === "pipeHighWaterMark") && (!Number.isSafeInteger(value) || value < (key === "pipeHighWaterMark" ? 1 : 0))) {
@@ -453,6 +457,7 @@ function tickSharedWallClockBudgets() {
     }
 }
 export class Budget {
+    pipelineBytes = 0;
     get fileSystemOperations() {
         return this._fileSystemOperations;
     }
@@ -494,7 +499,7 @@ export class Budget {
             this.maxSourceBytesSmi = limits.maxSourceBytes | 0;
         if (limits.maxPipelineStages < 0x3fffffff)
             this.maxPipelineStagesSmi = limits.maxPipelineStages | 0;
-        if (limits.pipeHighWaterMark < 65536)
+        if (limits.pipeHighWaterMark < 65536 || limits.maxPipelineBytes !== Infinity)
             this.canSyncPurePipe = false;
         this.signal = signal ? combineManagedSignals(signal, this.controller.signal) : this.controller.signal;
         if (signal)
@@ -588,6 +593,8 @@ export class Budget {
         return this._wallClockDeadline;
     }
     close() {
+        if (this._hasExternalSignal)
+            releaseCombinedSignal(this.signal);
         const timer = this._wallClockTimer;
         if (timer === undefined)
             return;
@@ -643,6 +650,16 @@ export class Budget {
     set fsOperations(value) {
         this._fileSystemOperations = value;
     }
+    pipelineInput = (bytes) => {
+        if (this.limits.maxPipelineBytes === Infinity)
+            return;
+        this.assertPipelineInput(bytes);
+        this.pipelineBytes += bytes;
+    };
+    assertPipelineInput(bytes) {
+        if (bytes > this.limits.maxPipelineBytes - this.pipelineBytes)
+            this.fail("maxPipelineBytes");
+    }
     reservePipelineStages(count) {
         this.signal.throwIfAborted();
         if (count > this.limits.maxPipelineStages - this._pipelineStages)
@@ -989,7 +1006,7 @@ export class Capture {
                 if (same)
                     return cachedCaptureAsciiStr;
             }
-            const decoded = typeof globalThis.Buffer === "function" ? globalThis.Buffer.prototype.utf8Slice.call(buf, 0, len) : sharedCaptureDecoder.decode(buf.subarray(0, len));
+            const decoded = sharedCaptureDecoder.decode(buf.subarray(0, len));
             if (len <= 4096) {
                 for (let i = 0; i < len; i++)
                     cachedCaptureAsciiBytes[i] = buf[i];
@@ -1020,6 +1037,17 @@ const invokedValues = new WeakMap();
 const functionDiagnostics = new WeakMap();
 const childIdentities = new WeakMap();
 const declarationArrays = Symbol("declarationArrays");
+const execDescriptorFrames = new WeakMap();
+async function closeExecDescriptors(state) {
+    const raw = stateMonitor(state)?.raw ?? state;
+    const frame = execDescriptorFrames.get(raw);
+    if (!frame)
+        return;
+    execDescriptorFrames.delete(raw);
+    const results = await Promise.allSettled([...frame.releases.values()].map(release => release()));
+    frame.releases.clear();
+    throwCleanupFailures(results.filter(result => result.status === "rejected").map(result => result.reason));
+}
 class DescriptorLifetime {
     finalize;
     _references = 1;
@@ -1264,6 +1292,8 @@ class ExpansionFailure extends Error {
         this.line = line;
     }
 }
+class FailglobFailure extends ExpansionFailure {
+}
 class CommandFailure extends Error {
     status;
     constructor(message, status) {
@@ -1493,6 +1523,7 @@ class BudgetedPipeStageSink {
         return Boolean(w.open && pipe && !pipe.failed && !pipe.signal?.aborted && pipe.readerReferences && (!pipe.writes || pipe.writes.size === 0) && (pipe.availableBytes ?? 0) < (pipe.highWaterMark ?? 0));
     }
     writeSync(chunk) {
+        this.budget.assertPipelineInput(chunk.byteLength);
         this.budget.bytes += chunk.byteLength;
         this.writable.write(chunk);
         if (chunk.byteLength && this.written)
@@ -1742,10 +1773,20 @@ function bindCommandIO(context, io, limits = {}) {
     });
 }
 class FastShellCommandContext {
-    constructor(runtime, state, io, scope, name, args, argumentValues, env, signalIsScoped) {
-        const directContext = FAST_DIRECT_CONTEXT_COMMANDS.has(name) || (name === "find" && !args.includes("-exec") && !args.includes("-ok"));
+    get signal() {
+        const self = this._self ?? this;
+        return self._nativeSignal ??= toNativeAbortSignal(self._rawSignal);
+    }
+    set signal(signal) {
+        const self = this._self ?? this;
+        self._rawSignal = signal;
+        self._nativeSignal = undefined;
+    }
+    constructor(runtime, state, io, scope, name, args, argumentValues, env, signalIsScoped, definition) {
+        const directContext = builtInDirectContextExecutors.has(definition.execute) && !customRegisteredCommands.has(definition.execute)
+            && (FAST_DIRECT_CONTEXT_COMMANDS.has(name) || (name === "find" && !args.includes("-exec") && !args.includes("-ok")));
         if (!directContext) {
-            const { [invocationScope]: ignoredScope, [valueScope]: ignoredAllocation, [declarationArrays]: ignoredArrays, argumentValues: ignoredArguments, ...publicIO } = io;
+            const { [invocationScope]: ignoredScope, [valueScope]: ignoredAllocation, [declarationArrays]: ignoredArrays, argumentValues: ignoredArguments, signal: ignoredSignal, ...publicIO } = io;
             Object.defineProperties(this, Object.getOwnPropertyDescriptors(publicIO));
         }
         this._self = this;
@@ -1764,15 +1805,19 @@ class FastShellCommandContext {
         this._argumentValues = argumentValues;
         this._env = env;
         this.cwd = state.cwd;
-        this.signal = runtime._isMemoryBackingFs && runtime.commandSignal === runtime.signal ? runtime.commandSignal : toNativeAbortSignal(runtime.commandSignal);
+        this.signal = runtime.commandSignal;
         this.onInternalError = runtime.budget.onInternalError;
         this.argv0 = io.argv0;
         this.capabilities = io.capabilities;
         this.processSignals = io.processSignals;
         this.diagnosticLine = io.diagnosticLine;
         this.scriptName = io.scriptName;
-        if (directContext)
+        if (directContext) {
+            Object.defineProperty(this, "signal", {
+                ...Object.getOwnPropertyDescriptor(FastShellCommandContext.prototype, "signal"), enumerable: true,
+            });
             return;
+        }
         workerRuntimeContexts.set(this, {
             budget: runtime.budget, umask: state.umask ?? 0o022, ignoredSignals: captureIgnoredTrapSignals(state.extensions), get fs() { return runtime.getContextFsForFast(0, combineManagedSignals(runtime.signal, scope.signal)); },
         });
@@ -1805,7 +1850,7 @@ class FastShellCommandContext {
         this.command = name;
         this.args = args;
         this.cwd = state.cwd;
-        this.signal = runtime._isMemoryBackingFs ? signal : toNativeAbortSignal(signal);
+        this.signal = signal;
         this.onInternalError = runtime.budget.onInternalError;
         this.argv0 = io.argv0;
         this.capabilities = io.capabilities;
@@ -1941,7 +1986,6 @@ class FastShellCommandContext {
     }
     get fs() {
         const self = this._self ?? this;
-        self.signal = toNativeAbortSignal(self.signal);
         if (!self._contextFs) {
             self._contextFs = self._runtime.getContextFsForFast(self._state.umask ?? 0o022, self._getScopedSignal());
         }
@@ -2005,7 +2049,7 @@ function isFastDirectCommand(name, words) {
     }
     return true;
 }
-const fastShellCommandAccessors = ["env", "fs", "shellPredicates", "inputBudget", "executionScope", "registerCleanup", "invoke", "argumentValues"].map(key => [key, Object.getOwnPropertyDescriptor(FastShellCommandContext.prototype, key)]);
+const fastShellCommandAccessors = ["signal", "env", "fs", "shellPredicates", "inputBudget", "executionScope", "registerCleanup", "invoke", "argumentValues", "stdinInput", "stdoutFile"].map(key => [key, Object.getOwnPropertyDescriptor(FastShellCommandContext.prototype, key)]);
 function cloneRawState(raw, hasLocals) {
     const variables = Object.assign(Object.create(null), raw.variables);
     const exported = raw.exported.size ? new Set(raw.exported) : new Set();
@@ -2033,6 +2077,12 @@ function cloneRawState(raw, hasLocals) {
         cloned.getopts = cloneGetoptsBinding(raw);
     if (raw.functionNames)
         cloned.functionNames = [...raw.functionNames];
+    if (raw.aliases)
+        cloned.aliases = new Map(raw.aliases);
+    if (raw.loopDepth > 0 || raw._subshellInLoop) {
+        cloned._subshellInLoop = true;
+    }
+    cloned.loopDepth = 0;
     return cloned;
 }
 function tryCloneStateSync(state, scope, inheritLocals = true) {
@@ -2924,7 +2974,7 @@ export function warmDefaultRuntimeContextFs(sourceFs, backingFs) {
     void created.rm;
     reusableDefaultContextFsBySourceFs.set(sourceFs, { scoped: created, inUseBy: undefined });
 }
-import { abortManagedController, addAbortSignalWaiter, combineManagedSignals, createManagedControlController, getRuntimeBackingFileSystem, interruptible, isSyncResolved, registerRuntimeBackingFileSystem, removeAbortSignalWaiter, toNativeAbortSignal } from "../../safe-bash-contracts/runtime-control.js";
+import { abortManagedController, addAbortSignalWaiter, combineManagedSignals, releaseCombinedSignal, createManagedControlController, getRuntimeBackingFileSystem, interruptible, isSyncResolved, registerRuntimeBackingFileSystem, removeAbortSignalWaiter, toNativeAbortSignal } from "../../safe-bash-contracts/runtime-control.js";
 export { getRuntimeBackingFileSystem, interruptible, registerRuntimeBackingFileSystem };
 const emptyWords = [];
 const emptyShellValues = [];
@@ -2969,7 +3019,6 @@ function hasGlobOrEscape(text, extglob = false) {
     }
     return false;
 }
-let nextProcessSubstitutionId = 0;
 const fastSubScratchArgs = [];
 const defaultValueScopeReserve = ValueScope.prototype.reserve;
 const defaultStringCodePointAt = String.prototype.codePointAt;
@@ -3217,14 +3266,12 @@ class PooledSyncPipeWriter {
     signal;
     target = EMPTY_BYTES;
     used = 0;
-    overflowed = false;
     lineCountOnly = -1;
     reset(budget, signal, target, lineCountOnly = -1) {
         this.budget = budget;
         this.signal = signal;
         this.target = target;
         this.used = 0;
-        this.overflowed = false;
         this.lineCountOnly = lineCountOnly;
     }
     writeLineCountSync(count, totalBytes) {
@@ -3233,16 +3280,22 @@ class PooledSyncPipeWriter {
             const budget = this.budget;
             if (budget.bytes + totalBytes > budget.maxOutputBytesSmi && totalBytes > budget.limits.maxOutputBytes - budget.bytes)
                 budget.fail("maxOutputBytes");
-            if (this.used + totalBytes > this.target.byteLength) {
-                this.overflowed = true;
-                return false;
-            }
             this.used += totalBytes;
             budget.bytes += totalBytes;
         }
         this.lineCountOnly = count;
         return true;
     }
+    reserve(length) {
+        const required = this.used + length;
+        if (required <= this.target.byteLength)
+            return;
+        // Output admission precedes allocation; intermediate stages may exceed 64 KiB.
+        const capacity = Math.min(this.budget.limits.maxOutputBytes, Math.max(required, this.target.byteLength * 2));
+        const target = new Uint8Array(capacity);
+        target.set(this.target.subarray(0, this.used));
+        this.target = target;
+    }
     writeSync(chunk) {
         this.signal.throwIfAborted();
         const len = chunk.byteLength;
@@ -3251,11 +3304,12 @@ class PooledSyncPipeWriter {
         const budget = this.budget;
         if (budget.bytes + len > budget.maxOutputBytesSmi && len > budget.limits.maxOutputBytes - budget.bytes)
             budget.fail("maxOutputBytes");
-        if (this.used + len > this.target.byteLength) {
-            this.overflowed = true;
-            return false;
-        }
+        this.reserve(len);
         this.target.set(chunk, this.used);
+        if (this.lineCountOnly >= 0)
+            for (const byte of chunk)
+                if (byte === 10)
+                    this.lineCountOnly++;
         this.used += len;
         budget.bytes += len;
         return true;
@@ -3267,23 +3321,23 @@ class PooledSyncPipeWriter {
         const budget = this.budget;
         if (budget.bytes + len > budget.maxOutputBytesSmi && len > budget.limits.maxOutputBytes - budget.bytes)
             budget.fail("maxOutputBytes");
-        if (this.used + len > this.target.byteLength) {
-            this.overflowed = true;
-            return false;
-        }
+        this.reserve(len);
         const dst = this.target;
         const base = this.used;
-        for (let i = 0; i < len; i++)
-            dst[base + i] = src[i];
+        for (let i = 0; i < len; i++) {
+            const byte = src[i];
+            dst[base + i] = byte;
+            if (this.lineCountOnly >= 0 && byte === 10)
+                this.lineCountOnly++;
+        }
         this.used = base + len;
         budget.bytes += len;
         return true;
     }
     write(chunk) {
         try {
-            if (this.writeSync(chunk))
-                return resolvedVoid;
-            return Promise.reject(new Error("Sync pipe stage buffer overflow"));
+            this.writeSync(chunk);
+            return resolvedVoid;
         }
         catch (err) {
             return Promise.reject(err);
@@ -3702,6 +3756,19 @@ function getOrParseSingleEvalUnit(source, unitLocale, parseBudget) {
 }
 export class Runtime {
     reuseDefaultContextFs;
+    persistentIO(state, io) {
+        const frame = execDescriptorFrames.get(stateMonitor(state)?.raw ?? state);
+        if (!frame || io.execFrame === frame && io.execVersion === frame.version)
+            return io;
+        const changed = new Map([...frame.descriptors].filter(([number]) => io.execFrame !== frame || (frame.revisions.get(number) ?? 0) > (io.execVersion ?? 0)));
+        const descriptors = new Map(io.descriptors ?? [[0, { input: io.stdin }], [1, { output: io.stdout }], [2, { output: io.stderr }]]);
+        for (const [number, descriptor] of changed)
+            descriptors.set(number, descriptor);
+        return { ...io, descriptors, execFrame: frame, execVersion: frame.version,
+            ...(changed.has(0) ? { stdin: descriptors.get(0)?.closed ? closedSource : descriptors.get(0)?.input ?? closedSource, stdinIsDefault: false } : {}),
+            ...(changed.has(1) ? { stdout: descriptors.get(1)?.closed ? closedSink : descriptors.get(1)?.output ?? closedSink } : {}),
+            ...(changed.has(2) ? { stderr: descriptors.get(2)?.closed ? closedSink : descriptors.get(2)?.output ?? closedSink } : {}) };
+    }
     static clearStaticPools() { clearRuntimePools(); }
     _syncReturnDepth = 0;
     _syncPendingReturnStatus;
@@ -3748,8 +3815,6 @@ export class Runtime {
             const method = Object.getOwnPropertyDescriptor(MemoryFileSystem.prototype, name)?.value;
             return typeof method !== "function" || Reflect.get(this.backingFs, name) === method;
         });
-        if (this._isMemoryBackingFs)
-            this.backingFs._activeRuntimeBudget = budget;
         registerInternalYieldCheckpoint(signal, budget.yieldCheckpoint);
         if (commandSignal !== signal) {
             inheritYieldCheckpoint(signal, commandSignal);
@@ -3771,6 +3836,7 @@ export class Runtime {
             const reusableEntry = reusableDefaultContextFsBySourceFs.get(this.sourceFs);
             if (reusableEntry && reusableEntry.inUseBy === this) {
                 retargetScopedFileSystem(reusableEntry.scoped, noopFsCharge, NEVER_ABORTED_SIGNAL, noopFsCharge, 256);
+                registerRuntimeBackingFileSystem(reusableEntry.scoped, this.backingFs);
                 reusableEntry.inUseBy = undefined;
             }
         }
@@ -3789,7 +3855,7 @@ export class Runtime {
         if (!this._fs) {
             this._fs = scopeFileSystem(this._rawFs, this.budget.chargeFs, this.signal, this.budget.cleanupChargeFs, { maxPathComponents: this.budget.limits.maxPathnameComponents });
             runtimeFileSystems.set(this._fs, this.sourceFs);
-            registerRuntimeBackingFileSystem(this._fs, this.backingFs);
+            registerRuntimeBackingFileSystem(this._fs, this.backingFs, this.budget.chargeFs);
         }
         return this._fs;
     }
@@ -3801,7 +3867,8 @@ export class Runtime {
         if (this.reuseDefaultContextFs && sig === this.signal && umask === 0o022 && !this._contextFs && this._isMemoryBackingFs) {
             const entry = reusableDefaultContextFsBySourceFs.get(this.sourceFs);
             if (entry && (entry.inUseBy === undefined || entry.inUseBy === this)) {
-                if (retargetScopedFileSystem(entry.scoped, this.budget.chargeFs, sig, this.budget.cleanupChargeFs, this.budget.limits.maxPathnameComponents)) {
+                if (retargetScopedFileSystem(entry.scoped, this.budget.chargeFs, toNativeAbortSignal(sig), this.budget.cleanupChargeFs, this.budget.limits.maxPathnameComponents)) {
+                    registerRuntimeBackingFileSystem(entry.scoped, this.backingFs, this.budget.chargeFs);
                     entry.inUseBy = this;
                     this._contextFsMask = umask;
                     this._contextFsSignal = sig;
@@ -3810,9 +3877,9 @@ export class Runtime {
                 }
             }
         }
-        const created = scopeFileSystem(creationFileSystem(this.sourceFs, umask), this.budget.chargeFs, sig, this.budget.cleanupChargeFs, { maxPathComponents: this.budget.limits.maxPathnameComponents });
+        const created = scopeFileSystem(creationFileSystem(this.sourceFs, umask), this.budget.chargeFs, toNativeAbortSignal(sig), this.budget.cleanupChargeFs, { maxPathComponents: this.budget.limits.maxPathnameComponents });
         runtimeFileSystems.set(created, this.sourceFs);
-        registerRuntimeBackingFileSystem(created, this.backingFs);
+        registerRuntimeBackingFileSystem(created, this.backingFs, this.budget.chargeFs);
         this._contextFsMask = umask;
         this._contextFsSignal = sig;
         this._contextFs = created;
@@ -5038,6 +5105,10 @@ export class Runtime {
     }
     variable(state, name) {
         name = this.referenceName(state, name);
+        if (name === "$" || name === "BASHPID")
+            return "1";
+        if (name === "!")
+            return "";
         if (name === "RANDOM" || name === "SECONDS")
             return readDynamicVariable(stateMonitor(state)?.raw ?? state, name) ?? state.variables[name];
         const binding = arrayStore(state)?.get(name);
@@ -6384,8 +6455,14 @@ export class Runtime {
             // publication snapshot, and choose the append cursor from the new maximum.
             const expandedEntries = [];
             let elementFields;
+            let attributedElement;
             if (assignment.kind === "element") {
                 elementFields = await this.valueWord(assignment.value, state, io, false, false, false, false, undefined, false, false, 0);
+                if (selectedIndex !== undefined && state.variableAttributes?.get(name)?.includes("i")) {
+                    const previous = assignment.append ? store.get(name)?.getValue(selectedIndex)
+                        ?? (selectedIndex === 0 ? state.variables[name] : undefined) ?? "" : undefined;
+                    attributedElement = await this.attributeValue(state, name, concatShellValues(elementFields, io[valueScope]), io, "assignment", previous);
+                }
             }
             else
                 for (const entry of assignment.entries) {
@@ -6409,6 +6486,32 @@ export class Runtime {
                 }
             current = store.get(name);
             initialMaximum = current?.maximum ?? (state.variables[name] === undefined ? -1 : 0);
+            // Arithmetic attributes and computed indices observe each preceding write.
+            // Expand words against the original binding first, then use ordinary element
+            // assignment publication so arithmetic reads the current array, not a draft.
+            if (assignment.kind === "compound" && expandedEntries.length > 0
+                && (state.variableAttributes?.get(name)?.includes("i")
+                    || !isAssociative && expandedEntries.some(({ entry }) => entry.index && numericIndex(entry.index) === undefined))) {
+                let cursor = assignment.append ? initialMaximum + 1 : 0;
+                if (!assignment.append)
+                    await this.arrayAssignment({ ...assignment, entries: [] }, state, io, undefined, origin, associative, true);
+                for (const { entry, fields } of expandedEntries) {
+                    const values = entry.index ? [concatShellValues(fields, io[valueScope])] : fields;
+                    for (const value of values) {
+                        const index = entry.index && !isAssociative
+                            ? (await this.arrayIndex(store.get(name), entry.index, state, io, operation, true)) : cursor;
+                        const part = { kind: "text", value: shellValueText(value), quoted: true };
+                        if (typeof value !== "string")
+                            invokedValues.set(part, value);
+                        await this.arrayAssignment({ kind: "element", name, append: entry.append ?? false,
+                            index: isAssociative ? entry.index : { decimal: String(index) }, value: { offset: entry.value.offset, parts: [part] } }, state, io, undefined, origin, associative, true);
+                        cursor = index + 1;
+                    }
+                }
+                if (declaration)
+                    await this.arrayAssignment({ ...assignment, append: true, entries: [] }, state, io, declaration, origin, associative, true);
+                return;
+            }
             this.assertArrayWritable(state, name, origin);
             const watch = await store.watch(name, operation, this.signal);
             const supersede = await stateMonitor(state).prepareTypedPublication(name, operation, this.signal);
@@ -6446,7 +6549,9 @@ export class Runtime {
                     const previous = append ? targetBinding.getValue(index) ?? "" : undefined;
                     if (append && !state.variableAttributes?.get(name)?.includes("i"))
                         value = await join([previous, value]);
-                    if (state.variableAttributes?.get(name))
+                    if (attributedElement !== undefined)
+                        value = attributedElement;
+                    else if (state.variableAttributes?.get(name))
                         value = await this.attributeValue(state, name, value, io, "assignment", previous);
                     else if (shellValueByteLength(value) > this.budget.limits.maxExpansionBytes)
                         this.budget.fail("maxExpansionBytes");
@@ -6613,7 +6718,12 @@ export class Runtime {
         }
     }
     async run(script, state, io) {
-        return this.finishShell(state, io, (await this.runUnit(script, state, io)).exitCode);
+        try {
+            return await this.finishShell(state, io, (await this.runUnit(script, state, io)).exitCode);
+        }
+        finally {
+            await closeExecDescriptors(state);
+        }
     }
     extensionContext(state, io, command = "", args = [], argumentValues = args) {
         const frame = state.extensions;
@@ -7707,7 +7817,7 @@ export class Runtime {
                         throw error;
                     throw error.reason;
                 }
-                if (error instanceof Flow && error.kind === "exit") {
+                if (error instanceof Flow && (error.kind === "exit" || error.kind === "return" || error.kind === "break" || error.kind === "continue")) {
                     if (this.tryFinishShellSync(state))
                         return { exitCode: error.status, terminated: true };
                     return this.finishShell(monitor.proxy, io, error.status).then(exitCode => ({ exitCode, terminated: true }));
@@ -7735,7 +7845,7 @@ export class Runtime {
                     throw error;
                 throw error.reason;
             }
-            if (error instanceof Flow && error.kind === "exit")
+            if (error instanceof Flow && (error.kind === "exit" || error.kind === "return" || error.kind === "break" || error.kind === "continue"))
                 return { exitCode: await this.finishShell(state, io, error.status), terminated: true };
             throw error;
         }
@@ -7752,7 +7862,7 @@ export class Runtime {
                     throw error;
                 throw error.reason;
             }
-            if (error instanceof Flow && error.kind === "exit")
+            if (error instanceof Flow && (error.kind === "exit" || error.kind === "return" || error.kind === "break" || error.kind === "continue"))
                 return { exitCode: await this.finishShell(state, io, error.status), terminated: true };
             throw error;
         }
@@ -7843,8 +7953,11 @@ export class Runtime {
                     try {
                         for (let i = 1; i < command.words.length; i++) {
                             const w = command.words[i];
-                            if (w.plain === undefined && !(w.parts.length === 1 && w.parts[0].kind === "text" && w.parts[0].quoted === true && !w.parts[0].byteValue))
+                            if (w.plain !== undefined
+                                ? w.plain.includes("{") || w.plain.startsWith("~") || hasGlobOrEscape(w.plain, true)
+                                : !(w.parts.length === 1 && w.parts[0].kind === "text" && w.parts[0].quoted === true && !w.parts[0].byteValue)) {
                                 allPlain = false;
+                            }
                             const v = this.fastValueWord(w, rawState, io, true, false, false, true, undefined, diagnosticLine);
                             if (typeof v !== "string")
                                 return undefined;
@@ -7856,6 +7969,7 @@ export class Runtime {
                         return undefined;
                     }
                     if (allPlain) {
+                        Object.freeze(args);
                         command._cachedConstArgs = args;
                         if (command.redirects.length === 0 || (command.redirects[0].target.plain !== undefined && (command.redirects[0].operator === ">" || command.redirects[0].operator === ">>"))) {
                             command._cachedFastSingle = {
@@ -7928,7 +8042,7 @@ export class Runtime {
                 }
             }
             else {
-                context = new FastShellCommandContext(this, rawState, io, scope, w0Plain, args, undefined, undefined, this._isMemoryBackingFs);
+                context = new FastShellCommandContext(this, rawState, io, scope, w0Plain, args, undefined, undefined, this._isMemoryBackingFs, externalDef);
                 if (redirectSink)
                     context.stdout = redirectSink;
             }
@@ -7948,7 +8062,7 @@ export class Runtime {
                 if (cmd.kind !== "simple" || !this.isPureExternalStageCommand(cmd, rawState) || cmd.words.length > this.budget.maxExpansionFieldsSmi)
                     return undefined;
             }
-            return this.executeFastPurePipelineUnit(pipeline, state, rawState, monitor, io, ignored || pipeline.negate);
+            return this.tryExecuteSyncPurePipelineUnit(pipeline, state, rawState, monitor, io, ignored || pipeline.negate);
         }
         return undefined;
     }
@@ -7999,18 +8113,20 @@ export class Runtime {
             }
         }
         catch (error) {
-            return this.finishFastSingleExternalUnitAsync(undefined, error, true, redirectSink, diagnosticLine, negate, ignored, monitor, rawState, existing, elem0, store, state, io, scope, restEpoch);
+            return this.finishFastSingleExternalUnitAsync(context, undefined, error, true, redirectSink, diagnosticLine, negate, ignored, monitor, rawState, existing, elem0, store, state, io, scope, restEpoch);
         }
-        return this.finishFastSingleExternalUnitAsync(raw, undefined, false, redirectSink, diagnosticLine, negate, ignored, monitor, rawState, existing, elem0, store, state, io, scope, restEpoch);
+        return this.finishFastSingleExternalUnitAsync(context, raw, undefined, false, redirectSink, diagnosticLine, negate, ignored, monitor, rawState, existing, elem0, store, state, io, scope, restEpoch);
     }
-    async finishFastSingleExternalUnitAsync(raw, initialError, hasInitialError, redirectSink, diagnosticLine, negate, ignored, monitor, rawState, existing, elem0, store, state, io, scope, restEpoch) {
+    async finishFastSingleExternalUnitAsync(context, raw, initialError, hasInitialError, redirectSink, diagnosticLine, negate, ignored, monitor, rawState, existing, elem0, store, state, io, scope, restEpoch) {
         let rawStatus = 0;
+        let commandSettled = hasInitialError;
+        const pending = hasInitialError ? undefined : Promise.resolve(raw).then(result => { commandSettled = true; return result; }, error => { commandSettled = true; throw error; });
         try {
             if (hasInitialError)
                 throw initialError;
             const res = this.budget._hasExternalSignal
-                ? await interruptible(Promise.resolve(raw), this.signal)
-                : await raw;
+                ? await interruptible(pending, this.signal)
+                : await pending;
             this.signal.throwIfAborted();
             if (redirectSink?.failedError !== undefined)
                 throw redirectSink.failedError;
@@ -8038,6 +8154,12 @@ export class Runtime {
             this.budget.endPathLookupSuspension();
             scope.leaveWork();
             redirectSink?.handle.close();
+            if (commandSettled)
+                context.releaseDirectStage();
+            else {
+                // Cancellation may win before the command stops using its context.
+                void pending.then(() => context.releaseDirectStage(), () => context.releaseDirectStage());
+            }
         }
         if (!existing) {
             monitor.lazyPipeStatus = rawStatus === 0 ? singleStatusZero : rawStatus === 1 ? singleStatusOne : [rawStatus];
@@ -8061,9 +8183,6 @@ export class Runtime {
         }
         return finalStatus === 0 ? SYNC_UNIT_ZERO : finalStatus === 1 ? SYNC_UNIT_ONE : { exitCode: finalStatus, terminated: false };
     }
-    executeFastPurePipelineUnit(pipeline, state, rawState, monitor, io, ignored) {
-        return this.tryExecuteSyncPurePipelineUnit(pipeline, state, rawState, monitor, io, ignored);
-    }
     tryExecuteSyncPurePipelineUnit(pipeline, state, rawState, monitor, io, ignored) {
         const backing = this.backingFs;
         if (syncPurePipelineSlotInUse || !this._isMemoryBackingFs || !backing || backing.capabilitiesFor !== undefined || this.middleware.length > 0 || customRegisteredRegistries.has(this.commands) || !io.stdinIsDefault || this.signal.aborted || hasYieldCheckpoint(this.signal) || !this.budget.canSyncPurePipe || !(io.stdout instanceof Capture && io.stdout._scratch4k !== undefined && io.stdout.length === 0 && io.stdout.write === Capture.prototype.write) || !(io.stderr instanceof Capture && io.stderr.length === 0 && io.stderr.write === Capture.prototype.write)) {
@@ -8182,7 +8301,7 @@ export class Runtime {
                     stageStdout = sharedSyncPipeWriter;
                 }
                 if (!context) {
-                    context = new FastShellCommandContext(this, rawState, io, scope, firstName, stageArgs, undefined, undefined, true);
+                    context = new FastShellCommandContext(this, rawState, io, scope, firstName, stageArgs, undefined, undefined, true, extDef);
                     pooledSyncPipeContext = context;
                 }
                 context.resetDirectStage(this, rawState, io, scope, firstName, stageArgs, inputSource, isFirst, stageStdout, this.signal);
@@ -8209,7 +8328,7 @@ export class Runtime {
                             statuses ??= new Array(n).fill(0);
                             statuses[index] = status;
                         }
-                    }).finally(() => scope.leaveWork()).then(() => runStages(index + 1, nextBuf, sharedSyncPipeWriter.used));
+                    }).finally(() => scope.leaveWork()).then(() => runStages(index + 1, sharedSyncPipeWriter.target, sharedSyncPipeWriter.used));
                 }
                 scope.leaveWork();
                 this.signal.throwIfAborted();
@@ -8217,7 +8336,7 @@ export class Runtime {
                     statuses ??= new Array(n).fill(0);
                     statuses[index] = 1;
                 }
-                prevBuf = nextBuf;
+                prevBuf = sharedSyncPipeWriter.target;
                 prevLen = sharedSyncPipeWriter.used;
             }
         };
@@ -8228,6 +8347,7 @@ export class Runtime {
             sharedSyncPipeWriter.signal = undefined;
             sharedSyncPipeWriter.target = EMPTY_BYTES;
             sharedSyncPipeReader.reset(EMPTY_BYTES, 0);
+            sharedSyncPipeReader.clearViews();
             syncPurePipelineSlotInUse = false;
             this.budget.leavePipelineStages(n);
         };
@@ -8260,270 +8380,6 @@ export class Runtime {
         release();
         return finish();
     }
-    executeFastPurePipelineUnitSlow(pipeline, state, rawState, monitor, io, ignored) {
-        const n = pipeline.commands.length;
-        this.budget.enterPipelineStages(n);
-        this.budget.commands += n;
-        const pipeOptions = { highWaterMark: this.budget.limits.pipeHighWaterMark, signal: this.signal };
-        const pipes = new Array(n - 1);
-        for (let i = 0; i < n - 1; i++) {
-            pipes[i] = createBytePipe(pipeOptions);
-        }
-        const controllers = new Array(n);
-        for (let i = 0; i < n; i++) {
-            controllers[i] = createManagedControlController();
-        }
-        const onParentAbort = (reason) => {
-            for (let i = 0; i < n; i++)
-                abortManagedController(controllers[i], reason);
-        };
-        addAbortSignalWaiter(this.signal, onParentAbort);
-        const scope = io[invocationScope];
-        const onScopeSeal = () => {
-            const closedReason = new Error("Invocation is closed");
-            for (let i = 0; i < n; i++)
-                abortManagedController(controllers[i], closedReason);
-            for (let i = 0; i < n - 1; i++)
-                void pipes[i].abort(closedReason);
-        };
-        scope.addSealCallback(onScopeSeal);
-        const statuses = new Array(n);
-        let asyncTasks;
-        try {
-            for (let index = 0; index < n; index++) {
-                const cmd = pipeline.commands[index];
-                const firstName = cmd.words[0].plain;
-                const extDef = this.commands.get(firstName);
-                let stageArgs = cmd._cachedPlainArgs;
-                if (!stageArgs) {
-                    stageArgs = new Array(cmd.words.length - 1);
-                    for (let w = 1; w < cmd.words.length; w++) {
-                        const word = cmd.words[w];
-                        stageArgs[w - 1] = word.plain ?? word.parts.map(p => p.value).join("");
-                    }
-                    cmd._cachedPlainArgs = stageArgs;
-                }
-                const incoming = index > 0 ? pipes[index - 1] : undefined;
-                const outgoing = index < n - 1 ? pipes[index] : undefined;
-                const reading = incoming?.endpoints?.read;
-                const writing = outgoing?.endpoints?.write;
-                const stageSignal = controllers[index].signal;
-                let input;
-                if (incoming) {
-                    reading.abortSignal = stageSignal;
-                    input = reading;
-                }
-                else if (io.stdinIsDefault)
-                    input = io.stdin;
-                else
-                    input = new ShellInput(io.stdin, this.budget, stageSignal, undefined, true);
-                const writable = writing?.writable ?? outgoing?.writable;
-                const stageStdout = outgoing
-                    ? new BudgetedPipeStageSink(this.budget, writable, stageSignal, undefined, index, controllers[index])
-                    : signalSink(io.stdout, stageSignal);
-                const context = new FastShellCommandContext(this, rawState, io, scope, firstName, stageArgs, undefined, undefined, true);
-                context.stdin = input;
-                if (incoming)
-                    context.stdinIsDefault = false;
-                context.stdout = stageStdout;
-                context.signal = this._isMemoryBackingFs ? stageSignal : toNativeAbortSignal(stageSignal);
-                context._scopedSignal = stageSignal;
-                if (asyncTasks === undefined) {
-                    scope.enterWork();
-                    this.budget.beginPathLookupSuspension();
-                    let syncExitCode = -1;
-                    let pendingRes;
-                    let syncErr;
-                    let hasSyncErr = false;
-                    try {
-                        const resPromise = extDef.execute(context);
-                        if (resPromise === RESOLVED_EXIT_ZERO) {
-                            stageSignal.throwIfAborted();
-                            syncExitCode = 0;
-                        }
-                        else if (resPromise === RESOLVED_EXIT_ONE) {
-                            stageSignal.throwIfAborted();
-                            syncExitCode = 1;
-                        }
-                        else
-                            pendingRes = Promise.resolve(resPromise);
-                    }
-                    catch (error) {
-                        hasSyncErr = true;
-                        syncErr = error;
-                    }
-                    if (syncExitCode >= 0) {
-                        this.budget.endPathLookupSuspension();
-                        scope.leaveWork();
-                        let asyncCleanup;
-                        if (!incoming && input !== io.stdin) {
-                            const closedInput = input.close();
-                            if (!isSyncResolved(closedInput))
-                                asyncCleanup = closedInput;
-                        }
-                        if (!asyncCleanup && reading) {
-                            const closedRead = reading.close();
-                            if (!isSyncResolved(closedRead))
-                                asyncCleanup = closedRead;
-                        }
-                        if (!asyncCleanup && writing) {
-                            const closedWrite = writing.close();
-                            if (!isSyncResolved(closedWrite))
-                                asyncCleanup = closedWrite;
-                        }
-                        if (!asyncCleanup && outgoing && !writing) {
-                            const closedOut = outgoing.close();
-                            if (!isSyncResolved(closedOut))
-                                asyncCleanup = closedOut;
-                        }
-                        if (!asyncCleanup) {
-                            statuses[index] = syncExitCode;
-                            continue;
-                        }
-                        asyncTasks = new Array(n);
-                        for (let prev = 0; prev < index; prev++)
-                            asyncTasks[prev] = Promise.resolve(statuses[prev]);
-                        asyncTasks[index] = asyncCleanup.then(() => syncExitCode);
-                        continue;
-                    }
-                    asyncTasks = new Array(n);
-                    for (let prev = 0; prev < index; prev++)
-                        asyncTasks[prev] = Promise.resolve(statuses[prev]);
-                    asyncTasks[index] = this.finishFastPurePipelineStageAsync(cmd, context, incoming, outgoing, reading, writing, input, stageSignal, scope, io, pendingRes, hasSyncErr, syncErr);
-                    continue;
-                }
-                scope.enterWork();
-                this.budget.beginPathLookupSuspension();
-                asyncTasks[index] = this.finishFastPurePipelineStageAsync(cmd, context, incoming, outgoing, reading, writing, input, stageSignal, scope, io, undefined, false, undefined, extDef);
-            }
-            if (asyncTasks !== undefined) {
-                return this.finishFastPurePipelineUnitAsync(asyncTasks, n, pipes, controllers, onParentAbort, onScopeSeal, scope, monitor, rawState, pipeline, state, io, ignored);
-            }
-        }
-        catch (syncFatal) {
-            scope.removeSealCallback(onScopeSeal);
-            removeAbortSignalWaiter(this.signal, onParentAbort);
-            for (let i = 0; i < n; i++)
-                abortManagedController(controllers[i], SHARED_PIPELINE_CLOSED);
-            for (let i = 0; i < n - 1; i++)
-                void pipes[i].abort();
-            this.budget.leavePipelineStages(n);
-            throw syncFatal;
-        }
-        scope.removeSealCallback(onScopeSeal);
-        removeAbortSignalWaiter(this.signal, onParentAbort);
-        for (let i = 0; i < n; i++) {
-            abortManagedController(controllers[i], SHARED_PIPELINE_CLOSED);
-        }
-        for (let i = 0; i < n - 1; i++) {
-            void pipes[i].abort();
-        }
-        this.budget.leavePipelineStages(n);
-        const restEpoch = monitor.chargeInternal(syncRestorationCharge, syncRestorationTickets).epoch;
-        monitor.lazyPipeStatus = statuses;
-        monitor.chargeInternal(syncPipeStatusCharge, syncPipeStatusTickets);
-        const rawStatus = rawState.pipefail ? statuses.findLast(s => s !== 0) ?? 0 : statuses[n - 1];
-        const finalStatus = pipeline.negate ? Number(rawStatus === 0) : rawStatus;
-        rawState.status = finalStatus;
-        monitor.epoch = restEpoch;
-        if (rawStatus !== 0 && !pipeline.negate && !ignored && rawState.errexit) {
-            if (this.tryFinishShellSync(state))
-                return { exitCode: finalStatus, terminated: true };
-            return this.finishShell(state, io, finalStatus).then(exitCode => ({ exitCode, terminated: true }));
-        }
-        return finalStatus === 0 ? SYNC_UNIT_ZERO : finalStatus === 1 ? SYNC_UNIT_ONE : { exitCode: finalStatus, terminated: false };
-    }
-    async finishFastPurePipelineStageAsync(cmd, context, incoming, outgoing, reading, writing, input, stageSignal, scope, io, pendingRes, hasSyncErr, syncErr, extDef) {
-        let exitCode = 0;
-        try {
-            if (hasSyncErr)
-                throw syncErr;
-            const res = await (pendingRes ?? extDef.execute(context));
-            stageSignal.throwIfAborted();
-            exitCode = validateExitCode(res.exitCode);
-        }
-        catch (error) {
-            if (error instanceof PipelineClosed || (stageSignal.aborted && Object.is(stageSignal.reason, SHARED_PIPELINE_CLOSED)))
-                exitCode = 141;
-            else if (errorCode(error) === "EPIPE" && !this.signal.aborted)
-                exitCode = 141;
-            else {
-                this.signal.throwIfAborted();
-                if (error instanceof Flow || error instanceof ShellLimitError || error instanceof ShellSyntaxError)
-                    throw error;
-                const line = io.diagnosticCommandLines?.get(cmd) ?? (cmd.line ?? 1) + (io.diagnosticOffset ?? 0);
-                try {
-                    await writeDiagnostic(context.stderr, `${io.scriptName ?? "shell"}: line ${line}: ${message(error, this.budget.onInternalError)}\n`);
-                }
-                catch (failure) {
-                    this.signal.throwIfAborted();
-                    publicDiagnosticMessage(failure, this.budget.onInternalError);
-                }
-                exitCode = error instanceof CommandFailure ? error.status : 1;
-            }
-        }
-        finally {
-            this.budget.endPathLookupSuspension();
-            scope.leaveWork();
-            if (!incoming && input !== io.stdin) {
-                const closedInput = input.close();
-                if (!isSyncResolved(closedInput)) {
-                    await closedInput.catch((error) => { if (!(error instanceof PipelineClosed))
-                        throw error; });
-                }
-            }
-            if (reading) {
-                const closedRead = reading.close();
-                if (!isSyncResolved(closedRead))
-                    await closedRead;
-            }
-            if (writing) {
-                const closedWrite = writing.close();
-                if (!isSyncResolved(closedWrite))
-                    await closedWrite;
-            }
-            if (outgoing && !writing) {
-                const closedOut = outgoing.close();
-                if (!isSyncResolved(closedOut))
-                    await closedOut.catch(() => undefined);
-            }
-        }
-        return exitCode;
-    }
-    async finishFastPurePipelineUnitAsync(tasks, n, pipes, controllers, onParentAbort, onScopeSeal, scope, monitor, rawState, pipeline, state, io, ignored) {
-        let statuses;
-        try {
-            statuses = this.budget._hasExternalSignal
-                ? await interruptible(Promise.all(tasks), this.signal)
-                : await Promise.all(tasks);
-        }
-        finally {
-            scope.removeSealCallback(onScopeSeal);
-            removeAbortSignalWaiter(this.signal, onParentAbort);
-            for (let i = 0; i < n; i++) {
-                abortManagedController(controllers[i], SHARED_PIPELINE_CLOSED);
-            }
-            for (let i = 0; i < n - 1; i++) {
-                const ab = pipes[i].abort();
-                if (!isSyncResolved(ab))
-                    await ab;
-            }
-            this.budget.leavePipelineStages(n);
-        }
-        const restEpoch = monitor.chargeInternal(syncRestorationCharge, syncRestorationTickets).epoch;
-        monitor.lazyPipeStatus = statuses;
-        monitor.chargeInternal(syncPipeStatusCharge, syncPipeStatusTickets);
-        const rawStatus = rawState.pipefail ? statuses.findLast(s => s !== 0) ?? 0 : statuses[n - 1];
-        const finalStatus = pipeline.negate ? Number(rawStatus === 0) : rawStatus;
-        rawState.status = finalStatus;
-        monitor.epoch = restEpoch;
-        if (rawStatus !== 0 && !pipeline.negate && !ignored && rawState.errexit) {
-            if (this.tryFinishShellSync(state))
-                return { exitCode: finalStatus, terminated: true };
-            return { exitCode: await this.finishShell(state, io, finalStatus), terminated: true };
-        }
-        return finalStatus === 0 ? SYNC_UNIT_ZERO : finalStatus === 1 ? SYNC_UNIT_ONE : { exitCode: finalStatus, terminated: false };
-    }
     async inputUnit(script, state, io, startListIndex = 0, startPipelineIndex = 0, skipFirstSync = false) {
         try {
             return await this.script(script, state, io, startListIndex, startPipelineIndex, skipFirstSync);
@@ -8538,6 +8394,7 @@ export class Runtime {
         }
     }
     trySyncPipeline(pipeline, state, io, ignored) {
+        io = this.persistentIO(state, io);
         const _rawSt = (stateMonitor(state)?.raw ?? state);
         if ((_rawSt._syncPendingFunctionResumes?.length ?? 0) > 0 || _rawSt._syncPendingEvalResume !== undefined)
             return undefined;
@@ -8797,7 +8654,7 @@ export class Runtime {
                             const uArg = wu.plain ?? (wu.parts.length === 1 && wu.parts[0].kind === "text" ? wu.parts[0].value : undefined);
                             if (uArg !== undefined) {
                                 const br = uArg.indexOf("[");
-                                if (br > 0 && uArg.endsWith("]") && (wu.parts[0]?.quoted || rawState.noglob || (!rawState.nullglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0))) {
+                                if (br > 0 && uArg.endsWith("]") && (wu.parts[0]?.quoted || rawState.noglob || (!rawState.nullglob && !rawState.failglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0))) {
                                     const arrName = uArg.slice(0, br);
                                     const subStr = uArg.slice(br + 1, -1);
                                     const b = isShellIdentifier(arrName) ? st?.get(arrName) : undefined;
@@ -9022,7 +8879,7 @@ export class Runtime {
                         let targetOk = false;
                         if (w2Plain !== undefined) {
                             const br = w2Plain.indexOf("[");
-                            if (br > 0 && w2Plain.endsWith("]") && (w2?.parts[0]?.quoted || rawState.noglob || (!rawState.nullglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0))) {
+                            if (br > 0 && w2Plain.endsWith("]") && (w2?.parts[0]?.quoted || rawState.noglob || (!rawState.nullglob && !rawState.failglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0))) {
                                 const arrName = w2Plain.slice(0, br);
                                 const subStr = w2Plain.slice(br + 1, -1);
                                 const b = isShellIdentifier(arrName) ? st?.get(arrName) : undefined;
@@ -10944,7 +10801,7 @@ export class Runtime {
             if (this.budget.limits.maxExpansionFields === Infinity && command.words.length >= 4 && w0Plain === "printf" && command.words[1]?.plain === "-v" && command.redirects.length === 0 && canMutatePipeStatus && (!pipeline.negate || ignored || !rawState.errexit) && !hasShellFunction(rawState, "printf") && !rawState.extensions?.builtins.has("printf")) {
                 const def = this.commands.get("printf");
                 if (def && def.execute === printfCommand.execute && command.words.length <= this.budget.maxExpansionFieldsSmi && (this.arePureArgWords(command.words, rawState) || command.words.every((w, idx) => idx < 4 ? this.isPureArgWord(w, rawState) : (this.isPureArgWord(w, rawState) || this.canSyncArrayMembersWord(w, rawState))))) {
-                    let targetSpec = command.words[2]?.plain !== undefined && (rawState.noglob || !hasGlobOrEscape(command.words[2].plain, !!rawState.extglob) || (!rawState.nullglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0)) ? command.words[2].plain : undefined;
+                    let targetSpec = command.words[2]?.plain !== undefined && (rawState.noglob || !hasGlobOrEscape(command.words[2].plain, !!rawState.extglob) || (!rawState.nullglob && !rawState.failglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0)) ? command.words[2].plain : undefined;
                     if (targetSpec === undefined) {
                         try {
                             targetSpec = this.fastValueWord(command.words[2], rawState, io, true, false, false, true, undefined, diagnosticLine);
@@ -12190,7 +12047,7 @@ export class Runtime {
                     const ops = [];
                     for (let ui = uStart; ui < command.words.length; ui++) {
                         const wu = command.words[ui];
-                        const canSkipGlobUnset = Boolean(wu.parts[0]?.quoted || rawState.noglob || (!rawState.nullglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0));
+                        const canSkipGlobUnset = Boolean(wu.parts[0]?.quoted || rawState.noglob || (!rawState.nullglob && !rawState.failglob && this._isMemoryBackingFs && tryGetMemoryDirectoryEntryNamesSync(this.backingFs, rawState.cwd)?.size === 0));
                         let tExpanded;
                         try {
                             const fv = this.fastValueWord(wu, rawState, io, !canSkipGlobUnset, false, false, true, undefined, diagnosticLine);
@@ -12987,6 +12844,7 @@ export class Runtime {
                 }
             }
             if (w0Plain === "eval" &&
+                !rawState.expand_aliases &&
                 canMutatePipeStatus &&
                 !pipeline.negate &&
                 !hasShellFunction(rawState, "eval") &&
@@ -13685,7 +13543,7 @@ export class Runtime {
         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 dynamicNames = new Set(["PIPESTATUS", "LINENO", "_", "FUNCNAME", "DIRSTACK", "BASH_SUBSHELL", "BASHPID"]);
         const assignments = [];
         const appends = new Map();
         for (const list of command.body.lists) {
@@ -13878,13 +13736,15 @@ export class Runtime {
             if (part.kind === "text") {
                 if (part.byteValue || invokedValues.has(part))
                     return false;
+                if (!part.quoted && (part.value.includes("~") || part.value.includes("{") || hasGlobOrEscape(part.value, true)))
+                    return false;
                 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 (part.name === "RANDOM" || part.name === "SECONDS" || stateMonitor(rawState)?.store?.get(part.name))
+                if (part.name === "RANDOM" || part.name === "SECONDS" || part.name === "BASHPID" || 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.
@@ -15948,8 +15808,8 @@ export class Runtime {
                                 rawState.status = 0;
                             }
                             runYieldCheckpoint(this.signal);
-                            for (let r = 0; r < regNames.length; r++) {
-                                rawState.variables[regNames[r]] = intToStr(sharedLoopIntRegs[r]);
+                            for (const name of touchedIntNamesList) {
+                                rawState.variables[name] = intToStr(sharedLoopIntRegs[regNames.indexOf(name)]);
                             }
                             regNames.length = 0;
                             if (hasDeferredSteps && lastInductionInt !== undefined)
@@ -17506,9 +17366,9 @@ export class Runtime {
         encoded = encoded.slice();
         if (step.targetDirPrefix !== undefined && step.targetNamePrefix !== undefined) {
             const fileName = this.evalSyncRedirectSuffix(step.targetWord, step.targetDirPrefix, step.targetNamePrefix, rawState, io);
-            if (tryWriteMemoryFileInDirSync(this.backingFs, step.targetDirPrefix, fileName, encoded, append, mode, this.commandSignal))
+            if (!fileName.includes("/") && fileName !== "." && fileName !== ".." && tryWriteMemoryFileInDirSync(this.backingFs, step.targetDirPrefix, fileName, encoded, append, mode, this.commandSignal))
                 return;
-            tryWriteMemoryFileSync(this.backingFs, step.targetDirPrefix + fileName, encoded, append, mode, this.commandSignal);
+            tryWriteMemoryFileSync(this.backingFs, normalizePath(step.targetDirPrefix + fileName, rawState.cwd), encoded, append, mode, this.commandSignal);
             return;
         }
         const targetVal = this.evalSyncRedirectWord(step.targetWord, rawState, io);
@@ -18144,6 +18004,7 @@ export class Runtime {
             }
             const firstIndex = listIndex === startListIndex ? startPipelineIndex : 0;
             for (let index = firstIndex; index < list.pipelines.length; index++) {
+                io = this.persistentIO(state, io);
                 if (state.noexec)
                     throw new Flow("discard", 0);
                 const operator = index > 0 ? list.operators[index - 1] : undefined;
@@ -18326,7 +18187,7 @@ export class Runtime {
                 }
                 for (let index = 1; index < pipeline.commands.length; index++)
                     pipes.push(createBytePipe({
-                        highWaterMark: this.budget.limits.pipeHighWaterMark, signal: this.signal,
+                        highWaterMark: this.budget.limits.pipeHighWaterMark, signal: this.signal, admitWrite: this.budget.pipelineInput,
                     }));
                 for (let index = 0; index < pipeline.commands.length; index++) {
                     controllers.push(createManagedControlController());
@@ -18362,6 +18223,7 @@ export class Runtime {
                     void installation.catch(() => undefined);
                 }
                 const tasks = pipeline.commands.map(async (command, index) => {
+                    const inCurrentShell = !!state.lastpipe && index === pipeline.commands.length - 1;
                     let admitted = false;
                     const admit = () => {
                         if (admitted)
@@ -18397,7 +18259,7 @@ export class Runtime {
                         let stageOwnsCleanup = false;
                         try {
                             const rawStateForChild = stateMonitor(state)?.raw ?? state;
-                            const isPureStage = !terminal && !(io.descriptors && (io.descriptors.size > 3 || io.descriptors.get(0)?.closed || io.descriptors.get(1)?.closed || io.descriptors.get(2)?.closed)) && runtime.isPureExternalStageCommand(command, rawStateForChild);
+                            const isPureStage = !inCurrentShell && !terminal && !(io.descriptors && (io.descriptors.size > 3 || io.descriptors.get(0)?.closed || io.descriptors.get(1)?.closed || io.descriptors.get(2)?.closed)) && runtime.isPureExternalStageCommand(command, rawStateForChild);
                             const references = isPureStage ? undefined : (cleanupRefs = new PipeDescriptorFrame(io[invocationScope]));
                             const descriptorFrame = isPureStage ? undefined : (cleanupDescFrame = new PreparedDescriptorFrame(references, this.budget));
                             const reading = incoming?.endpoints?.read;
@@ -18421,14 +18283,15 @@ export class Runtime {
                                     try {
                                         const isFastPure = isPureStage || runtime.isPureExternalStageCommand(command, rawStateForChild);
                                         const forkedExt = isFastPure ? forkExtensions(state.extensions, "pipeline") : undefined;
-                                        const child = isFastPure
+                                        const child = inCurrentShell ? state : isFastPure
                                             ? Object.assign(cloneRawState(rawStateForChild, false), {
                                                 extensions: forkedExt, isolated: true, _readOnlyStage: true,
                                             })
                                             : (tryCloneStateSync(state) ?? await cloneState(state, this.signal));
-                                        preparedChild = child;
-                                        child.variables.BASH_SUBSHELL = String(Number(state.variables.BASH_SUBSHELL ?? 0) + 1);
-                                        if (!child._readOnlyStage) {
+                                        preparedChild = inCurrentShell ? undefined : child;
+                                        if (!inCurrentShell)
+                                            child.variables.BASH_SUBSHELL = String(Number(state.variables.BASH_SUBSHELL ?? 0) + 1);
+                                        if (!inCurrentShell && !child._readOnlyStage) {
                                             child.extensions = undefined;
                                             child.extensions = forkExtensions(state.extensions, "pipeline");
                                             child.isolated = true;
@@ -18459,7 +18322,9 @@ export class Runtime {
                                             await installation;
                                             signal.throwIfAborted();
                                         }
-                                        const work = runtime.runPipelineStageWork(command, child, childIO, io, reason => { checkpointFailure = reason; });
+                                        const work = inCurrentShell
+                                            ? runtime.command(command, child, { ...childIO, terminal: undefined })
+                                            : runtime.runPipelineStageWork(command, child, childIO, io, reason => { checkpointFailure = reason; });
                                         preparedChild = undefined;
                                         started = true;
                                         retain(work);
@@ -18809,6 +18674,7 @@ export class Runtime {
         return status;
     }
     async executeCommand(command, state, originalIO, fileShortcut = false) {
+        originalIO = this.persistentIO(state, originalIO);
         const terminal = originalIO.terminal?.target === command ? originalIO.terminal : undefined;
         if (!state._readOnlyStage)
             state = trackState(state, this.budget, originalIO[invocationScope]);
@@ -19173,6 +19039,20 @@ export class Runtime {
         let diagnosticFailure;
         let outputTracker;
         const snapshotHolder = {};
+        const execState = stateMonitor(state)?.raw ?? state;
+        const savedExecDescriptors = new Map();
+        if (command.redirects.length) {
+            const frame = execDescriptorFrames.get(execState);
+            for (const redirect of command.redirects) {
+                for (const number of redirect.operator === "&>" || redirect.operator === "&>>" ? [1, 2] : [redirect.descriptor]) {
+                    if (savedExecDescriptors.has(number))
+                        continue;
+                    const descriptor = originalIO.descriptors?.get(number)
+                        ?? (number === 0 ? { input: originalIO.stdin } : number === 1 ? { output: originalIO.stdout } : number === 2 ? { output: originalIO.stderr } : { closed: true });
+                    savedExecDescriptors.set(number, { descriptor, revision: frame?.revisions.get(number), release: descriptor.lifetime?.acquire() });
+                }
+            }
+        }
         try {
             let status = 0;
             if (command.kind === "simple") {
@@ -19208,15 +19088,38 @@ export class Runtime {
         }
         finally {
             try {
-                if (!references && outputs.size === 0 && inputs.size === 0 && processSubstitutions.length === 0)
-                    allocation.close();
-                else
-                    await this.cleanupCommandResources(references, outputs, inputs, processSubstitutions, allocation, diagnosticFailure, io);
+                const frame = execDescriptorFrames.get(execState);
+                const retirements = [];
+                for (const [number, saved] of savedExecDescriptors) {
+                    if (frame && !snapshotHolder.persistentRedirects && frame.revisions.get(number) !== saved.revision) {
+                        const release = frame.releases.get(number);
+                        if (saved.release)
+                            frame.releases.set(number, saved.release);
+                        else
+                            frame.releases.delete(number);
+                        frame.descriptors.set(number, saved.descriptor);
+                        frame.revisions.set(number, ++frame.version);
+                        if (release)
+                            retirements.push(release());
+                    }
+                    else if (saved.release)
+                        retirements.push(saved.release());
+                }
+                const retired = await Promise.allSettled(retirements);
+                throwCleanupFailures(retired.filter(result => result.status === "rejected").map(result => result.reason));
             }
             finally {
-                snapshotHolder.finish?.();
-                if (snapshotHolder.scope)
-                    await snapshotHolder.scope.close();
+                try {
+                    if (!references && outputs.size === 0 && inputs.size === 0 && processSubstitutions.length === 0)
+                        allocation.close();
+                    else
+                        await this.cleanupCommandResources(references, outputs, inputs, processSubstitutions, allocation, diagnosticFailure, io);
+                }
+                finally {
+                    snapshotHolder.finish?.();
+                    if (snapshotHolder.scope)
+                        await snapshotHolder.scope.close();
+                }
             }
         }
     }
@@ -19446,8 +19349,7 @@ export class Runtime {
                                 }
                             if (!matched)
                                 continue;
-                            if (clause.body.lists.length)
-                                status = await this.script(clause.body, state, io);
+                            status = clause.body.lists.length ? await this.script(clause.body, state, io) : 0;
                             if (clause.terminator === ";;" || clause.terminator === "esac")
                                 break;
                             fallthrough = clause.terminator === ";&";
@@ -19473,8 +19375,7 @@ export class Runtime {
                             }
                         if (!matched)
                             continue;
-                        if (clause.body.lists.length)
-                            status = await this.script(clause.body, state, io);
+                        status = clause.body.lists.length ? await this.script(clause.body, state, io) : 0;
                         if (clause.terminator === ";;" || clause.terminator === "esac")
                             break;
                         fallthrough = clause.terminator === ";&";
@@ -19805,6 +19706,8 @@ export class Runtime {
                 publicDiagnosticMessage(failure, this.budget.onInternalError);
             }
         }
+        if (error instanceof FailglobFailure)
+            throw completedExit(1, state.errexit ? "exit" : "discard");
         if (error instanceof ExpansionFailure || error instanceof BraceExpansionFailure)
             throw completedExit(error instanceof ParameterExpansionFailure && !state.isolated ? 127 : 1);
         if (error instanceof FatalCommandFailure)
@@ -19923,6 +19826,8 @@ export class Runtime {
             const descriptor = descriptors.get(0)?.closed ? undefined : descriptors.get(0);
             const stdinIsDefault = descriptor?.input ? descriptor.stdinIsDefault : false;
             return {
+                ...(io.execVersion === undefined ? {} : { execVersion: io.execVersion }),
+                ...(io.execFrame === undefined ? {} : { execFrame: io.execFrame }),
                 capabilities: io.capabilities, ...(io.argv0 === undefined ? {} : { argv0: io.argv0 }), [invocationScope]: io[invocationScope], ...(io.admittedHandles === undefined ? {} : { admittedHandles: io.admittedHandles }), ...(io.processSignals === undefined ? {} : { processSignals: io.processSignals }), ...(io[valueScope] === undefined ? {} : { [valueScope]: io[valueScope] }), ...(io.execution === undefined ? {} : { execution: io.execution }), ...(io.diagnosticLine === undefined ? {} : { diagnosticLine: io.diagnosticLine }), ...(io.diagnosticOffset === undefined ? {} : { diagnosticOffset: io.diagnosticOffset }), ...(io.assignmentDiagnosticContext === undefined ? {} : { assignmentDiagnosticContext: io.assignmentDiagnosticContext }), ...(io.functionCommandLines === undefined ? {} : { functionCommandLines: io.functionCommandLines }), ...(io.diagnosticCommandLines === undefined ? {} : { diagnosticCommandLines: io.diagnosticCommandLines }), ...(io.scriptName === undefined ? {} : { scriptName: io.scriptName }), ...(io.substitutionDiagnosticLine === undefined ? {} : { substitutionDiagnosticLine: io.substitutionDiagnosticLine }), ...(io.substitutionDiagnosticLines === undefined ? {} : { substitutionDiagnosticLines: io.substitutionDiagnosticLines }), ...(io.processSubstitutions === undefined ? {} : { processSubstitutions: io.processSubstitutions }), stdin: descriptor?.input ?? closedSource, ...(stdinIsDefault === undefined ? {} : { stdinIsDefault }), stdout: descriptors.get(1)?.closed ? closedSink : descriptors.get(1)?.output ?? closedSink, stderr: descriptors.get(2)?.closed ? closedSink : descriptors.get(2)?.output ?? closedSink, descriptors,
             };
         };
@@ -20054,7 +19959,19 @@ export class Runtime {
                     }
                     else {
                         const append = redirect.operator === ">>" || redirect.operator === "&>>";
-                        const flag = append ? "a" : state.noclobber && redirect.operator !== ">|" ? "wx" : "w";
+                        let flag = append ? "a" : state.noclobber && redirect.operator !== ">|" ? "wx" : "w";
+                        if (flag === "wx") {
+                            try {
+                                const stat = await resourceFs.stat(path, options);
+                                if (stat.type !== "file" && stat.type !== "directory")
+                                    flag = "w";
+                            }
+                            catch (error) {
+                                this.signal.throwIfAborted();
+                                if (!(error instanceof FsError) || error.code !== "ENOENT")
+                                    throw error;
+                            }
+                        }
                         const capabilities = await this.fs.capabilitiesFor?.(path, { ...options, ...(flag === "wx" ? { creation: "exclusive" } : {}) }) ?? this.fs.capabilities;
                         const streaming = capabilities.preferStreamingRedirection === true && typeof this.fs.writeStream === "function"
                             && (append ? capabilities.streamingAppend ?? capabilities.streamingWrite : capabilities.streamingWrite) === true;
@@ -20548,6 +20465,31 @@ export class Runtime {
             }
             if (!words.length)
                 return state.substitutionStatus;
+            if (words[declarationIndex] === "exec" && !functionCommand && !state.extensions?.builtins.has("exec")) {
+                snapshotHolder.persistentRedirects = true;
+                const raw = stateMonitor(state)?.raw ?? state;
+                let frame = execDescriptorFrames.get(raw);
+                if (!frame) {
+                    frame = { version: 0, descriptors: new Map(), revisions: new Map(), releases: new Map() };
+                    execDescriptorFrames.set(raw, frame);
+                    this.budget.executionCleanup.register(() => closeExecDescriptors(raw));
+                }
+                for (const redirect of command.redirects) {
+                    const numbers = redirect.operator === "&>" || redirect.operator === "&>>" ? [1, 2] : [redirect.descriptor];
+                    for (const number of numbers) {
+                        const descriptor = io.descriptors?.get(number) ?? { closed: true };
+                        const release = descriptor.lifetime?.acquire();
+                        const previousRelease = frame.releases.get(number);
+                        if (release)
+                            frame.releases.set(number, release);
+                        else
+                            frame.releases.delete(number);
+                        frame.descriptors.set(number, descriptor);
+                        frame.revisions.set(number, ++frame.version);
+                        await previousRelease?.();
+                    }
+                }
+            }
             const args = words.slice(1);
             const argValues = allStrings ? args : wordValues.slice(1);
             const dispatchIO = compounds ? { ...io, [declarationArrays]: compounds } : io;
@@ -20688,7 +20630,7 @@ export class Runtime {
                     env[`BASH_FUNC_${key}%%`] = functionDisplay(key, body).slice(key.length + 1).trimEnd();
             }
         }
-        const context = new FastShellCommandContext(this, state, io, scope, name, values, undefined, env, this._isMemoryBackingFs);
+        const context = new FastShellCommandContext(this, state, io, scope, name, values, undefined, env, this._isMemoryBackingFs, definition);
         const runtimeFrame = {};
         scope.enterWork();
         this.budget.beginPathLookupSuspension();
@@ -21429,6 +21371,37 @@ export class Runtime {
                             state.lastArgument = context.args.at(-1) ?? context.command;
                             return { exitCode };
                         }
+                        if (context.command === "exec") {
+                            let execIdx = 0;
+                            while (execIdx < context.args.length) {
+                                const f = context.args[execIdx];
+                                if (f === "--") {
+                                    execIdx += 1;
+                                    break;
+                                }
+                                if (f === "-a" && execIdx + 1 < context.args.length) {
+                                    execIdx += 2;
+                                    continue;
+                                }
+                                if (f === "-c" || f === "-l") {
+                                    execIdx += 1;
+                                    continue;
+                                }
+                                break;
+                            }
+                            const execRest = context.args.slice(execIdx);
+                            const execCmd = execRest[0];
+                            if (execCmd === undefined) {
+                                return { exitCode: 0 };
+                            }
+                            const execArgs = execRest.slice(1);
+                            const status = await this.dispatch(execCmd, execArgs, state, { ...io, ...context }, assignments, true, context.argumentValues.values.slice(execIdx + 1));
+                            throw completedExit(status, "exit");
+                        }
+                        if (context.command === "read" && context.args.some(arg => arg.startsWith("-") && (arg.includes("u") || arg.includes("t")))) {
+                            const { executeRead } = await import("./read-builtin.js");
+                            return { exitCode: await executeRead(true, this.extensionContext(state, { ...io, ...context }, context.command, context.args, context.argumentValues.values)) };
+                        }
                         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) {
@@ -21862,7 +21835,7 @@ export class Runtime {
         try {
             do {
                 this.signal.throwIfAborted();
-                const unit = parseShellUnit(source, position, byteLocale(state.variables), this.budget.parsing, lineIndex, undefined, false, state.extensions?.syntax);
+                const unit = parseShellUnit(source, position, byteLocale(state.variables), this.budget.parsing, lineIndex, undefined, false, state.extensions?.syntax, state.expand_aliases ? state.aliases : undefined);
                 for (const warning of unit.script.warnings ?? [])
                     await writeDiagnostic(io.stderr, `${io.scriptName}: warning: ${warning}\n`);
                 if (unit.script.lists.length) {
@@ -21909,7 +21882,7 @@ export class Runtime {
             }
             const unitIO = { ...io, diagnosticOffset: offset };
             try {
-                const unit = eof ? parseShellUnit(source, 0, byteLocale(state.variables), this.budget.parsing, lineIndex, undefined, false, state.extensions?.syntax) : parseShellInputUnit(source, byteLocale(state.variables), this.budget.parsing, lineIndex, state.extensions?.syntax);
+                const unit = eof ? parseShellUnit(source, 0, byteLocale(state.variables), this.budget.parsing, lineIndex, undefined, false, state.extensions?.syntax, state.expand_aliases ? state.aliases : undefined) : parseShellInputUnit(source, byteLocale(state.variables), this.budget.parsing, lineIndex, state.extensions?.syntax, state.expand_aliases ? state.aliases : undefined);
                 if (unit) {
                     for (const warning of unit.script.warnings ?? [])
                         await writeDiagnostic(io.stderr, `${io.scriptName}: warning: ${warning}\n`);
@@ -22145,8 +22118,10 @@ export class Runtime {
             else {
                 const options = { signal: this.signal };
                 const stat = await interruptible(this.fs.stat(path, options), this.signal);
-                if (stat.type !== "file")
-                    throw new CommandFailure(`${target}: ${stat.type === "directory" ? "Is a directory" : "not a regular file"}`, 126);
+                if (stat.type === "directory")
+                    throw new CommandFailure(`${target}: Is a directory`, 126);
+                if (stat.type !== "file" && (direct || (stat.type !== "character" && stat.type !== "fifo")))
+                    throw new CommandFailure(`${target}: not a regular file`, 126);
                 if (direct) {
                     const capabilities = this.fs.capabilitiesFor
                         ? await interruptible(this.fs.capabilitiesFor(path, options), this.signal) : this.fs.capabilities;
@@ -22228,7 +22203,7 @@ export class Runtime {
                 this.signal.throwIfAborted();
                 let unit;
                 try {
-                    unit = parseShellUnit(source, position, byteLocale(child.variables), this.budget.parsing, lineIndex, undefined, false, child.extensions?.syntax);
+                    unit = parseShellUnit(source, position, byteLocale(child.variables), this.budget.parsing, lineIndex, undefined, false, child.extensions?.syntax, child.expand_aliases ? child.aliases : undefined);
                 }
                 catch (error) {
                     if (!(error instanceof ShellSyntaxError))
@@ -22254,7 +22229,7 @@ export class Runtime {
         }
     }
     async runCurrentText(source, state, io, fatalSyntax, syntaxName, byteSource = false, includeSyntaxContext = true, sourceValues) {
-        if (!sourceValues && !byteSource && isDefaultShellSyntax(state.extensions?.syntax) && source.length <= 4096) {
+        if (!state.expand_aliases && !sourceValues && !byteSource && isDefaultShellSyntax(state.extensions?.syntax) && source.length <= 4096) {
             try {
                 const cachedUnit = getOrParseSingleEvalUnit(source, byteLocale(state.variables), this.budget.parsing);
                 if (cachedUnit) {
@@ -22285,7 +22260,7 @@ export class Runtime {
         try {
             do {
                 this.signal.throwIfAborted();
-                const unit = parseShellUnit(source, position, byteLocale(state.variables), this.budget.parsing, lineIndex, sourceValues, byteSource, state.extensions?.syntax);
+                const unit = parseShellUnit(source, position, byteLocale(state.variables), this.budget.parsing, lineIndex, sourceValues, byteSource, state.extensions?.syntax, state.expand_aliases ? state.aliases : undefined);
                 for (const warning of unit.script.warnings ?? [])
                     await writeDiagnostic(io.stderr, `${io.scriptName ?? "shell"}: warning: ${warning}\n`);
                 if (unit.script.lists.length) {
@@ -22408,7 +22383,7 @@ export class Runtime {
             const stat = await interruptible(this.fs.stat(path, options), this.signal);
             if (stat.type === "directory")
                 throw new CommandFailure(`${context.command}: ${target}: is a directory`, 1);
-            if (stat.type !== "file")
+            if (stat.type !== "file" && stat.type !== "character" && stat.type !== "fifo")
                 throw new CommandFailure(`${target}: not a regular file`, 1);
             await interruptible(this.fs.access(path, ACCESS_MODES.R_OK, options), this.signal);
             const maxBytes = this.budget.limits.maxSourceBytes - this.budget.sourceBytes;
@@ -23150,7 +23125,7 @@ export class Runtime {
             return 1;
         }
         const options = new Map();
-        for (const name of setNamespace ? ["allexport", "braceexpand", "errexit", "noclobber", "noexec", "noglob", "nounset", "pipefail"] : ["dotglob", "extglob", "globstar", "nocaseglob", "nocasematch", "nullglob"]) {
+        for (const name of setNamespace ? ["allexport", "braceexpand", "errexit", "noclobber", "noexec", "noglob", "nounset", "pipefail"] : ["dotglob", "expand_aliases", "extglob", "failglob", "globstar", "inherit_errexit", "lastpipe", "nocaseglob", "nocasematch", "nullglob"]) {
             options.set(name, {
                 get enabled() { return name === "braceexpand" ? state.braceexpand !== false : !!state[name]; }, set enabled(value) { state[name] = value; },
             });
@@ -23620,6 +23595,12 @@ export class Runtime {
         }
         if (command === "shopt")
             return this.shoptBuiltin(context, state);
+        if (command === "alias" || command === "unalias") {
+            const aliases = state.aliases ??= new Map();
+            const limits = { maxArgumentBytes: this.budget.limits.maxExpansionBytes, maxAliasBytes: this.budget.limits.maxExpansionBytes };
+            const definition = command === "alias" ? createAliasCommand({ aliases, limits }) : createUnaliasCommand({ aliases, limits });
+            return (await definition.execute(context)).exitCode;
+        }
         if (command === "let")
             return this.letBuiltin(context, state);
         if (command === "mapfile" || command === "readarray")
@@ -24632,6 +24613,8 @@ export class Runtime {
         }
         if (command === "break" || command === "continue") {
             if (!state.loopDepth) {
+                if (state._subshellInLoop)
+                    throw completedExit(0, command, 1);
                 await writeDiagnostic(stderr, `${command}: only meaningful in a loop\n`);
                 return 0;
             }
@@ -24868,7 +24851,7 @@ export class Runtime {
             if (operator === "+" ? !missing : missing) {
                 if (operator === "=")
                     throw new ArrayFailure(`${part.name}[${memberSelector.separator}]: bad array subscript`);
-                const alternate = concatShellValues(await this.valueWord(part.alternate, state, this.parameterOperandIO(part.alternate, state, io), false, false, hereString, false, undefined, hereDocument), io[valueScope]);
+                const alternate = concatShellValues(await this.valueWord(part.alternate, state, this.parameterOperandIO(part.alternate, state, io), false, false, hereString, false, undefined, hereDocument || part.quoted), io[valueScope]);
                 if (operator === "?")
                     throw new ParameterExpansionFailure(`${part.name}: ${shellValueText(alternate) || "parameter not set"}`, io.diagnosticLine ?? part.line);
                 return alternate;
@@ -24892,12 +24875,13 @@ export class Runtime {
                 if (operator === "+" ? !missing : missing) {
                     const operandIO = this.parameterOperandIO(part.alternate, state, io);
                     if (operator === "=") {
-                        await this.arrayAssignment({ kind: "element", name: part.name, index: element.index, append: false, value: part.alternate }, state, operandIO);
+                        const elemAlt = part.quoted ? { ...part.alternate, parts: part.alternate.parts.map(p => ({ ...p, quoted: true })) } : part.alternate;
+                        await this.arrayAssignment({ kind: "element", name: part.name, index: element.index, append: false, value: elemAlt }, state, operandIO);
                         const assigned = store.get(part.name);
                         const assignedIndex = assigned.associative ? await this.arrayIndex(assigned, element.index, state, io, store.owner) : index;
                         return assignedIndex === undefined ? "" : assigned.getValue(assignedIndex) ?? "";
                     }
-                    const alternate = concatShellValues(await this.valueWord(part.alternate, state, operandIO, false, false, hereString, false, undefined, hereDocument), io[valueScope]);
+                    const alternate = concatShellValues(await this.valueWord(part.alternate, state, operandIO, false, false, hereString, false, undefined, hereDocument || part.quoted), io[valueScope]);
                     if (operator === "?")
                         throw new ParameterExpansionFailure(`${part.name}: ${shellValueText(alternate) || (part.operator.startsWith(":") ? "parameter null or not set" : "parameter not set")}`, io.diagnosticLine ?? part.line);
                     return alternate;
@@ -25144,13 +25128,32 @@ export class Runtime {
             if (state.depth >= this.budget.limits.maxSubstitutionDepth)
                 this.budget.fail("maxSubstitutionDepth");
             this.signal.throwIfAborted();
-            const tempPath = `/.procsub-${++nextProcessSubstitutionId}`;
+            const ids = state.processSubstitutionIds ??= { next: 0 };
+            const requestedDirectory = pathOf(state, state.variables.TMPDIR || "/tmp");
+            const directory = requestedDirectory === "/" ? "/tmp" : requestedDirectory;
+            await this.sourceFs.mkdir(directory, { recursive: true, signal: this.signal });
+            let tempPath = "";
+            let owned = false;
             io[invocationScope].register(async () => {
+                if (owned)
+                    try {
+                        await this.sourceFs.rm(tempPath, { force: true });
+                    }
+                    catch { }
+            });
+            while (!owned) {
+                this.budget.tick();
+                tempPath = pathOf(state, `${directory}/.procsub-${++ids.next}`);
                 try {
-                    await this.sourceFs.rm(tempPath, { force: true });
+                    await this.sourceFs.writeFile(tempPath, new Uint8Array(0), { flag: "wx", signal: this.signal });
+                    owned = true;
                 }
-                catch { }
-            });
+                catch (error) {
+                    this.signal.throwIfAborted();
+                    if (!(error instanceof FsError) || error.code !== "EEXIST")
+                        throw error;
+                }
+            }
             if (part.direction === "<") {
                 const capture = new Capture();
                 const child = await cloneState(state, this.signal);
@@ -25161,7 +25164,6 @@ export class Runtime {
                     child.errexit = false;
                 delete child.redirectAssignments;
                 child.depth++;
-                child.loopDepth = 0;
                 const references = new PipeDescriptorFrame(io[invocationScope]);
                 const lifetime = new DescriptorLifetime();
                 const captureIO = isolateIO({
@@ -25215,7 +25217,6 @@ export class Runtime {
                     child.errexit = false;
                 delete child.redirectAssignments;
                 child.depth++;
-                child.loopDepth = 0;
                 const prepared = prepareBytesInput(bytes, this.budget);
                 const input = new ShellInput(prepared.source, this.budget, this.commandSignal, prepared.options);
                 const lifetime = new DescriptorLifetime(async () => {
@@ -25265,7 +25266,7 @@ export class Runtime {
             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")
+            if (state.profile !== "sh" && !state.inherit_errexit)
                 child.errexit = false;
             for (const [name, value] of state.redirectAssignments ?? []) {
                 await this.writeVariable(child, name, value, io);
@@ -25273,7 +25274,6 @@ export class Runtime {
             }
             delete child.redirectAssignments;
             child.depth++;
-            child.loopDepth = 0;
             const pipeline = part.script.lists.length === 1 && part.script.lists[0].pipelines.length === 1 ? part.script.lists[0].pipelines[0] : undefined;
             const command = pipeline && !pipeline.negate && pipeline.commands.length === 1 ? pipeline.commands[0] : undefined;
             const fileShortcut = command?.kind === "simple" && command.words.length === 0 && command.redirects.length === 1 && command.redirects[0].operator === "<";
@@ -25416,16 +25416,19 @@ export class Runtime {
             if ((operator === "+" && !missing) || (operator !== "+" && missing)) {
                 const operandIO = this.parameterOperandIO(part.alternate, state, io);
                 let alternate;
+                const altWord = !hereDocument && !part.quoted && operator === "="
+                    ? { ...part.alternate, parts: expandTildes(part.alternate.parts, state.variables, this.budget, undefined, true) }
+                    : part.alternate;
                 if (operator === "=" && arrayStore(state)?.get(part.name)) {
                     alternate = "";
                     await this.arrayZero(state, part.name, io, async () => {
-                        retained = await this.arrayJoin(requireArrays(state).owner, await this.valueWord(part.alternate, state, operandIO, false, false, hereString, false, undefined, hereDocument), "");
+                        retained = await this.arrayJoin(requireArrays(state).owner, await this.valueWord(altWord, state, operandIO, false, false, hereString, false, undefined, hereDocument || part.quoted || operator === "="), "");
                         return retained;
                     });
                     value = shellValueText(retained);
                     return part.length ? this.valueLength(retained, state, io) : retained;
                 }
-                retained = concatShellValues(await this.valueWord(part.alternate, state, operandIO, false, false, hereString, false, undefined, hereDocument), io[valueScope]);
+                retained = concatShellValues(await this.valueWord(altWord, state, operandIO, false, false, hereString, false, undefined, hereDocument || part.quoted || operator === "="), io[valueScope]);
                 alternate = shellValueText(retained);
                 if (operator === "?")
                     throw new ParameterExpansionFailure(`${part.name}: ${alternate || (part.operator.startsWith(":") ? "parameter null or not set" : "parameter not set")}`, io.diagnosticLine ?? part.line);
@@ -26010,7 +26013,7 @@ export class Runtime {
                 }
                 if (part.indirect || part.specialParameter)
                     return undefined;
-                if (part.name === "@" || part.name === "*" || part.name === "PIPESTATUS" || part.name === "LINENO" || part.name === "BASH_SUBSHELL" || 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 === "BASHPID" || part.name === "_" || part.name === "FUNCNAME" || part.name === "DIRSTACK")
                     return undefined;
                 if (!isShellIdentifier(part.name))
                     return undefined;
@@ -35449,7 +35452,7 @@ export class Runtime {
             if (p.kind === "text")
                 continue;
             if (p.kind === "variable") {
-                if (p.name === "BASH_SUBSHELL" || p.name === "RANDOM" || p.name === "SECONDS")
+                if (p.name === "BASH_SUBSHELL" || p.name === "BASHPID" || p.name === "RANDOM" || p.name === "SECONDS")
                     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;
@@ -35476,6 +35479,10 @@ export class Runtime {
         return true;
     }
     tryFastPureSubstitution(part, state, rawState, io) {
+        if (!cCollation(rawState.variables.LC_ALL || rawState.variables.LC_COLLATE || rawState.variables.LANG || "C"))
+            return undefined;
+        if (this.budget.limits.maxPipelineBytes !== Infinity)
+            return undefined;
         // Synchronous evaluators do not expose cumulative source-read accounting.
         // Use the command context whenever the caller has set an input ceiling.
         if (this.budget.limits.maxInputBytes !== Infinity)
@@ -35929,8 +35936,6 @@ export class Runtime {
             syncPurePipelineSlotInUse = true;
             this.budget.enterPipelineStages(n);
             this.budget.commands += n;
-            const scope = io[invocationScope];
-            let context = pooledSyncPipeContext;
             let prevBuf = sharedSyncPipeBuf0;
             let prevLen = fastSharedTextEncoder.encodeInto(stage0Formatted, sharedSyncPipeBuf0).written;
             try {
@@ -37017,35 +37022,9 @@ export class Runtime {
                         prevLen = written;
                         continue;
                     }
-                    sharedSyncPipeReader.reset(prevBuf, prevLen, this.signal, -1);
-                    sharedSyncPipeWriter.reset(this.budget, this.signal, nextBuf, -1);
-                    if (!context) {
-                        context = new FastShellCommandContext(this, rawState, io, scope, firstName, stageArgs, undefined, undefined, true);
-                        pooledSyncPipeContext = context;
-                    }
-                    context.resetDirectStage(this, rawState, io, scope, firstName, stageArgs, sharedSyncPipeReader, false, sharedSyncPipeWriter, this.signal);
-                    sharedSyncPipeReader.abortSignal = context.signal;
-                    scope.enterWork();
-                    this.budget.beginPathLookupSuspension();
-                    let resPromise;
-                    try {
-                        resPromise = extDef.execute(context);
-                    }
-                    finally {
-                        this.budget.endPathLookupSuspension();
-                        scope.leaveWork();
-                    }
-                    if (resPromise !== RESOLVED_EXIT_ZERO) {
-                        if (resPromise && typeof resPromise.catch === "function") {
-                            resPromise.catch(() => { });
-                        }
-                        pooledSyncPipeContext = undefined;
-                        context = undefined;
-                        return undefined;
-                    }
-                    this.signal.throwIfAborted();
-                    prevBuf = nextBuf;
-                    prevLen = sharedSyncPipeWriter.used;
+                    // A command executor may suspend. Decline before invoking it so the
+                    // ordinary pipeline owns its context and executes every stage once.
+                    return undefined;
                 }
                 if (prevBuf.subarray(0, prevLen).includes(0))
                     return undefined;
@@ -37057,12 +37036,6 @@ export class Runtime {
                     this.budget.bytes = previousBytes;
                     this.budget.commands = previousCommands;
                 }
-                if (context)
-                    context.releaseDirectStage();
-                sharedSyncPipeWriter.budget = undefined;
-                sharedSyncPipeWriter.signal = undefined;
-                sharedSyncPipeWriter.target = EMPTY_BYTES;
-                sharedSyncPipeReader.reset(EMPTY_BYTES, 0);
                 syncPurePipelineSlotInUse = false;
                 this.budget.leavePipelineStages(n);
             }
@@ -40173,6 +40146,8 @@ export class Runtime {
                 }
             }
             await sortExpansionStrings(found, work, true);
+            if (!found.length && state.failglob)
+                throw new FailglobFailure(`no match: ${value}`);
             return found.length ? found : state.nullglob ? [] : [value];
         }
         finally {
@@ -40267,6 +40242,8 @@ export class Runtime {
             remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 * (Math.ceil(Math.log2(found.length + 1)) + 1) + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes"),
         };
         await sortExpansionStrings(found, sortingWork, true);
+        if (!found.length && state.failglob)
+            throw new FailglobFailure(`no match: ${value}`);
         return found.length ? found : state.nullglob ? [] : [value];
     }
 }
@@ -40286,6 +40263,7 @@ export class RootShellState {
         this.substitutionStatus = 0;
         this.lastArgument = "";
         this.secondsOrigin = Date.now();
+        this.processSubstitutionIds = { next: 0 };
     }
     get exported() {
         const raw = stateMonitor(this)?.raw;