@cplieger/deadset-ts 3.13.0 → 4.0.0

package/README.md

@@ -8,7 +8,7 @@ deadset-ts is a command-line analyzer for TypeScript and JavaScript projects. It
 
 deadset-ts is report-only. It never edits source, and it refuses any `--fix` flag.
 
-**Status: pre-release.** This version implements contract 4.0.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. Seven exemption classes hold a declaration back from the sweep, and `print-retained` lists what each one held back: `interface-satisfaction`, a member an interface requires of a class whose value reaches that interface; `decorator`, a decorated member and every member of a decorated class; `injection-container`, a decorated property of a class a dependency-injection container constructs, being a class passed to a call `ts.injection_registrations` names or one a parameter of whose constructor carries a decorator; `framework-lifecycle`, a member a `ts.lifecycle_contracts` entry lists, on a class that is the entry's component by a decorator or a call the entry names or by extending a class it names; `serialization-contract`, the properties of a class whose values reach `JSON.stringify` or a declaration `ts.serializers` names, and those and its `toJSON` and `toString` where a value is passed to an `unknown` or `any` parameter of a function outside the analysis; and, at the lowest confidence, `template-field`, a member an action of a template under `analysis.template_dirs` names, and `reflective-lookup`, a member a literal key of an element access or of `Reflect.get`, `Reflect.set` or `Reflect.has` names. None of them holds back a `#private` member. `analyze` writes the report the Contract's report schema declares, with text, JSON, GitHub annotation, SARIF 2.1.0 and template renderings beside it on request. A scope document passed with `--scope` names the consumers loaded beside the target, each a directory whose compiler configurations open in the same session; a reference from a consumer keeps a target declaration live, the report names every consumer it loaded, and a consumer that is absent or does not load ends the run with exit code 3. A library target's published API is `certain` once every declared consumer loads and `possible` with no consumer information, and in that second case `DS1001` defaults to `allow` and the narrowing kinds report only in files no manifest export reaches. `explain` answers why one declaration is reported, retained, live or dead, from the same analysis the report is built from. `describe` prints the analyzer's description with its conformance record over the published corpus and the declared gaps `conformance.json` lists. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process. The one runtime dependency is the `typescript` package at exactly 7.0.2, installed under the `@typescript/native` name until TypeScript 7.1 ships a compiler API the tooling can share.
+**Status: pre-release.** This version implements contract 4.0.0 and ships the analyzer's foundation: one compiler session per run over the projects `analysis.configurations` declares, in the order it lists them, each a compiler configuration file below the target, or, where it declares none, every `tsconfig` project discovered under the target (the explicit scope, every `tsconfig*.json`, each project's `references`), a fail-closed read of every project's diagnostics, where a discovered project whose configuration names no input, carries an option the compiler refuses or cannot be read is dropped, named in the report's `configurations_not_built` with its error and on standard error, and the rest analyzed, while a project `analysis.configurations` or the scope names ends the run with exit code 3, configuration decoding against the contract's closed key list with `print-config` and its provenance, `print-projects`, the report-only guard, the symbol inventory of every declaration a project's own files hold down to its class and type members, the one-pass reference resolution over that inventory, which resolves each file's identifiers in batches ([batch-cap calibration](docs/batch-cap-calibration.md) is the measurement behind the batch size), and the root set `print-roots` prints. A root is a declaration the analysis keeps live without a reference: what a file exports when the manifest names it through `main`, `module`, `types`, `bin` or `exports`, or when `ts.entry_files` matches it; a library target's published API; the configuration, setup and test files of Vitest, Stryker and Playwright, the flat configuration of ESLint, and a worker or service worker a call addresses by a string literal; and every declaration a `roots.patterns` entry names. An entry that names nothing is reported as `DS1704` and fails the run. The entry-point conventions of other tools are not read, and `DECLINED_CONVENTIONS` lists each one with the reason. Seven exemption classes hold a declaration back from the sweep, and `print-retained` lists what each one held back: `interface-satisfaction`, a member an interface requires of a class whose value reaches that interface; `decorator`, a decorated member and every member of a decorated class; `injection-container`, a decorated property of a class a dependency-injection container constructs, being a class passed to a call `ts.injection_registrations` names or one a parameter of whose constructor carries a decorator; `framework-lifecycle`, a member a `ts.lifecycle_contracts` entry lists, on a class that is the entry's component by a decorator or a call the entry names or by extending a class it names; `serialization-contract`, the properties of a class whose values reach `JSON.stringify` or a declaration `ts.serializers` names, and those and its `toJSON` and `toString` where a value is passed to an `unknown` or `any` parameter of a function outside the analysis; and, at the lowest confidence, `template-field`, a member an action of a template under `analysis.template_dirs` names, and `reflective-lookup`, a member a literal key of an element access or of `Reflect.get`, `Reflect.set` or `Reflect.has` names. None of them holds back a `#private` member. `analyze` writes the report the Contract's report schema declares, with text, JSON, GitHub annotation, SARIF 2.1.0 and template renderings beside it on request. A scope document passed with `--scope` names the consumers loaded beside the target, each a directory whose compiler configurations open in the same session; a reference from a consumer keeps a target declaration live, the report names every consumer it loaded, and a consumer that is absent or does not load ends the run with exit code 3. A library target's published API is `certain` once every declared consumer loads and `possible` with no consumer information, and in that second case `DS1001` defaults to `allow` and the narrowing kinds report only in files no manifest export reaches. `explain` answers why one declaration is reported, retained, held by an unanswered question, live or dead, from the same analysis the report is built from. `describe` prints the analyzer's description with its conformance record over the published corpus and the declared gaps `conformance.json` lists. The analysis is reached through the command, and through `run()` for a caller that runs the command in-process. Every question the analysis asks the compiler is guarded: a question the compiler server fails on is answered as unknown, every declaration that answer could have kept live is kept live and reported by nothing, as is every declaration only those keep live or whose own references went unanswered, and standard error counts the unanswered questions by project. The one runtime dependency is the `typescript` package at exactly 7.1.0-dev.20261003.1, installed under the `@typescript/native` name.
 
 ## Install
 
@@ -28,7 +28,7 @@ The npm package carries the command and the library as JavaScript that the compi
 npx deadset-ts version
 ```
 
-`version` prints the analyzer version and the Contract version it implements, and exits 0. `print-config`, `print-projects`, `print-roots` and `print-retained` print what their row of the table says and exit 0, or 1 when `print-roots` reports a `DS1704`, and `print-retained` exits 2 when an `exemptions.disabled` entry is not an exemption class or an `analysis.template_dirs` entry is not a directory below the target root. `analyze --report=PATH` writes the JSON report to `PATH` through a temporary file renamed into place, each `--format` rendering at `PATH` with its suffix appended (`text` as `.txt`, `json` as `.json`, `github` as `.annotations` in GitHub workflow-command form, `sarif` as `.sarif`, and `template` as `.tmpl`, rendering the file `--template=FILE` names, written in a subset of Go's `text/template` action grammar over the report's JSON member names), and with `--baseline-write=FILE` a baseline of every finding; it writes nothing to standard output and exits with the Contract's exit-code table: 0 clean, 1 for a finding at or above `reporters.fail_on` or a stale suppression, 2 for a usage error, including a template that cannot be read or does not parse, 3 for a failed load or a rendering that cannot be written, and 4 for a pending finding, which outranks 1. `--exit-code=off` exits 0 whatever the verdict and names the verdict on standard error. The report names the target relative to the directory the run is invoked from, so a target outside that directory fails with 3. `describe` writes its JSON document to standard output and exits 0. `explain --why=SYM`, or the same request spelled `--why-live=SYM` or `--why-not=SYM`, prints why that one declaration is reported, retained, live or dead, with the shortest reference path from a root or a loaded consumer for a live one, and exits 0; a request that names no one declaration exits 2 and lists up to 20 declarations it partially matches. Any other invocation and no arguments print the usage line and exit 2.
+`version` prints the analyzer version and the Contract version it implements, and exits 0. `print-config`, `print-projects`, `print-roots` and `print-retained` print what their row of the table says and exit 0, or 1 when `print-roots` reports a `DS1704`, and `print-retained` exits 2 when an `exemptions.disabled` entry is not an exemption class or an `analysis.template_dirs` entry is not a directory below the target root. `analyze --report=PATH` writes the JSON report to `PATH` through a temporary file renamed into place, each `--format` rendering at `PATH` with its suffix appended (`text` as `.txt`, `json` as `.json`, `github` as `.annotations` in GitHub workflow-command form, `sarif` as `.sarif`, and `template` as `.tmpl`, rendering the file `--template=FILE` names, written in a subset of Go's `text/template` action grammar over the report's JSON member names), and with `--baseline-write=FILE` a baseline of every finding; it writes nothing to standard output and exits with the Contract's exit-code table: 0 clean, 1 for a finding at or above `reporters.fail_on` or a stale suppression, 2 for a usage error, including a template that cannot be read or does not parse, 3 for a failed load or a rendering that cannot be written, and 4 for a pending finding, which outranks 1. `--exit-code=off` exits 0 whatever the verdict and names the verdict on standard error. The report names the target relative to the directory the run is invoked from, so a target outside that directory fails with 3. `describe` writes its JSON document to standard output and exits 0. `explain --why=SYM`, or the same request spelled `--why-live=SYM` or `--why-not=SYM`, prints why that one declaration is reported, retained, held by an unanswered question, live or dead, with the shortest reference path from a root or a loaded consumer for a live one, and exits 0; a request that names no one declaration exits 2 and lists up to 20 declarations it partially matches. Any other invocation and no arguments print the usage line and exit 2.
 
 | Verb             | Job                                                                                |
 | ---------------- | ---------------------------------------------------------------------------------- |
@@ -44,7 +44,7 @@ npx deadset-ts version
 ## Requirements
 
 - Node.js 24 or later. The npm command is JavaScript the compiler emits at publish, so it runs with no loader and no flag; a clone of this repository runs the same command from its TypeScript sources through Node's own type stripping, which is what needs the version.
-- TypeScript 7. The analyzer is written against the `typescript` package at exactly version 7.0.2 and its `unstable/*` API. It does not run on TypeScript 6, whose compiler API TypeScript 7 removed, and it does not fall back to it.
+- TypeScript 7. The analyzer is written against the `typescript` package at exactly version 7.1.0-dev.20261003.1 and its `unstable/*` API. It does not run on TypeScript 6, whose compiler API TypeScript 7 removed, and it does not fall back to it.
 - Linux. Other platforms are untested.
 
 ## API

package/dist/bin/node-host.js

@@ -47,18 +47,21 @@ function readVersion() {
 /** The mode every document the command writes carries. */
 const DOCUMENT_MODE = 0o644;
 /**
- * Writes one document through a temporary file in the same directory, flushed and then
- * renamed into place, so a run that dies partway leaves no truncated document at the path.
+ * Writes one document through a temporary file in the same directory, piece by piece,
+ * flushed and then renamed into place, so a run that dies partway leaves no truncated
+ * document at the path.
  */
-function writeAtomically(path, text) {
+function writeAtomically(path, pieces) {
     const temporary = join(dirname(path), `.${basename(path)}.${randomBytes(6).toString("hex")}`);
     const fd = openSync(temporary, "wx", DOCUMENT_MODE);
     try {
         try {
             fchmodSync(fd, DOCUMENT_MODE);
-            const bytes = Buffer.from(text, "utf8");
-            for (let written = 0; written < bytes.length;) {
-                written += writeSync(fd, bytes, written);
+            for (const piece of pieces) {
+                const bytes = Buffer.from(piece, "utf8");
+                for (let written = 0; written < bytes.length;) {
+                    written += writeSync(fd, bytes, written);
+                }
             }
             fsyncSync(fd);
         }
@@ -99,6 +102,6 @@ export function nodeHost() {
             found ??= readVersion();
             return found;
         },
-        writeFile: writeAtomically,
+        writeDocument: writeAtomically,
     };
 }

package/dist/src/alias-chain.js

@@ -3,8 +3,10 @@
  * declaration of the target it is, and along the chain of aliases it heads to each
  * declaration every link of that chain is.
  */
+import { isExportAssignment, isExportSpecifier, isIdentifier, isImportClause, isImportSpecifier, isNamespaceExport, isNamespaceImport, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
-import { nodeKey } from "./inventory.js";
+import { declarationsByName, nodeKey } from "./inventory.js";
+import { UNANSWERED } from "./query.js";
 /**
  * The chain walks over one project, against the declarations of `held`, the same
  * project's inventory.
@@ -14,7 +16,7 @@ import { nodeKey } from "./inventory.js";
  * library file is never fetched to find out that the inventory does not hold it.
  */
 export function aliasChains(project, held) {
-    const ownFiles = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const ownFiles = project.ownPaths();
     const steps = new Map();
     const chains = new Map();
     let asked = 0;
@@ -50,23 +52,68 @@ export function aliasChains(project, held) {
         steps.set(symbol.id, next);
         return next;
     };
+    const files = held.symbols.filter((one) => one.kind === "file").map((one) => one.id);
+    /**
+     * The declarations an alias whose step went unanswered may stand for: every one the
+     * inventory holds under its own name or the name it carries forward, and every file
+     * where it carries a module, so a use through it still counts for what it reaches.
+     */
+    const sameNamed = (alias) => {
+        const names = new Set([alias.name]);
+        let module = false;
+        for (const handle of alias.declarations) {
+            const node = ownFiles.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+            if (node === undefined) {
+                continue;
+            }
+            if ((isImportSpecifier(node) || isExportSpecifier(node)) && node.propertyName !== undefined) {
+                names.add(node.propertyName.text);
+            }
+            else if (isImportClause(node)) {
+                names.add("default");
+            }
+            else if (isNamespaceImport(node) || isNamespaceExport(node)) {
+                module = true;
+            }
+            else if (isExportAssignment(node) && isIdentifier(node.expression)) {
+                names.add(node.expression.text);
+            }
+        }
+        const byName = declarationsByName(held);
+        const ids = [...names].flatMap((name) => byName.get(name) ?? []);
+        return [...new Set([...ids, ...(module ? files : [])])].map((id) => ({
+            id,
+            stepped: true,
+            guessed: true,
+        }));
+    };
     const chainOf = (symbol) => {
         const cached = chains.get(symbol.id);
         if (cached !== undefined) {
             return cached;
         }
         const targets = [];
+        const add = (id, stepped, guessed = false) => {
+            if (!targets.some((target) => target.id === id)) {
+                targets.push({ id, stepped, guessed });
+            }
+        };
         const walked = new Set();
         let at = symbol;
         let stepped = false;
         while (at !== undefined && !walked.has(at.id)) {
             walked.add(at.id);
             for (const id of declarationsOf(at)) {
-                if (!targets.some((target) => target.id === id)) {
-                    targets.push({ id, stepped });
+                add(id, stepped);
+            }
+            const next = stepOf(at);
+            if (next === UNANSWERED) {
+                for (const target of sameNamed(at)) {
+                    add(target.id, true, true);
                 }
+                break;
             }
-            at = stepOf(at);
+            at = next;
             stepped = true;
         }
         chains.set(symbol.id, targets);
@@ -74,13 +121,18 @@ export function aliasChains(project, held) {
     };
     const nextDeclared = (symbol) => {
         const walked = new Set([symbol.id]);
+        let from = symbol;
         let at = stepOf(symbol);
-        while (at !== undefined && !walked.has(at.id)) {
+        while (at !== undefined && (at === UNANSWERED || !walked.has(at.id))) {
+            if (at === UNANSWERED) {
+                return sameNamed(from);
+            }
             walked.add(at.id);
             const ids = declarationsOf(at);
             if (ids.length > 0) {
-                return ids;
+                return ids.map((id) => ({ id, stepped: true, guessed: false }));
             }
+            from = at;
             at = stepOf(at);
         }
         return [];

package/dist/src/analysis.js

@@ -12,10 +12,10 @@ import { configuredDeclarations, configuredRef, declarationsNamed, } from "./con
 import { decorator } from "./decorator.js";
 import { dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
-import { diagnosticErrors, discoverProjects, DiscoveryError } from "./discover.js";
+import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
-import { computeExemptions, disabledClasses, exemptionsOf, retainedIn, } from "./exempt.js";
+import { computeExemptions, disabledClasses, exemptionsOf, isUnansweredRecord, retainedIn, } from "./exempt.js";
 import { heldByInclusion, sourceTree } from "./file-facts.js";
 import { findingsPass, recordedFindings, rowKey } from "./findings-pass.js";
 import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js";
@@ -63,12 +63,12 @@ function compare(a, b) {
     return a < b ? -1 : 1;
 }
 /**
- * Reads every project the scope discovers, and every project of every consumer it
- * declares, in one snapshot. Each is checked for errors first. A target project is then
- * enumerated and rooted, and `stage` reads the rest of what it needs from the project
- * while its view is open; a consumer project is read for its references to the target's
- * declarations. A project carrying an error fails the run with no answer, as every verb
- * that reads declarations does, and so does a declared consumer that cannot be loaded.
+ * Reads every project the scope discovers, and every project of each consumer it
+ * declares, in one snapshot, each checked for errors first. A target project is
+ * enumerated, rooted and handed to `stage`; a consumer project is read for its references
+ * to the target. A guess that does not load is dropped into `notBuilt` (see
+ * {@link isGuess}); any other project that does not load or carries an error fails the
+ * run, as does a run whose every guess was dropped.
  */
 function readProjects(engine, host, scope, config, stage) {
     const targetRoot = scope.target.path;
@@ -83,15 +83,31 @@ function readProjects(engine, host, scope, config, stage) {
         testFiles: config.ts.testFiles,
         publishedAPI: config.targetKind === "library",
     };
+    const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
+    const notBuilt = [...discovered.notBuilt];
+    const dropped = (configFile, error) => {
+        notBuilt.push({
+            id: ids.get(configFile) ?? configFile,
+            configFile,
+            error: targetRelative(error, absoluteRoot),
+        });
+    };
     const failures = [];
     const consumed = new Map();
-    const { projects } = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (project) => {
-        const errors = diagnosticErrors(diagnosticsOf(project));
-        if (errors.length > 0) {
-            failures.push(...errors);
+    const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (project) => {
+        const errors = projectErrors(diagnosticsOf(project));
+        const consumer = consumerOf.get(project.configFile);
+        const [unloaded] = errors.load;
+        if (unloaded !== undefined &&
+            consumer === undefined &&
+            isGuess(discovered, project.configFile)) {
+            dropped(project.configFile, renderDiagnostic(unloaded, (path) => relativePath(absoluteRoot, path) ?? path));
+            return undefined;
+        }
+        if (errors.load.length > 0 || errors.check.length > 0) {
+            failures.push(...errors.load, ...errors.check);
             return undefined;
         }
-        const consumer = consumerOf.get(project.configFile);
         if (consumer !== undefined) {
             for (const reference of consumerReferences(project, host, targetRoot, {
                 id: consumer.id,
@@ -105,16 +121,29 @@ function readProjects(engine, host, scope, config, stage) {
         const rooted = roots(project, held, targetRoot, options);
         const configuration = ids.get(project.configFile) ?? project.configFile;
         return stage(project, { configuration, configFile: project.configFile, held, rooted });
-    });
+    }, discovered.derived ? "record" : "refuse");
+    for (const configFile of session.unopened) {
+        if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
+            throw new DiscoveryError(`${configFile} opened no project`, []);
+        }
+        dropped(configFile, "the compiler opened no project for the configuration");
+    }
     if (failures.length > 0) {
         throw new DiscoveryError(`${String(failures.length)} error(s); no answer was produced`, failures);
     }
+    const answers = session.projects.filter((answer) => answer !== undefined);
+    const [first] = notBuilt;
+    if (answers.length === 0 && first !== undefined) {
+        throw new DiscoveryError(`no configuration discovery derived could be built; ${first.id}: ${first.error}`, []);
+    }
     return {
-        answers: projects.filter((answer) => answer !== undefined),
+        answers,
         consumers: {
             loaded: loads.map((load) => load.consumer),
             references: [...consumed.values()],
         },
+        notBuilt,
+        unanswered: session.unanswered,
     };
 }
 /**
@@ -125,7 +154,8 @@ function readProjects(engine, host, scope, config, stage) {
  */
 export function runRoots(engine, host, scope, config, provenance) {
     const targetRoot = scope.target.path;
-    const projects = readProjects(engine, host, scope, config, (_project, read) => read).answers;
+    const read = readProjects(engine, host, scope, config, (_project, projectRead) => projectRead);
+    const projects = read.answers;
     const configurations = [];
     const merged = new Map();
     for (const answer of projects) {
@@ -159,6 +189,8 @@ export function runRoots(engine, host, scope, config, provenance) {
         configurations,
         roots: ordered,
         findings: unmatchedRootFindings(unmatched, documentOf(host, provenance, ROOTS_SETTING, targetRoot)),
+        notBuilt: read.notBuilt,
+        unanswered: read.unanswered,
     };
 }
 /** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
@@ -201,10 +233,19 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             mode,
             testFiles: new Set(resolved.testFilePaths),
         });
+        const unanswered = [
+            ...projectRead.held.unanswered,
+            ...projectRead.rooted.unanswered,
+            ...resolved.references
+                .filter((reference) => reference.resolution === "by-name")
+                .map((reference) => reference.to),
+            ...exempt.filter(isUnansweredRecord).map((record) => record.id),
+        ];
         return {
             configFile: projectRead.configFile,
             configured,
             exempt,
+            unanswered,
             extra: extra(project, projectRead, resolved.references),
         };
     });
@@ -221,17 +262,64 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     return {
         matrix: matrixOf(projects.map((one) => one.configured)),
         exempt: exemptionsOf(projects.flatMap((one) => one.exempt)),
+        unansweredHeld: [
+            ...new Set([
+                ...read.answers.flatMap((one) => one.unanswered),
+                ...consumed.filter((one) => one.resolution === "by-name").map((one) => one.to),
+            ]),
+        ],
         projects,
         consumers: read.consumers.loaded,
+        notBuilt: read.notBuilt,
+        unanswered: read.unanswered,
     };
 }
-/** The sweep of a run read once, under one set of marks. */
+/**
+ * The sweep of a run read once, under one set of marks. Where a question went unanswered,
+ * the run is swept once more without what that question could have kept live and without
+ * the references that stood in for its answer, and every declaration that sweep judges
+ * dead and this one judges live, or dead by another rule, is held by the gap too, as is
+ * every declaration that makes such a reference.
+ */
 function sweptOf(read, input) {
-    const swept = { ...input, exempt: read.exempt };
+    const swept = { ...input, exempt: read.exempt, unanswered: read.unansweredHeld };
+    const result = sweepMatrix(read.matrix, swept);
+    const held = new Set(read.unansweredHeld);
+    if (held.size > 0) {
+        // What a declaration reads where the checker did not answer is unknown, so a rule
+        // over what it reads, the test of dead code among them, cannot judge it.
+        for (const { configured } of read.projects) {
+            for (const reference of configured.references) {
+                if (reference.resolution === "by-name") {
+                    held.add(reference.from);
+                }
+            }
+        }
+        const dead = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
+        const answered = matrixOf(read.projects.map(({ configured }) => ({
+            ...configured,
+            references: configured.references.filter((one) => one.resolution !== "by-name"),
+        })));
+        const bare = {
+            ...swept,
+            exempt: read.exempt.filter((record) => !isUnansweredRecord(record)),
+            unanswered: [],
+        };
+        for (const candidate of sweepMatrix(answered, bare).candidates) {
+            const kept = dead.get(candidate.id);
+            if (kept?.testOfDeadCode !== candidate.testOfDeadCode ||
+                kept.relation !== candidate.relation) {
+                held.add(candidate.id);
+            }
+        }
+    }
     return {
         matrix: read.matrix,
-        sweep: sweepMatrix(read.matrix, swept),
+        sweep: result,
         retained: retainedIn(read.matrix, swept),
+        notBuilt: read.notBuilt,
+        unanswered: read.unanswered,
+        heldByUnanswered: [...held],
     };
 }
 /**
@@ -250,8 +338,8 @@ export function runSweep(engine, host, scope, config, input, detectors = DETECTO
 /** Reads a run's projects with every per-project fact an emitter reads. */
 function readEmitterRun(engine, host, scope, config, mode, detectors) {
     const targetRoot = scope.target.path;
-    return readRun(engine, host, scope, config, mode, detectors, (project, read, references) => ({
-        deprecated: deprecatedDeclarations(project, read.held),
+    const run = readRun(engine, host, scope, config, mode, detectors, (project, read, references) => ({
+        deprecation: deprecatedDeclarations(project, read.held),
         accessors: accessorsOf(project, read.held),
         needs: projectNeeds(project, read.held, host),
         implementations: implementations(project, read.held),
@@ -261,6 +349,12 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
         declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
         parts: projectParts(project, read.held, references, targetRoot),
     }));
+    // Whether a declaration carries the marker decides its code, so one whose marker went
+    // unread is reported by nothing.
+    const unread = run.projects.flatMap((one) => one.extra.deprecation.unanswered);
+    return unread.length === 0
+        ? run
+        : { ...run, unansweredHeld: [...new Set([...run.unansweredHeld, ...unread])] };
 }
 /**
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
@@ -273,7 +367,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
     return {
         config,
         swept,
-        deprecated: new Set(projects.flatMap((one) => one.extra.deprecated)),
+        deprecated: new Set(projects.flatMap((one) => one.extra.deprecation.deprecated)),
         stores: storesOf(projects.map((one) => ({
             references: one.configured.references,
             accessors: one.extra.accessors,
@@ -293,7 +387,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
             edges: readEdgeSides(host, targetRoot),
         },
         selfCheck,
-        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set(read.exempt.map((one) => one.id))),
+        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...read.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
     };
 }
 /**
@@ -332,6 +426,8 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             })),
             testFileRules: testFileRulesOf(config.ts.testFiles, read.projects.flatMap((one) => one.configured.testFiles)),
             consumers: read.consumers,
+            notBuilt: read.notBuilt,
+            unanswered: read.unanswered,
         },
         configured: read.projects.map((one) => one.configured),
         symbols,

package/dist/src/calls.js

@@ -8,7 +8,7 @@
 import { isArrayLiteralExpression, isCallExpression, isClassDeclaration, isDecorator, isIdentifier, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadElement, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { nodeKey } from "./inventory.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { must } from "./query.js";
 /** The name node a callee or a decorator expression resolves through, where it has one. */
 export function calleeName(expression) {
     if (isParenthesizedExpression(expression)) {
@@ -37,31 +37,32 @@ export function decoratorsOf(node) {
 /**
  * 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.
+ * 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(project, nodes) {
     const followed = new Map();
     const targets = new Map();
-    for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-        const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
-        project.symbolsAt(run.map((node) => project.handle(node))).forEach((symbol, index) => {
-            const node = run[index];
-            if (symbol === undefined || node === undefined) {
-                return;
-            }
-            let target = symbol;
-            if ((symbol.flags & SymbolFlags.Alias) !== 0) {
-                if (!followed.has(symbol.id)) {
-                    const aliased = project.checker.getAliasedSymbol(symbol);
-                    followed.set(symbol.id, aliased.declarations.length === 0 ? undefined : aliased);
-                }
-                target = followed.get(symbol.id);
-            }
-            if (target !== undefined) {
-                targets.set(node, target);
+    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 = 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;
 }
 /** The values one expression passes: itself, or what an array or object literal holds. */
@@ -109,7 +110,7 @@ export function classesPassed(project, held, chains, calls) {
     const classes = new Set(held.symbols.filter((symbol) => symbol.kind === "class").map((symbol) => symbol.id));
     const classesOf = (value) => {
         const symbol = value.shorthand
-            ? project.shorthandValueAt(project.handle(value.name))
+            ? must(project.shorthandValueAt(project.handle(value.name)))
             : targets.get(value.name);
         return symbol === undefined
             ? []

package/dist/src/class-members.js

@@ -5,7 +5,7 @@
  */
 import { isClassDeclaration, isClassExpression } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { must } from "./query.js";
 /** The name node of each class declaration of the target, by the class's identifier. */
 export function classNames(project, held) {
     const names = new Map();
@@ -23,13 +23,12 @@ export function classNames(project, held) {
     }
     return names;
 }
-/** The types of a batch of nodes, asked in capped batches. */
+/**
+ * The types of a batch of nodes, for a pass that cannot go on past a type the checker
+ * did not answer: it stops there, as {@link must} stops.
+ */
 export function typesAt(project, nodes) {
-    const types = [];
-    for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-        types.push(...project.checker.getTypeAtLocation(nodes.slice(from, from + DEFAULT_BATCH_CAP)));
-    }
-    return types;
+    return project.queries.typesAt(nodes).map(must);
 }
 /**
  * The type one side of each class is: the instance type at the class's name, or the
@@ -39,9 +38,9 @@ function sideTypes(project, nodes, side) {
     if (side === "instance") {
         return typesAt(project, nodes);
     }
-    const symbols = project.symbolsAt(nodes.map((node) => project.handle(node)));
+    const symbols = project.symbolsAt(nodes.map((node) => project.handle(node))).map(must);
     const present = symbols.filter((symbol) => symbol !== undefined);
-    const types = present.length === 0 ? [] : project.checker.getTypeOfSymbol(present);
+    const types = project.queries.typesOfSymbols(present).map(must);
     let next = 0;
     return symbols.map((symbol) => (symbol === undefined ? undefined : types[next++]));
 }
@@ -52,7 +51,7 @@ function sideTypes(project, nodes, side) {
  */
 export function classMembers(project, held, classIds, side) {
     const named = [...classNames(project, held)].filter(([id]) => classIds.has(id));
-    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const own = project.ownPaths();
     const types = sideTypes(project, named.map(([, node]) => node), side);
     const members = new Map();
     named.forEach(([id], index) => {
@@ -61,7 +60,7 @@ export function classMembers(project, held, classIds, side) {
             return;
         }
         const found = [];
-        for (const property of project.checker.getPropertiesOfType(type)) {
+        for (const property of must(project.queries.propertiesOf(type))) {
             for (const handle of property.declarations) {
                 if (!own.has(handle.path)) {
                     continue;