@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/src/analysis.ts

@@ -14,18 +14,21 @@ import {
   configuredDeclarations,
   configuredRef,
   declarationsNamed,
-} from "./configured-declarations.ts";
+} from "./roots/configured-declarations.ts";
 import { decorator } from "./decorator.ts";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.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";
 import { loadRun, type LoadedRun } from "./load/load.ts";
-import { generatedFiles, type AppliedConvention } from "./conventions.ts";
+import type { AppliedConvention } from "./entries/conventions.ts";
+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 { generatedFile, generatedFilesOf } from "./generated-file.ts";
-import { inOperandNames } from "./in-operands.ts";
+import { bindingsOf, distinctBindings, type BindingRecord } from "./bindings.ts";
+import { generatedFile, generatedFilesOf, type GeneratedFact } from "./generated-file.ts";
+import { inOperandNames } from "./findings/in-operands.ts";
 import { sourceFilesOf } from "./source-files.ts";
 import {
   evidenceRecords,
@@ -47,13 +50,13 @@ 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 "./manifest.ts";
+import { readManifest, type ManifestEntry } from "./roots/manifest.ts";
 import {
   liveFilesAt,
   matrixOf,
@@ -74,26 +77,32 @@ import {
 import type { UnansweredQuestion } from "./query.ts";
 import { byPosition, isComponentFile, type Position } from "./position.ts";
 import type { TypeErrorSkip, UnansweredCount } from "./report.ts";
-import { skippedRoots, skippedUnits, type SkippedUnit } from "./type-errors.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 {
-  roots,
+  rootSet,
   unmatchedEverywhere,
-  type Root,
   type RootKind,
   type Roots,
   type HeldScripts,
-} from "./roots.ts";
+} 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 { mergedGlobalInterfaces } from "./augmentations.ts";
-import { unseenLoadsOf, type UnseenLoad } from "./unseen-loads.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";
@@ -103,6 +112,7 @@ import type { Exemption, Mode, SweepInput } from "./sweep.ts";
 import { readTemplates, templateField } from "./template-field.ts";
 import { bytewise } from "./text/compare.ts";
 import { holdsManifest, manifestAt } from "./fs/manifest.ts";
+import { runDirectories } from "./entries/run-directories.ts";
 import { globExpression } from "./text/glob.ts";
 
 /** The setting whose source decides where a finding about a configured root sits. */
@@ -176,10 +186,14 @@ interface ProjectRead {
   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 detail its retentions name. */
-  readonly generated: ReadonlyMap<string, string>;
-  /** The files, absolute, an applied convention row names as test files. */
-  readonly testFileNames: ReadonlySet<string>;
+  /** 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. */
@@ -194,8 +208,12 @@ 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. */
+  readonly workflows: Workflows;
 }
 
 /**
@@ -216,14 +234,13 @@ function readProjects<Answer>(
   const parse = (fileName: string, text: string) => engine.parseSourceFile(fileName, text);
   return loadRun(engine, host, scope, config, ({ plan, classified, runFiles }) => {
     const { packages, conventions } = plan;
+    const workflows = readWorkflows(host, targetRoot);
     const options = {
       host,
       manifest: packages.manifest,
       otherPackages: packages.entries,
       patterns: config.roots.patterns,
       entryFiles: config.ts.entry_files,
-      conventions,
-      testFiles: config.ts.test_files,
       parse,
       publishedAPI: config.target.kind !== undefined && kindOf(config.target.kind) === "library",
       publishedMembers: packages.published,
@@ -233,19 +250,18 @@ function readProjects<Answer>(
     const answers = classified.analyzed.map(({ plan: planned, project, skips, referenceOnly }) => {
       const read = (): ProjectRead => {
         const held = inventory(project, host, targetRoot);
-        const found = roots(project, held, targetRoot, options);
-        const kept = skippedRoots(project, held, skips);
-        const rooted =
-          kept.length === 0
-            ? found
-            : {
-                ...found,
-                liveUnderReachability: [
-                  ...found.liveUnderReachability,
-                  ...kept.map((id) => ({ id, kind: "type-error" as const, source: "" })),
-                ],
-              };
         const own = sourceFilesOf(project, targetRoot);
+        const sources = readSources({
+          host,
+          targetRoot,
+          files: own,
+          parse,
+          testFiles: config.ts.test_files,
+          conventions,
+          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 +273,18 @@ function readProjects<Answer>(
             .ownSourceFiles()
             .filter((file) => referenceOnly(file.fileName))
             .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
-          generated: generatedFilesOf(own, generatedFiles(conventions, own)),
-          testFileNames: conventions.testFiles,
+          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 +293,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)) {
+      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 +312,13 @@ function readProjects<Answer>(
       ),
       parse,
     );
-    return { answers, references: [...consumed.values()], outsideTests };
+    return {
+      answers,
+      references: [...consumed.values()],
+      consumerHeld: [...consumerHeld],
+      outsideTests,
+      workflows,
+    };
   });
 }
 
@@ -386,6 +423,14 @@ 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;
@@ -442,6 +487,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,14 +504,15 @@ 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[];
   readonly componentWarnings: readonly ComponentWarning[];
   /** Per own file below the target root, the module specifiers its imports write. */
   readonly imports: ReadonlyMap<string, readonly string[]>;
-  /** The global augmentations a declaration outside the project names. */
-  readonly augmented: readonly Root[];
   /** The data members its production code decodes into. */
   readonly decoded: Decoded;
   readonly extra: Extra;
@@ -499,6 +547,8 @@ interface ReadRun<Extra> {
   readonly memberDirs: readonly string[];
   /** The directory of every nested package, absolute. */
   readonly nestedDirs: readonly string[];
+  /** The target root's workflow steps, git hooks and makefile, read once. */
+  readonly workflows: Workflows;
 }
 
 /** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
@@ -564,6 +614,7 @@ function readRun<Extra>(
     read: ProjectRead,
     references: readonly Reference[],
     testFiles: readonly string[],
+    unseenLoads: readonly UnseenLoad[],
   ) => Extra,
 ): ReadRun<Extra> {
   const targetRoot = scope.target.path;
@@ -572,12 +623,18 @@ function readRun<Extra>(
     ? { delimiters: config.analysis.template_delimiters, files: [] }
     : readTemplates(host, targetRoot, config.analysis);
   const consumers = scope.consumers.map((consumer) => consumer.path);
+  const directories = runDirectories(host, targetRoot, (fileName, text) =>
+    engine.parseSourceFile(fileName, text),
+  );
   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.testFileNames,
+      testFile,
+      directories,
+      formedForNode: projectRead.formedForNode,
     });
+    const testFiles = testFilePaths(project, targetRoot, testFile);
     const evidence = evidenceRecords(
       {
         project,
@@ -602,14 +659,11 @@ function readRun<Extra>(
     return {
       projectRead,
       references: resolved.references,
-      testFiles: resolved.testFilePaths,
+      held: resolved.held,
+      possiblyLoaded: resolved.possiblyLoaded,
+      testFiles,
       evidence,
       componentFiles: components.map(pathOf),
-      augmented: mergedGlobalInterfaces(
-        project,
-        projectRead.held,
-        sourceFilesOf(project, targetRoot),
-      ).map((id): Root => ({ id, kind: "global-augmentation", source: "" })),
       imports: new Map(
         project.ownSourceFiles().flatMap((file) => {
           const path = relativePath(targetRoot, file.fileName);
@@ -638,10 +692,19 @@ 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),
+      extra: extra(
+        project,
+        projectRead,
+        resolved.references,
+        testFiles,
+        resolved.unseenLoads.map((position) => ({
+          configuration: projectRead.configuration,
+          position,
+        })),
+      ),
     };
   });
   const outsidePaths = read.result.outsideTests.map((one) => one.path);
@@ -658,7 +721,12 @@ function readRun<Extra>(
   const { support, testUsed } = testSupportFiles(
     withOutside.flatMap((one) => one.projectRead.held.symbols),
     withOutside.flatMap((one) => one.references),
-    withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability),
+    // An outside declaration naming a global augmentation calls nothing of its file.
+    withOutside.flatMap((one) =>
+      one.projectRead.rooted.liveUnderReachability.filter(
+        (root) => root.kind !== "global-augmentation",
+      ),
+    ),
     withOutside.flatMap((one) => one.testFiles),
     testEvidence(host, targetRoot, withOutside),
   );
@@ -691,7 +759,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);
@@ -699,9 +767,7 @@ function readRun<Extra>(
       configuration: projectRead.configuration,
       symbols: projectRead.held.symbols,
       references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
-      // The augmentations are rooted after test support is read: an outside declaration
-      // naming one calls nothing of its file.
-      roots: [...projectRead.rooted.liveUnderReachability, ...one.augmented],
+      roots: projectRead.rooted.liveUnderReachability,
       testFiles: [...one.testFiles, ...supportFiles],
       ...(supportFiles.length === 0 ? {} : { supportFiles }),
       ...(testUsedFiles.length === 0 ? {} : { testUsedFiles }),
@@ -720,13 +786,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,
@@ -754,7 +820,8 @@ 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,
@@ -769,6 +836,7 @@ function readRun<Extra>(
     conventionUses: read.plan.conventions.uses,
     memberDirs: read.plan.packages.members,
     nestedDirs: read.plan.packages.nested,
+    workflows: read.result.workflows,
   };
 }
 
@@ -842,8 +910,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] : [],
     ),
   );
 }
@@ -856,8 +924,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) {
@@ -889,7 +958,7 @@ function sweptOf<Extra>(
     // 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") {
+        if (reference.guessed === true) {
           held.add(reference.from);
         }
       }
@@ -898,7 +967,7 @@ function sweptOf<Extra>(
     const answered = matrixOf(
       read.projects.map(({ configured }) => ({
         ...configured,
-        references: configured.references.filter((one) => one.resolution !== "by-name"),
+        references: configured.references.filter((one) => one.guessed !== true),
       })),
     );
     const bare: SweepInput = {
@@ -958,7 +1027,8 @@ interface EmitterExtra {
   readonly needs: ReturnType<typeof projectNeeds>;
   readonly implementations: ReturnType<typeof implementations>;
   readonly heldByInclusion: readonly string[];
-  readonly generated: readonly string[];
+  readonly generated: ReadonlyMap<string, GeneratedFact>;
+  readonly bindings: readonly BindingRecord[];
   readonly inOperands: readonly string[];
   readonly rooted: Roots;
   readonly directives: readonly InlineDirective[];
@@ -996,15 +1066,22 @@ export function readEmitterRun(
     config,
     mode,
     detectors,
-    (project, read, references, testFiles) => ({
+    (project, read, references, testFiles, unseenLoads) => ({
       deprecation: deprecatedDeclarations(project, read.held),
       accessors: accessorsOf(project, read.held),
-      needs: projectNeeds(project, read.held, host, targetRoot, (fileName, text) =>
-        engine.parseSourceFile(fileName, text),
+      needs: projectNeeds(
+        project,
+        read.held,
+        host,
+        targetRoot,
+        (fileName, text) => engine.parseSourceFile(fileName, text),
+        read.sources.configuration,
+        read.sources.workflows,
       ),
       implementations: implementations(project, read.held),
       heldByInclusion: heldByInclusion(project, targetRoot),
-      generated: [...read.generated.keys()],
+      generated: read.generated,
+      bindings: read.bindings,
       inOperands: inOperandNames(project, targetRoot, testFiles),
       rooted: read.rooted,
       directives: inlineDirectives(project, read.held, targetRoot).filter(
@@ -1012,7 +1089,7 @@ export function readEmitterRun(
       ),
       declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
       parts: projectParts(project, read.held, references, targetRoot),
-      unseenLoads: unseenLoadsOf(project, read.configuration, targetRoot, testFiles),
+      unseenLoads,
     }),
   );
   // Whether a declaration carries the marker decides its code, so one whose answer went
@@ -1093,6 +1170,7 @@ export function emitterInputOver(
     stores: storesOf(
       projects.map((one) => ({
         references: one.configured.references,
+        support: new Set(one.configured.supportFiles ?? []),
         accessors: one.extra.accessors,
       })),
       swept.exempt,
@@ -1101,6 +1179,7 @@ export function emitterInputOver(
     dependencies: dependenciesOf(
       host,
       targetRoot,
+      read.workflows,
       [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)],
       swept.sweep.candidates.map((candidate) => candidate.id),
       members.read,
@@ -1111,7 +1190,7 @@ export 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)),
+      generated: new Set(projects.flatMap((one) => [...one.extra.generated.keys()])),
       inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
       unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
     },
@@ -1123,6 +1202,7 @@ 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)),
     },
     selfCheck,
     intraFunction: intraFunctionFacts(
@@ -1211,6 +1291,8 @@ function readAnalysis(
         one.heldScripts.map((held) => ({ ...held, configFile: one.configFile })),
       ),
       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,
@@ -1317,6 +1399,10 @@ interface RunFacts {
   readonly heldScripts: readonly (HeldScripts & { readonly configFile: string })[];
   /** The loads of production files whose target the run cannot resolve, per configuration. */
   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. */

package/src/augmentations.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] };
 }
 
 /**

package/src/automatic-types.ts

@@ -25,7 +25,7 @@ import {
   type SourceFile,
   type Statement,
 } from "@typescript/native/ast";
-import type { ParseFile } from "./configuration-files.ts";
+import type { ParseFile } from "./entries/configuration-files.ts";
 import type { Host } from "./host.ts";
 import { ancestors, dirnamePath, joinPath, resolvePath } from "./paths.ts";
 import { entriesOf } from "./fs/tree.ts";