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

package/src/roots.ts

@@ -1,16 +1,22 @@
 /**
- * The root set of one project: every declaration the analysis keeps live without a
- * reference, and why.
- *
- * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
- * that names a caller is live under reference counting as well, which the sweep
- * decides; the published API only supposes a consumer, so a published export is live
- * under reachability and still a candidate under reference counting.
+ * The root set of one project: every declaration kept live without a reference, and why.
+ * Every root seeds reachability and none counts as a reference; a root of a kind that
+ * names a caller is live under reference counting too, which the sweep decides, so a
+ * 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,
@@ -18,24 +24,37 @@ import {
   isPropertyDeclaration,
   isVariableDeclaration,
   isVariableStatement,
+  SyntaxKind,
+  type Expression,
   type Node,
+  type ObjectLiteralExpression,
   type SourceFile,
 } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.ts";
-import type { ParseFile } from "./configuration-files.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 { 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 { 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 } from "./source-files.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 { commandDirectories, workflowCommands } from "./workflow-steps.ts";
 
 /** Why one declaration is a root. */
 export type RootKind =
@@ -62,6 +81,8 @@ export type RootKind =
   | "pattern"
   /** A declaration of a function or statement a type error skipped, and what it may have selected. */
   | "type-error"
+  /** An ambient global interface merging into one declared outside the target, and its holders. */
+  | "global-augmentation"
   /** A file a tool or the platform enters by its own convention, and what it exports where the tool reads it. */
   | EntryRule;
 
@@ -82,14 +103,9 @@ export interface Root {
 /** One project's roots, and every configured string that named nothing in it. */
 export interface Roots {
   /**
-   * Every root of this project, ordered by the site of the declaration it names,
-   * then by kind, then by the string that named it. A declaration that is a root for
-   * more than one reason appears once per reason, so an explanation can name every
-   * reason it is live.
-   *
-   * The member says which relation the set feeds: every declaration here is live
-   * under reachability. A root of a kind that names a caller is also live under
-   * reference counting, which the sweep decides.
+   * Every root of this project, live under reachability, ordered by the site of the
+   * declaration it names, then by kind, then by the string that named it. A declaration
+   * rooted for several reasons appears once per reason, so an explanation names each.
    */
   readonly liveUnderReachability: readonly Root[];
   /**
@@ -101,9 +117,22 @@ export interface Roots {
   /**
    * Every declaration of the project, where the checker left the module or export table
    * of an entry or a published file unanswered, since which of them that file exports is
-   * unknown; otherwise each one an unanswered published type name may name.
+   * unknown; otherwise each one an unanswered published type name may name. Beside them, each
+   * file of {@link heldScripts} and every declaration its export table names.
    */
   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[];
+  /** Every package whose command strings name, as `spelledFiles` reads them, an own file no root enters with all it exports. */
+  readonly heldScripts: readonly HeldScripts[];
+}
+
+/** One package's command strings, and the own files they name that no root enters with all they export. */
+export interface HeldScripts {
+  /** The package's directory, absolute. */
+  readonly dir: string;
+  /** Each file, by its path below the target root. */
+  readonly files: readonly string[];
 }
 
 /** What decides the roots beside the declarations themselves. */
@@ -134,6 +163,8 @@ export interface RootOptions {
    * inside the target whose entries are published API whatever the target's kind.
    */
   readonly publishedMembers?: ReadonlySet<string> | undefined;
+  /** The files the configurations read from a file hold, 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 +202,18 @@ 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 {
+  const between = ancestors(dirnamePath(file), dir);
+  return between.length > 0 && !between.slice(0, -1).some((at) => holdsManifest(host, at));
+}
+
 /**
  * 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 +233,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("?");
@@ -254,14 +331,6 @@ export function matchRef(pattern: string, ref: string): boolean {
   return matchGlob(Array.from(pattern), Array.from(ref));
 }
 
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /** 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[]>();
@@ -277,15 +346,60 @@ function childrenOf(held: Inventory): ReadonlyMap<string, readonly InventorySymb
 }
 
 /**
- * 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 everything its module exports: each name of the module's export
- * table, and where a name is a re-export, every link of the chain to the declaration
- * it carries, so a re-exported declaration is a root of the file that publishes it.
- * In a library, what a published file exports is rooted by the published API alone.
- * A file a runtime executes without reading its exports, a test file or a worker, is
- * a root by itself.
+ * Per package, the own files its command strings name as plain text, 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' whole command strings, and the target root's package has the
+ * workflow steps, git hooks and makefile recipes beside its own, with the directories its
+ * workflow steps and lefthook commands run in, where a `.` names that directory's index file.
+ */
+function scriptHolds(
+  entries: readonly ManifestEntry[],
+  files: SourceFiles,
+  entered: readonly {
+    readonly file: SourceFile;
+    readonly exports: boolean;
+    readonly names?: readonly string[];
+  }[],
+  host: Host,
+  targetRoot: string,
+): readonly HeldScripts[] {
+  const rooted = new Set(
+    entered.filter((one) => one.exports && one.names === undefined).map((one) => one.file.fileName),
+  );
+  const spelled = [...files.byName.values()]
+    .filter((file) => !rooted.has(file.fileName))
+    .map((file) => ({ file, paths: [file.fileName, ...files.writtenAs(file)] }));
+  const cwd = host.workingDirectory();
+  const commands = new Map<string, string[]>([
+    [
+      resolvePath(cwd, targetRoot),
+      [...workflowCommands(host, targetRoot), ...commandDirectories(host, targetRoot)],
+    ],
+  ]);
+  for (const entry of entries) {
+    if (entry.command !== undefined) {
+      const dir = resolvePath(cwd, entry.dir);
+      commands.set(dir, [...(commands.get(dir) ?? []), entry.command]);
+    }
+  }
+  const held: HeldScripts[] = [];
+  for (const [dir, texts] of commands) {
+    const named = spelledFiles(texts.join("\n"), dir, spelled);
+    if (named.length > 0) {
+      const paths = named.map((file) => relativePath(targetRoot, file.fileName) ?? file.fileName);
+      held.push({ dir, files: paths });
+    }
+  }
+  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>,
@@ -307,9 +421,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(
@@ -338,46 +464,96 @@ export function roots<Brand>(
     })),
   ];
   const scripted = entries.flatMap(({ entry }) =>
-    entry.role === "script" ? files.named(entry.path) : [],
+    entry.role === "script" && entry.command === 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[] => {
     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) {
       published.push(...entryFiles(entry));
     }
   }
-  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));
-    }
+  if (options.publishedAPI) {
+    // A library's bundle hands what its entry exports to every program that loads it.
+    published.push(
+      ...points.filter((point) => point.rule === "bundler-entry").map((point) => point.file),
+    );
   }
+  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)) {
-        enter(file, "entry-file", pattern, true);
+        patterned.push({ file, pattern });
       }
     }
   }
+  const unmapped: ManifestEntry[] = [];
+  const mapped = patterned.map(({ file }) => file);
+  for (const { entry } of entries) {
+    if (entry.command !== undefined) {
+      continue;
+    }
+    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);
   }
+  const heldScripts = scriptHolds(
+    entries.map(({ entry }) => entry),
+    files,
+    entered,
+    options.host,
+    targetRoot,
+  );
+  const heldFiles = [...new Set(heldScripts.flatMap((one) => one.files))].flatMap(
+    (path) => files.byPath.get(path) ?? [],
+  );
   for (const file of files.byPath.values()) {
     for (const alias of typeQueryAliases(file)) {
       const source = alias.type.getText().replace(/\s+/gu, " ");
@@ -390,9 +566,14 @@ 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,
+    ...heldFiles,
   ]);
   for (const entry of entered) {
     const id = fileIds.get(entry.file.fileName);
@@ -401,8 +582,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);
       }
     }
   }
@@ -426,13 +612,23 @@ export function roots<Brand>(
     const left = sites.get(a.id);
     const right = sites.get(b.id);
     const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
-    return site || compare(a.kind, b.kind) || compare(a.source, b.source);
+    return site || bytewise(a.kind, b.kind) || bytewise(a.source, b.source);
   });
 
   return {
     liveUnderReachability: ordered,
     unmatched,
-    unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
+    unanswered: [
+      ...(answered ? api.guessed : held.symbols.map((symbol) => symbol.id)),
+      // A command runs a held file and may read any export of it, so the file, which reaches its
+      // top level, and its exports are held; a declaration neither reaches is still dead.
+      ...heldFiles.flatMap((file) => {
+        const id = fileIds.get(file.fileName);
+        return [...(id === undefined ? [] : [id]), ...(exportsOf.get(file.fileName) ?? [])];
+      }),
+    ],
+    unmappedEntries,
+    heldScripts,
   };
 }
 
@@ -448,12 +644,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 +677,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. */
@@ -533,12 +738,12 @@ function releaseTagged(
 const EXPORTING_CONTAINERS: ReadonlySet<string> = new Set(["file", "namespace"]);
 
 /**
- * Every declaration a consumer of the library can name: what the published files export,
- * and below each the members a consumer writes, a namespace's exported ones and any other
- * declaration's public and protected ones. A declaration a published one's type names is
- * published too, and so is an exported declaration a release tag marks. A type name the
- * checker leaves unanswered publishes every declaration spelled as it is, as `guessed`. A
- * published file is not itself published.
+ * 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>,
@@ -553,11 +758,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,56 +773,87 @@ 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) {
-    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) {
+  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);
         }
       }
     }
-    const named = round.flatMap((id) => {
-      const symbol = byId.get(id);
-      return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
-    });
-    for (const symbol of inferredTypeSymbols(
-      project,
-      round.flatMap((id) => {
-        const symbol = byId.get(id);
-        const node = symbol === undefined ? undefined : nodes.nodeOf(symbol);
-        return node === undefined ? [] : [node];
-      }),
-    )) {
-      for (const target of chains.chainOf(symbol)) {
-        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);
+    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);
+          }
         }
-      } else if (symbol !== undefined) {
+      }
+      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] };
 }
 
@@ -625,24 +863,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 +890,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) ?? [],
   };
 }
 
@@ -665,30 +900,139 @@ function declarationNodes(
 const INFERRED_DEPTH = 4;
 
 /**
- * The declarations of the types the compiler infers where a declaration writes none: the
- * type of a variable or a property with no annotation, and the result of a function or a
- * method with no result annotation, each with the types its type arguments and its union
- * or intersection constituents name, to a fixed depth. A question the checker leaves
- * unanswered names nothing.
+ * 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 TSSymbol[] {
+): { readonly types: readonly TSSymbol[]; readonly members: readonly TSSymbol[] } {
   const { queries } = project;
-  const valued = declarations.flatMap((node) =>
+  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[] = [];
-  queries.typesAt(valued).forEach((type) => {
+  const returnedTypes: Type[] = [];
+  queries.typesAt([...valued, ...returned]).forEach((type, at) => {
     if (type !== UNANSWERED && type !== undefined) {
-      types.push(type);
+      (at < valued.length ? types : returnedTypes).push(type);
     }
   });
+  types.push(...returnedTypes);
   for (const node of declarations) {
     const signature = isFunctionLikeDeclaration(node)
       ? node
@@ -731,7 +1075,19 @@ function inferredTypeSymbols<Brand>(
   types.forEach((type) => {
     visit(type, 0);
   });
-  return [...found.values()];
+  // 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()] };
 }
 
 /**
@@ -793,13 +1149,10 @@ function configured(
 }
 
 /**
- * Every configured string that named no declaration in ANY project of the run, in
- * configuration order and each once.
- *
- * A finding about a configured root is about the configuration and not about a
- * declaration, so there is one per run: a string that names a declaration of one
- * project has named something, and the projects it named nothing in are not a
- * finding. A run with no project names nothing with any of them.
+ * Every configured string that named no declaration in any project of the run, in
+ * configuration order and each once. The finding is about the configuration, so a string
+ * naming a declaration of one project has named something, and a run with no project
+ * names nothing with any of them.
  */
 export function unmatchedEverywhere(
   patterns: readonly string[],