@sema-agent/core 7.47.0 → 7.49.0

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

@@ -12,11 +12,13 @@
  *    here-document `${`), and resets every name to the state it starts the text in (a function body: it runs at its
  *    call, against that table);
  *  · {@link BindingThread} — the effects threaded through the segments the way the plan threads the working directory
- *    (`shell-read-plan.ts`): a value bound in a segment that may not have run before a reader (an `&&` / `||` run, a
- *    branch, a loop body, a subshell, a pipeline member, a background job) joins the values the name held before
- *    instead of replacing them. A function body runs at its call, which the plan does not follow (a function may be
- *    called anywhere after its definition): a name the body binds is unreadable to every reader past the body, whatever
- *    is assigned to it later, and to every reader in another body — unless the body declared it with a plain `local`.
+ *    (`shell-read-plan.ts`), in their ORDERED state: a binding is one for a reader only where it may run before the
+ *    reader in the same shell — not one written after it, inside a subshell the reader is not in (a closed `( … )`, a
+ *    pipeline member that is not the last, a background job) or in a function body (it runs at a call: a call the plan
+ *    sees makes every name a body binds unknown from there). A value bound in a segment that may not have run before
+ *    a reader (an `&&` / `||` run, a branch, a loop body, the last pipeline member) joins the values the name held
+ *    before instead of replacing them. A reader in a function body loses every name another body binds — unless the
+ *    body declared it with a plain `local`. `PWD` / `OLDPWD` start from what the working-directory thread says.
  *    An attribute and a name reference hold for every segment they may RUN before: a later one, one in a function body
  *    (it runs at its call), one in the same loop body (a later beat).
  *
@@ -26,6 +28,7 @@
  */
 import { type LexedRedirect, type LexedSegment, type LexedToken, type LexedWord } from "../../shell/lex.js";
 import { type DeclaredAttribute } from "./program-read-model.js";
+import { type BuiltinState } from "./shell-read-builtins.js";
 /** A value a name may hold — the text the program receives ({@link spelled}: what a shell re-parsing it reads), literal
  *  throughout, or a PATTERN whose matches are the values (a `for` list word the shell globs before the loop binds it;
  *  `spelled` is then the pattern as the program receives it where it matches nothing): `glob`, with its `parts` — the
@@ -36,10 +39,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,9 +61,20 @@ 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;
 }
-/** What a name holds at one point of a text: its possible values, or `"unknown"`. */
-type NameState = readonly BoundValue[] | "unknown";
+/** 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;
+/** The values a name may hold where the text settles it. */
+export type NameValues = readonly BoundValue[];
+/** What a name holds at one point of a text: its possible values, or `"unknown"`. (The values are a NAMED arm: the
+ *  release manifest reads a union that spells a word as a vocabulary, and a `readonly …[]` arm beside the word is a shape
+ *  it cannot enumerate — it would then publish the set unreadable.) */
+export type NameState = NameValues | "unknown";
 /**
  * The variables bash keeps itself — it sets them (`PWD`, `REPLY`, `OPTARG`, `BASH_REMATCH`, …), holds them read-only
  * (`SHELLOPTS`, `BASHOPTS`, `BASH_VERSINFO`: an assignment to one is refused), or evaluates every value assigned to them
@@ -67,11 +83,32 @@ type NameState = readonly BoundValue[] | "unknown";
  * question, never a read). Their value is never the text that bound it.
  */
 export declare const SHELL_INTEGER_VARIABLES: ReadonlySet<string>;
-/** Is this a variable bash keeps itself ({@link SHELL_INTEGER_VARIABLES}, or one it sets)? */
+/** Is this a variable bash keeps itself ({@link SHELL_INTEGER_VARIABLES}, or one it sets)? The working-directory names
+ *  ({@link WORKING_DIRECTORY_NAMES}) are not: their value is the working-directory thread's ({@link WorkingDirectoryState}). */
 export declare function shellKeepsName(name: string): boolean;
-/** One binding a segment makes: a name and what it now holds (`unknown` = made unknown). `prefix`: a prefix assignment
- *  to a special builtin, which may or may not outlive the command. `loopVar`: a `for` loop's variable, held through
- *  its body. */
+/** The names bash sets when the working directory moves: `PWD` (where the shell stands, as the move spelled it) and
+ *  `OLDPWD` (the `PWD` it stood in before the last move — `cd -` goes there). A text may assign them too. */
+export declare const WORKING_DIRECTORY_NAMES: readonly ["PWD", "OLDPWD"];
+export type WorkingDirectoryName = (typeof WORKING_DIRECTORY_NAMES)[number];
+/** What the working-directory thread (`shell-read-plan.ts`) says the two names hold at one segment, before anything the
+ *  text assigns them: the bases it may stand in (`PWD`) and the ones it stood in before its last move (`OLDPWD`) —
+ *  `unknown` where it lost track, the move's spelling is not the base (a physical move), or the shell inherited it. */
+export type WorkingDirectoryState = {
+    readonly [K in WorkingDirectoryName]: NameState;
+} & {
+    /** The last segment before the reader whose move the thread applied or lost track at (-1: none in this text). */
+    readonly movedAt: number;
+};
+/** The POSIX special builtins: a prefix assignment to one stays after it, and one runs before a function of its name
+ *  (in POSIX mode, which an inherited environment can turn on unseen). */
+export declare const SPECIAL_BUILTINS: ReadonlySet<string>;
+export declare const functionKey: (name: string) => string;
+/** What a function name is at a reader: `defined` — it certainly is one; `absent` — it certainly is not; `maybe` — a branch,
+ *  a loop, a body that may not have run, a removal that may not have found it. */
+export type FunctionState = "defined" | "maybe" | "absent";
+/** One binding a segment makes: a name and what it now holds (`unknown` = made unknown). `prefix`: a binding that may or
+ *  may not take effect (a prefix assignment to a special builtin, which may or may not outlive its command; an `unset` of a
+ *  function, which a read-only function refuses). `loopVar`: a `for` loop's variable, held through its body. */
 export interface Binding {
     readonly name: string;
     readonly state: NameState;
@@ -107,9 +144,9 @@ export interface BindingEffect {
 /** How one value word reads against the table, the earlier assignments of the same segment applied (bash assigns left
  *  to right): its possible values, or `unknown`. */
 export type ValueReader = (word: Pick<LexedWord, "pieces">, quoted: boolean, overlay: ReadonlyMap<string, NameState>) => NameState;
-/** The segment's shape the effect needs beside its words: a function definition head was dropped from it. */
+/** The segment's shape the effect needs beside its words: the functions whose definition heads were dropped from it. */
 export interface SegmentShape {
-    readonly definesFunction: boolean;
+    readonly defines: readonly string[];
 }
 /** The argv projection of a lexed segment: structure that names nothing that runs here is dropped — a subshell
  *  parenthesis, a bare `{` / `}`, a function definition's head (`NAME ()`, and `function NAME [()]` with a name of
@@ -125,38 +162,53 @@ export declare function projectSegment(segment: LexedSegment): ProjectedSegment;
  *  `NAME ( )` ({@link isDefinitionName}), and `function NAME [( )]` — a bare `function` at command position, a name of any
  *  spelling. The lexer puts the body's compound command back at command position after the head, so a definition
  *  nested in a body is dropped the same way; after a drop the token that moved up is looked at again. Answers where the
- *  heads stood: entry `k` counts the heads dropped right before the token now at `k` (the last entry, past the last
- *  token, a head whose body opens in a later segment). */
-export declare function dropDefinitionHeads(tokens: LexedToken[]): readonly number[];
+ *  heads stood: entry `k` names the functions whose heads were dropped right before the token now at `k` (the last entry,
+ *  past the last token, a head whose body opens in a later segment). */
+export declare function dropDefinitionHeads(tokens: LexedToken[]): readonly (readonly string[])[];
 /**
  * What a word holds through the names it refers to — `$NAME`, `${NAME}`, a leading `~` (the value of `HOME`): `undefined`
  * 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).
+ * `shadow`: the word the shell looks up first is a function of the text where the segment stands (`named`: it is one, the
+ * builtin of its name does not run — the call's effect is the body's; `maybe`: it may be one, so what the builtin binds is one
+ * more value its names may hold). `availability`: whether the builtin of a name runs by it where the segment stands
+ * ({@link BuiltinState}) — `disabled`: the word finds no command and binds nothing, `maybe`: as a function that may stand.
  */
-export declare function bindingEffectOf(segment: LexedSegment, argv: readonly LexedWord[], shape: SegmentShape, readValue: ValueReader): BindingEffect;
+export declare function bindingEffectOf(segment: LexedSegment, argv: readonly LexedWord[], shape: SegmentShape, readValue: ValueReader, shadow?: "named" | "maybe", availability?: (builtin: string) => BuiltinState): BindingEffect;
 /**
  * The names an ARITHMETIC text may assign: every identifier in a text that carries an assignment operator (`=` that is no
  * comparison, `+=` and its kin, `++`, `--`) — read whole, not parsed: a name only compared there is made unknown too.
@@ -180,7 +232,22 @@ 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[]>;
+    /** The names something before the nested text may have changed — a change that can reach where it starts, and the
+     *  names its own segment's command environment sets (`TMPDIR=… bash -c …`): there such a name no longer holds what the
+     *  shell provides ({@link BindingTable.providedByShell}). `all`: any name. Absent: none. */
+    readonly rebound?: ReadonlySet<string> | "all";
+}
+/** The function and builtin keys of the shell a text runs in — a literal `eval` text, a substitution body (a fork): what each key
+ *  holds where the text starts (the outer table's answer for it), and the names a call to one of the outer functions may change. */
+export interface InheritedFunctions {
+    readonly start: (key: string) => NameState;
+    readonly bound: ReadonlySet<string> | "all";
 }
+/** Two rebound sets as one. */
+export declare function joinRebound(a: ReadonlySet<string> | "all" | undefined, b: Iterable<string> | "all" | undefined): ReadonlySet<string> | "all";
 /** What the thread answers for one reader: what a name may hold, and whether a name carries the integer attribute. */
 export interface BindingTable {
     stateOf(name: string): NameState;
@@ -194,6 +261,16 @@ export interface BindingTable {
     floorOf(name: string): readonly FloorValue[];
     /** What a substitution body here starts with. */
     readonly inherited: InheritedNames;
+    /** The names a change that can reach this point touched — a binding, or a name made unknown, that may run before it in
+     *  this shell (the thread's order: {@link BindingThread}) — and the names its start says were rebound; `all`: any. */
+    readonly rebound: ReadonlySet<string> | "all";
+    /** Does this name still hold what the shell provides here: no change that can reach this point touched it? */
+    providedByShell(name: string): boolean;
+    /** What a function of this name is here: the one ordered rule that answers a variable's value answers it
+     *  ({@link FunctionState}). A name the text never defines is `absent` to the caller's own filter, not to this thread. */
+    functionState(name: string): FunctionState;
+    /** Whether the builtin of this name runs by it here: the same ordered rule ({@link BuiltinState}). */
+    builtinState(name: string): BuiltinState;
 }
 /**
  * The effects of a text's segments, threaded the way the plan threads its working directory: a reader at segment `j`
@@ -203,11 +280,16 @@ export interface BindingTable {
  * assignment, and — reached through `&&` / `||` — it lies in `j`'s own `&&` run (`andRunStart`: the same index the
  * working-directory thread reads).
  *
- * A function body runs at its call, and the plan does not follow calls (a function may be called anywhere after its
- * definition — through a wrapper word, `eval`, `trap`, `source`, another function): a name bound in a body is
- * {@link Unreadable} to every reader past the body, a later assignment included, and to every reader in another body;
- * the body's own readers follow its own order. A name the body declares with a plain `local` (before the binding,
- * where the declaration certainly ran) never leaves it.
+ * A binding exists for a reader only where it may run before the reader IN THE SAME SHELL — the ordered state: one
+ * written after the reader, one inside a subshell the reader is not in (a `( … )` group that closed before it, a
+ * pipeline member that is not the last, a background job — a substitution body is a text of its own) and one in a
+ * function body is NOT a binding for it. A function body runs at its call: a call the plan can see (a program word
+ * naming one of the text's functions, a code body a builtin runs later, which may name one) makes every name a body
+ * binds unknown from that segment on ({@link functionBound}); a text the plan does not read (`eval`, `source`, a
+ * computed program word) already makes every name unknown. The last member of a pipeline may or may not run in this
+ * shell: its bindings join the values before them. A body's own readers follow its own order; a reader in another body
+ * loses a name any other body binds ({@link Unreadable}). A name the body declares with a plain `local` (before the
+ * binding, where the declaration certainly ran) never leaves it.
  *
  * An attribute ({@link NameAttribute}) and a name reference hold for every segment they may RUN before — a later one,
  * one in a function body, one in the same loop body: an assignment there binds something other than its text.
@@ -225,7 +307,11 @@ export declare class BindingThread {
     /** `HOME` may already hold something other than the declared home where the text starts (a substitution body
      *  inside a text that bound it). */
     private readonly homeStartsTouched;
+    /** The functions the shell that runs this text (a literal `eval` text) already holds. */
+    private readonly inheritedFunctions?;
     private readonly entries;
+    /** The `local` declarations the walk applied as certain ({@link apply}), each where it stands. */
+    private readonly localDeclarations;
     /** The attributes the text gives ({@link BindingEffect.attributes}), and where — read off its names alone, before any
      *  reader: one given later in the text may run first. */
     private readonly attributesAt;
@@ -233,8 +319,15 @@ export declare class BindingThread {
     private readonly unreadable;
     /** The block nesting each segment moves ({@link blockStructure}). */
     private readonly blocks;
-    /** Segments that are a pipeline member or run in the background. */
-    private readonly detached;
+    /** Segments that END in a pipe or a `&`: the command that closes them is a pipeline member that is not the last, or a
+     *  background job — a subshell of its own ({@link ownSubshellAt}: which of the segment's bindings that is). */
+    private readonly ownSubshell;
+    /** The floors the names start the text with ({@link InheritedNames.floors}). */
+    private readonly startFloors;
+    /** The names rebound where the text starts ({@link InheritedNames.rebound}). */
+    private readonly startRebound;
+    /** Where a function body runs ({@link runsBodies}): the last segment that can call one, and the command environment of each call. */
+    private bodyRuns;
     constructor(segments: readonly LexedSegment[], 
     /** What each segment binds, its names alone (a value is the reader's to read). */
     named: readonly BindingEffect[], 
@@ -248,31 +341,96 @@ export declare class BindingThread {
      *  inside a text that bound it). */
     homeStartsTouched?: boolean, 
     /** What holds where the text starts: given before its first segment. */
-    inherited?: InheritedNames);
+    inherited?: InheritedNames, 
+    /** The functions the shell that runs this text (a literal `eval` text) already holds. */
+    inheritedFunctions?: InheritedFunctions | undefined);
     /** What a text nested at segment `j` starts with ({@link InheritedNames}) — `j` absent: a text run later, which every
-     *  segment may run before. */
+     *  segment may run before (in whatever shell: a later text may run inside a subshell or a body, so every change
+     *  counts). */
     inheritedAt(j?: number): InheritedNames;
-    /** What segment `at` makes unreadable: in a function body, the names it binds (unless the body declared them `local`
-     *  where the declaration certainly ran) — every name where it may bind any; a name reference, every name. */
+    /** What a name holds where the text starts: a function name unbound, a builtin enabled (what the shell around an `eval` text, a
+     *  substitution body or a text run later holds, if it says); a variable as the plan says. */
+    private startOf;
+    /** Does any segment of this text bind the name (or every name)? */
+    private bindsInText;
+    /** What a text this one runs at some later point (a `trap` action) finds each function and builtin key: the point is not ordered
+     *  against the segments (it may fire after any of them, inside any body or subshell), so a key holds what the text starts it with
+     *  and every value any segment binds it ({@link InheritedFunctions}). */
+    heldAnywhere(): InheritedFunctions;
+    /** Tell the thread where function bodies run: `runs[si]` — segment `si` may run one (a call, a text the plan does not
+     *  read); `atEnd` — a code body may run at the text's end or at any point (`trap`); `environment[si]` — what a call's own
+     *  command environment sets. A call inside a loop may run again after a later segment of the loop. The last run point
+     *  bounds what can precede a body: a binding after it never does. A name a body that makes a call binds — `local` too:
+     *  the shell's scope is dynamic, the callee runs inside it — is unreadable to a reader in any other body. */
+    runsBodies(runs: readonly boolean[], atEnd: boolean, environment: readonly (ReadonlySet<string> | "all" | undefined)[]): void;
+    /** The names a reader that runs LATER than it stands may find rebound by segments after it: a reader in a function body
+     *  runs at each call, so every segment up to the last run point (and a call's own command environment) may run before it;
+     *  a text handed to run later (`j` absent) at any point. A reader that runs where it stands has none: the effects the walk
+     *  has applied so far are the ones that precede it. A `local` counts like any binding: it shortens a name's life, not the
+     *  view of a reader that runs inside its extent (a body called from there, a `trap` text it sets). */
+    private boundLater;
+    /** Does a binding segment `at` makes, standing at `standing`, run in a subshell of its own — a pipeline member that is
+     *  not the last, a background job? A segment's closing pipe or `&` ends ITS LAST command, at the depth that command
+     *  stands: a binding that stands shallower (a function definition's head, in front of the block its body opens in the
+     *  same segment: `f(){ ls | head; … }`) is not that member — the pipe closes a command inside the body, and the
+     *  definition is the shell's own. */
+    private ownSubshellAt;
+    /** Is a binding segment `at` makes one no later reader may count on as certain: made in a pipeline member (it follows a
+     *  `|`, or it is {@link ownSubshellAt}) or a background job? */
+    private detachedAt;
+    /** Can a binding segment `at` makes exist for a reader at segment `j` (`j` absent: a reader at the text's end, outside
+     *  every body and subshell)? Not where `at` stands in a function body the reader is not in (the body runs at its call),
+     *  runs in a subshell of its own (a pipeline member that is not the last, a background job), or stands in a `( … )`
+     *  group the reader is not in. */
+    private visible;
+    /** Where the binding `name` of segment `at` is made: the segment's own place, or — a function definition — where its head
+     *  stands. */
+    private standingOf;
+    /** The names any of the text's function bodies binds — what a call to one of them may change — or `all` where a body
+     *  may bind any name. A name the body keeps `local` ({@link leavesBody}) stays in it. */
+    functionBound(): ReadonlySet<string> | "all";
+    /** The function body a binding segment `at` makes belongs to, where the name can outlive it: the body it stands in — a
+     *  plain `local NAME` is the body's own and never leaves it (an optioned declaration, `declare -g` / `local -p`, reads no
+     *  scope, so it can). What a reader in ANOTHER body loses ({@link unreadableBy}); a call to the body changes it unless a
+     *  declaration the body certainly ran covers the name ({@link functionBound}). */
+    private bodyBinding;
+    /** Does segment `at` stand in a function body (it runs at a call, not here)? */
+    inFunctionBody(at: number): boolean;
+    /** Does segment `at` run in a subshell (a `( … )` group, a pipeline member that is not the last, a background job) or a
+     *  function body — whatever it changes, the shell that runs the next segment may not see? */
+    runsApart(at: number): boolean;
+    /** Segment `at` hands this shell a body it runs at ANY later point (a `trap` action, an alias value): every name the
+     *  body may bind (`all`: any) is unreadable to every reader after `at`, whatever is assigned to it in between. */
+    runsLater(at: number, names: ReadonlySet<string> | "all"): void;
+    /** What segment `at` makes unreadable: in a function body, the names it binds (a plain `local` stays in it) — every name
+     *  where it may bind any; a name reference, every name. Read before any segment is applied, so it does not ask which
+     *  declarations certainly ran: a name a body assigns after its own `local` is lost to a reader in another body all the same
+     *  (more questions, never fewer). */
     private unreadableBy;
     /** May segment `x` run before segment `e` runs (`x` being `e`: before a later run of it): `x` comes first in the text,
      *  `e` stands in a function body (the body runs at its call, after any segment, and may run again), or both stand in
      *  one loop's body (a later beat runs `x` again first). */
     private mayRunBefore;
-    /** Did the body certainly declare this name `local` before segment `at`: an earlier segment of the body, run on its
-     *  own (no `&&` / `||`, no pipeline member or background job), in a block still open at `at`. */
+    /** Did the body certainly declare this name `local` before segment `at`: an earlier segment of the body, run on its own
+     *  (no `&&` / `||`, no pipeline member or background job), in a block still open at `at`, whose declaration the walk
+     *  APPLIED as certain — the shell ran its word as the builtin: no function of that name standing, no launcher, path or
+     *  redirection in the way, and the builtin enabled where the body runs (what {@link bindingEffectOf} concluded, the ordered
+     *  state of {@link BindingTable.functionState} and {@link BindingTable.builtinState}; recorded by {@link apply}). */
     private declaredLocal;
-    /** Does the block that holds segment `at`'s words stay open (no closing word, no switch of branch) through `j`? */
+    /** Does the block that holds a binding's words stay open (no closing word, no switch of branch) through `j`? */
     private heldThrough;
     /** Apply segment `at`'s effect. `andRun`: the segment was reached through `&&` / `||`. `loopEnd`: for a loop variable,
      *  the index of the loop's end. */
     apply(at: number, effect: BindingEffect, andRun: boolean, loopEnd?: number): void;
-    /** Has the function body a binding at segment `at` was made in closed by segment `j`? */
-    private leftBody;
-    /** Make these names unknown from segment `at` on (a loop body that binds them may have run before any of its beats). */
+    /** Does a reader at segment `j` lose the name `u` makes unreadable: past a name reference it may run after, or in a
+     *  function body other than the one that binds it? */
+    private lostAt;
+    /** Make these names unknown from segment `at` on (a loop body that binds them may have run before any of its beats; a
+     *  call runs a body that binds them). */
     kill(at: number, names: Iterable<string> | "all"): void;
-    /** The table a reader at segment `j` sees; `andRunStart` = the first segment of `j`'s `&&` run. */
-    tableAt(j: number, andRunStart: number): BindingTable;
+    /** The table a reader at segment `j` sees; `andRunStart` = the first segment of `j`'s `&&` run; `where` = what the
+     *  working-directory thread says `PWD` / `OLDPWD` hold there (absent: it does not say — both unknown). */
+    tableAt(j: number, andRunStart: number, where?: WorkingDirectoryState): BindingTable;
 }
 /** A segment that opens with `((`: an arithmetic command (or a subshell in a subshell — the tokens are the same). */
 export declare function isArithmeticCommand(segment: LexedSegment): boolean;
@@ -297,4 +455,3 @@ export declare function arithmeticSubstitutions(text: string, table: BindingTabl
 }): string[];
 /** The text of every `[…]` subscript in an arithmetic text (nested brackets balanced; an unclosed one runs to the end). */
 export declare function subscriptsOf(text: string): string[];
-export {};