@sema-agent/core 7.45.0 → 7.46.0

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

@@ -1,9 +1,12 @@
-import { lexShell, PARSE_FAILURE_SENTENCE, substitutionsInHeredocBody, literalTildeSpelling, } from "../../shell/lex.js";
-import { compoundArrayElements, dropDefinitionHeads, expandsOf, readOfText, readsOf, rewritten, spelledWithHome, isArithmeticBody, unreadableSentenceOf } from "./shell-read-word.js";
-import { LAUNCHER_TABLE, SHELL_BLOCK_WORDS, programBasename, programPositionRunsShell, readProgramPosition, shellScanDeclineOf, } from "./bash-program-position.js";
-import { ASSIGNMENT_VALUE_NOT_PATHS, DECLARATION_BUILTINS, INERT_BUILTINS, INTERPRETER_INLINE_PROGRAMS, NO_PATH_OPERAND_COMMANDS, NO_PATH_OPERAND_EVALUATORS, POLL_LOOP_MAX_BEATS, RECURSIVE_READ_FORMS, SHELL_REENTRY_PROGRAM_RE, UNMODELLED_BASE_MOVERS, argvProgramOf, homeMayBeRebound, attachedOptionPayloads, resolveOperandLexically, inlineProgramClause, interpreterKey, isPathShapedToken, messageSlotWords, readVerbOptionSlot, sedScriptSlotFiles, segmentSelectsRecursiveRead, slotValueCandidates, suppliesFirstOperandSlot, verbFirstOperandSlot, verbOptionsArePositionIndependent, } from "./bash-readonly-classifier.js";
+import { lexShell, PARSE_FAILURE_SENTENCE, substitutionsInHeredocBody, literalTextOf, literalTildeSpelling, } from "../../shell/lex.js";
+import { readOfText, readsOf, rewritten, spelledWithHome, isArithmeticBody, unreadableSentenceOf } from "./shell-read-word.js";
+import { assignmentArithmetic, bare, listedVerbCandidates, pathSubcommandOf, programTextSentence, pushAssignment, roleReads, subscriptOnly, unlistedWords } from "./shell-read-argv.js";
+import { ARITHMETIC_TEST_OPERATORS, BindingThread, arithmeticSubstitutions, isArithmeticCommand, bindingEffectOf, parameterBodySubstitutions, projectSegment, valueOf, } from "./shell-read-bindings.js";
+import { programBasename, programPositionRunsShell, readProgramPosition, shellScanDeclineOf, } from "./bash-program-position.js";
+import { POLL_LOOP_MAX_BEATS, attachedOptionPayloads, resolveOperandLexically, isPathShapedToken, programTextSlotFiles, } from "./bash-readonly-classifier.js";
+import { BLOCK_WORD_NAMES, commandLineOptionSpellings, declaredAttributes, isDeclarationBuiltin, isInertBuiltin, launcherOptionPathRole, launcherOptionStep, readOptionRole, programLanguageOf, programTextOpensOf, selectedOptions, movesBaseUnfollowed, opensNoOperand, programDelivery, programRow, readArgRoles, runsShellText, } from "./program-read-model.js";
 import { isAbsolutePathForm } from "./safety.js";
-import { codeBodies, reentryText } from "./shell-reentry-text.js";
+import { codeBodies, pipedTextOf, reentryText, scriptFileAt, stdinTextsOf } from "./shell-reentry-text.js";
 export const READ_CANDIDATE_PROVENANCES = Object.freeze([
     "operand",
     "option_value",
@@ -15,28 +18,52 @@ export const READ_CANDIDATE_PROVENANCES = Object.freeze([
     "cd_target",
     "program_path",
     "script_slot_file",
+    "mount_source",
+    "object_path",
 ]);
 const NESTING_MAX = 4;
 const BASE_CANDIDATE_MAX = 256;
-export function planShellReads(command, decl, depth = 0, homeRebound = false, arithmetic = false) {
+export function planShellReads(command, decl, depth = 0, start) {
     const shape = { grouped: false, backgrounded: false, strayRedirection: false };
     if (depth > NESTING_MAX)
         return { segments: [], unreadable: `command text nested more than ${NESTING_MAX} levels deep`, shape };
     const lexed = lexShell(command);
     if ("parseFailure" in lexed)
         return { segments: [], unreadable: PARSE_FAILURE_SENTENCE[lexed.parseFailure.reason], shape };
-    const home = homeRebound || homeMayBeRebound(command) ? undefined : decl.homeDir;
-    const unreadable = unreadableSentenceOf(lexed, command, !arithmetic);
-    const nestedPlan = (text, arithmetic = false) => planShellReads(text, decl, depth + 1, home === undefined, arithmetic);
+    const unreadable = unreadableSentenceOf(lexed, command);
     const projected = lexed.segments.map((segment) => projectSegment(segment));
-    const planned = projected.map((p, si) => segmentFacts(lexed.segments[si], p, decl, home, nestedPlan));
-    const inert = depth === 0 && unreadable === undefined && planned.every(segmentOpensNothing);
-    const facts = inert ? planned.map((f) => ({ ...f, reads: f.reads.filter((c) => c.provenance !== "env_assignment") })) : planned;
-    shape.grouped = projected.some((p) => p.grouped);
-    shape.backgrounded = lexed.segments.some((s) => s.connector === "&") || facts.some((f) => f.backgrounds === true);
-    shape.strayRedirection = projected.some((p) => p.argv.length === 0 && p.redirects.length > 0);
-    const basesOf = facts.map(() => new Set());
-    const unmodelled = facts.map(() => false);
+    const named = projected.map((p, si) => bindingEffectOf(lexed.segments[si], p.argv, p, () => "unknown"));
+    const boundHere = (name) => named.some((e) => e.all === "unknown" || e.bindings.some((b) => b.name === name));
+    const boundAnywhere = (name) => boundHere(name) || start?.boundAnywhere(name) === true;
+    const declaredHome = decl.homeDir !== undefined ? [{ spelled: decl.homeDir }] : "unknown";
+    const initial = start?.initial ?? ((name) => (name === "HOME" ? declaredHome : "unknown"));
+    const loopShapes = projected.map((p) => loopShapeOf(p));
+    const loopEndOf = new Map();
+    {
+        const open = [];
+        loopShapes.forEach((l, si) => {
+            if (l === "head")
+                open.push(si);
+            else if (l === "end") {
+                const h = open.pop();
+                if (h !== undefined)
+                    loopEndOf.set(h, si);
+            }
+        });
+    }
+    const names = new BindingThread(lexed.segments, named, initial, boundAnywhere, loopEndOf, start?.homeTouched === true, start?.inherited);
+    const laterStart = { initial: (name) => (name === "HOME" && !boundAnywhere("HOME") ? declaredHome : "unknown"), boundAnywhere, homeTouched: boundAnywhere("HOME"), inherited: names.inheritedAt() };
+    const nestedPlanner = (table) => (text, kind) => planShellReads(text, decl, depth + 1, kind === "substitution" ? { initial: (name) => table.stateOf(name), boundAnywhere, homeTouched: table.homeTouched, inherited: table.inherited } : laterStart);
+    const empty = lexed.segments.map((segment, si) => segmentIsEmpty(segment, projected[si]));
+    const facts = projected.map(() => undefined);
+    const tables = projected.map(() => undefined);
+    const factsAt = (si, table) => {
+        tables[si] ??= table;
+        const piped = si > 0 && lexed.segments[si].connector === "|" ? pipedTextOf(lexed.segments[si - 1], projected[si - 1].argv) : undefined;
+        return (facts[si] ??= segmentFacts(lexed.segments[si], projected[si], decl, table, nestedPlanner(table), piped));
+    };
+    const basesOf = projected.map(() => new Set());
+    const unmodelled = projected.map(() => false);
     let candidates = [{ base: decl.cwd, skippedCd: -1 }];
     let baseLost = false;
     let floorBases;
@@ -48,22 +75,25 @@ export function planShellReads(command, decl, depth = 0, homeRebound = false, ar
     let crossedAllAnd = true;
     let crossedAnyOr = false;
     let previousEmitted = -1;
-    const reaches = facts.map(() => undefined);
+    const reaches = projected.map(() => undefined);
     const loops = [];
     const thread = (si, replay) => {
-        const f = facts[si];
+        const connector = lexed.segments[si].connector;
         if (previousEmitted >= 0) {
-            const connector = f.connector;
             if (replay || connector !== "&&")
                 crossedAllAnd = false;
             if (!replay && connector === "||")
                 crossedAnyOr = true;
         }
-        if (f.empty)
+        if (empty[si]) {
+            if (!replay)
+                factsAt(si, names.tableAt(si, andRunStart));
             return;
+        }
         if (previousEmitted >= 0 && !crossedAllAnd)
             andRunStart = crossedAnyOr ? si + 1 : si;
-        const pipeFed = f.connector === "|" || facts[si + 1]?.connector === "|";
+        const f = replay ? facts[si] : factsAt(si, names.tableAt(si, andRunStart));
+        const pipeFed = f.connector === "|" || lexed.segments[si + 1]?.connector === "|";
         reaches[si] ??= { andJoined: previousEmitted >= 0 && crossedAllAnd, orBroken: !crossedAllAnd && crossedAnyOr, moveProvable: f.moveProvable && !replay && !pipeFed };
         crossedAllAnd = true;
         crossedAnyOr = false;
@@ -107,46 +137,67 @@ export function planShellReads(command, decl, depth = 0, homeRebound = false, ar
         else
             candidates = next;
     };
-    for (let si = 0; si < facts.length; si++) {
-        const f = facts[si];
-        if (f.loopHead !== undefined) {
-            loops.push({ bodyStart: si + 1, beats: f.loopHead.beats });
-            thread(si, false);
+    const bind = (si) => {
+        const table = tables[si];
+        if (table === undefined)
+            return;
+        const end = loopEndOf.get(si);
+        if (end !== undefined) {
+            const body = named.slice(si + 1, end);
+            names.kill(si, body.some((e) => e.all === "unknown") ? "all" : body.flatMap((e) => e.bindings.map((b) => b.name)));
+        }
+        const segment = lexed.segments[si];
+        const effect = bindingEffectOf(segment, projected[si].argv, projected[si], (w, quoted, overlay) => valueOf(w, table, quoted, overlay));
+        const { all, ...rest } = effect;
+        names.apply(si, all === "reset" ? rest : effect, segment.connector === "&&" || segment.connector === "||", end);
+    };
+    for (let si = 0; si < projected.length; si++) {
+        const shapeOfLoop = loopShapes[si];
+        if (named[si].all === "reset")
+            names.apply(si, { bindings: [], all: "reset" }, false);
+        thread(si, false);
+        bind(si);
+        if (shapeOfLoop === "head") {
+            loops.push({ bodyStart: si + 1, beats: facts[si].loopHead?.beats });
             continue;
         }
-        if (f.loopEnd) {
-            thread(si, false);
-            const frame = loops.pop();
-            if (frame === undefined)
-                continue;
-            const body = facts.slice(frame.bodyStart, si);
-            const moves = body.some((b) => b.baseMove !== undefined);
-            if (!moves)
-                continue;
-            if (frame.beats === undefined) {
-                for (let k = frame.bodyStart; k < si; k++)
-                    unmodelled[k] = true;
-                loseBase(candidates.filter((c) => c.skippedCd < andRunStart));
-                continue;
-            }
-            for (let beat = 1; beat < frame.beats && !baseLost; beat++) {
-                for (let k = frame.bodyStart; k < si; k++)
-                    thread(k, true);
-            }
+        if (shapeOfLoop !== "end")
+            continue;
+        const frame = loops.pop();
+        if (frame === undefined)
+            continue;
+        const body = facts.slice(frame.bodyStart, si);
+        const moves = body.some((b) => b?.baseMove !== undefined);
+        if (!moves)
+            continue;
+        if (frame.beats === undefined) {
+            for (let k = frame.bodyStart; k < si; k++)
+                unmodelled[k] = true;
+            loseBase(candidates.filter((c) => c.skippedCd < andRunStart));
             continue;
         }
-        thread(si, false);
+        for (let beat = 1; beat < frame.beats && !baseLost; beat++) {
+            for (let k = frame.bodyStart; k < si; k++)
+                thread(k, true);
+        }
     }
+    const planned = facts.map((f) => f);
+    const inert = depth === 0 && unreadable === undefined && planned.every(segmentOpensNothing);
+    const settled = inert ? planned.map((f) => ({ ...f, reads: f.reads.filter((c) => c.provenance !== "env_assignment") })) : planned;
+    shape.grouped = projected.some((p) => p.grouped);
+    shape.backgrounded = lexed.segments.some((s) => s.connector === "&") || settled.some((f) => f.backgrounds === true);
+    shape.strayRedirection = projected.some((p) => p.argv.length === 0 && p.redirects.length > 0);
     const segments = [];
-    for (let si = 0; si < facts.length; si++) {
-        const f = facts[si];
+    for (let si = 0; si < settled.length; si++) {
+        const f = settled[si];
         if (f.empty)
             continue;
         const bases = unmodelled[si] ? "unmodelled" : [...basesOf[si]];
         const floor = unmodelled[si] && floorBases !== undefined && floorBases.length > 0 ? floorBases : undefined;
         const withBases = (c) => {
             const relative = relativeSpelling(c.spelled);
-            return { ...c, bases: relative ? bases : [], ...(relative && floor !== undefined ? { floorBases: floor } : {}) };
+            const here = c.provenance === "object_path" && bases !== "unmodelled" ? [...new Set(bases.flatMap(ancestorsOf))] : bases;
+            return { ...c, bases: relative ? here : [], ...(relative && floor !== undefined ? { floorBases: floor } : {}) };
         };
         segments.push({
             text: f.text,
@@ -156,6 +207,7 @@ export function planShellReads(command, decl, depth = 0, homeRebound = false, ar
             ...(f.verb !== undefined ? { verb: f.verb } : {}),
             ...(f.reentry !== undefined ? { reentry: f.reentry } : {}),
             ...(f.unreadProgramText !== undefined ? { unreadProgramText: f.unreadProgramText } : {}),
+            ...(f.stdin !== undefined ? { stdin: f.stdin } : {}),
             declines: f.declines,
             reads: dedupe(f.reads).map(withBases),
             redirects: f.redirects.map((r) => (r.target === undefined ? { op: r.op, direction: r.direction } : { op: r.op, direction: r.direction, target: withBases(r.target) })),
@@ -167,57 +219,88 @@ export function planShellReads(command, decl, depth = 0, homeRebound = false, ar
     }
     return { segments, shape, ...(unreadable !== undefined ? { unreadable } : {}) };
 }
+function ancestorsOf(dir) {
+    const out = [dir];
+    for (let d = dir, up = parentOf(d); up !== d; d = up, up = parentOf(d))
+        out.push(up);
+    return out;
+}
+function parentOf(dir) {
+    return resolveOperandLexically(dir, "..", undefined) ?? dir;
+}
+function loopShapeOf(p) {
+    const head = p.argv[0];
+    if (head === undefined)
+        return undefined;
+    if (head.raw === head.folded && (head.folded === "for" || head.folded === "select") && BLOCK_WORD_NAMES.has(head.folded))
+        return "head";
+    if (head.raw === head.folded && head.folded === "done" && BLOCK_WORD_NAMES.has(head.folded))
+        return "end";
+    const pos = readProgramPosition(p.argv);
+    return pos.controlWords.some((i) => p.argv[i].folded === "while" || p.argv[i].folded === "until") ? "head" : undefined;
+}
+function segmentIsEmpty(segment, p) {
+    if (p.argv.length > 0 || p.redirects.length > 0 || segment.substitutions.length > 0)
+        return false;
+    return !segment.tokens.some((t) => t.kind === "heredoc" && !t.quoted && (substitutionsInHeredocBody(t.body)?.length ?? 1) > 0);
+}
 function segmentOpensNothing(f) {
     if (f.empty)
         return true;
     const program = f.verb;
     const at = program === undefined ? -1 : f.argv.findIndex((w) => w.folded === program.name);
-    const inertProgram = program === undefined || (program.name === program.basename && INERT_BUILTINS.has(program.basename) && !(DECLARATION_BUILTINS.has(program.basename) && f.argv.slice(at + 1).some((w) => /^[-+]/.test(w.folded))));
+    const inertProgram = program === undefined || (program.name === program.basename && isInertBuiltin(program.basename) && !(isDeclarationBuiltin(program.basename) && f.argv.slice(at + 1).some((w) => /^[-+]/.test(w.folded))));
     return inertProgram && f.argv.every((w) => !/[[\]$`]/.test(w.raw)) && f.nested.length === 0 && f.reentry === undefined && f.declines.length === 0 && f.launcherChain.length === 0 && f.redirects.every((r) => r.direction !== "in") && f.reads.every((c) => c.provenance === "env_assignment");
 }
-function projectSegment(segment) {
-    const tokens = [...segment.tokens];
-    let grouped = tokens.some((t) => t.kind === "group");
-    dropDefinitionHeads(tokens);
-    const words = tokens.filter((t) => {
-        if (t.kind !== "word")
-            return false;
-        if (t.raw === t.folded && (t.folded === "{" || t.folded === "}")) {
-            grouped = true;
-            return false;
-        }
-        return true;
-    });
-    return {
-        argv: words,
-        redirects: tokens.filter((t) => t.kind === "redirect"),
-        grouped,
-    };
-}
-function segmentFacts(segment, p, decl, home, nestedPlan) {
-    const facts = segmentFactsRead(segment, p, decl, home, nestedPlan);
+function segmentFacts(segment, p, decl, table, nestedPlan, piped) {
+    const facts = segmentFactsRead(segment, p, decl, table, nestedPlan, piped);
     const unresolvedRaw = new Set();
     for (const t of segment.tokens) {
         const w = t.kind === "word" ? t : t.kind === "redirect" ? t.target : undefined;
         if (w !== undefined && w.pieces.some((p) => p.literal === undefined && p.expansion === undefined))
             unresolvedRaw.add(w.raw);
     }
-    const homeWithheld = home === undefined && decl.homeDir !== undefined;
-    const floor = (c) => { const f = (c.expands === "unresolvable" || c.spelled.startsWith("./~")) && decl.homeDir !== undefined ? spelledWithHome(c.spelled, c.raw, decl.homeDir) : undefined; return f === undefined ? c : { ...c, floorSpelled: f }; };
+    const homeWithheld = decl.homeDir !== undefined && table.stateOf("HOME") === "unknown";
+    const floor = (c) => {
+        if (c.floorSpelled !== undefined)
+            return c;
+        const f = (c.expands === "unresolvable" || c.spelled.startsWith("./~")) && decl.homeDir !== undefined ? spelledWithHome(c.spelled, c.raw, decl.homeDir) : undefined;
+        return f === undefined ? c : { ...c, floorSpelled: f };
+    };
     const unsettle = (c) => floor((unresolvedRaw.has(c.raw) || (homeWithheld && c.spelled.startsWith("~"))) && c.expands !== "unresolvable" ? { ...c, expands: "unresolvable" } : c);
+    const each = (c) => {
+        const { alternatives, floors, ...one } = c;
+        const shadows = (floors ?? []).map((v) => ({ spelled: v.spelled, raw: one.raw, provenance: one.provenance, expands: v.glob === true ? "glob" : false, denyOnly: true }));
+        return [...[one, ...(alternatives ?? []).map((spelled) => ({ ...one, spelled }))].map(unsettle), ...shadows];
+    };
     const move = facts.baseMove;
     return {
         ...facts,
-        reads: facts.reads.map(unsettle),
-        ...(move !== undefined && typeof move.target !== "string" ? { baseMove: { target: unsettle(move.target) } } : {}),
+        reads: facts.reads.flatMap(each),
+        redirects: facts.redirects.map((r) => (r.target === undefined ? r : { ...r, target: unsettle(r.target) })),
+        ...(move !== undefined && typeof move.target !== "string" ? { baseMove: { target: unsettle(move.target.alternatives !== undefined ? { ...each(move.target)[0], expands: "unresolvable" } : move.target) } } : {}),
     };
 }
-function segmentFactsRead(segment, p, decl, home, nestedPlan) {
+function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
     const nested = [];
+    const ctx = { table, reentered: [], programTextSeen: false };
     const arithmetic = segment.tokens.flatMap((t) => (t.kind === "word" ? t : t.kind === "redirect" ? t.target : undefined)?.pieces ?? []).flatMap((q) => (q.expansion?.kind === "arithmetic" && q.expansion.body !== undefined && isArithmeticBody(q.expansion.body) ? [q.expansion.body] : []));
     const count = (list, body) => list.filter((b) => b === body).length;
-    for (const body of segment.substitutions)
-        nested.push(nestedPlan(body, count(arithmetic, body) === count(segment.substitutions, body)));
+    const arithmeticBody = (body) => {
+        const l = lexShell(body);
+        if ("parseFailure" in l)
+            nested.push(nestedPlan(body, "substitution"));
+        else
+            for (const s of l.segments.flatMap((sg) => sg.substitutions))
+                nested.push(nestedPlan(s, "substitution"));
+        ctx.reentered.push(...arithmeticSubstitutions(body, table));
+    };
+    for (const body of segment.substitutions) {
+        if (count(arithmetic, body) > 0 && count(arithmetic, body) === count(segment.substitutions, body))
+            arithmeticBody(body);
+        else
+            nested.push(nestedPlan(body, "substitution"));
+    }
     let unreadableHeredoc = false;
     for (const t of segment.tokens) {
         if (t.kind !== "heredoc" || t.quoted)
@@ -227,12 +310,24 @@ function segmentFactsRead(segment, p, decl, home, nestedPlan) {
             unreadableHeredoc = true;
             continue;
         }
-        for (const s of inner)
-            nested.push(nestedPlan(s.body, s.kind === "arithmetic" && isArithmeticBody(s.body)));
+        for (const s of inner) {
+            if (s.kind === "arithmetic" && isArithmeticBody(s.body))
+                arithmeticBody(s.body);
+            else
+                nested.push(nestedPlan(s.body, "substitution"));
+        }
     }
     if (unreadableHeredoc)
         nested.push({ segments: [], unreadable: "a here-document body carries a substitution this lexer cannot delimit", shape: { grouped: false, backgrounded: false, strayRedirection: false } });
-    const redirects = p.redirects.map((r) => redirectFact(r, home));
+    if (isArithmeticCommand(segment))
+        ctx.reentered.push(...arithmeticSubstitutions(p.argv.map((w) => w.folded).join(" "), table));
+    for (const t of segment.tokens) {
+        const w = t.kind === "word" ? t : t.kind === "redirect" ? t.target : undefined;
+        for (const q of w?.pieces ?? [])
+            if (q.expansion?.kind === "parameter" && q.expansion.name !== undefined && q.expansion.body !== undefined)
+                ctx.reentered.push(...parameterBodySubstitutions(q.expansion.name, q.expansion.body, table));
+    }
+    const redirects = p.redirects.map((r) => redirectFact(r, table, decl.homeDir));
     const reads = [];
     for (const r of redirects)
         if (r.direction === "in" && r.target !== undefined)
@@ -244,42 +339,60 @@ function segmentFactsRead(segment, p, decl, home, nestedPlan) {
         redirects,
         nested,
     };
-    const toks = readsOf(p.argv, home);
+    const toks = readsOf(p.argv, table, decl.homeDir);
+    const done = (f) => {
+        const reentered = [...new Set(ctx.reentered)];
+        for (const body of reentered)
+            nested.push(nestedPlan(body, "later"));
+        return {
+            ...base,
+            ...f,
+            ...(reentered.length > 0 ? { reentry: "shell" } : {}),
+            ...(f.unreadProgramText === undefined && ctx.programText !== undefined ? { unreadProgramText: ctx.programText } : {}),
+        };
+    };
     const head = toks[0]?.folded;
     if (head === "coproc" && toks[0].raw === head && toks.length > 1) {
-        const tail = (from) => ({ argv: p.argv.slice(from), redirects: p.redirects, grouped: p.grouped });
-        const first = segmentFacts(segment, tail(1), decl, home, nestedPlan);
+        const tail = (from) => ({ ...p, argv: p.argv.slice(from) });
+        const first = segmentFacts(segment, tail(1), decl, table, nestedPlan, piped);
         if (toks.length < 3)
             return { ...first, backgrounds: true };
-        const second = segmentFacts(segment, tail(2), decl, home, nestedPlan);
+        const second = segmentFacts(segment, tail(2), decl, table, nestedPlan, piped);
         const seen = new Set(first.nested.map((n) => JSON.stringify(n.segments.map((sg) => sg.text))));
         const extraNested = second.nested.filter((n) => !seen.has(JSON.stringify(n.segments.map((sg) => sg.text))));
         return { ...first, ...(second.reentry === "shell" ? { reentry: second.reentry } : {}), reads: [...first.reads, ...second.reads], nested: [...first.nested, ...extraNested], backgrounds: true };
     }
-    if (head !== undefined && toks[0].raw === head && SHELL_BLOCK_WORDS.has(head)) {
-        if (head === "for" || head === "select")
-            return { ...base, empty: false, launcherChain: [], declines: [], reads, moveProvable: false, loopHead: { beats: literalBeats(toks) }, loopEnd: false };
-        if (head === "done")
-            return { ...base, empty: false, launcherChain: [], declines: [], reads, moveProvable: false, loopEnd: true };
-        return { ...base, empty: false, launcherChain: [], declines: [], reads, moveProvable: false, loopEnd: false };
+    const loop = loopShapeOf(p);
+    if (head !== undefined && toks[0].raw === head && BLOCK_WORD_NAMES.has(head)) {
+        if (loop === "head")
+            return done({ empty: false, launcherChain: [], declines: [], reads, moveProvable: false, loopHead: { beats: literalBeats(toks) } });
+        if (head === "[[") {
+            toks.forEach((r, i) => {
+                if (ARITHMETIC_TEST_OPERATORS.has(toks[i - 1]?.folded ?? "") || ARITHMETIC_TEST_OPERATORS.has(toks[i + 1]?.folded ?? "") || toks[i - 1]?.folded === "-v")
+                    ctx.reentered.push(...arithmeticSubstitutions(r.folded, table));
+            });
+        }
+        return done({ empty: false, launcherChain: [], declines: [], reads, moveProvable: false });
     }
     const pos = readProgramPosition(p.argv);
     const written = pos.written;
     if (written === undefined)
-        return { ...base, empty: toks.length === 0 && redirects.length === 0 && nested.length === 0, launcherChain: [], declines: [], reads, moveProvable: false, loopEnd: false };
-    const loopHead = pos.controlWords.some((i) => toks[i].folded === "while" || toks[i].folded === "until") ? { beats: undefined } : undefined;
+        return done({ empty: segmentIsEmpty(segment, p), launcherChain: [], declines: [], reads, moveProvable: false });
+    const loopHead = loop === "head" ? { beats: undefined } : undefined;
     const launcherChain = pos.launchers.map((l) => l.name);
     const launcherIndices = new Set(pos.launchers.map((l) => l.index));
     const declines = [];
-    const decline = shellScanDeclineOf(pos, NO_PATH_OPERAND_COMMANDS);
+    const decline = shellScanDeclineOf(pos, opensNoOperand);
     if (decline !== undefined)
         declines.push(decline);
     const program = pos.program;
     const basename = program?.basename;
     const listed = basename !== undefined && (decl.readers.has(basename) || basename === "cd");
     const verb = program === undefined ? undefined : { name: program.name, basename: program.basename, listed };
-    for (const k of pos.assignments)
+    for (const k of pos.assignments) {
         pushAssignment(reads, toks[k].word, "env_assignment");
+        assignmentArithmetic(toks[k].word, table.isInteger(toks[k].word.assignment?.name ?? ""), ctx);
+    }
     for (const l of pos.launchers) {
         const r = toks[l.index];
         if (isPathShapedToken(r.folded))
@@ -290,19 +403,30 @@ function segmentFactsRead(segment, p, decl, home, nestedPlan) {
         const assignmentIndices = new Set(pos.assignments);
         const chainEnd = pos.program?.index ?? toks.length;
         const launcherValueIndices = new Set();
+        const launcherPathValues = new Map();
         for (const l of pos.launchers) {
-            const row = LAUNCHER_TABLE.get(programBasename(l.name));
-            if (row === undefined)
+            const row = programRow(programBasename(l.name));
+            if (row?.launcher === undefined)
                 continue;
             for (let j = l.index + 1; j < chainEnd; j++) {
                 const w = toks[j].folded;
                 if (!w.startsWith("-") || w === "-")
                     break;
-                const arity = row.optionArity.get(w);
-                if (arity === undefined)
+                const step = launcherOptionStep(row, w);
+                if (step === undefined)
                     break;
-                if (arity === 1)
-                    launcherValueIndices.add(++j);
+                if (step === 2) {
+                    const role = launcherOptionPathRole(row, w);
+                    if (role === undefined)
+                        launcherValueIndices.add(j + 1);
+                    else
+                        launcherPathValues.set(j + 1, { value: toks[j + 1].folded, role });
+                    j++;
+                    continue;
+                }
+                const own = readOptionRole(row, w);
+                if (own.form === "attached" && own.role?.kind === "path")
+                    launcherPathValues.set(j, { value: literalTildeSpelling(own.value), role: own.role });
             }
         }
         for (let j = 0; j < chainEnd; j++) {
@@ -310,6 +434,11 @@ function segmentFactsRead(segment, p, decl, home, nestedPlan) {
                 continue;
             const r = toks[j];
             const word = r.folded;
+            const pathValue = launcherPathValues.get(j);
+            if (pathValue !== undefined) {
+                reads.push(...roleReads(r, "option_value", pathValue.value, pathValue.role, "literal", ctx));
+                continue;
+            }
             if (word.startsWith("-") && word !== "-") {
                 for (const payload of attachedOptionPayloads(word))
                     reads.push(bare(r, "unlisted_word", payload));
@@ -332,74 +461,82 @@ function segmentFactsRead(segment, p, decl, home, nestedPlan) {
     if (pos.argvFromStdin)
         reentry = "argv";
     if (pos.refusal !== undefined) {
-        const owner = programBasename(pos.refusal.owner);
-        const row = LAUNCHER_TABLE.get(owner);
-        if (pos.refusal.kind === "option_at_program_position" && row?.commandString !== undefined) {
-            const text = commandStringValue(row.commandString, toks, pos.refusal.option);
+        const commandLine = commandLineOptionSpellings(programRow(programBasename(pos.refusal.owner)));
+        if (pos.refusal.kind === "option_at_program_position" && commandLine.length > 0) {
+            const text = commandStringValue(commandLine, toks, pos.refusal.option);
             if (text !== undefined) {
-                nested.push(nestedPlan(text.value));
+                nested.push(nestedPlan(text.value, "later"));
                 reentry = "shell";
-                unlistedWords(reads, toks, text.next, launcherIndices, "unlisted_word");
-                return { ...base, empty: false, launcherChain, ...(verb !== undefined ? { verb } : {}), reentry, declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), loopEnd: false };
+                unlistedWords(reads, toks, text.next, launcherIndices, "unlisted_word", ctx);
+                return done({ empty: false, launcherChain, ...(verb !== undefined ? { verb } : {}), reentry, declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}) });
             }
         }
-        if (programPositionRunsShell(pos, SHELL_REENTRY_PROGRAM_RE)) {
+        if (programPositionRunsShell(pos, runsShellText)) {
             reentry = "shell";
             const first = pos.launchers[0]?.index ?? written;
-            const text = toks.slice(first + 1).map((r) => r.folded).filter((w) => !w.startsWith("-") || w === "-").join(" ");
-            if (text.length > 0)
-                nested.push(nestedPlan(text));
-            return { ...base, empty: false, launcherChain, ...(verb !== undefined ? { verb } : {}), reentry, declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), loopEnd: false };
+            const runs = pos.refusal.kind === "control_syntax_at_program_position" ? pos.refusal : undefined;
+            const text = runs?.handsText === true ? toks.slice(first + 1).map((r) => r.folded).filter((w) => !w.startsWith("-") || w === "-").join(" ") : "";
+            const shell = { name: runs?.word ?? "sh", basename: "sh", listed: decl.readers.has("sh") };
+            const stdin = text.length > 0 ? [] : stdinTextsOf(segment, piped);
+            for (const t of new Set([text, ...stdin.map((s) => (s.literal === undefined ? "" : reentryText(shell.basename, [], s.literal) ?? ""))]))
+                if (t.length > 0)
+                    nested.push(nestedPlan(t, "later"));
+            return done({ empty: false, launcherChain, verb: shell, reentry, declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), ...(stdin.length > 0 ? { stdin } : {}) });
         }
         const from = pos.launchers[0]?.index ?? written;
-        unlistedWords(reads, toks, from, launcherIndices, "unlisted_word");
-        return { ...base, empty: false, launcherChain, ...(verb !== undefined ? { verb } : {}), ...(reentry !== undefined ? { reentry } : {}), declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), loopEnd: false };
+        unlistedWords(reads, toks, from, launcherIndices, "unlisted_word", ctx);
+        return done({ empty: false, launcherChain, ...(verb !== undefined ? { verb } : {}), ...(reentry !== undefined ? { reentry } : {}), declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}) });
     }
     if (program === undefined) {
         if (pos.launchers.length > 0)
-            unlistedWords(reads, toks, pos.launchers[0].index, launcherIndices, "unlisted_word");
-        return { ...base, empty: false, launcherChain, ...(reentry !== undefined ? { reentry } : {}), declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), loopEnd: false };
+            unlistedWords(reads, toks, pos.launchers[0].index, launcherIndices, "unlisted_word", ctx);
+        return done({ empty: false, launcherChain, ...(reentry !== undefined ? { reentry } : {}), declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}) });
     }
     const argReads = toks.slice(program.index + 1);
     const args = argReads.map((r) => r.folded);
-    const texts = argReads.map((r) => (r.word.pieces.every((q) => q.literal !== undefined) ? r.word.pieces.map((q) => q.literal).join("") : r.folded));
+    const texts = argReads.map((r) => literalTextOf(r.word.pieces) ?? r.folded);
     const programRead = toks[program.index];
     if (rewritten(programRead) || isPathShapedToken(programRead.folded))
         reads.push(bare(programRead, "program_path"));
-    if (SHELL_REENTRY_PROGRAM_RE.test(basename)) {
+    if (runsShellText(basename)) {
         reentry = "shell";
+        const stdin = stdinTextsOf(segment, piped);
         const text = reentryText(basename, texts);
-        for (const t of new Set([text, reentryText(basename, args)]))
+        const scripts = [text, reentryText(basename, args), ...stdin.map((s) => (s.literal === undefined ? undefined : reentryText(basename, texts, s.literal)))];
+        for (const t of new Set(scripts))
             if (t !== undefined)
-                nested.push(nestedPlan(t));
+                nested.push(nestedPlan(t, "later"));
         if (basename === "source" || basename === ".") {
             const file = argReads.find((a) => !a.folded.startsWith("-") || a.folded === "-");
             if (file !== undefined)
                 reads.push(bare(file, "operand"));
         }
-        else if (text === undefined) {
-            const file = argReads.find((a) => !a.folded.startsWith("-") || a.folded === "-");
-            if (file !== undefined && file.folded !== "-")
-                reads.push(bare(file, "operand"));
+        else {
+            const file = scriptFileAt(basename, args);
+            if (file !== undefined)
+                reads.push(bare(argReads[file], "operand"));
         }
-        return { ...base, empty: false, launcherChain, verb: verb, reentry, declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), loopEnd: false };
+        return done({ empty: false, launcherChain, verb: verb, reentry, declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), ...(stdin.length > 0 ? { stdin } : {}) });
     }
-    const interpreter = INTERPRETER_INLINE_PROGRAMS.get(interpreterKey(basename));
-    if (interpreter !== undefined && inlineProgramClause(interpreter, args) !== undefined)
+    const row = programRow(basename);
+    const delivery = programDelivery(row, args);
+    if (delivery !== undefined)
         reentry = "interpreter";
     const moveProvable = pos.controlWords.length === 0 && pos.launchers.length === 0 && pos.assignments.length === 0 && program.name === basename;
     let baseMove;
     if (basename === "cd") {
         baseMove = cdMove(argReads, reads);
     }
-    else if (UNMODELLED_BASE_MOVERS.has(basename)) {
+    else if (movesBaseUnfollowed(basename)) {
         baseMove = { target: "unmodelled" };
-        unlistedWords(reads, toks, program.index, launcherIndices, "unlisted_word", program);
+        unlistedWords(reads, toks, program.index, launcherIndices, "unlisted_word", ctx, program);
     }
     else if (listed) {
-        listedVerbCandidates(basename, argReads, reads);
+        listedVerbCandidates(basename, argReads, reads, ctx);
     }
-    else if (DECLARATION_BUILTINS.has(basename) && program.name === basename) {
+    else if (isDeclarationBuiltin(basename) && program.name === basename) {
+        const integer = declaredAttributes(row, args).has("integer");
+        const asWritten = row?.operands?.rest?.kind === "binds-name" && row.operands.rest.asWritten === true;
         for (const r of argReads) {
             const a = r.word.assignment;
             if (a !== undefined && (r.expands !== "unresolvable" || a.value.expansions.length > 0))
@@ -408,20 +545,39 @@ function segmentFactsRead(segment, p, decl, home, nestedPlan) {
                 reads.push(bare(r, "unlisted_word"));
                 pushAssignment(reads, r.word, "unlisted_word");
             }
+            assignmentArithmetic(r.word, integer || (a !== undefined && table.isInteger(a.name)), ctx, asWritten);
         }
     }
     else {
-        unlistedWords(reads, toks, program.index, launcherIndices, "unlisted_word", program);
+        unlistedWords(reads, toks, program.index, launcherIndices, "unlisted_word", ctx, program);
+    }
+    for (const e of row === undefined ? [] : readArgRoles(row, args)) {
+        const role = e.kind === "value" || e.kind === "operand" ? e.role : e.kind === "option" && typeof e.reading === "object" ? e.reading.role : undefined;
+        if (role?.kind !== "binds-name" || role.asWritten === true)
+            continue;
+        const text = e.kind === "option" && typeof e.reading === "object" ? e.reading.attached : args[e.at];
+        ctx.reentered.push(...arithmeticSubstitutions(subscriptOnly(text), table));
+    }
+    const language = programLanguageOf(row);
+    if (language !== undefined && (delivery === "stdin" || (delivery === "text" && !ctx.programTextSeen))) {
+        const opens = programTextOpensOf(language);
+        if (opens === "any" || typeof opens !== "string")
+            ctx.programText ??= delivery === "stdin" ? `reads the ${language} program it runs from its standard input, which this station does not read` : programTextSentence(language);
     }
+    const effectSub = pathSubcommandOf(row, args);
+    const effectRow = effectSub?.row ?? row;
+    const effectArgs = effectSub === undefined ? args : args.slice(effectSub.at + 1);
+    if (effectRow !== undefined && selectedOptions(effectRow, effectArgs).some((o) => o.effect === "executes"))
+        reentry = "shell";
     let unreadProgramText;
-    if (basename === "sed") {
-        const slot = sedScriptSlotFiles(args);
+    const slot = row === undefined ? undefined : programTextSlotFiles(row, args);
+    if (slot !== undefined) {
         for (const f of slot.reads)
             reads.push(bare(readOfText(f), "script_slot_file"));
         for (const f of slot.writes)
             reads.push(bare(readOfText(f), "write_redirect_target"));
         for (const c of slot.commands)
-            nested.push(nestedPlan(c));
+            nested.push(nestedPlan(c, "later"));
         if (slot.commands.length > 0 || slot.executesPatternSpace)
             reentry = "shell";
         unreadProgramText = slot.unread;
@@ -430,9 +586,8 @@ function segmentFactsRead(segment, p, decl, home, nestedPlan) {
     if (bodies.size > 0)
         reentry = "shell";
     for (const body of bodies)
-        nested.push(nestedPlan(body));
-    return {
-        ...base,
+        nested.push(nestedPlan(body, "later"));
+    return done({
         empty: false,
         launcherChain,
         verb: verb,
@@ -443,8 +598,7 @@ function segmentFactsRead(segment, p, decl, home, nestedPlan) {
         ...(baseMove !== undefined ? { baseMove } : {}),
         moveProvable,
         ...(loopHead !== undefined ? { loopHead } : {}),
-        loopEnd: false,
-    };
+    });
 }
 function rebasePlan(plan, from, to) {
     if (to !== "unmodelled" && to.length === 1 && to[0] === from)
@@ -490,165 +644,20 @@ function dedupe(reads) {
     }
     return out;
 }
-function bare(r, provenance, spelled = r.folded) {
-    return { spelled, raw: r.raw, provenance, expands: r.expands };
-}
 function relativeSpelling(spelled) {
     return !(isAbsolutePathForm(spelled) || spelled.startsWith("~"));
 }
 function joinBase(base, target, homeDir) {
     return resolveOperandLexically(base, target, homeDir);
 }
-function redirectFact(r, home) {
+function redirectFact(r, table, homeDir) {
     if (r.target === undefined)
         return { op: r.op, direction: "dup" };
     if (r.op === "<")
-        return { op: r.op, direction: "in", target: bare(readsOf([r.target], home)[0], "stdin_redirect") };
+        return { op: r.op, direction: "in", target: bare(readsOf([r.target], table, homeDir)[0], "stdin_redirect") };
     if (r.op === "<<<")
         return { op: r.op, direction: "in" };
-    return { op: r.op, direction: "out", target: bare(readsOf([r.target], home)[0], "write_redirect_target") };
-}
-function pushAssignment(reads, w, provenance) {
-    const a = w.assignment;
-    if (a === undefined)
-        return;
-    const expandsTilde = a.value.expansions.some((p) => p.expansion?.kind === "tilde");
-    const value = expandsTilde ? a.value.folded : literalTildeSpelling(a.value.folded);
-    const settled = a.op === "=" && !expandsTilde;
-    const named = a.value.folded === "" || (a.op === "+=" ? expandsTilde : !settled) ? undefined : value;
-    if (a.value.folded === "" && settled)
-        return;
-    const v = { spelled: value, raw: a.bare ? a.value.raw : w.raw, provenance };
-    const unsettled = provenance !== "env_assignment" ? { ...v, expands: "unresolvable" } : v.spelled.startsWith("~") && !v.spelled.includes(":") ? { ...v, expands: expandsOf(a.value) } : undefined;
-    if (!settled && unsettled !== undefined)
-        reads.push(unsettled);
-    const substitutes = a.value.expansions.some((p) => p.expansion?.kind === "command" || p.expansion?.kind === "process" || p.expansion?.kind === "arithmetic");
-    if (named !== undefined && !substitutes)
-        reads.push({ spelled: named, raw: w.raw, provenance, expands: expandsOf(w) });
-    if (a.value.folded.includes(":"))
-        for (const m of a.value.folded.split(":"))
-            if (m !== "") {
-                const r = readOfText(m);
-                reads.push({ spelled: r.folded, raw: r.raw, provenance, expands: r.expands, denyOnly: true });
-            }
-    if (a.form === "compound")
-        for (const e of compoundArrayElements(a.value))
-            reads.push({ spelled: e.folded, raw: e.raw, provenance, expands: e.expands, ...(e.denyOnly === true ? { denyOnly: true } : {}) });
-}
-function unlistedWords(reads, toks, from, launcherIndices, provenance, program) {
-    const argv = program !== undefined ? { program: program.basename, from: program.index } : argvProgramOf(toks.map((r) => r.word));
-    const argvStart = argv?.from ?? toks.length;
-    const slotVerb = argv?.program;
-    const message = slotVerb === undefined || argv === undefined ? new Set() : messageSlotWords(slotVerb, toks, argvStart);
-    const declaredNotPaths = ASSIGNMENT_VALUE_NOT_PATHS.has(slotVerb ?? "");
-    const noPathOperands = slotVerb !== undefined && NO_PATH_OPERAND_COMMANDS.has(slotVerb);
-    const permutes = slotVerb === undefined || !verbOptionsArePositionIndependent(slotVerb);
-    const expanding = new Set();
-    for (let j = from; j < toks.length; j++) {
-        if (launcherIndices.has(j))
-            continue;
-        if (noPathOperands && j > argvStart && !NO_PATH_OPERAND_EVALUATORS.has(slotVerb))
-            break;
-        if (toks[j].expands !== "unresolvable")
-            continue;
-        expanding.add(j);
-        reads.push(bare(toks[j], j === argvStart ? "program_path" : provenance));
-        if (j < argvStart)
-            pushAssignment(reads, toks[j].word, "env_assignment");
-        else if (j > argvStart && !declaredNotPaths)
-            pushAssignment(reads, toks[j].word, provenance);
-    }
-    const positional = [];
-    let stdinOperand = false;
-    let endOfOptions = false;
-    let sawArgvOperand = false;
-    for (let j = from; j < toks.length; j++) {
-        if (launcherIndices.has(j) || expanding.has(j) || message.has(j))
-            continue;
-        const r = toks[j];
-        const word = r.folded;
-        if (j > from && !endOfOptions && word === "--") {
-            endOfOptions = true;
-            continue;
-        }
-        if (noPathOperands && j >= argvStart)
-            break;
-        if (j === argvStart && !isPathShapedToken(word))
-            continue;
-        const optionShaped = !endOfOptions && word.startsWith("-") && word !== "-";
-        if (optionShaped && j > argvStart) {
-            const slot = slotVerb === undefined ? undefined : readVerbOptionSlot(slotVerb, word);
-            if (sawArgvOperand && permutes) {
-                reads.push(bare(r, provenance));
-                if (slot !== undefined && slot.form === "separated") {
-                    const ahead = toks[j + 1];
-                    if (ahead !== undefined && ahead.expands !== "unresolvable")
-                        for (const c of slotValueCandidates(ahead.folded, slot.kind))
-                            reads.push(bare(ahead, "option_value", c));
-                }
-            }
-            if (slot !== undefined && slot.form !== "unexplained" && !(slot.form === "separated" && sawArgvOperand && permutes)) {
-                if (slot.form === "attached") {
-                    for (const c of slotValueCandidates(literalTildeSpelling(slot.value), slot.kind))
-                        reads.push(bare(r, "option_value", c));
-                }
-                else if (slot.form === "separated") {
-                    j++;
-                    const value = toks[j];
-                    if (value !== undefined && !expanding.has(j)) {
-                        const named = slotValueCandidates(value.folded, slot.kind);
-                        for (const c of named)
-                            reads.push(bare(value, "option_value", c));
-                        if (named.length > 0)
-                            positional.push(value);
-                    }
-                }
-                continue;
-            }
-            for (const payload of attachedOptionPayloads(word))
-                reads.push(bare(r, provenance, payload));
-            if (isPathShapedToken(word))
-                reads.push(bare(r, provenance));
-            continue;
-        }
-        if (optionShaped) {
-            for (const payload of attachedOptionPayloads(word))
-                reads.push(bare(r, provenance, payload));
-            if (isPathShapedToken(word))
-                reads.push(bare(r, provenance));
-            continue;
-        }
-        if (j > argvStart) {
-            sawArgvOperand = true;
-            if (word === "-") {
-                const m = slotVerb === undefined ? undefined : RECURSIVE_READ_FORMS[slotVerb];
-                if (m === undefined || m.dashIsStdin === true)
-                    stdinOperand = true;
-                else
-                    positional.push(r);
-            }
-            else
-                positional.push(r);
-        }
-        reads.push(bare(r, j === argvStart ? "program_path" : provenance));
-        if (j < argvStart)
-            pushAssignment(reads, r.word, "env_assignment");
-        else if (!declaredNotPaths)
-            pushAssignment(reads, r.word, provenance);
-    }
-    if (slotVerb !== undefined && argv !== undefined && segmentSelectsRecursiveRead(slotVerb, toks.slice(argvStart + 1).map((x) => x.folded))) {
-        const roots = positional.length > 0 ? positional : stdinOperand ? [] : [readOfText(".")];
-        for (const root of roots)
-            reads.push(bare(root, "traversal_root"));
-    }
-    for (let j = from; j < toks.length; j++) {
-        if (launcherIndices.has(j) || j === argvStart)
-            continue;
-        if (noPathOperands && j > argvStart)
-            break;
-        if (toks[j].expands === "glob")
-            reads.push(bare(toks[j], provenance));
-    }
+    return { op: r.op, direction: "out", target: bare(readsOf([r.target], table, homeDir)[0], "write_redirect_target") };
 }
 function commandStringValue(options, toks, option) {
     const at = toks.findIndex((r) => r.folded === option);
@@ -696,106 +705,3 @@ function cdMove(args, reads) {
     reads.push(c);
     return { target: c };
 }
-function listedVerbCandidates(name, argReads, reads) {
-    if (NO_PATH_OPERAND_COMMANDS.has(name))
-        return;
-    const args = argReads.map((r) => r.folded);
-    const expanding = new Set();
-    argReads.forEach((r, k) => {
-        if (!rewritten(r))
-            return;
-        expanding.add(k);
-        reads.push({ spelled: r.folded, raw: r.raw, provenance: "operand", expands: "unresolvable" });
-    });
-    const eoo = args.indexOf("--");
-    const firstOperandSlot = verbFirstOperandSlot(name);
-    const firstOperandSuppliedByFlag = firstOperandSlot !== undefined && (eoo === -1 ? args : args.slice(0, eoo)).some((t) => suppliesFirstOperandSlot(firstOperandSlot, t));
-    const positional = [];
-    let sawOperand = false;
-    let stdinOperand = false;
-    let endOfOptions = false;
-    const permutes = !verbOptionsArePositionIndependent(name);
-    const push = (k, text, provenance) => {
-        reads.push(bare(argReads[k], provenance, text));
-    };
-    for (let k = 0; k < args.length; k++) {
-        const t = args[k];
-        if (expanding.has(k))
-            continue;
-        if (!endOfOptions) {
-            if (t === "--") {
-                endOfOptions = true;
-                continue;
-            }
-            if (t.startsWith("-") && t !== "-") {
-                const slot = readVerbOptionSlot(name, t);
-                if (sawOperand && permutes) {
-                    push(k, t, "operand");
-                    if (slot !== undefined && slot.form === "separated") {
-                        const ahead = args[k + 1];
-                        if (ahead !== undefined && !expanding.has(k + 1))
-                            for (const c of slotValueCandidates(ahead, slot.kind))
-                                push(k + 1, c, "option_value");
-                    }
-                }
-                if (slot !== undefined && slot.form !== "unexplained" && !(slot.form === "separated" && sawOperand && permutes)) {
-                    if (slot.form === "attached") {
-                        for (const c of slotValueCandidates(literalTildeSpelling(slot.value), slot.kind))
-                            push(k, c, "option_value");
-                    }
-                    else if (slot.form === "separated") {
-                        const value = args[++k];
-                        if (value !== undefined && !expanding.has(k)) {
-                            const named = slotValueCandidates(value, slot.kind);
-                            for (const c of named)
-                                push(k, c, "option_value");
-                            if (named.length > 0)
-                                positional.push(argReads[k]);
-                        }
-                    }
-                    continue;
-                }
-                for (const payload of attachedOptionPayloads(t))
-                    push(k, payload, "option_value");
-                continue;
-            }
-        }
-        const inFirstOperandSlot = firstOperandSlot !== undefined && !firstOperandSuppliedByFlag && !sawOperand;
-        sawOperand = true;
-        if (t === "-") {
-            if (inFirstOperandSlot)
-                continue;
-            const m = RECURSIVE_READ_FORMS[name];
-            if (m === undefined || m.dashIsStdin === true) {
-                stdinOperand = true;
-                continue;
-            }
-            positional.push(argReads[k]);
-            continue;
-        }
-        if (inFirstOperandSlot) {
-            const named = slotValueCandidates(t, firstOperandSlot.kind);
-            for (const c of named)
-                push(k, c, "operand");
-            if (named.length > 0)
-                positional.push(argReads[k]);
-            continue;
-        }
-        positional.push(argReads[k]);
-        push(k, t, "operand");
-        if (!ASSIGNMENT_VALUE_NOT_PATHS.has(name)) {
-            pushAssignment(reads, argReads[k].word, "operand");
-        }
-    }
-    for (let k = 0; k < args.length; k++) {
-        if (expanding.has(k))
-            continue;
-        if (argReads[k].expands === "glob")
-            reads.push(bare(argReads[k], "operand"));
-    }
-    if (segmentSelectsRecursiveRead(name, args)) {
-        const roots = positional.length > 0 ? positional : stdinOperand ? [] : [readOfText(".")];
-        for (const root of roots)
-            reads.push(bare(root, "traversal_root"));
-    }
-}