@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/src/analysis.ts

@@ -17,6 +17,7 @@ import {
 } from "./roots/configured-declarations.ts";
 import { decorator } from "./decorator.ts";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.ts";
+import { carriersOf, NO_CARRIERS, type Carriers } from "./exposure.ts";
 import { deprecatedDeclarations, type Deprecation } from "./deprecation.ts";
 import { moduleIdentity, type LoadedConsumer, type NotBuilt } from "./load/discover.ts";
 import type { LibraryUnfound } from "./load/classify.ts";
@@ -26,17 +27,16 @@ import { readSources, type SourceFacts } from "./entries/sources.ts";
 import { readWorkflows, type Workflows } from "./entries/workflow-steps.ts";
 import { readEdgeSides } from "./edges.ts";
 import { enumGroup } from "./enum-group.ts";
+import { bindingsOf, distinctBindings, type BindingRecord } from "./bindings.ts";
 import { generatedFile, generatedFilesOf, type GeneratedFact } from "./generated-file.ts";
-import { inOperandNames } from "./in-operands.ts";
+import { inOperandNames } from "./findings/in-operands.ts";
 import { sourceFilesOf } from "./source-files.ts";
 import {
   evidenceRecords,
   heldRecords,
   disabledClasses,
   exemptionsOf,
-  holdingWhile,
   isUnansweredRecord,
-  retainedIn,
   writtenRecords,
   type Detector,
   type Detectors,
@@ -49,22 +49,14 @@ import type { EmitterInput } from "./findings/emitter.ts";
 import { unmatchedRootFindings, type SelfCheckFacts } from "./findings/self-check.ts";
 import { frameworkLifecycle } from "./framework-lifecycle.ts";
 import type { Host } from "./host.ts";
-import { implementations, mergeImplementations } from "./implementations.ts";
+import { implementations, mergeImplementations } from "./findings/implementations.ts";
 import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.ts";
 import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-function-parts.ts";
 import { type Inventory, type InventorySymbol } from "./inventory.ts";
 import { inventory } from "./inventory/enumerate.ts";
 import { readManifest, type ManifestEntry } from "./roots/manifest.ts";
-import {
-  liveFilesAt,
-  matrixOf,
-  referenceKey,
-  sweepMatrix,
-  type Configured,
-  type Matrix,
-  type SweepResult,
-} from "./matrix.ts";
+import { matrixOf, referenceKey, type Configured, type Matrix } from "./liveness/matrix.ts";
 import {
   ancestors,
   dirnamePath,
@@ -78,7 +70,7 @@ import { byPosition, isComponentFile, type Position } from "./position.ts";
 import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
 import { skippedUnits, type SkippedUnit } from "./type-errors.ts";
 import { reflectiveLookup } from "./reflective-lookup.ts";
-import { references, testFileRulesOf, type Reference, type TestFileRule } from "./references.ts";
+import { references, type Reference } from "./references.ts";
 import {
   rootSet,
   unmatchedEverywhere,
@@ -88,18 +80,28 @@ import {
 } from "./roots/root-set.ts";
 import type { Scope } from "./scope.ts";
 import { decodedMembers, serializationContract, type Decoded } from "./serialization-contract.ts";
-import { outsideTestReferences, testFilesAt, type OutsideTest } from "./outside-tests.ts";
+import { outsideTestReferences, testFilesAt, type OutsideTest } from "./tests/outside.ts";
 import type { UnseenLoad } from "./roots/unseen-loads.ts";
 import type { UnresolvedSpecifier } from "./load/specifiers.ts";
+import { formedForNode } from "./load/synthesize.ts";
 import type { UnreadInput } from "./load/plan.ts";
 import { GLOBALS_RUNNER, namesTestGlobals } from "./load/test-globals.ts";
-import { supportReferences, testSupportFiles, type TestEvidence } from "./test-support.ts";
+import {
+  targetTestFile,
+  testFilePaths,
+  testFileRulesOf,
+  withheldBy,
+  type TestFileRule,
+} from "./tests/file-class.ts";
+import { testSupportFiles, type TestEvidence } from "./tests/support.ts";
 import type { Engine, 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 { sweep, type Sweep, type SweepPolicy } from "./liveness/sweep.ts";
+import type { Exemption } from "./exempt.ts";
+import type { Mode } from "./tests/file-class.ts";
 import { readTemplates, templateField } from "./template-field.ts";
 import { bytewise } from "./text/compare.ts";
 import { holdsManifest, manifestAt } from "./fs/manifest.ts";
@@ -179,8 +181,12 @@ interface ProjectRead {
   readonly skipped: readonly SkippedUnit[];
   /** The project's generated files, by path below the target root, each with what decided it. */
   readonly generated: ReadonlyMap<string, GeneratedFact>;
+  /** The binding identities its generated files publish (`bindings.6`, `bindings.7`). */
+  readonly bindings: readonly BindingRecord[];
   /** What the project's entry sources enter and name, read once. */
   readonly sources: SourceFacts;
+  /** Whether the run formed the program to resolve its modules as Node does (program.36). */
+  readonly formedForNode: boolean;
 }
 
 /** One target project the run analyzes, as its stage is handed it. */
@@ -195,6 +201,8 @@ interface ProjectsRead<Answer> {
   readonly answers: readonly Answer[];
   /** Every reference a consumer makes to a declaration of the target, each once. */
   readonly references: readonly Reference[];
+  /** The declarations a consumer's read rules held, each once. */
+  readonly consumerHeld: readonly string[];
   /** The test files below the target root no project the run reads holds, parsed. */
   readonly outsideTests: readonly OutsideTest[];
   /** The target root's workflow steps, git hooks and makefile, read once for every project. */
@@ -246,6 +254,7 @@ function readProjects<Answer>(
           workflows,
         });
         const rooted = rootSet(project, held, targetRoot, { ...options, sources, skips });
+        const generated = generatedFilesOf(own, sources.generated);
         return {
           configuration: planned.id,
           configFile: project.configFile,
@@ -257,8 +266,18 @@ function readProjects<Answer>(
             .ownSourceFiles()
             .filter((file) => referenceOnly(file.fileName))
             .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-          generated: generatedFilesOf(own, sources.generated),
+          generated,
+          bindings: bindingsOf(
+            own.byPath,
+            generated,
+            new Map(
+              held.symbols
+                .filter((one) => one.kind === "file")
+                .map((one) => [one.position.path, one.ref]),
+            ),
+          ),
           sources,
+          formedForNode: formedForNode(planned),
         };
       };
       for (const file of project.ownSourceFiles()) {
@@ -267,11 +286,16 @@ function readProjects<Answer>(
       return stage(project, { configuration: planned.id, read });
     });
     const consumed = new Map<string, Reference>();
+    const consumerHeld = new Set<string>();
     for (const { project, consumer } of classified.consumed) {
       const side = { id: consumer.id, root: consumer.path };
-      for (const reference of consumerReferences(project, host, targetRoot, side, config, parse)) {
+      const read = consumerReferences(project, host, targetRoot, side, config, parse);
+      for (const reference of read.references) {
         consumed.set(referenceKey(reference), reference);
       }
+      for (const id of read.held) {
+        consumerHeld.add(id);
+      }
     }
     const outsideTests = testFilesAt(
       host,
@@ -281,7 +305,13 @@ function readProjects<Answer>(
       ),
       parse,
     );
-    return { answers, references: [...consumed.values()], outsideTests, workflows };
+    return {
+      answers,
+      references: [...consumed.values()],
+      consumerHeld: [...consumerHeld],
+      outsideTests,
+      workflows,
+    };
   });
 }
 
@@ -386,30 +416,24 @@ export function runRoots(
   };
 }
 
+/** The production mode a configuration sets: a consumer's test reference is classed as `analysis.consumer_tests` says. */
+export function productionMode(config: PartialConfig): Mode {
+  return {
+    production: true,
+    consumerTestsProduction: config.analysis.consumer_tests === "production",
+  };
+}
+
 /** The run's sweep, beside the matrix it judged. */
 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.
-   */
-  readonly retained: readonly Exemption[];
+  readonly sweep: Sweep;
   /** 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 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. */
@@ -442,6 +466,8 @@ interface SweptProject<Extra> {
   readonly unanswered: readonly string[];
   /** The data members a generic declared outside the analysis fills, which it may read. */
   readonly filledOutside: readonly string[];
+  /** What only a bundler's retry of an import Node leaves unresolved names (program.38). */
+  readonly possiblyLoaded: 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. */
@@ -457,6 +483,9 @@ interface SweptProject<Extra> {
 interface ReadProject<Extra> {
   readonly projectRead: ProjectRead;
   readonly references: readonly Reference[];
+  /** The declarations its read rules held where the checker did not answer. */
+  readonly held: readonly string[];
+  readonly possiblyLoaded: readonly string[];
   readonly testFiles: readonly string[];
   readonly evidence: readonly Exemption[];
   readonly componentFiles: readonly string[];
@@ -477,6 +506,8 @@ interface ReadRun<Extra> {
   readonly projects: readonly SweptProject<Extra>[];
   /** Every declared consumer, each loaded, in the scope's order. */
   readonly consumers: readonly LoadedConsumer[];
+  /** Whether the scope declares a consumer, loaded or not. */
+  readonly declaresConsumers: boolean;
   /** The derived configurations the run dropped. */
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
@@ -578,11 +609,13 @@ function readRun<Extra>(
   );
   const read = readProjects<ReadProject<Extra>>(engine, host, scope, config, (project, opened) => {
     const projectRead = opened.read();
+    const testFile = targetTestFile(projectRead.sources.testFiles);
     const resolved = references(project, projectRead.held, targetRoot, {
-      testFiles: config.ts.test_files,
-      testFileNames: projectRead.sources.testFiles,
+      testFile,
       directories,
+      formedForNode: projectRead.formedForNode,
     });
+    const testFiles = testFilePaths(project, targetRoot, testFile);
     const evidence = evidenceRecords(
       {
         project,
@@ -607,7 +640,9 @@ function readRun<Extra>(
     return {
       projectRead,
       references: resolved.references,
-      testFiles: resolved.testFilePaths,
+      held: resolved.held,
+      possiblyLoaded: resolved.possiblyLoaded,
+      testFiles,
       evidence,
       componentFiles: components.map(pathOf),
       imports: new Map(
@@ -638,14 +673,14 @@ function readRun<Extra>(
       decoded: decodedMembers(
         project,
         projectRead.held,
-        productionFiles(project, targetRoot, resolved.testFilePaths),
+        productionFiles(project, targetRoot, testFiles),
         consumers,
       ),
       extra: extra(
         project,
         projectRead,
         resolved.references,
-        resolved.testFilePaths,
+        testFiles,
         resolved.unseenLoads.map((position) => ({
           configuration: projectRead.configuration,
           position,
@@ -705,7 +740,7 @@ function readRun<Extra>(
       testFiles: new Set([...one.testFiles, ...support]),
     });
     const exempt = detected.records;
-    const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
+    const made = [...one.references, ...(satisfied?.references ?? [])];
     const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
     const supportFiles = [...support].filter((path) => held.has(path)).sort(bytewise);
     const testUsedFiles = [...testUsed].filter((path) => held.has(path)).sort(bytewise);
@@ -732,13 +767,13 @@ function readRun<Extra>(
       unanswered: [
         ...projectRead.held.unanswered,
         ...projectRead.rooted.unanswered,
-        ...made
-          .filter((reference) => reference.resolution === "by-name")
-          .map((reference) => reference.to),
+        ...made.filter((reference) => reference.guessed === true).map((reference) => reference.to),
+        ...one.held,
         ...exempt.filter(isUnansweredRecord).map((record) => record.id),
         ...one.decoded.unanswered,
       ],
       filledOutside: one.decoded.filled,
+      possiblyLoaded: one.possiblyLoaded,
       typeErrorSkips: projectRead.typeErrorSkips,
       unmappedEntries: projectRead.rooted.unmappedEntries,
       heldScripts: projectRead.rooted.heldScripts,
@@ -766,11 +801,13 @@ function readRun<Extra>(
     unansweredHeld: [
       ...new Set([
         ...answers.flatMap((one) => one.unanswered),
-        ...consumed.filter((one) => one.resolution === "by-name").map((one) => one.to),
+        ...consumed.filter((one) => one.guessed === true).map((one) => one.to),
+        ...read.result.consumerHeld,
       ]),
     ],
     projects,
     consumers: read.plan.discovery.consumers,
+    declaresConsumers: scope.consumers.length > 0,
     notBuilt: read.classified.notBuilt,
     unanswered: read.unanswered,
     componentsUnread: read.plan.workspace?.componentsUnread ?? [],
@@ -785,33 +822,6 @@ function readRun<Extra>(
   };
 }
 
-/**
- * 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.
@@ -855,8 +865,8 @@ function countedWrites(
   mode: Mode,
 ): ReadonlySet<string> {
   return new Set(
-    supportReferences(references, support).flatMap((reference) =>
-      reference.use === "write" && !(mode.production && reference.test) ? [reference.to] : [],
+    references.flatMap((reference) =>
+      reference.use === "write" && !withheldBy(mode, reference, support) ? [reference.to] : [],
     ),
   );
 }
@@ -869,8 +879,9 @@ function writtenOnly<Extra>(read: ReadRun<Extra>, mode: Mode): ReadonlySet<strin
   const written = new Set<string>();
   const readSome = new Set<string>();
   for (const { configured } of read.projects) {
+    const support = new Set(configured.supportFiles ?? []);
     for (const reference of configured.references) {
-      if (mode.production && reference.test) {
+      if (withheldBy(mode, reference, support)) {
         continue;
       }
       if (reference.use === "write" && reference.consumer === undefined) {
@@ -883,62 +894,27 @@ function writtenOnly<Extra>(read: ReadRun<Extra>, mode: Mode): ReadonlySet<strin
   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
- * 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.
- */
+/** The sweep of a run read once, under one set of marks. */
 function sweptOf<Extra>(
   read: ReadRun<Extra>,
-  input: Pick<SweepInput, "marked" | "mode">,
+  input: Pick<SweepPolicy, "marked" | "mode">,
 ): RunSweep {
-  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
-    // 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: 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);
-      }
-    }
-  }
+  const componentFiles = [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(
+    bytewise,
+  );
   return {
     matrix: read.matrix,
-    sweep: result,
-    exempt,
-    retained: retainedIn(read.matrix, swept, writtenOnly(read, input.mode)),
+    sweep: sweep(read.matrix, {
+      ...input,
+      exempt: read.exempt,
+      unanswered: read.unansweredHeld,
+      componentFiles,
+      unseenCallers: !read.declaresConsumers,
+      writeOnly: 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(bytewise),
   };
 }
 
@@ -955,7 +931,7 @@ export function runSweep(
   host: Host,
   scope: Scope,
   config: ResolvedConfig,
-  input: Pick<SweepInput, "marked" | "mode">,
+  input: Pick<SweepPolicy, "marked" | "mode">,
   detectors: Detectors = DETECTORS,
 ): RunSweep {
   return sweptOf(
@@ -972,12 +948,14 @@ interface EmitterExtra {
   readonly implementations: ReturnType<typeof implementations>;
   readonly heldByInclusion: readonly string[];
   readonly generated: ReadonlyMap<string, GeneratedFact>;
+  readonly bindings: readonly BindingRecord[];
   readonly inOperands: readonly string[];
   readonly rooted: Roots;
   readonly directives: readonly InlineDirective[];
   readonly declarationsNamed: readonly boolean[];
   readonly parts: ProjectParts;
   readonly unseenLoads: readonly UnseenLoad[];
+  readonly carriers: Carriers;
 }
 
 /** The project's own files below the target root that are no test file. */
@@ -1024,6 +1002,7 @@ export function readEmitterRun(
       implementations: implementations(project, read.held),
       heldByInclusion: heldByInclusion(project, targetRoot),
       generated: read.generated,
+      bindings: read.bindings,
       inOperands: inOperandNames(project, targetRoot, testFiles),
       rooted: read.rooted,
       directives: inlineDirectives(project, read.held, targetRoot).filter(
@@ -1032,6 +1011,8 @@ export function readEmitterRun(
       declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
       parts: projectParts(project, read.held, references, targetRoot),
       unseenLoads,
+      // Only a closed world reports an unnecessary export, which is all the carriers decide.
+      carriers: config.consumers.complete ? carriersOf(project, read.held) : NO_CARRIERS,
     }),
   );
   // Whether a declaration carries the marker decides its code, so one whose answer went
@@ -1098,7 +1079,7 @@ export function emitterInputOver(
   scope: Scope,
   config: ResolvedConfig,
   read: ReadRun<EmitterExtra>,
-  input: Pick<SweepInput, "marked" | "mode">,
+  input: Pick<SweepPolicy, "marked" | "mode">,
   selfCheck: SelfCheckFacts,
 ): EmitterInput {
   const targetRoot = scope.target.path;
@@ -1112,9 +1093,10 @@ export function emitterInputOver(
     stores: storesOf(
       projects.map((one) => ({
         references: one.configured.references,
+        support: new Set(one.configured.supportFiles ?? []),
         accessors: one.extra.accessors,
       })),
-      swept.exempt,
+      swept.sweep.exempt,
       input.mode,
     ),
     dependencies: dependenciesOf(
@@ -1143,12 +1125,24 @@ export function emitterInputOver(
       encapsulated: readManifest(host, targetRoot).declaresExports,
       edges: readEdgeSides(host, targetRoot),
       filledOutside: new Set(projects.flatMap((one) => one.filledOutside)),
+      possiblyLoaded: new Set(projects.flatMap((one) => one.possiblyLoaded)),
+      carriers: {
+        named: new Map(
+          [
+            ...Map.groupBy(
+              projects.flatMap((one) => [...one.extra.carriers.named]),
+              ([id]) => id,
+            ),
+          ].map(([id, entries]) => [id, [...new Set(entries.flatMap(([, named]) => named))]]),
+        ),
+        unread: new Set(projects.flatMap((one) => [...one.extra.carriers.unread])),
+      },
     },
     selfCheck,
     intraFunction: intraFunctionFacts(
       projects.map((one) => one.extra.parts),
       projects.flatMap((one) => one.configured.references),
-      new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered]),
+      new Set([...swept.sweep.exempt.map((one) => one.id), ...swept.sweep.held]),
     ),
   };
 }
@@ -1232,6 +1226,7 @@ function readAnalysis(
       ),
       unseenLoads: read.projects.flatMap((one) => one.extra.unseenLoads),
       generated: new Map(read.projects.flatMap((one) => [...one.extra.generated])),
+      bindings: distinctBindings(read.projects.flatMap((one) => one.extra.bindings)),
     },
     configured: read.projects.map((one) => one.configured),
     symbols,
@@ -1340,6 +1335,8 @@ interface RunFacts {
   readonly unseenLoads: readonly UnseenLoad[];
   /** Every generated file of the run, by its path below the target root, each once. */
   readonly generated: ReadonlyMap<string, GeneratedFact>;
+  /** Every binding record the run's generated files publish, each once. */
+  readonly bindings: readonly BindingRecord[];
 }
 
 /** One configuration whose component files a run cannot read. */
@@ -1385,7 +1382,7 @@ export function runAnalysis(
  * declarations of its own the run holds for them.
  */
 export function unansweredCounts(analysis: RunAnalysis): readonly UnansweredCount[] {
-  const held = new Set(analysis.swept.heldByUnanswered);
+  const held = new Set(analysis.swept.sweep.held);
   return analysis.run.projects.flatMap((project) => {
     const questions =
       analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length +

package/src/augmentations.ts

@@ -14,7 +14,7 @@ import {
   type Node,
 } from "@typescript/native/ast";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { referenceKey } from "./matrix.ts";
+import { referenceKey } from "./liveness/matrix.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";
@@ -78,7 +78,7 @@ function holdersOf(
  * file or a `declare` holds that a `declare global` block, or the top level of a file in
  * `scripts`, declares, directly or inside a namespace there.
  */
-export function ambientGlobalInterfaces(
+function ambientGlobalInterfaces(
   held: Inventory,
   interfaces: readonly string[],
   scripts: ReadonlySet<string>,
@@ -89,19 +89,31 @@ export function ambientGlobalInterfaces(
     : interfaces.filter((id) => held.ambient.has(id) && holders(id).global);
 }
 
+/** The ambient global interfaces of a project's own files that merge into a declaration outside them. */
+interface GlobalMerges {
+  /** The files that are no module, by identifier. */
+  readonly scripts: ReadonlySet<string>;
+  /** Each such interface, by identifier. */
+  readonly interfaces: ReadonlySet<string>;
+  /**
+   * Each such interface with every interface, namespace and block between it and the global
+   * scope: the outside declaration names it wherever a value is typed by it. Where every
+   * outside declaration is a package's, not the compiler's library, and declares no member,
+   * each member it declares as well: such an interface is a slot the package reads by type,
+   * as `keyof` does, in declarations the analysis does not walk.
+   */
+  readonly kept: readonly string[];
+}
+
 /**
- * Each ambient global interface of the project's own files that merges into an interface
- * declared outside them, with every interface, namespace and block between it and the
- * global scope: the outside declaration names it wherever a value is typed by it. Where
- * every outside declaration is a package's, not the compiler's library, and declares no
- * member, each member it declares as well: such an interface is a slot the package reads
- * by type, as `keyof` does, in declarations the analysis does not walk.
+ * Which ambient global interfaces of the project's own files, `files`, merge into an interface
+ * declared outside them, and what each merge keeps.
  */
 export function mergedGlobalInterfaces<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   files: SourceFiles,
-): readonly string[] {
+): GlobalMerges {
   const scripts = new Set<string>();
   const names = new Map<string, Node>();
   for (const file of files.byName.values()) {
@@ -124,7 +136,7 @@ export function mergedGlobalInterfaces<Brand>(
   const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
   const asked = [...names].filter(([id]) => global.has(id));
   if (asked.length === 0) {
-    return [];
+    return { scripts, interfaces: new Set(), kept: [] };
   }
   const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
   const holders = holdersOf(held, scripts);
@@ -135,24 +147,26 @@ export function mergedGlobalInterfaces<Brand>(
     const node = project.declarationAt(handle)?.node;
     return node !== undefined && isInterfaceDeclaration(node) && node.members.length === 0;
   };
-  return [
-    ...new Set(
-      asked.flatMap(([id], at) => {
-        const symbol = answers[at];
-        if (typeof symbol !== "object") {
-          return [];
-        }
-        const outside = symbol.declarations.filter((handle) => !files.byName.has(handle.path));
-        if (outside.length === 0) {
-          return [];
-        }
-        const members = outside.every(empty)
-          ? held.symbols.filter((one) => one.parent === id).map((one) => one.id)
-          : [];
-        return [id, ...(holders?.(id).ids ?? []), ...members];
-      }),
-    ),
-  ];
+  const interfaces = new Set<string>();
+  const kept = new Set<string>();
+  asked.forEach(([id], at) => {
+    const symbol = answers[at];
+    const outside =
+      typeof symbol === "object"
+        ? symbol.declarations.filter((handle) => !files.byName.has(handle.path))
+        : [];
+    if (outside.length === 0) {
+      return;
+    }
+    interfaces.add(id);
+    const members = outside.every(empty)
+      ? held.symbols.filter((one) => one.parent === id).map((one) => one.id)
+      : [];
+    for (const one of [id, ...(holders?.(id).ids ?? []), ...members]) {
+      kept.add(one);
+    }
+  });
+  return { scripts, interfaces, kept: [...kept] };
 }
 
 /**