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

package/src/{roots.ts → roots/root-set.ts}

@@ -5,64 +5,34 @@
  * published export, which only supposes a consumer, stays a reference-counting candidate.
  */
 
-import {
-  isArrowFunction,
-  isAssertionExpression,
-  isExpressionWithTypeArguments,
-  isFunctionLikeDeclaration,
-  isIdentifier,
-  isMethodDeclaration,
-  isObjectLiteralExpression,
-  isParenthesizedExpression,
-  isPropertyAssignment,
-  isReturnStatement,
-  isSatisfiesExpression,
-  isPropertyAccessExpression,
-  isQualifiedName,
-  isTypeQueryNode,
-  isTypeReferenceNode,
-  isPropertyDeclaration,
-  isVariableDeclaration,
-  isVariableStatement,
-  SyntaxKind,
-  type Expression,
-  type Node,
-  type ObjectLiteralExpression,
-  type SourceFile,
-} from "@typescript/native/ast";
-import { aliasChains } from "./alias-chain.ts";
-import { isGlobalBlock } from "./augmentations.ts";
-import {
-  filesNamedBy,
-  outsideChain,
-  relativeSpecifiers,
-  type ParseFile,
-} from "./configuration-files.ts";
-import { conventionEntries, type Conventions } from "./conventions.ts";
-import { entryPoints, type EntryRule } from "./entry-points.ts";
-import type { Host } from "./host.ts";
-import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
+import type { SourceFile } from "@typescript/native/ast";
+import { aliasChains } from "../alias-chain.ts";
+import { filesNamedBy, outsideChain, type ParseFile } from "../entries/configuration-files.ts";
+import type { EntryRule, SourceFacts } from "../entries/sources.ts";
+import { relativeSpecifiers } from "../entries/static-module.ts";
+import type { Host } from "../host.ts";
+import { nodeKey, type Inventory } from "../inventory.ts";
 import type { Manifest, ManifestEntry } from "./manifest.ts";
-import { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.ts";
-import { byPosition } from "./position.ts";
-import { UNANSWERED } from "./query.ts";
-import type { ProjectView } from "./session.ts";
-import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
-import { sourceFilesOf, type SourceFiles } from "./source-files.ts";
-import { typeQueryAliases } from "./type-query-alias.ts";
-import { bytewise } from "./text/compare.ts";
-import { holdsManifest } from "./fs/manifest.ts";
-import { globExpression } from "./text/glob.ts";
-import { spelledFiles } from "./text/named-files.ts";
-import { commandFileTexts, workflowCommands } from "./workflow-steps.ts";
-import { readCommands } from "./commands/read.ts";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "../paths.ts";
+import { byPosition } from "../position.ts";
+import { UNANSWERED } from "../query.ts";
+import type { ProjectView } from "../session.ts";
+import { sourceFilesOf, type SourceFiles } from "../source-files.ts";
+import { typeQueryAliases } from "../type-query-alias.ts";
+import { bytewise } from "../text/compare.ts";
+import { holdsManifest } from "../fs/manifest.ts";
+import { globExpression } from "../text/glob.ts";
+import { spelledFiles } from "../text/named-files.ts";
+import type { Workflows } from "../entries/workflow-steps.ts";
+import { extensionOf, OUTPUT_EXTENSIONS } from "../extensions.ts";
+import { publishedAPI, releaseTagged } from "./published-reach.ts";
+import { skippedRoots, type Skip } from "../type-errors.ts";
+import { mergedGlobalInterfaces } from "../augmentations.ts";
 
 /** Why one declaration is a root. */
 export type RootKind =
   /** A file `ts.entry_files` names, and what it exports. */
   | "entry-file"
-  /** A file an applied convention row's globs match, and what it exports. */
-  | "convention"
   /** A file the manifest names as an importable entry point, and what it exports outside the published API. */
   | "manifest-entry"
   /** A file the manifest names as a command, and what it exports outside the published API. */
@@ -151,10 +121,10 @@ export interface RootOptions {
   readonly patterns: readonly string[];
   /** `ts.entry_files` from the resolved configuration. */
   readonly entryFiles: readonly string[];
-  /** The convention rows the run applied. */
-  readonly conventions?: Conventions | undefined;
-  /** `ts.test_files` from the resolved configuration. */
-  readonly testFiles: readonly string[];
+  /** What the project's entry sources enter, read once. */
+  readonly sources: SourceFacts;
+  /** The type errors that skipped a unit of the project's own files. */
+  readonly skips: readonly Skip[];
   /** The parser the configuration files no program holds are read with, where they are read. */
   readonly parse?: ParseFile | undefined;
   /** Whether the target is a library, so a consumer outside it reaches its published API. */
@@ -197,9 +167,6 @@ const READ_BACK_RULES: ReadonlySet<EntryRule> = new Set([
   "html-entry",
 ]);
 
-/** The extensions a manifest target's name drops: the ones a build writes. */
-const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
-
 /** The extension a source file's name drops. */
 const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
 
@@ -227,7 +194,11 @@ function readBackByName(
     return [];
   }
   const cut = below.indexOf("/");
-  const name = (cut === -1 ? below : below.slice(cut + 1)).replace(OUTPUT_EXTENSION, "");
+  const written = cut === -1 ? below : below.slice(cut + 1);
+  const name = written.slice(
+    0,
+    written.length - (extensionOf(written, OUTPUT_EXTENSIONS)?.length ?? 0),
+  );
   if (name === "") {
     return [];
   }
@@ -332,37 +303,20 @@ export function matchRef(pattern: string, ref: string): boolean {
   return matchGlob(Array.from(pattern), Array.from(ref));
 }
 
-/** The members of one declaration, indexed by the container that holds them. */
-function childrenOf(held: Inventory): ReadonlyMap<string, readonly InventorySymbol[]> {
-  const byParent = new Map<string, InventorySymbol[]>();
-  for (const symbol of held.symbols) {
-    const siblings = byParent.get(symbol.parent);
-    if (siblings === undefined) {
-      byParent.set(symbol.parent, [symbol]);
-    } else {
-      siblings.push(symbol);
-    }
-  }
-  return byParent;
-}
-
 /**
  * Per package, the own files its held texts name, as `spelledFiles` reads them, but those a
  * root enters with all they export: a command can use no more of such a file than the root
  * keeps live. A manifest's are its entries' held texts, and the target root's package has the
  * workflow steps, git hooks and makefile recipes beside its own, with the whole text of each
- * file `commandFileTexts` reads.
+ * file they are read from.
  */
 function scriptHolds(
   entries: readonly ManifestEntry[],
   files: SourceFiles,
-  entered: readonly {
-    readonly file: SourceFile;
-    readonly exports: boolean;
-    readonly names?: readonly string[];
-  }[],
+  entered: readonly Entered[],
   host: Host,
   targetRoot: string,
+  workflows: Workflows,
 ): readonly HeldScripts[] {
   const rooted = new Set(
     entered.filter((one) => one.exports && one.names === undefined).map((one) => one.file.fileName),
@@ -374,13 +328,7 @@ function scriptHolds(
   const commands = new Map<string, string[]>([
     [
       resolvePath(cwd, targetRoot),
-      [
-        ...workflowCommands(host, targetRoot).flatMap(({ text, dir, writtenDirectory }) => [
-          readCommands(text, dir).held,
-          ...(writtenDirectory === undefined ? [] : [writtenDirectory]),
-        ]),
-        ...commandFileTexts(host, targetRoot),
-      ],
+      [...workflows.readings.map((reading) => reading.held), ...workflows.texts],
     ],
   ]);
   for (const entry of entries) {
@@ -400,62 +348,24 @@ function scriptHolds(
   return held;
 }
 
-/**
- * The roots one project holds, and every configured string that named nothing in it. A
- * file a manifest member, an entry-file pattern or a tool's configuration names is a root
- * with each name of its export table and every link of a re-export chain to the
- * declaration it carries; in a library, the published API alone roots what a published
- * file exports. A file a runtime executes without reading its exports, a test file or a
- * worker, is a root by itself.
- */
-export function roots<Brand>(
-  project: ProjectView<Brand>,
-  held: Inventory,
-  targetRoot: string,
-  options: RootOptions,
-): Roots {
-  const files = sourceFilesOf(project, targetRoot);
-  const declared = held.declarations;
-  const fileIds = new Map<string, string>();
-  for (const file of files.byName.values()) {
-    const id = declared.get(nodeKey(file, file));
-    if (id !== undefined) {
-      fileIds.set(file.fileName, id);
-    }
-  }
-  const found = new Map<string, Root>();
-  const add = (id: string, kind: RootKind, source: string): void => {
-    found.set([id, kind, source].join("\u0000"), { id, kind, source });
-  };
+/** One file a source enters, with the export names it roots where it roots only some. */
+interface Entered {
+  readonly file: SourceFile;
+  readonly kind: RootKind;
+  readonly source: string;
+  readonly exports: boolean;
+  readonly names?: readonly string[];
+}
 
-  const entered: {
-    file: SourceFile;
-    kind: RootKind;
-    source: string;
-    exports: boolean;
-    names?: readonly string[];
-  }[] = [];
-  const enter = (
-    file: SourceFile,
-    kind: RootKind,
-    source: string,
-    exports: boolean,
-    names?: readonly string[],
-  ): void => {
-    entered.push({ file, kind, source, exports, ...(names === undefined ? {} : { names }) });
-  };
+/** One manifest entry, and whether a consumer outside the target reaches what it names. */
+interface PackageEntry {
+  readonly entry: ManifestEntry;
+  readonly publishes: boolean;
+}
 
-  const points = entryPoints(
-    project,
-    files,
-    options.testFiles,
-    options.host,
-    targetRoot,
-    options.parse,
-    options.conventions?.selected,
-  );
-  const published: SourceFile[] = [];
-  const entries = [
+/** The target's manifest entries, then those of its other packages. */
+function packageEntries(options: RootOptions): readonly PackageEntry[] {
+  return [
     ...options.manifest.entries.map((entry) => ({
       entry,
       publishes:
@@ -470,24 +380,21 @@ export function roots<Brand>(
         (options.publishedAPI || options.publishedMembers?.has(entry.dir) === true),
     })),
   ];
-  const scripted = entries.flatMap(({ entry }) =>
-    entry.role === "script" && entry.held === undefined ? files.named(entry.path) : [],
-  );
-  const readBackTo = [
-    ...scripted,
-    ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
-  ];
-  const entryFilesOf = new Map<ManifestEntry, readonly SourceFile[]>();
-  const entryFiles = (entry: ManifestEntry): readonly SourceFile[] => {
-    const known = entryFilesOf.get(entry);
-    if (known !== undefined) {
-      return known;
-    }
-    const found = readEntryFiles(entry);
-    entryFilesOf.set(entry, found);
-    return found;
-  };
-  const readEntryFiles = (entry: ManifestEntry): readonly SourceFile[] => {
+}
+
+/**
+ * The program files one manifest entry names, read once per entry: its path, else its
+ * output's source, else a rooted file of `readBackTo` by name, else the chain it starts
+ * outside every program.
+ */
+function entryFileReader(
+  options: RootOptions,
+  targetRoot: string,
+  files: SourceFiles,
+  readBackTo: readonly SourceFile[],
+): (entry: ManifestEntry) => readonly SourceFile[] {
+  const read = new Map<ManifestEntry, readonly SourceFile[]>();
+  const readEntry = (entry: ManifestEntry): readonly SourceFile[] => {
     const named = files.named(entry.path);
     if (named.length > 0 || entry.role === "script") {
       return named;
@@ -500,11 +407,54 @@ export function roots<Brand>(
     const byName = readBackByName(options.host, entry, readBackTo);
     return byName.length > 0 ? byName : throughOutside(options, targetRoot, files, entry);
   };
-  for (const { entry, publishes } of entries) {
-    if (publishes) {
-      published.push(...entryFiles(entry));
+  return (entry) => {
+    const known = read.get(entry) ?? readEntry(entry);
+    read.set(entry, known);
+    return known;
+  };
+}
+
+/** The files `ts.entry_files` names, each with the pattern that names it. */
+function patternedFiles(
+  files: SourceFiles,
+  patterns: readonly string[],
+): readonly { file: SourceFile; pattern: string }[] {
+  const patterned: { file: SourceFile; pattern: string }[] = [];
+  for (const pattern of patterns) {
+    const expression = globExpression(pattern);
+    for (const [path, file] of files.byPath) {
+      if (expression.test(path)) {
+        patterned.push({ file, pattern });
+      }
     }
   }
+  return patterned;
+}
+
+/**
+ * The files every root source enters, in the order manifest entries, entry-file patterns,
+ * entry sources; the files whose exports a consumer outside the target reaches; and the
+ * entries that name no file even read back by name to another entered file.
+ */
+function enteredFiles(
+  options: RootOptions,
+  targetRoot: string,
+  files: SourceFiles,
+  entries: readonly PackageEntry[],
+): {
+  entered: readonly Entered[];
+  published: readonly SourceFile[];
+  unmappedEntries: readonly ManifestEntry[];
+} {
+  const points = options.sources.entered;
+  const scripted = entries.flatMap(({ entry }) =>
+    entry.role === "script" && entry.held === undefined ? files.named(entry.path) : [],
+  );
+  const entryFiles = entryFileReader(options, targetRoot, files, [
+    ...scripted,
+    ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
+  ]);
+  const published = entries.flatMap(({ entry, publishes }) => (publishes ? entryFiles(entry) : []));
   if (options.publishedAPI) {
     // A library's bundle hands what its entry exports to every program that loads it.
     published.push(
@@ -512,15 +462,8 @@ export function roots<Brand>(
     );
   }
   const publishedNames = new Set(published.map((file) => file.fileName));
-  const patterned: { file: SourceFile; pattern: string }[] = [];
-  for (const pattern of options.entryFiles) {
-    const expression = globExpression(pattern);
-    for (const [path, file] of files.byPath) {
-      if (expression.test(path)) {
-        patterned.push({ file, pattern });
-      }
-    }
-  }
+  const patterned = patternedFiles(files, options.entryFiles);
+  const entered: Entered[] = [];
   const unmapped: ManifestEntry[] = [];
   const mapped = patterned.map(({ file }) => file);
   for (const { entry } of entries) {
@@ -534,33 +477,41 @@ export function roots<Brand>(
     mapped.push(...named);
     for (const file of named) {
       const kind = ENTRY_KINDS[entry.role];
-      enter(file, kind, entry.member, !publishedNames.has(file.fileName));
+      entered.push({
+        file,
+        kind,
+        source: entry.member,
+        exports: !publishedNames.has(file.fileName),
+      });
     }
   }
-  const unmappedEntries = unmapped.filter(
-    (entry) => readBackByName(options.host, entry, mapped).length === 0,
-  );
   for (const { file, pattern } of patterned) {
-    enter(file, "entry-file", pattern, true);
-  }
-  for (const { file, row } of options.conventions === undefined
-    ? []
-    : conventionEntries(options.conventions, files)) {
-    enter(file, "convention", row, true);
+    entered.push({ file, kind: "entry-file", source: pattern, exports: true });
   }
   for (const point of points) {
-    enter(point.file, point.rule, point.source, point.exports, point.names);
+    entered.push({
+      file: point.file,
+      kind: point.rule,
+      source: point.source,
+      exports: point.exports,
+      ...(point.names === undefined ? {} : { names: point.names }),
+    });
   }
-  const heldScripts = scriptHolds(
-    entries.map(({ entry }) => entry),
-    files,
+  return {
     entered,
-    options.host,
-    targetRoot,
-  );
-  const heldFiles = [...new Set(heldScripts.flatMap((one) => one.files))].flatMap(
-    (path) => files.byPath.get(path) ?? [],
-  );
+    published,
+    unmappedEntries: unmapped.filter(
+      (entry) => readBackByName(options.host, entry, mapped).length === 0,
+    ),
+  };
+}
+
+/** Every declaration and container of a `typeof import(...)` global, with the type's text. */
+function typeQueryRoots(
+  files: SourceFiles,
+  declared: Inventory["declarations"],
+  add: (id: string, kind: RootKind, source: string) => void,
+): void {
   for (const file of files.byPath.values()) {
     for (const alias of typeQueryAliases(file)) {
       const source = alias.type.getText().replace(/\s+/gu, " ");
@@ -572,6 +523,60 @@ export function roots<Brand>(
       }
     }
   }
+}
+
+/** The roots in the order {@link Roots.liveUnderReachability} states. */
+function orderedRoots(found: Iterable<Root>, held: Inventory): readonly Root[] {
+  const sites = new Map(held.symbols.map((symbol) => [symbol.id, symbol.position]));
+  return [...found].sort((a, b) => {
+    const left = sites.get(a.id);
+    const right = sites.get(b.id);
+    const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
+    return site || bytewise(a.kind, b.kind) || bytewise(a.source, b.source);
+  });
+}
+
+/**
+ * The roots one project holds, and every configured string that named nothing in it. A
+ * file a manifest member, an entry-file pattern or a tool's configuration names is a root
+ * with each name of its export table and every re-export link to what it carries; in a
+ * library, the published API alone roots what a published file exports. A test file is a
+ * root by itself, and so is each declaration a type error's skip keeps and each global
+ * interface merging into one declared outside the project.
+ */
+export function rootSet<Brand>(
+  project: ProjectView<Brand>,
+  held: Inventory,
+  targetRoot: string,
+  options: RootOptions,
+): Roots {
+  const files = sourceFilesOf(project, targetRoot);
+  const fileIds = new Map<string, string>();
+  for (const file of files.byName.values()) {
+    const id = held.declarations.get(nodeKey(file, file));
+    if (id !== undefined) {
+      fileIds.set(file.fileName, id);
+    }
+  }
+  const found = new Map<string, Root>();
+  const add = (id: string, kind: RootKind, source: string): void => {
+    found.set([id, kind, source].join("\u0000"), { id, kind, source });
+  };
+
+  const entries = packageEntries(options);
+  const { entered, published, unmappedEntries } = enteredFiles(options, targetRoot, files, entries);
+  const heldScripts = scriptHolds(
+    entries.map(({ entry }) => entry),
+    files,
+    entered,
+    options.host,
+    targetRoot,
+    options.sources.workflows,
+  );
+  const heldFiles = [...new Set(heldScripts.flatMap((one) => one.files))].flatMap(
+    (path) => files.byPath.get(path) ?? [],
+  );
+  typeQueryRoots(files, held.declarations, add);
 
   const {
     tables: exportsOf,
@@ -613,17 +618,15 @@ export function roots<Brand>(
   }
 
   const unmatched = configured(held, options.patterns, add);
-
-  const sites = new Map(held.symbols.map((symbol) => [symbol.id, symbol.position]));
-  const ordered = [...found.values()].sort((a, b) => {
-    const left = sites.get(a.id);
-    const right = sites.get(b.id);
-    const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
-    return site || bytewise(a.kind, b.kind) || bytewise(a.source, b.source);
-  });
+  for (const id of skippedRoots(project, held, options.skips)) {
+    add(id, "type-error", "");
+  }
+  for (const id of mergedGlobalInterfaces(project, held, files).kept) {
+    add(id, "global-augmentation", "");
+  }
 
   return {
-    liveUnderReachability: ordered,
+    liveUnderReachability: orderedRoots(found.values(), held),
     unmatched,
     unanswered: [
       ...(answered ? api.guessed : held.symbols.map((symbol) => symbol.id)),
@@ -698,436 +701,6 @@ function exportTables<Brand>(
   return { tables, named, answered };
 }
 
-/** A release tag of a documentation comment: `@` and its name, between white space or the ends. */
-const RELEASE_TAG = /(?:^|\s)@(?:public|beta|alpha)(?=\s|$)/u;
-
-/**
- * Whether the documentation comment of the statement that starts at `start`, the last
- * `/** *\/` comment before it with only white space between the two, holds a release tag.
- */
-function releaseTagIn(text: string, from: number, start: number): boolean {
-  const leading = text.slice(from, start);
-  const open = leading.lastIndexOf("/**");
-  const close = open < 0 ? -1 : leading.indexOf("*/", open + 3);
-  if (close < 0 || leading.slice(close + 2).trim() !== "") {
-    return false;
-  }
-  return RELEASE_TAG.test(leading.slice(open + 3, close));
-}
-
-/** The exported top-level declarations of the program's files a release tag marks. */
-function releaseTagged(
-  held: Inventory,
-  files: { readonly byPath: ReadonlyMap<string, SourceFile> },
-): readonly string[] {
-  const exported = new Set(held.symbols.filter((symbol) => symbol.exported).map((one) => one.id));
-  const found: string[] = [];
-  for (const file of files.byPath.values()) {
-    for (const statement of file.statements) {
-      if (!releaseTagIn(file.text, statement.pos, statement.getStart())) {
-        continue;
-      }
-      const nodes: readonly Node[] = isVariableStatement(statement)
-        ? statement.declarationList.declarations
-        : [statement];
-      for (const node of nodes) {
-        const id = held.declarations.get(nodeKey(file, node));
-        if (id !== undefined && exported.has(id)) {
-          found.push(id);
-        }
-      }
-    }
-  }
-  return found;
-}
-
-/** The kinds of container whose export table, not its members' visibility, says what it publishes. */
-const EXPORTING_CONTAINERS: ReadonlySet<string> = new Set(["file", "namespace"]);
-
-/**
- * Every declaration a consumer of the library can name, a published file itself excluded:
- * what the published files export, with a namespace's exported members and any other
- * declaration's public and protected ones; a declaration a published one's type names; an
- * exported declaration a release tag marks; each declaration a `declare global` block holds
- * in a published file or one holding a published declaration; and, as `guessed`, each
- * declaration spelled as a type name the checker leaves unanswered.
- */
-function publishedAPI<Brand>(
-  project: ProjectView<Brand>,
-  published: readonly SourceFile[],
-  exportsOf: ReadonlyMap<string, readonly string[]>,
-  held: Inventory,
-  byPath: ReadonlyMap<string, SourceFile>,
-  tagged: readonly string[],
-): { readonly ids: readonly string[]; readonly guessed: readonly string[] } {
-  const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
-  const children = childrenOf(held);
-  const nodes = declarationNodes(held, byPath);
-  const chains = aliasChains(project, held);
-  const reached = new Set<string>();
-  const entered = new Set<string>();
-  const guessed = new Set<string>();
-  const pending: string[] = [];
-  const reach = (id: string): void => {
-    const file = byId.get(id)?.kind === "file";
-    if (!(file ? entered : reached).has(id)) {
-      (file ? entered : reached).add(id);
-      pending.push(id);
-    }
-  };
-  for (const id of tagged) {
-    reach(id);
-  }
-  for (const file of published) {
-    for (const id of exportsOf.get(file.fileName) ?? []) {
-      reach(id);
-    }
-  }
-  const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
-  const blocks = held.symbols.filter((one) => isGlobalBlock(one, held, files));
-  const fileOf = (id: string): string | undefined => {
-    let at = byId.get(id);
-    while (at !== undefined && at.kind !== "file") {
-      at = byId.get(at.parent);
-    }
-    return at?.id;
-  };
-  const publishedFiles = published.flatMap(
-    (file) => held.declarations.get(nodeKey(file, file)) ?? [],
-  );
-  const globalsReached = (): boolean => {
-    const typed = new Set([...publishedFiles, ...[...reached].flatMap((id) => fileOf(id) ?? [])]);
-    const before = pending.length;
-    for (const block of blocks.filter((one) => typed.has(one.parent))) {
-      reach(block.id);
-      for (const member of children.get(block.id) ?? []) {
-        if (member.kind !== "type-parameter") {
-          reach(member.id);
-        }
-      }
-    }
-    return pending.length > before;
-  };
-  do {
-    while (pending.length > 0) {
-      const round: string[] = [];
-      for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-        round.push(next);
-        const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-        for (const member of children.get(next) ?? []) {
-          const reachable = exporting
-            ? member.exported
-            : member.visibility !== "private" && member.visibility !== "private-name";
-          if (member.kind !== "type-parameter" && reachable) {
-            reach(member.id);
-          }
-        }
-      }
-      const named = round.flatMap((id) => {
-        const symbol = byId.get(id);
-        return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
-      });
-      const inferred = inferredTypeSymbols(
-        project,
-        round.flatMap((id) => {
-          const symbol = byId.get(id);
-          return symbol === undefined ? [] : nodes.nodesOf(symbol);
-        }),
-      );
-      for (const symbol of inferred.types) {
-        for (const target of chains.chainOf(symbol)) {
-          reach(target.id);
-        }
-      }
-      for (const symbol of inferred.members) {
-        for (const target of chains.chainOf(symbol)) {
-          const member = byId.get(target.id);
-          if (member?.visibility === "public" || member?.visibility === "protected") {
-            reach(target.id);
-          }
-        }
-      }
-      project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
-        if (symbol === UNANSWERED) {
-          for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
-            guessed.add(id);
-            reach(id);
-          }
-        } else if (symbol !== undefined) {
-          for (const target of chains.chainOf(symbol)) {
-            reach(target.id);
-          }
-        }
-      });
-    }
-  } while (globalsReached());
-  return { ids: [...reached], guessed: [...guessed] };
-}
-
-/** The type names declarations of the inventory write, each file walked once, when first asked. */
-function declarationNodes(
-  held: Inventory,
-  byPath: ReadonlyMap<string, SourceFile>,
-): {
-  typeNamesOf(symbol: InventorySymbol): readonly Node[];
-  nodesOf(symbol: InventorySymbol): readonly Node[];
-} {
-  const walked = new Map<string, { byId: Map<string, Node[]>; nodes: Set<Node> }>();
-  const nodesIn = (path: string): { byId: Map<string, Node[]>; nodes: Set<Node> } => {
-    const known = walked.get(path);
-    if (known !== undefined) {
-      return known;
-    }
-    const found = { byId: new Map<string, Node[]>(), nodes: new Set<Node>() };
-    const file = byPath.get(path);
-    if (file !== undefined) {
-      const visit = (node: Node): void => {
-        const id = held.declarations.get(nodeKey(file, node));
-        if (id !== undefined) {
-          found.nodes.add(node);
-          found.byId.set(id, [...(found.byId.get(id) ?? []), node]);
-        }
-        node.forEachChild(visit);
-      };
-      visit(file);
-    }
-    walked.set(path, found);
-    return found;
-  };
-  return {
-    typeNamesOf: (symbol) => {
-      const { byId, nodes } = nodesIn(symbol.position.path);
-      return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
-    },
-    nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
-  };
-}
-
-/** How deep the type arguments and constituents of an inferred type are followed. */
-const INFERRED_DEPTH = 4;
-
-/**
- * The values one function body returns, each through the type assertions around it: the
- * value a caller receives carries the operand's type whatever type the assertion or the
- * signature names. A nested function's returns are its own.
- */
-function returnedValues(body: Node): readonly Expression[] {
-  const found: Expression[] = [];
-  const add = (value: Expression): void => {
-    for (let at: Expression | undefined = value; at !== undefined;) {
-      found.push(at);
-      at =
-        isAssertionExpression(at) || isSatisfiesExpression(at) || isParenthesizedExpression(at)
-          ? at.expression
-          : undefined;
-    }
-  };
-  if (!isFunctionLikeDeclaration(body.parent) || body.parent.body !== body) {
-    return found;
-  }
-  if (isArrowFunction(body.parent) && body.kind !== SyntaxKind.Block) {
-    add(body as Expression);
-    return found;
-  }
-  const visit = (node: Node): void => {
-    if (isFunctionLikeDeclaration(node)) {
-      return;
-    }
-    if (isReturnStatement(node) && node.expression !== undefined) {
-      add(node.expression);
-    }
-    node.forEachChild(visit);
-  };
-  body.forEachChild(visit);
-  return found;
-}
-
-/** The object literal one returned value is, written there or as the initializer of a variable `body` declares. */
-function returnedLiteral(value: Expression, body: Node): ObjectLiteralExpression | undefined {
-  if (isObjectLiteralExpression(value)) {
-    return value;
-  }
-  if (!isIdentifier(value)) {
-    return undefined;
-  }
-  let found: ObjectLiteralExpression | undefined;
-  const visit = (node: Node): void => {
-    if (
-      isVariableDeclaration(node) &&
-      isIdentifier(node.name) &&
-      node.name.text === value.text &&
-      node.initializer !== undefined
-    ) {
-      let at: Expression = node.initializer;
-      while (
-        isAssertionExpression(at) ||
-        isSatisfiesExpression(at) ||
-        isParenthesizedExpression(at)
-      ) {
-        at = at.expression;
-      }
-      found = isObjectLiteralExpression(at) ? at : found;
-    }
-    if (!isFunctionLikeDeclaration(node)) {
-      node.forEachChild(visit);
-    }
-  };
-  body.forEachChild(visit);
-  return found;
-}
-
-/**
- * The values one function body returns, and those each method of an object literal it
- * returns returns, to a fixed depth: a caller holding the literal calls its methods, and
- * receives what they return.
- */
-function returnedThroughLiterals(body: Node, depth = 0): readonly Expression[] {
-  const values = returnedValues(body);
-  if (depth >= INFERRED_DEPTH) {
-    return values;
-  }
-  const found = [...values];
-  for (const value of values) {
-    for (const property of returnedLiteral(value, body)?.properties ?? []) {
-      const fn = isMethodDeclaration(property)
-        ? property
-        : isPropertyAssignment(property) && isFunctionLikeDeclaration(property.initializer)
-          ? property.initializer
-          : undefined;
-      if (fn?.body !== undefined) {
-        found.push(...returnedThroughLiterals(fn.body, depth + 1));
-      }
-    }
-  }
-  return found;
-}
-
-/**
- * The declarations of the types the compiler infers where a declaration writes none, and
- * of the values a function returns: the type of a variable or a property with no
- * annotation, the result of a function or a method with no result annotation, and the type
- * of each value its body returns, each with the types its type arguments and its union or
- * intersection constituents name, to a fixed depth; and as `members` the properties of each
- * returned value's type. A question the checker leaves unanswered names nothing.
- */
-function inferredTypeSymbols<Brand>(
-  project: ProjectView<Brand>,
-  declarations: readonly Node[],
-): { readonly types: readonly TSSymbol[]; readonly members: readonly TSSymbol[] } {
-  const { queries } = project;
-  const valued: Node[] = declarations.flatMap((node) =>
-    (isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
-    node.type === undefined &&
-    !isFunctionLikeDeclaration(node.initializer ?? node)
-      ? [node.name]
-      : [],
-  );
-  const returned = declarations.flatMap((node) => {
-    const signature = isFunctionLikeDeclaration(node)
-      ? node
-      : isVariableDeclaration(node) &&
-          node.initializer !== undefined &&
-          isFunctionLikeDeclaration(node.initializer)
-        ? node.initializer
-        : undefined;
-    return signature?.body === undefined ? [] : returnedThroughLiterals(signature.body);
-  });
-  const types: Type[] = [];
-  const returnedTypes: Type[] = [];
-  queries.typesAt([...valued, ...returned]).forEach((type, at) => {
-    if (type !== UNANSWERED && type !== undefined) {
-      (at < valued.length ? types : returnedTypes).push(type);
-    }
-  });
-  types.push(...returnedTypes);
-  for (const node of declarations) {
-    const signature = isFunctionLikeDeclaration(node)
-      ? node
-      : isVariableDeclaration(node) &&
-          node.type === undefined &&
-          node.initializer !== undefined &&
-          isFunctionLikeDeclaration(node.initializer)
-        ? node.initializer
-        : undefined;
-    if (signature === undefined || signature.type !== undefined || signature.body === undefined) {
-      continue;
-    }
-    const typed = queries.signatureOf(signature);
-    const result =
-      typed === UNANSWERED || typed === undefined ? undefined : queries.returnTypeOf(typed);
-    if (result !== UNANSWERED && result !== undefined) {
-      types.push(result);
-    }
-  }
-  const found = new Map<number, TSSymbol>();
-  const seen = new Set<Type>();
-  const visit = (type: Type, depth: number): void => {
-    if (depth > INFERRED_DEPTH || seen.has(type)) {
-      return;
-    }
-    seen.add(type);
-    const symbol = queries.symbolOfType(type);
-    if (symbol !== UNANSWERED && symbol !== undefined) {
-      found.set(symbol.id, symbol);
-    }
-    const parts = queries.constituents(type);
-    const args = queries.typeArguments(type);
-    for (const next of [
-      ...(parts === UNANSWERED || (parts.length === 1 && parts[0] === type) ? [] : parts),
-      ...(args === UNANSWERED ? [] : args),
-    ]) {
-      visit(next, depth + 1);
-    }
-  };
-  types.forEach((type) => {
-    visit(type, 0);
-  });
-  // A returned value carries each property of its type, one an anonymous type declares or
-  // an intersection merges included, which no type name reaches.
-  const members = new Map<number, TSSymbol>();
-  for (const type of returnedTypes) {
-    const parts = queries.constituents(type);
-    for (const one of [type, ...(parts === UNANSWERED ? [] : parts)]) {
-      const properties = queries.propertiesOf(one);
-      for (const property of properties === UNANSWERED ? [] : properties) {
-        members.set(property.id, property);
-      }
-    }
-  }
-  return { types: [...found.values()], members: [...members.values()] };
-}
-
-/**
- * The names of types one declaration's own syntax writes: in a type reference, a
- * heritage clause or a type query. A function body is not read, and neither is a
- * declaration nested in this one, which `nested` holds and which is read on its own.
- */
-function typeNamesOf(declaration: Node, nested: ReadonlySet<Node>): readonly Node[] {
-  const found: Node[] = [];
-  const visit = (node: Node): void => {
-    if (node !== declaration && nested.has(node)) {
-      return;
-    }
-    if (isTypeReferenceNode(node)) {
-      found.push(isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
-    } else if (isExpressionWithTypeArguments(node)) {
-      found.push(
-        isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression,
-      );
-    } else if (isTypeQueryNode(node)) {
-      found.push(isQualifiedName(node.exprName) ? node.exprName.right : node.exprName);
-    }
-    const body = isFunctionLikeDeclaration(node) ? node.body : undefined;
-    node.forEachChild((child) => {
-      if (child !== body) {
-        visit(child);
-      }
-    });
-  };
-  visit(declaration);
-  return found;
-}
-
 /**
  * Keeps every declaration the configuration names and returns every string that
  * named none, in configuration order. A string the configuration lists twice is one