@sema-agent/core 7.47.0 → 7.48.0

package/dist/tools/fs/shell-read-argv.d.ts

@@ -10,11 +10,9 @@ import { type Read } from "./shell-read-word.js";
 import { type BindingTable, type FloorValue } from "./shell-read-bindings.js";
 import { subcommandOf, type ArgRole, type ProgramRow } from "./program-read-model.js";
 import type { ReadCandidate, ReadCandidateProvenance } from "./shell-read-plan.js";
-/** A candidate before the threading fills its bases. `alternatives`: the other spellings its word may expand to (a name
- *  bound to several values), each with the pattern its names are matched by — one candidate each once the segment's reads
- *  are read. */
+/** A candidate before the threading fills its bases. `floors`: the spellings its word's names left for the deny judge
+ *  alone (a word whose names are unknown here). */
 export type Bare = Omit<ReadCandidate, "bases"> & {
-    readonly alternatives?: readonly Pick<ReadCandidate, "spelled" | "pattern">[];
     readonly floors?: readonly FloorValue[];
 };
 /** What reading a segment's words found beside its candidates. */
@@ -36,9 +34,8 @@ export declare function pathSubcommandOf(row: ProgramRow | undefined, args: read
 /** The sentence of inline program text the station does not read. */
 export declare const programTextSentence: (language: string) => string;
 /** One candidate without its bases (filled by the threading pass): the word's spelling — or `spelled`, a caller's
- *  reading of PART of it (an option payload, a `key=value` value) — with the word's own expansion facts. A word whose
- *  names may hold several values offers each as its whole spelling; a PART of such a word is not followed through them
- *  (it is unresolvable). */
+ *  reading of PART of it (an option payload, a `key=value` value) — with the word's own expansion facts. The word is read
+ *  in one reading of the segment's names (`segmentReadingsOf`): its names hold one value each, or are unknown. */
 export declare function bare(r: Read, provenance: ReadCandidateProvenance, spelled?: string): Bare;
 /** The reads one value of a declared role hands over: a candidate per file it names, or — a value the program expands
  *  past the listed bound — the word itself, unresolvable. A mount source is a read the daemon makes of the whole tree

package/dist/tools/fs/shell-read-argv.js

@@ -1,5 +1,5 @@
 import { literalTildeSpelling } from "../../shell/lex.js";
-import { expandsOf, patternOf, readOfText, rewritten, spellingOf } from "./shell-read-word.js";
+import { expandsOf, partPattern, readOfText, rewritten } from "./shell-read-word.js";
 import { arithmeticSubstitutions } from "./shell-read-bindings.js";
 import { argvProgramOf, attachedOptionPayloads, isPathShapedToken } from "./bash-readonly-classifier.js";
 import { assignmentArgumentsAreNotPaths, evaluatesOperands, messageWords, moduleTailOf, objectPathsOf, opensNoOperand, programRow, programTextMayOpen, programTextOpensOf, readArgs, selectsContentsTraversal, slotValueCandidates, subcommandOf, valuesAreLiteral, walksCwdWithoutOperand, wordsReadBySomeImplementations, } from "./program-read-model.js";
@@ -10,16 +10,13 @@ export function pathSubcommandOf(row, args) {
 export const programTextSentence = (language) => `runs inline ${language} program text, which may open files this station does not read`;
 export function bare(r, provenance, spelled = r.folded) {
     const whole = spelled === r.folded;
-    const alternatives = r.values !== undefined && r.values.length > 1 ? r.values.slice(1).map((v) => { const pattern = patternOf(v); return { spelled: spellingOf(v), ...(pattern !== undefined ? { pattern } : {}) }; }) : undefined;
-    if (!whole && alternatives !== undefined)
-        return { spelled, raw: r.raw, provenance, expands: "unresolvable" };
+    const pattern = whole ? r.pattern : partPattern(r, spelled);
     return {
         spelled,
         raw: r.raw,
         provenance,
         expands: r.expands,
-        ...(whole && r.pattern !== undefined ? { pattern: r.pattern } : {}),
-        ...(whole && alternatives !== undefined ? { alternatives } : {}),
+        ...(pattern !== undefined ? { pattern } : {}),
         ...(whole && r.homeFloor !== undefined ? { floorSpelled: r.homeFloor } : {}),
         ...(whole && r.floorValues !== undefined ? { floors: r.floorValues } : {}),
     };
@@ -64,8 +61,9 @@ export function pushAssignment(reads, w, provenance) {
     if (!settled && unsettled !== undefined)
         reads.push(unsettled);
     const substitutes = a.value.expansions.some((p) => p.expansion?.kind === "command" || p.expansion?.kind === "process" || p.expansion?.kind === "arithmetic");
+    const pattern = named === undefined ? undefined : partPattern({ folded: w.folded, ...(w.judged !== undefined ? { pattern: w.judged } : {}) }, named);
     if (named !== undefined && !substitutes)
-        reads.push({ spelled: named, raw: w.raw, provenance, expands: expandsOf(w) });
+        reads.push({ spelled: named, raw: w.raw, provenance, expands: expandsOf(w), ...(pattern !== undefined ? { pattern } : {}) });
     if (a.value.folded.includes(":"))
         for (const m of a.value.folded.split(":"))
             if (m !== "") {

package/dist/tools/fs/shell-read-bindings.d.ts

@@ -36,10 +36,12 @@ export type BoundValue = {
     readonly spelled: string;
     readonly glob?: never;
     readonly parts?: never;
+    readonly fields?: readonly string[];
 } | {
     readonly spelled: string;
     readonly glob: true;
     readonly parts: readonly ValuePart[];
+    readonly fields?: never;
 };
 /** One run of a pattern {@link BoundValue}: literal text, or a pattern — the shell expands its characters — `text` as
  *  written (what a shell re-reading it matches by), `judged` as a reader judges the names it matches. */
@@ -56,7 +58,14 @@ export type ValuePart = {
 export interface FloorValue {
     readonly spelled: string;
     readonly glob?: true;
+    /** A pattern's spelling as a reader judges the names it matches, where it is not `spelled` ({@link judgedSpellingOf}). */
+    readonly pattern?: string;
 }
+/** A pattern value's names as a reader judges them, where that is not its spelling: its runs, a class the judge widens
+ *  as `?` (the lexer's `WordExpansion.pattern.judged`), a leading `~` the literal tilde it is. */
+export declare function judgedSpellingOf(v: BoundValue): string | undefined;
+/** A value as a deny-floor spelling, its judged spelling with it. */
+export declare function floorOf(v: BoundValue): FloorValue;
 /** What a name holds at one point of a text: its possible values, or `"unknown"`. */
 type NameState = readonly BoundValue[] | "unknown";
 /**
@@ -133,25 +142,36 @@ export declare function dropDefinitionHeads(tokens: LexedToken[]): readonly numb
  * where it refers to no name (it reads as written), else {@link valueOf}. `table.stateOf` is read after `overlay` (the
  * names the same segment bound earlier).
  */
-export declare function wordValues(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined, quoted: boolean, overlay?: ReadonlyMap<string, NameState>): readonly BoundValue[] | "unknown" | undefined;
+export declare function wordValues(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined, quoted: boolean, overlay?: ReadonlyMap<string, NameState>, split?: boolean): readonly BoundValue[] | "unknown" | undefined;
+/** The names a word's expansions read as values — a bare `$NAME` / `${NAME}`, and one written inside a bracket the shell
+ *  forms its class from after expanding it ({@link valueOf}) — in the order they stand. */
+export declare function namesIn(word: Pick<LexedWord, "pieces">): string[];
 /**
  * What a VALUE word holds (an assignment's value, a `for` list word, a word handed to a program) — THE piece walk, the one
- * producer of {@link BoundValue}s: every combination of the values its pieces take — a literal piece its text, a glob
- * piece its pattern (as the program receives it, as written for a shell re-reading it, and as a reader judges it — the
- * lexer's three texts, never re-cut here), `~` and `$NAME` the values the table gives:
- *  · its values — a piece the shell globs makes the value a pattern;
+ * producer of {@link BoundValue}s: every combination of the values its pieces take, each field's pattern formed once the
+ * whole field has expanded ({@link formedField}) — a literal piece its text, a glob piece its pattern as written (a bracket
+ * holding an expansion its brackets and its body, the body's names substituted in place), `~` and `$NAME` the values the
+ * table gives:
+ *  · its values — a field the shell globs makes the value a pattern;
  *  · `"unknown"` — a name it refers to is not settled here, it carries an expansion no name answers (a modifier, a
- *    substitution, a brace list, `~user`, an expansion inside a bracket pattern), an UNQUOTED expansion's value is not one
- *    word or `IFS` may have changed (`quoted` = the whole word is read as one value: an assignment's value, which is never
- *    split), or it would list more than {@link WORD_VALUES_MAX} values.
+ *    substitution, a brace list, `~user`), an UNQUOTED expansion's value is no {@link READABLE_VALUE} (or holds
+ *    whitespace outside `split`), `IFS` may have changed (`quoted` = the whole word is read as one value: an assignment's
+ *    value, which is never split), a field is not formed or a split one forms a pattern, or it would list more than
+ *    {@link WORD_VALUES_MAX} values.
+ * `split` = the word is read as the ARGUMENTS it becomes: an unquoted value is split into its words on the default `IFS`
+ * (a value then carries its {@link BoundValue} `fields`).
  */
-export declare function valueOf(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined, quoted: boolean, overlay?: ReadonlyMap<string, NameState>): NameState;
+export declare function valueOf(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined, quoted: boolean, overlay?: ReadonlyMap<string, NameState>, split?: boolean): NameState;
 /**
  * The spellings a word the table leaves unknown may still take through the deny floors of the names it refers to
  * ({@link BindingTable.floorOf}) — `${A[k]}`, `${A[@]}`, `$A` reading an array's elements — or through their values where
  * known: for the deny judge alone. Empty where some name it refers to leaves neither.
  */
 export declare function wordFloorValues(word: Pick<LexedWord, "pieces">, table: BindingTable | undefined): readonly FloorValue[];
+/** Where a segment's argv heads a `for` / `select` loop: the index of that bare word, at the segment's start or past the
+ *  bare control words in front of it (`do for x in …`, `then for …` — a loop nested in a body or a branch); `undefined`
+ *  for any other segment. */
+export declare function loopListHeadAt(argv: readonly LexedWord[]): number | undefined;
 /**
  * What ONE segment does to the names (see the module header). `argv` = the segment's argv projection (structure
  * dropped); `readValue` folds a value word against the table (a reader that answers `unknown` gives the names alone).
@@ -180,6 +200,9 @@ export type NameReader = (name: string) => NameState;
 export interface InheritedNames {
     readonly attributes: readonly NameAttribute[];
     readonly references: boolean;
+    /** The deny floors a name starts the text with ({@link BindingTable.floorOf}): what the words handing it this text as
+     *  written may name there — or, for a substitution body, the floors its segment reads. */
+    readonly floors?: ReadonlyMap<string, readonly FloorValue[]>;
 }
 /** What the thread answers for one reader: what a name may hold, and whether a name carries the integer attribute. */
 export interface BindingTable {
@@ -235,6 +258,8 @@ export declare class BindingThread {
     private readonly blocks;
     /** Segments that are a pipeline member or run in the background. */
     private readonly detached;
+    /** The floors the names start the text with ({@link InheritedNames.floors}). */
+    private readonly startFloors;
     constructor(segments: readonly LexedSegment[], 
     /** What each segment binds, its names alone (a value is the reader's to read). */
     named: readonly BindingEffect[], 

package/dist/tools/fs/shell-read-bindings.js

@@ -1,9 +1,19 @@
 import { argvOf, lexShell, literalTildeSpelling, substitutionsInHeredocBody } from "../../shell/lex.js";
-import { readProgramPosition } from "./bash-program-position.js";
+import { isShellSyntaxWord, LOOP_LIST_HEADS, readProgramPosition } from "./bash-program-position.js";
 import { declaredAttributes, programRow, readArgRoles } from "./program-read-model.js";
 import { codeBodies } from "./shell-reentry-text.js";
+export function judgedSpellingOf(v) {
+    if (v.glob !== true)
+        return undefined;
+    const judged = literalTildeSpelling(v.parts.map((p) => (p.pattern ? p.judged : p.text)).join(""));
+    return judged === literalTildeSpelling(v.spelled) ? undefined : judged;
+}
+export function floorOf(v) {
+    const pattern = judgedSpellingOf(v);
+    return v.glob === true ? { spelled: v.spelled, glob: true, ...(pattern !== undefined ? { pattern } : {}) } : { spelled: v.spelled };
+}
 function sameValue(a, b) {
-    if (a.spelled !== b.spelled)
+    if (a.spelled !== b.spelled || a.fields?.length !== b.fields?.length)
         return false;
     if (a.glob !== true || b.glob !== true)
         return a.glob === b.glob;
@@ -203,14 +213,51 @@ function blockStructure(segments) {
         return { words: words ?? depth, after: depth, lowest, switches, ...(body !== undefined ? { body } : {}) };
     });
 }
-const ONE_WORD = /^[A-Za-z0-9_./+@:%=,-]+$/;
+const READABLE_VALUE = /^[^\\~()]*$/;
 const WORD_VALUES_MAX = 64;
-export function wordValues(word, table, quoted, overlay = new Map()) {
-    if (!word.pieces.some((p) => p.expansion?.kind === "parameter" || p.expansion?.kind === "tilde"))
+const quotedRunsOf = (v) => v.glob === true ? v.parts.map((r) => (r.pattern ? { text: r.text, mode: "set", judged: r.judged } : { text: r.text, mode: "inactive" })) : [{ text: v.spelled, mode: "inactive" }];
+function formedField(f) {
+    const runs = f.runs;
+    if (!runs.some((r) => r.mode === "active" && /[[\]*?]/.test(r.text))) {
+        if (!runs.some((r) => r.mode === "raw" || r.mode === "set"))
+            return { spelled: f.text };
+        return { spelled: f.text, glob: true, parts: joinRuns([], runs.map((r) => (r.mode === "raw" || r.mode === "set" ? { text: r.text, pattern: true, judged: r.judged } : { text: r.text, pattern: false }))) };
+    }
+    if (runs.some((r) => r.mode === "active" && /[ \t\n\\]/.test(r.text)) || (runs.some((r) => r.mode === "set") && runs.some((r) => r.mode === "active" && /[[\]]/.test(r.text))))
         return undefined;
-    return valueOf(word, table, quoted, overlay);
+    const escaped = runs.map((r) => (r.mode === "raw" || r.mode === "set" ? r.text : r.text.replace(r.mode === "active" ? /[^A-Za-z0-9_./*?[\]!^:=,+@%-]/g : /[^A-Za-z0-9_./]/g, (c) => `\\${c}`))).join("");
+    const lexed = lexShell(`: ${escaped}`);
+    const words = "parseFailure" in lexed || lexed.segments.length !== 1 ? undefined : argvOf(lexed.segments[0]);
+    if (words?.length !== 2)
+        return undefined;
+    let parts = [];
+    for (const p of words[1].pieces) {
+        if (p.expansion?.pattern !== undefined)
+            parts = joinRuns(parts, [{ text: p.expansion.pattern.written, pattern: true, judged: p.expansion.pattern.judged }]);
+        else if (p.expansion === undefined && p.literal !== undefined)
+            parts = joinRuns(parts, [{ text: p.literal, pattern: false }]);
+        else
+            return undefined;
+    }
+    return parts.some((r) => r.pattern) ? { spelled: f.text, glob: true, parts } : { spelled: f.text };
+}
+export function wordValues(word, table, quoted, overlay = new Map(), split = false) {
+    if (!word.pieces.some((p) => p.expansion?.kind === "parameter" || p.expansion?.kind === "tilde") && namesIn(word).length === 0)
+        return undefined;
+    return valueOf(word, table, quoted, overlay, split);
+}
+export function namesIn(word) {
+    return word.pieces.flatMap((p) => {
+        const e = p.expansion;
+        if (e?.kind === "parameter" && e.name !== undefined)
+            return e.body === undefined || e.body === e.name ? [e.name] : [];
+        return e?.kind === "glob" && e.pattern === undefined ? (bracketBodyOf(e.body) ?? []).flatMap((w) => namesIn(w)) : [];
+    });
+}
+function bracketBodyOf(body) {
+    const lexed = body === undefined ? undefined : lexShell(`""${body}`);
+    return lexed === undefined || "parseFailure" in lexed ? undefined : lexed.segments.flatMap((s) => argvOf(s));
 }
-const runsOf = (v) => (v.glob === true ? v.parts : [{ text: v.spelled, pattern: false }]);
 function joinRuns(runs, more) {
     const out = [...runs];
     for (const r of more) {
@@ -224,51 +271,96 @@ function joinRuns(runs, more) {
     }
     return out;
 }
-export function valueOf(word, table, quoted, overlay = new Map()) {
+export function valueOf(word, table, quoted, overlay = new Map(), split = false) {
     const stateOf = (name) => (table === undefined ? "unknown" : overlay.get(name) ?? table.stateOf(name));
-    let combos = [{ text: "", glob: false, parts: [] }];
-    for (const p of word.pieces) {
-        const e = p.expansion;
-        let options;
-        if (e === undefined) {
-            if (p.literal === undefined)
-                return "unknown";
-            options = [{ spelled: p.literal }];
-        }
-        else if (e.kind === "glob") {
-            if (e.pattern === undefined)
-                return "unknown";
-            options = [{ spelled: e.pattern.folded, glob: true, parts: [{ text: e.pattern.written, pattern: true, judged: e.pattern.judged }] }];
+    const EMPTY = { text: "", runs: [] };
+    let combos = [{ field: EMPTY, closed: [], started: false, split: false }];
+    const activeRun = (text) => ({ text, mode: "active" });
+    const splitInto = (c, value) => {
+        const words = value.split(/[ \t\n]+/).filter((w) => w !== "");
+        if (words.length === 0)
+            return value === "" ? { ...c, split: true } : { ...c, field: EMPTY, started: false, closed: c.started ? [...c.closed, c.field] : c.closed, split: true };
+        const closed = [...c.closed];
+        if (/^[ \t\n]/.test(value) && c.started)
+            closed.push(c.field);
+        let field = closed.length > c.closed.length ? { text: words[0], runs: [activeRun(words[0])] } : { text: c.field.text + words[0], runs: [...c.field.runs, activeRun(words[0])] };
+        for (let i = 1; i < words.length; i++) {
+            closed.push(field);
+            field = { text: words[i], runs: [activeRun(words[i])] };
         }
-        else if (e.kind === "tilde") {
-            if (e.body !== "~")
-                return "unknown";
-            const home = stateOf("HOME");
-            if (home === "unknown")
-                return "unknown";
-            options = home;
-        }
-        else if (e.kind === "parameter" && e.name !== undefined && (e.body === undefined || e.body === e.name)) {
-            const state = stateOf(e.name);
-            if (state === "unknown")
-                return "unknown";
-            if (p.quotedBy === undefined && !quoted && (table?.ifsTouched === true || state.some((v) => v.glob === true || !ONE_WORD.test(v.spelled))))
-                return "unknown";
-            options = state;
-        }
-        else
-            return "unknown";
-        const next = [];
-        for (const c of combos)
-            for (const o of options)
-                next.push({ text: c.text + o.spelled, glob: c.glob || o.glob === true, parts: joinRuns(c.parts, runsOf(o)) });
+        if (!/[ \t\n]$/.test(value))
+            return { ...c, field, started: true, closed, split: true };
+        closed.push(field);
+        return { ...c, field: EMPTY, started: false, closed, split: true };
+    };
+    const extend = (options) => {
+        const next = combos.flatMap((c) => options.map((o) => ({ ...c, field: { text: c.field.text + o.text, runs: [...c.field.runs, ...o.runs] }, started: true })));
         if (next.length > WORD_VALUES_MAX)
-            return "unknown";
+            return false;
         combos = next;
-    }
+        return true;
+    };
+    const unquotedKind = (v) => v.glob === true || !READABLE_VALUE.test(v.spelled) ? undefined : !/[ \t\n]/.test(v.spelled) && v.spelled !== "" ? "run" : split ? "split" : undefined;
+    const walk = (pieces, unquoted) => {
+        for (const p of pieces) {
+            const e = p.expansion;
+            const bare = unquoted && p.quotedBy === undefined;
+            if (e === undefined) {
+                if (p.literal === undefined || !extend([{ text: p.literal, runs: [{ text: p.literal, mode: bare ? "active" : "inactive" }] }]))
+                    return false;
+            }
+            else if (e.kind === "glob") {
+                const formed = e.pattern;
+                if (formed !== undefined) {
+                    if (!extend([{ text: formed.folded, runs: [{ text: formed.written, mode: "raw", judged: formed.judged }] }]))
+                        return false;
+                    continue;
+                }
+                const words = bracketBodyOf(e.body);
+                if (words?.length !== 1 || !extend([{ text: "[", runs: [activeRun("[")] }]) || !walk(words[0].pieces, true) || !extend([{ text: "]", runs: [activeRun("]")] }]))
+                    return false;
+            }
+            else if (e.kind === "tilde") {
+                const home = e.body === "~" ? stateOf("HOME") : "unknown";
+                if (home === "unknown" || !extend(home.map((v) => ({ text: v.spelled, runs: quotedRunsOf(v) }))))
+                    return false;
+            }
+            else if (e.kind === "parameter" && e.name !== undefined && (e.body === undefined || e.body === e.name)) {
+                const state = stateOf(e.name);
+                if (state === "unknown")
+                    return false;
+                if (!bare) {
+                    if (!extend(state.map((v) => ({ text: v.spelled, runs: quotedRunsOf(v) }))))
+                        return false;
+                    continue;
+                }
+                const kinds = state.map(unquotedKind);
+                if (table?.ifsTouched === true || kinds.includes(undefined))
+                    return false;
+                if (!kinds.includes("split")) {
+                    if (!extend(state.map((v) => ({ text: v.spelled, runs: [activeRun(v.spelled)] }))))
+                        return false;
+                    continue;
+                }
+                const next = combos.flatMap((c) => state.map((v) => splitInto(c, v.spelled)));
+                if (next.length > WORD_VALUES_MAX)
+                    return false;
+                combos = next;
+            }
+            else
+                return false;
+        }
+        return true;
+    };
+    if (!walk(word.pieces, !quoted))
+        return "unknown";
     const out = [];
     for (const c of combos) {
-        const v = c.glob ? { spelled: c.text, glob: true, parts: c.parts } : { spelled: c.text };
+        const fields = (c.split ? (c.started ? [...c.closed, c.field] : c.closed) : [c.field]).map(formedField);
+        const formed = fields.filter((f) => f !== undefined && !(c.split && f.glob === true));
+        if (formed.length !== fields.length)
+            return "unknown";
+        const v = !c.split ? formed[0] : formed.length !== 1 ? { spelled: formed.map((f) => f.spelled).join(" "), fields: formed.map((f) => f.spelled) } : { spelled: formed[0].spelled };
         if (!out.some((x) => sameValue(x, v)))
             out.push(v);
     }
@@ -288,22 +380,29 @@ export function wordFloorValues(word, table) {
         }
         else if (e.kind === "parameter" && e.name !== undefined) {
             const state = table.stateOf(e.name);
-            options = state !== "unknown" && (e.body === undefined || e.body === e.name) ? state : table.floorOf(e.name);
+            options = state !== "unknown" && (e.body === undefined || e.body === e.name) ? state.map(floorOf) : table.floorOf(e.name);
         }
         else
             return [];
         if (options.length === 0)
             return [];
         const next = [];
-        for (const c of combos)
-            for (const o of options)
-                next.push(c.glob === true || o.glob === true ? { spelled: c.spelled + o.spelled, glob: true } : { spelled: c.spelled + o.spelled });
+        for (const c of combos) {
+            for (const o of options) {
+                const pattern = c.pattern !== undefined || o.pattern !== undefined ? (c.pattern ?? c.spelled) + (o.pattern ?? o.spelled) : undefined;
+                next.push(c.glob === true || o.glob === true ? { spelled: c.spelled + o.spelled, glob: true, ...(pattern !== undefined ? { pattern } : {}) } : { spelled: c.spelled + o.spelled });
+            }
+        }
         if (next.length > WORD_VALUES_MAX)
             return [];
         combos = next;
     }
     return combos;
 }
+export function loopListHeadAt(argv) {
+    const at = isShellSyntaxWord(argv[0], LOOP_LIST_HEADS) ? 0 : readProgramPosition(argv).written;
+    return at !== undefined && isShellSyntaxWord(argv[at], LOOP_LIST_HEADS) ? at : undefined;
+}
 export function bindingEffectOf(segment, argv, shape, readValue) {
     const bindings = [];
     let all = shape.definesFunction ? "reset" : undefined;
@@ -353,21 +452,21 @@ export function bindingEffectOf(segment, argv, shape, readValue) {
             kill(name);
         return { bindings, all };
     }
-    const head = argv[0];
-    const headWord = head !== undefined && head.raw === head.folded ? head.folded : undefined;
-    if (headWord === "for" || headWord === "select") {
+    const loopAt = loopListHeadAt(argv);
+    if (loopAt !== undefined) {
+        const headWord = argv[loopAt].folded;
         if (tokens.some((t) => t.kind === "group"))
             unknownAll();
-        const name = argv[1] !== undefined ? nameOf(argv[1]) : undefined;
+        const name = argv[loopAt + 1] !== undefined ? nameOf(argv[loopAt + 1]) : undefined;
         if (name === undefined || name === "computed") {
             unknownAll();
             return { bindings, all };
         }
-        const inAt = argv.findIndex((w, i) => i >= 2 && w.raw === "in");
+        const inAt = argv.findIndex((w, i) => i >= loopAt + 2 && w.raw === "in");
         let state = "unknown";
-        if (headWord === "for" && inAt === 2 && argv.length > 3) {
+        if (headWord === "for" && inAt === loopAt + 2 && argv.length > loopAt + 3) {
             const values = [];
-            for (const w of argv.slice(3)) {
+            for (const w of argv.slice(loopAt + 3)) {
                 const v = readValue(w, false, overlay);
                 if (v === "unknown") {
                     values.length = 0;
@@ -381,7 +480,7 @@ export function bindingEffectOf(segment, argv, shape, readValue) {
         bind({ name, state, loopVar: true });
         return { bindings, all };
     }
-    if (headWord === "coproc" && argv[1] !== undefined)
+    if (argv[0]?.raw === "coproc" && argv[1] !== undefined)
         killNamed(nameOf(argv[1]));
     const pos = readProgramPosition(argv);
     const program = pos.program;
@@ -490,7 +589,7 @@ function compoundFloor(raw, readValue, overlay) {
     return compoundElementWords(raw).flatMap((w) => {
         const v = w.tail === true ? "unknown" : readValue(w, true, overlay);
         if (v !== "unknown")
-            return [...v];
+            return v.map(floorOf);
         const text = w.pieces.some((q) => q.expansion?.kind === "tilde") ? w.folded : literalTildeSpelling(w.folded);
         return [w.pieces.some((q) => q.expansion?.kind === "glob") ? { spelled: text, glob: true } : { spelled: text }];
     });
@@ -550,6 +649,7 @@ export class BindingThread {
     unreadable;
     blocks;
     detached;
+    startFloors;
     constructor(segments, named, initial, boundAnywhere, loops, homeStartsTouched = false, inherited = NOTHING_INHERITED) {
         this.segments = segments;
         this.named = named;
@@ -557,6 +657,7 @@ export class BindingThread {
         this.boundAnywhere = boundAnywhere;
         this.loops = loops;
         this.homeStartsTouched = homeStartsTouched;
+        this.startFloors = inherited.floors ?? new Map();
         this.blocks = blockStructure(segments);
         this.detached = segments.map((s, i) => s.connector === "|" || segments[i + 1]?.connector === "|" || segments[i + 1]?.connector === "&");
         this.unreadable = [...(inherited.references ? [{ at: -1 }] : []), ...named.flatMap((effect, at) => this.unreadableBy(effect, at))];
@@ -564,9 +665,14 @@ export class BindingThread {
     }
     inheritedAt(j) {
         const holds = (at) => j === undefined || this.mayRunBefore(at, j);
+        const floors = new Map(this.startFloors);
+        for (const e of this.entries)
+            if (e.name !== undefined && e.floor !== undefined && (j === undefined || e.at < j))
+                floors.set(e.name, [...(floors.get(e.name) ?? []), ...e.floor]);
         return {
             attributes: this.attributesAt.filter((x) => holds(x.at)).map(({ name, kind }) => (name !== undefined ? { name, kind } : { kind })),
             references: this.unreadable.some((u) => u.name === undefined && u.body === undefined && holds(u.at)),
+            ...(floors.size > 0 ? { floors } : {}),
         };
     }
     unreadableBy(effect, at) {
@@ -688,7 +794,7 @@ export class BindingThread {
             isInteger: (name) => SHELL_INTEGER_VARIABLES.has(name) || given(name, j, true),
             ifsTouched: touched("IFS"),
             homeTouched: this.homeStartsTouched || touched("HOME"),
-            floorOf: (name) => this.entries.filter((e) => e.at < j && e.name === name).flatMap((e) => e.floor ?? []),
+            floorOf: (name) => [...(this.startFloors.get(name) ?? []), ...this.entries.filter((e) => e.at < j && e.name === name).flatMap((e) => e.floor ?? [])],
             inherited: this.inheritedAt(j),
         };
     }

package/dist/tools/fs/shell-read-establish.js

@@ -57,11 +57,10 @@ function parseBracketExpression(pattern, start) {
             return { source: anyChar ? "[^/]" : `[${negate ? "^" : ""}${body}]`, end: i };
         }
         if (ch === "[" && (pattern[i + 1] === ":" || pattern[i + 1] === "." || pattern[i + 1] === "=")) {
-            const close = pattern.indexOf(`${pattern[i + 1]}]`, i + 2);
-            if (close < 0)
-                return undefined;
             anyChar = true;
-            i = close + 1;
+            const close = pattern.indexOf(`${pattern[i + 1]}]`, i + 2);
+            if (close >= 0 && (pattern[i + 1] === ":" ? /^[A-Za-z]+$/.test(pattern.slice(i + 2, close)) : close === i + 3))
+                i = close + 1;
             continue;
         }
         body += ch === "-" ? "-" : ch.replace(/[\]\\^]/g, "\\$&");

package/dist/tools/fs/shell-read-plan.d.ts

@@ -30,9 +30,9 @@
  * Every ambiguity resolves toward MORE candidates, never fewer.
  */
 import { type LenientConnector, type LexedRedirect, type LexedWord } from "../../shell/lex.js";
-import { type BindingTable, type NameReader } from "./shell-read-bindings.js";
 import { type ShellScanDecline } from "./bash-program-position.js";
 import { type StdinText } from "./shell-reentry-text.js";
+import { type PlanStart } from "./shell-read-start.js";
 /** WHY a word is a read candidate — a closed set, registered in `docs/CLOSED-SETS.md`. */
 export declare const READ_CANDIDATE_PROVENANCES: readonly ["operand", "option_value", "stdin_redirect", "write_redirect_target", "env_assignment", "unlisted_word", "traversal_root", "cd_target", "program_path", "script_slot_file", "mount_source", "object_path"];
 export type ReadCandidateProvenance = (typeof READ_CANDIDATE_PROVENANCES)[number];
@@ -142,18 +142,5 @@ export interface ShellReadPlan {
         readonly strayRedirection: boolean;
     };
 }
-/** Where a nested text starts its names: a substitution body inherits the table of the segment it sits in (a subshell
- *  holds every variable); a text the shell runs later or elsewhere (a code body, `eval`'s text, a child shell's `-c`)
- *  starts from the text's own start — every name unknown, `HOME` the declared home unless the enclosing text binds it
- *  anywhere. `boundAnywhere` answers for the enclosing texts. */
-interface PlanStart {
-    readonly initial: NameReader;
-    readonly boundAnywhere: (name: string) => boolean;
-    /** `HOME` may already hold something other than the declared home where the nested text starts. */
-    readonly homeTouched: boolean;
-    /** The attributes and name references in force where the nested text starts. */
-    readonly inherited: BindingTable["inherited"];
-}
 /** Plan every read candidate of one command (the contract is this module's header). */
 export declare function planShellReads(command: string, decl: ShellReadDeclarations, depth?: number, start?: PlanStart): ShellReadPlan;
-export {};