@cplieger/deadset-ts 4.0.1 → 5.0.0

package/README.md

@@ -4,7 +4,7 @@
 
 deadset-ts finds dead code in TypeScript projects, down to class members, type members and dead stores inside functions, and writes a report your CI can fail on.
 
-It reads your `tsconfig.json` projects, `allowJs` JavaScript included, with the type information of TypeScript 7.1.0-dev.20261003.1, its one dependency. Your project keeps its own TypeScript version and must also compile under that version. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
+It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261003.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
 
 ## Why use it
 
@@ -17,7 +17,7 @@ deadset-ts is built for a CI gate on dead code. Each finding names code to delet
 - The same tree gives the same report, and a baseline keyed on code and symbol survives moved lines.
 - It writes text, JSON, GitHub annotations, SARIF 2.1.0 or a custom template.
 
-Consider [Knip](https://knip.dev) if you want issues fixed with `--fix`, plugins for over 100 tools, or Astro, MDX, Svelte and Vue files checked.
+Consider [Knip](https://knip.dev) if you want issues fixed with `--fix`, plugins for over 100 tools, or MDX files checked.
 
 ## Install
 
@@ -90,7 +90,7 @@ A TypeScript caller that imports the source sets `allowImportingTsExtensions`, b
 
 ## Related projects
 
-deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset-spec), which fixes the issue codes, the report schema and the exit codes. It passes the Contract's conformance corpus except one reflective-lookup fixture, the gap [`conformance.json`](conformance.json) declares.
+deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset-spec), which fixes the issue codes, the report schema and the exit codes. It passes every fixture of the Contract's conformance corpus except one reflective-lookup fixture, the gap [`conformance.json`](conformance.json) declares.
 
 - [deadset-go](https://github.com/cplieger/deadset-go) is the same analysis for Go modules.
 - [deadset](https://github.com/cplieger/deadset) runs both analyzers as one command and merges their reports, resolving the edges between Go and TypeScript code.
@@ -105,7 +105,7 @@ deadset-ts implements the [deadset Contract](https://github.com/cplieger/deadset
 
 ## Contributing
 
-See [CONTRIBUTING.md](https://github.com/cplieger/.github/blob/main/CONTRIBUTING.md).
+See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## Disclaimer
 

package/dist/bin/component-mapper.js

@@ -0,0 +1,5 @@
+import { mapperConnection } from "./mapper-connection.js";
+const connection = mapperConnection((bytes) => process.stdout.write(bytes));
+process.stdin.on("data", (chunk) => {
+    connection.receive(chunk);
+});

package/dist/bin/mapper-connection.js

@@ -0,0 +1,101 @@
+/**
+ * The content mapper the compiler runs for component files: JSON-RPC 2.0 messages, each
+ * framed by a `Content-Length` header, over the process's standard streams. It answers
+ * `transform` with {@link componentModule} and keeps no state between requests.
+ * The protocol is the compiler's own:
+ * https://github.com/microsoft/TypeScript/blob/f9f8d01292562242b6e7c7142e46ed7e470926f9/tsc/internal/contentmapper/hostimpl.go
+ */
+import { componentModule } from "../src/component-files.js";
+/** The JSON-RPC code of a method this mapper does not serve. */
+const METHOD_NOT_FOUND = -32601;
+/** The JSON-RPC code of a request whose parameters are not the protocol's. */
+const INVALID_PARAMS = -32602;
+const HEADER_END = new Uint8Array([0x0d, 0x0a, 0x0d, 0x0a]);
+/** The offset of `needle` in `bytes` at or after `from`, or -1. */
+function indexOf(bytes, needle, from) {
+    outer: for (let at = from; at + needle.length <= bytes.length; at += 1) {
+        for (let index = 0; index < needle.length; index += 1) {
+            if (bytes[at + index] !== needle[index]) {
+                continue outer;
+            }
+        }
+        return at;
+    }
+    return -1;
+}
+/** The answer to one message, or undefined for a notification, which takes none. */
+function answer(message) {
+    if (message.id === undefined) {
+        return undefined;
+    }
+    const reply = (result) => ({ jsonrpc: "2.0", id: message.id, result });
+    const fail = (code, text) => ({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: { code, message: text },
+    });
+    switch (message.method) {
+        case "initialize":
+            return reply({ positionEncoding: "utf-16", diagnosticSource: "deadset-ts" });
+        case "openProject":
+            return reply({});
+        case "closeProject":
+            return reply(null);
+        case "transform": {
+            const content = typeof message.params === "object" && message.params !== null
+                ? message.params.content
+                : undefined;
+            if (typeof content !== "string") {
+                return fail(INVALID_PARAMS, "transform: params.content is not a string");
+            }
+            const module = componentModule(content);
+            return reply({ text: module.text, extension: module.extension, mappings: module.mappings });
+        }
+        default:
+            return fail(METHOD_NOT_FOUND, `no method ${JSON.stringify(message.method)}`);
+    }
+}
+/**
+ * A connection over one byte stream. A message whose body is not JSON is answered with
+ * nothing, because it carries no id to answer to.
+ */
+export function mapperConnection(write) {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    let pending = new Uint8Array(0);
+    return {
+        receive(chunk) {
+            const joined = new Uint8Array(pending.length + chunk.length);
+            joined.set(pending);
+            joined.set(chunk, pending.length);
+            pending = joined;
+            for (;;) {
+                const headerEnd = indexOf(pending, HEADER_END, 0);
+                if (headerEnd < 0) {
+                    return;
+                }
+                const header = decoder.decode(pending.subarray(0, headerEnd));
+                const length = Number(/content-length:\s*(\d+)/iu.exec(header)?.[1] ?? "0");
+                const bodyStart = headerEnd + HEADER_END.length;
+                if (pending.length < bodyStart + length) {
+                    return;
+                }
+                const body = decoder.decode(pending.subarray(bodyStart, bodyStart + length));
+                pending = pending.slice(bodyStart + length);
+                let message;
+                try {
+                    message = JSON.parse(body);
+                }
+                catch {
+                    continue;
+                }
+                const reply = answer(message);
+                if (reply !== undefined) {
+                    const bytes = encoder.encode(JSON.stringify(reply));
+                    write(encoder.encode(`Content-Length: ${String(bytes.length)}\r\n\r\n`));
+                    write(bytes);
+                }
+            }
+        },
+    };
+}

package/dist/bin/node-host.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, fchmodSync, fsyncSync, openSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { closeSync, fchmodSync, fsyncSync, mkdtempSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 /** The name the manifest of this package declares. */
 const PACKAGE_NAME = "@cplieger/deadset-ts";
@@ -75,6 +76,24 @@ function writeAtomically(path, pieces) {
         throw error;
     }
 }
+/** A new directory under the platform's temporary directory. */
+function temporaryDirectory() {
+    const path = mkdtempSync(join(tmpdir(), "deadset-ts-mapper-"));
+    return {
+        path,
+        remove: () => {
+            rmSync(path, { recursive: true, force: true });
+        },
+    };
+}
+/**
+ * The mapper beside this file, in the same form: the emitted tree runs the emitted
+ * mapper and a checkout runs the source through the runtime's own type stripping.
+ */
+function componentMapperCommand() {
+    const here = fileURLToPath(import.meta.url);
+    return [process.execPath, join(dirname(here), `component-mapper${extname(here)}`)];
+}
 /**
  * The filesystem of the platform the command runs on, and the version of the
  * package it was installed from.
@@ -98,10 +117,13 @@ export function nodeHost() {
             }
             return stat.isDirectory() ? "directory" : "file";
         },
+        realPath: (path) => realpathSync(path),
         analyzerVersion: () => {
             found ??= readVersion();
             return found;
         },
         writeDocument: writeAtomically,
+        temporaryDirectory,
+        componentMapperCommand,
     };
 }

package/dist/src/analysis.js

@@ -7,15 +7,17 @@
  * carries a project's identity in its type so a handle cannot cross to another
  * project's checker, and that holds only for views the session itself hands out.
  */
+import { lineOf, readComponent } from "./component-files.js";
 import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
 import { configuredDeclarations, configuredRef, declarationsNamed, } from "./configured-declarations.js";
 import { decorator } from "./decorator.js";
 import { dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
 import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
+import { conventionFailuresFor, readConventions, } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
-import { computeExemptions, disabledClasses, exemptionsOf, isUnansweredRecord, retainedIn, } from "./exempt.js";
+import { computeExemptions, disabledClasses, exemptionsOf, holdingWhile, 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";
@@ -26,19 +28,23 @@ import { interfaceSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { readManifest } from "./manifest.js";
-import { matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { relativePath, resolvePath } from "./paths.js";
-import { byPosition } from "./position.js";
+import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
+import { joinPath, relativePath, resolvePath } from "./paths.js";
+import { byPosition, isComponentFile } from "./position.js";
+import { SetupError, setupLine } from "./setup-failure.js";
+import { pathsOf, readErrors, skippedRoots, skippedUnits, } from "./type-errors.js";
 import { reflectiveLookup } from "./reflective-lookup.js";
 import { references, testFileRulesOf } from "./references.js";
 import { roots, unmatchedEverywhere } from "./roots.js";
 import { serializationContract } from "./serialization-contract.js";
-import { diagnosticsOf, runSession } from "./session.js";
+import { supportReferences, testSupportFiles } from "./test-support.js";
+import { diagnosticsOf, ownedAs, runSession } from "./session.js";
 import { accessorsOf, storesOf } from "./stores.js";
 import { isPartKind } from "./suppress.js";
 import { bindRows, readBaseline, readIgnoreFile } from "./suppress-file.js";
 import { inlineDirectives, inlineSuppressions } from "./suppress-inline.js";
 import { readTemplates, templateField } from "./template-field.js";
+import { ownErrors, workspaceRun } from "./workspace-run.js";
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
 /**
@@ -63,12 +69,29 @@ function compare(a, b) {
     return a < b ? -1 : 1;
 }
 /**
- * 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.
+ * The manifests the analysis reads, each once: the target's own, then every workspace
+ * member's below the target root.
+ */
+function conventionManifests(host, targetRoot, memberDirs) {
+    const found = new Map();
+    if (host.kindOf(joinPath(targetRoot, "package.json")) === "file") {
+        found.set(targetRoot, { dir: targetRoot, path: "package.json" });
+    }
+    for (const dir of memberDirs) {
+        const below = relativePath(targetRoot, dir);
+        if (below !== undefined && !found.has(dir)) {
+            found.set(dir, { dir, path: `${below}/package.json` });
+        }
+    }
+    return [...found.values()];
+}
+/**
+ * Reads every project the scope discovers, and each declared consumer's, in one snapshot,
+ * each checked for errors first. `stage` is handed a target project and enumerates and roots
+ * it if it reads it; a consumer project is read for its references to the target. A type error
+ * in an own file skips the unit holding it. A guess that does not load or meets a setup failure
+ * is dropped into `notBuilt` (see {@link isGuess}); any other such project fails the run, as
+ * does a run whose every guess was dropped.
  */
 function readProjects(engine, host, scope, config, stage) {
     const targetRoot = scope.target.path;
@@ -76,14 +99,19 @@ function readProjects(engine, host, scope, config, stage) {
     const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
     const loads = consumerLoads(engine, host, scope, discovered.configFiles);
     const consumerOf = new Map(loads.flatMap((load) => load.configFiles.map((configFile) => [configFile, load.consumer])));
+    const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
+    const workspace = workspaceRun(engine, host, absoluteRoot, discovered.configFiles, readManifest(host, targetRoot));
+    const conventions = readConventions(host, (fileName, text) => engine.parseSourceFile(fileName, text), conventionManifests(host, absoluteRoot, workspace?.memberDirs ?? []), config.ts.disabledConventions);
     const options = {
-        manifest: readManifest(host, targetRoot),
+        host,
+        manifest: workspace?.manifest ?? readManifest(host, targetRoot),
+        workspaceEntries: workspace?.entries,
         patterns: config.rootPatterns,
         entryFiles: config.ts.entryFiles,
+        conventions,
         testFiles: config.ts.testFiles,
         publishedAPI: config.targetKind === "library",
     };
-    const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
     const notBuilt = [...discovered.notBuilt];
     const dropped = (configFile, error) => {
         notBuilt.push({
@@ -93,10 +121,36 @@ function readProjects(engine, host, scope, config, stage) {
         });
     };
     const failures = [];
+    const unbuildable = [];
+    const setupDropped = [];
     const consumed = new Map();
-    const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (project) => {
-        const errors = projectErrors(diagnosticsOf(project));
-        const consumer = consumerOf.get(project.configFile);
+    const setupMet = (configFile, met) => {
+        const [first] = met;
+        if (first !== undefined && isGuess(discovered, configFile)) {
+            dropped(configFile, setupLine(first));
+            setupDropped.push(...met);
+        }
+        else {
+            unbuildable.push(...met);
+        }
+    };
+    const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (opened) => {
+        const consumer = consumerOf.get(opened.configFile);
+        const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
+        if (setup !== undefined) {
+            setupMet(opened.configFile, [
+                { setupClass: "workspace-member-without-source", detail: setup },
+            ]);
+            return undefined;
+        }
+        const referenceOnly = workspace === undefined || consumer !== undefined
+            ? () => false
+            : workspace.referenceOnly(opened.configFile, opened.rootFiles);
+        const project = workspace === undefined || consumer !== undefined
+            ? opened
+            : ownedAs(opened, (file, fromExternalLibrary) => workspace.ownFile(file, fromExternalLibrary));
+        const raw = projectErrors(diagnosticsOf(project));
+        const errors = { load: raw.load, check: ownErrors(raw.check, referenceOnly) };
         const [unloaded] = errors.load;
         if (unloaded !== undefined &&
             consumer === undefined &&
@@ -104,8 +158,37 @@ function readProjects(engine, host, scope, config, stage) {
             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);
+        if (errors.load.length > 0) {
+            failures.push(...errors.load);
+            return undefined;
+        }
+        const reading = readErrors(project, errors.check, {
+            host,
+            targetRoot: consumer === undefined
+                ? absoluteRoot
+                : resolvePath(host.workingDirectory(), consumer.path),
+            paths: pathsOf(engine, project.configFile),
+        });
+        if (reading.failing.length > 0) {
+            failures.push(...reading.failing);
+            return undefined;
+        }
+        if (consumer !== undefined && reading.missing.length > 0) {
+            unbuildable.push(...reading.missing.map((one) => ({
+                setupClass: "missing-consumer",
+                detail: `the consumer ${consumer.path} does not build, its dependencies not installed: ${one.detail}`,
+            })));
+            return undefined;
+        }
+        if (reading.missing.length > 0) {
+            setupMet(project.configFile, reading.missing);
+            return undefined;
+        }
+        const unconventional = consumer === undefined
+            ? conventionFailuresFor(conventions, project.configFile, project.ownSourceFiles().map((file) => file.fileName))
+            : [];
+        if (unconventional.length > 0) {
+            setupMet(project.configFile, unconventional);
             return undefined;
         }
         if (consumer !== undefined) {
@@ -117,22 +200,52 @@ function readProjects(engine, host, scope, config, stage) {
             }
             return undefined;
         }
-        const held = inventory(project, host, targetRoot);
-        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");
+        const read = () => {
+            const held = inventory(project, host, targetRoot);
+            const found = roots(project, held, targetRoot, options);
+            const kept = skippedRoots(project, held, reading.skips);
+            const rooted = kept.length === 0
+                ? found
+                : {
+                    ...found,
+                    liveUnderReachability: [
+                        ...found.liveUnderReachability,
+                        ...kept.map((id) => ({ id, kind: "type-error", source: "" })),
+                    ],
+                };
+            return {
+                configuration,
+                configFile: project.configFile,
+                held,
+                rooted,
+                typeErrorSkips: reading.skips.map((one) => one.record),
+                skipped: skippedUnits(reading.skips, absoluteRoot),
+                referenceOnly: project
+                    .ownSourceFiles()
+                    .filter((file) => referenceOnly(file.fileName))
+                    .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
+            };
+        };
+        return stage(project, { configuration, read });
+    }, discovered.derived ? "record" : "refuse", workspace?.programs);
     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 (unbuildable.length > 0) {
+        throw new SetupError(unbuildable);
+    }
     if (failures.length > 0) {
         throw new DiscoveryError(`${String(failures.length)} error(s), so no answer was produced`, failures);
     }
     const answers = session.projects.filter((answer) => answer !== undefined);
     const [first] = notBuilt;
+    if (answers.length === 0 && setupDropped.length > 0) {
+        throw new SetupError(setupDropped);
+    }
     if (answers.length === 0 && first !== undefined) {
         throw new DiscoveryError(`no configuration discovery derived could be built; ${first.id}: ${first.error}`, []);
     }
@@ -144,8 +257,19 @@ function readProjects(engine, host, scope, config, stage) {
         },
         notBuilt,
         unanswered: session.unanswered,
+        componentsUnread: workspace?.componentsUnread ?? [],
+        conventionsApplied: conventions.applied,
     };
 }
+/**
+ * The projects the run the scope and the configuration describe analyzes, each read
+ * for the errors and setup failures that decide whether it is analyzed, dropped or
+ * fails the run, exactly as the analysis reads them.
+ */
+export function runProjects(engine, host, scope, config) {
+    const read = readProjects(engine, host, scope, config, (_project, opened) => opened.configuration);
+    return { configurations: read.answers, notBuilt: read.notBuilt, unanswered: read.unanswered };
+}
 /**
  * The root set of the run the scope and the configuration describe.
  *
@@ -154,7 +278,7 @@ function readProjects(engine, host, scope, config, stage) {
  */
 export function runRoots(engine, host, scope, config, provenance) {
     const targetRoot = scope.target.path;
-    const read = readProjects(engine, host, scope, config, (_project, projectRead) => projectRead);
+    const read = readProjects(engine, host, scope, config, (_project, opened) => opened.read());
     const projects = read.answers;
     const configurations = [];
     const merged = new Map();
@@ -217,36 +341,53 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         ? { delimiters: config.analysis.templateDelimiters, files: [] }
         : readTemplates(host, targetRoot, config.analysis);
     const consumers = scope.consumers.map((consumer) => consumer.path);
-    const read = readProjects(engine, host, scope, config, (project, projectRead) => {
+    const read = readProjects(engine, host, scope, config, (project, opened) => {
+        const projectRead = opened.read();
         const resolved = references(project, projectRead.held, targetRoot, {
             testFiles: config.ts.testFiles,
         });
+        const support = testSupportFiles(projectRead.held.symbols, resolved.references, projectRead.rooted.liveUnderReachability, resolved.testFilePaths);
+        const made = supportReferences(resolved.references, support);
         const configured = {
             configuration: projectRead.configuration,
             symbols: projectRead.held.symbols,
-            references: resolved.references,
+            references: made,
             roots: projectRead.rooted.liveUnderReachability,
             testFiles: resolved.testFilePaths,
+            ...(support.size === 0 ? {} : { supportFiles: [...support].sort() }),
+            ...(projectRead.referenceOnly.length === 0
+                ? {}
+                : { referenceOnly: projectRead.referenceOnly }),
         };
         const exempt = computeExemptions({ project, held: projectRead.held, targetRoot, templates, ts: config.ts, consumers }, detectors, {
             disabled,
             mode,
-            testFiles: new Set(resolved.testFilePaths),
+            testFiles: new Set([...resolved.testFilePaths, ...support]),
         });
         const unanswered = [
             ...projectRead.held.unanswered,
             ...projectRead.rooted.unanswered,
-            ...resolved.references
+            ...made
                 .filter((reference) => reference.resolution === "by-name")
                 .map((reference) => reference.to),
             ...exempt.filter(isUnansweredRecord).map((record) => record.id),
         ];
+        const components = project.ownSourceFiles().filter(isComponentFile);
+        const pathOf = (file) => relativePath(targetRoot, file.fileName) ?? file.fileName;
         return {
             configFile: projectRead.configFile,
             configured,
             exempt,
             unanswered,
-            extra: extra(project, projectRead, resolved.references),
+            typeErrorSkips: projectRead.typeErrorSkips,
+            skipped: projectRead.skipped,
+            componentFiles: components.map(pathOf),
+            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
+                path: pathOf(file),
+                line: lineOf(file.originalText, warning.offset),
+                reason: warning.reason,
+            }))),
+            extra: extra(project, projectRead, made),
         };
     });
     const consumed = read.consumers.references;
@@ -272,8 +413,33 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         consumers: read.consumers.loaded,
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
+        componentsUnread: read.componentsUnread,
+        conventionsApplied: read.conventionsApplied,
     };
 }
+/**
+ * The run swept under one set of marks with the records that hold. A record a component
+ * file's markup holds counts only while the file is live, and what it holds may be what
+ * keeps the file live, so each file's markup joins only once a sweep without it finds the
+ * file live, until a sweep finds no further file live.
+ */
+function holdingSweep(read, input) {
+    const paths = new Set(read.exempt.flatMap((record) => record.whileLive ?? []));
+    let live = new Set();
+    for (;;) {
+        const swept = {
+            ...input,
+            exempt: holdingWhile(read.exempt, live),
+            unanswered: read.unansweredHeld,
+        };
+        const result = sweepMatrix(read.matrix, swept);
+        const next = new Set(liveFilesAt(read.matrix, result, paths).map((one) => one.position.path));
+        if (next.size === live.size) {
+            return { swept, result };
+        }
+        live = next;
+    }
+}
 /**
  * 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
@@ -282,8 +448,8 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
  * every declaration that makes such a reference.
  */
 function sweptOf(read, input) {
-    const swept = { ...input, exempt: read.exempt, unanswered: read.unansweredHeld };
-    const result = sweepMatrix(read.matrix, swept);
+    const { swept, result } = holdingSweep(read, input);
+    const exempt = swept.exempt ?? [];
     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
@@ -302,7 +468,7 @@ function sweptOf(read, input) {
         })));
         const bare = {
             ...swept,
-            exempt: read.exempt.filter((record) => !isUnansweredRecord(record)),
+            exempt: exempt.filter((record) => !isUnansweredRecord(record)),
             unanswered: [],
         };
         for (const candidate of sweepMatrix(answered, bare).candidates) {
@@ -316,10 +482,13 @@ function sweptOf(read, input) {
     return {
         matrix: read.matrix,
         sweep: result,
+        exempt,
         retained: retainedIn(read.matrix, swept),
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
         heldByUnanswered: [...held],
+        skipped: read.projects.flatMap((one) => one.skipped),
+        componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(compare),
     };
 }
 /**
@@ -341,11 +510,11 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
     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),
+        needs: projectNeeds(project, read.held, host, targetRoot),
         implementations: implementations(project, read.held),
         heldByInclusion: heldByInclusion(project, targetRoot),
         rooted: read.rooted,
-        directives: inlineDirectives(project, read.held, targetRoot),
+        directives: inlineDirectives(project, read.held, targetRoot).filter((directive) => !read.referenceOnly.includes(directive.site.path)),
         declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
         parts: projectParts(project, read.held, references, targetRoot),
     }));
@@ -371,7 +540,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
         stores: storesOf(projects.map((one) => ({
             references: one.configured.references,
             accessors: one.extra.accessors,
-        })), read.exempt, input.mode),
+        })), swept.exempt, input.mode),
         dependencies: dependenciesOf(host, targetRoot, projects.map((one) => one.extra.needs), swept.sweep.candidates.map((candidate) => candidate.id)),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
@@ -387,7 +556,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), ...swept.heldByUnanswered])),
+        intraFunction: intraFunctionFacts(projects.map((one) => one.extra.parts), projects.flatMap((one) => one.configured.references), new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered])),
     };
 }
 /**
@@ -424,10 +593,18 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
                 id: one.configured.configuration,
                 configFile: one.configFile,
             })),
-            testFileRules: testFileRulesOf(config.ts.testFiles, read.projects.flatMap((one) => one.configured.testFiles)),
+            testFileRules: testFileRulesOf(config.ts.testFiles, read.projects.flatMap((one) => one.configured.testFiles), read.projects.flatMap((one) => one.configured.supportFiles ?? [])),
+            typeErrorSkips: read.projects.flatMap((one) => one.typeErrorSkips),
+            componentWarnings: [
+                ...new Map(read.projects
+                    .flatMap((one) => one.componentWarnings)
+                    .map((one) => [`${one.path}:${String(one.line)}:${one.reason}`, one])).values(),
+            ],
             consumers: read.consumers,
             notBuilt: read.notBuilt,
             unanswered: read.unanswered,
+            componentsUnread: read.componentsUnread,
+            conventionsApplied: read.conventionsApplied,
         },
         configured: read.projects.map((one) => one.configured),
         symbols,
@@ -475,6 +652,22 @@ export function runAnalysis(engine, host, scope, config, provenance, mode, detec
     const inputs = reader.inputsUnder(readBaseline(host, scope.target.path, reader.symbols));
     return analysisOf(reader, inputs);
 }
+/**
+ * One count per configuration of the run in which the checker left a question unanswered:
+ * the questions asked in its project, and the declarations of its own the run holds for them.
+ */
+export function unansweredCounts(analysis) {
+    const held = new Set(analysis.swept.heldByUnanswered);
+    return analysis.run.projects.flatMap((project) => {
+        const questions = analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length;
+        if (questions === 0) {
+            return [];
+        }
+        const symbols = analysis.configured.find((one) => one.configuration === project.id)?.symbols;
+        const declarations = new Set((symbols ?? []).map((one) => one.id).filter((id) => held.has(id)));
+        return [{ configuration: project.id, questions, declarations: declarations.size }];
+    });
+}
 function analysisOf(reader, inputs) {
     return {
         result: findingsPass(inputs),