@cplieger/deadset-ts 8.0.0-dev.17 → 8.0.0-dev.19

package/dist/src/conformance-record.js

@@ -4,7 +4,7 @@ export const RECORD = {
     conformance: {
         corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:a4ffbc1c2d9dc7903ccbf52af0e1a22094e0b50363f59365f6aa37b9437d3427",
+        digest: "sha256:e4af2b9bcd07fd745101bf3215cd21e9df1448bdc332a791f25d5676cf15c794",
     },
     gaps: [],
 };

package/dist/src/contract/contract.generated.js

@@ -372,7 +372,7 @@ export const KIND_ROWS = [
         subject: "declaration",
         holdsLive: true,
         rule: "An exported symbol whose every reference is inside the symbol's own package or module, reported as a candidate for unexporting. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
-        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the package references that function or method, because the caller holds values of the type, and unexporting it would leave an exported signature naming a type its callers cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
+        precondition: "Closed world only. A Go main package, and an internal/ directory tree for importers outside its parent, are closed worlds whatever the configuration declares, because no other program can import them, so this finding is reported there always. A published package is a closed world only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the package reaches its values through its own package's exported declarations: a reference to an exported function or method whose parameters or results name the type, to an exported variable or constant whose type names it, to an exported field or property whose type names it, an embedded field included, or to an exported member of the type itself, a field promoted through an embedding included. A type a reference from outside the package names, or whose values such a reference reaches, passes the reach on to each type its definition names other than through an unexported member, whether it is exported or not, so an unexported type an exported function returns passes it to the types its exported fields name. A type names another through every composite that spells it: a pointer, an array, a slice, a map key or value, a channel, a function signature and a type argument. The referencing code holds values of the type, so unexporting it would leave an exported declaration naming a type its users cannot name. A package-level declaration whose name a string literal spells carries the class grammar/analysis/confidence.md gives it.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
         defaultSeverity: "warn",
@@ -387,7 +387,7 @@ export const KIND_ROWS = [
         subject: "declaration",
         holdsLive: true,
         rule: "An exported symbol of a non-internal package whose every reference is inside the target module, reported as a candidate for relocation behind an internal boundary. The subject is a package-level declaration or a method. Three subjects are excluded. An interface method is excluded because its exportedness is the contract of the interface that declares it. A struct field is excluded because an encoder reads it by name. A method that satisfies an interface some symbol uses as a type is excluded because it cannot be unexported without its type ceasing to satisfy that interface, and so is a method whose name and signature are those of a method of an exported interface type declared by a package outside the target that the import closure holds, because that interface fixes them whether or not the program converts the method's type to it. The finding names the narrower visibility the references support. A declared cross-language edge counts as an out-of-package reference. Where the edge's other side is unknown to the analyzer, the finding is emitted pending. A reference from a Go external test package, a test file whose package clause names its directory's package with the suffix _test, is a reference from outside the package, because that test builds as another package and needs the export.",
-        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type that a parameter or a result of an exported function or method of its own package names is not reported when a reference from outside the target module references that function or method, because the caller holds values of the type, and moving it behind an internal boundary would leave an exported signature naming a type its callers cannot name.",
+        precondition: "Closed world only. Reported always for a main package and an internal/ directory tree, and for a published package only when the configuration declares the consumer set complete and every declared consumer loads. A library with no consumer loaded and no complete consumer set declared gets this finding on its internal/ tree and its main packages and never on its published API. A symbol the rule of DS1301 holds for is not reported under this code, whatever severity the configuration gives DS1301, because the write-only finding names the defect to fix first. A type is not reported when a reference from outside the target module reaches its values through its own package's exported declarations, as DS1501 defines that reach, because the referencing code holds values of the type, and moving it behind an internal boundary would leave an exported declaration naming a type its users cannot name.",
         details: { narrower_visibility: "required", name_literal: "optional" },
         defaultEnabled: true,
         defaultSeverity: "warn",
@@ -1206,6 +1206,13 @@ export const EVIDENCE = [
             "DS1602",
         ],
     },
+    {
+        evidence: "unwritten-run-path",
+        rule: "confidence.35",
+        class: "possible",
+        languages: ["ts"],
+        codes: ["DS1601", "DS1602"],
+    },
     {
         evidence: "schema-operation-default",
         rule: "schemas.10",

package/dist/src/entries/conventions.js

@@ -9,7 +9,7 @@ import { lineOf } from "../component-files.js";
 import { CONVENTION_ROWS, } from "./convention-rows.js";
 import { documentStrings } from "./configuration-files.js";
 import { readCommands } from "../commands/read.js";
-import { nodeTestGlobs, } from "./test-runners.js";
+import { nodeTestGlobs } from "./test-runners.js";
 import { documentModule, membersNamed, staticModule, textsOf, valuesAt, } from "./static-module.js";
 import { ancestors, cannotStartPackageName, dirnamePath, joinPath, normalizePath, relativePath, resolvePath, } from "../paths.js";
 import { satisfies } from "../version-range.js";
@@ -520,11 +520,11 @@ function packageKeyUses(read, dir, manifest, keys) {
         text.startsWith(`${name}/`) ||
         (text.startsWith(`${name}:`) && text.length > name.length + 1)));
 }
-/** Every simple command of a manifest's `scripts`, as the command reader reads it in the manifest's directory. */
-function scriptCommands(manifest, dir) {
+/** What the command reader reads each of a manifest's `scripts` as, in the manifest's directory. */
+function scriptReadings(manifest, dir) {
     const scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
     return isRecord(scripts)
-        ? Object.values(scripts).flatMap((text) => typeof text === "string" ? readCommands(text, dir).commands : [])
+        ? Object.values(scripts).flatMap((text) => typeof text === "string" ? [readCommands(text, dir)] : [])
         : [];
 }
 /**
@@ -543,6 +543,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     const read = readFilesOnce(host, parse);
     for (const manifest of manifests) {
         const declared = readJSON(host, joinPath(manifest.dir, MANIFEST));
+        const scripts = scriptReadings(declared, manifest.dir);
         let input;
         const runnerInput = () => {
             input ??= {
@@ -558,7 +559,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
                     }
                     return undefined;
                 },
-                scripts: scriptCommands(declared, manifest.dir),
+                scripts: scripts.flatMap((one) => one.commands),
             };
             return input;
         };
@@ -659,7 +660,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
                 });
             }
         }
-        testGlobs.push(...nodeTestGlobs(runnerInput().scripts));
+        testGlobs.push(...nodeTestGlobs(scripts.flatMap((one) => one.tests)));
     }
     const unique = [...new Map(applied.map((one) => [JSON.stringify(one), one])).values()];
     unique.sort((a, b) => bytewise(a.name, b.name) ||

package/dist/src/entries/test-runners.js

@@ -107,7 +107,7 @@ function parsed(words, table) {
         else if (table.flags.has(name)) {
             keep(name, equals < 0 ? "true" : word.slice(equals + 1));
         }
-        else if (!(table.assigned === true && equals > 0)) {
+        else {
             return undefined;
         }
     }
@@ -632,31 +632,6 @@ const AVA_CONFIG = ["ava.config.js", "ava.config.cjs", "ava.config.mjs"];
 export const AVA_6 = avaRunner(AVA_CONFIG, ["cjs", "mjs", "js"]);
 /** AVA 8, which reads no `ava.config.cjs` and defaults to no `.cjs` test. */
 export const AVA_8 = avaRunner(["ava.config.js", "ava.config.mjs"], ["mjs", "js"]);
-/**
- * The options of `node` (https://nodejs.org/api/cli.html) a test run writes: the ones that take
- * a value, the flags, and any long option whose value follows `=`.
- */
-const NODE_OPTIONS = {
-    valued: new Set([
-        ...["-r", "--require", "--import", "--loader", "--experimental-loader", "--env-file"],
-        ...["--env-file-if-exists", "--conditions", "-C", "--input-type", "--watch-path"],
-        ...["--test-reporter", "--test-reporter-destination", "--test-concurrency"],
-        ...["--test-name-pattern", "--test-skip-pattern", "--test-timeout", "--test-shard"],
-        ...["--test-coverage-include", "--test-coverage-exclude", "--test-coverage-branches"],
-        ...["--test-coverage-functions", "--test-coverage-lines", "--test-isolation"],
-        ...["--test-global-setup"],
-    ]),
-    flags: new Set([
-        ...["--test", "--test-only", "--watch", "--test-force-exit", "--test-update-snapshots"],
-        ...["--test-randomize", "--experimental-test-coverage", "--experimental-test-module-mocks"],
-        ...["--experimental-test-snapshots", "--experimental-strip-types", "--no-strip-types"],
-        ...["--no-experimental-strip-types", "--experimental-transform-types", "--enable-source-maps"],
-        ...["--experimental-vm-modules", "--experimental-detect-module", "--no-warnings"],
-        ...["--no-experimental-detect-module", "--experimental-require-module", "--trace-warnings"],
-        ...["--no-experimental-require-module", "--expose-gc", "--inspect", "--inspect-brk"],
-    ]),
-    assigned: true,
-};
 /** The patterns `node --test` runs with no operand (`doc/api/test.md`), the TypeScript ones where types are stripped. */
 function nodeTestDefaults(stripped) {
     const forms = ["**/*.test", "**/*-test", "**/*_test", "**/test-*", "**/test", "**/test/**/*"];
@@ -666,19 +641,10 @@ function nodeTestDefaults(stripped) {
     ];
 }
 /**
- * The files each `node --test` command of a manifest's scripts runs: its operands, each a glob
- * read in the command's directory, or the default patterns where it writes none. A command
- * holding a dynamic word or an option {@link NODE_OPTIONS} does not name runs no file here.
+ * The files each `node --test` run of a manifest's scripts runs, as the command reader reads
+ * it: its operands, each a glob read in the command's directory, or the default patterns where
+ * it writes none.
  */
-export function nodeTestGlobs(scripts) {
-    return scripts.flatMap((command) => {
-        const words = afterProgram(command, ["node"]);
-        const read = words === undefined ? undefined : parsed(words, NODE_OPTIONS);
-        if (!read?.values.has("--test")) {
-            return [];
-        }
-        const stripped = !read.values.has("--no-strip-types") && !read.values.has("--no-experimental-strip-types");
-        const patterns = read.operands.length > 0 ? read.operands : nodeTestDefaults(stripped);
-        return patterns.map((one) => belowGlob(command.dir, one));
-    });
+export function nodeTestGlobs(runs) {
+    return runs.flatMap((run) => (run.patterns.length > 0 ? run.patterns : nodeTestDefaults(run.stripped)).map((one) => belowGlob(run.dir, one)));
 }

package/dist/src/entries/workflow-steps.js

@@ -1,10 +1,11 @@
 /**
  * The command strings beside a target root's packages: a CI workflow's `run:` steps, the git
- * hooks, the hook managers' commands and the makefile's recipe lines, each with the directory
- * it runs in. A workflow or hook manager file is read by `text/yaml.ts`, and one it does not
+ * hooks, the hook managers' commands and scripts and the makefile's recipe lines, each with the
+ * directory it runs in. A workflow or hook manager file is read by `text/yaml.ts`, and one it does not
  * read gives no command; each command is read by `commands/read.ts`.
  */
 import { pathsNamed, readCommands } from "../commands/read.js";
+import { PART } from "../commands/shell.js";
 import { isRecord } from "../json-document.js";
 import { joinPath, resolvePath } from "../paths.js";
 import { filesIn } from "../fs/tree.js";
@@ -14,14 +15,20 @@ const WORKFLOWS = ".github/workflows";
 const HOOK_DIRS = [".husky", ".githooks"];
 /** The key setting the directory a workflow step, or each step a `defaults.run` covers, runs in. */
 const WORKING_DIRECTORY = "working-directory";
-/**
- * The hook manager files, each with the key its commands are written under and the key of their
- * directory: lefthook's `root`, https://lefthook.dev/configuration/root/
- */
 const HOOK_MANAGERS = [
-    [".pre-commit-config.yaml", "entry", undefined],
-    ...["lefthook.yml", "lefthook.yaml", ".lefthook.yml"].map((name) => [name, "run", "root"]),
+    { name: ".pre-commit-config.yaml", key: "entry" },
+    ...["lefthook.yml", "lefthook.yaml", ".lefthook.yml"].map((name) => ({
+        name,
+        key: "run",
+        dirKey: "root",
+        scripts: true,
+    })),
 ];
+/**
+ * The directories lefthook searches for a hook's scripts after the file's `source_dir` and
+ * `source_dir_local`: https://github.com/evilmartians/lefthook/blob/master/internal/command/run.go
+ */
+const LEFTHOOK_DIRS = [".config/lefthook", ".config/lefthook-local"];
 /** The names GNU make reads a makefile under, in the order it tries them. */
 const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"];
 function readText(host, path) {
@@ -73,7 +80,6 @@ function keyedCommands(text, root, key, dirKey) {
                     : written.includes("${{")
                         ? undefined
                         : resolvePath(root, written),
-                writtenDirectory: written,
             });
         }
         for (const value of Object.values(node)) {
@@ -83,6 +89,51 @@ function keyedCommands(text, root, key, dirKey) {
     visit(yamlDocument(text), undefined);
     return found;
 }
+/**
+ * The command lefthook runs for each script a lefthook file's hooks name, each key of a hook's
+ * `scripts` and each `script` of a job in its `jobs`, a group's among them, from each directory
+ * it searches: its `runner`, then the path `<dir>/<hook>/<name>` quoted as lefthook quotes it,
+ * run in the target root: https://lefthook.dev/configuration/Scripts/
+ */
+function lefthookScripts(text, root) {
+    const document = yamlDocument(text);
+    if (!isRecord(document)) {
+        return [];
+    }
+    const dirs = [
+        scalarText(document["source_dir"]) ?? ".lefthook/",
+        scalarText(document["source_dir_local"]) ?? ".lefthook-local/",
+        ...LEFTHOOK_DIRS,
+    ];
+    const found = [];
+    const add = (hook, name, runner) => {
+        for (const dir of dirs) {
+            const path = `'${joinPath(dir, hook, name).replaceAll("'", "'\\''")}'`;
+            found.push({
+                text: runner === undefined || runner.trim() === "" ? path : `${runner} ${path}`,
+                dir: root,
+            });
+        }
+    };
+    const jobs = (hook, list) => {
+        for (const job of Array.isArray(list) ? list : []) {
+            const script = isRecord(job) ? scalarText(job["script"]) : undefined;
+            if (isRecord(job) && script !== undefined) {
+                add(hook, script, scalarText(job["runner"]));
+            }
+            const group = isRecord(job) ? job["group"] : undefined;
+            jobs(hook, isRecord(group) ? group["jobs"] : undefined);
+        }
+    };
+    for (const [hook, value] of Object.entries(document)) {
+        const scripts = isRecord(value) ? value["scripts"] : undefined;
+        for (const [name, options] of Object.entries(isRecord(scripts) ? scripts : {})) {
+            add(hook, name, isRecord(options) ? scalarText(options["runner"]) : undefined);
+        }
+        jobs(hook, isRecord(value) ? value["jobs"] : undefined);
+    }
+    return found;
+}
 /** The path of each git hook script at `root`, every file in {@link HOOK_DIRS}. */
 function hookScripts(host, root) {
     return HOOK_DIRS.flatMap((dir) => filesIn(host, joinPath(root, dir), () => true).map((name) => joinPath(root, dir, name)));
@@ -91,10 +142,44 @@ function hookScripts(host, root) {
 function makefileAt(host, root) {
     return MAKEFILES.map((name) => joinPath(root, name)).find((candidate) => host.kindOf(candidate) === "file");
 }
+/**
+ * One recipe line as make hands it to the shell: each `$$` a `$`, and each reference to a
+ * variable or a function, which make expands first, a part only the run knows:
+ * https://www.gnu.org/software/make/manual/html_node/Reference.html
+ */
+function expandedByMake(line) {
+    let expanded = "";
+    for (let at = 0; at < line.length; at += 1) {
+        const char = line.charAt(at);
+        const next = line.charAt(at + 1);
+        if (char !== "$") {
+            expanded += char;
+        }
+        else if (next === "$") {
+            expanded += "$";
+            at += 1;
+        }
+        else {
+            let end = at + 1;
+            if (next === "(" || next === "{") {
+                const close = next === "(" ? ")" : "}";
+                for (let depth = 0; end < line.length; end += 1) {
+                    depth += line.charAt(end) === next ? 1 : line.charAt(end) === close ? -1 : 0;
+                    if (depth === 0) {
+                        break;
+                    }
+                }
+            }
+            expanded += PART;
+            at = Math.min(end, line.length);
+        }
+    }
+    return expanded;
+}
 /**
  * Each recipe line of the target root's makefile: a line that starts with a tab, joined with
- * the lines a trailing `\` continues it onto, less the `@`, `-` and `+` make reads before it.
- * Make runs each line in a shell of its own.
+ * the lines a trailing `\` continues it onto, less the `@`, `-` and `+` make reads before it,
+ * as make expands it. Make runs each line in a shell of its own.
  */
 function recipeLines(host, root) {
     const path = makefileAt(host, root);
@@ -104,16 +189,15 @@ function recipeLines(host, root) {
         .split(/\r?\n/u)
         .filter((line) => line.startsWith("\t"))
         .map((line) => ({
-        text: line.slice(1).replace(/^[@+-]+/u, ""),
+        text: expandedByMake(line.slice(1).replace(/^[@+-]+/u, "")),
         dir: root,
-        writtenDirectory: undefined,
     }));
 }
 /**
  * Every command the target root's workflow steps, git hooks, hook managers and makefile run:
  * the `run:` steps of the workflow files in `.github/workflows`, each file in `.husky` and
  * `.githooks` as one shell script, the `entry:` commands of `.pre-commit-config.yaml`, the
- * `run:` commands of a lefthook file and the makefile's recipe lines.
+ * `run:` commands and the scripts of a lefthook file and the makefile's recipe lines.
  */
 export function workflowCommands(host, targetRoot) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
@@ -123,35 +207,125 @@ export function workflowCommands(host, targetRoot) {
         ...hookScripts(host, root).map((path) => ({
             text: readText(host, path) ?? "",
             dir: root,
-            writtenDirectory: undefined,
         })),
-        ...HOOK_MANAGERS.flatMap(([name, key, dirKey]) => keyedCommands(readText(host, joinPath(root, name)) ?? "", root, key, dirKey)),
+        ...HOOK_MANAGERS.flatMap(({ name, key, dirKey, scripts }) => {
+            const text = readText(host, joinPath(root, name)) ?? "";
+            return [
+                ...keyedCommands(text, root, key, dirKey),
+                ...(scripts === true ? lefthookScripts(text, root) : []),
+            ];
+        }),
         ...recipeLines(host, root),
     ];
 }
 /**
  * The whole text of each file {@link workflowCommands} reads a command from, each workflow file,
- * git hook, hook manager file and makefile at the target root. Layer 3 holds it whole, so a part
- * no command is read from, a comment included, or one the reading of the structure misses, still
- * holds every file it names.
+ * git hook, hook manager file and makefile at the target root, which the dependency rule reads.
  */
 export function commandFileTexts(host, targetRoot) {
+    return commandFiles(host, targetRoot).flatMap(({ path }) => readText(host, path) ?? []);
+}
+/** Each file {@link workflowCommands} reads a command from, with the key a YAML file writes its commands under. */
+function commandFiles(host, targetRoot) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     return [
-        ...filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name)).map((name) => joinPath(root, WORKFLOWS, name)),
-        ...hookScripts(host, root),
-        ...HOOK_MANAGERS.map(([name]) => joinPath(root, name)),
-        ...[makefileAt(host, root) ?? []].flat(),
-    ].flatMap((path) => readText(host, path) ?? []);
+        ...filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name)).map((name) => ({
+            path: joinPath(root, WORKFLOWS, name),
+            key: "run",
+        })),
+        ...hookScripts(host, root).map((path) => ({ path, key: undefined })),
+        ...HOOK_MANAGERS.map(({ name, key }) => ({ path: joinPath(root, name), key })),
+        ...[makefileAt(host, root) ?? []].flat().map((path) => ({ path, key: undefined })),
+    ];
+}
+/**
+ * The filters of a workflow's `on` key, which name the files and refs whose change triggers it
+ * and run none: https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#onpushpull_requestpull_request_targetpathspaths-ignore
+ */
+const TRIGGER_FILTERS = new Set([
+    "paths",
+    "paths-ignore",
+    "branches",
+    "branches-ignore",
+    "tags",
+    "tags-ignore",
+]);
+/**
+ * The values of one YAML file that are no command, each with its key: every scalar but one
+ * written under `key`, which is read as a command string, and one of a trigger filter. A file
+ * `yamlDocument` does not read is one value, its whole text. No key and no comment is a value.
+ */
+function yamlValues(text, key) {
+    const document = yamlDocument(text);
+    if (document === undefined) {
+        return [{ text, shell: false }];
+    }
+    const found = [];
+    // `trigger` is 1 for the value of the top-level `on`, a map of events, and 2 for an event's.
+    const visit = (node, under, trigger = 0) => {
+        if (Array.isArray(node)) {
+            for (const item of node) {
+                visit(item, under);
+            }
+        }
+        else if (isRecord(node)) {
+            for (const [name, value] of Object.entries(node)) {
+                const on = node === document && (name === "on" || name === "true");
+                if ((name !== key || scalarText(value) === undefined) &&
+                    !(trigger === 2 && TRIGGER_FILTERS.has(name))) {
+                    visit(value, name, on ? 1 : trigger === 1 ? 2 : 0);
+                }
+            }
+        }
+        else {
+            const value = scalarText(node);
+            if (value !== undefined) {
+                found.push({ text: value, shell: false, ...(under === undefined ? {} : { key: under }) });
+            }
+        }
+    };
+    visit(document, undefined);
+    return found;
+}
+/**
+ * The lines of a makefile that are no recipe line, joined with the lines a trailing `\`
+ * continues them onto, each without the comment a `#` make does not read as escaped starts.
+ */
+function makefileValues(text) {
+    return text
+        .replace(/\\\r?\n/gu, " ")
+        .split(/\r?\n/u)
+        .filter((line) => !line.startsWith("\t"))
+        .map((line) => line.replace(/(?<!\\)#.*$/u, ""))
+        .filter((line) => line.trim() !== "")
+        .map((line) => ({ text: line, shell: false }));
+}
+/**
+ * The texts layer 3 reads of the target root's command files: each command string, and each
+ * value of a workflow file, a hook manager file and the makefile that is no command.
+ */
+function heldTexts(host, targetRoot) {
+    const makefile = makefileAt(host, resolvePath(host.workingDirectory(), targetRoot));
+    return [
+        ...workflowCommands(host, targetRoot).map(({ text }) => ({ text, shell: true })),
+        ...commandFiles(host, targetRoot).flatMap(({ path, key }) => {
+            const text = readText(host, path);
+            return text === undefined
+                ? []
+                : key !== undefined
+                    ? yamlValues(text, key)
+                    : path === makefile
+                        ? makefileValues(text)
+                        : [];
+        }),
+    ];
 }
 /** Reads the target root's workflow steps, git hooks, hook managers and makefile. */
 export function readWorkflows(host, targetRoot) {
     return {
-        readings: workflowCommands(host, targetRoot).map(({ text, dir, writtenDirectory }) => {
-            const reading = readCommands(text, dir);
-            return { ...reading, held: [reading.held, writtenDirectory ?? ""].join("\n") };
-        }),
+        readings: workflowCommands(host, targetRoot).map(({ text, dir }) => readCommands(text, dir)),
         texts: commandFileTexts(host, targetRoot),
+        held: heldTexts(host, targetRoot),
     };
 }
 /**

package/dist/src/exempt.js

@@ -10,7 +10,6 @@ import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
 import { TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
 import { Unanswerable } from "./query.js";
-import { sweep } from "./sweep.js";
 import { bytewise } from "./text/compare.js";
 /**
  * The classes `exemptions.disabled` switches off. A class that runs on another language
@@ -130,13 +129,6 @@ export function exemptionsOf(found) {
         return true;
     });
 }
-/**
- * The records that hold while the component files at `live` are live: every record that
- * holds whatever is live, and each one a live file's markup holds, as a record of the run.
- */
-export function holdingWhile(records, live) {
-    return exemptionsOf(records.flatMap(({ whileLive, ...record }) => whileLive === undefined || live.has(whileLive) ? [record] : []));
-}
 /** The records per declaration, each declaration's in the order given. */
 function byDeclaration(records) {
     const grouped = new Map();
@@ -151,24 +143,6 @@ function byDeclaration(records) {
     }
     return grouped;
 }
-/**
- * The records that held back a declaration: one some configuration's graph, swept
- * again with no exemption and its marks, judges a candidate, whatever another
- * configuration answers, or one in `writeOnly`, which the run would report as written
- * and never read without the record's read. A declaration a relation or a mark holds
- * live in every configuration is held back by no record. The order is the
- * declarations' site order, and for one declaration the input's.
- */
-export function retainedIn(matrix, input, writeOnly = new Set()) {
-    const exempt = input.exempt ?? [];
-    if (exempt.length === 0) {
-        return [];
-    }
-    const bare = { marked: input.marked, mode: input.mode };
-    const dead = new Set(matrix.graphs.flatMap((graph) => sweep(graph, bare).candidates.map((candidate) => candidate.id)));
-    const held = byDeclaration(exempt.filter((record) => dead.has(record.id) || writeOnly.has(record.id)));
-    return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
-}
 /**
  * One line per held-back declaration, in site order: its reference and position, then
  * each record's class, site and detail, all separated by tabs.