@cplieger/deadset-ts 4.0.1 → 5.1.0

package/src/analysis.ts

@@ -8,6 +8,7 @@
  * project's checker, and that holds only for views the session itself hands out.
  */
 
+import { lineOf, readComponent } from "./component-files.ts";
 import type { Config, Provenance } from "./config.ts";
 import {
   consumerLoads,
@@ -33,12 +34,22 @@ import {
   type LocatedDiagnostic,
   type NotBuilt,
 } from "./discover.ts";
+import {
+  conventionFailuresFor,
+  generatedFiles,
+  readConventions,
+  type AppliedConvention,
+  type ConventionManifest,
+} from "./conventions.ts";
 import { readEdgeSides } from "./edges.ts";
 import { enumGroup } from "./enum-group.ts";
+import { generatedFile } from "./generated-file.ts";
+import { sourceFilesOf } from "./source-files.ts";
 import {
-  computeExemptions,
+  detectExemptions,
   disabledClasses,
   exemptionsOf,
+  holdingWhile,
   isUnansweredRecord,
   retainedIn,
   type Detector,
@@ -63,6 +74,7 @@ import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-fun
 import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { readManifest } from "./manifest.ts";
 import {
+  liveFilesAt,
   matrixOf,
   referenceKey,
   sweepMatrix,
@@ -70,21 +82,32 @@ import {
   type Matrix,
   type SweepResult,
 } from "./matrix.ts";
-import { relativePath, resolvePath } from "./paths.ts";
+import { joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
-import { byPosition, type Position } from "./position.ts";
+import { byPosition, isComponentFile, type Position } from "./position.ts";
+import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
+import { SetupError, setupLine, type SetupFailure } from "./setup-failure.ts";
+import {
+  pathsOf,
+  readErrors,
+  skippedRoots,
+  skippedUnits,
+  type SkippedUnit,
+} from "./type-errors.ts";
 import { reflectiveLookup } from "./reflective-lookup.ts";
 import { references, testFileRulesOf, type Reference, type TestFileRule } from "./references.ts";
 import { roots, unmatchedEverywhere, type RootKind, type Roots } from "./roots.ts";
 import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
-import { diagnosticsOf, runSession, type Engine, type ProjectView } from "./session.ts";
+import { supportReferences, testSupportFiles } from "./test-support.ts";
+import { diagnosticsOf, ownedAs, runSession, type Engine, type ProjectView } from "./session.ts";
 import { accessorsOf, storesOf } from "./stores.ts";
 import { isPartKind, type SuppressionRecord, type Suppressions, type Verdict } from "./suppress.ts";
 import { bindRows, readBaseline, readIgnoreFile, type Recorded } from "./suppress-file.ts";
 import { inlineDirectives, inlineSuppressions, type InlineDirective } from "./suppress-inline.ts";
 import type { Exemption, Mode, SweepInput } from "./sweep.ts";
 import { readTemplates, templateField } from "./template-field.ts";
+import { ownErrors, workspaceRun } from "./workspace-run.ts";
 
 /** The setting whose source decides where a finding about a configured root sits. */
 const ROOTS_SETTING = "roots.patterns";
@@ -156,6 +179,24 @@ interface ProjectRead {
   readonly configFile: string;
   readonly held: Inventory;
   readonly rooted: Roots;
+  /**
+   * The paths below the target root of the workspace-package files the project holds
+   * only for the references they make.
+   */
+  readonly referenceOnly: readonly string[];
+  /** Every type error of the project's own files that skipped a unit. */
+  readonly typeErrorSkips: readonly TypeErrorSkip[];
+  /** The lines each of those skips withholds every finding on. */
+  readonly skipped: readonly SkippedUnit[];
+  /** The project's generated files, by path below the target root, each with the row naming it. */
+  readonly generated: ReadonlyMap<string, string>;
+}
+
+/** One target project the run analyzes, as its stage is handed it. */
+interface OpenedProject {
+  readonly configuration: string;
+  /** Enumerates and roots the project; called only inside the stage it was handed to. */
+  readonly read: () => ProjectRead;
 }
 
 /** What a run read of the consumers its scope declares. */
@@ -174,22 +215,48 @@ interface ReadProjects<Answer> {
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
   readonly unanswered: readonly UnansweredQuestion[];
+  /** Per configuration whose component files the run cannot read, the reason. */
+  readonly componentsUnread: readonly ComponentsUnread[];
+  /** The convention rows the run applied. */
+  readonly conventionsApplied: readonly AppliedConvention[];
+}
+
+/**
+ * The manifests the analysis reads, each once: the target's own, then every workspace
+ * member's below the target root.
+ */
+function conventionManifests(
+  host: Host,
+  targetRoot: string,
+  memberDirs: readonly string[],
+): readonly ConventionManifest[] {
+  const found = new Map<string, ConventionManifest>();
+  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 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.
+ * 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<Answer>(
   engine: Engine,
   host: Host,
   scope: Scope,
   config: Config,
-  stage: <Brand>(project: ProjectView<Brand>, read: ProjectRead) => Answer,
+  stage: <Brand>(project: ProjectView<Brand>, opened: OpenedProject) => Answer,
 ): ReadProjects<Answer> {
   const targetRoot = scope.target.path;
   const discovered = discoverProjects(engine, host, scope, config.analysis.configurations);
@@ -200,14 +267,31 @@ function readProjects<Answer>(
       load.configFiles.map((configFile) => [configFile, load.consumer] as const),
     ),
   );
+  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,
+    parse: (fileName: string, text: string) => engine.parseSourceFile(fileName, text),
     publishedAPI: config.targetKind === "library",
   };
-  const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
   const notBuilt: NotBuilt[] = [...discovered.notBuilt];
   const dropped = (configFile: string, error: string): void => {
     notBuilt.push({
@@ -217,13 +301,42 @@ function readProjects<Answer>(
     });
   };
   const failures: LocatedDiagnostic[] = [];
+  const unbuildable: SetupFailure[] = [];
+  const setupDropped: SetupFailure[] = [];
   const consumed = new Map<string, Reference>();
+  const setupMet = (configFile: string, met: readonly SetupFailure[]): void => {
+    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()],
-    (project) => {
-      const errors = projectErrors(diagnosticsOf(project));
-      const consumer = consumerOf.get(project.configFile);
+    (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 &&
@@ -236,8 +349,45 @@ function readProjects<Answer>(
         );
         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" as const,
+            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) {
@@ -255,12 +405,39 @@ function readProjects<Answer>(
         }
         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 });
+      const read = (): ProjectRead => {
+        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" as const, 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) ?? []),
+          generated: generatedFiles(conventions, sourceFilesOf(project, targetRoot)),
+        };
+      };
+      return stage(project, { configuration, read });
     },
     discovered.derived ? "record" : "refuse",
+    workspace?.programs,
   );
   for (const configFile of session.unopened) {
     if (consumerOf.has(configFile) || !isGuess(discovered, configFile)) {
@@ -268,6 +445,9 @@ function readProjects<Answer>(
     }
     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`,
@@ -276,6 +456,9 @@ function readProjects<Answer>(
   }
   const answers = session.projects.filter((answer): answer is 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}`,
@@ -290,9 +473,37 @@ function readProjects<Answer>(
     },
     notBuilt,
     unanswered: session.unanswered,
+    componentsUnread: workspace?.componentsUnread ?? [],
+    conventionsApplied: conventions.applied,
   };
 }
 
+/** The projects one run analyzes, and what reading them left out. */
+interface RunProjects {
+  /** Each configuration the run analyzes, by the name discovery gives its project, in discovery order. */
+  readonly configurations: readonly string[];
+  /** The derived configurations the run dropped. */
+  readonly notBuilt: readonly NotBuilt[];
+  /** Every question the checker could not answer, each once. */
+  readonly unanswered: readonly UnansweredQuestion[];
+}
+
+/**
+ * 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: Engine, host: Host, scope: Scope, config: Config): RunProjects {
+  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.
  *
@@ -307,7 +518,7 @@ export function runRoots(
   provenance: Provenance,
 ): RunRoots {
   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: string[] = [];
@@ -361,6 +572,8 @@ export function runRoots(
 export interface RunSweep {
   readonly matrix: Matrix;
   readonly sweep: SweepResult;
+  /** The exemption records that hold under the sweep. */
+  readonly exempt: readonly Exemption[];
   /**
    * The exemption records that held back a declaration some configuration of the run
    * would otherwise judge dead, in the declarations' site order.
@@ -375,12 +588,25 @@ export interface RunSweep {
    * such a declaration keeps live. The run reports none of them.
    */
   readonly heldByUnanswered: readonly string[];
+  /** The lines of the units type errors skipped, on which the run reports nothing. */
+  readonly skipped: readonly SkippedUnit[];
+  /** The component files the run read, by path below the target root, each once. */
+  readonly componentFiles: readonly string[];
+}
+
+/** One `<script` start tag of a component file the run read no block for. */
+export interface ComponentWarning {
+  /** The file, below the target root. */
+  readonly path: string;
+  readonly line: number;
+  readonly reason: string;
 }
 
 /** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
 const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
   ["interface-satisfaction", interfaceSatisfaction],
   ["enum-group", enumGroup],
+  ["generated-file", generatedFile],
   ["template-field", templateField],
   ["reflective-lookup", reflectiveLookup],
   ["decorator", decorator],
@@ -396,6 +622,11 @@ interface SweptProject<Extra> {
   readonly exempt: readonly Exemption[];
   /** The declarations of the project an unanswered question could have kept live. */
   readonly unanswered: readonly string[];
+  readonly typeErrorSkips: readonly TypeErrorSkip[];
+  readonly skipped: readonly SkippedUnit[];
+  /** The component files the project holds of its own, by path below the target root. */
+  readonly componentFiles: readonly string[];
+  readonly componentWarnings: readonly ComponentWarning[];
   readonly extra: Extra;
 }
 
@@ -412,6 +643,10 @@ interface ReadRun<Extra> {
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
   readonly unanswered: readonly UnansweredQuestion[];
+  /** Per configuration whose component files the run cannot read, the reason. */
+  readonly componentsUnread: readonly ComponentsUnread[];
+  /** The convention rows the run applied. */
+  readonly conventionsApplied: readonly AppliedConvention[];
 }
 
 /**
@@ -439,48 +674,78 @@ function readRun<Extra>(
     ? { delimiters: config.analysis.templateDelimiters, files: [] }
     : readTemplates(host, targetRoot, config.analysis);
   const consumers = scope.consumers.map((consumer) => consumer.path);
-  const read = readProjects<SweptProject<Extra>>(
-    engine,
-    host,
-    scope,
-    config,
-    (project, projectRead) => {
-      const resolved = references(project, projectRead.held, targetRoot, {
-        testFiles: config.ts.testFiles,
-      });
-      const configured: Configured = {
-        configuration: projectRead.configuration,
-        symbols: projectRead.held.symbols,
-        references: resolved.references,
-        roots: projectRead.rooted.liveUnderReachability,
-        testFiles: resolved.testFilePaths,
-      };
-      const exempt = computeExemptions(
-        { project, held: projectRead.held, targetRoot, templates, ts: config.ts, consumers },
-        detectors,
-        {
-          disabled,
-          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),
-      };
-    },
-  );
+  const read = readProjects<SweptProject<Extra>>(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 detected = detectExemptions(
+      {
+        project,
+        held: projectRead.held,
+        targetRoot,
+        templates,
+        ts: config.ts,
+        consumers,
+        ...(config.analysis.generatedFiles === "include"
+          ? {}
+          : { generated: projectRead.generated }),
+      },
+      detectors,
+      {
+        disabled,
+        mode,
+        testFiles: new Set([...resolved.testFilePaths, ...support]),
+      },
+    );
+    const exempt = detected.records;
+    const made = supportReferences(resolved.references, support);
+    const configured: Configured = {
+      configuration: projectRead.configuration,
+      symbols: projectRead.held.symbols,
+      references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
+      roots: projectRead.rooted.liveUnderReachability,
+      testFiles: resolved.testFilePaths,
+      ...(support.size === 0 ? {} : { supportFiles: [...support].sort() }),
+      ...(projectRead.referenceOnly.length === 0
+        ? {}
+        : { referenceOnly: projectRead.referenceOnly }),
+    };
+    const unanswered = [
+      ...projectRead.held.unanswered,
+      ...projectRead.rooted.unanswered,
+      ...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: (typeof components)[number]): string =>
+      relativePath(targetRoot, file.fileName) ?? file.fileName;
+    return {
+      configFile: projectRead.configFile,
+      configured,
+      exempt,
+      unanswered,
+      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;
   const projects = read.answers.map((one) =>
     consumed.length === 0
@@ -506,9 +771,93 @@ function readRun<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<Extra>(
+  read: ReadRun<Extra>,
+  input: Pick<SweepInput, "marked" | "mode">,
+): { readonly swept: SweepInput; readonly result: SweepResult } {
+  const paths = new Set(read.exempt.flatMap((record) => record.whileLive ?? []));
+  let live = new Set<string>();
+  for (;;) {
+    const swept: SweepInput = {
+      ...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 test references exemption evidence written in a test file makes: each is a read of
+ * the declaration it would retain, made by the test file at the evidence's site.
+ */
+function evidenceReferences(
+  symbols: readonly InventorySymbol[],
+  inTestFiles: readonly Exemption[],
+): readonly Reference[] {
+  if (inTestFiles.length === 0) {
+    return [];
+  }
+  const files = new Map(
+    symbols
+      .filter((symbol) => symbol.kind === "file")
+      .map((symbol) => [symbol.position.path, symbol.id]),
+  );
+  return inTestFiles.flatMap((record) => {
+    const from = files.get(record.site.path);
+    return from === undefined
+      ? []
+      : [
+          {
+            from,
+            to: record.id,
+            position: record.site,
+            use: "read",
+            resolution: "syntax",
+            test: true,
+          },
+        ];
+  });
+}
+
+/**
+ * The declarations every reference the mode counts stores into, a loaded consumer's
+ * reference counting as a read: what the write-only kind would report but for a record.
+ */
+function writtenOnly<Extra>(read: ReadRun<Extra>, mode: Mode): ReadonlySet<string> {
+  const written = new Set<string>();
+  const readSome = new Set<string>();
+  for (const { configured } of read.projects) {
+    for (const reference of configured.references) {
+      if (mode.production && reference.test) {
+        continue;
+      }
+      if (reference.use === "write" && reference.consumer === undefined) {
+        written.add(reference.to);
+      } else {
+        readSome.add(reference.to);
+      }
+    }
+  }
+  return new Set([...written].filter((id) => !readSome.has(id)));
+}
+
 /**
  * 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
@@ -520,8 +869,8 @@ function sweptOf<Extra>(
   read: ReadRun<Extra>,
   input: Pick<SweepInput, "marked" | "mode">,
 ): RunSweep {
-  const swept: SweepInput = { ...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
@@ -542,7 +891,7 @@ function sweptOf<Extra>(
     );
     const bare: SweepInput = {
       ...swept,
-      exempt: read.exempt.filter((record) => !isUnansweredRecord(record)),
+      exempt: exempt.filter((record) => !isUnansweredRecord(record)),
       unanswered: [],
     };
     for (const candidate of sweepMatrix(answered, bare).candidates) {
@@ -558,10 +907,13 @@ function sweptOf<Extra>(
   return {
     matrix: read.matrix,
     sweep: result,
-    retained: retainedIn(read.matrix, swept),
+    exempt,
+    retained: retainedIn(read.matrix, swept, writtenOnly(read, input.mode)),
     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),
   };
 }
 
@@ -596,6 +948,7 @@ interface EmitterExtra {
   readonly needs: ReturnType<typeof projectNeeds>;
   readonly implementations: ReturnType<typeof implementations>;
   readonly heldByInclusion: readonly string[];
+  readonly generated: readonly string[];
   readonly rooted: Roots;
   readonly directives: readonly InlineDirective[];
   readonly declarationsNamed: readonly boolean[];
@@ -622,11 +975,16 @@ function readEmitterRun(
     (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, (fileName, text) =>
+        engine.parseSourceFile(fileName, text),
+      ),
       implementations: implementations(project, read.held),
       heldByInclusion: heldByInclusion(project, targetRoot),
+      generated: [...read.generated.keys()],
       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),
     }),
@@ -663,7 +1021,7 @@ function emitterInputOver(
         references: one.configured.references,
         accessors: one.extra.accessors,
       })),
-      read.exempt,
+      swept.exempt,
       input.mode,
     ),
     dependencies: dependenciesOf(
@@ -676,6 +1034,7 @@ function emitterInputOver(
     files: {
       tree: sourceTree(host, targetRoot),
       heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
+      generated: new Set(projects.flatMap((one) => one.extra.generated)),
     },
     boundary: {
       consumers: {
@@ -689,7 +1048,7 @@ function emitterInputOver(
     intraFunction: intraFunctionFacts(
       projects.map((one) => one.extra.parts),
       projects.flatMap((one) => one.configured.references),
-      new Set([...read.exempt.map((one) => one.id), ...swept.heldByUnanswered]),
+      new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered]),
     ),
   };
 }
@@ -768,10 +1127,21 @@ function readAnalysis(
       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] as const),
+        ).values(),
+      ],
       consumers: read.consumers,
       notBuilt: read.notBuilt,
       unanswered: read.unanswered,
+      componentsUnread: read.componentsUnread,
+      conventionsApplied: read.conventionsApplied,
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -842,6 +1212,20 @@ export interface RunFacts {
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
   readonly unanswered: readonly UnansweredQuestion[];
+  /** Every type error that skipped a unit, in the run's order. */
+  readonly typeErrorSkips: readonly TypeErrorSkip[];
+  /** Every `<script` start tag a component file holds that no block was read for, each once. */
+  readonly componentWarnings: readonly ComponentWarning[];
+  /** Per configuration whose component files the run cannot read, the reason. */
+  readonly componentsUnread: readonly ComponentsUnread[];
+  /** The convention rows the run applied. */
+  readonly conventionsApplied: readonly AppliedConvention[];
+}
+
+/** One configuration whose component files a run cannot read. */
+export interface ComponentsUnread {
+  readonly configFile: string;
+  readonly reason: string;
 }
 
 /** The findings of one run, beside what a report states about the run itself. */
@@ -874,6 +1258,25 @@ export function runAnalysis(
   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: RunAnalysis): readonly UnansweredCount[] {
+  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: AnalysisReader, inputs: AnalysisInputs): RunAnalysis {
   return {
     result: findingsPass(inputs),