@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/commands/held.js

@@ -0,0 +1,499 @@
+/**
+ * The words layer 3 of the command reader reads: each word of a command string as the vendored
+ * shell parser reads it, and each token of a value of a command file that is no command, each
+ * with whether it may write the file a command runs. `text/named-files.ts` reads the files
+ * they name. Comments and keys are never words.
+ */
+import { forEachChild, parse, } from "../vendor/unbash/parser.js";
+import { expressionsAsParts, heldTextsOf, parseLine, PART, wordOf } from "./shell.js";
+import { fileOperands, outputOf } from "./tools.js";
+/** A `uses:` value that references a repository's action, never a local path (https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#jobsjob_idstepsuses). */
+const ACTION_REFERENCE = /^[\w-][\w.-]*\/[\w.-]+(?:\/[\w.-]+)*@[\w./-]+$/u;
+/** The word of a command whose runtime runs a file no word of it writes, as another program hands it the path. */
+const UNWRITTEN = { text: PART, runs: true };
+const NO_STDIN = { content: [], piped: [], unknown: false };
+const UNKNOWN_STDIN = { ...NO_STDIN, unknown: true };
+/** Whether `redirect` reads into descriptor 0, the default of `<`, `<>`, `<&`, `<<` and `<<<`. */
+function readsInput(redirect) {
+    const { descriptor } = redirect;
+    return ((redirect.type !== "Redirect" || ["<", "<>", "<&"].includes(redirect.operator)) &&
+        (descriptor === undefined || (descriptor.type === "FileDescriptor" && descriptor.value === 0)));
+}
+/**
+ * The standard input `redirects` give a command, the last that reads descriptor 0 deciding as
+ * the shell applies them in order, or `inherited` where none does. A `<&` duplicates a
+ * descriptor the line does not show.
+ */
+function stdinOf(redirects, inherited) {
+    const last = redirects.findLast(readsInput);
+    if (last === undefined) {
+        return inherited;
+    }
+    switch (last.type) {
+        case "HereDoc":
+            return { ...NO_STDIN, content: [last.body.text] };
+        case "HereString":
+            return { ...NO_STDIN, content: last.target === undefined ? [] : heldTextsOf(last.target) };
+        default:
+            return last.operator === "<&" || last.target === undefined
+                ? UNKNOWN_STDIN
+                : { ...NO_STDIN, file: wordOf(last.target) };
+    }
+}
+/** The words of a simple command, its program word first. */
+function wordsOf(node) {
+    return node.type === "Command" && node.name !== undefined
+        ? [node.name, ...node.suffix.filter((part) => part.type === "Word")]
+        : [];
+}
+/** What the pipeline member `member`, whose own standard input `inputs` holds, writes to the next, as {@link outputOf} reads it. */
+function pipedFrom(member, inputs) {
+    const words = wordsOf(member);
+    const output = words.length === 0 ? undefined : outputOf(words.map(wordOf));
+    if (output === undefined) {
+        return UNKNOWN_STDIN;
+    }
+    const own = output.input ? (inputs.get(member) ?? NO_STDIN) : NO_STDIN;
+    const textsAt = (at) => {
+        const word = words[at];
+        return word === undefined ? [] : heldTextsOf(word);
+    };
+    const lines = [
+        ...output.at.flatMap(textsAt),
+        ...output.joined.map(([from, to]) => words
+            .slice(from, to)
+            .flatMap((_, at) => textsAt(from + at))
+            .join(" ")),
+        ...output.texts,
+    ];
+    return { ...own, piped: [...own.piped, ...lines] };
+}
+/** How many times a quoted text, a here-document's body or a `-c` value is read as a command line in turn. */
+const DEPTH = 4;
+/** A `\\` a path may hold: none that ends a line, nor one before a backquote, which it escapes. */
+const BACKSLASH_PATH = /\\(?![\r\n`])/gu;
+/** Text a shell may read as more than one word: a blank or an operator. */
+const LINE_SYNTAX = /[\s;&|<>()]/u;
+/** A shell parameter's name, or a special parameter, after its `$`. */
+const PARAMETER = /[A-Za-z_]\w*|[0-9@*#?!$-]/uy;
+/** The place after the brackets that open at `at`, nested ones included, or the text's end. */
+function closing(text, at, open, close) {
+    let depth = 0;
+    for (let next = at; next < text.length; next += 1) {
+        depth += text.charAt(next) === open ? 1 : text.charAt(next) === close ? -1 : 0;
+        if (depth === 0) {
+            return next + 1;
+        }
+    }
+    return text.length;
+}
+/** The text inside each outermost command substitution `text`, a line that does not parse, writes. */
+function substitutions(text) {
+    const found = [];
+    for (let at = text.indexOf("$("); at >= 0; at = text.indexOf("$(", at + 1)) {
+        const end = closing(text, at + 1, "(", ")");
+        found.push(text.slice(at + 2, text.charAt(end - 1) === ")" ? end - 1 : end));
+        at = end - 1;
+    }
+    return found;
+}
+/**
+ * `text`, a line that does not parse, with each expansion it writes as a part: a parameter
+ * expansion, a command substitution or an arithmetic expansion to its matching bracket, and
+ * a backquoted command to its closing backquote, each to the text's end where none closes it.
+ */
+function expansionsAsParts(text) {
+    let read = "";
+    for (let at = 0; at < text.length; at += 1) {
+        const char = text.charAt(at);
+        const next = text.charAt(at + 1);
+        let end = at;
+        if (char === "`") {
+            const close = text.indexOf("`", at + 1);
+            end = close < 0 ? text.length : close + 1;
+        }
+        else if (char === "$" && (next === "{" || next === "(")) {
+            end = closing(text, at + 1, next, next === "{" ? "}" : ")");
+        }
+        else if (char === "$") {
+            PARAMETER.lastIndex = at + 1;
+            end = at + 1 + (PARAMETER.exec(text)?.[0].length ?? -1);
+        }
+        if (end > at) {
+            read += PART;
+            at = end - 1;
+        }
+        else {
+            read += char;
+        }
+    }
+    return read;
+}
+/** A character a shell reads as syntax, a glob or a quote. */
+const METACHARACTER = /[|&;<>()"'`*?[\]{}~\\]/gu;
+/** An operator, which ends a shell word wherever it stands outside quotes. */
+const OPERATOR = /[;&|<>()]+/u;
+/**
+ * The texts one token stands for as one shell word, an assignment's value for an assignment,
+ * or `undefined` where it is not one.
+ */
+function tokenTexts(token) {
+    const script = parse(token);
+    const [statement, ...more] = script.commands;
+    const command = statement?.command;
+    if ((script.errors ?? []).length > 0 || more.length > 0 || command?.type !== "Command") {
+        return undefined;
+    }
+    const [assignment, ...others] = command.prefix;
+    if (command.name === undefined) {
+        return others.length === 0 &&
+            command.suffix.length === 0 &&
+            assignment?.type === "Assignment" &&
+            assignment.value.type === "Word"
+            ? heldTextsOf(assignment.value)
+            : undefined;
+    }
+    return command.prefix.length === 0 && command.suffix.length === 0
+        ? heldTextsOf(command.name)
+        : undefined;
+}
+/**
+ * The texts one blank-separated token of a line that does not parse stands for: each
+ * expansion in it a part, then each piece of it between operators as the one word it is,
+ * else with its quotes removed, else with each other character a shell reads as syntax a part.
+ */
+function tokenPieces(token) {
+    return expansionsAsParts(token)
+        .split(OPERATOR)
+        .filter((piece) => piece !== "")
+        .flatMap((piece) => tokenTexts(piece) ??
+        tokenTexts(piece.replaceAll(/["']/gu, "")) ?? [piece.replaceAll(METACHARACTER, PART)]);
+}
+/** A token that ends a simple command, as a `;`, `&`, `|` or parenthesis it ends with does, and one that starts the next. */
+const ENDS_COMMAND = /[;&|()]$/u;
+const STARTS_COMMAND = /^[;&|()]/u;
+/** The reserved words that may stand before a simple command's program word in a line. */
+const RESERVED = new Set(["if", "then", "else", "elif", "fi", "do", "done", "while", "until"].concat([
+    "case",
+    "esac",
+    "{",
+    "}",
+    "!",
+    "time",
+]));
+/** A token that redirects: its descriptor, its operator, and its target where the token writes it. */
+const REDIRECT = /^(\d*)(&>>|&>|<<<|<<-|<<|<>|<&|>&|>>|>\||<|>)(.*)$/su;
+/**
+ * The standard input one redirect token of a line that does not parse gives: a file for `<`
+ * or `<>`, written as `target` writes it, and for a here-document, a here-string or a `<&`,
+ * text this reading does not take apart.
+ */
+function tokenStdin(operator, target) {
+    if (operator !== "<" && operator !== "<>") {
+        return UNKNOWN_STDIN;
+    }
+    const text = target.replace(/[;&|)]+$/u, "").replaceAll(/["']/gu, "");
+    return {
+        ...NO_STDIN,
+        file: { value: text.includes(PART) ? undefined : text, text, written: text },
+    };
+}
+/**
+ * {@link fileOperands} of `words`, the tokens `tokens` of a line read without its structure,
+ * one simple command from each operator token to the next, past the reserved words it starts
+ * with, its redirect tokens read as {@link tokenStdin} reads them, each first word `program`'s.
+ * A command after a `|` reads what no row reads, and any other `stdin`, the line's own; a
+ * reader of what no word writes there runs a file no word writes.
+ */
+function commandsOf(tokens, words, program, stdin) {
+    const places = new Set();
+    const lines = new Map();
+    const replaced = new Map();
+    const joined = [];
+    const texts = [];
+    let unwritten = false;
+    let input = false;
+    let stdinRead = false;
+    for (let from = 0; from < words.length;) {
+        let to = from;
+        while (to < words.length && !(to > from && STARTS_COMMAND.test(tokens[to] ?? ""))) {
+            to += 1;
+            if (ENDS_COMMAND.test(tokens[to - 1] ?? "")) {
+                break;
+            }
+        }
+        const piped = /(?<!\|)\|$/u.test(tokens[from - 1] ?? "") || /^\|(?!\|)/u.test(tokens[from] ?? "");
+        let fed = piped ? UNKNOWN_STDIN : stdin;
+        const kept = [];
+        let start = from;
+        while (start < to && RESERVED.has(tokens[start] ?? "")) {
+            start += 1;
+        }
+        for (let at = start; at < to; at += 1) {
+            const [, descriptor, operator = "", rest = ""] = REDIRECT.exec(tokens[at] ?? "") ?? [];
+            if (descriptor === undefined) {
+                kept.push(at);
+                continue;
+            }
+            const target = rest === "" && at + 1 < to ? (tokens[(at += 1)] ?? "") : rest;
+            if ((descriptor === "" || descriptor === "0") && operator.startsWith("<")) {
+                fed = tokenStdin(operator, target);
+            }
+        }
+        const one = fileOperands(kept.map((at) => words[at] ?? { value: undefined, text: "" }), program, fed.file);
+        const place = (at) => kept[at] ?? to;
+        for (const at of one.places) {
+            places.add(place(at));
+        }
+        for (const [at, prefix] of one.lines) {
+            lines.set(place(at), prefix);
+        }
+        for (const [at, pattern] of one.replaced) {
+            replaced.set(place(at), pattern);
+        }
+        joined.push(...one.joined.map(([start, end]) => [place(start), place(end)]));
+        texts.push(...one.texts);
+        unwritten ||=
+            one.unwritten ||
+                ((one.input || one.stdin) && (fed.unknown || fed.content.length > 0 || fed.piped.length > 0));
+        input ||= one.input;
+        stdinRead ||= one.stdin;
+        from = to;
+    }
+    return { places, unwritten, lines, input, stdin: stdinRead, replaced, joined, texts };
+}
+/**
+ * The words of one line read without its structure: the whole line, each blank-separated
+ * token as {@link tokenPieces} reads it, as written, so the words inside an expansion count,
+ * and with each expansion a part, so a blank inside one splits nothing, and the text of each
+ * command substitution as a command line. A token may write the file a command runs at the
+ * places {@link fileOperands} gives, `program` saying whether the first token is a program word.
+ */
+function tokenWords(line, program, depth, into, stdin = NO_STDIN) {
+    const read = expressionsAsParts(line);
+    into.push({ text: expansionsAsParts(read), runs: false });
+    // Past the depth a command line a program runs is read no more.
+    const asLine = (text, quoted) => {
+        if (depth > 0) {
+            lineWords(text, depth - 1, quoted, into);
+        }
+        else {
+            into.push(UNWRITTEN);
+        }
+    };
+    for (const inner of substitutions(read)) {
+        asLine(inner, true);
+    }
+    const blanks = (text) => text.split(/\s+/u).filter((token) => token !== "");
+    for (const token of blanks(read)) {
+        for (const text of tokenPieces(token)) {
+            into.push({ text, runs: false });
+        }
+    }
+    const tokens = blanks(expansionsAsParts(read));
+    const texts = tokens.map((token) => tokenTexts(token) ?? tokenPieces(token));
+    const operands = commandsOf(tokens, texts.map(([only, ...more], at) => ({
+        value: more.length === 0 && only !== undefined && !only.includes(PART) ? only : undefined,
+        text: tokens[at] ?? "",
+        ...(more.length === 0 && only !== undefined ? { written: only } : {}),
+    })), program, stdin);
+    const replacedAt = (at) => (texts[at] ?? []).map((text) => {
+        const replaced = operands.replaced.get(at);
+        return replaced === undefined ? text : text.replace(replaced, PART);
+    });
+    texts.forEach((_, at) => {
+        for (const read of replacedAt(at)) {
+            const prefix = operands.lines.get(at);
+            into.push({ text: read, runs: operands.places.has(at) });
+            if (prefix !== undefined) {
+                asLine(read.slice(read.startsWith(prefix) ? prefix.length : 0), false);
+            }
+        }
+    });
+    for (const [from, to] of operands.joined) {
+        asLine(texts
+            .slice(from, to)
+            .flatMap((_, at) => replacedAt(from + at))
+            .join(" "), false);
+    }
+    for (const text of operands.texts) {
+        asLine(text, false);
+    }
+    if (operands.unwritten) {
+        into.push(UNWRITTEN);
+    }
+}
+/**
+ * The standard input of each simple command below `node`: its own, as {@link stdinOf} reads
+ * it, that of the nearest compound command around it, or `inherited`, what the command that
+ * hands the line on reads; each later member of a pipeline reads what the one before writes.
+ */
+function inputsOf(node, inherited, into) {
+    const own = node.type === "Command" || node.type === "Redirected"
+        ? stdinOf(node.redirects, inherited)
+        : inherited;
+    if (node.type === "Command") {
+        into.set(node, own);
+    }
+    if (node.type === "Pipeline") {
+        let carried = own;
+        for (const member of node.commands) {
+            inputsOf(member, carried, into);
+            carried = pipedFrom(member, into);
+        }
+        return;
+    }
+    forEachChild(node, (child) => {
+        inputsOf(child, own, into);
+    });
+}
+/** The simple commands of `script` the command reader's first layer reads: each member of each pipeline of each and-or list. */
+function topCommands(script) {
+    return new Set(script.commands.flatMap(({ command }) => (command.type === "AndOr" ? command.commands : [command]).flatMap((one) => one.type === "Pipeline" ? one.commands : [one])));
+}
+/**
+ * Each word one parsed command line writes, anywhere in its structure, into `into`. A quoted
+ * text or a here-document's body may be a command line a program it is handed to runs, so it
+ * is read as one in turn. Where {@link fileOperands} says a command hands a word, or words
+ * joined by blanks, to a shell, the shell reads them whole with the command's standard input,
+ * and where it reads its standard input, that input as {@link Stdin} reads it: a here-document
+ * is a command line only for a shell, and code for a runtime. `stdin` is what the line's own
+ * standard input carries, and `tests` whether the line is a manifest's script.
+ */
+function scriptWords(script, depth, quoted, into, stdin, tests) {
+    const runs = new Set();
+    const lines = new Map();
+    const replaced = new Map();
+    const handed = new Map();
+    const inputs = new Map();
+    inputsOf(script, stdin, inputs);
+    const top = tests ? topCommands(script) : new Set();
+    const asLine = (text, how, fed = NO_STDIN) => {
+        if (depth > 0 && (how === "line" || (how === "text" && LINE_SYNTAX.test(text)))) {
+            lineWords(text, depth - 1, how === "text", into, fed);
+        }
+        else if (how === "line") {
+            // Past the depth a command line a program runs is read no more.
+            into.push(UNWRITTEN);
+        }
+    };
+    const visit = (node, how) => {
+        let inner = how;
+        switch (node.type) {
+            case "Command": {
+                const fed = inputs.get(node) ?? NO_STDIN;
+                const words = wordsOf(node);
+                const operands = words.length === 0
+                    ? undefined
+                    : fileOperands(words.map(wordOf), !quoted, fed.file, top.has(node));
+                words.forEach((word, at) => {
+                    const pattern = operands?.replaced.get(at);
+                    if (operands?.places.has(at) === true) {
+                        runs.add(word);
+                    }
+                    const prefix = operands?.lines.get(at);
+                    if (prefix !== undefined) {
+                        lines.set(word, prefix);
+                        handed.set(word, fed);
+                    }
+                    if (pattern !== undefined) {
+                        replaced.set(word, pattern);
+                    }
+                });
+                const reads = operands?.input === true || operands?.stdin === true;
+                if (operands?.unwritten === true || (reads && fed.unknown)) {
+                    into.push(UNWRITTEN);
+                }
+                for (const text of reads ? fed.piped : []) {
+                    asLine(text, "line");
+                }
+                for (const text of operands?.input === true ? fed.content : []) {
+                    asLine(text, "line");
+                }
+                for (const text of operands?.texts ?? []) {
+                    asLine(text, "line", fed);
+                }
+                for (const [from, to] of operands?.joined ?? []) {
+                    const texts = words.slice(from, to).flatMap((word, at) => {
+                        const pattern = operands?.replaced.get(from + at);
+                        return heldTextsOf(word).map((one) => pattern === undefined ? one : one.replace(pattern, PART));
+                    });
+                    asLine(texts.join(" "), "line", fed);
+                }
+                break;
+            }
+            case "Word": {
+                const pattern = replaced.get(node);
+                const prefix = lines.get(node);
+                for (const one of heldTextsOf(node)) {
+                    const text = pattern === undefined ? one : one.replace(pattern, PART);
+                    into.push({ text, runs: runs.has(node) });
+                    if (prefix !== undefined) {
+                        asLine(text.slice(text.startsWith(prefix) ? prefix.length : 0), "line", handed.get(node));
+                    }
+                }
+                inner = lines.has(node) ? "read" : how;
+                break;
+            }
+            case "SingleQuoted":
+            case "AnsiCQuoted":
+                asLine(node.value, how);
+                break;
+            case "DoubleQuoted":
+                asLine(node.text.slice(1, -1), how);
+                break;
+            case "HereDocBody":
+                asLine(node.text, how);
+                break;
+            default:
+                break;
+        }
+        forEachChild(node, (child) => {
+            visit(child, inner);
+        });
+    };
+    visit(script, "text");
+}
+/**
+ * Each word of one command line, read twice: as POSIX reads it, and with each
+ * {@link BACKSLASH_PATH} read as `/`, as PowerShell and cmd read a path. A line that does not
+ * parse is read line by line, and a line of it that does not parse either by {@link tokenWords};
+ * `stdin` and `tests` are what {@link scriptWords} takes.
+ */
+function lineWords(source, depth, quoted, into, stdin = NO_STDIN, tests = false) {
+    for (const reading of new Set([source, source.replaceAll(BACKSLASH_PATH, "/")])) {
+        const script = parseLine(reading);
+        if ((script.errors ?? []).length === 0) {
+            scriptWords(script, depth, quoted, into, stdin, tests && reading === source);
+            continue;
+        }
+        for (const line of reading.split(/\r?\n/u)) {
+            const one = parseLine(line);
+            if ((one.errors ?? []).length === 0) {
+                scriptWords(one, depth, quoted, into, stdin, false);
+            }
+            else {
+                tokenWords(line, !quoted, depth, into, stdin);
+            }
+        }
+    }
+}
+/**
+ * The words of `texts`: each command string's, and each line of each other value's, read by
+ * {@link tokenWords} as a quoted text is, with no program word, but for a `uses:` value that
+ * references another repository's action.
+ */
+export function heldWords(texts) {
+    const found = [];
+    for (const { text, shell, key, tested } of texts) {
+        if (shell) {
+            lineWords(text, DEPTH, false, found, NO_STDIN, tested === true);
+        }
+        else if (key !== "uses" || !ACTION_REFERENCE.test(text.trim())) {
+            for (const line of text.split(/\r?\n/u)) {
+                tokenWords(line, false, DEPTH, found);
+            }
+        }
+    }
+    return found;
+}

package/dist/src/commands/read.js

@@ -0,0 +1,161 @@
+/**
+ * The one reader of every command string the analysis reads. Layer 3, the holding rule
+ * `roots/root-set.ts` applies through `commands/held.ts` and `text/named-files.ts`, reads every
+ * word of the string whatever the other two layers make of it; layer 1 parses the string and
+ * layer 2 reads each simple command a tool's reader understands, and they only add the files
+ * and modules it runs.
+ */
+import { joinPath, resolvePath } from "../paths.js";
+import { shellLine } from "./shell.js";
+import { configurationsOf, preloadTarget, readBuiltin, handedOn, testRun, } from "./tools.js";
+import { APPENDED_EXTENSIONS } from "../extensions.js";
+/**
+ * The outcomes of one pipeline run in `dir`: those of the builtin that is its one member, as
+ * `readBuiltin` gives them, a directory the analysis does not know after a part layer 1 does
+ * not read, and either status in `dir` otherwise, a pipeline of several members included,
+ * whose members each run in a subshell.
+ */
+function outcomesOf(pipeline, dir) {
+    const [only] = pipeline.alone ? pipeline.commands : [];
+    const outcomes = pipeline.opaque
+        ? [
+            { dir: undefined, ok: true },
+            { dir: undefined, ok: false },
+        ]
+        : ((only === undefined ? undefined : readBuiltin(only, dir)) ?? [
+            { dir, ok: true },
+            { dir, ok: false },
+        ]);
+    return outcomes.map((one) => ({ dir: one.dir, ok: one.ok !== pipeline.negated }));
+}
+/** The one directory every outcome is in, or `undefined` where they differ or none is known. */
+function oneDirectory(outcomes) {
+    const dirs = new Set(outcomes.map((one) => one.dir));
+    return dirs.size === 1 ? [...dirs][0] : undefined;
+}
+/**
+ * What `text`, run in `dir`, `undefined` where not known, runs. A pipeline is read where every
+ * way its and-or list reaches it leaves the shell in one known directory, none after an `exit`;
+ * a background list moves and ends no later one. The words and configuration files of every
+ * simple command of the string's own line are read in `dir` as well, wherever they run.
+ */
+export function readCommands(text, dir) {
+    const runs = [];
+    const commands = [];
+    const configurations = [];
+    const tests = [];
+    const readTests = (words, at) => {
+        const run = testRun(words);
+        if (run !== undefined) {
+            tests.push({ dir: at, ...run });
+        }
+    };
+    const readCommand = (words, at) => {
+        commands.push({ dir: at, words: words.map((word) => word.value) });
+        const [handed, reading] = handedOn(words);
+        readTests(handed, at);
+        if (reading?.kind === "line") {
+            readLine(reading.text, at);
+            return;
+        }
+        configurations.push(...configurationsOf(handed).map((written) => ({ dir: at, written })));
+        if (reading !== undefined && (reading.entry !== undefined || reading.preloads.length > 0)) {
+            runs.push({
+                dir: at,
+                entry: reading.entry,
+                preloads: reading.preloads,
+                runtime: reading.runtime,
+            });
+        }
+    };
+    const readLine = (source, start) => {
+        let at = start;
+        for (const list of shellLine(source)) {
+            let outcomes = [{ dir: at, ok: true }];
+            for (const pipeline of list.pipelines) {
+                const { operator } = pipeline;
+                const reached = outcomes.filter((one) => operator === undefined || one.ok === (operator === "&&"));
+                const where = reached.length === 0 ? undefined : oneDirectory(reached);
+                if (where !== undefined) {
+                    pipeline.commands.forEach((words) => {
+                        readCommand(words, where);
+                    });
+                }
+                const next = reached.flatMap((one) => outcomesOf(pipeline, one.dir));
+                const passed = outcomes.filter((one) => !reached.includes(one));
+                outcomes = [
+                    ...new Map([...passed, ...next].map((one) => [`${String(one.ok)}\u0000${one.dir ?? ""}`, one])).values(),
+                ];
+            }
+            if (!list.background) {
+                at = oneDirectory(outcomes);
+            }
+        }
+    };
+    readLine(text, dir);
+    if (dir !== undefined) {
+        for (const words of shellLine(text).flatMap((list) => list.pipelines.flatMap((pipeline) => pipeline.commands))) {
+            commands.push({ dir, words: words.map((word) => word.value) });
+            configurations.push(...configurationsOf(words).map((written) => ({ dir, written })));
+            readTests(handedOn(words)[0], dir);
+        }
+    }
+    const unique = (all) => [
+        ...new Map(all.map((one) => [JSON.stringify(one), one])).values(),
+    ];
+    return {
+        runs,
+        commands: unique(commands),
+        configurations: unique(configurations),
+        tests: unique(tests),
+        held: text,
+    };
+}
+/**
+ * The files `run` loads: its entry, and each preload written as a path. Each may be at its
+ * path, with each extension tried, and as a directory's `index` file.
+ */
+export function loadsOf(run) {
+    const written = [
+        ...(run.entry === undefined
+            ? []
+            : [{ written: run.entry, path: resolvePath(run.dir, run.entry) }]),
+        ...run.preloads.flatMap((preload) => {
+            const target = preloadTarget(preload, run.dir);
+            return target !== undefined && "path" in target
+                ? [{ written: preload.specifier, path: target.path }]
+                : [];
+        }),
+    ];
+    return written.map(({ written: one, path }) => ({
+        written: one,
+        paths: [
+            path,
+            ...APPENDED_EXTENSIONS.map((extension) => `${path}${extension}`),
+            ...APPENDED_EXTENSIONS.map((extension) => joinPath(path, `index${extension}`)),
+        ],
+    }));
+}
+/** The module specifiers `run` preloads that name a package rather than a path. */
+export function preloadedPackages(run) {
+    return run.preloads.flatMap((preload) => {
+        const target = preloadTarget(preload, run.dir);
+        return target !== undefined && "package" in target ? [target.package] : [];
+    });
+}
+/**
+ * Every path `reading` names: each static word of its commands read against the directory the
+ * command runs in, a word holding `*` aside, which a tool reads as a pattern, and every path a
+ * file a read command runs or preloads may be at.
+ */
+export function pathsNamed(reading) {
+    const named = [
+        ...reading.commands.flatMap(({ dir, words }) => words.flatMap((word) => word === undefined || word.includes("*")
+            ? []
+            : [{ path: resolvePath(dir, word), written: word }])),
+        ...reading.runs
+            .flatMap(loadsOf)
+            .flatMap(({ written, paths }) => paths.map((path) => ({ path, written }))),
+    ];
+    return [...new Map(named.map((one) => [`${one.path}\u0000${one.written}`, one])).values()];
+}