@poe-platform/safe-bash 0.1.145 → 0.1.147

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

@@ -3,12 +3,13 @@ import { ACCESS_MODES, FsError, composeMiddleware, createBytePipe, pipeBytes, re
 import { concatShellValues, shellValueByteLength, shellValueBytes, shellValueFromBytes, shellValueText } from "../contracts/value.js";
 import { createCommandArguments, getCommandArguments } from "../contracts/command.js";
 import { ValueArena } from "./value-state.js";
-import { HereDocumentSyntaxError, hereDocumentWords, parseShellInputUnit, parseShellUnit } from "./parser.js";
+import { compoundEntryWords, HereDocumentSyntaxError, hereDocumentWords, parseShellInputUnit, parseShellUnit } from "./parser.js";
 import { SourceLineIndex } from "./source-line-index.js";
 import { ShellLimitError, ShellSyntaxError } from "./types.js";
 import { fileInput, ShellInput } from "./input.js";
 import { evaluateArithmetic, prepareArithmetic } from "./arithmetic.js";
 import { defaultMaxParseUnits, ParseBudget } from "./parse-budget.js";
+import { BraceExpansionFailure, expandBraces } from "./brace-expansion.js";
 import { evaluatePositionalArithmetic } from "./arithmetic-parameters.js";
 import { compilePattern, matchesPattern } from "./pattern.js";
 import { nextCodePointOffset, previousCodePointOffset, scanString, stringCheckpoint } from "./string-operations.js";
@@ -19,6 +20,8 @@ import { invocationScope, throwCleanupFailures } from "./cleanup.js";
 import { bindFileOutputBudget, openFileOutput } from "../contracts/filesystem-output.js";
 import { outputFailure } from "../contracts/io.js";
 import { executionCommands } from "../commands/execution.js";
+import { formatPrintf, printfCommand } from "../commands/basic.js";
+import { UsageError } from "../commands/internal.js";
 import { cloneGetoptsState, createGetoptsState, GetoptsError, scanGetopts, withGetoptsIndex } from "./getopts.js";
 import { activateChildCancellation, prepareChildCancellation, selectRuntimeCancellationOutcome, subscribeCancellation, } from "./cancellation.js";
 import { getArrayAssignment, getArraySelector, copyArraySelector, numericIndex, literalIndex, isQuoteMarker } from "./arrays/syntax.js";
@@ -53,7 +56,7 @@ const shellBuiltinNames = new Set([
 const implementedBuiltins = new Set([...shellBuiltinNames].filter(name => !["echo", "printf", "test", "["].includes(name)));
 const specialBuiltinNames = new Set([":", ".", "break", "continue", "eval", "exit", "export", "readonly", "return", "set", "shift", "unset"]);
 const unsupportedSetOptionNames = new Set([
-    "allexport", "braceexpand", "emacs", "errtrace", "functrace", "hashall", "histexpand", "history",
+    "allexport", "emacs", "errtrace", "functrace", "hashall", "histexpand", "history",
     "ignoreeof", "interactive-comments", "keyword", "monitor", "noclobber", "noexec", "noglob", "nolog",
     "notify", "onecmd", "physical", "posix", "privileged", "verbose", "vi", "xtrace",
 ]);
@@ -339,7 +342,7 @@ function signalSink(sink, signal) {
         budgetedSinks.set(output, { budget: owned.budget, write: output.write });
     return output;
 }
-async function cloneState(state, signal, scope) {
+async function cloneState(state, signal, scope, inheritLocals = true) {
     const destination = await snapshotState(state, () => ({
         ...state,
         variables: Object.assign(Object.create(null), state.variables),
@@ -347,7 +350,7 @@ async function cloneState(state, signal, scope) {
         readonlyVariables: new Set(state.readonlyVariables),
         getopts: cloneGetoptsBinding(state),
         directoryStack: { entries: [...state.directoryStack?.entries ?? []], bytes: state.directoryStack?.bytes ?? 0 },
-        locals: scope ? [] : state.locals.map((scope) => new Map([...scope].map(([name, saved]) => [name, { ...saved, ...(saved.getopts ? { getopts: { integer: saved.getopts.integer, cursor: cloneGetoptsState(saved.getopts.cursor) } } : {}) }]))),
+        locals: inheritLocals ? state.locals.map((scope) => new Map([...scope].map(([name, saved]) => [name, { ...saved, ...(saved.getopts ? { getopts: { integer: saved.getopts.integer, cursor: cloneGetoptsState(saved.getopts.cursor) } } : {}) }]))) : [],
     }), signal, async (destination, owner) => {
         const store = arrayStore(destination) ?? requireArrays(destination);
         for (let index = 0; index < destination.locals.length; index++) {
@@ -361,14 +364,19 @@ async function cloneState(state, signal, scope) {
                         throw new ArrayFailure("stale state snapshot");
                     const savedOwner = ArrayOwner.create(owner.ledger, owner);
                     let binding;
+                    let releaseBinding;
                     try {
+                        scope?.register(async () => { await savedOwner.completion; await releaseBinding; });
                         const watch = await store.watch(name, savedOwner, signal);
                         const tickets = savedOwner.reserve({ generation: true, version: true, epoch: true, slots: 1, metadata: 64, work: 14 });
                         const token = await textToken(savedOwner, name, signal);
                         const admission = savedOwner.reserve({ slots: 1, metadata: 32, work: 5 });
                         binding = typed.binding?.retain();
                         typedSavedVariables.set(copied, { owner: savedOwner, binding, tickets, prepared: { name: token, admission }, watch, scalarLegacy: typed.scalarLegacy });
-                        tickets.cleanup = () => { typedSavedVariables.delete(copied); };
+                        tickets.cleanup = () => {
+                            if (typedSavedVariables.delete(copied) && scope)
+                                releaseBinding = scope.cleanup(async () => { await binding?.release(); });
+                        };
                     }
                     catch (error) {
                         await binding?.release();
@@ -1693,6 +1701,22 @@ export class Runtime {
             }
             else
                 for (const entry of assignment.entries) {
+                    const original = compoundEntryWords.get(entry);
+                    if (entry.index && original && state.braceexpand !== false && original.parts.some(part => part.kind === "text" && !part.quoted && part.value.includes("{"))) {
+                        let expandedEntry = false;
+                        for await (const expanded of expandBraces(original, this.budget, this.signal)) {
+                            if (expanded === original)
+                                break;
+                            expandedEntry = true;
+                            const values = await this.valueWord(expanded, state, io, true, false, false, false, undefined, false);
+                            for (const value of values) {
+                                await insert(cursor, shellValueText(value));
+                                cursor++;
+                            }
+                        }
+                        if (expandedEntry)
+                            continue;
+                    }
                     const fields = await this.word(entry.value, state, io, entry.index === undefined);
                     if (entry.index) {
                         const index = numericIndex(entry.index);
@@ -2002,6 +2026,8 @@ export class Runtime {
         originalIO = { ...originalIO, [valueScope]: allocation };
         let io = originalIO;
         let diagnosticFailure;
+        let snapshotScope;
+        let finishSnapshot;
         try {
             const execute = async () => {
                 if (command.kind === "function") {
@@ -2013,7 +2039,11 @@ export class Runtime {
                     return 0;
                 }
                 if (command.kind === "simple")
-                    return await this.simple(command, state, originalIO, inputs, outputs, fileShortcut);
+                    return await this.simple(command, state, originalIO, inputs, outputs, () => {
+                        snapshotScope = originalIO[invocationScope].child();
+                        void snapshotScope.run(() => new Promise(resolve => { finishSnapshot = resolve; }));
+                        return snapshotScope;
+                    }, fileShortcut);
                 io = await this.redirect(command.redirects, state, io, inputs, outputs, command.kind === "subshell", command.kind !== "subshell");
                 if (command.kind === "conditional") {
                     try {
@@ -2023,7 +2053,7 @@ export class Runtime {
                             work: { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") },
                             expand: async (word, pattern = false) => (await this.word(word, state, io, false, pattern, false, pattern)).join(""),
                             regex: (subject, pattern) => this.ere(subject, pattern, state, io),
-                            option: name => name === "errexit" ? !!state.errexit : name === "nounset" ? !!state.nounset : name === "pipefail" ? state.pipefail : false,
+                            option: name => name === "braceexpand" ? state.braceexpand !== false : name === "errexit" ? !!state.errexit : name === "nounset" ? !!state.nounset : name === "pipefail" ? state.pipefail : false,
                             present: name => {
                                 const match = /^([a-zA-Z_][a-zA-Z_0-9]*)(?:\[(0|[1-9][0-9]*|[@*])\])?$/u.exec(name);
                                 if (!match)
@@ -2230,7 +2260,7 @@ export class Runtime {
                     this.signal.throwIfAborted();
                 }
             }
-            if (error instanceof ExpansionFailure)
+            if (error instanceof ExpansionFailure || error instanceof BraceExpansionFailure)
                 throw completedExit(error instanceof ParameterExpansionFailure && !state.isolated ? 127 : 1);
             if (error instanceof FatalCommandFailure)
                 throw completedExit(error.status);
@@ -2240,16 +2270,22 @@ export class Runtime {
             return status;
         }
         finally {
-            await Promise.allSettled([
-                ...[...outputs].map(async (close) => close({ reason: new FsError("ECANCELED", { syscall: "redirect" }) })),
-                ...[...inputs].map(async (input) => input.close()),
-            ]).then(results => {
-                const failures = results.filter(result => result.status === "rejected").map(result => result.reason);
-                if (diagnosticFailure)
-                    io[invocationScope].failures.push(...failures);
-                else
-                    throwCleanupFailures(failures);
-            }).finally(() => allocation.close());
+            try {
+                await Promise.allSettled([
+                    ...[...outputs].map(async (close) => close({ reason: new FsError("ECANCELED", { syscall: "redirect" }) })),
+                    ...[...inputs].map(async (input) => input.close()),
+                ]).then(results => {
+                    const failures = results.filter(result => result.status === "rejected").map(result => result.reason);
+                    if (diagnosticFailure)
+                        io[invocationScope].failures.push(...failures);
+                    else
+                        throwCleanupFailures(failures);
+                }).finally(() => allocation.close());
+            }
+            finally {
+                finishSnapshot?.();
+                await snapshotScope?.close();
+            }
         }
     }
     async loopBody(body, state, io) {
@@ -2535,7 +2571,7 @@ export class Runtime {
             return undefined;
         return { name: match[1], append: match[2] === "+", value: { offset: word.offset, parts: [{ ...first, value: first.value.slice(match[0].length) }, ...word.parts.slice(1)] } };
     }
-    async simple(command, state, originalIO, inputs, outputs, fileShortcut = false) {
+    async simple(command, state, originalIO, inputs, outputs, createSnapshotScope, fileShortcut = false) {
         state.substitutionStatus = 0;
         const assignments = [];
         let wordIndex = 0;
@@ -2558,9 +2594,8 @@ export class Runtime {
         const inlineInput = command.redirects.some((redirect) => redirect.document || redirect.operator === "<<<");
         const functionCommand = words.length > 0 && state.functions.has(words[0]);
         const isolatedInlineInput = inlineInput && words.length > 0 && !shellBuiltinNames.has(words[0]) && !functionCommand;
-        if (isolatedInlineInput)
-            state = await cloneState(state, this.signal);
-        let io = originalIO;
+        const snapshotScope = isolatedInlineInput ? createSnapshotScope() : undefined;
+        let io = snapshotScope ? { ...originalIO, [invocationScope]: snapshotScope } : originalIO;
         const previous = new Map();
         const assign = async () => {
             for (const assignment of assignments) {
@@ -2599,9 +2634,14 @@ export class Runtime {
                     state.exported.add(assignment.name);
             }
         };
-        if (words.length)
-            stateMonitor(state)?.openOverlay(previous);
+        let overlayOpen = false;
         try {
+            if (snapshotScope)
+                state = await cloneState(state, this.signal, snapshotScope);
+            if (words.length) {
+                stateMonitor(state)?.openOverlay(previous);
+                overlayOpen = true;
+            }
             if (inlineInput || (state.profile === "sh" || !words.length) && assignments.some(assignment => state.readonlyVariables?.has(assignment.name)))
                 await assign();
             if (inlineInput && functionCommand && previous.size) {
@@ -2706,7 +2746,7 @@ export class Runtime {
             throw new ExecutionFailure(error, io);
         }
         finally {
-            if (words.length) {
+            if (overlayOpen) {
                 for (const [key, saved] of previous)
                     await originalIO[invocationScope].cleanup(async () => {
                         if (saved.superseded)
@@ -2719,8 +2759,6 @@ export class Runtime {
             else
                 for (const saved of previous.values())
                     saved.heldValue?.release();
-            if (isolatedInlineInput)
-                stateMonitor(state)?.closeValues();
         }
     }
     async dispatch(name, args, state, io, assignments, bypassFunctions = false, values = args) {
@@ -2972,6 +3010,9 @@ export class Runtime {
                     }
                 }
                 const definition = this.commands.get(context.command);
+                if (context.command === "printf" && definition?.execute === printfCommand.execute && context.args[0]?.startsWith("-v")) {
+                    return { exitCode: await this.printfVariable(context, state, assignments) };
+                }
                 if (!definition) {
                     if (context.command === "bash" || context.command === "sh")
                         return { exitCode: await this.interpreter(context, state, io) };
@@ -3228,21 +3269,30 @@ export class Runtime {
         let commandString = false;
         let standardInput = false;
         let errexit = false;
+        let braceexpand = true;
         while (args.length && /^[+-]/u.test(args[0])) {
             const option = args.shift();
             if (option === "--" || option === "-")
                 break;
-            if (!/^-[cse]+$|^\+e+$/u.test(option)) {
-                await writeText(context.stderr, `${context.command}: ${option}: unsupported option; supported flags are -c, -s, -e and +e\n`);
+            if ((option === "-o" || option === "+o") && args[0] === "braceexpand") {
+                braceexpand = option === "-o";
+                args.shift();
+                continue;
+            }
+            const flags = option.slice(1);
+            if (!flags.length || [...flags].some(flag => !(option[0] === "-" ? "cseB" : "eB").includes(flag))) {
+                await writeText(context.stderr, `${context.command}: ${option}: unsupported option; supported flags are -c, -s, -e, +e, -B, +B and +/-o braceexpand\n`);
                 return 2;
             }
             commandString ||= option.includes("c");
             standardInput ||= option.includes("s");
             if (option.includes("e"))
                 errexit = option.startsWith("-");
+            if (option.includes("B"))
+                braceexpand = option.startsWith("-");
         }
         if (!commandString && !standardInput && args.length)
-            return this.scriptFile(context, state, io, args[0], args.slice(1), false, errexit, loadedSource);
+            return this.scriptFile(context, state, io, args[0], args.slice(1), false, errexit, loadedSource, braceexpand);
         const source = commandString ? args.shift() : undefined;
         if (commandString && source === undefined) {
             await writeText(context.stderr, `${context.command}: -c: option requires an argument\n`);
@@ -3251,6 +3301,7 @@ export class Runtime {
         const arg0 = commandString ? args.shift() ?? context.command : context.command;
         const child = this.processState(context, state, arg0, args);
         child.errexit = errexit;
+        child.braceexpand = braceexpand;
         const childIO = isolateIO({ ...io, ...context, execution: { ignoreErrexit: false }, diagnosticLine: 1, diagnosticOffset: 0, scriptName: arg0 });
         if (source !== undefined) {
             this.budget.source(Buffer.byteLength(source));
@@ -3542,7 +3593,7 @@ export class Runtime {
             return { exitCode: validateExitCode(result.exitCode) };
         }, (runtime, forwarded, child, childIO) => (command, arguments_, options = {}) => runtime.shebangTarget(forwarded, child, childIO, command, arguments_, options, target, loadedSource));
     }
-    async scriptFile(context, state, io, target, args, direct, errexit = false, loadedSource) {
+    async scriptFile(context, state, io, target, args, direct, errexit = false, loadedSource, braceexpand = true) {
         if (target === "")
             throw new CommandFailure(`${context.command}: : No such file or directory`, 127);
         if (state.depth >= this.budget.limits.maxSubstitutionDepth)
@@ -3612,6 +3663,7 @@ export class Runtime {
         }
         const child = this.processState(context, state, target, args);
         child.errexit = errexit;
+        child.braceexpand = braceexpand;
         if (direct)
             child.profile = interpreterProfile ?? state.profile ?? "bash";
         const childIO = isolateIO({ ...io, ...context, execution: { ignoreErrexit: false }, diagnosticLine: 1, diagnosticOffset: 0, scriptName: target });
@@ -3850,7 +3902,7 @@ export class Runtime {
         const allocation = this.budget.values.scope();
         scope.register(() => allocation.close());
         const carrier = this.admitArguments(getCommandArguments({ args, ...(options.argumentValues ? { argumentValues: options.argumentValues } : {}) }).values, allocation);
-        const child = await cloneState(state, this.signal, scope);
+        const child = await cloneState(state, this.signal, scope, false);
         child.cwd = resolvePath(context.cwd, options.cwd ?? ".");
         const env = options.replaceEnv ? { ...options.env } : { ...context.env, ...options.env, PWD: child.cwd };
         if (guestArrays(child) || Object.keys(env).some(key => arrayStore(child)?.get(key)))
@@ -3927,10 +3979,12 @@ export class Runtime {
                     state.errexit = enabled;
                 else if (flag === "u")
                     state.nounset = enabled;
+                else if (flag === "B")
+                    state.braceexpand = enabled;
                 else if (flag === "o" && position === option.length - 1) {
                     const name = args[index + 1];
                     if (name === undefined) {
-                        const options = [["errexit", !!state.errexit], ["nounset", !!state.nounset], ["pipefail", state.pipefail]];
+                        const options = [["braceexpand", state.braceexpand !== false], ["errexit", !!state.errexit], ["nounset", !!state.nounset], ["pipefail", state.pipefail]];
                         for (const [name, active] of options)
                             await writeText(stdout, enabled ? `${name}\t${active ? "on" : "off"}\n` : `set ${active ? "-" : "+"}o ${name}\n`);
                     }
@@ -3941,6 +3995,8 @@ export class Runtime {
                             state.nounset = enabled;
                         else if (name === "pipefail")
                             state.pipefail = enabled;
+                        else if (name === "braceexpand")
+                            state.braceexpand = enabled;
                         else {
                             const unsupported = unsupportedSetOptionNames.has(name);
                             await this.diagnostic(context, `set: ${name}: ${unsupported ? "unsupported shell option" : "invalid option name"}`);
@@ -3953,7 +4009,7 @@ export class Runtime {
                     valid = false;
             }
             if (!valid) {
-                await writeText(stderr, "set: unsupported shell option; supported forms are +/- e/u clusters, -- arguments and terminal o with pipefail, errexit or nounset\n");
+                await writeText(stderr, "set: unsupported shell option; supported forms are +/- e/u/B clusters, -- arguments and terminal o with braceexpand, pipefail, errexit or nounset\n");
                 return 1;
             }
             index++;
@@ -4365,6 +4421,131 @@ export class Runtime {
         }
         return status;
     }
+    async printfVariable(context, state, assignments) {
+        const incoming = getCommandArguments(context);
+        let offset = 0;
+        let name = "";
+        let index;
+        while (incoming.args[offset]?.startsWith("-v")) {
+            const option = incoming.args[offset++];
+            const target = option.slice(2) || incoming.args[offset++];
+            if (target === undefined) {
+                await writeText(context.stderr, "printf: -v: option requires an argument\n");
+                return 2;
+            }
+            const bracket = target.indexOf("[");
+            name = bracket < 0 ? target : target.slice(0, bracket);
+            if (!/^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(name) || bracket >= 0 && !target.endsWith("]")) {
+                await writeText(context.stderr, `printf: '${target}': not a valid identifier\n`);
+                return 2;
+            }
+            index = undefined;
+            if (bracket >= 0) {
+                if (target[bracket + 1] === "'" || target[bracket + 1] === '"') {
+                    await writeText(context.stderr, `printf: '${target}': unsupported indexed-array subscript\n`);
+                    return 2;
+                }
+                try {
+                    index = literalIndex(target.slice(bracket + 1, -1), 0, this.budget.parsing);
+                }
+                catch (error) {
+                    this.signal.throwIfAborted();
+                    if (!(error instanceof ShellSyntaxError))
+                        throw error;
+                    await writeText(context.stderr, `printf: '${target}': unsupported indexed-array subscript\n`);
+                    return 2;
+                }
+                if (numericIndex(index) === undefined) {
+                    await writeText(context.stderr, "printf: index outside 0..2147483647\n");
+                    return 2;
+                }
+            }
+        }
+        const arguments_ = incoming.slice(offset);
+        const format = arguments_.args[0] === "--" ? arguments_.args[1] : arguments_.args[0];
+        if (format === undefined || arguments_.args[0] !== "--" && format.startsWith("-")) {
+            await writeText(context.stderr, "printf: usage: printf [-v var] format [arguments]\n");
+            return 2;
+        }
+        const allocation = this.budget.values.scope();
+        context[invocationScope].register(() => allocation.close());
+        const chunks = [];
+        let length = 0;
+        let terminated = false;
+        const stdout = { write: async (chunk) => {
+                this.budget.cpuCheckpoint();
+                if (chunk.byteLength > this.budget.limits.maxExpansionBytes - length)
+                    this.budget.fail("maxExpansionBytes");
+                length += chunk.byteLength;
+                if (terminated || !chunk.byteLength)
+                    return;
+                const nul = chunk.indexOf(0);
+                const bytes = nul < 0 ? chunk : chunk.subarray(0, nul);
+                if (bytes.byteLength)
+                    chunks.push(shellValueFromBytes(bytes, allocation));
+                terminated = nul >= 0;
+            } };
+        try {
+            let status;
+            try {
+                status = (await formatPrintf({ ...context, args: arguments_.args, argumentValues: arguments_, stdout })).exitCode;
+            }
+            catch (error) {
+                this.signal.throwIfAborted();
+                if (!(error instanceof UsageError))
+                    throw error;
+                await writeText(context.stderr, `printf: ${error.message}\n`);
+                status = 1;
+            }
+            const value = concatShellValues(chunks, allocation);
+            this.signal.throwIfAborted();
+            if (state.readonlyVariables?.has(name)) {
+                await writeText(context.stderr, `printf: ${name}: readonly variable\n`);
+                return 1;
+            }
+            if (index || arrayStore(state)?.get(name)) {
+                const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+                const decode = (bytes) => {
+                    try {
+                        return decoder.decode(bytes);
+                    }
+                    catch (error) {
+                        this.signal.throwIfAborted();
+                        if (!(error instanceof TypeError))
+                            throw error;
+                        return undefined;
+                    }
+                };
+                let text = decode(shellValueBytes(value, allocation));
+                if (text !== undefined && index && numericIndex(index) !== 0 && !arrayStore(state)?.get(name) && state.variables[name] !== undefined) {
+                    const previous = stateMonitor(state).values.get(name, state.variables[name]);
+                    if (decode(shellValueBytes(previous, allocation)) === undefined)
+                        text = undefined;
+                }
+                if (text === undefined) {
+                    await writeText(context.stderr, "printf: indexed variables do not support non-UTF-8 bytes\n");
+                    return 1;
+                }
+                if (index)
+                    await this.arrayAssignment({ kind: "element", name, index, append: false, value: { offset: 0, parts: [{ kind: "text", value: text, quoted: true }] } }, state, context);
+                else
+                    await this.assignVariable(state, name, text);
+            }
+            else
+                this.writeVariable(state, name, value);
+            const previous = assignments.get(name);
+            if (previous) {
+                if (!previous.exported)
+                    state.exported.delete(name);
+                await this.discardVariable(previous);
+                assignments.delete(name);
+            }
+            return status;
+        }
+        finally {
+            allocation.close();
+        }
+    }
     async builtin(context, state, assignments, diagnose, suppressSpecial = false) {
         const { command, args, stdout, stderr } = context;
         if (command === ":" || command === "true")
@@ -4921,9 +5102,11 @@ export class Runtime {
     async valueWords(words, state, io, declaration = false) {
         const fields = [];
         for (const word of words) {
-            fields.push(...await this.valueWord(word, state, io, !(declaration && this.assignment(word))));
-            if (fields.length > this.budget.limits.maxExpansionFields)
+            const values = await this.valueWord(word, state, io, !(declaration && this.assignment(word)), false, false, false, undefined, true);
+            if (values.length > this.budget.limits.maxExpansionFields - fields.length)
                 this.budget.fail("maxExpansionFields");
+            for (const value of values)
+                fields.push(value);
         }
         return fields;
     }
@@ -5050,7 +5233,7 @@ export class Runtime {
             return this.arrayJoin(store.owner, values, Array.from(state.variables.IFS ?? " ")[0] ?? "");
         }
         let value = part.name === "?" ? String(state.status)
-            : part.name === "-" ? `${state.errexit ? "e" : ""}${state.nounset ? "u" : ""}`
+            : part.name === "-" ? `${state.errexit ? "e" : ""}${state.nounset ? "u" : ""}${state.braceexpand !== false ? "B" : ""}`
                 : part.name === "#" ? String(state.positional.length)
                     : part.name === "@" || part.name === "*" ? state.positional.join(hereString && (part.name === "@" || !part.quoted) ? " " : Array.from(state.variables.IFS ?? " ")[0] ?? "")
                         : /^0+$/u.test(part.name) ? state.arg0 ?? "virtual-bash"
@@ -5354,7 +5537,25 @@ export class Runtime {
     async word(word, state, io, split = true, pattern = false, hereString = false, conditionalPattern = false, regexAppend) {
         return (await this.valueWord(word, state, io, split, pattern, hereString, conditionalPattern, regexAppend)).map(shellValueText);
     }
-    async valueWord(word, state, io, split = true, pattern = false, hereString = false, conditionalPattern = false, regexAppend) {
+    async valueWord(word, state, io, split = true, pattern = false, hereString = false, conditionalPattern = false, regexAppend, braces = split && !pattern && !hereString) {
+        if (braces && state.braceexpand !== false && word.parts.some(part => part.kind === "text" && !part.quoted && part.value.includes("{"))) {
+            const fields = [];
+            let bytes = 0;
+            for await (const expanded of expandBraces(word, this.budget, this.signal)) {
+                const values = await this.valueWord(expanded, state, io, split, pattern, hereString, conditionalPattern, regexAppend, false);
+                if (values.length > this.budget.limits.maxExpansionFields - fields.length)
+                    this.budget.fail("maxExpansionFields");
+                for (const value of values) {
+                    const size = shellValueByteLength(value);
+                    if (size > this.budget.limits.maxExpansionBytes - bytes)
+                        this.budget.fail("maxExpansionBytes");
+                    bytes += size;
+                    io[valueScope]?.reserve(32 + (typeof value === "string" ? value.length * 2 : 0), 0);
+                    fields.push(value);
+                }
+            }
+            return fields;
+        }
         const arrayOwned = word.parts.some(part => part.kind === "variable" && (getArraySelector(part) !== undefined || arrayStore(state)?.get(part.name) !== undefined));
         const owner = arrayOwned ? requireArrays(state).owner : undefined;
         const holding = owner?.hold();