@sema-agent/core 7.45.0 → 7.46.0

package/dist/tools/fs/safety.d.ts

@@ -129,6 +129,9 @@ export interface FsViolation {
  * lands it outside every POSIX/drive root, i.e. a location the working directory does not contain.
  */
 export declare function isAbsolutePathForm(p: string): boolean;
+/** Does this absolute spelling name the opening process's STANDARD INPUT (`/dev/stdin`, `/dev/fd/0`, `/proc/<pid>/fd/0`),
+ *  folded lexically first (`/dev/./stdin`, `/dev//fd/0`)? */
+export declare function namesStandardInput(path: string): boolean;
 /**
  * Windows-FAMILY spelling of a path (extracted here so {@link canonicalizeTarget} judges
  * the UNC family by the same rule): drive-rooted (`C:\…`/`C:/…`), UNC-backslash (`\\host\share`), or a

package/dist/tools/fs/safety.js

@@ -3,6 +3,7 @@ import { readDenySentence } from "./read-deny.js";
 import { homeViewsOf } from "./read-deny-home.js";
 import { sliceHeadSafe } from "../../core/surrogate-safe-slice.js";
 import { pathTargetValue, protectivePathTargetOf } from "../../core/tool-registry.js";
+import { readPathViews } from "../../core/effective-path-target.js";
 import { withGateTimeout, DEFAULT_GATE_AWAIT_TIMEOUT_MS } from "../../core/gate-bounded-await.js";
 import { thrownText } from "../../core/thrown-value.js";
 export function fileArgPath(args) {
@@ -41,6 +42,10 @@ const BLOCKED_DEVICE_PATHS = new Set([
 function isProcStdioFd(key) {
     return key.startsWith("/proc/") && (key.endsWith("/fd/0") || key.endsWith("/fd/1") || key.endsWith("/fd/2"));
 }
+export function namesStandardInput(path) {
+    const k = path.startsWith("/") ? normalizeAbsPathLexically(path) : "";
+    return k === "/dev/stdin" || k === "/dev/fd/0" || (k.startsWith("/proc/") && k.endsWith("/fd/0"));
+}
 const PROC_SENSITIVE_SUFFIXES = ["/environ", "/cmdline", "/auxv", "/maps", "/mem", "/stat"];
 function isProcSensitiveFile(key) {
     return key.startsWith("/proc/") && PROC_SENSITIVE_SUFFIXES.some((suf) => key.endsWith(suf));
@@ -457,7 +462,8 @@ function within(rootCanonical, p) {
     return pN.identity.startsWith(rootN.identity.endsWith(SEP) ? rootN.identity : rootN.identity + SEP);
 }
 export async function resolveKey(env, rootCanonical, path, signal, baseCwd, additionalRoots, exactFileReadExemption, readDeny, containmentFace) {
-    const canon = await canonicalizeTarget(env, path, signal, pathFamilyOf({ root: rootCanonical }), baseCwd);
+    const views = await readPathViews(env, path, baseCwd ?? rootCanonical, { root: rootCanonical, ...(baseCwd !== undefined ? { cwd: baseCwd } : {}) }, signal, { hops: readDeny !== undefined });
+    const canon = views.canonical ?? (await canonicalizeTarget(env, path, signal, pathFamilyOf({ root: rootCanonical }), baseCwd));
     if (!canon.ok)
         return { ok: false, violation: { code: "invalid", message: canon.message } };
     const key = canon.key;
@@ -466,8 +472,9 @@ export async function resolveKey(env, rootCanonical, path, signal, baseCwd, addi
         return { ok: false, violation: { code: "invalid", message: `path "${path}" is a blocked device/special file (reading it can hang the process); refused.` } };
     }
     if (readDeny !== undefined) {
-        const judged = { aliasResolved: canon.aliasResolved === true };
-        let hit = readDeny.matchTarget(key, lexicalViewOf(path, baseCwd ?? rootCanonical), judged);
+        const judged = { aliasResolved: canon.aliasResolved === true, hops: views.hops };
+        const lexical = views.lexical?.kind === "path" ? spellingOfIdentity(views.lexical.identity, pathFamilyOf({ root: rootCanonical })) : undefined;
+        let hit = readDeny.matchTarget(key, lexical, judged);
         if (hit === null) {
             const homeView = await homeViewsOf(env, readDeny, signal).of(key);
             if (homeView !== undefined)

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

@@ -0,0 +1,85 @@
+/**
+ * The candidates ONE program's words hand the read station — the program read model's rows read word by word: a
+ * listed reader's operands and option-value slots, an unlisted program's words (its own row read where it has one,
+ * read the speculative way where it has none), a subcommand's words by the subcommand's row, a module's program text,
+ * an assignment word's value. `shell-read-plan.ts` threads the segments and their bases; this module is what one
+ * segment's argv offers.
+ */
+import { type LexedWord } from "../../shell/lex.js";
+import { type Read } from "./shell-read-word.js";
+import { type BindingTable, type BoundValue } from "./shell-read-bindings.js";
+import { subcommandOf, type ArgRole, type ProgramRow } from "./program-read-model.js";
+import type { ReadCandidate, ReadCandidateProvenance } from "./shell-read-plan.js";
+/** A candidate before the threading fills its bases. `alternatives`: the other spellings its word may expand to (a name
+ *  bound to several values) — one candidate each once the segment's reads are read. */
+export type Bare = Omit<ReadCandidate, "bases"> & {
+    readonly alternatives?: readonly string[];
+    readonly floors?: readonly BoundValue[];
+};
+/** What reading a segment's words found beside its candidates. */
+export interface WordContext {
+    /** The names at this segment. */
+    readonly table: BindingTable;
+    /** Shell text the arithmetic evaluator runs (a substitution in a subscript it evaluates): the segment re-enters it. */
+    readonly reentered: string[];
+    /** Program text the station does not read — inline text in a language that may open files, or a program read from
+     *  standard input: why the segment's reads are not established. */
+    programText?: string;
+    /** Some program text was found in a slot (whether or not it may open files). */
+    programTextSeen: boolean;
+}
+/** The subcommand whose row says how ITS words name paths (operands or a traversal of its own), or `undefined`: a
+ *  subcommand whose row states only its grammar — its message slots, read by {@link messageWords} — leaves its words to
+ *  the program's own reading. */
+export declare function pathSubcommandOf(row: ProgramRow | undefined, args: readonly string[]): ReturnType<typeof subcommandOf>;
+/** The sentence of inline program text the station does not read. */
+export declare const programTextSentence: (language: string) => string;
+/** One candidate without its bases (filled by the threading pass): the word's spelling — or `spelled`, a caller's
+ *  reading of PART of it (an option payload, a `key=value` value) — with the word's own expansion facts. A word whose
+ *  names may hold several values offers each as its whole spelling; a PART of such a word is not followed through them
+ *  (it is unresolvable). */
+export declare function bare(r: Read, provenance: ReadCandidateProvenance, spelled?: string): Bare;
+/** The reads one value of a declared role hands over: a candidate per file it names, or — a value the program expands
+ *  past the listed bound — the word itself, unresolvable. A mount source is a read the daemon makes of the whole tree
+ *  under it (a read and a traversal root); an object path
+ *  `<rev>:<path>` offers the word as a path and the `<path>` it spells to the deny judge; program text is never a path
+ *  ({@link programTextReads}). `alsoOperand`: the walk read the option past the first operand, where the program may
+ *  have stopped reading options — a path role is still offered (more candidates), but no program text is read there:
+ *  the word is the operands' (the script's own argument), as the program's delivery reading says. */
+export declare function roleReads(r: Read, provenance: ReadCandidateProvenance, value: string, role: ArgRole, globs: "expanded" | "literal", ctx: WordContext, alsoOperand?: boolean): Bare[];
+/**
+ * The candidates a `NAME=value` word hands the judge, both facts about its VALUE (the word is a path to nobody):
+ * what path it NAMES, and what the text cannot SETTLE — placed as an operand is wherever an environment value
+ * names ONE path (a leading tilde against the declared home; a `:` joins a second). Where the text runs nothing able
+ * to open a file, {@link planShellReads} drops them: the value names a path to nobody.
+ *
+ * Bash applies its assignment-word expansion to such a word even when it is an ARGUMENT to a simple command, so
+ * the program receives `NAME=<expanded value>`, and a program that reads its value as a path (`dd if=…`, a build
+ * or tool variable, a launcher's environment word) opens what the value names. Two facts of the lexer's
+ * {@link AssignmentFact} are read: a tilde the shell EXPANDS in the value (at its start and after each `:`, where
+ * unquoted — `value.expansions`) leaves the path unsettled, and the append form (`NAME+=value`) names `<whatever
+ * NAME held>` + value, so the whole value is not in the text — but the text it appends IS, and an unset or empty
+ * NAME makes it the whole value, so it is a candidate too. A value that is a substitution is the nested plan
+ * its body already is, never a candidate of its own text (its placeholder is not a path).
+ */
+export declare function pushAssignment(reads: Bare[], w: LexedWord, provenance: ReadCandidateProvenance): void;
+/** Every word of a segment whose program's grammar this parser does not model, from `from` onward: option
+ *  payloads and path-shaped option words included, the launcher chain's own words excluded, a program declared
+ *  to open no path operand handing only the environment words in front of it. A program with NO row is read the
+ *  speculative way: every word is still handed over, but the filesystem decides it
+ *  ({@link ReadCandidate.speculative}). */
+export declare function unlistedWords(reads: Bare[], toks: readonly Read[], from: number, launcherIndices: ReadonlySet<number>, provenance: ReadCandidateProvenance, ctx: WordContext, program?: {
+    readonly index: number;
+    readonly basename: string;
+}): void;
+/** The positional operands and declared option-value slots of a listed reader — the program read model's argv walk,
+ *  one candidate per word the program may open, plus the traversal roots of a recursive form. A subcommand's words
+ *  are read by its own row; the words a module takes as its program text are program text. */
+export declare function listedVerbCandidates(name: string, argReads: readonly Read[], reads: Bare[], ctx: WordContext): void;
+/** The subscript of a variable-name word (`a[…]`), as the arithmetic text that is evaluated; the empty text for a plain
+ *  name. */
+export declare function subscriptOnly(word: string): string;
+/** An assignment word's arithmetic: its own subscript (`a[$(…)]=1`, quoted or not — not for a builtin that takes the
+ *  name `asWritten`), and its value where the name carries the integer attribute (`declare -i n; n='a[$(…)]'`, bash's
+ *  own `OPTIND` / `RANDOM` / …). */
+export declare function assignmentArithmetic(w: LexedWord, integer: boolean, ctx: WordContext, asWritten?: boolean): void;

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

@@ -0,0 +1,386 @@
+import { literalTildeSpelling } from "../../shell/lex.js";
+import { expandsOf, readOfText, rewritten } from "./shell-read-word.js";
+import { arithmeticSubstitutions } from "./shell-read-bindings.js";
+import { argvProgramOf, attachedOptionPayloads, isPathShapedToken } from "./bash-readonly-classifier.js";
+import { assignmentArgumentsAreNotPaths, evaluatesOperands, messageWords, moduleTailOf, objectPathsOf, opensNoOperand, programRow, programTextMayOpen, programTextOpensOf, readArgs, selectsContentsTraversal, slotValueCandidates, subcommandOf, valuesAreLiteral, walksCwdWithoutOperand, wordsReadBySomeImplementations, } from "./program-read-model.js";
+export function pathSubcommandOf(row, args) {
+    const sub = subcommandOf(row, args);
+    return sub !== undefined && (sub.row.operands !== undefined || sub.row.traversal !== undefined) ? sub : undefined;
+}
+export const programTextSentence = (language) => `runs inline ${language} program text, which may open files this station does not read`;
+export function bare(r, provenance, spelled = r.folded) {
+    const whole = spelled === r.folded;
+    if (!whole && r.values !== undefined)
+        return { spelled, raw: r.raw, provenance, expands: "unresolvable" };
+    return {
+        spelled,
+        raw: r.raw,
+        provenance,
+        expands: r.expands,
+        ...(whole && r.values !== undefined ? { alternatives: r.values.slice(1) } : {}),
+        ...(whole && r.homeFloor !== undefined ? { floorSpelled: r.homeFloor } : {}),
+        ...(whole && r.floorValues !== undefined ? { floors: r.floorValues } : {}),
+    };
+}
+export function roleReads(r, provenance, value, role, globs, ctx, alsoOperand = false) {
+    if (role.kind === "program-text")
+        return alsoOperand ? [] : programTextReads(r, provenance, value, role.language, ctx);
+    if (role.kind === "object-path")
+        return [bare(r, provenance, value), ...objectPathsOf(value).map((c) => ({ ...bare(r, "object_path", c), denyOnly: true }))];
+    const named = slotValueCandidates(value, role, globs);
+    if (named === undefined)
+        return [{ ...bare(r, provenance), expands: "unresolvable" }];
+    if (role.kind === "mount-source")
+        return named.flatMap((c) => [bare(r, "mount_source", c), bare(r, "traversal_root", c)]);
+    return named.map((c) => bare(r, provenance, c));
+}
+function programTextReads(r, provenance, text, language, ctx) {
+    ctx.programTextSeen = true;
+    const opens = programTextOpensOf(language);
+    if (opens === "arithmetic") {
+        ctx.reentered.push(...arithmeticSubstitutions(text, ctx.table));
+        return [];
+    }
+    if (opens === "parsed" || opens === "never")
+        return [];
+    if (programTextMayOpen(language, text))
+        ctx.programText ??= programTextSentence(language);
+    return [{ ...bare(r, provenance, text), denyOnly: true }];
+}
+export function pushAssignment(reads, w, provenance) {
+    const a = w.assignment;
+    if (a === undefined || a.form === "compound")
+        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 });
+            }
+}
+export function unlistedWords(reads, toks, from, launcherIndices, provenance, ctx, 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 slotRow = slotVerb === undefined ? undefined : programRow(slotVerb);
+    const noRow = slotVerb !== undefined && slotRow === undefined;
+    const speculate = (start, how) => {
+        if (!noRow)
+            return;
+        for (let i = start; i < reads.length; i++) {
+            const c = reads[i];
+            if (c.expands === "unresolvable" || c.speculative !== undefined || c.denyOnly === true || c.provenance === "program_path" || c.provenance === "env_assignment")
+                continue;
+            reads[i] = { ...c, speculative: how };
+        }
+    };
+    const message = slotVerb === undefined || argv === undefined ? new Set() : messageWords(slotVerb, toks, argvStart);
+    let declaredNotPaths = assignmentArgumentsAreNotPaths(slotVerb ?? "");
+    const noPathOperands = slotVerb !== undefined && opensNoOperand(slotVerb);
+    const expanding = new Set();
+    for (let j = from; j < toks.length; j++) {
+        if (launcherIndices.has(j))
+            continue;
+        if (noPathOperands && j > argvStart && !evaluatesOperands(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 = [];
+    const pastOperand = new Set();
+    let stdinOperand = false;
+    let globs = "expanded";
+    let walkRow = slotRow;
+    let walkFrom = argvStart + 1;
+    let relocated = false;
+    if (argvStart >= toks.length) {
+        let endOfOptions = 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 (!endOfOptions && word.startsWith("-") && word !== "-") {
+                for (const payload of attachedOptionPayloads(word))
+                    reads.push(bare(r, provenance, payload));
+                if (isPathShapedToken(word))
+                    reads.push(bare(r, provenance));
+                continue;
+            }
+            reads.push(bare(r, provenance));
+            pushAssignment(reads, r.word, "env_assignment");
+        }
+    }
+    else if (!noPathOperands) {
+        const programWord = toks[argvStart];
+        if (!expanding.has(argvStart) && !launcherIndices.has(argvStart) && !message.has(argvStart)) {
+            const word = programWord.folded;
+            if (isPathShapedToken(word)) {
+                if (word.startsWith("-") && word !== "-") {
+                    for (const payload of attachedOptionPayloads(word))
+                        reads.push(bare(programWord, provenance, payload));
+                    reads.push(bare(programWord, provenance));
+                }
+                else {
+                    reads.push(bare(programWord, "program_path"));
+                    if (!declaredNotPaths)
+                        pushAssignment(reads, programWord.word, provenance);
+                }
+            }
+        }
+        const args = toks.slice(argvStart + 1).map((r) => r.folded);
+        const sub = pathSubcommandOf(slotRow, args);
+        const tail = moduleTailOf(slotRow, args);
+        const skipped = (j) => launcherIndices.has(j) || expanding.has(j) || message.has(j) || (tail !== undefined && j >= argvStart + 1 + tail.from);
+        const walk = (row, first, last, slotKind) => {
+            const at = (k) => first + k;
+            const words = toks.slice(first, last).map((r, k) => ({ folded: r.folded, skip: skipped(at(k)) }));
+            globs = valuesAreLiteral(row, words.map((w) => w.folded)) ? "literal" : "expanded";
+            const someRead = wordsReadBySomeImplementations(row, words.map((w) => w.folded));
+            for (const e of readArgs(row, words, { firstOperandSlot: slotKind })) {
+                const start = reads.length;
+                handleUnlistedEvent(e, at(e.at));
+                if (someRead.has(e.at))
+                    for (let i = start; i < reads.length; i++)
+                        if (reads[i].expands !== "unresolvable" && reads[i].denyOnly !== true)
+                            reads[i] = { ...reads[i], speculative: "containment" };
+            }
+        };
+        if (sub !== undefined) {
+            walk(slotRow, argvStart + 1, argvStart + 1 + sub.at, false);
+            declaredNotPaths = sub.row.operands?.assignmentArguments === "not-paths";
+            walkRow = sub.row;
+            walkFrom = argvStart + 2 + sub.at;
+            relocated = sub.relocated;
+            positional.length = 0;
+            stdinOperand = false;
+            walk(sub.row, walkFrom, toks.length, true);
+        }
+        else
+            walk(slotRow, argvStart + 1, toks.length, "program-text");
+        if (tail !== undefined)
+            for (let j = argvStart + 1 + tail.from; j < toks.length; j++)
+                if (!expanding.has(j))
+                    reads.push(...roleReads(toks[j], "operand", toks[j].folded, tail.role, globs, ctx));
+    }
+    function handleUnlistedEvent(e, j) {
+        const r = toks[j];
+        const start = reads.length;
+        switch (e.kind) {
+            case "end-of-options":
+                return;
+            case "dash-word-operand":
+                pastOperand.add(j);
+                reads.push(bare(r, provenance));
+                speculate(start, "whole");
+                return;
+            case "value": {
+                if (!e.consumed) {
+                    if (r.expands !== "unresolvable")
+                        reads.push(...roleReads(r, "option_value", r.folded, e.role, globs, ctx, true));
+                    return;
+                }
+                if (expanding.has(j))
+                    return;
+                const named = roleReads(r, "option_value", r.folded, e.role, globs, ctx);
+                reads.push(...named);
+                if (named.some((c) => c.denyOnly !== true))
+                    positional.push(r);
+                return;
+            }
+            case "option":
+                if (e.reading === "no-value")
+                    return;
+                if (e.reading === "speculative") {
+                    for (const payload of attachedOptionPayloads(r.folded))
+                        reads.push(bare(r, provenance, payload));
+                    speculate(start, "containment");
+                    const whole = reads.length;
+                    if (isPathShapedToken(r.folded))
+                        reads.push(bare(r, provenance));
+                    speculate(whole, "whole");
+                    return;
+                }
+                reads.push(...roleReads(r, "option_value", literalTildeSpelling(e.reading.attached), e.reading.role, globs, ctx, pastOperand.has(j)));
+                return;
+            case "operand": {
+                const role = e.dash === undefined ? (e.slot ?? e.role) : undefined;
+                const named = role !== undefined ? roleReads(r, provenance, r.folded, role, globs, ctx) : [bare(r, provenance)];
+                if (e.dash === "stdin")
+                    stdinOperand = true;
+                else if (named.some((c) => c.denyOnly !== true))
+                    positional.push(r);
+                reads.push(...named);
+                speculate(start, r.word.assignment !== undefined ? "whole" : "containment");
+                const values = reads.length;
+                if (!declaredNotPaths && e.slot === undefined)
+                    pushAssignment(reads, r.word, provenance);
+                speculate(values, "containment");
+                return;
+            }
+        }
+    }
+    if (walkRow !== undefined && argv !== undefined && selectsContentsTraversal(walkRow, toks.slice(walkFrom).map((x) => x.folded))) {
+        const roots = positional.length > 0 ? positional : stdinOperand || !walksCwdWithoutOperand(walkRow) ? [] : [readOfText(".")];
+        for (const root of roots)
+            reads.push(relocated ? { ...bare(root, "traversal_root"), expands: "unresolvable" } : bare(root, "traversal_root"));
+    }
+    for (let j = from; j < toks.length; j++) {
+        if (launcherIndices.has(j) || j === argvStart)
+            continue;
+        if (noPathOperands && j > argvStart)
+            break;
+        const start = reads.length;
+        if (toks[j].expands === "glob")
+            reads.push(bare(toks[j], provenance));
+        speculate(start, "containment");
+    }
+}
+export function listedVerbCandidates(name, argReads, reads, ctx) {
+    if (opensNoOperand(name))
+        return;
+    const row = programRow(name);
+    const args = argReads.map((r) => r.folded);
+    const expanding = new Set();
+    argReads.forEach((r, k) => {
+        if (!rewritten(r))
+            return;
+        expanding.add(k);
+        reads.push({ ...bare(r, "operand"), expands: "unresolvable" });
+    });
+    const sub = pathSubcommandOf(row, args);
+    const tail = moduleTailOf(row, args);
+    if (sub !== undefined) {
+        walkListed(row, argReads, 0, sub.at, expanding, reads, ctx, false);
+        walkListed(sub.row, argReads, sub.at + 1, argReads.length, expanding, reads, ctx, sub.relocated);
+    }
+    else
+        walkListed(row, argReads, 0, tail !== undefined ? tail.from : argReads.length, expanding, reads, ctx, false);
+    if (tail !== undefined)
+        for (let k = tail.from; k < argReads.length; k++)
+            if (!expanding.has(k))
+                reads.push(...roleReads(argReads[k], "operand", args[k], tail.role, "expanded", ctx));
+    for (let k = 0; k < args.length; k++) {
+        if (expanding.has(k))
+            continue;
+        if (argReads[k].expands === "glob")
+            reads.push(bare(argReads[k], "operand"));
+    }
+}
+function walkListed(row, argReads, first, last, expanding, reads, ctx, relocated) {
+    const slice = argReads.slice(first, last);
+    const args = slice.map((r) => r.folded);
+    const positional = [];
+    let stdinOperand = false;
+    const globs = valuesAreLiteral(row, args) ? "literal" : "expanded";
+    const someRead = wordsReadBySomeImplementations(row, args);
+    const pastOperand = new Set();
+    const offer = (k, value, role, provenance, alsoOperand = false) => {
+        const named = roleReads(slice[k], provenance, value, role, globs, ctx, alsoOperand);
+        reads.push(...named);
+        return named.filter((c) => c.denyOnly !== true).length;
+    };
+    for (const e of readArgs(row, args.map((folded, k) => ({ folded, skip: expanding.has(first + k) })), { firstOperandSlot: true })) {
+        const t = args[e.at];
+        const start = reads.length;
+        switch (e.kind) {
+            case "end-of-options":
+                break;
+            case "dash-word-operand":
+                pastOperand.add(e.at);
+                reads.push(bare(slice[e.at], "operand"));
+                break;
+            case "value": {
+                if (expanding.has(first + e.at))
+                    break;
+                if (offer(e.at, t, e.role, "option_value", !e.consumed) > 0 && e.consumed)
+                    positional.push(slice[e.at]);
+                break;
+            }
+            case "option":
+                if (e.reading === "no-value")
+                    break;
+                if (e.reading === "speculative") {
+                    for (const payload of attachedOptionPayloads(t))
+                        reads.push(bare(slice[e.at], "option_value", payload));
+                    break;
+                }
+                offer(e.at, literalTildeSpelling(e.reading.attached), e.reading.role, "option_value", pastOperand.has(e.at));
+                break;
+            case "operand": {
+                if (e.dash !== undefined) {
+                    if (e.slot !== undefined)
+                        break;
+                    if (e.dash === "stdin")
+                        stdinOperand = true;
+                    else
+                        positional.push(slice[e.at]);
+                    break;
+                }
+                if (e.slot !== undefined) {
+                    if (offer(e.at, t, e.slot, "operand") > 0)
+                        positional.push(slice[e.at]);
+                    break;
+                }
+                let named = 1;
+                if (e.role !== undefined)
+                    named = offer(e.at, t, e.role, "operand");
+                else
+                    reads.push(bare(slice[e.at], "operand"));
+                if (named > 0)
+                    positional.push(slice[e.at]);
+                if (row?.operands?.assignmentArguments !== "not-paths")
+                    pushAssignment(reads, slice[e.at].word, "operand");
+                break;
+            }
+        }
+        if (someRead.has(e.at))
+            for (let i = start; i < reads.length; i++)
+                if (reads[i].expands !== "unresolvable" && reads[i].denyOnly !== true)
+                    reads[i] = { ...reads[i], speculative: "containment" };
+    }
+    if (selectsContentsTraversal(row, args)) {
+        const roots = positional.length > 0 ? positional : stdinOperand || !walksCwdWithoutOperand(row) ? [] : [readOfText(".")];
+        for (const root of roots)
+            reads.push(relocated ? { ...bare(root, "traversal_root"), expands: "unresolvable" } : bare(root, "traversal_root"));
+    }
+}
+export function subscriptOnly(word) {
+    const at = word.indexOf("[");
+    return at < 0 ? "" : word.slice(at);
+}
+export function assignmentArithmetic(w, integer, ctx, asWritten = false) {
+    const a = w.assignment;
+    if (a === undefined) {
+        if (!asWritten)
+            ctx.reentered.push(...arithmeticSubstitutions(subscriptOnly(w.folded), ctx.table));
+        return;
+    }
+    if (a.subscript !== undefined && !asWritten)
+        ctx.reentered.push(...arithmeticSubstitutions(`[${a.subscript.folded}]`, ctx.table));
+    if (integer)
+        ctx.reentered.push(...arithmeticSubstitutions(a.value.folded, ctx.table));
+}