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

package/dist/src/verbs/explain.js

@@ -1,13 +1,16 @@
-import { runAnalysis } from "../analysis.js";
-import { listing } from "../components.js";
-import { ConfigError } from "../config.js";
-import { OUTSIDE, swept as judged } from "../graph.js";
-import { referenceKey } from "../matrix.js";
+import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.js";
+import { productionMode, runAnalysis } from "../analysis.js";
+import { listing } from "../liveness/components.js";
+import { swept as judged } from "../liveness/graph.js";
 import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
 import { positionKey } from "../position.js";
+import { madeByTestCode } from "../tests/file-class.js";
 import { resolve } from "../resolve.js";
-import { EXIT_CLEAN, EXIT_USAGE } from "./verb.js";
+import {} from "./verb.js";
+import { UsageError } from "../usage.js";
+import { bytewise } from "../text/compare.js";
+import { diagnose } from "../product.js";
 /**
  * The three spellings of an explanation request, each naming the symbol to explain. They are
  * one request, because exactly one state holds for a symbol and the answer is that state.
@@ -33,10 +36,10 @@ function namedSymbol(option) {
     });
     const [only, ...more] = named;
     if (only === undefined) {
-        throw new ConfigError("malformed", "", "explain explains the symbol --why, --why-live or --why-not names, and none was named");
+        throw new UsageError("explain explains the symbol --why, --why-live or --why-not names, and none was named");
     }
     if (more.length > 0) {
-        throw new ConfigError("malformed", "", `explain explains one symbol, and ${named.map((one) => `--${one.name}`).join(", ")} each name one`);
+        throw new UsageError(`explain explains one symbol, and ${named.map((one) => `--${one.name}`).join(", ")} each name one`);
     }
     return only.value;
 }
@@ -73,153 +76,97 @@ function subjectOf(symbols, named) {
     const partial = symbols
         .filter((symbol) => symbol.ref.toLowerCase().includes(folded) || symbol.name.toLowerCase().includes(folded))
         .map(described)
-        .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+        .sort(bytewise);
     return { candidates: partial.slice(0, MAX_PARTIAL_MATCHES) };
 }
-/** Every reference of the run once, a reference several configurations make counted once. */
-function referencesOf(configured) {
-    const seen = new Set();
-    const held = [];
-    for (const reference of configured.flatMap((one) => one.references)) {
-        const key = referenceKey(reference);
-        if (!seen.has(key)) {
-            seen.add(key);
-            held.push(reference);
-        }
-    }
-    return held;
-}
-/** Every root of the run once per reason, in the order the projects name them. */
-function rootsOf(configured) {
-    const seen = new Set();
-    return configured
-        .flatMap((one) => one.roots)
-        .filter((root) => {
-        const key = [root.id, root.kind, root.source].join("\u0000");
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-}
-/**
- * The shortest path from a root or a loaded consumer to one declaration, walked breadth first
- * from every root at once in the order the run names them, a consumer's reference being the
- * first hop of a path of its own, and following the references the sweep follows: a
- * reference that reads a module reaches what the module exports, and an evaluation or a root
- * reaches the module alone. Under `production` no reference a test file made is followed,
- * which is the set the report's sweep counts.
- */
-function shortestPath(analysis, to, production) {
-    const graph = analysis.swept.matrix.union;
-    const out = new Map();
-    const consumed = [];
-    for (const reference of referencesOf(analysis.configured)) {
-        if (production && reference.test) {
-            continue;
-        }
-        const { consumer } = reference;
-        if (consumer !== undefined) {
-            consumed.push({ ...reference, consumer });
-            continue;
-        }
-        const held = out.get(reference.from);
-        if (held === undefined) {
-            out.set(reference.from, [reference]);
-        }
-        else {
-            held.push(reference);
-        }
-    }
-    const steps = [];
-    const seen = new Set();
-    const expanded = new Set();
-    const enter = (step) => {
-        if (!seen.has(step.at)) {
-            seen.add(step.at);
-            steps.push(step);
-        }
-    };
-    const follow = (reference, previous, origin) => {
-        enter({ at: reference.to, hop: { k: "reference", reference }, previous, origin });
-        const target = graph.at(reference.to);
-        if (reference.use === "evaluation" || target === OUTSIDE || expanded.has(reference.to)) {
-            return;
-        }
-        expanded.add(reference.to);
-        for (const exported of graph.exportsOf[target] ?? []) {
-            const id = graph.symbols[exported]?.id;
-            if (id !== undefined) {
-                enter({ at: id, hop: { k: "export", reference, to: id }, previous, origin });
-            }
-        }
-    };
-    for (const root of rootsOf(analysis.configured)) {
-        enter({ at: root.id, hop: undefined, previous: -1, origin: { k: "root", root } });
-    }
-    // A consumer's reference is one hop long, so it joins the walk where the roots' first
-    // hops do.
-    const firstHops = steps.length;
-    for (let head = 0;; head += 1) {
-        if (head === firstHops) {
-            for (const reference of consumed) {
-                follow(reference, -1, { k: "consumer", consumer: reference.consumer });
+/** Where a path starts, as a line names it. */
+function originText(origin, graph) {
+    const id = (at) => graph.symbols[at]?.id ?? "";
+    switch (origin.k) {
+        case "root":
+            return `root ${origin.rooted.kind} ${id(origin.rooted.at)}`;
+        case "consumed": {
+            const reference = graph.references[origin.edge.reference];
+            if (reference?.consumer !== undefined) {
+                return `consumer ${reference.consumer}`;
             }
+            return reference?.unheld === true
+                ? `test file no project holds ${reference.from.replace(/#$/u, "")}`
+                : `declaration no configuration judges ${reference?.from ?? ""}`;
         }
-        const step = steps[head];
-        if (step === undefined) {
-            break;
-        }
-        if (step.at === to) {
-            const path = [];
-            for (let at = step; at?.hop !== undefined; at = steps[at.previous]) {
-                path.unshift(at.hop);
-            }
-            return { origin: step.origin, path };
-        }
-        for (const reference of out.get(step.at) ?? []) {
-            follow(reference, head, step.origin);
-        }
+        case "exemption":
+            return `exemption ${origin.record.class} ${positionKey(origin.record.site)}`;
+        case "mark":
+            return `suppression of ${id(origin.at)}`;
+        case "unanswered":
+            return `unanswered question about ${id(origin.at)}`;
     }
-    return undefined;
 }
 /** What made a reference: a declaration of the target, or a loaded consumer. */
 function madeBy(reference) {
     return reference.consumer === undefined ? reference.from : `consumer ${reference.consumer}`;
 }
-function referenceLine(reference, tail) {
-    return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${reference.test ? "\tfrom a test file" : ""}\n`;
+/**
+ * One reference of an answer, marked where test code made it, a test-support file's included,
+ * and naming the configurations that make it where they are not every one of the run.
+ */
+function referenceLine(reference, tail, support, configurations) {
+    const partial = configurations.making.length < configurations.run.length;
+    return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${madeByTestCode(reference, support) ? "\tfrom a test file" : ""}${partial ? `\tmade in ${configurations.making.join(" ")}` : ""}\n`;
 }
 /** Why a declaration no finding names and no exemption held back is live, or how it fell. */
 function liveness(analysis, subject, cascade) {
-    const { sweep } = analysis.swept;
+    const { matrix, sweep } = analysis.swept;
+    const graph = matrix.union;
     const candidate = sweep.candidates.find((one) => one.id === subject.id);
     if (candidate === undefined && !judged(subject.kind)) {
         return `answer: unjudged\n  unjudged: neither liveness relation judges a ${subject.kind}\n`;
     }
     let text = `answer: ${candidate === undefined ? "live" : "dead"}\n`;
     text += `  live under: ${listed(sweep.liveUnder.get(subject.id) ?? [])}\n`;
-    for (const root of rootsOf(analysis.configured).filter((one) => one.id === subject.id)) {
-        text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+    const at = graph.at(subject.id);
+    const seen = new Set();
+    for (const root of graph.rooted.filter((one) => one.at === at)) {
+        const key = `${root.kind}\u0000${root.source}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+        }
     }
-    const found = shortestPath(analysis, subject.id, true) ?? shortestPath(analysis, subject.id, false);
-    if (found !== undefined && found.path.length > 0) {
-        const { origin } = found;
-        text += `  reached from: ${origin.k === "root" ? `root ${origin.root.kind} ${origin.root.id}` : `consumer ${origin.consumer}`}\n`;
-        for (const hop of found.path) {
-            text += referenceLine(hop.reference, `${madeBy(hop.reference)} -> ${hop.reference.to}`);
+    const support = new Set(analysis.configured.flatMap((one) => one.supportFiles ?? []));
+    const line = (edge, tail) => {
+        const reference = graph.references[edge.reference];
+        return reference === undefined
+            ? ""
+            : referenceLine(reference, tail(reference), support, {
+                making: graph.configurations[edge.reference] ?? [],
+                run: matrix.configurations,
+            });
+    };
+    const found = sweep.path(subject.id);
+    if (found !== undefined && found.hops.length > 0) {
+        text += `  reached from: ${originText(found.origin, graph)}\n`;
+        for (const hop of found.hops) {
+            text += line(hop.edge, (reference) => `${madeBy(reference)} -> ${reference.to}`);
             if (hop.k === "export") {
-                text += `  export: ${hop.reference.to} -> ${hop.to}\n`;
+                const reference = graph.references[hop.edge.reference];
+                text += `  export: ${reference?.to ?? ""} -> ${graph.symbols[hop.to]?.id ?? ""}\n`;
             }
         }
     }
     else if (found === undefined) {
-        const references = referencesOf(analysis.configured).filter((one) => one.to === subject.id);
-        text += "  unreachable: no path of references reaches it from a root or a loaded consumer\n";
+        const references = graph.references.flatMap((one, place) => one.to === subject.id ? [place] : []);
+        text +=
+            "  unreachable: no path of references reaches it from a root, a loaded consumer or a test file no project holds\n";
         text += `  references: ${String(references.length)}\n`;
-        for (const reference of references) {
-            text += referenceLine(reference, `from ${madeBy(reference)}`);
+        for (const place of references) {
+            const reference = graph.references[place];
+            if (reference !== undefined) {
+                text += referenceLine(reference, `from ${madeBy(reference)}`, support, {
+                    making: graph.configurations[place] ?? [],
+                    run: matrix.configurations,
+                });
+            }
         }
     }
     if (candidate !== undefined) {
@@ -276,7 +223,7 @@ function explanation(analysis, subject, cascade) {
     text += `position: ${subject.id}\n`;
     text += `configurations: ${listed(analysis.swept.matrix.heldIn[at] ?? [])}\n`;
     const found = analysis.result.findings.find((one) => positionKey(one.position) === subject.id);
-    const retained = analysis.swept.retained.filter((one) => one.id === subject.id);
+    const retained = analysis.swept.sweep.retained.filter((one) => one.id === subject.id);
     if (found !== undefined) {
         text += reported(found);
     }
@@ -286,7 +233,7 @@ function explanation(analysis, subject, cascade) {
             text += `  class: ${one.class}\t${positionKey(one.site)}\t${one.detail}\n`;
         }
     }
-    else if (analysis.swept.heldByUnanswered.includes(subject.id)) {
+    else if (analysis.swept.sweep.held.includes(subject.id)) {
         text +=
             "answer: held\n  held by: a question the checker did not answer, which could have kept it live, so no finding names it\n";
     }
@@ -298,18 +245,17 @@ function explanation(analysis, subject, cascade) {
 /**
  * Explains one symbol from the analysis the report is built from: why a reported symbol is
  * reported, which exemption classes held a retained one back, that an unanswered question held
- * a held one, and for any other declaration the relations that hold it live and the shortest
- * path from a root or a loaded consumer, or the references it has where no path reaches it. A
- * request naming no one declaration exits with the usage code and names what partially
+ * a held one, and for any other declaration the relations that hold it live and the path the
+ * sweep's strongest tier reaching it follows, or the references it has where no path reaches
+ * it. A request naming no one declaration exits with the usage code and names what partially
  * matches it. Where the analysis was partial, the error stream says so.
  */
 export const explainVerb = ({ out, err, host, inputs, scope, openClient, option }) => {
     const named = namedSymbol(option);
     const { config, provenance } = resolve(inputs());
     const scoped = scope();
-    const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, {
-        production: true,
-    });
+    const mode = productionMode(config);
+    const analysis = runAnalysis(openClient(config), host, scoped, config, provenance, mode);
     const { subject, candidates } = subjectOf(analysis.swept.matrix.union.symbols, named);
     const notes = partialNotes({
         notBuilt: analysis.run.notBuilt,
@@ -317,7 +263,7 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     });
     if (subject === undefined) {
-        err.write(`deadset-ts: ${JSON.stringify(named)} names no one symbol of the target\n`);
+        diagnose(err, `${JSON.stringify(named)} names no one symbol of the target`);
         for (const candidate of candidates) {
             err.write(`  ${candidate}\n`);
         }
@@ -329,7 +275,7 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         out.write(explanation(analysis, subject, config.reporters.cascade));
     }
     for (const note of notes) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     return subject === undefined ? EXIT_USAGE : EXIT_CLEAN;
 };

package/dist/src/verbs/print-config.js

@@ -1,6 +1,7 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.js";
 import { printConfig } from "../print.js";
 import { resolve } from "../resolve.js";
-import { EXIT_CLEAN } from "./verb.js";
+import {} from "./verb.js";
 /** Writes the resolved configuration with the source of every setting. */
 export const printConfigVerb = ({ out, inputs }) => {
     const { config, provenance } = resolve(inputs());

package/dist/src/verbs/print-projects.js

@@ -1,8 +1,10 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.js";
 import { runProjects } from "../analysis.js";
 import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
-import { resolveUnkinded } from "../resolve.js";
-import { EXIT_CLEAN } from "./verb.js";
+import { resolvePartial } from "../resolve.js";
+import {} from "./verb.js";
+import { diagnose } from "../product.js";
 /**
  * Writes the name of every project one run analyzes, one per line: the identifier the
  * build matrix declares for it, or, where discovery derived the project, its
@@ -11,7 +13,7 @@ import { EXIT_CLEAN } from "./verb.js";
  * instead, and one that fails the analysis fails this command the same way.
  */
 export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient }) => {
-    const config = resolveUnkinded(inputs());
+    const config = resolvePartial(inputs());
     const scoped = scope();
     const answer = runProjects(openClient(config), host, scoped, config);
     for (const id of answer.configurations) {
@@ -22,7 +24,7 @@ export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient })
         unanswered: answer.unanswered,
         targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     })) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     return EXIT_CLEAN;
 };

package/dist/src/verbs/print-retained.js

@@ -1,9 +1,33 @@
-import { runSweep } from "../analysis.js";
-import { retainedLines } from "../exempt.js";
+import { EXIT_CLEAN } from "../contract/contract.generated.js";
+import { productionMode, runSweep } from "../analysis.js";
 import { partialNotes } from "../partial.js";
+import { positionKey } from "../position.js";
 import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
-import { EXIT_CLEAN } from "./verb.js";
+import {} from "./verb.js";
+import { diagnose } from "../product.js";
+/**
+ * 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.
+ */
+function retainedLines(symbols, retained) {
+    const held = new Map();
+    for (const record of retained) {
+        held.set(record.id, [...(held.get(record.id) ?? []), record]);
+    }
+    return symbols.flatMap((symbol) => {
+        const records = held.get(symbol.id);
+        if (records === undefined) {
+            return [];
+        }
+        const fields = records.flatMap((record) => [
+            record.class,
+            positionKey(record.site),
+            record.detail,
+        ]);
+        return [[symbol.ref, positionKey(symbol.position), ...fields].join("\t")];
+    });
+}
 /**
  * Writes every declaration an exemption held back in the production sweep a report is
  * built from, one per line, and nothing where no exemption held one back. One fact
@@ -16,9 +40,9 @@ export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient })
     const scoped = scope();
     const swept = runSweep(openClient(config), host, scoped, config, {
         marked: [],
-        mode: { production: true },
+        mode: productionMode(config),
     });
-    for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
+    for (const line of retainedLines(swept.matrix.union.symbols, swept.sweep.retained)) {
         out.write(`${line}\n`);
     }
     for (const note of partialNotes({
@@ -26,7 +50,7 @@ export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient })
         unanswered: swept.unanswered,
         targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     })) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     return EXIT_CLEAN;
 };

package/dist/src/verbs/print-roots.js

@@ -1,8 +1,10 @@
+import { EXIT_CLEAN, EXIT_FINDINGS } from "../contract/contract.generated.js";
 import { runRoots } from "../analysis.js";
 import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
-import { EXIT_CLEAN, EXIT_FINDINGS } from "./verb.js";
+import {} from "./verb.js";
+import { diagnose } from "../product.js";
 /**
  * One root as a line: the declaration's reference, why it is a root, and the string
  * that named it, separated by tabs. A run of several configurations adds the ones
@@ -39,7 +41,7 @@ export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) =>
         unanswered: answer.unanswered,
         targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
     })) {
-        err.write(`deadset-ts: ${note}\n`);
+        diagnose(err, note);
     }
     return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
 };

package/dist/src/verbs/verb.js

@@ -1,5 +1 @@
-/** The exit codes the Contract's exit-code table names. */
-export const EXIT_CLEAN = 0;
-export const EXIT_FINDINGS = 1;
-export const EXIT_USAGE = 2;
-export const EXIT_FAILURE = 3;
+export {};

package/dist/src/verbs/version.js

@@ -1,7 +1,18 @@
-import { CONTRACT_VERSION } from "../version.js";
-import { EXIT_CLEAN } from "./verb.js";
+import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.js";
+import { productFault } from "../failure.js";
+import {} from "./verb.js";
+import { message, PRODUCT } from "../product.js";
+/** The version the host reports for this analyzer; one it cannot read is a fault of the analyzer. */
+export function ownVersion(host) {
+    try {
+        return host.analyzerVersion();
+    }
+    catch (error) {
+        throw productFault(`cannot read its own version: ${message(error)}`);
+    }
+}
 /** Writes the version the host reports and the Contract version this analyzer implements. */
 export const versionVerb = ({ out, host }) => {
-    out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+    out.write(`${PRODUCT} ${ownVersion(host)}\ncontract ${CONTRACT_VERSION}\n`);
     return EXIT_CLEAN;
 };

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.2",
+  "version": "8.0.0-dev.21",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"
@@ -9,6 +9,7 @@
     "include": [
       "LICENSE",
       "NOTICE",
+      "THIRD_PARTY_NOTICES.md",
       "README.md",
       "bin/**",
       "src/**",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.2",
+  "version": "8.0.0-dev.21",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",
@@ -19,6 +19,8 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
+    "gen": "node scripts/gen-contract.ts",
+    "vendor": "node scripts/vendor-unbash.ts",
     "prepack": "npm run build",
     "typecheck": "tsc -p tsconfig.json",
     "typecheck:tests": "tsc -p tsconfig.test.json",
@@ -29,24 +31,27 @@
     "lint:prettier": "prettier --check .",
     "lint:fix": "eslint . --fix && prettier --write ."
   },
+  "cplieger": {
+    "vitestShards": 2
+  },
   "dependencies": {
-    "@typescript/native": "npm:typescript@7.1.0-dev.20261010.1"
+    "@typescript/native": "npm:typescript@7.1.0-dev.20261103.1"
   },
   "overrides": {
     "qs": "^6.15.2"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
-    "@stryker-mutator/core": "10.0.0",
-    "@stryker-mutator/typescript-checker": "10.0.0",
-    "@stryker-mutator/vitest-runner": "10.0.0",
+    "@stryker-mutator/core": "10.1.1",
+    "@stryker-mutator/typescript-checker": "10.1.1",
+    "@stryker-mutator/vitest-runner": "10.1.1",
     "@types/node": "24.19.2",
-    "eslint": "10.12.0",
+    "eslint": "10.14.0",
     "fast-check": "4.10.2",
     "prettier": "3.9.10",
     "typescript": "npm:@typescript/typescript6@6.0.2",
-    "typescript-eslint": "8.71.1",
-    "vitest": "5.0.4"
+    "typescript-eslint": "8.72.1",
+    "vitest": "5.1.0"
   },
   "publishConfig": {
     "access": "public"
@@ -71,6 +76,7 @@
   "files": [
     "LICENSE",
     "NOTICE",
+    "THIRD_PARTY_NOTICES.md",
     "dist/",
     "src/",
     "!src/**/*.test.ts",

package/src/alias-chain.ts

@@ -1,7 +1,7 @@
 /**
  * Where an import or export chain leads in one project: from one symbol to each
  * declaration of the target it is, and along the chain of aliases it heads to each
- * declaration every link of that chain is.
+ * declaration every link of that chain is, and what a name resolves to through them.
  */
 
 import {
@@ -12,10 +12,11 @@ import {
   isImportSpecifier,
   isNamespaceExport,
   isNamespaceImport,
+  type Node,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/sync";
-import { declarationsByName, isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
-import { UNANSWERED, type Answer } from "./query.ts";
+import { isParameterProperty, nodeKey, type Inventory } from "./inventory.ts";
+import { must, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One declaration a chain reaches, and whether a step along an alias reached it. */
@@ -49,8 +50,6 @@ export interface AliasChains {
    * link is declared.
    */
   nextDeclared(symbol: TSSymbol): readonly ChainTarget[];
-  /** How many steps the compiler was asked for: one per alias, whatever the chains it heads. */
-  readonly steps: number;
 }
 
 /**
@@ -65,7 +64,6 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
   const ownFiles = project.ownPaths();
   const steps = new Map<number, Answer<TSSymbol | undefined>>();
   const chains = new Map<number, readonly ChainTarget[]>();
-  let asked = 0;
 
   const declarationsOf = (symbol: TSSymbol): string[] => {
     const ids: string[] = [];
@@ -102,7 +100,6 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
       return steps.get(symbol.id);
     }
     const next = project.aliasStepOf(symbol);
-    asked += 1;
     steps.set(symbol.id, next);
     return next;
   };
@@ -132,7 +129,7 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
         names.add(node.expression.text);
       }
     }
-    const byName = declarationsByName(held);
+    const byName = held.byName;
     const ids = [...names].flatMap((name) => byName.get(name) ?? []);
     return [...new Set([...ids, ...(module ? files : [])])].map((id) => ({
       id,
@@ -197,8 +194,40 @@ export function aliasChains<Brand>(project: ProjectView<Brand>, held: Inventory)
     declarationsOf,
     chainOf,
     nextDeclared,
-    get steps() {
-      return asked;
-    },
   };
 }
+
+/**
+ * What each of a batch of nodes resolves to, every alias followed to the declaration
+ * it stands for. A node the checker resolves to nothing, and an alias that resolves
+ * to nothing, are absent from the answer. Each alias is followed once. A question the
+ * checker does not answer stops the pass, as {@link must} stops.
+ */
+export function resolvedTargets<Brand>(
+  project: ProjectView<Brand>,
+  nodes: readonly Node[],
+): ReadonlyMap<Node, TSSymbol> {
+  const followed = new Map<number, TSSymbol | undefined>();
+  const targets = new Map<Node, TSSymbol>();
+  project
+    .symbolsAt(nodes.map((node) => project.handle(node)))
+    .map(must)
+    .forEach((symbol, index) => {
+      const node = nodes[index];
+      if (symbol === undefined || node === undefined) {
+        return;
+      }
+      let target: TSSymbol | undefined = symbol;
+      if ((symbol.flags & SymbolFlags.Alias) !== 0) {
+        if (!followed.has(symbol.id)) {
+          const aliased = must(project.queries.aliased(symbol));
+          followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
+        }
+        target = followed.get(symbol.id);
+      }
+      if (target !== undefined) {
+        targets.set(node, target);
+      }
+    });
+  return targets;
+}