@sema-agent/core 7.46.0 → 7.48.0

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

@@ -1,7 +1,24 @@
 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 || a.fields?.length !== b.fields?.length)
+        return false;
+    if (a.glob !== true || b.glob !== true)
+        return a.glob === b.glob;
+    return a.parts.length === b.parts.length && a.parts.every((p, i) => p.text === b.parts[i].text && p.pattern === b.parts[i].pattern);
+}
 export const SHELL_INTEGER_VARIABLES = new Set([
     "RANDOM", "SECONDS", "LINENO", "OPTIND", "MAILCHECK", "HISTCMD", "SRANDOM", "EPOCHSECONDS", "EPOCHREALTIME", "BASHPID", "BASH_MONOSECONDS",
     "BASH_TRAPSIG", "COLUMNS", "LINES", "SHLVL", "ERRNO", "TMOUT", "HISTSIZE", "SAVEHIST", "TRY_BLOCK_ERROR", "TRY_BLOCK_INTERRUPT", "KEYTIMEOUT",
@@ -196,62 +213,157 @@ 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()) {
-    const pieces = word.pieces;
-    if (!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;
-    if (table === undefined)
-        return "unknown";
-    const start = pieces[0]?.span[0] ?? 0;
-    const raw = word.raw;
-    let combos = [{ text: "", glob: false }];
-    const stateOf = (name) => overlay.get(name) ?? table.stateOf(name);
-    for (const p of pieces) {
+    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;
-        let options;
-        if (e === undefined) {
-            if (p.literal === undefined)
-                return "unknown";
-            options = [{ spelled: p.literal }];
-        }
-        else if (e.kind === "glob") {
-            const written = raw === undefined ? undefined : raw.slice(p.span[0] - start, p.span[1] - start);
-            if (written === undefined)
-                return "unknown";
-            options = [{ spelled: written, glob: true }];
-        }
-        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 || state.some((v) => v.glob === true || !ONE_WORD.test(v.spelled))))
-                return "unknown";
-            options = state;
+        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));
+}
+function joinRuns(runs, more) {
+    const out = [...runs];
+    for (const r of more) {
+        const last = out[out.length - 1];
+        if (last !== undefined && last.pattern && r.pattern)
+            out[out.length - 1] = { text: last.text + r.text, pattern: true, judged: last.judged + r.judged };
+        else if (last !== undefined && !last.pattern && !r.pattern)
+            out[out.length - 1] = { text: last.text + r.text, pattern: false };
+        else if (r.text !== "")
+            out.push(r);
+    }
+    return out;
+}
+export function valueOf(word, table, quoted, overlay = new Map(), split = false) {
+    const stateOf = (name) => (table === undefined ? "unknown" : overlay.get(name) ?? table.stateOf(name));
+    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
-            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 });
+        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)
-        if (!out.some((v) => v.spelled === c.text && (v.glob === true) === c.glob))
-            out.push(c.glob ? { spelled: c.text, glob: true } : { spelled: c.text });
+    for (const c of combos) {
+        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);
+    }
     return out;
 }
 export function wordFloorValues(word, table) {
@@ -268,32 +380,28 @@ 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 valueOf(word, table, quoted, overlay = new Map()) {
-    const values = wordValues(word, table, quoted, overlay);
-    if (values !== undefined)
-        return values;
-    if (word.pieces.every((p) => p.expansion === undefined && p.literal !== undefined))
-        return [{ spelled: word.pieces.map((p) => p.literal).join("") }];
-    const folded = word.folded;
-    if (folded !== undefined && word.pieces.every((p) => p.expansion === undefined ? p.literal !== undefined : p.expansion.kind === "glob"))
-        return [{ spelled: folded, glob: true }];
-    return "unknown";
+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 = [];
@@ -344,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;
@@ -372,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;
@@ -481,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 }];
     });
@@ -541,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;
@@ -548,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))];
@@ -555,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) {
@@ -652,7 +767,7 @@ export class BindingThread {
                 return "unknown";
             const values = [];
             const add = (vs) => { for (const v of vs)
-                if (!values.some((x) => x.spelled === v.spelled && x.glob === v.glob))
+                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];
@@ -679,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, "\\$&");
@@ -557,7 +556,7 @@ export function createShellReadEstablisher(env, readRoots, opts) {
                 for (const m of walkedTree.members)
                     out.push({ ...(await canonicalReadOf(candidate, m.path, [m.path], "expansion", folded, m.canonical, signal)), node: m.node, walked: true });
             };
-            for (const lexical of lexicalReadsOf(candidate, boundary)) {
+            for (const [i, lexical] of lexicalReadsOf(candidate, boundary).entries()) {
                 if (lexical.established !== "lexical") {
                     out.push(lexical);
                     continue;
@@ -567,7 +566,7 @@ export function createShellReadEstablisher(env, readRoots, opts) {
                 const walked = spellings.find((s) => s !== folded) ?? folded;
                 if (candidate.expands === "glob") {
                     let matched = false;
-                    for (const p of spellings) {
+                    for (const p of candidate.pattern === undefined ? spellings : lexicalReadsOf({ ...candidate, spelled: candidate.pattern }, boundary)[i]?.spellings ?? spellings) {
                         const expanded = await expandGlobCandidate(p, roots, signal);
                         if (expanded !== undefined && "unverifiable" in expanded) {
                             out.push({ candidate, established: "unestablishable", spellings, origin: folded, cause: expanded.unverifiable });
@@ -581,7 +580,7 @@ export function createShellReadEstablisher(env, readRoots, opts) {
                                     await land(read, spellings, folded);
                         }
                     }
-                    if (!matched)
+                    if (!matched || candidate.pattern !== undefined)
                         for (const read of await atSeats(walked, spellings, "canonical", undefined, undefined))
                             await land(read, spellings, folded);
                     continue;

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];
@@ -49,8 +49,9 @@ export interface ShellReadDeclarations {
     readonly face?: "open" | "roots";
 }
 export interface ReadCandidate {
-    /** The folded word (quotes removed, a literal leading tilde spelled `./~`). */
+    /** The folded word (quotes removed, a literal leading tilde spelled `./~`) — a pattern's name where nothing matches. */
     readonly spelled: string;
+    /** The spelling a pattern's names are matched by where the matcher widens a class (`["!"a]`, `[[:alpha:]]`: any one character). */ readonly pattern?: string;
     /** The raw spelling, quotes retained — where "is this metacharacter quoted" is still answerable. */
     readonly raw: string;
     readonly provenance: ReadCandidateProvenance;
@@ -141,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 {};