@poe-platform/safe-bash 0.1.522 → 0.1.524

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

@@ -27,7 +27,7 @@ import { formatPrintf, printfCommand } from "../commands/basic.js";
 import { pathOf, UsageError } from "../commands/internal.js";
 import { cloneGetoptsState, createGetoptsInput, createGetoptsState, GetoptsError, getoptsInputAllocationSize, scanGetopts, withGetoptsIndex } from "./getopts.js";
 import { activateChildCancellation, prepareChildCancellation, selectRuntimeCancellationOutcome, subscribeCancellation, } from "./cancellation.js";
-import { getArrayAssignment, getArraySelector, copyArraySelector, numericIndex, literalIndex, isQuoteMarker } from "./arrays/syntax.js";
+import { getArrayAssignment, getArraySelector, copyArraySelector, numericIndex, literalIndex, isQuoteMarker, prefixNameQuoteGroups } from "./arrays/syntax.js";
 import { ArrayFailure, ArrayOwner, exactSum } from "./arrays/ledger.js";
 import { controlNames, IndexedBinding, textToken } from "./arrays/bindings.js";
 import { arrayStore, guestArrays, requireArrays, snapshotState, stateMonitor, trackState } from "./arrays/state.js";
@@ -37,6 +37,7 @@ import { EreLedger } from "../commands/regex-execution/ere/limits.js";
 import { compileEre } from "../commands/regex-execution/ere/syntax.js";
 import { matchEre } from "../commands/regex-execution/ere/matcher.js";
 import { PathLookup, pathTargets } from "./path-lookup.js";
+import { transformParameter } from "./parameter-transforms.js";
 export const defaultLimits = {
     maxParseUnits: defaultMaxParseUnits,
     maxInputBytes: 32 * 1024 * 1024,
@@ -76,6 +77,40 @@ export function resolveLimits(...limits) {
     return result;
 }
 const budgetedSinks = new WeakMap();
+async function sortExpansionStrings(values, work) {
+    const compare = async (left, right) => {
+        for (let index = 0; index < Math.min(left.length, right.length); index++) {
+            const pending = stringCheckpoint(work);
+            if (pending)
+                await pending;
+            const difference = left.charCodeAt(index) - right.charCodeAt(index);
+            if (difference)
+                return difference;
+        }
+        return left.length - right.length;
+    };
+    const sift = async (root, end) => {
+        while (root * 2 + 1 < end) {
+            let child = root * 2 + 1;
+            if (child + 1 < end && await compare(values[child], values[child + 1]) < 0)
+                child++;
+            if (await compare(values[root], values[child]) >= 0)
+                return;
+            const saved = values[root];
+            values[root] = values[child];
+            values[child] = saved;
+            root = child;
+        }
+    };
+    for (let index = Math.floor(values.length / 2) - 1; index >= 0; index--)
+        await sift(index, values.length);
+    for (let end = values.length - 1; end > 0; end--) {
+        const saved = values[0];
+        values[0] = values[end];
+        values[end] = saved;
+        await sift(0, end);
+    }
+}
 export class Budget {
     limits;
     onInternalError;
@@ -261,7 +296,7 @@ const typedSavedVariables = new WeakMap();
 const valueScope = Symbol("shell value allocation scope");
 const invokedValues = new WeakMap();
 function isolateIO(io) {
-    return { ...io, ...(io.descriptors ? { descriptors: new Map([...io.descriptors].map(([number, descriptor]) => [number, { ...descriptor }])) } : {}) };
+    return { ...io, nameExpansionContext: undefined, ...(io.descriptors ? { descriptors: new Map([...io.descriptors].map(([number, descriptor]) => [number, { ...descriptor }])) } : {}) };
 }
 function activeIO(io) {
     const input = io.descriptors?.get(0);
@@ -1536,6 +1571,7 @@ export class Runtime {
             const current = store.get(name);
             if (index !== undefined && current) {
                 staged = index === "members" ? IndexedBinding.create(store.owner) : await current.copy(this.signal);
+                staged.assigned = current.assigned;
                 let maximum = -1;
                 for (const key of staged.values.keys()) {
                     operation.reserve({ work: 2 }).release();
@@ -1777,7 +1813,8 @@ export class Runtime {
                 throw new ArrayFailure("readonly binding");
             if (!watch.valid())
                 throw new ArrayFailure("stale binding");
-            if (!(assignment.kind === "compound" && assignment.append && writes === 0)) {
+            staged.assigned = true;
+            if (!(assignment.kind === "compound" && assignment.append && writes === 0 && current?.assigned)) {
                 let released;
                 stateMonitor(state).publish(tickets, name, () => {
                     supersede();
@@ -2094,8 +2131,8 @@ export class Runtime {
                             fs: this.fs, cwd: state.cwd, signal: this.signal,
                             locale: state.variables.LC_ALL || state.variables.LC_COLLATE || state.variables.LANG || "C",
                             work: { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes"), allocation },
-                            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),
+                            expand: async (word, pattern = false) => (await this.word(word, state, { ...io, nameExpansionContext: "conditional" }, false, pattern, false, pattern)).join(""),
+                            regex: (subject, pattern) => this.ere(subject, pattern, state, { ...io, nameExpansionContext: "conditional" }),
                             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);
@@ -2348,6 +2385,7 @@ export class Runtime {
     async document(document, state, io, line = document.endLine) {
         this.signal.throwIfAborted();
         let value = "";
+        let fragments;
         let size = 0;
         let words = 0;
         const warnings = [];
@@ -2358,18 +2396,28 @@ export class Runtime {
                     await writeDiagnostic(io.stderr, `shell: warning: ${warning}\n`);
                 if (++words % 128 === 0)
                     await yieldTurn(this.signal);
-                const part = (await this.word(word, state, io, false)).join("");
-                size += Buffer.byteLength(part);
+                const part = concatShellValues(await this.valueWord(word, state, { ...io, nameExpansionContext: "document" }, false), io[valueScope]);
+                size += shellValueByteLength(part);
                 if (size > this.budget.limits.maxExpansionBytes)
                     this.budget.fail("maxExpansionBytes");
-                value += part;
+                if (!fragments && typeof part === "string")
+                    value += part;
+                else {
+                    if (!fragments) {
+                        io[valueScope]?.reserve(64 + value.length * 2, 0);
+                        fragments = [value];
+                        value = "";
+                    }
+                    io[valueScope]?.reserve(32 + (typeof part === "string" ? part.length * 2 : 0), 0);
+                    fragments.push(part);
+                }
             }
         }
         finally {
             for (const warning of warnings.splice(0))
                 await writeDiagnostic(io.stderr, `shell: warning: ${warning}\n`);
         }
-        return value;
+        return fragments ? concatShellValues(fragments, io[valueScope]) : value;
     }
     async redirect(redirects, state, io, inputs, outputs, isolatedInlineInput = false, persistMoves = false, fileShortcut = false, line) {
         this.signal.throwIfAborted();
@@ -2401,6 +2449,7 @@ export class Runtime {
             const stdinIsDefault = descriptor?.input ? descriptor.stdinIsDefault : false;
             return {
                 [invocationScope]: io[invocationScope],
+                ...(io[valueScope] === undefined ? {} : { [valueScope]: io[valueScope] }),
                 ...(io.execution === undefined ? {} : { execution: io.execution }),
                 ...(io.diagnosticLine === undefined ? {} : { diagnosticLine: io.diagnosticLine }),
                 ...(io.diagnosticOffset === undefined ? {} : { diagnosticOffset: io.diagnosticOffset }),
@@ -2421,7 +2470,7 @@ export class Runtime {
                     const hereString = redirect.operator === "<<<";
                     let value;
                     try {
-                        value = redirect.document ? await this.document(redirect.document, state, currentIO(), line) : (await this.word(redirect.target, state, currentIO(), false, false, hereString)).join("");
+                        value = redirect.document ? await this.document(redirect.document, state, currentIO(), line) : concatShellValues(await this.valueWord(redirect.target, state, currentIO(), false, false, hereString), io[valueScope]);
                     }
                     catch (error) {
                         if (error instanceof NounsetFailure)
@@ -2435,11 +2484,11 @@ export class Runtime {
                         throw error;
                     }
                     if (hereString) {
-                        if (Buffer.byteLength(value) >= this.budget.limits.maxExpansionBytes)
+                        if (shellValueByteLength(value) >= this.budget.limits.maxExpansionBytes)
                             this.budget.fail("maxExpansionBytes");
-                        value += "\n";
+                        value = concatShellValues([value, "\n"], io[valueScope]);
                     }
-                    const input = new ShellInput(toByteSource(value), this.budget, this.signal);
+                    const input = new ShellInput(toByteSource(typeof value === "string" ? value : shellValueBytes(value, io[valueScope])), this.budget, this.signal);
                     inputs.add(input);
                     descriptors.set(redirect.descriptor, { input, stdinIsDefault: false });
                     continue;
@@ -5208,7 +5257,112 @@ export class Runtime {
     async part(part, state, io, hereString = false) {
         return shellValueText(await this.valuePart(part, state, io, hereString));
     }
+    async *prefixNames(prefix, state) {
+        const allocation = this.budget.values.scope();
+        const store = arrayStore(state);
+        const holding = store?.owner.hold();
+        const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+        try {
+            allocation.reserveBytes(128);
+            const names = [];
+            const seen = new Set();
+            let bytes = 0;
+            const consider = async (name, assigned) => {
+                const scanned = await scanString(name, work);
+                const pending = stringCheckpoint(work, name.length + 1);
+                if (pending)
+                    await pending;
+                if (!assigned || !name.startsWith(prefix) || seen.has(name))
+                    return;
+                for (let index = 0; index < name.length; index++) {
+                    const pending = stringCheckpoint(work);
+                    if (pending)
+                        await pending;
+                    const code = name.charCodeAt(index);
+                    if (!(code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || index > 0 && code >= 48 && code <= 57))
+                        return;
+                }
+                if (names.length >= this.budget.limits.maxExpansionFields)
+                    this.budget.fail("maxExpansionFields");
+                if (scanned.bytes > this.budget.limits.maxExpansionBytes - bytes)
+                    this.budget.fail("maxExpansionBytes");
+                bytes += scanned.bytes;
+                allocation.reserveBytes(name.length * 2 + 64);
+                seen.add(name);
+                names.push(name);
+            };
+            for (const name in state.variables)
+                if (Object.hasOwn(state.variables, name))
+                    await consider(name, state.variables[name] !== undefined);
+            if (store)
+                for (const [name, entry] of store.bindings)
+                    await consider(name, entry.binding.assigned);
+            // Bash lists initialized names from dynamically enclosing local scopes,
+            // even when the current local value shadows them with an unset value.
+            for (const frame of state.locals)
+                for (const [name, saved] of frame) {
+                    await consider(name, saved.value !== undefined || typedSavedVariables.get(saved)?.binding?.assigned === true);
+                }
+            await sortExpansionStrings(names, work);
+            for (const name of names) {
+                const pending = stringCheckpoint(work);
+                if (pending)
+                    await pending;
+                yield name;
+            }
+        }
+        finally {
+            allocation.close();
+            holding?.release();
+        }
+    }
     async valuePart(part, state, io, hereString = false) {
+        if (part.kind === "variable" && part.transform) {
+            const selector = getArraySelector(part);
+            if (selector?.kind === "members" || part.name === "@" || part.name === "*") {
+                const members = selector ? await this.arrayMembers(part.name, state) : this.positionalValues(state);
+                const ifs = state.variables.IFS ?? " ";
+                const separator = ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
+                const fragments = [];
+                let bytes = 0;
+                for (const member of members) {
+                    const value = await this.transformValue(member, part.transform, state, io);
+                    bytes += shellValueByteLength(value) + (fragments.length ? Buffer.byteLength(separator) : 0);
+                    if (bytes > this.budget.limits.maxExpansionBytes)
+                        this.budget.fail("maxExpansionBytes");
+                    io[valueScope]?.reserve(32, 0);
+                    if (fragments.length)
+                        fragments.push(separator);
+                    fragments.push(value);
+                }
+                return concatShellValues(fragments, io[valueScope]);
+            }
+            const base = { ...part };
+            delete base.transform;
+            copyArraySelector(part, base);
+            const existing = selector?.kind === "element" ? arrayStore(state)?.get(part.name)?.get(numericIndex(selector.index) ?? -1) ?? (numericIndex(selector.index) === 0 ? this.variable(state, part.name) : undefined)
+                : /^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(part.name) ? this.variable(state, part.name)
+                    : /^[1-9][0-9]*$/u.test(part.name) ? state.positional[Number(part.name) - 1] : "";
+            const value = await this.valuePart(base, state, io, hereString);
+            return existing === undefined ? "" : this.transformValue(value, part.transform, state, io);
+        }
+        if (part.kind === "variable" && part.prefixNames) {
+            const ifs = state.variables.IFS ?? " ";
+            const separator = io.nameExpansionContext === "document" || io.nameExpansionContext === "conditional" && part.prefixNames === "@"
+                ? " " : ifs.length ? String.fromCodePoint(ifs.codePointAt(0)) : "";
+            const fragments = [];
+            let bytes = 0;
+            for await (const name of this.prefixNames(part.name, state)) {
+                const join = fragments.length ? separator : "";
+                bytes += Buffer.byteLength(name) + Buffer.byteLength(join);
+                if (bytes > this.budget.limits.maxExpansionBytes)
+                    this.budget.fail("maxExpansionBytes");
+                io[valueScope]?.reserve((name.length + join.length) * 2 + 32, 0);
+                fragments.push(join, name);
+            }
+            io[valueScope]?.reserve(bytes * 2, 0);
+            return fragments.join("");
+        }
         const binding = part.kind === "variable" ? arrayStore(state)?.get(part.name) : undefined;
         const holding = binding ? requireArrays(state).owner.hold() : undefined;
         const selector = getArraySelector(part);
@@ -5233,6 +5387,19 @@ export class Runtime {
             throw new ShellSyntaxError("Syntax nesting exceeds 64", word.offset);
         return { ...io, parameterDepth };
     }
+    async transformValue(value, operator, state, io) {
+        const allocation = io[valueScope] ?? this.budget.values.scope();
+        try {
+            return await transformParameter(value, operator, {
+                maximumBytes: this.budget.limits.maxExpansionBytes, byteLocale: byteLocale(state.variables), allocation,
+                work: { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 8 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") },
+            });
+        }
+        finally {
+            if (!io[valueScope])
+                allocation.close();
+        }
+    }
     async partValue(part, state, io, hereString) {
         this.signal.throwIfAborted();
         if (part.kind === "compound-substitution-eof") {
@@ -5656,7 +5823,8 @@ export class Runtime {
             }
             return fields;
         }
-        const arrayOwned = word.parts.some(part => part.kind === "variable" && (getArraySelector(part) !== undefined || arrayStore(state)?.get(part.name) !== undefined));
+        const arrayOwned = word.parts.some(part => part.kind === "variable" && !part.prefixNames && (getArraySelector(part) !== undefined || arrayStore(state)?.get(part.name) !== undefined));
+        const prefixOwned = word.parts.some(part => part.kind === "variable" && (part.prefixNames === "@" || part.transform && part.name === "@"));
         const owner = arrayOwned ? requireArrays(state).owner : undefined;
         const holding = owner?.hold();
         const scratch = !owner && split && state.variables.IFS !== "" && word.parts.some(part => !part.quoted && part.kind !== "text")
@@ -5667,12 +5835,14 @@ export class Runtime {
             owner?.reserve({ metadata: 128 + word.parts.length * 32, allocatedSlots: word.parts.length + 1, work: word.parts.length + 5 });
             scratch?.reserve(word.parts.length * 32, 0);
             const fields = [];
+            let emptyNameGroups;
+            let quoteGroup;
             const addField = () => {
                 if (fields.length >= this.budget.limits.maxExpansionFields)
                     this.budget.fail("maxExpansionFields");
                 scratch?.reserve(32, 0);
                 owner?.reserve({ metadata: 32, allocatedSlots: 1, work: 3 });
-                fields.push({ fragments: [], bytes: false, patterns: undefined, present: false });
+                fields.push({ fragments: [], bytes: false, patterns: undefined, present: false, independentPresence: false });
             };
             addField();
             let expansionBytes = 0;
@@ -5712,6 +5882,15 @@ export class Runtime {
                 regexAppend?.(text, !glob);
                 field.fragments.push(value);
                 field.present ||= present;
+                if (present) {
+                    if (size > 0 || !quoteGroup)
+                        field.independentPresence = true;
+                    else {
+                        io[valueScope]?.reserve(32, 0);
+                        field.quoteGroups ??= [];
+                        field.quoteGroups.push(quoteGroup);
+                    }
+                }
             };
             const appendSplit = async (value) => {
                 this.budget.cpuCheckpoint();
@@ -5768,7 +5947,8 @@ export class Runtime {
             const parts = word.parts.map((part) => ({ part, splitText: false, io }));
             for (let index = 0; index < parts.length; index++) {
                 const { part, splitText, io: partIO } = parts[index];
-                const quotedPresence = part.quoted && !(arrayOwned && isQuoteMarker(part));
+                quoteGroup = prefixNameQuoteGroups.get(part);
+                const quotedPresence = part.quoted && !((arrayOwned || prefixOwned) && isQuoteMarker(part));
                 if (part.kind === "variable" && ["-", "+", ":-", ":+"].includes(part.operator ?? "") && /^[a-zA-Z_][a-zA-Z_0-9]*$/u.test(part.name)) {
                     const value = this.variable(state, part.name);
                     const missing = value === undefined || (part.operator.startsWith(":") && value === "");
@@ -5783,17 +5963,36 @@ export class Runtime {
                     }
                 }
                 const selector = getArraySelector(part);
-                if (part.kind === "variable" && selector?.kind === "members" && !part.length && split && (!part.quoted || selector.separator === "@")) {
-                    const members = await this.arrayMembers(part.name, state);
+                if (part.kind === "variable" && part.prefixNames === "@" && split && (part.quoted || state.variables.IFS === "")) {
+                    let position = 0;
+                    for await (const name of this.prefixNames(part.name, state)) {
+                        if (position++)
+                            addField();
+                        append(name, !part.quoted, true);
+                    }
+                    if (position === 0 && quoteGroup) {
+                        io[valueScope]?.reserve(32, 0);
+                        emptyNameGroups ??= new Set();
+                        emptyNameGroups.add(quoteGroup);
+                    }
+                }
+                else if (part.kind === "variable" && split && (selector?.kind === "members" && !part.length && (!part.quoted || selector.separator === "@") || part.transform && part.name === "@")) {
+                    const members = selector?.kind === "members" ? await this.arrayMembers(part.name, state) : this.positionalValues(state);
                     for (let position = 0; position < members.length; position++) {
                         if (position > 0)
                             addField();
-                        const value = members[position];
+                        const original = members[position];
+                        const value = part.transform ? await this.transformValue(original, part.transform, state, partIO) : original;
                         if (part.quoted || state.variables.IFS === "")
-                            append(value, !part.quoted, part.quoted || value.length > 0);
+                            append(value, !part.quoted, part.quoted || shellValueByteLength(value) > 0);
                         else
                             await appendSplit(value);
                     }
+                    if (part.transform && members.length === 0 && quoteGroup) {
+                        io[valueScope]?.reserve(32, 0);
+                        emptyNameGroups ??= new Set();
+                        emptyNameGroups.add(quoteGroup);
+                    }
                 }
                 else if (part.kind === "text" && !splitText) {
                     let value = invokedValues.get(part) ?? part.byteValue ?? part.value;
@@ -5801,7 +6000,7 @@ export class Runtime {
                         value = (state.variables.HOME ?? "~") + value.slice(1);
                     append(value, !part.quoted, quotedPresence || shellValueByteLength(value) > 0);
                 }
-                else if (part.kind === "variable" && part.name === "@" && part.quoted && !part.operator && split) {
+                else if (part.kind === "variable" && part.name === "@" && part.quoted && !part.operator && !part.transform && split) {
                     for (let position = 0; position < state.positional.length; position++) {
                         if (position > 0)
                             addField();
@@ -5827,6 +6026,21 @@ export class Runtime {
             for (const field of fields) {
                 if (!field.present && split)
                     continue;
+                if (split && !field.independentPresence && field.quoteGroups) {
+                    const work = { remaining: this.budget.limits.maxExpansionBytes, signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+                    let empty = true;
+                    for (const group of field.quoteGroups) {
+                        const pending = stringCheckpoint(work);
+                        if (pending)
+                            await pending;
+                        if (!emptyNameGroups?.has(group)) {
+                            empty = false;
+                            break;
+                        }
+                    }
+                    if (empty)
+                        continue;
+                }
                 if (scratch && field.fragments.length > 1 && !field.bytes)
                     scratch.reserve(field.fragments.reduce((bytes, value) => bytes + shellValueText(value).length * 2, 0), 0);
                 const assembled = concatShellValues(field.fragments, io[valueScope]);
@@ -6156,38 +6370,7 @@ export class Runtime {
             }
             // In-place heap sort preserves ordinary UTF-16 pathname order while
             // charging comparisons, including long common prefixes, and yielding.
-            const compare = async (left, right) => {
-                for (let index = 0; index < Math.min(left.length, right.length); index++) {
-                    const pending = stringCheckpoint(work);
-                    if (pending)
-                        await pending;
-                    const difference = left.charCodeAt(index) - right.charCodeAt(index);
-                    if (difference)
-                        return difference;
-                }
-                return left.length - right.length;
-            };
-            const sift = async (root, end) => {
-                while (root * 2 + 1 < end) {
-                    let child = root * 2 + 1;
-                    if (child + 1 < end && await compare(found[child], found[child + 1]) < 0)
-                        child++;
-                    if (await compare(found[root], found[child]) >= 0)
-                        return;
-                    const saved = found[root];
-                    found[root] = found[child];
-                    found[child] = saved;
-                    root = child;
-                }
-            };
-            for (let index = Math.floor(found.length / 2) - 1; index >= 0; index--)
-                await sift(index, found.length);
-            for (let end = found.length - 1; end > 0; end--) {
-                const saved = found[0];
-                found[0] = found[end];
-                found[end] = saved;
-                await sift(0, end);
-            }
+            await sortExpansionStrings(found, work);
             return found.length ? found : [value];
         }
         finally {