@sema-agent/core 7.47.0 → 7.49.0

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

@@ -1,9 +1,21 @@
 import { argvOf, lexShell, literalTildeSpelling, substitutionsInHeredocBody } from "../../shell/lex.js";
-import { readProgramPosition } from "./bash-program-position.js";
+import { shellWordsOf } from "../../shell/shell-words.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";
+import { BUILTIN_ENABLED, BUILTINS_ALL, ENABLE_BUILTIN, builtinKey, chainAvailability, enableBindings, isBuiltinKey, isDisabledValue, speaksFor } from "./shell-read-builtins.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;
@@ -15,53 +27,62 @@ export const SHELL_INTEGER_VARIABLES = new Set([
     "LISTMAX", "LOGCHECK", "PERIOD", "FUNCNEST", "UID", "EUID", "GID", "EGID", "REPORTTIME", "REPORTMEMORY", "DIRSTACKSIZE", "BAUD",
     "ZLE_RPROMPT_INDENT", "MBEGIN", "MEND", "PPID", "ARGC", "ZSH_SUBSHELL", "TTYIDLE", "status",
 ]);
-const SHELL_SET_VARIABLES = new Set(["PWD", "OLDPWD", "REPLY", "OPTARG", "MAPFILE", "BASH_REMATCH", "PIPESTATUS", "FUNCNAME", "BASH_COMMAND", "BASH_SUBSHELL", "COPROC", "GROUPS", "SHELLOPTS", "BASHOPTS", "BASH_VERSINFO"]);
+const SHELL_SET_VARIABLES = new Set(["REPLY", "OPTARG", "MAPFILE", "BASH_REMATCH", "PIPESTATUS", "FUNCNAME", "BASH_COMMAND", "BASH_SUBSHELL", "COPROC", "GROUPS", "SHELLOPTS", "BASHOPTS", "BASH_VERSINFO"]);
 export function shellKeepsName(name) {
     return SHELL_INTEGER_VARIABLES.has(name) || SHELL_SET_VARIABLES.has(name);
 }
-const OPENING_WORDS = new Set(["if", "case", "for", "while", "until", "select", "{"]);
-const CLOSING_WORDS = new Set(["fi", "esac", "done", "}"]);
-const SWITCHING_WORDS = new Set(["else", "elif"]);
-const SPECIAL_BUILTINS = new Set([":", ".", "break", "continue", "eval", "exec", "exit", "export", "readonly", "return", "set", "shift", "source", "times", "trap", "unset"]);
+export const WORKING_DIRECTORY_NAMES = Object.freeze(["PWD", "OLDPWD"]);
+const isWorkingDirectoryName = (name) => name === "PWD" || name === "OLDPWD";
+const OPENING_WORDS = shellWordsOf("scope_open");
+const CLOSING_WORDS = shellWordsOf("scope_close");
+const SWITCHING_WORDS = shellWordsOf("scope_switch");
+const GROUP_WORDS = shellWordsOf("group"), DEFINITION_WORDS = shellWordsOf("definition"), ITERATING_HEADS = shellWordsOf("loop_iterates"), BACKGROUND_WORDS = shellWordsOf("background");
+export const SPECIAL_BUILTINS = new Set([":", ".", "break", "continue", "eval", "exec", "exit", "export", "readonly", "return", "set", "shift", "source", "times", "trap", "unset"]);
 const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const LOCAL_DECLARATION = "local";
+const FUNCTION_KEY_PREFIX = "()";
+export const functionKey = (name) => FUNCTION_KEY_PREFIX + name;
+const isFunctionKey = (name) => name.startsWith(FUNCTION_KEY_PREFIX);
+const FUNCTION_DEFINED = [{ spelled: "defined" }];
+const FUNCTION_ABSENT = [{ spelled: "absent" }];
+const isDefinedValue = (v) => v.spelled === "defined";
 const ATTRIBUTE_KINDS = { integer: "integer", transformed: "transformed", frozen: "frozen" };
 const EVERY_ATTRIBUTE = Object.values(ATTRIBUTE_KINDS).map((kind) => ({ kind }));
 export function projectSegment(segment) {
     const tokens = [...segment.tokens];
     let grouped = tokens.some((t) => t.kind === "group");
-    const definesFunction = dropDefinitionHeads(tokens).some((n) => n > 0);
+    const defines = dropDefinitionHeads(tokens).flat();
     dropCasePattern(tokens);
     const words = tokens.filter((t) => {
         if (t.kind !== "word")
             return false;
-        if (t.raw === t.folded && (t.folded === "{" || t.folded === "}")) {
+        if (t.raw === t.folded && GROUP_WORDS.has(t.folded)) {
             grouped = true;
             return false;
         }
         return true;
     });
-    return { argv: words, redirects: tokens.filter((t) => t.kind === "redirect"), grouped, definesFunction };
+    return { argv: words, redirects: tokens.filter((t) => t.kind === "redirect"), grouped, defines };
 }
 function isDefinitionName(word) {
     return IDENTIFIER.test(word.folded) || (word.atCommandPosition && word.expansions.length === 0 && !/[?*+@!]$/.test(word.raw));
 }
 export function dropDefinitionHeads(tokens) {
-    const heads = new Array(tokens.length + 1).fill(0);
-    const drop = (k, count) => {
+    const heads = Array.from({ length: tokens.length + 1 }, () => []);
+    const drop = (k, count, name) => {
         tokens.splice(k, count);
         heads.splice(k, count);
-        heads[k]++;
+        heads[k].push(name);
     };
     for (let k = 0; k + 1 < tokens.length; k++) {
         const [a, b, c, d] = [tokens[k], tokens[k + 1], tokens[k + 2], tokens[k + 3]];
-        if (a.kind === "word" && a.raw === "function" && a.atCommandPosition && b.kind === "word") {
-            drop(k--, c?.kind === "group" && c.op === "(" && d?.kind === "group" && d.op === ")" ? 4 : 2);
-        }
+        if (a.kind === "word" && DEFINITION_WORDS.has(a.raw) && a.atCommandPosition && b.kind === "word")
+            drop(k--, c?.kind === "group" && c.op === "(" && d?.kind === "group" && d.op === ")" ? 4 : 2, b.folded);
     }
     for (let k = 0; k + 2 < tokens.length; k++) {
         const [a, b, c] = [tokens[k], tokens[k + 1], tokens[k + 2]];
         if (a.kind === "word" && b.kind === "group" && b.op === "(" && c.kind === "group" && c.op === ")" && isDefinitionName(a))
-            drop(k, 3);
+            drop(k, 3, a.folded);
     }
     return heads;
 }
@@ -98,6 +119,8 @@ function extglobParen(tokens, at) {
 function blockStructure(segments) {
     let depth = 0;
     let bodies = 0;
+    let subshellIds = 0;
+    const subshellStack = [];
     const frames = [];
     const deeper = () => {
         depth++;
@@ -113,9 +136,13 @@ function blockStructure(segments) {
     return segments.map((segment) => {
         const tokens = [...segment.tokens];
         const heads = dropDefinitionHeads(tokens);
+        const defs = [];
         const startBodies = (k) => {
-            for (let n = heads[k]; n > 0; n--)
+            for (const name of heads[k]) {
+                const enclosing = innermost();
+                defs.push({ name, standing: { ...(enclosing !== undefined ? { body: enclosing } : {}), subshells: [...subshellStack], depth } });
                 frames.push({ body: { id: bodies++, base: depth }, opened: false });
+            }
         };
         const arithmetic = isArithmeticCommand(segment);
         const patternEnd = casePatternEnd(tokens);
@@ -123,6 +150,7 @@ function blockStructure(segments) {
         const open = [];
         let lowest = depth;
         let words;
+        let subshells;
         let body;
         const switches = [];
         const innermost = () => [...frames].reverse().find((f) => f.opened)?.body;
@@ -140,6 +168,7 @@ function blockStructure(segments) {
                     if (k <= patternEnd)
                         return;
                     deeper();
+                    subshellStack.push(subshellIds++);
                     return;
                 }
                 const from = open.pop();
@@ -151,6 +180,7 @@ function blockStructure(segments) {
                     return;
                 }
                 shallower();
+                subshellStack.pop();
                 lowest = Math.min(lowest, depth);
                 return;
             }
@@ -167,6 +197,7 @@ function blockStructure(segments) {
                 switches.push(depth);
             else if (k > patternEnd) {
                 words ??= depth;
+                subshells ??= [...subshellStack];
                 body = innermost();
             }
         };
@@ -200,17 +231,54 @@ function blockStructure(segments) {
         while (frames.length > 0 && frames[frames.length - 1].flat === true)
             frames.pop();
         startBodies(tokens.length);
-        return { words: words ?? depth, after: depth, lowest, switches, ...(body !== undefined ? { body } : {}) };
+        return { words: words ?? depth, after: depth, lowest, switches, subshells: subshells ?? [...subshellStack], defs, ...(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;
+    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;
-    return valueOf(word, table, quoted, overlay);
+    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 +292,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 }];
+    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 === "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 }] }];
-        }
-        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,25 +401,32 @@ 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 bindingEffectOf(segment, argv, shape, readValue) {
+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, shadow, availability) {
     const bindings = [];
-    let all = shape.definesFunction ? "reset" : undefined;
+    let all = shape.defines.length > 0 ? "reset" : undefined;
     const unknownAll = () => void (all = "unknown");
     const overlay = new Map();
     let scope;
@@ -316,6 +436,8 @@ export function bindingEffectOf(segment, argv, shape, readValue) {
             overlay.set(b.name, b.state);
     };
     const kill = (name) => bind({ name, state: "unknown" });
+    for (const name of shape.defines)
+        bind({ name: functionKey(name), state: FUNCTION_DEFINED });
     const nameOf = (w) => {
         if (w.pieces.some((p) => p.expansion !== undefined || p.literal === undefined))
             return "computed";
@@ -353,21 +475,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 (ITERATING_HEADS.has(headWord) && 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 +503,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] !== undefined && BACKGROUND_WORDS.has(argv[0].raw) && argv[1] !== undefined)
         killNamed(nameOf(argv[1]));
     const pos = readProgramPosition(argv);
     const program = pos.program;
@@ -401,9 +523,20 @@ export function bindingEffectOf(segment, argv, shape, readValue) {
         unknownAll();
         return { bindings, all, attributes: EVERY_ATTRIBUTE, references: true };
     }
-    if (program === undefined || row === undefined)
+    if (program === undefined || shadow === "named")
+        return { bindings, all };
+    const settled = bindings.length;
+    const runsAsBuiltin = program.name === program.basename && pos.launchers.every((l, i) => (l.name === "builtin" || l.name === "command") && argv[l.index].folded === l.name && l.index + 1 === (pos.launchers[i + 1]?.index ?? program.index)) && !segment.tokens.some((t) => t.kind === "redirect" || t.kind === "heredoc");
+    const available = runsAsBuiltin ? chainAvailability([...pos.launchers.map((l) => l.name), program.basename], availability) : "enabled";
+    if (available === "disabled")
         return { bindings, all };
+    const mayNotRun = shadow === "maybe" || available === "maybe" || (!runsAsBuiltin && (row?.builtin === "declaration" || program.basename === ENABLE_BUILTIN));
+    const finish = (e) => (mayNotRun ? { ...e, bindings: e.bindings.map((b, i) => (i < settled ? b : { ...b, prefix: true })) } : e);
     const args = argv.slice(program.index + 1);
+    if (program.basename === ENABLE_BUILTIN)
+        return finish({ bindings: [...bindings, ...enableBindings(args)], all });
+    if (row === undefined)
+        return { bindings, all };
     const folded = args.map((w) => w.folded);
     if (row.reentry?.kind === "shell" && (row.reentry.text === "words" || row.reentry.text === "file-operand"))
         unknownAll();
@@ -416,7 +549,7 @@ export function bindingEffectOf(segment, argv, shape, readValue) {
                 kill(name);
     }
     if (row.builtin === "declaration") {
-        scope = args.some((w) => w.folded.startsWith("-") || w.folded.startsWith("+")) ? "unread" : program.basename === "local" ? "local" : undefined;
+        scope = args.some((w) => w.folded.startsWith("-") || w.folded.startsWith("+")) ? "unread" : program.basename === LOCAL_DECLARATION ? "local" : undefined;
         const assigns = declaredAttributes(row, folded);
         const kinds = [...assigns].filter((k) => k !== "reference" && k !== "unsettled");
         const storesText = [...assigns].every((k) => k === "frozen");
@@ -443,12 +576,19 @@ export function bindingEffectOf(segment, argv, shape, readValue) {
                 bind({ name, state: assignedState(a, readValue, expanded) });
             attributes.push(...kinds.map((kind) => ({ name, kind })));
         }
-        const inFunction = program.basename === "local" ? { inFunction: true } : {};
+        const inFunction = program.basename === LOCAL_DECLARATION ? { inFunction: true } : {};
         if (references) {
             unknownAll();
-            return { bindings, all, attributes, references: true, ...inFunction };
+            return finish({ bindings, all, attributes, references: true, ...inFunction });
         }
-        return { bindings, all, attributes, ...inFunction };
+        return finish({ bindings, all, attributes, ...inFunction });
+    }
+    if (program.basename === "unset") {
+        const { operands, variablesOnly } = unsetOperands(args);
+        if (!variablesOnly)
+            for (const w of operands)
+                if (w.pieces.every((p) => p.literal !== undefined && p.expansion === undefined))
+                    bind({ name: functionKey(w.folded), state: FUNCTION_ABSENT, prefix: true });
     }
     for (const e of readArgRoles(row, folded)) {
         const role = e.kind === "value" || e.kind === "operand" ? e.role : e.kind === "option" && typeof e.reading === "object" ? e.reading.role : undefined;
@@ -468,11 +608,32 @@ export function bindingEffectOf(segment, argv, shape, readValue) {
     const nameLetters = new Set(row.grammars.flatMap((g) => Object.entries(g.short).flatMap(([letter, s]) => (s.value?.kind === "binds-name" ? [letter] : []))));
     if (nameLetters.size > 0 && readArgRoles(row, folded).some((e) => e.kind === "option" && e.reading === "speculative" && [...folded[e.at].slice(1)].some((ch) => nameLetters.has(ch))))
         unknownAll();
-    return { bindings, all };
+    return finish({ bindings, all });
 }
 function nameIn(text) {
     return /^([A-Za-z_][A-Za-z0-9_]*)(?:\[.*\])?$/s.exec(text)?.[1];
 }
+function unsetOperands(args) {
+    let variables = false;
+    let otherwise = false;
+    let at = 0;
+    for (; at < args.length; at++) {
+        const w = args[at].folded;
+        if (w === "--") {
+            at++;
+            break;
+        }
+        if (!/^-./.test(w))
+            break;
+        for (const letter of w.slice(1)) {
+            if (letter === "v" || letter === "n")
+                variables = true;
+            else
+                otherwise = true;
+        }
+    }
+    return { operands: args.slice(at), variablesOnly: variables && !otherwise };
+}
 function compoundElementWords(raw) {
     const inner = /^\(([\s\S]*)\)$/.exec(raw)?.[1];
     const l = inner === undefined ? undefined : lexShell(inner);
@@ -490,7 +651,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 }];
     });
@@ -538,6 +699,11 @@ export function textBindsHome(text) {
     return names === "all" || names.has("HOME");
 }
 const NOTHING_INHERITED = { attributes: [], references: false };
+export function joinRebound(a, b) {
+    if (a === "all" || b === "all")
+        return "all";
+    return new Set([...(a ?? []), ...(b ?? [])]);
+}
 export class BindingThread {
     segments;
     named;
@@ -545,40 +711,186 @@ export class BindingThread {
     boundAnywhere;
     loops;
     homeStartsTouched;
+    inheritedFunctions;
     entries = [];
+    localDeclarations = [];
     attributesAt;
     unreadable;
     blocks;
-    detached;
-    constructor(segments, named, initial, boundAnywhere, loops, homeStartsTouched = false, inherited = NOTHING_INHERITED) {
+    ownSubshell;
+    startFloors;
+    startRebound;
+    bodyRuns = { limit: -1, environment: [] };
+    constructor(segments, named, initial, boundAnywhere, loops, homeStartsTouched = false, inherited = NOTHING_INHERITED, inheritedFunctions) {
         this.segments = segments;
         this.named = named;
         this.initial = initial;
         this.boundAnywhere = boundAnywhere;
         this.loops = loops;
         this.homeStartsTouched = homeStartsTouched;
+        this.inheritedFunctions = inheritedFunctions;
+        this.startFloors = inherited.floors ?? new Map();
+        this.startRebound = inherited.rebound ?? new Set();
         this.blocks = blockStructure(segments);
-        this.detached = segments.map((s, i) => s.connector === "|" || segments[i + 1]?.connector === "|" || segments[i + 1]?.connector === "&");
+        this.ownSubshell = segments.map((_, i) => segments[i + 1]?.connector === "|" || segments[i + 1]?.connector === "&");
         this.unreadable = [...(inherited.references ? [{ at: -1 }] : []), ...named.flatMap((effect, at) => this.unreadableBy(effect, at))];
         this.attributesAt = [...inherited.attributes.map((a) => ({ ...a, at: -1 })), ...named.flatMap((effect, at) => (effect.attributes ?? []).map((a) => ({ ...a, at })))];
     }
     inheritedAt(j) {
         const holds = (at) => j === undefined || this.mayRunBefore(at, j);
+        const reaches = (e) => j === undefined || (this.mayRunBefore(e.at, j) && this.visible(e, 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]);
+        let rebound = this.startRebound;
+        for (const e of this.entries)
+            if (e.state !== "reset" && reaches(e))
+                rebound = joinRebound(rebound, e.name === undefined ? "all" : [e.name]);
+        for (const u of this.unreadable)
+            if (j === undefined || this.lostAt(u, j))
+                rebound = joinRebound(rebound, u.name === undefined ? "all" : [u.name]);
+        rebound = joinRebound(rebound, this.boundLater(j));
         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 } : {}),
+            rebound,
         };
     }
+    startOf(name) {
+        return isFunctionKey(name) ? this.inheritedFunctions?.start(name) ?? FUNCTION_ABSENT : isBuiltinKey(name) ? this.inheritedFunctions?.start(name) ?? BUILTIN_ENABLED : this.initial(name);
+    }
+    bindsInText(name) {
+        return this.named.some((effect) => effect.all === "unknown" || effect.bindings.some((b) => speaksFor(b.name, name)));
+    }
+    heldAnywhere() {
+        const start = (key) => {
+            const own = this.startOf(key);
+            if (own === "unknown")
+                return own;
+            const values = [...own];
+            for (const effect of this.named) {
+                if (effect.all === "unknown")
+                    return "unknown";
+                for (const b of effect.bindings) {
+                    if (!speaksFor(b.name, key))
+                        continue;
+                    if (b.state === "unknown")
+                        return "unknown";
+                    for (const v of b.state)
+                        if (!values.some((x) => sameValue(x, v)))
+                            values.push(v);
+                }
+            }
+            return values;
+        };
+        return { start, bound: new Set() };
+    }
+    runsBodies(runs, atEnd, environment) {
+        let limit = atEnd ? this.named.length - 1 : -1;
+        runs.forEach((r, si) => {
+            if (!r)
+                return;
+            limit = Math.max(limit, si);
+            for (const [head, end] of this.loops)
+                if (head <= si && si < end)
+                    limit = Math.max(limit, end);
+        });
+        this.bodyRuns = { limit, environment };
+        const calling = new Set(runs.flatMap((r, si) => (r && this.blocks[si].body !== undefined ? [this.blocks[si].body.id] : [])));
+        this.named.forEach((effect, at) => {
+            for (const b of effect.bindings) {
+                const body = this.standingOf(at, b.name).body;
+                if (body !== undefined && calling.has(body.id))
+                    this.unreadable.push({ at, name: b.name, body });
+            }
+        });
+    }
+    boundLater(j) {
+        const out = new Set();
+        if (j !== undefined && this.blocks[j].body === undefined)
+            return out;
+        const limit = j === undefined ? this.named.length - 1 : this.bodyRuns.limit;
+        for (let s = j === undefined ? 0 : j + 1; s <= limit; s++) {
+            const effect = this.named[s];
+            if (effect.all === "unknown" || effect.references === true)
+                return "all";
+            for (const b of effect.bindings)
+                out.add(b.name);
+            const environment = this.bodyRuns.environment[s];
+            if (environment === "all")
+                return "all";
+            for (const name of environment ?? [])
+                out.add(name);
+        }
+        return out;
+    }
+    ownSubshellAt(at, standing) {
+        return this.ownSubshell[at] === true && standing.depth >= this.blocks[at].after;
+    }
+    detachedAt(at, standing) {
+        return this.segments[at].connector === "|" || this.ownSubshellAt(at, standing);
+    }
+    visible(e, j) {
+        const reader = j === undefined ? undefined : this.blocks[j];
+        if (e.standing.body !== undefined && reader?.body?.id !== e.standing.body.id)
+            return false;
+        if (j !== e.at && this.ownSubshellAt(e.at, e.standing))
+            return false;
+        const around = reader?.subshells ?? [];
+        return e.standing.subshells.every((id) => around.includes(id));
+    }
+    standingOf(at, name) {
+        const own = this.blocks[at];
+        const head = name !== undefined && isFunctionKey(name) ? own.defs.find((d) => functionKey(d.name) === name) : undefined;
+        return head?.standing ?? { ...(own.body !== undefined ? { body: own.body } : {}), subshells: own.subshells, depth: own.words };
+    }
+    functionBound() {
+        const out = new Set();
+        if (this.inheritedFunctions?.bound === "all")
+            return "all";
+        for (const name of this.inheritedFunctions?.bound ?? [])
+            out.add(name);
+        for (let at = 0; at < this.named.length; at++) {
+            const effect = this.named[at];
+            if (this.blocks[at].body !== undefined && (effect.all === "unknown" || effect.references === true))
+                return "all";
+            for (const b of effect.bindings) {
+                const own = this.bodyBinding(b, at);
+                if (own !== undefined && (b.scope === "unread" || !this.declaredLocal(b.name, at, own)))
+                    out.add(b.name);
+            }
+        }
+        return out;
+    }
+    bodyBinding(b, at) {
+        const own = this.standingOf(at, b.name).body;
+        return own !== undefined && b.scope !== "local" ? own : undefined;
+    }
+    inFunctionBody(at) {
+        return this.blocks[at].body !== undefined;
+    }
+    runsApart(at) {
+        return this.blocks[at].subshells.length > 0 || this.ownSubshell[at] === true || this.blocks[at].body !== undefined;
+    }
+    runsLater(at, names) {
+        if (names === "all")
+            this.unreadable.push({ at });
+        else
+            for (const name of names)
+                this.unreadable.push({ at, name });
+    }
     unreadableBy(effect, at) {
         const body = this.blocks[at].body;
         const out = [];
-        if (body !== undefined) {
-            for (const b of effect.bindings)
-                if (b.scope !== "local" && (b.scope === "unread" || !this.declaredLocal(b.name, at, body)))
-                    out.push({ at, name: b.name, body });
-            if (effect.all === "unknown")
-                out.push({ at, body });
+        for (const b of effect.bindings) {
+            const own = this.bodyBinding(b, at);
+            if (own !== undefined)
+                out.push({ at, name: b.name, body: own });
         }
+        if (body !== undefined && effect.all === "unknown")
+            out.push({ at, body });
         if (effect.references === true)
             out.push({ at });
         return out;
@@ -589,107 +901,139 @@ export class BindingThread {
         return this.blocks[e].body !== undefined || [...this.loops].some(([head, end]) => head <= e && x < end);
     }
     declaredLocal(name, at, body) {
-        for (let k = 0; k < at; k++) {
-            const connector = this.segments[k].connector;
-            if (this.blocks[k].body?.id !== body.id || this.detached[k] === true || connector === "&&" || connector === "||")
-                continue;
-            if (this.named[k].bindings.some((b) => b.scope === "local" && b.name === name) && this.heldThrough(k, at))
-                return true;
-        }
-        return false;
+        return this.localDeclarations.some((d) => d.body === body.id && d.name === name && d.at < at && this.heldThrough(d, at));
     }
-    heldThrough(at, j) {
-        const depth = this.blocks[at].words;
-        if (this.blocks[at].after < depth)
+    heldThrough(e, j) {
+        const depth = e.standing.depth;
+        if (this.blocks[e.at].after < depth)
             return false;
-        for (let k = at + 1; k <= j; k++)
+        for (let k = e.at + 1; k <= j; k++)
             if (this.blocks[k].lowest < depth || this.blocks[k].switches.includes(depth))
                 return false;
         return true;
     }
     apply(at, effect, andRun, loopEnd) {
-        const detached = this.detached[at] === true;
-        const refused = effect.inFunction === true && this.blocks[at].body === undefined;
+        const body = this.blocks[at].body;
+        const refused = effect.inFunction === true && body === undefined;
         if (effect.all !== undefined)
-            this.entries.push({ at, state: effect.all === "reset" ? "reset" : "unknown", detached: false, andRun: false });
+            this.entries.push({ at, standing: this.standingOf(at), state: effect.all === "reset" ? "reset" : "unknown", detached: false, andRun: false });
         for (const b of effect.bindings) {
+            const standing = this.standingOf(at, b.name);
+            const detached = this.detachedAt(at, standing) || b.prefix === true;
             this.entries.push({
-                at, name: b.name, state: refused ? "unknown" : b.state, detached: detached || b.prefix === true, andRun,
+                at, standing, name: b.name, state: refused ? "unknown" : b.state, detached, andRun,
                 ...(b.loopVar === true && loopEnd !== undefined ? { certainUntil: loopEnd } : {}),
                 ...(b.floor !== undefined && b.floor.length > 0 ? { floor: b.floor } : {}),
             });
+            if (b.scope === "local" && body !== undefined && !refused && !detached && !andRun)
+                this.localDeclarations.push({ at, name: b.name, body: body.id, standing });
         }
     }
-    leftBody(at, body, j) {
-        if (this.blocks[at].after <= body.base)
-            return true;
-        for (let k = at + 1; k <= j; k++)
-            if (this.blocks[k].lowest <= body.base)
-                return true;
-        return false;
+    lostAt(u, j) {
+        if (u.body === undefined)
+            return this.mayRunBefore(u.at, j);
+        const readerBody = this.blocks[j].body;
+        return readerBody !== undefined && readerBody.id !== u.body.id;
     }
     kill(at, names) {
+        const standing = this.standingOf(at);
         if (names === "all") {
-            this.entries.push({ at, state: "unknown", detached: false, andRun: false });
+            this.entries.push({ at, standing, state: "unknown", detached: false, andRun: false });
             return;
         }
         for (const name of names)
-            this.entries.push({ at, name, state: "unknown", detached: false, andRun: false });
+            this.entries.push({ at, standing, name, state: "unknown", detached: false, andRun: false });
     }
-    tableAt(j, andRunStart) {
+    tableAt(j, andRunStart, where) {
         const certain = (e) => {
             if (e.certainUntil !== undefined && j < e.certainUntil)
                 return true;
-            if (e.detached || !this.heldThrough(e.at, j))
+            if (e.detached || !this.heldThrough(e, j))
                 return false;
             return !e.andRun || e.at >= andRunStart;
         };
         const readerBody = this.blocks[j].body;
-        const lost = (u) => {
-            if (u.body === undefined)
-                return this.mayRunBefore(u.at, j);
-            if (readerBody !== undefined && readerBody.id !== u.body.id)
-                return true;
-            return u.at < j && this.leftBody(u.at, u.body, j);
-        };
-        const before = (e) => e.at < j || (e.at === j && e.state === "reset");
+        const lost = (u) => this.lostAt(u, j);
+        const before = (e) => (e.at < j || (e.at === j && e.state === "reset")) && this.visible(e, j);
         const given = (name, at, integer) => this.attributesAt.some((x) => (x.name === undefined || x.name === name) && (integer !== true || x.kind === "integer") && x.at !== at && this.mayRunBefore(x.at, at));
-        const stateOf = (name) => {
-            if (shellKeepsName(name))
-                return "unknown";
-            if (this.unreadable.some((u) => (u.name === undefined || u.name === name) && lost(u)))
-                return "unknown";
+        const walk = (name, start) => {
             const values = [];
             const add = (vs) => { for (const v of vs)
                 if (!values.some((x) => sameValue(x, v)))
                     values.push(v); };
             for (let i = this.entries.length - 1; i >= 0; i--) {
                 const e = this.entries[i];
-                if (!before(e) || (e.name !== undefined && e.name !== name))
+                if (!before(e) || (e.name !== undefined && !speaksFor(e.name, name)))
+                    continue;
+                if (e.state === "reset" && isBuiltinKey(name))
                     continue;
-                const state = e.state === "reset" ? (name === "HOME" && this.boundAnywhere("HOME") ? "unknown" : this.initial(name)) : e.state;
+                const state = e.state === "reset" ? ((name === "HOME" && this.boundAnywhere("HOME")) || this.bindsInText(name) ? "unknown" : this.initial(name)) : e.state;
                 if (state === "unknown")
-                    return "unknown";
+                    return { state: "unknown" };
                 if (e.name !== undefined && given(e.name, e.at))
-                    return "unknown";
+                    return { state: "unknown" };
                 add(state);
                 if (certain(e))
-                    return values;
+                    return { state: values, decided: e };
             }
-            const start = this.initial(name);
             if (start === "unknown")
-                return "unknown";
+                return { state: "unknown" };
             add(start);
-            return values;
+            return { state: values };
+        };
+        const later = this.boundLater(j);
+        const boundLater = (name) => later === "all" || later.has(name) || (isBuiltinKey(name) && later.has(BUILTINS_ALL));
+        const stateOf = (name) => {
+            if (shellKeepsName(name))
+                return "unknown";
+            if (this.unreadable.some((u) => speaksFor(u.name, name) && lost(u)))
+                return "unknown";
+            if (!isWorkingDirectoryName(name)) {
+                const walked = walk(name, this.startOf(name));
+                const own = walked.decided !== undefined && walked.decided.state !== "reset" && readerBody !== undefined && walked.decided.standing.body?.id === readerBody.id;
+                return boundLater(name) && !own ? "unknown" : walked.state;
+            }
+            if (boundLater(name))
+                return "unknown";
+            const assigned = walk(name, []);
+            if (assigned.decided !== undefined && where !== undefined && readerBody === undefined && assigned.decided.at > where.movedAt)
+                return assigned.state;
+            const thread = readerBody === undefined ? where?.[name] ?? "unknown" : "unknown";
+            if (thread === "unknown" || assigned.state === "unknown")
+                return "unknown";
+            const held = assigned.state;
+            return [...held, ...thread.filter((v) => !held.some((x) => sameValue(x, v)))];
         };
         const touched = (name) => this.entries.some((e) => before(e) && (e.name === undefined || e.name === name));
+        let rebound = this.startRebound;
+        for (const e of this.entries)
+            if (e.state !== "reset" && (readerBody !== undefined ? e.at !== j : before(e)))
+                rebound = joinRebound(rebound, e.name === undefined ? "all" : [e.name]);
+        for (const u of this.unreadable)
+            if (lost(u))
+                rebound = joinRebound(rebound, u.name === undefined ? "all" : [u.name]);
+        const settled = joinRebound(rebound, later);
         return {
             stateOf,
             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 ?? []),
+            ifsTouched: touched("IFS") || boundLater("IFS"),
+            homeTouched: this.homeStartsTouched || touched("HOME") || boundLater("HOME"),
+            floorOf: (name) => [...(this.startFloors.get(name) ?? []), ...this.entries.filter((e) => e.at < j && e.name === name).flatMap((e) => e.floor ?? [])],
             inherited: this.inheritedAt(j),
+            rebound: settled,
+            providedByShell: (name) => settled !== "all" && !settled.has(name),
+            functionState: (name) => {
+                const held = stateOf(functionKey(name));
+                if (held === "unknown")
+                    return "maybe";
+                return !held.some(isDefinedValue) ? "absent" : held.length > 1 ? "maybe" : "defined";
+            },
+            builtinState: (name) => {
+                const held = stateOf(builtinKey(name));
+                if (held === "unknown")
+                    return "maybe";
+                return held.every(isDisabledValue) ? "disabled" : held.some(isDisabledValue) ? "maybe" : "enabled";
+            },
         };
     }
 }