@sema-agent/core 7.29.0 → 7.30.1

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

@@ -1,7 +1,9 @@
-import { lexShell, PARSE_FAILURE_SENTENCE, UNRESOLVED_SENTENCE, UNRESOLVED_VIEW, substitutionsInHeredocBody, wordsOf, literalTildeSpelling, SUBSTITUTION_PLACEHOLDER, } from "../../shell/lex.js";
-import { LAUNCHER_TABLE, SHELL_BLOCK_WORDS, programBasename, programPositionRunsShell, readProgramPosition, shellScanDeclineOf, writtenAssignmentPrefix, } from "./bash-program-position.js";
-import { ASSIGNMENT_VALUE_NOT_PATHS, INTERPRETER_INLINE_PROGRAMS, NO_PATH_OPERAND_COMMANDS, POLL_LOOP_MAX_BEATS, RECURSIVE_READ_FORMS, SHELL_REENTRY_PROGRAM_RE, UNMODELLED_BASE_MOVERS, argvProgramOf, assignmentWordPayload, attachedOptionPayloads, foldHomeVariableSpelling, resolveOperandLexically, hasUnquotedExpansionMetachar, hasUnquotedGlobMetachar, inlineProgramClause, interpreterKey, isPathShapedToken, readVerbOptionSlot, sedScriptSlotFiles, segmentSelectsRecursiveRead, slotValueCandidates, suppliesFirstOperandSlot, verbFirstOperandSlot, verbOptionsArePositionIndependent, } from "./bash-readonly-classifier.js";
+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, INTERPRETER_INLINE_PROGRAMS, NO_PATH_OPERAND_COMMANDS, POLL_LOOP_MAX_BEATS, RECURSIVE_READ_FORMS, SHELL_REENTRY_PROGRAM_RE, UNMODELLED_BASE_MOVERS, argvProgramOf, homeMayBeRebound, attachedOptionPayloads, resolveOperandLexically, inlineProgramClause, interpreterKey, isPathShapedToken, readVerbOptionSlot, sedScriptSlotFiles, segmentSelectsRecursiveRead, slotValueCandidates, suppliesFirstOperandSlot, verbFirstOperandSlot, verbOptionsArePositionIndependent, } from "./bash-readonly-classifier.js";
 import { isAbsolutePathForm } from "./safety.js";
+import { codeBodies, reentryText } from "./shell-reentry-text.js";
 export const READ_CANDIDATE_PROVENANCES = [
     "operand",
     "option_value",
@@ -16,39 +18,29 @@ export const READ_CANDIDATE_PROVENANCES = [
 ];
 const NESTING_MAX = 4;
 const BASE_CANDIDATE_MAX = 256;
-function firstRefusedUnresolvedSentence(lexed) {
-    for (const segment of lexed.segments) {
-        for (const token of segment.tokens) {
-            const word = token.kind === "word" ? token : token.kind === "redirect" ? token.target : undefined;
-            if (word?.unresolved !== undefined && UNRESOLVED_VIEW[word.unresolved] === "refuse")
-                return UNRESOLVED_SENTENCE[word.unresolved];
-        }
-    }
-    return undefined;
-}
-export function planShellReads(command, decl, depth = 0) {
+export function planShellReads(command, decl, depth = 0, homeRebound = false, arithmetic = false) {
     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 homeReassigned = /(^|[\s;&|(){}`])(?:export\s+)?HOME\+?=/.test(command);
-    const lexed = lexShell(foldHomeVariableSpelling(command, homeReassigned ? undefined : decl.homeDir), { mode: "lenient" });
+    const lexed = lexShell(command);
     if ("parseFailure" in lexed)
         return { segments: [], unreadable: PARSE_FAILURE_SENTENCE[lexed.parseFailure.reason], shape };
-    const unreadable = firstRefusedUnresolvedSentence(lexed);
-    const nestedPlan = (text) => planShellReads(text, decl, depth + 1);
+    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 projected = lexed.segments.map((segment) => projectSegment(segment));
-    const facts = projected.map((p, si) => segmentFacts(lexed.segments[si], p, decl, nestedPlan));
+    const facts = projected.map((p, si) => segmentFacts(lexed.segments[si], p, decl, home, nestedPlan));
     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.words.folded.length === 0 && p.redirects.length > 0);
+    shape.strayRedirection = projected.some((p) => p.argv.length === 0 && p.redirects.length > 0);
     const basesOf = facts.map(() => new Set());
     const unmodelled = facts.map(() => false);
     let candidates = [{ base: decl.cwd, skippedCd: -1 }];
     let baseLost = false;
     let floorBases;
-    const loseBase = (reachable) => {
+    const loseBase = (reachable, floorTarget) => {
         baseLost = true;
-        floorBases ??= [...new Set(reachable.map((c) => c.base))];
+        floorBases ??= [...new Set([...reachable.map((c) => c.base), ...(floorTarget !== undefined ? [floorTarget] : [])])];
     };
     let andRunStart = 0;
     let crossedAllAnd = true;
@@ -84,7 +76,7 @@ export function planShellReads(command, decl, depth = 0) {
         if (move === undefined || baseLost)
             return;
         if (typeof move.target === "string" || move.target.expands !== false) {
-            loseBase(reachable);
+            loseBase(reachable, typeof move.target !== "string" ? move.target.floorSpelled : move.target === "home" ? decl.homeDir : undefined);
             return;
         }
         const target = move.target.spelled;
@@ -176,11 +168,7 @@ export function planShellReads(command, decl, depth = 0) {
 function projectSegment(segment) {
     const tokens = [...segment.tokens];
     let grouped = tokens.some((t) => t.kind === "group");
-    for (let k = 0; k + 2 < tokens.length; k++) {
-        const [a, b, c] = [tokens[k], tokens[k + 1], tokens[k + 2]];
-        if (a.kind === "word" && b.kind === "group" && b.op === "(" && c.kind === "group" && c.op === ")" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(a.folded))
-            tokens.splice(k, 3);
-    }
+    dropDefinitionHeads(tokens);
     const words = tokens.filter((t) => {
         if (t.kind !== "word")
             return false;
@@ -191,23 +179,22 @@ function projectSegment(segment) {
         return true;
     });
     return {
-        words: wordsOf({ ...segment, tokens: words }),
         argv: words,
         redirects: tokens.filter((t) => t.kind === "redirect"),
         grouped,
     };
 }
-function segmentFacts(segment, p, decl, nestedPlan) {
-    const facts = segmentFactsRead(segment, p, decl, nestedPlan);
+function segmentFacts(segment, p, decl, home, nestedPlan) {
+    const facts = segmentFactsRead(segment, p, decl, home, nestedPlan);
     const unresolvedRaw = new Set();
     for (const t of segment.tokens) {
         const w = t.kind === "word" ? t : t.kind === "redirect" ? t.target : undefined;
-        if (w?.unresolved !== undefined && UNRESOLVED_VIEW[w.unresolved] === "refuse")
+        if (w !== undefined && w.pieces.some((p) => p.literal === undefined && p.expansion === undefined))
             unresolvedRaw.add(w.raw);
     }
-    if (unresolvedRaw.size === 0)
-        return facts;
-    const unsettle = (c) => (unresolvedRaw.has(c.raw) && c.expands !== "unresolvable" ? { ...c, expands: "unresolvable" } : c);
+    const homeWithheld = home === undefined && decl.homeDir !== undefined;
+    const floor = (c) => { const f = c.expands === "unresolvable" && 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 move = facts.baseMove;
     return {
         ...facts,
@@ -215,10 +202,12 @@ function segmentFacts(segment, p, decl, nestedPlan) {
         ...(move !== undefined && typeof move.target !== "string" ? { baseMove: { target: unsettle(move.target) } } : {}),
     };
 }
-function segmentFactsRead(segment, p, decl, nestedPlan) {
+function segmentFactsRead(segment, p, decl, home, nestedPlan) {
     const nested = [];
+    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));
+        nested.push(nestedPlan(body, count(arithmetic, body) === count(segment.substitutions, body)));
     let unreadableHeredoc = false;
     for (const t of segment.tokens) {
         if (t.kind !== "heredoc" || t.quoted)
@@ -228,12 +217,12 @@ function segmentFactsRead(segment, p, decl, nestedPlan) {
             unreadableHeredoc = true;
             continue;
         }
-        for (const body of inner)
-            nested.push(nestedPlan(body));
+        for (const s of inner)
+            nested.push(nestedPlan(s.body, s.kind === "arithmetic" && isArithmeticBody(s.body)));
     }
     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));
+    const redirects = p.redirects.map((r) => redirectFact(r, home));
     const reads = [];
     for (const r of redirects)
         if (r.direction === "in" && r.target !== undefined)
@@ -245,30 +234,30 @@ function segmentFactsRead(segment, p, decl, nestedPlan) {
         redirects,
         nested,
     };
-    const toks = p.words;
-    const head = toks.folded[0];
-    if (head === "coproc" && toks.raw[0] === head && toks.folded.length > 1) {
-        const tail = (from) => ({ words: { folded: toks.folded.slice(from), raw: toks.raw.slice(from) }, argv: p.argv.slice(from), redirects: p.redirects, grouped: p.grouped });
-        const first = segmentFacts(segment, tail(1), decl, nestedPlan);
-        if (toks.folded.length < 3)
+    const toks = readsOf(p.argv, home);
+    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);
+        if (toks.length < 3)
             return { ...first, backgrounds: true };
-        const second = segmentFacts(segment, tail(2), decl, nestedPlan);
+        const second = segmentFacts(segment, tail(2), decl, home, nestedPlan);
         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, reads: [...first.reads, ...second.reads], nested: [...first.nested, ...extraNested], backgrounds: true };
+        return { ...first, ...(second.reentry === "shell" ? { reentry: second.reentry } : {}), reads: [...first.reads, ...second.reads], nested: [...first.nested, ...extraNested], backgrounds: true };
     }
-    if (head !== undefined && toks.raw[0] === head && SHELL_BLOCK_WORDS.has(head)) {
+    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 pos = readProgramPosition(toks);
+    const pos = readProgramPosition(p.argv);
     const written = pos.written;
     if (written === undefined)
-        return { ...base, empty: toks.folded.length === 0 && redirects.length === 0 && nested.length === 0, launcherChain: [], declines: [], reads, moveProvable: false, loopEnd: false };
-    const loopHead = pos.controlWords.some((i) => toks.folded[i] === "while" || toks.folded[i] === "until") ? { beats: undefined } : 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;
     const launcherChain = pos.launchers.map((l) => l.name);
     const launcherIndices = new Set(pos.launchers.map((l) => l.index));
     const declines = [];
@@ -281,24 +270,23 @@ function segmentFactsRead(segment, p, decl, nestedPlan) {
     const verb = program === undefined ? undefined : { name: program.name, basename: program.basename, listed };
     const envOpens = basename !== undefined && !NO_PATH_OPERAND_COMMANDS.has(basename);
     for (const k of pos.assignments)
-        pushAssignment(reads, toks.folded[k], toks.raw[k], "env_assignment", envOpens);
+        pushAssignment(reads, toks[k].word, "env_assignment", envOpens);
     for (const l of pos.launchers) {
-        const raw = toks.raw[l.index];
-        const folded = toks.folded[l.index];
-        if (isPathShapedToken(folded))
-            reads.push(bare(raw, folded, "program_path"));
+        const r = toks[l.index];
+        if (isPathShapedToken(r.folded))
+            reads.push(bare(r, "program_path"));
     }
     {
         const controlIndices = new Set(pos.controlWords);
         const assignmentIndices = new Set(pos.assignments);
-        const chainEnd = pos.program?.index ?? toks.folded.length;
+        const chainEnd = pos.program?.index ?? toks.length;
         const launcherValueIndices = new Set();
         for (const l of pos.launchers) {
             const row = LAUNCHER_TABLE.get(programBasename(l.name));
             if (row === undefined)
                 continue;
             for (let j = l.index + 1; j < chainEnd; j++) {
-                const w = toks.folded[j];
+                const w = toks[j].folded;
                 if (!w.startsWith("-") || w === "-")
                     break;
                 const arity = row.optionArity.get(w);
@@ -311,24 +299,24 @@ function segmentFactsRead(segment, p, decl, nestedPlan) {
         for (let j = 0; j < chainEnd; j++) {
             if (launcherIndices.has(j) || controlIndices.has(j) || assignmentIndices.has(j) || launcherValueIndices.has(j) || j === written)
                 continue;
-            const word = toks.folded[j];
-            const raw = toks.raw[j];
+            const r = toks[j];
+            const word = r.folded;
             if (word.startsWith("-") && word !== "-") {
                 for (const payload of attachedOptionPayloads(word))
-                    reads.push(bare(raw, payload, "unlisted_word"));
+                    reads.push(bare(r, "unlisted_word", payload));
                 if (isPathShapedToken(word))
-                    reads.push(bare(raw, word, "unlisted_word"));
+                    reads.push(bare(r, "unlisted_word"));
                 continue;
             }
-            if (expandsOf(raw, word) === "unresolvable") {
-                reads.push({ spelled: word, raw, provenance: "unlisted_word", expands: "unresolvable" });
+            if (r.expands === "unresolvable") {
+                reads.push(bare(r, "unlisted_word"));
                 continue;
             }
-            if (assignmentWordPayload(word, toks.raw[j]) !== undefined) {
-                pushAssignment(reads, word, toks.raw[j], "env_assignment", envOpens);
+            if (r.word.assignment !== undefined) {
+                pushAssignment(reads, r.word, "env_assignment", envOpens);
                 continue;
             }
-            reads.push(bare(raw, word, "unlisted_word"));
+            reads.push(bare(r, "unlisted_word"));
         }
     }
     let reentry;
@@ -349,7 +337,7 @@ function segmentFactsRead(segment, p, decl, nestedPlan) {
         if (programPositionRunsShell(pos, SHELL_REENTRY_PROGRAM_RE)) {
             reentry = "shell";
             const first = pos.launchers[0]?.index ?? written;
-            const text = toks.folded.slice(first + 1).filter((w) => !w.startsWith("-") || w === "-").join(" ");
+            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 };
@@ -363,27 +351,27 @@ function segmentFactsRead(segment, p, decl, nestedPlan) {
             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 };
     }
-    const args = toks.folded.slice(program.index + 1);
-    const rawArgs = toks.raw.slice(program.index + 1);
-    const programWordUnread = program.name.includes(SUBSTITUTION_PLACEHOLDER) || hasUnquotedExpansionMetachar(toks.raw[program.index]);
-    if (programWordUnread)
-        reads.push(bare(toks.raw[program.index], program.name, "program_path"));
-    else if (isPathShapedToken(program.name))
-        reads.push(bare(toks.raw[program.index], program.name, "program_path"));
+    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 programRead = toks[program.index];
+    if (rewritten(programRead) || isPathShapedToken(programRead.folded))
+        reads.push(bare(programRead, "program_path"));
     if (SHELL_REENTRY_PROGRAM_RE.test(basename)) {
         reentry = "shell";
-        const text = reentryText(basename, args);
-        if (text !== undefined)
-            nested.push(nestedPlan(text));
+        const text = reentryText(basename, texts);
+        for (const t of new Set([text, reentryText(basename, args)]))
+            if (t !== undefined)
+                nested.push(nestedPlan(t));
         if (basename === "source" || basename === ".") {
-            const file = args.find((a) => !a.startsWith("-") || a === "-");
+            const file = argReads.find((a) => !a.folded.startsWith("-") || a.folded === "-");
             if (file !== undefined)
-                reads.push(bare(rawArgs[args.indexOf(file)], file, "operand"));
+                reads.push(bare(file, "operand"));
         }
         else if (text === undefined) {
-            const file = args.find((a) => !a.startsWith("-") || a === "-");
-            if (file !== undefined && file !== "-")
-                reads.push(bare(rawArgs[args.indexOf(file)], file, "operand"));
+            const file = argReads.find((a) => !a.folded.startsWith("-") || a.folded === "-");
+            if (file !== undefined && file.folded !== "-")
+                reads.push(bare(file, "operand"));
         }
         return { ...base, empty: false, launcherChain, verb: verb, reentry, declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), loopEnd: false };
     }
@@ -393,14 +381,14 @@ function segmentFactsRead(segment, p, decl, nestedPlan) {
     const moveProvable = pos.controlWords.length === 0 && pos.launchers.length === 0 && pos.assignments.length === 0 && program.name === basename;
     let baseMove;
     if (basename === "cd") {
-        baseMove = cdMove(args, rawArgs, reads);
+        baseMove = cdMove(argReads, reads);
     }
     else if (UNMODELLED_BASE_MOVERS.has(basename)) {
         baseMove = { target: "unmodelled" };
         unlistedWords(reads, toks, program.index, launcherIndices, "unlisted_word", program);
     }
     else if (listed) {
-        listedVerbCandidates(basename, args, rawArgs, reads);
+        listedVerbCandidates(basename, argReads, reads);
     }
     else {
         unlistedWords(reads, toks, program.index, launcherIndices, "unlisted_word", program);
@@ -409,15 +397,20 @@ function segmentFactsRead(segment, p, decl, nestedPlan) {
     if (basename === "sed") {
         const slot = sedScriptSlotFiles(args);
         for (const f of slot.reads)
-            reads.push(bare(f, f, "script_slot_file"));
+            reads.push(bare(readOfText(f), "script_slot_file"));
         for (const f of slot.writes)
-            reads.push(bare(f, f, "write_redirect_target"));
+            reads.push(bare(readOfText(f), "write_redirect_target"));
         for (const c of slot.commands)
             nested.push(nestedPlan(c));
         if (slot.commands.length > 0 || slot.executesPatternSpace)
             reentry = "shell";
         unreadProgramText = slot.unread;
     }
+    const bodies = new Set([...codeBodies(basename, texts), ...codeBodies(basename, args)]);
+    if (bodies.size > 0)
+        reentry = "shell";
+    for (const body of bodies)
+        nested.push(nestedPlan(body));
     return {
         ...base,
         empty: false,
@@ -469,7 +462,7 @@ function dedupe(reads) {
     const seen = new Set();
     const out = [];
     for (const c of reads) {
-        const key = `${c.provenance}\u0000${c.spelled}\u0000${c.expands}`;
+        const key = `${c.provenance}\u0000${c.spelled}\u0000${c.expands}\u0000${c.denyOnly === true}`;
         if (seen.has(key))
             continue;
         seen.add(key);
@@ -477,15 +470,8 @@ function dedupe(reads) {
     }
     return out;
 }
-function bare(raw, folded, provenance) {
-    return { spelled: folded, raw, provenance, expands: expandsOf(raw, folded) };
-}
-function expandsOf(raw, folded) {
-    if (folded.includes(SUBSTITUTION_PLACEHOLDER) || hasUnquotedExpansionMetachar(raw) || /[`(]/.test(raw) || raw.includes(")"))
-        return "unresolvable";
-    if (hasUnquotedGlobMetachar(raw))
-        return "glob";
-    return false;
+function bare(r, provenance, spelled = r.folded) {
+    return { spelled, raw: r.raw, provenance, expands: r.expands };
 }
 function relativeSpelling(spelled) {
     return !(isAbsolutePathForm(spelled) || spelled.startsWith("~"));
@@ -493,54 +479,67 @@ function relativeSpelling(spelled) {
 function joinBase(base, target, homeDir) {
     return resolveOperandLexically(base, target, homeDir);
 }
-function redirectFact(r) {
+function redirectFact(r, home) {
     if (r.target === undefined)
         return { op: r.op, direction: "dup" };
     if (r.op === "<")
-        return { op: r.op, direction: "in", target: bare(r.target.raw, r.target.folded, "stdin_redirect") };
+        return { op: r.op, direction: "in", target: bare(readsOf([r.target], home)[0], "stdin_redirect") };
     if (r.op === "<<<")
         return { op: r.op, direction: "in" };
-    return { op: r.op, direction: "out", target: bare(r.target.raw, r.target.folded, "write_redirect_target") };
+    return { op: r.op, direction: "out", target: bare(readsOf([r.target], home)[0], "write_redirect_target") };
 }
-function pushAssignment(reads, folded, raw, provenance, opensValue = true) {
-    const payload = assignmentWordPayload(folded, raw);
-    const prefix = writtenAssignmentPrefix(folded)?.prefix;
-    if (payload === undefined || prefix === undefined)
+function pushAssignment(reads, w, provenance, opensValue = true) {
+    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: folded.slice(prefix.length), raw: raw.startsWith(prefix) ? raw.slice(prefix.length) : raw, provenance };
-    const unsettled = provenance !== "env_assignment" ? { ...v, expands: "unresolvable" } : v.spelled.startsWith("~") && !v.spelled.includes(":") ? bare(v.raw, v.spelled, provenance) : undefined;
-    if (payload.kind === "unresolved" && opensValue && unsettled !== undefined)
+    const v = { spelled: a.value.folded, 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 && opensValue && unsettled !== undefined)
         reads.push(unsettled);
-    if (payload.value !== undefined && payload.value !== SUBSTITUTION_PLACEHOLDER)
-        reads.push(bare(raw, payload.value, provenance));
+    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.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);
-    const argvStart = argv?.from ?? toks.folded.length;
+    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 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.folded.length; j++) {
+    for (let j = from; j < toks.length; j++) {
         if (launcherIndices.has(j))
             continue;
         if (noPathOperands && j > argvStart)
             break;
-        if (expandsOf(toks.raw[j], toks.folded[j]) !== "unresolvable")
+        if (toks[j].expands !== "unresolvable")
             continue;
         expanding.add(j);
-        reads.push({ spelled: toks.folded[j], raw: toks.raw[j], provenance: j === argvStart ? "program_path" : provenance, expands: "unresolvable" });
+        reads.push(bare(toks[j], j === argvStart ? "program_path" : provenance));
+        if (j < argvStart)
+            pushAssignment(reads, toks[j].word, "env_assignment", slotVerb !== undefined && !noPathOperands);
+        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.folded.length; j++) {
+    for (let j = from; j < toks.length; j++) {
         if (launcherIndices.has(j) || expanding.has(j))
             continue;
-        const word = toks.folded[j];
-        const raw = toks.raw[j];
+        const r = toks[j];
+        const word = r.folded;
         if (j > from && !endOfOptions && word === "--") {
             endOfOptions = true;
             continue;
@@ -553,43 +552,43 @@ function unlistedWords(reads, toks, from, launcherIndices, provenance, program)
         if (optionShaped && j > argvStart) {
             const slot = slotVerb === undefined ? undefined : readVerbOptionSlot(slotVerb, word);
             if (sawArgvOperand && permutes) {
-                reads.push(bare(raw, word, provenance));
+                reads.push(bare(r, provenance));
                 if (slot !== undefined && slot.form === "separated") {
-                    const ahead = toks.folded[j + 1];
-                    if (ahead !== undefined && expandsOf(toks.raw[j + 1], ahead) !== "unresolvable")
-                        for (const c of slotValueCandidates(ahead, slot.kind))
-                            reads.push(bare(toks.raw[j + 1], c, "option_value"));
+                    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(raw, c, "option_value"));
+                        reads.push(bare(r, "option_value", c));
                 }
                 else if (slot.form === "separated") {
                     j++;
-                    const value = toks.folded[j];
+                    const value = toks[j];
                     if (value !== undefined && !expanding.has(j)) {
-                        const named = slotValueCandidates(value, slot.kind);
+                        const named = slotValueCandidates(value.folded, slot.kind);
                         for (const c of named)
-                            reads.push(bare(toks.raw[j], c, "option_value"));
+                            reads.push(bare(value, "option_value", c));
                         if (named.length > 0)
-                            positional.push({ word: value, raw: toks.raw[j] });
+                            positional.push(value);
                     }
                 }
                 continue;
             }
             for (const payload of attachedOptionPayloads(word))
-                reads.push(bare(raw, payload, provenance));
+                reads.push(bare(r, provenance, payload));
             if (isPathShapedToken(word))
-                reads.push(bare(raw, word, provenance));
+                reads.push(bare(r, provenance));
             continue;
         }
         if (optionShaped) {
             for (const payload of attachedOptionPayloads(word))
-                reads.push(bare(raw, payload, provenance));
+                reads.push(bare(r, provenance, payload));
             if (isPathShapedToken(word))
-                reads.push(bare(raw, word, provenance));
+                reads.push(bare(r, provenance));
             continue;
         }
         if (j > argvStart) {
@@ -599,39 +598,38 @@ function unlistedWords(reads, toks, from, launcherIndices, provenance, program)
                 if (m === undefined || m.dashIsStdin === true)
                     stdinOperand = true;
                 else
-                    positional.push({ word, raw });
+                    positional.push(r);
             }
             else
-                positional.push({ word, raw });
+                positional.push(r);
         }
-        reads.push(bare(raw, word, j === argvStart ? "program_path" : provenance));
+        reads.push(bare(r, j === argvStart ? "program_path" : provenance));
         if (j < argvStart)
-            pushAssignment(reads, word, raw, "env_assignment", slotVerb !== undefined && !noPathOperands);
+            pushAssignment(reads, r.word, "env_assignment", slotVerb !== undefined && !noPathOperands);
         else if (!declaredNotPaths)
-            pushAssignment(reads, word, raw, provenance);
+            pushAssignment(reads, r.word, provenance);
     }
-    if (slotVerb !== undefined && argv !== undefined && segmentSelectsRecursiveRead(slotVerb, toks.folded.slice(argvStart + 1))) {
-        const roots = positional.length > 0 ? positional : stdinOperand ? [] : [{ word: ".", raw: "." }];
+    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({ spelled: root.word, raw: root.raw, provenance: "traversal_root", expands: expandsOf(root.raw, root.word) });
+            reads.push(bare(root, "traversal_root"));
     }
-    for (let j = from; j < toks.folded.length; j++) {
+    for (let j = from; j < toks.length; j++) {
         if (launcherIndices.has(j) || j === argvStart)
             continue;
         if (noPathOperands && j > argvStart)
             break;
-        const raw = toks.raw[j];
-        if (expandsOf(raw, toks.folded[j]) === "glob")
-            reads.push(bare(raw, toks.folded[j], provenance));
+        if (toks[j].expands === "glob")
+            reads.push(bare(toks[j], provenance));
     }
 }
 function commandStringValue(options, toks, option) {
-    const at = toks.folded.indexOf(option);
+    const at = toks.findIndex((r) => r.folded === option);
     if (at < 0)
         return undefined;
     for (const spelling of options) {
         if (option === spelling) {
-            const value = toks.folded[at + 1];
+            const value = toks[at + 1]?.folded;
             return value === undefined ? undefined : { value, next: at + 2 };
         }
         if (spelling.startsWith("--") && option.startsWith(`${spelling}=`))
@@ -641,68 +639,46 @@ function commandStringValue(options, toks, option) {
     }
     return undefined;
 }
-function reentryText(basename, args) {
-    if (basename === "eval")
-        return args.length === 0 ? undefined : args.join(" ");
-    if (basename === "parallel")
-        return args.filter((a) => !a.startsWith("-")).join(" ") || undefined;
-    if (basename === "source" || basename === ".")
-        return undefined;
-    for (let k = 0; k < args.length; k++) {
-        const a = args[k];
-        if (a === "--")
-            return undefined;
-        if (!a.startsWith("-") || a === "-")
-            return undefined;
-        const c = a.indexOf("c");
-        if (a.startsWith("--"))
-            continue;
-        if (c > 0)
-            return a.length > c + 1 ? a.slice(c + 1) : args[k + 1];
-    }
-    return undefined;
-}
 function literalBeats(toks) {
-    const at = toks.folded.indexOf("in");
+    const at = toks.findIndex((r) => r.folded === "in");
     if (at < 0)
         return undefined;
-    const words = toks.folded.slice(at + 1);
-    const raws = toks.raw.slice(at + 1);
+    const words = toks.slice(at + 1);
     if (words.length === 0)
         return undefined;
-    if (words.length === 1 && words[0].includes(SUBSTITUTION_PLACEHOLDER)) {
-        const m = /^\$\(\s*seq\s+(\d+)\s+(\d+)\s*\)$/.exec(raws[0]);
+    const only = words.length === 1 && words[0].word.pieces.length === 1 ? words[0].word.pieces[0].expansion : undefined;
+    if (only !== undefined) {
+        const m = only.kind === "command" ? /^\s*seq\s+(\d+)\s+(\d+)\s*$/.exec(only.body ?? "") : null;
         if (m === null)
             return undefined;
         const beats = Number(m[2]) - Number(m[1]) + 1;
         return beats >= 1 && beats <= POLL_LOOP_MAX_BEATS ? beats : undefined;
     }
-    for (let k = 0; k < words.length; k++) {
-        if (expandsOf(raws[k], words[k]) !== false)
+    for (const w of words)
+        if (w.expands !== false)
             return undefined;
-    }
     return words.length <= POLL_LOOP_MAX_BEATS ? words.length : undefined;
 }
-function cdMove(args, rawArgs, reads) {
-    const idx = args.findIndex((t) => !t.startsWith("-") || t === "-");
-    if (idx < 0)
+function cdMove(args, reads) {
+    const target = args.find((t) => !t.folded.startsWith("-") || t.folded === "-");
+    if (target === undefined)
         return { target: "home" };
-    const target = args[idx];
-    if (target === "-")
+    if (target.folded === "-")
         return { target: "previous" };
-    const c = bare(rawArgs[idx], target, "cd_target");
+    const c = bare(target, "cd_target");
     reads.push(c);
     return { target: c };
 }
-function listedVerbCandidates(name, args, rawArgs, reads) {
+function listedVerbCandidates(name, argReads, reads) {
     if (NO_PATH_OPERAND_COMMANDS.has(name))
         return;
+    const args = argReads.map((r) => r.folded);
     const expanding = new Set();
-    rawArgs.forEach((raw, k) => {
-        if (!hasUnquotedExpansionMetachar(raw))
+    argReads.forEach((r, k) => {
+        if (!rewritten(r))
             return;
         expanding.add(k);
-        reads.push({ spelled: args[k], raw, provenance: "operand", expands: "unresolvable" });
+        reads.push({ spelled: r.folded, raw: r.raw, provenance: "operand", expands: "unresolvable" });
     });
     const eoo = args.indexOf("--");
     const firstOperandSlot = verbFirstOperandSlot(name);
@@ -713,7 +689,7 @@ function listedVerbCandidates(name, args, rawArgs, reads) {
     let endOfOptions = false;
     const permutes = !verbOptionsArePositionIndependent(name);
     const push = (k, text, provenance) => {
-        reads.push(bare(rawArgs[k], text, provenance));
+        reads.push(bare(argReads[k], provenance, text));
     };
     for (let k = 0; k < args.length; k++) {
         const t = args[k];
@@ -747,7 +723,7 @@ function listedVerbCandidates(name, args, rawArgs, reads) {
                             for (const c of named)
                                 push(k, c, "option_value");
                             if (named.length > 0)
-                                positional.push({ word: value, raw: rawArgs[k] });
+                                positional.push(argReads[k]);
                         }
                     }
                     continue;
@@ -767,7 +743,7 @@ function listedVerbCandidates(name, args, rawArgs, reads) {
                 stdinOperand = true;
                 continue;
             }
-            positional.push({ word: t, raw: rawArgs[k] });
+            positional.push(argReads[k]);
             continue;
         }
         if (inFirstOperandSlot) {
@@ -775,24 +751,24 @@ function listedVerbCandidates(name, args, rawArgs, reads) {
             for (const c of named)
                 push(k, c, "operand");
             if (named.length > 0)
-                positional.push({ word: t, raw: rawArgs[k] });
+                positional.push(argReads[k]);
             continue;
         }
-        positional.push({ word: t, raw: rawArgs[k] });
+        positional.push(argReads[k]);
         push(k, t, "operand");
         if (!ASSIGNMENT_VALUE_NOT_PATHS.has(name)) {
-            pushAssignment(reads, t, rawArgs[k], "operand");
+            pushAssignment(reads, argReads[k].word, "operand");
         }
     }
     for (let k = 0; k < args.length; k++) {
         if (expanding.has(k))
             continue;
-        if (expandsOf(rawArgs[k], args[k]) === "glob")
-            reads.push(bare(rawArgs[k], args[k], "operand"));
+        if (argReads[k].expands === "glob")
+            reads.push(bare(argReads[k], "operand"));
     }
     if (segmentSelectsRecursiveRead(name, args)) {
-        const roots = positional.length > 0 ? positional : stdinOperand ? [] : [{ word: ".", raw: "." }];
+        const roots = positional.length > 0 ? positional : stdinOperand ? [] : [readOfText(".")];
         for (const root of roots)
-            reads.push({ spelled: root.word, raw: root.raw, provenance: "traversal_root", expands: expandsOf(root.raw, root.word) });
+            reads.push(bare(root, "traversal_root"));
     }
 }