@cplieger/deadset-ts 3.12.1 → 4.0.0

package/src/analysis.ts

@@ -8,7 +8,6 @@
  * project's checker, and that holds only for views the session itself hands out.
  */
 
-import type { Diagnostic } from "@typescript/native/unstable/sync";
 import type { Config, Provenance } from "./config.ts";
 import {
   consumerLoads,
@@ -16,16 +15,31 @@ import {
   moduleIdentity,
   type LoadedConsumer,
 } from "./consumers.ts";
+import {
+  configuredDeclarations,
+  configuredRef,
+  declarationsNamed,
+} from "./configured-declarations.ts";
 import { decorator } from "./decorator.ts";
 import { dependenciesOf, projectNeeds } from "./dependencies.ts";
-import { deprecatedDeclarations } from "./deprecation.ts";
-import { diagnosticErrors, discoverProjects, DiscoveryError } from "./discover.ts";
+import { deprecatedDeclarations, type Deprecation } from "./deprecation.ts";
+import {
+  discoverProjects,
+  DiscoveryError,
+  isGuess,
+  projectErrors,
+  renderDiagnostic,
+  targetRelative,
+  type LocatedDiagnostic,
+  type NotBuilt,
+} from "./discover.ts";
 import { readEdgeSides } from "./edges.ts";
 import { enumGroup } from "./enum-group.ts";
 import {
   computeExemptions,
   disabledClasses,
   exemptionsOf,
+  isUnansweredRecord,
   retainedIn,
   type Detector,
   type Detectors,
@@ -33,7 +47,7 @@ import {
 import type { TSExemptionClass } from "./exempt-classes.ts";
 import { heldByInclusion, sourceTree } from "./file-facts.ts";
 import type { Finding } from "./finding.ts";
-import { findingsPass, type PassResult } from "./findings-pass.ts";
+import { findingsPass, recordedFindings, rowKey, type PassResult } from "./findings-pass.ts";
 import type { EmitterInput } from "./findings/emitter.ts";
 import {
   NO_SELF_CHECK,
@@ -45,7 +59,8 @@ import type { Host } from "./host.ts";
 import { implementations, mergeImplementations } from "./implementations.ts";
 import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction } from "./interface-satisfaction.ts";
-import { inventory, type Inventory } from "./inventory.ts";
+import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
+import { inventory, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { readManifest } from "./manifest.ts";
 import {
   matrixOf,
@@ -56,6 +71,7 @@ import {
   type SweepResult,
 } from "./matrix.ts";
 import { relativePath, resolvePath } from "./paths.ts";
+import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, type Position } from "./position.ts";
 import { reflectiveLookup } from "./reflective-lookup.ts";
 import { references, testFileRulesOf, type Reference, type TestFileRule } from "./references.ts";
@@ -64,8 +80,8 @@ import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
 import { diagnosticsOf, runSession, type Engine, type ProjectView } from "./session.ts";
 import { accessorsOf, storesOf } from "./stores.ts";
-import type { Suppressions } from "./suppress.ts";
-import { readBaseline, readIgnoreFile } from "./suppress-file.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";
@@ -99,6 +115,10 @@ export interface RunRoots {
   readonly roots: readonly RunRoot[];
   /** One finding per configured root or pattern that named nothing in any project. */
   readonly findings: readonly Finding[];
+  /** The derived configurations the run dropped. */
+  readonly notBuilt: readonly NotBuilt[];
+  /** Every question the checker could not answer, each once. */
+  readonly unanswered: readonly UnansweredQuestion[];
 }
 
 /**
@@ -150,15 +170,19 @@ interface ConsumerReads {
 interface ReadProjects<Answer> {
   readonly answers: readonly Answer[];
   readonly consumers: ConsumerReads;
+  /** The derived configurations the run dropped, in the order it met them. */
+  readonly notBuilt: readonly NotBuilt[];
+  /** Every question the checker could not answer, each once. */
+  readonly unanswered: readonly UnansweredQuestion[];
 }
 
 /**
- * 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<Answer>(
   engine: Engine,
@@ -183,18 +207,39 @@ function readProjects<Answer>(
     testFiles: config.ts.testFiles,
     publishedAPI: config.targetKind === "library",
   };
-  const failures: Diagnostic[] = [];
+  const absoluteRoot = resolvePath(host.workingDirectory(), targetRoot);
+  const notBuilt: NotBuilt[] = [...discovered.notBuilt];
+  const dropped = (configFile: string, error: string): void => {
+    notBuilt.push({
+      id: ids.get(configFile) ?? configFile,
+      configFile,
+      error: targetRelative(error, absoluteRoot),
+    });
+  };
+  const failures: LocatedDiagnostic[] = [];
   const consumed = new Map<string, Reference>();
-  const { projects } = runSession(
+  const session = runSession(
     engine,
     [...discovered.configFiles, ...consumerOf.keys()],
     (project) => {
-      const errors = diagnosticErrors(diagnosticsOf(project));
-      if (errors.length > 0) {
-        failures.push(...errors);
+      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,
@@ -215,19 +260,36 @@ function readProjects<Answer>(
       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 is 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 is Answer => answer !== undefined),
+    answers,
     consumers: {
       loaded: loads.map((load) => load.consumer),
       references: [...consumed.values()],
     },
+    notBuilt,
+    unanswered: session.unanswered,
   };
 }
 
@@ -245,7 +307,8 @@ export function runRoots(
   provenance: Provenance,
 ): RunRoots {
   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: string[] = [];
   const merged = new Map<string, Omit<RunRoot, "configurations"> & { configurations: string[] }>();
@@ -289,6 +352,8 @@ export function runRoots(
       unmatched,
       documentOf(host, provenance, ROOTS_SETTING, targetRoot),
     ),
+    notBuilt: read.notBuilt,
+    unanswered: read.unanswered,
   };
 }
 
@@ -301,6 +366,15 @@ export interface RunSweep {
    * would otherwise judge dead, in the declarations' site order.
    */
   readonly retained: readonly Exemption[];
+  /** The derived configurations the run dropped. */
+  readonly notBuilt: readonly NotBuilt[];
+  /** Every question the checker could not answer, each once. */
+  readonly unanswered: readonly UnansweredQuestion[];
+  /**
+   * Every declaration an unanswered question could have kept live, and every one only
+   * such a declaration keeps live. The run reports none of them.
+   */
+  readonly heldByUnanswered: readonly string[];
 }
 
 /** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
@@ -320,6 +394,8 @@ interface SweptProject<Extra> {
   readonly configFile: string;
   readonly configured: Configured;
   readonly exempt: readonly Exemption[];
+  /** The declarations of the project an unanswered question could have kept live. */
+  readonly unanswered: readonly string[];
   readonly extra: Extra;
 }
 
@@ -327,9 +403,15 @@ interface SweptProject<Extra> {
 interface ReadRun<Extra> {
   readonly matrix: Matrix;
   readonly exempt: readonly Exemption[];
+  /** The declarations of the run an unanswered question could have kept live, each once. */
+  readonly unansweredHeld: readonly string[];
   readonly projects: readonly SweptProject<Extra>[];
   /** Every declared consumer, each loaded, in the scope's order. */
   readonly consumers: readonly LoadedConsumer[];
+  /** The derived configurations the run dropped. */
+  readonly notBuilt: readonly NotBuilt[];
+  /** Every question the checker could not answer, each once. */
+  readonly unanswered: readonly UnansweredQuestion[];
 }
 
 /**
@@ -345,7 +427,11 @@ function readRun<Extra>(
   config: Config,
   mode: Mode,
   detectors: Detectors,
-  extra: <Brand>(project: ProjectView<Brand>, read: ProjectRead) => Extra,
+  extra: <Brand>(
+    project: ProjectView<Brand>,
+    read: ProjectRead,
+    references: readonly Reference[],
+  ) => Extra,
 ): ReadRun<Extra> {
   const targetRoot = scope.target.path;
   const disabled = disabledClasses(config);
@@ -353,33 +439,48 @@ function readRun<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 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),
-      },
-    );
-    return {
-      configFile: projectRead.configFile,
-      configured,
-      exempt,
-      extra: extra(project, projectRead),
-    };
-  });
+  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 consumed = read.consumers.references;
   const projects = read.answers.map((one) =>
     consumed.length === 0
@@ -395,21 +496,72 @@ function readRun<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<Extra>(
   read: ReadRun<Extra>,
   input: Pick<SweepInput, "marked" | "mode">,
 ): RunSweep {
-  const swept: SweepInput = { ...input, exempt: read.exempt };
+  const swept: SweepInput = { ...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: SweepInput = {
+      ...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],
   };
 }
 
@@ -439,13 +591,15 @@ export function runSweep(
 
 /** What each project contributes to the facts every emitter reads beside the sweep. */
 interface EmitterExtra {
-  readonly deprecated: readonly string[];
+  readonly deprecation: Deprecation;
   readonly accessors: ReturnType<typeof accessorsOf>;
   readonly needs: ReturnType<typeof projectNeeds>;
   readonly implementations: ReturnType<typeof implementations>;
   readonly heldByInclusion: readonly string[];
   readonly rooted: Roots;
   readonly directives: readonly InlineDirective[];
+  readonly declarationsNamed: readonly boolean[];
+  readonly parts: ProjectParts;
 }
 
 /** Reads a run's projects with every per-project fact an emitter reads. */
@@ -458,15 +612,31 @@ function readEmitterRun(
   detectors: Detectors,
 ): ReadRun<EmitterExtra> {
   const targetRoot = scope.target.path;
-  return readRun(engine, host, scope, config, mode, detectors, (project, read) => ({
-    deprecated: deprecatedDeclarations(project, read.held),
-    accessors: accessorsOf(project, read.held),
-    needs: projectNeeds(project, read.held, host),
-    implementations: implementations(project, read.held),
-    heldByInclusion: heldByInclusion(project, targetRoot),
-    rooted: read.rooted,
-    directives: inlineDirectives(project, read.held, targetRoot),
-  }));
+  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),
+      heldByInclusion: heldByInclusion(project, targetRoot),
+      rooted: read.rooted,
+      directives: inlineDirectives(project, read.held, targetRoot),
+      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])] };
 }
 
 /**
@@ -487,7 +657,7 @@ function emitterInputOver(
   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,
@@ -516,6 +686,11 @@ function emitterInputOver(
       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]),
+    ),
   };
 }
 
@@ -548,15 +723,25 @@ export interface AnalysisInputs {
   readonly suppressions: Suppressions;
 }
 
+/** One run read once, and analyzed under any set of baseline rows without reading it again. */
+interface AnalysisReader {
+  readonly run: RunFacts;
+  readonly configured: readonly Configured[];
+  /** The declarations of the run, which a baseline row binds against. */
+  readonly symbols: readonly InventorySymbol[];
+  /** The inputs of the run under the directives, the ignore file and the baseline given. */
+  readonly inputsUnder: (baseline: Suppressions) => AnalysisInputs;
+}
+
 /**
  * Reads the run the scope and the configuration describe for its findings. The inline
- * directives, the ignore file's entries and the baseline's rows are read and bound before
- * any sweep, and the run is swept once under every bound record's mark and once under
- * none, so a record is decided against the finding its code would have produced. The
+ * directives, the ignore file's entries and the baseline's rows are bound before any
+ * sweep, and the run is swept once under every bound record's mark and once under none,
+ * so a record is decided against the finding its code would have produced. The
  * self-check family reports the refused suppressions and the roots that named nothing.
  * Beside the inputs it answers the projects and test-file rules a report names.
  */
-function runAnalysisInputs(
+function readAnalysis(
   engine: Engine,
   host: Host,
   scope: Scope,
@@ -564,40 +749,17 @@ function runAnalysisInputs(
   provenance: Provenance,
   mode: Mode,
   detectors: Detectors,
-): {
-  readonly inputs: AnalysisInputs;
-  readonly run: RunFacts;
-  readonly configured: readonly Configured[];
-} {
+): AnalysisReader {
   const targetRoot = scope.target.path;
   const read = readEmitterRun(engine, host, scope, config, mode, detectors);
   const symbols = read.matrix.union.symbols;
-  const documents = [
+  const fixed = [
     inlineSuppressions(read.projects.map((one) => one.extra.directives)),
     readIgnoreFile(host, targetRoot, symbols),
-    readBaseline(host, targetRoot, symbols),
   ];
-  const suppressions: Suppressions = {
-    records: documents.flatMap((one) => one.records),
-    refusals: documents.flatMap((one) => one.refusals),
-  };
-  const facts: SelfCheckFacts = {
-    refusals: suppressions.refusals,
-    unmatchedRoots: unmatchedEverywhere(
-      config.rootPatterns,
-      read.projects.map((one) => one.extra.rooted),
-    ),
-    rootsDocument: documentOf(host, provenance, ROOTS_SETTING, targetRoot),
-  };
-  const marked = [...new Set(suppressions.records.map((record) => record.bound))].filter(
-    (id) => id !== "",
-  );
+  const inputsUnder = (baseline: Suppressions): AnalysisInputs =>
+    inputsOver(host, scope, config, provenance, mode, read, [...fixed, baseline]);
   return {
-    inputs: {
-      marked: emitterInputOver(host, scope, config, read, { marked, mode }, facts),
-      unmarked: emitterInputOver(host, scope, config, read, { marked: [], mode }, facts),
-      suppressions,
-    },
     run: {
       projects: read.projects.map((one) => ({
         id: one.configured.configuration,
@@ -608,8 +770,56 @@ function runAnalysisInputs(
         read.projects.flatMap((one) => one.configured.testFiles),
       ),
       consumers: read.consumers,
+      notBuilt: read.notBuilt,
+      unanswered: read.unanswered,
     },
     configured: read.projects.map((one) => one.configured),
+    symbols,
+    inputsUnder,
+  };
+}
+
+/** The inputs of one read run under the suppression documents given, in reading order. */
+function inputsOver(
+  host: Host,
+  scope: Scope,
+  config: Config,
+  provenance: Provenance,
+  mode: Mode,
+  read: ReadRun<EmitterExtra>,
+  documents: readonly Suppressions[],
+): AnalysisInputs {
+  const targetRoot = scope.target.path;
+  const suppressions: Suppressions = {
+    records: documents.flatMap((one) => one.records),
+    refusals: documents.flatMap((one) => one.refusals),
+  };
+  const facts: SelfCheckFacts = {
+    refusals: suppressions.refusals,
+    unmatchedRoots: unmatchedEverywhere(
+      config.rootPatterns,
+      read.projects.map((one) => one.extra.rooted),
+    ),
+    rootsDocument: documentOf(host, provenance, ROOTS_SETTING, targetRoot),
+    unmatchedDeclarations: configuredDeclarations(config)
+      .filter((_, at) => !read.projects.some((one) => one.extra.declarationsNamed[at] === true))
+      .map((one) => ({
+        ref: configuredRef(one.entry),
+        key: one.key,
+        document: documentOf(host, provenance, one.key, targetRoot),
+      })),
+  };
+  const marked = [
+    ...new Set(
+      suppressions.records
+        .filter((record) => !isPartKind(record.code))
+        .map((record) => record.bound),
+    ),
+  ].filter((id) => id !== "");
+  return {
+    marked: emitterInputOver(host, scope, config, read, { marked, mode }, facts),
+    unmarked: emitterInputOver(host, scope, config, read, { marked: [], mode }, facts),
+    suppressions,
   };
 }
 
@@ -628,6 +838,10 @@ export interface RunFacts {
   readonly testFileRules: readonly TestFileRule[];
   /** Every consumer the run loaded beside the target, in the scope's order. */
   readonly consumers: readonly LoadedConsumer[];
+  /** The derived configurations the run dropped. */
+  readonly notBuilt: readonly NotBuilt[];
+  /** Every question the checker could not answer, each once. */
+  readonly unanswered: readonly UnansweredQuestion[];
 }
 
 /** The findings of one run, beside what a report states about the run itself. */
@@ -655,14 +869,81 @@ export function runAnalysis(
   mode: Mode,
   detectors: Detectors = DETECTORS,
 ): RunAnalysis {
-  const { inputs, run, configured } = runAnalysisInputs(
-    engine,
-    host,
-    scope,
-    config,
-    provenance,
-    mode,
-    detectors,
-  );
-  return { result: findingsPass(inputs), run, swept: inputs.marked.swept, configured };
+  const reader = readAnalysis(engine, host, scope, config, provenance, mode, detectors);
+  const inputs = reader.inputsUnder(readBaseline(host, scope.target.path, reader.symbols));
+  return analysisOf(reader, inputs);
+}
+
+function analysisOf(reader: AnalysisReader, inputs: AnalysisInputs): RunAnalysis {
+  return {
+    result: findingsPass(inputs),
+    run: reader.run,
+    swept: inputs.marked.swept,
+    configured: reader.configured,
+  };
+}
+
+/** A baseline write: the analysis of its first round, and the rows its fixpoint holds. */
+interface BaselineWrite {
+  /** The first round, which reads no baseline. */
+  readonly first: RunAnalysis;
+  /** The rows that remain when a round records no row and removes none, in recording order. */
+  readonly rows: readonly Recorded[];
+}
+
+/**
+ * The fixpoint a baseline write records. The first round reads no baseline; each later
+ * round reads the rows recorded so far, records a row for each recordable finding no row
+ * already names, and removes every row it reports stale. A removed row is not recorded
+ * again, so the write ends.
+ */
+export function runBaselineWrite(
+  engine: Engine,
+  host: Host,
+  scope: Scope,
+  config: Config,
+  provenance: Provenance,
+  mode: Mode,
+  reason: string,
+  detectors: Detectors = DETECTORS,
+): BaselineWrite {
+  const reader = readAnalysis(engine, host, scope, config, provenance, mode, detectors);
+  const first = analysisOf(reader, reader.inputsUnder({ records: [], refusals: [] }));
+  let rows: readonly Recorded[] = [];
+  const removed = new Set<string>();
+  let result = first.result;
+  let stale: ReadonlySet<string> = new Set<string>();
+  for (;;) {
+    const held = new Set(rows.map(rowKey));
+    const added = recordedFindings(result.findings).filter(
+      (row) => !held.has(rowKey(row)) && !removed.has(rowKey(row)),
+    );
+    if (added.length === 0 && stale.size === 0) {
+      return { first, rows };
+    }
+    for (const key of stale) {
+      removed.add(key);
+    }
+    rows = [...rows.filter((row) => !stale.has(rowKey(row))), ...added];
+    const inputs = reader.inputsUnder(bindRows(rows, reason, reader.symbols));
+    result = findingsPass(inputs);
+    stale = staleRows(inputs.suppressions.records, result.ledger.verdicts);
+  }
+}
+
+/** The baseline rows a round reports stale: every record a row binds to matched nothing. */
+function staleRows(
+  records: readonly SuppressionRecord[],
+  verdicts: readonly Verdict[],
+): ReadonlySet<string> {
+  const live = new Set<string>();
+  const stale = new Set<string>();
+  records.forEach((record, at) => {
+    if (record.mechanism !== "baseline") {
+      return;
+    }
+    const key = rowKey(record);
+    (verdicts[at] === "stale" ? stale : live).add(key);
+  });
+  return new Set([...stale].filter((key) => !live.has(key)));
 }