@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/dist/src/{workspace.js → load/workspace.js}

@@ -1,47 +1,34 @@
 /**
  * The workspace a target sits in: the packages `pnpm-workspace.yaml` or a manifest's
- * `workspaces` declares in the nearest directory at or above the target root, up to
- * its repository root, where its patterns name the package the target is in, each
- * with the compiler configurations in its directory. A
- * member is the workspace root or a directory the patterns name that holds a named
- * manifest, never one below `node_modules`.
+ * `workspaces` declares in the nearest directory at or above the target root, up to its
+ * repository root, where its patterns name the package the target is in, each with the
+ * compiler configurations in its directory.
  */
-import { DiscoveryError } from "./discover.js";
+import { configFilesIn } from "./discover.js";
+import { failureExit } from "../failure.js";
 import { commonDirectory } from "./emit-map.js";
-import { dirnamePath, joinPath, relativePath } from "./paths.js";
-import { pnpmPackages } from "./pnpm-workspace.js";
-const MANIFEST = "package.json";
+import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { isRecord } from "../json-document.js";
+import { directoriesIn, repositoryOf } from "../fs/tree.js";
+import { holdsManifest, inInstalledPackages, INSTALLED_PACKAGES, MANIFEST, manifestAt, } from "../fs/manifest.js";
+import { braceExpanded, pathMatches, segmentMatches } from "../text/glob.js";
+import { yamlKey } from "../text/yaml.js";
 const PNPM_WORKSPACE = "pnpm-workspace.yaml";
-const CONFIG_FILE = /^tsconfig.*\.json$/u;
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** One manifest, decoded, or `undefined` where there is none to read. */
-function manifestAt(host, dir) {
-    let text;
-    try {
-        text = host.readFile(joinPath(dir, MANIFEST));
-    }
-    catch {
-        return undefined;
-    }
-    try {
-        const value = JSON.parse(text);
-        return isRecord(value) ? value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** The patterns one directory declares a workspace with, or `undefined` where it declares none. */
 function declarationAt(host, dir) {
     const pnpm = joinPath(dir, PNPM_WORKSPACE);
     if (host.kindOf(pnpm) === "file") {
-        const read = pnpmPackages(host.readFile(pnpm));
-        if (read.kind === "refused") {
-            throw new DiscoveryError(`${pnpm}: ${read.reason}; the workspace's packages are read from a sequence of strings`, []);
+        const read = yamlKey(host.readFile(pnpm), "packages");
+        if (read.kind === "absent") {
+            return { file: pnpm, patterns: [] };
         }
-        return { file: pnpm, patterns: read.kind === "listed" ? read.patterns : [] };
+        const listed = read.kind === "value" ? read.value : undefined;
+        if (!Array.isArray(listed) || !listed.every((entry) => typeof entry === "string")) {
+            const reason = read.kind === "refused" ? read.reason : "packages is not a sequence of strings";
+            throw failureExit("no-program", `${pnpm}: ${reason}; the workspace's packages are read from a sequence of strings: correct the declaration`);
+        }
+        return { file: pnpm, patterns: listed };
     }
     const manifest = manifestAt(host, dir);
     if (manifest === undefined || !Object.hasOwn(manifest, "workspaces")) {
@@ -50,7 +37,7 @@ function declarationAt(host, dir) {
     const declared = manifest["workspaces"];
     const list = isRecord(declared) ? declared["packages"] : declared;
     if (!Array.isArray(list) || !list.every((entry) => typeof entry === "string")) {
-        throw new DiscoveryError(`${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one`, []);
+        throw failureExit("no-program", `${joinPath(dir, MANIFEST)}: workspaces is neither an array of strings nor an object whose packages is one: correct the declaration`);
     }
     return { file: joinPath(dir, MANIFEST), patterns: list };
 }
@@ -62,20 +49,6 @@ function declaresWorkspace(host, dir) {
     const manifest = manifestAt(host, dir);
     return manifest !== undefined && Object.hasOwn(manifest, "workspaces");
 }
-/** A pattern with every brace list expanded into its alternatives. */
-function braceExpanded(pattern) {
-    const open = pattern.indexOf("{");
-    const close = open < 0 ? -1 : pattern.indexOf("}", open);
-    if (close < 0) {
-        return [pattern];
-    }
-    const before = pattern.slice(0, open);
-    const after = pattern.slice(close + 1);
-    return pattern
-        .slice(open + 1, close)
-        .split(",")
-        .flatMap((member) => braceExpanded(before + member + after));
-}
 /**
  * The segments of one pattern below the workspace root, `.` and empty segments
  * dropped and `..` taken back, or `undefined` where it leaves the root.
@@ -96,52 +69,6 @@ function segmentsOf(pattern) {
     }
     return segments;
 }
-/**
- * Whether one directory name matches one pattern segment: `*` stands for any run of
- * characters and `?` for one, and neither matches a leading dot.
- */
-function segmentMatches(segment, name) {
-    if (name.startsWith(".") && !segment.startsWith(".")) {
-        return false;
-    }
-    const source = Array.from(segment)
-        .map((character) => {
-        if (character === "*") {
-            return ".*";
-        }
-        if (character === "?") {
-            return ".";
-        }
-        return character.replaceAll(/[.+^${}()|[\]\\/]/gu, (c) => `\\${c}`);
-    })
-        .join("");
-    return new RegExp(`^${source}$`, "u").test(name);
-}
-/** Whether one path's segments match one pattern's, `**` standing for any run of segments. */
-function pathMatches(pattern, path) {
-    const [head, ...rest] = pattern;
-    if (head === undefined) {
-        return path.length === 0;
-    }
-    if (head === "**") {
-        return (pathMatches(rest, path) ||
-            (path.length > 0 && !(path[0] ?? "").startsWith(".") && pathMatches(pattern, path.slice(1))));
-    }
-    const [name, ...below] = path;
-    return name !== undefined && segmentMatches(head, name) && pathMatches(rest, below);
-}
-function subdirectories(host, dir) {
-    try {
-        return host
-            .readDirectory(dir)
-            .filter((entry) => entry.directory && entry.name !== "node_modules" && entry.name !== ".git")
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch {
-        return [];
-    }
-}
 /**
  * Every directory below `dir` one pattern names. `**` does not descend into a
  * directory that declares a workspace of its own, whose packages are that
@@ -155,7 +82,7 @@ function expand(host, dir, pattern, into) {
     }
     if (head === "**") {
         expand(host, dir, rest, into);
-        for (const name of subdirectories(host, dir)) {
+        for (const name of directoriesIn(host, dir)) {
             if (name.startsWith(".")) {
                 continue;
             }
@@ -166,12 +93,12 @@ function expand(host, dir, pattern, into) {
     }
     if (!head.includes("*") && !head.includes("?")) {
         const child = joinPath(dir, head);
-        if (head !== "node_modules" && host.kindOf(child) === "directory") {
+        if (head !== INSTALLED_PACKAGES && host.kindOf(child) === "directory") {
             expand(host, child, rest, into);
         }
         return;
     }
-    for (const name of subdirectories(host, dir)) {
+    for (const name of directoriesIn(host, dir)) {
         if (segmentMatches(head, name)) {
             expand(host, joinPath(dir, name), rest, into);
         }
@@ -208,10 +135,10 @@ function namesDirectory(root, patterns, dir) {
     if (below === undefined) {
         return false;
     }
-    const path = below.split("/");
-    if (path.includes("node_modules")) {
+    if (inInstalledPackages(below)) {
         return false;
     }
+    const path = below.split("/");
     let named = false;
     for (const written of patterns) {
         const negated = written.startsWith("!");
@@ -238,18 +165,7 @@ function layoutOf(configFile, parsed) {
     return { outDir: parsed.outDir, declarationDir: parsed.declarationDir, sourceDirs };
 }
 function configurationsOf(host, dir, parse) {
-    let names;
-    try {
-        names = host
-            .readDirectory(dir)
-            .filter((entry) => !entry.directory && CONFIG_FILE.test(entry.name))
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch {
-        return [];
-    }
-    return names.flatMap((name) => {
+    return configFilesIn(host, dir).flatMap((name) => {
         const configFile = joinPath(dir, name);
         const parsed = parse(configFile);
         return parsed === undefined
@@ -267,31 +183,27 @@ function configurationsOf(host, dir, parse) {
  * highest directory below it, at or above the target root, that holds a manifest.
  */
 function nearestDeclaration(host, targetRoot) {
-    let dir = targetRoot;
     let highestPackage;
-    for (;;) {
+    for (const dir of ancestors(targetRoot, repositoryOf(host, targetRoot)?.root)) {
         const declared = declarationAt(host, dir);
         if (declared !== undefined) {
             return { root: dir, ...declared, highestPackage };
         }
-        if (host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+        if (holdsManifest(host, dir)) {
             highestPackage = dir;
         }
-        const up = dirnamePath(dir);
-        if (up === dir || host.kindOf(joinPath(dir, ".git")) !== "absent") {
-            return undefined;
-        }
-        dir = up;
     }
+    return undefined;
 }
 /**
  * The workspace the target sits in, or `undefined` where none holds it: no directory
  * from the target root up to its repository root declares one with a member beside
  * its root, or the nearest one does not name the highest package below it, at or
  * above the target root, among its members. `parse` reads one compiler configuration,
- * or answers `undefined` where it does not read.
+ * or answers `undefined` where it does not read. `known`, a workspace already read, is the
+ * answer where the nearest declaration is its own, so its members are not listed again.
  */
-export function findWorkspace(host, targetRoot, parse) {
+export function findWorkspace(host, targetRoot, parse, known) {
     const declared = nearestDeclaration(host, targetRoot);
     if (declared === undefined) {
         return undefined;
@@ -300,6 +212,9 @@ export function findWorkspace(host, targetRoot, parse) {
         !namesDirectory(declared.root, declared.patterns, declared.highestPackage)) {
         return undefined;
     }
+    if (known?.root === declared.root) {
+        return known;
+    }
     const members = [];
     for (const dir of memberDirectories(host, declared.root, declared.patterns)) {
         const manifest = manifestAt(host, dir);
@@ -320,7 +235,10 @@ export function findWorkspace(host, targetRoot, parse) {
     if (members.length < 2) {
         return undefined;
     }
-    members.sort((a, b) => a.dir === declared.root ? -1 : b.dir === declared.root ? 1 : a.dir < b.dir ? -1 : 1);
+    members.sort((a, b) => a.dir === declared.root ? -1 : b.dir === declared.root ? 1 : bytewise(a.dir, b.dir));
+    return assembled(host, declared.root, members);
+}
+function assembled(host, root, members) {
     const named = new Map();
     for (const member of members) {
         named.set(member.name, [...(named.get(member.name) ?? []), member]);
@@ -332,11 +250,12 @@ export function findWorkspace(host, targetRoot, parse) {
             return scopes.get(dir);
         }
         const up = dirnamePath(dir);
-        const found = host.kindOf(joinPath(dir, MANIFEST)) === "file" ? dir : up === dir ? undefined : scopeOf(up);
+        const found = holdsManifest(host, dir) ? dir : up === dir ? undefined : scopeOf(up);
         scopes.set(dir, found);
         return found;
     };
     return {
+        root,
         members,
         named,
         memberOf: (path) => {
@@ -345,6 +264,25 @@ export function findWorkspace(host, targetRoot, parse) {
         },
     };
 }
+/**
+ * The workspace with the programs the run forms put first among each member's configurations,
+ * by the member's directory: a formed program has no file on disk to list, so its file list
+ * is what makes a member's JavaScript its source.
+ */
+export function withFormed(host, workspace, formed) {
+    return assembled(host, workspace.root, workspace.members.map((member) => {
+        const own = formed.get(member.dir) ?? [];
+        return own.length === 0
+            ? member
+            : {
+                ...member,
+                configurations: [
+                    ...own.map((layout) => ({ fileNames: new Set(layout.fileNames) })),
+                    ...member.configurations,
+                ],
+            };
+    }));
+}
 /**
  * Whether one configuration holds one file only for the references it makes: the file
  * belongs to a workspace package, the root included, and the configuration does not

package/dist/src/manifest.js

@@ -5,13 +5,12 @@
  * directory's manifest, {@link packageEntries} those of the packages below the target root.
  */
 import { isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { isRecord } from "./json-document.js";
+import { MANIFEST, manifestAt, readJSON } from "./fs/manifest.js";
+import { scriptTokens } from "./text/shell.js";
 /** The manifest's own name. */
-const MANIFEST = "package.json";
 /** The three members that name an entry point beside `exports` and `bin`. */
 const LEGACY_MEMBERS = ["main", "module", "types"];
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 /**
  * Whether one member's value names a file of this package rather than another
  * package or a URL. A target written with no leading dot is a path too, which is
@@ -23,31 +22,32 @@ function isTarget(value, requireDot) {
     }
     return !requireDot || value.startsWith("./");
 }
-/** Where a script's command line splits into tokens: white space and the shell's operators. */
-const SCRIPT_SEPARATORS = /\s+|&&|\|\||;|\|/u;
-/** A token written inside one pair of quotes. */
-const QUOTED = /^(["'])(.*)\1$/su;
-/**
- * Every token one script's command line holds, each with one pair of enclosing quotes
- * removed. A token holding a wildcard is a pattern rather than a path, and names no
- * entry point.
- */
-export function scriptTokens(command) {
-    return command
-        .split(SCRIPT_SEPARATORS)
-        .map((token) => token.replace(QUOTED, "$2"))
-        .filter((token) => token !== "" && !token.includes("*"));
-}
 /** One member's spelling below another: `exports` then `exports["."]`. */
 function below(member, key) {
     return `${member}[${JSON.stringify(key)}]`;
 }
 /**
- * Every target one `exports` value carries, at the member each is written under.
- *
- * The value nests strings, subpath or condition objects and alternative arrays to
- * any depth; a `null` blocks a subpath. Every level is walked, because each
- * condition names its own entry file, and a key's meaning is never read.
+ * The command strings one manifest runs, each at the member it is written under: each of its
+ * `scripts`, and the `exec` command of nodemon's configuration, in the manifest's `nodemonConfig`
+ * or the `nodemon.json` beside it, which nodemon runs the watched script with:
+ * https://github.com/remy/nodemon#config-files
+ */
+export function manifestCommands(host, dir, manifest) {
+    const scripts = manifest["scripts"];
+    const nodemon = {
+        nodemonConfig: manifest["nodemonConfig"],
+        "nodemon.json": readJSON(host, joinPath(dir, "nodemon.json")),
+    };
+    const written = [
+        ...Object.entries(isRecord(scripts) ? scripts : {}).map(([name, value]) => [below("scripts", name), value]),
+        ...Object.entries(nodemon).map(([member, config]) => [below(member, "exec"), isRecord(config) ? config["exec"] : undefined]),
+    ];
+    return written.flatMap(([member, command]) => typeof command === "string" ? [{ member, command }] : []);
+}
+/**
+ * Every target one `exports` value carries, at the member each is written under. Every level of
+ * strings, subpath or condition objects and alternative arrays is walked, because each condition
+ * names its own entry file; a `null` blocks a subpath, and a key's meaning is never read.
  */
 function exportTargets(value, member, found) {
     if (typeof value === "string") {
@@ -69,28 +69,6 @@ function exportTargets(value, member, found) {
         exportTargets(held, below(member, key), found);
     }
 }
-/** The manifest at the target root, decoded, or undefined where there is none to read. */
-function manifestOf(host, targetRoot) {
-    let text;
-    try {
-        text = host.readFile(joinPath(targetRoot, MANIFEST));
-    }
-    catch {
-        return undefined;
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        // A manifest this program cannot read names no entry point, which is the same
-        // answer as an absent one. What a manifest's contents say is not refused here:
-        // the package manager owns that refusal, and an analysis of a tree it rejects
-        // is not the run's subject.
-        return undefined;
-    }
-    return isRecord(value) ? value : undefined;
-}
 /**
  * What the manifest in `targetRoot` declares about where its package is entered.
  *
@@ -99,7 +77,7 @@ function manifestOf(host, targetRoot) {
  * it and there is one such configuration per project, while there is one manifest.
  */
 export function readManifest(host, targetRoot) {
-    const manifest = manifestOf(host, targetRoot);
+    const manifest = manifestAt(host, targetRoot);
     if (manifest === undefined) {
         return { entries: [], declaresExports: false };
     }
@@ -110,6 +88,24 @@ export function readManifest(host, targetRoot) {
             found.push({ member, path: value, role: "import", published: true });
         }
     }
+    // A `browser` string replaces `main` in a browser bundle, and an object replaces each
+    // module it maps with the file it names: https://github.com/defunctzombie/package-browser-field-spec
+    const browser = manifest["browser"];
+    if (typeof browser === "string" && isTarget(browser, false)) {
+        found.push({ member: "browser", path: browser, role: "import", published: true });
+    }
+    else if (isRecord(browser)) {
+        for (const [replaced, value] of Object.entries(browser)) {
+            if (typeof value === "string" && isTarget(value, true)) {
+                found.push({
+                    member: below("browser", replaced),
+                    path: value,
+                    role: "import",
+                    published: true,
+                });
+            }
+        }
+    }
     const bin = manifest["bin"];
     if (typeof bin === "string" && isTarget(bin, false)) {
         found.push({ member: "bin", path: bin, role: "run", published: false });
@@ -128,16 +124,15 @@ export function readManifest(host, targetRoot) {
             if (typeof command !== "string") {
                 continue;
             }
-            for (const token of new Set(scriptTokens(command))) {
-                found.push({
-                    member: below("scripts", name),
-                    path: token,
-                    role: "script",
-                    published: false,
-                });
+            const member = below("scripts", name);
+            for (const path of new Set(scriptTokens(command))) {
+                found.push({ member, path, role: "script", published: false });
             }
         }
     }
+    for (const { member, command } of manifestCommands(host, targetRoot, manifest)) {
+        found.push({ member, path: ".", role: "script", published: false, command });
+    }
     return {
         entries: found.map((entry) => ({
             ...entry,

package/dist/src/matrix.js

@@ -70,11 +70,13 @@ export function matrixOf(per) {
         }
     });
     symbols.sort((a, b) => byPosition(a.position, b.position));
+    const testUsed = new Set(per.flatMap((one) => one.testUsedFiles ?? []));
     return {
         configurations: per.map((one) => one.configuration),
-        graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles)),
-        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))]),
+        graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles, one.ambient)),
+        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))], new Set(per.flatMap((one) => [...(one.ambient ?? [])]))),
         heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
+        testUsed: symbols.map((symbol) => testUsed.has(symbol.position.path)),
         dependents,
     };
 }
@@ -100,29 +102,36 @@ export function sweepMatrix(matrix, input) {
         new Map((per[index]?.candidates ?? []).map((candidate) => [candidate.id, candidate])),
     ]));
     const union = matrix.union;
-    const dead = union.symbols.map(() => false);
-    const testOfDeadCode = union.symbols.map(() => false);
     const heldBy = union.symbols.map(() => undefined);
-    const unreferencedTest = union.symbols.map(() => false);
-    const testReached = reachedWithTheTests(union, [
+    const held = [
         ...input.marked,
         ...(input.exempt ?? []).map((record) => record.id),
         ...(input.unanswered ?? []),
-    ]);
-    const judged = union.symbols.map((symbol, at) => {
+    ];
+    const testReached = reachedWithTheTests(union, held);
+    // A test uses what it names: a file a test reads through a star re-export or a
+    // namespace keeps the exports nothing names at their own class.
+    const testNamed = reachedWithTheTests(union, held, false);
+    const everywhere = union.symbols.map((symbol, at) => {
         const held = matrix.heldIn[at] ?? [];
         const found = held.map((configuration) => byConfiguration.get(configuration)?.get(symbol.id));
         return held.length === 0 || found.some((candidate) => candidate === undefined)
             ? undefined
             : found.filter((candidate) => candidate !== undefined);
     });
+    const compiled = compiledReferences(matrix, new Set(union.symbols.flatMap((symbol, at) => (everywhere[at] === undefined ? [] : [symbol.id]))), input.mode);
+    const judged = everywhere.map((found, at) => compiled.has(union.symbols[at]?.id ?? "") ? undefined : found);
     // A configuration that does not hold a test's subject's caller finds the subject dead,
     // so a test is of dead code only where every production subject it names is dead in
     // every configuration that holds it.
     const subjectsDead = (at) => (union.out[at] ?? []).every((edge) => union.test[edge.to] === true ||
         union.support[edge.to] === true ||
+        union.ambient[edge.to] === true ||
         union.subject[edge.to] !== true ||
         judged[edge.to] !== undefined);
+    const admittedAt = (at) => judged[at]?.every((candidate) => candidate.testOfDeadCode) === true && subjectsDead(at);
+    const kept = keptByTests(union, testReached, admittedAt);
+    const testUsed = testUsedReach(union, union.symbols.map((_symbol, at) => matrix.testUsed[at] === true && testNamed[at] === true), judged.map((one) => one !== undefined));
     const candidates = [];
     union.symbols.forEach((symbol, at) => {
         const all = judged[at];
@@ -130,15 +139,12 @@ export function sweepMatrix(matrix, input) {
             return;
         }
         const held = matrix.heldIn[at] ?? [];
-        const admitted = all.every((candidate) => candidate.testOfDeadCode) && subjectsDead(at);
+        const admitted = admittedAt(at);
         const testRefs = union.made[at]?.test ?? 0;
         const heldByTests = heldBy[union.parent[at] ?? OUTSIDE] ??
             (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
         const unreferenced = union.test[at] === true && !admitted && testReached[at] !== true;
-        dead[at] = true;
-        testOfDeadCode[at] = admitted;
         heldBy[at] = heldByTests;
-        unreferencedTest[at] = unreferenced;
         const productionRefs = union.made[at]?.production ?? 0;
         const counted = all.every((candidate) => candidate.relation === "reference-counting");
         candidates.push({
@@ -153,15 +159,90 @@ export function sweepMatrix(matrix, input) {
             configurations: held,
             heldByTests,
             unreferencedTest: unreferenced,
+            testUsed: testUsed[at] === true,
+            keptByTests: kept[at] === true,
         });
     });
     const liveUnder = liveAnywhere(union.symbols, per);
     return {
         liveUnder,
         candidates,
-        components: componentsOf(union, dead.map((one, at) => one && heldBy[at] === undefined), testOfDeadCode, unreferencedTest, positionsOf(union, matrix.dependents, liveUnder)),
+        components: deadComponents(matrix, { liveUnder, candidates }, new Set()),
     };
 }
+/**
+ * Every declaration of `dead`, those dead in every configuration that holds them, that a
+ * configuration's graph references from a judged declaration outside `dead` or already
+ * kept, until none joins: deleting one would break that configuration's compile. A
+ * production run counts no reference a test file made.
+ */
+function compiledReferences(matrix, dead, mode) {
+    const kept = new Set();
+    for (let changed = true; changed;) {
+        changed = false;
+        for (const graph of matrix.graphs) {
+            graph.out.forEach((edges, from) => {
+                const id = graph.symbols[from]?.id ?? "";
+                if (graph.subject[from] !== true || (dead.has(id) && !kept.has(id))) {
+                    return;
+                }
+                for (const edge of edges) {
+                    const to = graph.symbols[edge.to]?.id ?? "";
+                    if ((!mode.production || !edge.test) && dead.has(to) && !kept.has(to)) {
+                        kept.add(to);
+                        changed = true;
+                    }
+                }
+            });
+        }
+    }
+    return kept;
+}
+/** Per declaration of the union, whether one of `seeds` is it or reaches it through `dead` declarations. */
+function testUsedReach(union, seeds, dead) {
+    // A file is no candidate, and its top level is what reaches what it alone calls.
+    const reached = seeds.map((seed, at) => seed && dead[at] === true);
+    const queue = seeds.flatMap((one, at) => (one ? [at] : []));
+    for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
+        for (const edge of union.out[at] ?? []) {
+            if (dead[edge.to] === true && reached[edge.to] !== true) {
+                reached[edge.to] = true;
+                queue.push(edge.to);
+            }
+        }
+    }
+    return reached;
+}
+/** Per declaration of the union, whether test code `reached` holds and `admitted` rejects references it. */
+function keptByTests(union, reached, admitted) {
+    const kept = union.symbols.map(() => false);
+    union.out.forEach((edges, from) => {
+        const testCode = union.test[from] === true || union.support[from] === true;
+        if (!testCode || reached[from] !== true || admitted(from)) {
+            return;
+        }
+        for (const edge of edges) {
+            if (edge.test) {
+                kept[edge.to] = true;
+            }
+        }
+    });
+    return kept;
+}
+/**
+ * The dead components of one sweep over the union, with the file declarations at `files`
+ * dead as well: a file that is deleted whole takes the declarations it holds and every
+ * dead declaration only its top level references with it.
+ */
+export function deadComponents(matrix, result, files) {
+    const union = matrix.union;
+    const byId = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
+    const candidateAt = (at) => byId.get(union.symbols[at]?.id ?? "");
+    return componentsOf(union, union.symbols.map((_symbol, at) => {
+        const candidate = candidateAt(at);
+        return files.has(at) || (candidate !== undefined && candidate.heldByTests === undefined);
+    }), union.symbols.map((_symbol, at) => candidateAt(at)?.testOfDeadCode === true), union.symbols.map((_symbol, at) => candidateAt(at)?.unreferencedTest === true), positionsOf(union, matrix.dependents, result.liveUnder));
+}
 /**
  * The file declarations at `paths`, below the target root, that one sweep holds live
  * under both relations, the rule a judged declaration is live by.