@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/shell/interpreter.js

@@ -0,0 +1,1490 @@
+import { lex } from './lexer.js';
+import { parse } from './parser.js';
+import { expandWords, expandWord, evaluateSubscript, ExpansionError, } from './expander.js';
+import { evaluateDoubleBracketWords } from './test-builtin.js';
+import { PipeChannel } from './pipe.js';
+import { exitCodeForAbortSignal } from './signals.js';
+import { resolve } from '../utils/path.js';
+import { encode } from '../utils/encoding.js';
+import { globMatch } from '../utils/glob.js';
+/**
+ * Bytes a file-backed descriptor holds before committing. Matches the stream
+ * chunk size used elsewhere and keeps a line-at-a-time producer from paying a
+ * store write per line.
+ */
+const FILE_WRITE_BLOCK_BYTES = 64 * 1024;
+function concatBytes(parts, total) {
+    const out = new Uint8Array(total);
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.length;
+    }
+    return out;
+}
+// ─── Signal classes for control flow ───
+export class BreakSignal {
+    levels;
+    constructor(levels) {
+        this.levels = levels;
+    }
+}
+export class ContinueSignal {
+    levels;
+    constructor(levels) {
+        this.levels = levels;
+    }
+}
+export class ReturnSignal {
+    exitCode;
+    constructor(exitCode) {
+        this.exitCode = exitCode;
+    }
+}
+export class ErrexitSignal {
+    exitCode;
+    constructor(exitCode) {
+        this.exitCode = exitCode;
+    }
+}
+export class ExitSignal {
+    exitCode;
+    constructor(exitCode) {
+        this.exitCode = exitCode;
+    }
+}
+class RedirectionOpenError extends Error {
+    target;
+    fsError;
+    constructor(target, fsError) {
+        super(fsError instanceof Error ? fsError.message : String(fsError));
+        this.target = target;
+        this.fsError = fsError;
+    }
+}
+function redirectionDiagnostic(error) {
+    const code = typeof error.fsError === 'object' && error.fsError !== null
+        && 'code' in error.fsError && typeof error.fsError.code === 'string'
+        ? error.fsError.code
+        : /^([A-Z][A-Z0-9]+):/.exec(error.message)?.[1];
+    const reason = code === 'EACCES' || code === 'EPERM'
+        ? 'Permission denied'
+        : code === 'ENOENT'
+            ? 'No such file or directory'
+            : code === 'ENOTDIR'
+                ? 'Not a directory'
+                : code === 'EISDIR'
+                    ? 'Is a directory'
+                    : error.message;
+    return `sh: ${error.target}: ${reason}\n`;
+}
+/**
+ * Assign a plain value to a name. A name that already holds an array keeps it:
+ * `a=(x y); a=plain` sets `a[0]` and leaves `a[1]` alone, which is bash's rule
+ * and the reason a variable's type only changes through `unset`.
+ */
+export function assignScalar(env, arrays, name, value) {
+    const array = arrays.get(name);
+    if (array === undefined)
+        env[name] = value;
+    else
+        array[0] = value;
+}
+export class Interpreter {
+    config;
+    lastExitCode = 0;
+    functions = new Map();
+    persistentOutputFds = new Map();
+    persistentInputFds = new Map();
+    persistentTerminalOutputFds = new Set();
+    persistentTerminalInputFds = new Set();
+    errexitSuppressionDepth = 0;
+    exitTrapDepth = 0;
+    /** One frame per running function call, holding the bindings `local` shadowed. */
+    localFrames = [];
+    constructor(config) {
+        this.config = config;
+    }
+    getLastExitCode() {
+        return this.lastExitCode;
+    }
+    async executeScript(script, terminalStdin) {
+        return this.executeScriptWithIo(script, this.createTerminalIo(terminalStdin));
+    }
+    async executeScriptWithIo(script, io) {
+        let exitCode = 0;
+        try {
+            for (const list of script.lists) {
+                exitCode = await this.executeList(list, io);
+            }
+        }
+        catch (error) {
+            if (error instanceof ErrexitSignal) {
+                exitCode = error.exitCode;
+            }
+            else if (error instanceof ExitSignal) {
+                exitCode = error.exitCode;
+            }
+            else {
+                throw error;
+            }
+        }
+        this.lastExitCode = exitCode;
+        return exitCode;
+    }
+    async executeLine(input, terminalStdin, options) {
+        const io = this.createTerminalIo(terminalStdin, options?.terminalFds, options?.scriptMode === true, options?.stdin);
+        if (options?.stdout)
+            io.stdout = options.stdout;
+        if (options?.stderr)
+            io.stderr = options.stderr;
+        if (options?.writeToTerminal)
+            io.writeToTerminal = options.writeToTerminal;
+        if (options?.commandContext)
+            io.commandContext = options.commandContext;
+        if (options?.commandIdentity)
+            io.commandIdentity = options.commandIdentity;
+        if (options?.runAs)
+            io.runAs = options.runAs;
+        if (options?.signal)
+            io.signal = options.signal;
+        if (options?.commandIdentity)
+            io.vfs = this.config.vfs.as(options.commandIdentity.cred);
+        try {
+            const tokens = lex(input);
+            const script = parse(tokens);
+            const exitCode = await this.executeScriptWithIo(script, io);
+            return await this.runExitTrap(exitCode, io, options?.runExitTrap === true);
+        }
+        catch (e) {
+            if (e instanceof BreakSignal || e instanceof ContinueSignal || e instanceof ReturnSignal) {
+                throw e;
+            }
+            if (e instanceof ErrexitSignal) {
+                this.lastExitCode = e.exitCode;
+                return e.exitCode;
+            }
+            if (e instanceof Error) {
+                this.writeTerminal(io, `${e.message}\n`);
+            }
+            // A failed expansion aborts with 1, the way bash does; 2 is reserved for
+            // the shell's own usage errors (syntax, bad builtin invocation).
+            const exitCode = e instanceof ExpansionError ? 1 : 2;
+            this.lastExitCode = exitCode;
+            return exitCode;
+        }
+    }
+    async executeList(list, io = {}) {
+        const abortCode = this.abortExitCode(io);
+        if (abortCode !== null)
+            return abortCode;
+        if (list.background) {
+            const abortController = new AbortController();
+            const commandText = this.getListCommandText(list);
+            const backgroundIo = this.createCommandIo(io);
+            backgroundIo.signal = abortController.signal;
+            backgroundIo.registerProcess = false;
+            backgroundIo.positionals = this.forkPositionals(io);
+            const promise = (async () => {
+                return await this.executeListEntries(list.entries, backgroundIo);
+            })();
+            const pid = this.config.processRegistry.spawn({
+                command: commandText.split(' ')[0] || 'unknown',
+                args: commandText.split(' '),
+                cwd: this.config.getCwd(),
+                env: { ...this.config.env },
+                isForeground: false,
+                promise,
+                abortController,
+            });
+            const waitable = this.config.processRegistry.get(pid)?.promise ?? promise;
+            const jobId = this.config.jobTable.add(commandText, waitable, abortController);
+            this.config.env['!'] = String(pid);
+            this.writeTerminal(io, `[${jobId}] ${pid} (background)\n`);
+            // Don't auto-reap - let Shell collect zombies before next prompt
+            // This matches Linux behavior where zombies persist until reaped
+            return 0;
+        }
+        return this.executeListEntries(list.entries, io);
+    }
+    getListCommandText(list) {
+        return list.entries.map((e) => e.pipeline.commands.map((c) => {
+            if (c.type === 'simple_command') {
+                return c.words.map((w) => w.map((p) => p.text).join('')).join(' ');
+            }
+            return c.type;
+        }).join(' | ')).join(' ');
+    }
+    async executeListEntries(entries, io = {}) {
+        let exitCode = 0;
+        let skipNext = false;
+        for (const entry of entries) {
+            const abortCode = this.abortExitCode(io);
+            if (abortCode !== null)
+                return abortCode;
+            if (!skipNext) {
+                exitCode = await this.executePipeline(entry.pipeline, io);
+            }
+            skipNext = false;
+            this.enforceErrexit(entry.connector, exitCode);
+            if (entry.connector === '&&' && exitCode !== 0) {
+                skipNext = true;
+            }
+            else if (entry.connector === '||' && exitCode === 0) {
+                skipNext = true;
+            }
+        }
+        this.lastExitCode = exitCode;
+        return exitCode;
+    }
+    async executePipeline(pipeline, io = {}) {
+        const abortCode = this.abortExitCode(io);
+        if (abortCode !== null)
+            return abortCode;
+        const commands = pipeline.commands;
+        let exitCode;
+        if (commands.length === 1) {
+            // Single command -- no piping needed
+            exitCode = await this.executeCommand(commands[0], io);
+        }
+        else {
+            exitCode = await this.executePipelineCommands(commands, io);
+        }
+        if (pipeline.negated) {
+            exitCode = exitCode === 0 ? 1 : 0;
+        }
+        return exitCode;
+    }
+    async executePipelineCommands(commands, io) {
+        const pipes = [];
+        const promises = [];
+        const pipelineAbortController = new AbortController();
+        const parentSignal = io.signal ?? this.config.getAbortSignal?.();
+        let unlinkParentSignal;
+        if (parentSignal?.aborted) {
+            pipelineAbortController.abort(parentSignal.reason);
+        }
+        else if (parentSignal) {
+            unlinkParentSignal = linkAbortSignal(parentSignal, pipelineAbortController);
+        }
+        try {
+            for (let i = 0; i < commands.length; i++) {
+                const abortCode = this.abortExitCode(io);
+                if (abortCode !== null)
+                    return abortCode;
+                const stdin = i > 0 ? pipes[i - 1].reader : undefined;
+                let stdout;
+                if (i < commands.length - 1) {
+                    const pipe = new PipeChannel();
+                    pipes.push(pipe);
+                    stdout = pipe.writer;
+                }
+                const cmd = commands[i];
+                const isLast = i === commands.length - 1;
+                const commandStdin = stdin ?? (i === 0 ? io.stdin : undefined);
+                const commandStdout = stdout ?? (isLast ? io.stdout : undefined);
+                const cmdIo = this.createCommandIo(io);
+                if (commandStdin)
+                    cmdIo.stdin = commandStdin;
+                else
+                    delete cmdIo.stdin;
+                if (commandStdout)
+                    cmdIo.stdout = commandStdout;
+                else
+                    delete cmdIo.stdout;
+                cmdIo.terminalFds = {
+                    stdin: stdin ? false : io.terminalFds?.stdin,
+                    stdout: stdout ? false : io.terminalFds?.stdout,
+                    stderr: io.terminalFds?.stderr,
+                };
+                cmdIo.signal = pipelineAbortController.signal;
+                cmdIo.positionals = this.forkPositionals(io);
+                const cmdPromise = (async () => {
+                    try {
+                        return await this.executeCommand(cmd, cmdIo);
+                    }
+                    catch (e) {
+                        if (e instanceof ExitSignal) {
+                            return e.exitCode;
+                        }
+                        throw e;
+                    }
+                    finally {
+                        if (i < commands.length - 1) {
+                            pipes[i].close();
+                        }
+                        if (isLast) {
+                            pipelineAbortController.abort();
+                            for (const pipe of pipes)
+                                pipe.close();
+                        }
+                    }
+                })();
+                promises.push(cmdPromise);
+            }
+            const results = await Promise.all(promises);
+            if (this.config.options.pipefail) {
+                for (let i = results.length - 1; i >= 0; i--) {
+                    if (results[i] !== 0)
+                        return results[i] ?? 1;
+                }
+            }
+            return results[results.length - 1] ?? 0;
+        }
+        finally {
+            unlinkParentSignal?.();
+        }
+    }
+    async executeCommand(cmd, io = {}) {
+        const abortCode = this.abortExitCode(io);
+        if (abortCode !== null)
+            return abortCode;
+        switch (cmd.type) {
+            case 'simple_command':
+                return this.executeSimpleCommand(cmd, io);
+            case 'double_bracket':
+                return this.executeDoubleBracket(cmd, io);
+            case 'if':
+                return this.executeIf(cmd, io);
+            case 'for':
+                return this.executeFor(cmd, io);
+            case 'while':
+                return this.executeWhile(cmd, io);
+            case 'until':
+                return this.executeUntil(cmd, io);
+            case 'case':
+                return this.executeCase(cmd, io);
+            case 'group':
+                return this.executeGroup(cmd, io);
+            case 'subshell':
+                return this.executeSubshell(cmd, io);
+            case 'function_def':
+                return this.executeFunctionDef(cmd);
+        }
+    }
+    async executeIf(node, io) {
+        return this.executeWithRedirections(node.redirections, io, async (redirIo) => {
+            let exitCode = 0;
+            for (const clause of node.clauses) {
+                const condCode = await this.withErrexitSuppressed(() => this.executeCompoundList(clause.condition, redirIo));
+                if (condCode === 0) {
+                    exitCode = await this.executeCompoundList(clause.body, redirIo);
+                    this.lastExitCode = exitCode;
+                    return exitCode;
+                }
+            }
+            if (node.elseBody) {
+                exitCode = await this.executeCompoundList(node.elseBody, redirIo);
+            }
+            this.lastExitCode = exitCode;
+            return exitCode;
+        });
+    }
+    async executeDoubleBracket(node, io) {
+        return this.executeWithRedirections(node.redirections, io, async (redirIo) => {
+            const stdout = redirIo.stdout ?? this.terminalSink(redirIo);
+            const stderr = redirIo.stderr ?? this.terminalSink(redirIo);
+            const fds = this.createCommandFds(stdout, stderr, redirIo.stdin, redirIo);
+            const builtinIo = this.createIoFromFds(redirIo, fds);
+            const exitCode = await this.withFdFlush(fds, () => evaluateDoubleBracketWords(node.words, this.createExpandContext(redirIo), redirIo.vfs ?? this.config.vfs, stderr, {
+                vfs: builtinIo.vfs ?? this.config.vfs,
+                cwd: this.config.getCwd(),
+                stdin: builtinIo.stdin,
+                stdout,
+                stderr,
+                terminalStdin: redirIo.terminalStdin,
+                terminalFds: {
+                    stdin: fds.terminalInputFds.has(0),
+                    stdout: fds.terminalOutputFds.has(1),
+                    stderr: fds.terminalOutputFds.has(2),
+                },
+                scriptMode: redirIo.scriptMode,
+                isFdTerminal: (fd) => this.isFdTerminal(fds, fd),
+                getPositionals: () => this.readPositionals(builtinIo),
+                setPositionals: (nextArgs) => this.writePositionals(builtinIo, nextArgs),
+                executeInline: (input, options) => this.executeInline(input, builtinIo, options),
+                declareLocal: (name) => this.declareLocal(name),
+            }));
+            this.lastExitCode = exitCode;
+            return exitCode;
+        });
+    }
+    async executeFor(node, io) {
+        return this.executeWithRedirections(node.redirections, io, async (redirIo) => {
+            const expandCtx = this.createExpandContext(redirIo);
+            let exitCode = 0;
+            let values;
+            if (node.words !== null) {
+                values = await expandWords(node.words, expandCtx);
+            }
+            else {
+                values = [...this.readPositionals(redirIo)];
+            }
+            for (const val of values) {
+                const abortCode = this.abortExitCode(redirIo);
+                if (abortCode !== null)
+                    return abortCode;
+                if (!this.assignEnv(node.variable, val)) {
+                    this.writeTerminal(redirIo, `${node.variable}: readonly variable\n`);
+                    return 1;
+                }
+                try {
+                    exitCode = await this.executeCompoundList(node.body, redirIo);
+                }
+                catch (e) {
+                    if (e instanceof BreakSignal) {
+                        if (e.levels > 1)
+                            throw new BreakSignal(e.levels - 1);
+                        break;
+                    }
+                    if (e instanceof ContinueSignal) {
+                        if (e.levels > 1)
+                            throw new ContinueSignal(e.levels - 1);
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+            this.lastExitCode = exitCode;
+            return exitCode;
+        });
+    }
+    async executeWhile(node, io) {
+        return this.executeWithRedirections(node.redirections, io, async (redirIo) => {
+            let exitCode = 0;
+            while (true) {
+                const abortCode = this.abortExitCode(redirIo);
+                if (abortCode !== null)
+                    return abortCode;
+                const condCode = await this.withErrexitSuppressed(() => this.executeCompoundList(node.condition, redirIo));
+                if (condCode !== 0)
+                    break;
+                try {
+                    exitCode = await this.executeCompoundList(node.body, redirIo);
+                }
+                catch (e) {
+                    if (e instanceof BreakSignal) {
+                        if (e.levels > 1)
+                            throw new BreakSignal(e.levels - 1);
+                        break;
+                    }
+                    if (e instanceof ContinueSignal) {
+                        if (e.levels > 1)
+                            throw new ContinueSignal(e.levels - 1);
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+            this.lastExitCode = exitCode;
+            return exitCode;
+        });
+    }
+    async executeUntil(node, io) {
+        return this.executeWithRedirections(node.redirections, io, async (redirIo) => {
+            let exitCode = 0;
+            while (true) {
+                const abortCode = this.abortExitCode(redirIo);
+                if (abortCode !== null)
+                    return abortCode;
+                const condCode = await this.withErrexitSuppressed(() => this.executeCompoundList(node.condition, redirIo));
+                if (condCode === 0)
+                    break;
+                try {
+                    exitCode = await this.executeCompoundList(node.body, redirIo);
+                }
+                catch (e) {
+                    if (e instanceof BreakSignal) {
+                        if (e.levels > 1)
+                            throw new BreakSignal(e.levels - 1);
+                        break;
+                    }
+                    if (e instanceof ContinueSignal) {
+                        if (e.levels > 1)
+                            throw new ContinueSignal(e.levels - 1);
+                        continue;
+                    }
+                    throw e;
+                }
+            }
+            this.lastExitCode = exitCode;
+            return exitCode;
+        });
+    }
+    async executeCase(node, io) {
+        return this.executeWithRedirections(node.redirections, io, async (redirIo) => {
+            const expandCtx = this.createExpandContext(redirIo);
+            const wordValue = await expandWord(node.word, expandCtx);
+            let exitCode = 0;
+            for (const item of node.items) {
+                for (const pattern of item.patterns) {
+                    const patternValue = await expandWord(pattern, expandCtx);
+                    if (globMatch(patternValue, wordValue)) {
+                        exitCode = await this.executeCompoundList(item.body, redirIo);
+                        this.lastExitCode = exitCode;
+                        return exitCode;
+                    }
+                }
+            }
+            this.lastExitCode = exitCode;
+            return exitCode;
+        });
+    }
+    async executeFunctionDef(node) {
+        this.functions.set(node.name, node.body);
+        return 0;
+    }
+    async executeGroup(node, io) {
+        const exitCode = await this.executeWithRedirections(node.redirections, io, (redirIo) => this.executeCompoundList(node.body, redirIo));
+        this.lastExitCode = exitCode;
+        return exitCode;
+    }
+    async executeSubshell(node, io) {
+        const savedCwd = this.config.getCwd();
+        const savedEnv = { ...this.config.env };
+        const savedArrays = new Map();
+        for (const [name, elements] of this.config.arrays)
+            savedArrays.set(name, [...elements]);
+        let exitCode = 0;
+        const subshellIo = this.createCommandIo(io);
+        subshellIo.positionals = this.forkPositionals(io);
+        try {
+            exitCode = await this.executeWithRedirections(node.redirections, subshellIo, (redirIo) => this.executeCompoundList(node.body, redirIo));
+        }
+        catch (e) {
+            if (e instanceof ExitSignal) {
+                exitCode = e.exitCode;
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            this.config.setCwd(savedCwd);
+            for (const key of Object.keys(this.config.env))
+                delete this.config.env[key];
+            Object.assign(this.config.env, savedEnv);
+            this.config.arrays.clear();
+            for (const [name, elements] of savedArrays)
+                this.config.arrays.set(name, elements);
+        }
+        this.lastExitCode = exitCode;
+        return exitCode;
+    }
+    async executeCompoundList(lists, io) {
+        let exitCode = 0;
+        for (const list of lists) {
+            const abortCode = this.abortExitCode(io);
+            if (abortCode !== null)
+                return abortCode;
+            exitCode = await this.executeList(list, io);
+        }
+        return exitCode;
+    }
+    async executeSimpleCommand(cmd, io) {
+        const abortCode = this.abortExitCode(io);
+        if (abortCode !== null)
+            return abortCode;
+        const expandCtx = this.createExpandContext(io);
+        // Expand words
+        const expandedArgs = await expandWords(cmd.words, expandCtx);
+        if (expandedArgs.length === 0 && cmd.assignments.length > 0) {
+            // Bare assignment -- set env vars
+            for (const assign of cmd.assignments) {
+                if (!await this.applyAssignment(assign, expandCtx)) {
+                    this.writeTerminal(io, `${assign.name}: readonly variable\n`);
+                    if (io.scriptMode === true)
+                        throw new ErrexitSignal(1);
+                    return 1;
+                }
+            }
+            // A command that is only assignments exits with the status of the last
+            // command substitution it ran, so `out="$(cmd)" || die` sees cmd fail.
+            return expandCtx.lastSubstitutionExitCode ?? 0;
+        }
+        if (expandedArgs.length === 0) {
+            return 0;
+        }
+        const [name, ...args] = expandedArgs;
+        // Check alias expansion
+        const aliases = this.config.aliases;
+        if (aliases) {
+            const aliasValue = aliases.get(name);
+            if (aliasValue !== undefined) {
+                // Rebuild the command line with the alias expanded
+                const expandedLine = aliasValue + (args.length > 0 ? ' ' + args.join(' ') : '');
+                return this.executeLineWithIo(expandedLine, io);
+            }
+        }
+        // Apply per-command assignments (temporary env)
+        const saved = new Map();
+        for (const assign of cmd.assignments) {
+            if (!saved.has(assign.name))
+                saved.set(assign.name, this.saveVariable(assign.name));
+            if (!await this.applyAssignment(assign, expandCtx)) {
+                (io.stderr ?? this.terminalSink(io)).write(`${assign.name}: readonly variable\n`);
+                return 1;
+            }
+        }
+        // Set up stdout/stderr (per-execution io target, then the terminal sink)
+        let stdout = io.stdout ?? this.terminalSink(io);
+        let stderr = io.stderr ?? this.terminalSink(io);
+        let stdin = io.stdin;
+        const fds = this.createCommandFds(stdout, stderr, stdin, io);
+        try {
+            await this.applyRedirections(cmd.redirections, fds, expandCtx, io, io.terminalStdin);
+        }
+        catch (error) {
+            const redirStderr = fds.outputFds.get(2) ?? stderr;
+            redirStderr.write(error instanceof RedirectionOpenError
+                ? redirectionDiagnostic(error)
+                : `${error instanceof Error ? error.message : String(error)}\n`);
+            this.lastExitCode = 1;
+            return 1;
+        }
+        stdout = fds.outputFds.get(1) ?? this.createNullWriter();
+        stderr = fds.outputFds.get(2) ?? this.createNullWriter();
+        stdin = fds.inputFds.get(0);
+        // If no stdin from pipe or redirect, fall back to terminal stdin
+        if (!stdin && io.terminalStdin) {
+            stdin = io.terminalStdin;
+        }
+        let exitCode;
+        try {
+            // Check for break/continue/return builtins
+            if (name === 'break') {
+                const levels = args[0] ? parseInt(args[0], 10) : 1;
+                throw new BreakSignal(levels);
+            }
+            if (name === 'continue') {
+                const levels = args[0] ? parseInt(args[0], 10) : 1;
+                throw new ContinueSignal(levels);
+            }
+            if (name === 'return') {
+                const code = args[0] ? parseInt(args[0], 10) : this.lastExitCode;
+                throw new ReturnSignal(code);
+            }
+            if (name === 'exec' && args.length === 0) {
+                this.persistFdState(fds);
+                exitCode = 0;
+            }
+            else {
+                // Check functions
+                const funcBody = this.functions.get(name);
+                if (funcBody) {
+                    exitCode = await this.executeFunction(funcBody, args, this.createIoFromFds(io, fds));
+                }
+                else {
+                    // Check builtins
+                    const builtin = this.config.builtins.get(name);
+                    if (builtin) {
+                        const builtinIo = this.createIoFromFds(io, fds);
+                        exitCode = await builtin(args, stdout, stderr, stdin, {
+                            vfs: builtinIo.vfs ?? this.config.vfs,
+                            cwd: this.config.getCwd(),
+                            stdin,
+                            stdout,
+                            stderr,
+                            terminalStdin: io.terminalStdin,
+                            terminalFds: {
+                                stdin: fds.terminalInputFds.has(0),
+                                stdout: fds.terminalOutputFds.has(1),
+                                stderr: fds.terminalOutputFds.has(2),
+                            },
+                            scriptMode: io.scriptMode,
+                            isFdTerminal: (fd) => this.isFdTerminal(fds, fd),
+                            getPositionals: () => this.readPositionals(builtinIo),
+                            setPositionals: (nextArgs) => this.writePositionals(builtinIo, nextArgs),
+                            executeInline: (input, options) => this.executeInline(input, builtinIo, options),
+                            declareLocal: (name) => this.declareLocal(name),
+                        });
+                    }
+                    else {
+                        // Check registry
+                        const command = await this.config.registry.resolve(name);
+                        if (!command) {
+                            stderr.write(`${name}: command not found\n`);
+                            exitCode = 127;
+                        }
+                        else {
+                            const shouldRegister = io.registerProcess !== false;
+                            let pid;
+                            const abortController = new AbortController();
+                            let unlinkShellSignal;
+                            const shellSignal = io.signal ?? this.config.getAbortSignal?.() ?? new AbortController().signal;
+                            unlinkShellSignal = linkAbortSignal(shellSignal, abortController);
+                            const terminalStdin = io.terminalStdin;
+                            const identity = io.commandIdentity;
+                            if (!identity)
+                                throw new Error('shell command identity is unavailable');
+                            let ctx;
+                            ctx = {
+                                ...io.commandContext,
+                                pid: identity.pid,
+                                cred: identity.cred,
+                                args,
+                                env: { ...this.config.env },
+                                cwd: this.config.getCwd(),
+                                vfs: io.vfs ?? this.config.vfs,
+                                stdout,
+                                stderr,
+                                signal: abortController.signal,
+                                stdin,
+                                terminalStdin,
+                                setRawMode: terminalStdin
+                                    ? (v) => { terminalStdin.rawMode = v; }
+                                    : undefined,
+                                getRawMode: terminalStdin
+                                    ? () => terminalStdin.rawMode
+                                    : undefined,
+                                isFdTerminal: (fd) => this.isFdTerminal(fds, fd),
+                                setUmask: identity.setUmask,
+                                runAs: (cred, argv) => io.runAs
+                                    ? io.runAs(ctx, cred, argv)
+                                    : Promise.resolve(126),
+                            };
+                            // Register process BEFORE executing so ps can see itself
+                            let commandPromise;
+                            if (shouldRegister) {
+                                let resolvePromise;
+                                let rejectPromise;
+                                const registeredPromise = new Promise((resolve, reject) => {
+                                    resolvePromise = resolve;
+                                    rejectPromise = reject;
+                                });
+                                pid = this.config.processRegistry.spawn({
+                                    command: name,
+                                    args: [name, ...args],
+                                    cwd: this.config.getCwd(),
+                                    env: { ...this.config.env },
+                                    isForeground: true,
+                                    promise: registeredPromise,
+                                    abortController,
+                                });
+                                commandPromise = command(ctx).then((code) => {
+                                    resolvePromise?.(code);
+                                    return code;
+                                }, (err) => {
+                                    rejectPromise?.(err);
+                                    if (err instanceof Error && err.name === 'AbortError')
+                                        return 130;
+                                    // Surface the failure: this rejection handler resolves
+                                    // commandPromise to an exit code, so the catch below
+                                    // never sees the error — without this write a throwing
+                                    // registered command dies silently at the prompt.
+                                    stderr.write(`${name}: ${err instanceof Error ? err.message : String(err)}\n`);
+                                    return 1;
+                                });
+                            }
+                            else {
+                                commandPromise = command(ctx);
+                            }
+                            try {
+                                exitCode = await commandPromise;
+                            }
+                            catch (e) {
+                                if (e instanceof Error && e.name === 'AbortError') {
+                                    exitCode = 130;
+                                }
+                                else {
+                                    stderr.write(`${name}: ${e instanceof Error ? e.message : String(e)}\n`);
+                                    exitCode = 1;
+                                }
+                            }
+                            finally {
+                                unlinkShellSignal?.();
+                                if (shouldRegister && pid !== undefined) {
+                                    await Promise.resolve();
+                                    this.config.processRegistry.reap(pid);
+                                }
+                            }
+                            // A signalled command reports the SIGNAL's status, not whatever
+                            // code it returned on its way out: `sleep` observes only that
+                            // ctx.signal aborted, and cannot tell SIGINT (130) from
+                            // SIGQUIT (131). The shell holds the reason, so it decides.
+                            const signalledCode = this.abortExitCode(io);
+                            if (signalledCode !== null)
+                                exitCode = signalledCode;
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            this.flushFds(fds);
+            // Restore env from per-command assignments
+            for (const [name, value] of saved)
+                this.restoreVariable(name, value);
+        }
+        const fatalSpecialBuiltin = io.scriptMode === true
+            && exitCode !== 0
+            && isFatalSpecialBuiltin(name);
+        this.lastExitCode = exitCode;
+        if (fatalSpecialBuiltin)
+            throw new ErrexitSignal(exitCode);
+        return exitCode;
+    }
+    assignEnv(name, value) {
+        if (this.config.readonlyNames.has(name))
+            return false;
+        assignScalar(this.config.env, this.config.arrays, name, value);
+        return true;
+    }
+    /**
+     * `name=value`, `name+=value`, `name[expr]=value` and `name=(word …)`.
+     * Returns false when the name is readonly, which the caller reports.
+     */
+    async applyAssignment(assign, ctx) {
+        const { name } = assign;
+        if (this.config.readonlyNames.has(name))
+            return false;
+        if (assign.elements !== undefined) {
+            const values = await expandWords(assign.elements, ctx);
+            const existing = assign.append ? this.config.arrays.get(name) ?? [] : [];
+            delete this.config.env[name];
+            this.config.arrays.set(name, [...existing, ...values]);
+            return true;
+        }
+        const value = await expandWord(assign.value, ctx);
+        if (assign.subscript !== undefined) {
+            const array = this.arrayFor(name);
+            const index = await evaluateSubscript(assign.subscript, array.length, ctx);
+            array[index] = assign.append ? (array[index] ?? '') + value : value;
+            return true;
+        }
+        // A plain assignment to an array name lands on its first element, and
+        // `arr+=x` appends to that element rather than adding one.
+        const array = this.config.arrays.get(name);
+        if (array !== undefined) {
+            array[0] = assign.append ? (array[0] ?? '') + value : value;
+            return true;
+        }
+        this.config.env[name] = assign.append ? (this.config.env[name] ?? '') + value : value;
+        return true;
+    }
+    /** One variable's whole binding, so a scope can put it back exactly. */
+    saveVariable(name) {
+        return { scalar: this.config.env[name], array: this.config.arrays.get(name) };
+    }
+    restoreVariable(name, saved) {
+        if (saved.array === undefined)
+            this.config.arrays.delete(name);
+        else
+            this.config.arrays.set(name, saved.array);
+        if (saved.scalar === undefined)
+            delete this.config.env[name];
+        else
+            this.config.env[name] = saved.scalar;
+    }
+    /** The array behind a subscripted assignment, promoting a scalar if needed. */
+    arrayFor(name) {
+        const existing = this.config.arrays.get(name);
+        if (existing !== undefined)
+            return existing;
+        const scalar = this.config.env[name];
+        const array = scalar === undefined ? [] : [scalar];
+        delete this.config.env[name];
+        this.config.arrays.set(name, array);
+        return array;
+    }
+    async executeFunction(body, args, io) {
+        let exitCode;
+        const functionIo = this.createCommandIo(io);
+        functionIo.positionals = { args: [...args] };
+        this.localFrames.push(new Map());
+        try {
+            exitCode = await this.executeCommand(body, functionIo);
+        }
+        catch (e) {
+            if (e instanceof ReturnSignal) {
+                exitCode = e.exitCode;
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            const frame = this.localFrames.pop();
+            if (frame !== undefined) {
+                for (const [name, saved] of frame)
+                    this.restoreVariable(name, saved);
+            }
+        }
+        this.lastExitCode = exitCode;
+        return exitCode;
+    }
+    /**
+     * Bind a name to the running function, unset, so an assignment to it does
+     * not outlive the call. Shell variables are dynamically scoped, so a callee
+     * still sees its caller's locals — which is what bash does. Returns false
+     * outside a function, where `local` is an error.
+     */
+    declareLocal(name) {
+        const frame = this.localFrames[this.localFrames.length - 1];
+        if (frame === undefined)
+            return false;
+        if (!frame.has(name))
+            frame.set(name, this.saveVariable(name));
+        delete this.config.env[name];
+        this.config.arrays.delete(name);
+        return true;
+    }
+    async executeCapture(input, io = {}) {
+        let captured = '';
+        const stdout = {
+            write: (text) => { captured += text; },
+        };
+        const captureIo = this.createCommandIo(io);
+        captureIo.stdout = stdout;
+        captureIo.positionals = this.forkPositionals(io);
+        const exitCode = await this.executeLineWithIo(input, captureIo);
+        return { output: captured, exitCode };
+    }
+    async executeInline(input, io, options = {}) {
+        const inlineIo = this.createCommandIo(io);
+        if (options.positionals !== undefined) {
+            inlineIo.positionals = { args: [...options.positionals] };
+        }
+        return this.executeLineWithIo(input, inlineIo);
+    }
+    async executeLineWithIo(input, io) {
+        const tokens = lex(input);
+        const script = parse(tokens);
+        return this.executeScriptWithIo(script, io);
+    }
+    async runExitTrap(exitCode, io, enabled) {
+        if (!enabled || this.exitTrapDepth > 0)
+            return exitCode;
+        const action = this.config.traps.get('EXIT');
+        if (action === undefined)
+            return exitCode;
+        const savedLastExitCode = this.lastExitCode;
+        this.lastExitCode = exitCode;
+        this.exitTrapDepth++;
+        try {
+            await this.executeLineWithIo(action, io);
+        }
+        finally {
+            this.exitTrapDepth--;
+            this.lastExitCode = savedLastExitCode;
+        }
+        return exitCode;
+    }
+    createTerminalIo(terminalStdin, terminalFds, scriptMode, stdin) {
+        const io = {};
+        if (stdin)
+            io.stdin = stdin;
+        if (terminalStdin)
+            io.terminalStdin = terminalStdin;
+        if (terminalFds)
+            io.terminalFds = terminalFds;
+        if (scriptMode)
+            io.scriptMode = true;
+        return io;
+    }
+    createCommandIo(io) {
+        const next = {};
+        if (io.stdin)
+            next.stdin = io.stdin;
+        if (io.stdout)
+            next.stdout = io.stdout;
+        if (io.stderr)
+            next.stderr = io.stderr;
+        if (io.writeToTerminal)
+            next.writeToTerminal = io.writeToTerminal;
+        if (io.terminalStdin)
+            next.terminalStdin = io.terminalStdin;
+        if (io.terminalFds)
+            next.terminalFds = io.terminalFds;
+        if (io.scriptMode)
+            next.scriptMode = true;
+        if (io.signal)
+            next.signal = io.signal;
+        if (io.registerProcess === false)
+            next.registerProcess = false;
+        if (io.positionals)
+            next.positionals = io.positionals;
+        if (io.commandContext)
+            next.commandContext = io.commandContext;
+        if (io.commandIdentity)
+            next.commandIdentity = io.commandIdentity;
+        if (io.runAs)
+            next.runAs = io.runAs;
+        if (io.vfs)
+            next.vfs = io.vfs;
+        return next;
+    }
+    /** Per-execution direct-terminal write, isolated from a nested capture. */
+    writeTerminal(io, text) {
+        (io.writeToTerminal ?? this.config.writeToTerminal)(text);
+    }
+    /** Late-bound fallback sink for command stdout/stderr with no fd target. */
+    terminalSink(io) {
+        return { write: (text) => this.writeTerminal(io, text) };
+    }
+    forkPositionals(io) {
+        return { args: [...this.readPositionals(io)] };
+    }
+    createExpandContext(io = {}) {
+        return {
+            env: this.config.env,
+            arrays: this.config.arrays,
+            positionals: this.readPositionals(io),
+            lastExitCode: this.lastExitCode,
+            cwd: this.config.getCwd(),
+            vfs: io.vfs ?? this.config.vfs,
+            options: this.config.options,
+            executeCapture: (input) => this.executeCapture(input, io),
+        };
+    }
+    createIoFromFds(io, fds) {
+        const next = this.createCommandIo(io);
+        next.stdout = fds.outputFds.get(1) ?? this.createNullWriter();
+        next.stderr = fds.outputFds.get(2) ?? this.createNullWriter();
+        const stdin = fds.inputFds.get(0);
+        if (stdin)
+            next.stdin = stdin;
+        else
+            delete next.stdin;
+        next.terminalFds = {
+            stdin: fds.terminalInputFds.has(0),
+            stdout: fds.terminalOutputFds.has(1),
+            stderr: fds.terminalOutputFds.has(2),
+        };
+        return next;
+    }
+    readPositionals(io) {
+        if (io.positionals)
+            return io.positionals.args;
+        const count = Number.parseInt(this.config.env['#'] ?? '0', 10);
+        const args = [];
+        for (let i = 1; i <= count; i++) {
+            args.push(this.config.env[String(i)] ?? '');
+        }
+        return args;
+    }
+    writePositionals(io, args) {
+        if (io.positionals) {
+            io.positionals.args = [...args];
+            return;
+        }
+        for (const key of Object.keys(this.config.env)) {
+            if (key === '@' || key === '#' || /^[1-9][0-9]*$/.test(key)) {
+                delete this.config.env[key];
+            }
+        }
+        this.config.env['#'] = String(args.length);
+        this.config.env['@'] = args.join(' ');
+        for (let i = 0; i < args.length; i++) {
+            this.config.env[String(i + 1)] = args[i];
+        }
+    }
+    createCommandFds(stdout, stderr, stdin, io) {
+        const outputFds = new Map([
+            [1, stdout],
+            [2, stderr],
+            ...this.persistentOutputFds,
+        ]);
+        const inputFds = new Map([
+            [0, stdin],
+            ...this.persistentInputFds,
+        ]);
+        const terminalOutputFds = new Set(this.persistentTerminalOutputFds);
+        setMembership(terminalOutputFds, 1, io.terminalFds?.stdout ?? !io.stdout);
+        setMembership(terminalOutputFds, 2, io.terminalFds?.stderr ?? !io.stderr);
+        const terminalInputFds = new Set(this.persistentTerminalInputFds);
+        setMembership(terminalInputFds, 0, io.terminalFds?.stdin ?? (!stdin && Boolean(io.terminalStdin)));
+        if (io.terminalStdin) {
+            for (const fd of terminalInputFds) {
+                inputFds.set(fd, io.terminalStdin);
+            }
+        }
+        return {
+            outputFds,
+            inputFds,
+            terminalOutputFds,
+            terminalInputFds,
+            changedOutputFds: new Set(),
+            changedInputFds: new Set(),
+        };
+    }
+    async executeWithRedirections(redirections, io, execute) {
+        if (redirections.length === 0) {
+            return execute(io);
+        }
+        const expandCtx = this.createExpandContext(io);
+        const stdout = io.stdout ?? this.terminalSink(io);
+        const stderr = io.stderr ?? this.terminalSink(io);
+        const fds = this.createCommandFds(stdout, stderr, io.stdin, io);
+        try {
+            await this.applyRedirections(redirections, fds, expandCtx, io, io.terminalStdin);
+        }
+        catch (error) {
+            if (!(error instanceof RedirectionOpenError))
+                throw error;
+            const redirStderr = fds.outputFds.get(2) ?? stderr;
+            redirStderr.write(redirectionDiagnostic(error));
+            this.lastExitCode = 1;
+            return 1;
+        }
+        return this.withFdFlush(fds, () => execute(this.createIoFromFds(io, fds)));
+    }
+    async applyRedirections(redirections, fds, expandCtx, io, terminalStdin) {
+        for (const redir of redirections) {
+            if (redir.operator === 'heredoc') {
+                const heredoc = redir.heredoc ?? { body: '', quoted: false, stripTabs: false };
+                const body = heredoc.quoted
+                    ? heredoc.body
+                    : await expandWord([{ text: heredoc.body, quoted: 'double' }], expandCtx);
+                this.setInputFd(fds, redir.fd ?? 0, { stream: this.createStringReader(body), terminal: false });
+                continue;
+            }
+            const target = await expandWord(redir.target, expandCtx);
+            switch (redir.operator) {
+                case 'write':
+                    this.setOutputFd(fds, redir.fd ?? 1, this.openOutputTarget(io, target, 'write', fds, terminalStdin));
+                    break;
+                case 'append':
+                    this.setOutputFd(fds, redir.fd ?? 1, this.openOutputTarget(io, target, 'append', fds, terminalStdin));
+                    break;
+                case 'read':
+                    this.setInputFd(fds, redir.fd ?? 0, this.openInputTarget(io, target, fds, terminalStdin));
+                    break;
+                case 'readWrite': {
+                    const fd = redir.fd ?? 0;
+                    this.setInputFd(fds, fd, this.openInputTarget(io, target, fds, terminalStdin));
+                    this.setOutputFd(fds, fd, this.openOutputTarget(io, target, 'append', fds, terminalStdin));
+                    break;
+                }
+                case 'writeAll': {
+                    const writer = this.openOutputTarget(io, target, 'write', fds, terminalStdin);
+                    this.setOutputFd(fds, 1, writer);
+                    this.setOutputFd(fds, 2, writer);
+                    break;
+                }
+                case 'dupOutput':
+                    this.dupOutputFd(fds, redir.fd ?? 1, target);
+                    break;
+                case 'dupInput':
+                    this.dupInputFd(fds, redir.fd ?? 0, target);
+                    break;
+            }
+        }
+    }
+    persistFdState(fds) {
+        for (const fd of fds.changedOutputFds) {
+            const stream = fds.outputFds.get(fd);
+            if (stream)
+                this.persistentOutputFds.set(fd, stream);
+            else
+                this.persistentOutputFds.delete(fd);
+            if (fds.terminalOutputFds.has(fd))
+                this.persistentTerminalOutputFds.add(fd);
+            else
+                this.persistentTerminalOutputFds.delete(fd);
+        }
+        for (const fd of fds.changedInputFds) {
+            const isTerminal = fds.terminalInputFds.has(fd);
+            if (fds.inputFds.has(fd)) {
+                this.persistentInputFds.set(fd, isTerminal ? undefined : fds.inputFds.get(fd));
+            }
+            else {
+                this.persistentInputFds.delete(fd);
+            }
+            if (isTerminal)
+                this.persistentTerminalInputFds.add(fd);
+            else
+                this.persistentTerminalInputFds.delete(fd);
+        }
+    }
+    setOutputFd(fds, fd, target) {
+        fds.outputFds.set(fd, target.stream);
+        setMembership(fds.terminalOutputFds, fd, target.terminal);
+        fds.changedOutputFds.add(fd);
+    }
+    setInputFd(fds, fd, target) {
+        fds.inputFds.set(fd, target.stream);
+        setMembership(fds.terminalInputFds, fd, target.terminal);
+        fds.changedInputFds.add(fd);
+    }
+    dupOutputFd(fds, fd, target) {
+        fds.changedOutputFds.add(fd);
+        if (target === '-') {
+            fds.outputFds.delete(fd);
+            fds.terminalOutputFds.delete(fd);
+            return;
+        }
+        const resolved = this.resolveOutputFd(target, fds.outputFds, fds.terminalOutputFds);
+        fds.outputFds.set(fd, resolved.stream);
+        setMembership(fds.terminalOutputFds, fd, resolved.terminal);
+    }
+    dupInputFd(fds, fd, target) {
+        fds.changedInputFds.add(fd);
+        if (target === '-') {
+            fds.inputFds.delete(fd);
+            fds.terminalInputFds.delete(fd);
+            return;
+        }
+        const resolved = this.resolveInputFd(target, fds.inputFds, fds.terminalInputFds);
+        fds.inputFds.set(fd, resolved.stream);
+        setMembership(fds.terminalInputFds, fd, resolved.terminal);
+    }
+    openOutputTarget(io, target, mode, fds, terminalStdin) {
+        if (target === '/dev/null')
+            return { stream: this.createNullWriter(), terminal: false };
+        if (target === '/dev/tty') {
+            if (!terminalStdin)
+                throw new Error('/dev/tty: no controlling terminal');
+            return { stream: this.terminalSink(io), terminal: true };
+        }
+        // /dev/stdout and /dev/stderr name the process's own descriptors, not
+        // files. Writing them into the device provider would silently discard.
+        if (target === '/dev/stdout')
+            return this.resolveOutputFd('1', fds.outputFds, fds.terminalOutputFds);
+        if (target === '/dev/stderr')
+            return this.resolveOutputFd('2', fds.outputFds, fds.terminalOutputFds);
+        const targetPath = resolve(this.config.getCwd(), target);
+        const vfs = io.vfs ?? this.config.vfs;
+        try {
+            if (mode === 'write') {
+                vfs.writeFile(targetPath, '');
+                return { stream: this.createFileWriter(vfs, targetPath, 'truncate'), terminal: false };
+            }
+            if (vfs.exists(targetPath)) {
+                if (vfs.stat(targetPath).type === 'directory') {
+                    throw Object.assign(new Error(`EISDIR: ${targetPath}`), { code: 'EISDIR' });
+                }
+                vfs.access(targetPath, 0o2);
+            }
+            else {
+                vfs.writeFile(targetPath, '');
+            }
+            return { stream: this.createFileWriter(vfs, targetPath, 'append'), terminal: false };
+        }
+        catch (error) {
+            throw new RedirectionOpenError(target, error);
+        }
+    }
+    openInputTarget(io, target, fds, terminalStdin) {
+        if (target === '/dev/null')
+            return { stream: this.createEmptyReader(), terminal: false };
+        if (target === '/dev/tty') {
+            if (!terminalStdin)
+                throw new Error('/dev/tty: no controlling terminal');
+            return { stream: terminalStdin, terminal: true };
+        }
+        if (target === '/dev/stdin')
+            return this.resolveInputFd('0', fds.inputFds, fds.terminalInputFds);
+        try {
+            return {
+                stream: this.createFileReader(io.vfs ?? this.config.vfs, resolve(this.config.getCwd(), target)),
+                terminal: false,
+            };
+        }
+        catch (error) {
+            throw new RedirectionOpenError(target, error);
+        }
+    }
+    /**
+     * A file-backed descriptor: an open file plus a write offset.
+     *
+     * Each write lands at the offset and advances it, the way write(2) does.
+     * Restating the whole file per write — which is what this used to do —
+     * makes every multi-write producer (`cat a b c`, a streaming `curl`, any
+     * line-at-a-time filter) persist only its final write and silently drop
+     * everything before it.
+     *
+     * Writes buffer to a block, as stdio does, so a line-at-a-time producer
+     * costs one store write per block rather than one per line. `mode`
+     * distinguishes `>` (a plain offset from the truncation point) from `>>`,
+     * which is O_APPEND: every block lands at whatever the current end is, so
+     * two descriptors appending to one file cannot overwrite each other.
+     */
+    createFileWriter(vfs, path, mode) {
+        let offset = 0;
+        let pending = [];
+        let pendingBytes = 0;
+        const endOfFile = () => (vfs.exists(path) ? vfs.stat(path).size : 0);
+        const flush = () => {
+            if (pendingBytes === 0)
+                return;
+            const block = pending.length === 1 ? pending[0] : concatBytes(pending, pendingBytes);
+            pending = [];
+            pendingBytes = 0;
+            const at = mode === 'append' ? endOfFile() : offset;
+            vfs.writeRange(path, at, block);
+            offset = at + block.length;
+        };
+        const push = (bytes) => {
+            if (bytes.length === 0)
+                return;
+            pending.push(bytes);
+            pendingBytes += bytes.length;
+            if (pendingBytes >= FILE_WRITE_BLOCK_BYTES)
+                flush();
+        };
+        return {
+            write: (text) => push(encode(text)),
+            writeBytes: (bytes) => push(bytes),
+            flush,
+        };
+    }
+    /**
+     * Run `body` and commit every file-backed descriptor it wrote through,
+     * whether it returned or threw. This is the close(2) side of the buffering
+     * in createFileWriter: buffered bytes must reach the store before the next
+     * command can read the file.
+     */
+    async withFdFlush(fds, body) {
+        try {
+            return await body();
+        }
+        finally {
+            this.flushFds(fds);
+        }
+    }
+    flushFds(fds) {
+        for (const stream of fds.outputFds.values())
+            stream.flush?.();
+    }
+    createFileReader(vfs, path) {
+        const content = vfs.readFileString(path);
+        return this.createStringReader(content);
+    }
+    createStringReader(content) {
+        let offset = 0;
+        return {
+            read: async () => {
+                if (offset >= content.length)
+                    return null;
+                const chunk = content.slice(offset);
+                offset = content.length;
+                return chunk;
+            },
+            readAll: async () => {
+                if (offset >= content.length)
+                    return '';
+                const chunk = content.slice(offset);
+                offset = content.length;
+                return chunk;
+            },
+            readLine: async () => {
+                if (offset >= content.length)
+                    return null;
+                const newline = content.indexOf('\n', offset);
+                if (newline < 0) {
+                    const line = content.slice(offset);
+                    offset = content.length;
+                    return line;
+                }
+                const line = content.slice(offset, newline);
+                offset = newline + 1;
+                return line;
+            },
+        };
+    }
+    resolveOutputFd(target, outputFds, terminalOutputFds) {
+        if (target === '-')
+            return { stream: this.createNullWriter(), terminal: false };
+        const fd = this.parseFdTarget(target);
+        const stream = outputFds.get(fd);
+        if (!stream)
+            throw new Error(`bad output file descriptor: ${target}`);
+        return { stream, terminal: terminalOutputFds.has(fd) };
+    }
+    resolveInputFd(target, inputFds, terminalInputFds) {
+        if (target === '-')
+            return { stream: this.createEmptyReader(), terminal: false };
+        const fd = this.parseFdTarget(target);
+        if (!inputFds.has(fd))
+            throw new Error(`bad input file descriptor: ${target}`);
+        return { stream: inputFds.get(fd), terminal: terminalInputFds.has(fd) };
+    }
+    parseFdTarget(target) {
+        if (!isDecimalInteger(target))
+            throw new Error(`bad file descriptor: ${target}`);
+        return Number.parseInt(target, 10);
+    }
+    createNullWriter() {
+        return { write: () => { }, writeBytes: () => { } };
+    }
+    createEmptyReader() {
+        return { read: async () => null, readAll: async () => '', readLine: async () => null };
+    }
+    isFdTerminal(fds, fd) {
+        if (fd === 0)
+            return fds.terminalInputFds.has(fd);
+        return fds.terminalOutputFds.has(fd);
+    }
+    enforceErrexit(connector, exitCode) {
+        if (!this.config.options.errexit)
+            return;
+        if (this.errexitSuppressionDepth > 0)
+            return;
+        if (exitCode === 0)
+            return;
+        if (connector === '&&' || connector === '||')
+            return;
+        throw new ErrexitSignal(exitCode);
+    }
+    async withErrexitSuppressed(fn) {
+        this.errexitSuppressionDepth++;
+        try {
+            return await fn();
+        }
+        finally {
+            this.errexitSuppressionDepth--;
+        }
+    }
+    abortExitCode(io) {
+        const signal = io.signal ?? this.config.getAbortSignal?.();
+        return signal?.aborted ? exitCodeForAbortSignal(signal) : null;
+    }
+}
+function setMembership(set, value, present) {
+    if (present)
+        set.add(value);
+    else
+        set.delete(value);
+}
+function isDecimalInteger(value) {
+    if (value.length === 0)
+        return false;
+    for (let i = 0; i < value.length; i++) {
+        const code = value.charCodeAt(i);
+        if (code < 48 || code > 57)
+            return false;
+    }
+    return true;
+}
+function isFatalSpecialBuiltin(name) {
+    switch (name) {
+        case ':':
+        case '.':
+        case 'break':
+        case 'continue':
+        case 'eval':
+        case 'exec':
+        case 'exit':
+        case 'export':
+        case 'readonly':
+        case 'return':
+        case 'set':
+        case 'shift':
+        case 'times':
+        case 'trap':
+        case 'unset':
+            return true;
+        default:
+            return false;
+    }
+}
+function linkAbortSignal(parent, child) {
+    if (parent.aborted) {
+        child.abort(parent.reason);
+        return () => { };
+    }
+    const onAbort = () => child.abort(parent.reason);
+    parent.addEventListener('abort', onAbort, { once: true });
+    return () => parent.removeEventListener('abort', onAbort);
+}