@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.1

package/src/module-declarations.ts

@@ -104,6 +104,8 @@ function namesModule(specifier: string, name: string): boolean {
 interface Named {
   readonly id: string;
   readonly members: readonly string[];
+  /** Whether the declaration's name is a pattern, which a specifier names by matching it. */
+  readonly wildcard: boolean;
 }
 
 /**
@@ -140,7 +142,7 @@ function namedBy(
         ]),
       );
       const members = (children.get(id) ?? []).filter((child) => wanted.has(child.ref));
-      return [{ id, members: members.map((child) => child.id) }];
+      return [{ id, members: members.map((child) => child.id), wildcard: name.includes("*") }];
     });
 }
 
@@ -208,28 +210,24 @@ export function moduleDeclarationReferences<Brand>(
   imports.forEach((one, index) => {
     const resolved = moduleOf(declared.length + index);
     const position = renderPosition(one.file, root, one.specifier.getStart());
-    const read = (to: string, resolution: Reference["resolution"]): void => {
-      found.push({
-        from: one.from,
-        to,
-        position,
-        use: "read",
-        resolution,
-        test: testFiles.has(position.path),
-      });
+    const read = (to: string, resolution: Reference["resolution"], test: boolean): void => {
+      found.push({ from: one.from, to, position, use: "read", resolution, test });
     };
+    const test = testFiles.has(position.path);
     const same = new Set(
       declared
         .filter((_, at) => resolved !== undefined && resolved === moduleOf(at))
         .map((declaration) => declaration.id),
     );
     for (const id of same) {
-      read(id, "batch");
+      read(id, "batch", test);
     }
     for (const declaration of named(one.specifier.text, one.names)) {
-      if (!same.has(declaration.id)) {
+      // A wildcard declaration is how the compiler types the file a matching specifier
+      // names, so the import uses it whoever writes it, a test included.
+      if (declaration.wildcard || !same.has(declaration.id)) {
         for (const to of [declaration.id, ...declaration.members]) {
-          read(to, "syntax");
+          read(to, "syntax", test && !declaration.wildcard);
         }
       }
     }

package/src/overrides.ts

@@ -1,10 +1,9 @@
 /**
- * The overrides of the target's class members. A call through the base class names the
- * base's member and runs the override of whichever subclass the value is, so the base
- * member's declaration references every override. A method, an accessor or a property,
- * static or not, overriding a member of a class declared outside the target, at any depth
- * of its `extends` chain, is used by outside code holding the instance or the class
- * through that class, so its own class references it.
+ * The overrides of the target's class members. A call through the base class runs the
+ * override of whichever subclass the value is, so the base member references every
+ * override. A member, static or not, overriding one of a class declared outside the target
+ * at any depth of its `extends` chain, a library's interface-and-variable class such as
+ * `Error` included, is used by outside code holding the value, so its own class references it.
  */
 
 import {
@@ -115,12 +114,16 @@ export function overrideReferences<Brand>(
       if (
         inTarget.length === 0 &&
         declared !== UNANSWERED &&
-        (declared.flags & SymbolFlags.Class) !== 0 &&
-        // The target's augmentation of an outside class merges an interface into it,
-        // so only a class declaration says where the class is.
-        declared.declarations.some(
-          (handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path),
-        )
+        (((declared.flags & SymbolFlags.Class) !== 0 &&
+          // The target's augmentation of an outside class merges an interface into it,
+          // so only a class declaration says where the class is.
+          declared.declarations.some(
+            (handle) => CLASS_DECLARATIONS.has(handle.kind) && !own.has(handle.path),
+          )) ||
+          ((declared.flags & SymbolFlags.Interface) !== 0 &&
+            declared.declarations.some(
+              (handle) => handle.kind === SyntaxKind.VariableDeclaration && !own.has(handle.path),
+            )))
       ) {
         outsideBases.set(id, declared);
       }
@@ -185,11 +188,13 @@ function outsideMemberNames<Brand>(
   outsideBases: ReadonlyMap<string, TSSymbol>,
 ): ReadonlyMap<string, ReadonlySet<string>> {
   const direct = new Map<string, ReadonlySet<string>>();
+  const error = errorType(project);
   for (const [classId, base] of outsideBases) {
     const instance = project.queries.declaredTypeOf(base);
     const statics = project.queries.typeOfSymbol(base);
     const components = [
       ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
+      ...(instance !== UNANSWERED && reaches(project, instance, error) ? ["toString"] : []),
       ...namesOf(project, statics === UNANSWERED ? undefined : statics).map(
         (name) => `${nameComponent(name)}:static`,
       ),
@@ -218,6 +223,40 @@ function outsideMemberNames<Brand>(
   return names;
 }
 
+/** The global `Error` instance type's identifier, where the program's library declares one. */
+function errorType<Brand>(project: ProjectView<Brand>): number | undefined {
+  const symbol = project.queries.resolveName("Error", SymbolFlags.Type, undefined, false);
+  if (symbol === UNANSWERED || symbol === undefined) {
+    return undefined;
+  }
+  const type = project.queries.declaredTypeOf(symbol);
+  return type === UNANSWERED ? undefined : type.id;
+}
+
+/**
+ * Whether one type is the `Error` instance type or extends it at any depth: the runtime
+ * prints an error through its `toString`, a member the library's `Error` interface omits.
+ */
+function reaches<Brand>(
+  project: ProjectView<Brand>,
+  type: Type,
+  target: number | undefined,
+): boolean {
+  const seen = new Set<number>();
+  const pending = [type];
+  for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+    if (next.id === target) {
+      return true;
+    }
+    if (!seen.has(next.id)) {
+      seen.add(next.id);
+      const bases = project.queries.baseTypes(next);
+      pending.push(...(bases === UNANSWERED ? [] : bases));
+    }
+  }
+  return false;
+}
+
 /** The names of a type's properties; none where the type or its properties are unanswered. */
 function namesOf<Brand>(project: ProjectView<Brand>, type: Type | undefined): readonly string[] {
   const properties = type === undefined ? UNANSWERED : project.queries.propertiesOf(type);

package/src/print.ts

@@ -84,6 +84,7 @@ export function printConfig(config: Config, provenance: Provenance): string {
         members: entry.members,
       })),
       serializers: config.ts.serializers.map(declarationOf),
+      roots_complete: config.ts.rootsComplete,
     },
     provenance: Object.fromEntries(
       [...provenance]

package/src/ref.ts

@@ -49,9 +49,11 @@ export const REF_EXPRESSIONS: readonly string[] = [
   `^${SCOPE}#$`,
   `^${SCOPE}#${TS_HEAD}$`,
   `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
+  `^${SCOPE}#${TS_HEAD}:import$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
+  `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
   `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,
 ];
 
@@ -151,6 +153,16 @@ export function computedComponent(text: string): string {
   return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
 
+/** The reference of an import binding, read against the reference of the module that holds it. */
+export function importRef(moduleRef: string, name: string): string {
+  return `${moduleRef}${nameComponent(name)}:import`;
+}
+
+/** The reference of a parameter, read against the reference of the declaration that holds it. */
+export function parameterRef(holderRef: string, name: string): string {
+  return `${holderRef}(${name})`;
+}
+
 /** The fragment of an export alias, inside the `declare module` block named, if one is. */
 export function aliasFragment(name: string, block?: string): string {
   const head = block === undefined ? "" : `${quoted(block)}.`;

package/src/references.ts

@@ -60,8 +60,15 @@ import { dirnamePath, queriedModulePath, relativePath, resolvePath } from "./pat
 import { byPosition, isComponentFile, renderPosition, type Position } from "./position.ts";
 import { DEFAULT_BATCH_CAP, propertyTables, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
+import { typeParameterReads } from "./type-parameter-reads.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
-import { computedKeyNames, keyNameOf, keyedUses, type KeyedAccess } from "./symbol-keys.ts";
+import {
+  computedKeyNames,
+  iterationReferences,
+  keyNameOf,
+  keyedUses,
+  type KeyedAccess,
+} from "./symbol-keys.ts";
 import { handedOn, valuesOf } from "./value-flow.ts";
 
 /**
@@ -1621,6 +1628,8 @@ export function references<Brand>(
     found.push(...indexedAccessReferences(project, held, chains, root, new Set(tests)));
     found.push(...elementAccessReferences(project, held, chains, root, new Set(tests)));
     found.push(...keyofComparisonReferences(project, held, chains, root, new Set(tests)));
+    found.push(...iterationReferences(project, held, chains, root, new Set(tests)));
+    found.push(...typeParameterReads(project, held, chains, root, new Set(tests)));
     found.push(...unimplementedCalleeReads(project, held, chains, root, new Set(tests)));
     found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
     typedLookups = (options.requestCount?.() ?? 0) - before;

package/src/report.ts

@@ -19,7 +19,7 @@ import type { StaleSuppression } from "./findings/self-check.ts";
 import type { TestFileRule } from "./references.ts";
 
 /** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "8.2.0";
+const SCHEMA_VERSION = "9.0.0";
 
 /** Every report schema version this analyzer reads: the one the Contract it implements admits. */
 export const SCHEMA_VERSIONS_ACCEPTED: readonly string[] = [SCHEMA_VERSION];
@@ -224,12 +224,21 @@ export interface Report {
   readonly excluded_by_cgo: readonly never[];
   readonly test_file_rules: readonly TestFileRule[];
   readonly type_error_skips: readonly TypeErrorSkip[];
-  readonly notes: readonly never[];
+  readonly notes: readonly ReportNote[];
   readonly unanswered_questions: readonly UnansweredCount[];
   readonly conventions_applied: readonly AppliedConvention[];
   readonly totals: WireTotals;
 }
 
+/** One hint about the run's setup, as the report schema's `notes` spells it. */
+export interface ReportNote {
+  readonly kind: "unmapped-entry";
+  /** The directory of the manifest the note is about, below the target root. */
+  readonly path: string;
+  readonly key: "ts.entry_files";
+  readonly message: string;
+}
+
 /** What one run answered, from which its report is built. */
 export interface ReportInput {
   readonly contractVersion: string;
@@ -247,6 +256,8 @@ export interface ReportInput {
   readonly unanswered: readonly UnansweredCount[];
   /** The convention rows the run applied, in the report's order. */
   readonly conventionsApplied: readonly AppliedConvention[];
+  /** The notes the run states, in any order. */
+  readonly notes?: readonly ReportNote[];
 }
 
 /** Two strings ordered bytewise. */
@@ -510,7 +521,9 @@ export function buildReport(input: ReportInput): Report {
     ]
       .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
       .map(([, skip]) => skip),
-    notes: [],
+    notes: [...new Map((input.notes ?? []).map((one) => [JSON.stringify(one), one])).entries()]
+      .sort(([a, x], [b, y]) => compare(x.kind, y.kind) || compare(x.path, y.path) || compare(a, b))
+      .map(([, note]) => note),
     unanswered_questions: [...input.unanswered]
       .sort(
         (a, b) =>

package/src/resolve.ts

@@ -112,6 +112,7 @@ interface Doc {
   readonly injectionRegistrations: readonly DeclarationEntry[] | undefined;
   readonly lifecycleContracts: readonly LifecycleContract[] | undefined;
   readonly serializers: readonly DeclarationEntry[] | undefined;
+  readonly rootsComplete: boolean | undefined;
 }
 
 /** One document the resolution reads, with the origin its settings carry. */
@@ -894,6 +895,7 @@ function readDoc(value: unknown, label: string): Doc {
     ),
     lifecycleContracts: readLifecycleContracts(ts, label),
     serializers: readDeclarations(ts, "serializers", "ts.serializers", label),
+    rootsComplete: readBoolean(ts, "roots_complete", "ts.roots_complete", label),
   };
 }
 
@@ -1191,6 +1193,7 @@ function settleAll(inputs: Inputs): { config: Config; provenance: Map<string, Or
         (doc) => doc.lifecycleContracts,
       ),
       serializers: at("ts.serializers", defaults.ts.serializers, (doc) => doc.serializers),
+      rootsComplete: at("ts.roots_complete", defaults.ts.rootsComplete, (doc) => doc.rootsComplete),
     },
   };
 

package/src/roots.ts

@@ -22,19 +22,24 @@ import {
   type SourceFile,
 } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.ts";
-import type { ParseFile } from "./configuration-files.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 { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import type { Manifest, ManifestEntry } from "./manifest.ts";
-import { relativePath, resolvePath } from "./paths.ts";
+import { dirnamePath, joinPath, 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 } from "./source-files.ts";
+import { sourceFilesOf, type SourceFiles } from "./source-files.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
 
 /** Why one declaration is a root. */
@@ -104,6 +109,8 @@ export interface Roots {
    * unknown; otherwise each one an unanswered published type name may name.
    */
   readonly unanswered: readonly string[];
+  /** Every manifest entry naming a file to import or run that reads back to no file of this project. */
+  readonly unmappedEntries: readonly ManifestEntry[];
 }
 
 /** What decides the roots beside the declarations themselves. */
@@ -134,6 +141,8 @@ export interface RootOptions {
    * inside the target whose entries are published API whatever the target's kind.
    */
   readonly publishedMembers?: ReadonlySet<string> | undefined;
+  /** Every file a program of the run holds, so a file another configuration compiles is no outside file. */
+  readonly runFiles?: ReadonlySet<string> | undefined;
 }
 
 /** Whether one declaration is written below the directory of a published workspace member. */
@@ -171,11 +180,25 @@ 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;
 
+/** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
+function ofPackage(host: Host, dir: string, file: string): boolean {
+  for (let at = dirnamePath(file); at !== dir; at = dirnamePath(at)) {
+    if (
+      relativePath(dir, at) === undefined ||
+      host.kindOf(joinPath(at, "package.json")) === "file"
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
 /**
  * The rooted files one manifest target reads back to by name: its path below the
  * manifest's directory, past its first directory where it names one, without its output
- * extension, is the name, and a rooted file is one whose path below the same directory,
- * without its source extension, ends with that name at a directory boundary.
+ * extension, is the name, and a rooted file of the manifest's own package is one whose
+ * path below the same directory, without its source extension, ends with that name at a
+ * directory boundary.
  */
 function readBackByName(
   host: Host,
@@ -195,13 +218,52 @@ function readBackByName(
   const found = new Map<string, SourceFile>();
   for (const file of rooted) {
     const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
-    if (path !== undefined && (path === name || path.endsWith(`/${name}`))) {
+    if (
+      path !== undefined &&
+      (path === name || path.endsWith(`/${name}`)) &&
+      ofPackage(host, dir, file.fileName)
+    ) {
       found.set(file.fileName, file);
     }
   }
   return [...found.values()];
 }
 
+/**
+ * The program files a manifest target no program holds reaches: the target is a file
+ * read as a configuration file outside the program is, and each file of the chain it
+ * starts loads the program files its relative specifiers name, read through the emit
+ * mapping, as a command's shim loads the compiled entry it runs.
+ */
+function throughOutside(
+  options: RootOptions,
+  targetRoot: string,
+  files: SourceFiles,
+  entry: ManifestEntry,
+): readonly SourceFile[] {
+  const cwd = options.host.workingDirectory();
+  const path = resolvePath(cwd, entry.path);
+  if (
+    options.parse === undefined ||
+    options.runFiles?.has(path) === true ||
+    options.host.kindOf(path) !== "file"
+  ) {
+    return [];
+  }
+  const chain = outsideChain(options.host, targetRoot, files, options.parse, [
+    { path, manifestDir: resolvePath(cwd, entry.dir) },
+  ]);
+  const found = new Map<string, SourceFile>();
+  for (const { file } of chain) {
+    for (const specifier of relativeSpecifiers(file)) {
+      for (const named of filesNamedBy(files, dirnamePath(file.fileName), specifier)) {
+        found.set(named.fileName, named);
+      }
+    }
+  }
+  return [...found.values()];
+}
+
 /** Whether a configured string carries either special character. */
 function isPattern(text: string): boolean {
   return text.includes("*") || text.includes("?");
@@ -307,9 +369,21 @@ export function roots<Brand>(
     found.set([id, kind, source].join("\u0000"), { id, kind, source });
   };
 
-  const entered: { file: SourceFile; kind: RootKind; source: string; exports: boolean }[] = [];
-  const enter = (file: SourceFile, kind: RootKind, source: string, exports: boolean): void => {
-    entered.push({ file, kind, source, exports });
+  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 }) });
   };
 
   const points = entryPoints(
@@ -344,11 +418,28 @@ export function roots<Brand>(
     ...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[] => {
     const named = files.named(entry.path);
-    return named.length > 0 || entry.role === "script"
-      ? named
-      : readBackByName(options.host, entry, readBackTo);
+    if (named.length > 0 || entry.role === "script") {
+      return named;
+    }
+    const cwd = options.host.workingDirectory();
+    const shipped = files.namedAsOutput(resolvePath(cwd, entry.dir), resolvePath(cwd, entry.path));
+    if (shipped.length > 0) {
+      return shipped;
+    }
+    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) {
@@ -356,27 +447,41 @@ export function roots<Brand>(
     }
   }
   const publishedNames = new Set(published.map((file) => file.fileName));
-  for (const { entry } of entries) {
-    for (const file of entryFiles(entry)) {
-      const kind = ENTRY_KINDS[entry.role];
-      enter(file, kind, entry.member, !publishedNames.has(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)) {
-        enter(file, "entry-file", pattern, true);
+        patterned.push({ file, pattern });
       }
     }
   }
+  const unmapped: ManifestEntry[] = [];
+  const mapped = patterned.map(({ file }) => file);
+  for (const { entry } of entries) {
+    const named = entryFiles(entry);
+    if (named.length === 0 && entry.role !== "script") {
+      unmapped.push(entry);
+    }
+    mapped.push(...named);
+    for (const file of named) {
+      const kind = ENTRY_KINDS[entry.role];
+      enter(file, kind, entry.member, !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);
   }
   for (const point of points) {
-    enter(point.file, point.rule, point.source, point.exports);
+    enter(point.file, point.rule, point.source, point.exports, point.names);
   }
   for (const file of files.byPath.values()) {
     for (const alias of typeQueryAliases(file)) {
@@ -390,7 +495,11 @@ export function roots<Brand>(
     }
   }
 
-  const { tables: exportsOf, answered } = exportTables(project, held, [
+  const {
+    tables: exportsOf,
+    named,
+    answered,
+  } = exportTables(project, held, [
     ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
     ...published,
   ]);
@@ -401,8 +510,13 @@ export function roots<Brand>(
     }
     add(id, entry.kind, entry.source);
     if (entry.exports) {
-      for (const exported of exportsOf.get(entry.file.fileName) ?? []) {
-        add(exported, entry.kind, entry.source);
+      const byName = named.get(entry.file.fileName);
+      const exported =
+        entry.names === undefined || byName === undefined
+          ? (exportsOf.get(entry.file.fileName) ?? [])
+          : entry.names.flatMap((name) => byName.get(name) ?? []);
+      for (const one of exported) {
+        add(one, entry.kind, entry.source);
       }
     }
   }
@@ -433,6 +547,7 @@ export function roots<Brand>(
     liveUnderReachability: ordered,
     unmatched,
     unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
+    unmappedEntries,
   };
 }
 
@@ -448,12 +563,18 @@ function exportTables<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   wanted: readonly SourceFile[],
-): { readonly tables: ReadonlyMap<string, readonly string[]>; readonly answered: boolean } {
+): {
+  readonly tables: ReadonlyMap<string, readonly string[]>;
+  /** Per file whose table the checker answered, the declarations each export name reaches. */
+  readonly named: ReadonlyMap<string, ReadonlyMap<string, readonly string[]>>;
+  readonly answered: boolean;
+} {
   const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
   const tables = new Map<string, readonly string[]>();
+  const named = new Map<string, Map<string, string[]>>();
   let answered = true;
   if (unique.length === 0) {
-    return { tables, answered };
+    return { tables, named, answered };
   }
   const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
   const chains = aliasChains(project, held);
@@ -475,15 +596,18 @@ function exportTables<Brand>(
       return;
     }
     const ids = new Set<string>();
+    const byName = new Map<string, string[]>();
     for (const exported of table) {
       for (const target of chains.chainOf(exported)) {
         answered &&= !target.guessed;
         ids.add(target.id);
+        byName.set(exported.name, [...(byName.get(exported.name) ?? []), target.id]);
       }
     }
     tables.set(file.fileName, [...ids]);
+    named.set(file.fileName, byName);
   });
-  return { tables, answered };
+  return { tables, named, answered };
 }
 
 /** A release tag of a documentation comment: `@` and its name, between white space or the ends. */
@@ -553,11 +677,13 @@ function publishedAPI<Brand>(
   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 => {
-    if (!reached.has(id) && byId.get(id)?.kind !== "file") {
-      reached.add(id);
+    const file = byId.get(id)?.kind === "file";
+    if (!(file ? entered : reached).has(id)) {
+      (file ? entered : reached).add(id);
       pending.push(id);
     }
   };
@@ -566,11 +692,7 @@ function publishedAPI<Brand>(
   }
   for (const file of published) {
     for (const id of exportsOf.get(file.fileName) ?? []) {
-      if (byId.get(id)?.kind === "file") {
-        pending.push(id);
-      } else {
-        reach(id);
-      }
+      reach(id);
     }
   }
   while (pending.length > 0) {
@@ -595,8 +717,7 @@ function publishedAPI<Brand>(
       project,
       round.flatMap((id) => {
         const symbol = byId.get(id);
-        const node = symbol === undefined ? undefined : nodes.nodeOf(symbol);
-        return node === undefined ? [] : [node];
+        return symbol === undefined ? [] : nodes.nodesOf(symbol);
       }),
     )) {
       for (const target of chains.chainOf(symbol)) {
@@ -625,24 +746,22 @@ function declarationNodes(
   byPath: ReadonlyMap<string, SourceFile>,
 ): {
   typeNamesOf(symbol: InventorySymbol): readonly Node[];
-  nodeOf(symbol: InventorySymbol): Node | undefined;
+  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 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 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);
-          if (!found.byId.has(id)) {
-            found.byId.set(id, node);
-          }
+          found.byId.set(id, [...(found.byId.get(id) ?? []), node]);
         }
         node.forEachChild(visit);
       };
@@ -654,10 +773,9 @@ function declarationNodes(
   return {
     typeNamesOf: (symbol) => {
       const { byId, nodes } = nodesIn(symbol.position.path);
-      const declaration = byId.get(symbol.id);
-      return declaration === undefined ? [] : typeNamesOf(declaration, nodes);
+      return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
     },
-    nodeOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id),
+    nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
   };
 }