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

package/src/mdx-entries.ts

@@ -0,0 +1,241 @@
+/**
+ * The files the import declarations of the target's Markdown and MDX documents load. A
+ * document is read as text: a line outside a fenced code block that starts with `import`
+ * is an import declaration, which an MDX compiler hoists into the module it builds.
+ */
+
+import type { SourceFile } from "@typescript/native/ast";
+import { resolveRelativeSpecifier } from "./configuration-files.ts";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath, resolvePath } from "./paths.ts";
+import type { SourceFiles } from "./source-files.ts";
+
+/** One file a document imports, the specifier that named it, and the export names it reads. */
+interface DocumentEntry {
+  readonly file: SourceFile;
+  readonly source: string;
+  /** The export names the import reads, or undefined for a namespace import, which reads them all. */
+  readonly names: readonly string[] | undefined;
+}
+
+/** The directories no document is read below. */
+const SKIPPED: ReadonlySet<string> = new Set(["node_modules", ".git"]);
+
+/** The extensions of a document whose imports an MDX compiler reads. */
+const DOCUMENT = /\.mdx?$/u;
+
+/** A fence line, its marker run and what follows it captured. */
+const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/u;
+
+/** A string literal in either quote, its escapes included. */
+const STRING = String.raw`"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'`;
+
+/** An import declaration at the start of a line, its clause and its specifier captured. */
+const IMPORT_LINE = new RegExp(
+  String.raw`^import\s+(?:((?:[^"'\n]|${STRING})*?)\s+from\s*)?["']([^"'\n]+)["']`,
+  "u",
+);
+
+/** The braces of an import clause, what they hold captured. */
+const BRACES = new RegExp(String.raw`\{((?:[^}"']|${STRING})*)\}`, "u");
+
+/** One comma-separated part of a clause's braces. */
+const PART = new RegExp(String.raw`(?:[^,"']|${STRING})+`, "gu");
+
+/** A named import of a clause's braces: the exported name and an optional local alias. */
+const NAMED_IMPORT = new RegExp(String.raw`^([\w$]+|${STRING})(?:\s+as\s+[\w$]+)?$`, "u");
+
+/** The single-character escapes of a string literal and the character each stands for. */
+const SINGLE_ESCAPES: ReadonlyMap<string, string> = new Map([
+  ["b", "\b"],
+  ["f", "\f"],
+  ["n", "\n"],
+  ["r", "\r"],
+  ["t", "\t"],
+  ["v", "\v"],
+  ["0", "\0"],
+  ["'", "'"],
+  ['"', '"'],
+  ["\\", "\\"],
+]);
+
+/**
+ * One escape of a string literal: two hexadecimal digits, a code unit, a code point, or one
+ * character and the digit after it.
+ */
+const ESCAPE = /\\(?:x([\da-fA-F]{2})|u([\da-fA-F]{4})|u\{([\da-fA-F]+)\}|(.)(\d?))/gu;
+
+/** What one escape stands for, or undefined for one a module cannot hold. */
+function unescaped([, hex, unit, point, single, digit]: RegExpExecArray): string | undefined {
+  if (single === undefined) {
+    const code = Number.parseInt(hex ?? unit ?? point ?? "", 16);
+    return code <= 0x10ffff ? String.fromCodePoint(code) : undefined;
+  }
+  return /[1-9xu]/u.test(single) || (single === "0" && digit !== "")
+    ? undefined
+    : `${SINGLE_ESCAPES.get(single) ?? single}${digit ?? ""}`;
+}
+
+/**
+ * The value of a quoted export name, its escapes decoded, or undefined for an escape this
+ * reading does not decode. A module is strict code, so no legacy octal escape is valid.
+ */
+function quotedName(literal: string): string | undefined {
+  const body = literal.slice(1, -1);
+  let value = "";
+  let from = 0;
+  for (const escape of body.matchAll(ESCAPE)) {
+    const decoded = unescaped(escape);
+    if (decoded === undefined) {
+      return undefined;
+    }
+    value += body.slice(from, escape.index) + decoded;
+    from = escape.index + escape[0].length;
+  }
+  return value + body.slice(from);
+}
+
+/**
+ * The export names one import clause reads: `default` for a default binding and each name
+ * its braces list, or undefined for a namespace import, which reads every export, and for
+ * a clause this reading does not parse, which may read any.
+ */
+function clauseNames(clause: string): readonly string[] | undefined {
+  const braces = BRACES.exec(clause);
+  const head = (braces === null ? clause : clause.slice(0, braces.index))
+    .replace(/,\s*$/u, "")
+    .trim();
+  if (head.includes("*")) {
+    return undefined;
+  }
+  const names = head === "" ? [] : ["default"];
+  if (head !== "" && !/^[\w$]+$/u.test(head)) {
+    return undefined;
+  }
+  for (const part of (braces?.[1]?.match(PART) ?? []).map((one) => one.trim())) {
+    const named = NAMED_IMPORT.exec(part);
+    if (part === "") {
+      continue;
+    }
+    if (named?.[1] === undefined) {
+      return undefined;
+    }
+    const name = /^["']/u.test(named[1]) ? quotedName(named[1]) : named[1];
+    if (name === undefined) {
+      return undefined;
+    }
+    names.push(name);
+  }
+  return names;
+}
+
+/** Every document below `dir`, outside every skipped directory, by absolute path. */
+function documents(host: Host, dir: string): readonly string[] {
+  let entries;
+  try {
+    entries = host.readDirectory(dir);
+  } catch {
+    return [];
+  }
+  const found: string[] = [];
+  for (const entry of entries) {
+    const path = joinPath(dir, entry.name);
+    if (entry.directory) {
+      if (!SKIPPED.has(entry.name)) {
+        found.push(...documents(host, path));
+      }
+    } else if (DOCUMENT.test(entry.name)) {
+      found.push(path);
+    }
+  }
+  return found.sort();
+}
+
+/** The relative specifiers one document's import lines name, its fenced code blocks skipped. */
+function importedBy(
+  text: string,
+): readonly { readonly specifier: string; readonly names: readonly string[] | undefined }[] {
+  const found: { specifier: string; names: readonly string[] | undefined }[] = [];
+  let open: string | undefined;
+  for (const line of text.split(/\r?\n/u)) {
+    const fence = FENCE.exec(line);
+    const marker = fence?.[1];
+    if (marker !== undefined && open === undefined) {
+      open = marker;
+      continue;
+    }
+    // https://spec.commonmark.org/0.31.2/#fenced-code-blocks: only a run of the opening
+    // character, at least as long and followed by nothing, closes a fence.
+    if (
+      marker !== undefined &&
+      open !== undefined &&
+      marker.startsWith(open.slice(0, 1)) &&
+      marker.length >= open.length &&
+      fence?.[2]?.trim() === ""
+    ) {
+      open = undefined;
+      continue;
+    }
+    const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
+    const specifier = matched?.[2];
+    if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+      found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
+    }
+  }
+  return found;
+}
+
+/** One document below a target root, by absolute path, and what its import lines name. */
+interface DocumentImports {
+  readonly path: string;
+  readonly imports: ReturnType<typeof importedBy>;
+}
+
+/**
+ * The documents each host's target roots hold, which every project of a run reads alike,
+ * kept for the host's life as {@link Host} allows.
+ */
+const documentsOf = new WeakMap<Host, Map<string, readonly DocumentImports[]>>();
+
+/** Every readable document below `root` and the import lines it writes, read once per host. */
+function documentImports(host: Host, root: string): readonly DocumentImports[] {
+  const byRoot = documentsOf.get(host) ?? new Map<string, readonly DocumentImports[]>();
+  documentsOf.set(host, byRoot);
+  const known = byRoot.get(root);
+  if (known !== undefined) {
+    return known;
+  }
+  const found = documents(host, root).flatMap((path) => {
+    try {
+      return [{ path, imports: importedBy(host.readFile(path)) }];
+    } catch {
+      return [];
+    }
+  });
+  byRoot.set(root, found);
+  return found;
+}
+
+/**
+ * Every own file one document below the target root imports by a relative specifier,
+ * read against the document's directory, on disk or through the emit mapping.
+ */
+export function documentEntries(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+): readonly DocumentEntry[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  const found: DocumentEntry[] = [];
+  for (const { path, imports } of documentImports(host, root)) {
+    const dir = dirnamePath(path);
+    for (const { specifier, names } of imports) {
+      const reached = resolveRelativeSpecifier(host, dir, specifier);
+      const held = reached === undefined ? undefined : files.byName.get(reached);
+      for (const file of held === undefined ? files.named(resolvePath(dir, specifier)) : [held]) {
+        found.push({ file, source: specifier, names });
+      }
+    }
+  }
+  return found;
+}

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/namespace-objects.ts

@@ -1,7 +1,7 @@
 /**
  * Module namespace objects: the binding of a namespace import, the value an `await` of a
  * dynamic `import()` produces, the first parameter of the first callback passed to `then`
- * on one, and a `const` binding initialized with one of these. A use reads the exports it
+ * on one, and a variable binding initialized with one of these. A use reads the exports it
  * names and no other: a property access by name or by a literal index, or a destructured
  * property, names one export, and any other use may read every export.
  */
@@ -9,22 +9,26 @@
 import {
   isArrowFunction,
   isAwaitExpression,
-  isBindingElement,
   isCallExpression,
+  isClassStaticBlockDeclaration,
   isElementAccessExpression,
   isExpressionStatement,
   isFunctionExpression,
+  isFunctionLikeDeclaration,
   isIdentifier,
   isImportDeclaration,
+  isModuleBlock,
   isNamespaceImport,
   isNoSubstitutionTemplateLiteral,
   isObjectBindingPattern,
   isParenthesizedExpression,
   isPropertyAccessExpression,
   isQualifiedName,
+  isSourceFile,
   isStringLiteral,
   isVariableDeclaration,
   isVariableDeclarationList,
+  isVariableStatement,
   isVoidExpression,
   NodeFlags,
   SyntaxKind,
@@ -32,6 +36,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
+import { spellsNoBinding } from "./spelled-names.ts";
 
 /** What one use of a namespace object reads beyond the names the checker resolves. */
 type NamespaceUse =
@@ -62,23 +67,33 @@ function isLiteralImport(node: Node): boolean {
   return argument !== undefined && isLiteralText(argument);
 }
 
-/** The node a `const` binding's name is visible below: the block or file its statement is in. */
-function scopeOf(declaration: Node): Node {
-  const statement = declaration.parent.parent;
-  return statement.parent;
+/**
+ * The node the binding one declaration list declares is visible below: for `let` and
+ * `const`, the loop whose head declares it, or else the block or file its statement is
+ * in; for `var`, the function, namespace body, static block or file that holds it.
+ */
+function scopeOf(list: Node): Node {
+  if ((list.flags & (NodeFlags.Let | NodeFlags.Const | NodeFlags.Using)) !== 0) {
+    return isVariableStatement(list.parent) ? list.parent.parent : list.parent;
+  }
+  let at = list.parent;
+  while (
+    !isSourceFile(at) &&
+    !isFunctionLikeDeclaration(at) &&
+    !isModuleBlock(at) &&
+    !isClassStaticBlockDeclaration(at)
+  ) {
+    at = at.parent;
+  }
+  return at;
 }
 
-/** Every identifier below `scope` that spells `name`, other than `declared` and a member's name. */
+/** Every identifier below `scope` that spells `name` as a reference, other than `declared`. */
 function occurrences(scope: Node, name: string, declared: Node): readonly Identifier[] {
   const found: Identifier[] = [];
   const visit = (node: Node): void => {
     if (isIdentifier(node)) {
-      const parent = node.parent;
-      const member =
-        (isPropertyAccessExpression(parent) && parent.name === node) ||
-        (isQualifiedName(parent) && parent.right === node) ||
-        (isBindingElement(parent) && parent.propertyName === node);
-      if (node !== declared && node.text === name && !member) {
+      if (node !== declared && node.text === name && !spellsNoBinding(node)) {
         found.push(node);
       }
       return;
@@ -92,8 +107,8 @@ function occurrences(scope: Node, name: string, declared: Node): readonly Identi
 /**
  * Every use of the namespace objects one file holds, keyed by the node the use is written
  * at, that reads more than a name the checker resolves: an indexed read by a literal, and
- * any use that may read every export. A shadowing declaration of a binding's name inside
- * its scope is read as the binding, which can only keep an export live.
+ * any use that may read every export. A use of a shadowing declaration of a binding's
+ * name inside its scope is read as a use of the binding, which can only keep an export live.
  */
 export function namespaceUses(file: SourceFile): ReadonlyMap<Node, NamespaceUse> {
   const uses = new Map<Node, NamespaceUse>();
@@ -142,13 +157,11 @@ export function namespaceUses(file: SourceFile): ReadonlyMap<Node, NamespaceUse>
         }
         return;
       }
+      // A binding that is not `const` is followed too: each assignment to it is an
+      // occurrence `value` cannot narrow, so a reassigned binding still reads every export.
       const list = parent.parent;
-      if (
-        isIdentifier(pattern) &&
-        isVariableDeclarationList(list) &&
-        (list.flags & NodeFlags.Const) !== 0
-      ) {
-        binding(pattern, scopeOf(parent), specifier, seen);
+      if (isIdentifier(pattern) && isVariableDeclarationList(list)) {
+        binding(pattern, scopeOf(list), specifier, seen);
         return;
       }
     }

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 {
@@ -26,6 +25,11 @@ import { nameComponent } from "./ref.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 
+const CLASS_DECLARATIONS: ReadonlySet<SyntaxKind> = new Set([
+  SyntaxKind.ClassDeclaration,
+  SyntaxKind.ClassExpression,
+]);
+
 /** The member kinds a subclass overrides. */
 const OVERRIDABLE: ReadonlySet<string> = new Set(["method", "class-member"]);
 
@@ -110,9 +114,16 @@ export function overrideReferences<Brand>(
       if (
         inTarget.length === 0 &&
         declared !== UNANSWERED &&
-        (declared.flags & SymbolFlags.Class) !== 0 &&
-        declared.declarations.length > 0 &&
-        declared.declarations.every((handle) => !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);
       }
@@ -177,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`,
       ),
@@ -210,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/paths.ts

@@ -67,6 +67,16 @@ export function dirnamePath(path: string): string {
   return cut === 0 ? SEPARATOR : normalized.slice(0, cut);
 }
 
+/**
+ * The extension of one path's last segment, from its last full stop, or the empty string
+ * where it has none. A segment that only starts with a full stop has none.
+ */
+export function extensionOf(path: string): string {
+  const name = path.slice(path.lastIndexOf(SEPARATOR) + 1);
+  const dot = name.lastIndexOf(".");
+  return dot <= 0 ? "" : name.slice(dot);
+}
+
 /** One path resolved against a directory, absolute where that directory is. */
 export function resolvePath(against: string, path: string): string {
   return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);

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";
 
 /**
@@ -196,10 +203,10 @@ export interface ReferenceCost {
   /** Per-type lookups for the contextual uses: each distinct type's constituents, properties and symbol. */
   readonly contextualLookups: number;
   /**
-   * The requests the passes that read members through the checker's types make: element
-   * accesses, key comparisons, instantiated signatures and values handed to unimplemented
-   * callees. They are
-   * counted where the caller measures the client, through `requestCount`, and are 0 otherwise.
+   * The requests the passes after the walk make: the bases overrides are read against,
+   * element accesses, key comparisons, instantiated signatures, values handed to
+   * unimplemented callees and the modules a `declare module` names. They are counted
+   * where the caller measures the client, through `requestCount`, and are 0 otherwise.
    */
   readonly typedLookups: number;
 }
@@ -1060,19 +1067,28 @@ export function references<Brand>(
   const fileIds = new Set(
     held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id),
   );
-  let topLevel: ReadonlyMap<string, readonly InventorySymbol[]> | undefined;
-  /** The declarations one file's top level holds. */
-  const declaredIn = (fileId: string): readonly InventorySymbol[] => {
-    if (topLevel === undefined) {
-      const byParent = new Map<string, InventorySymbol[]>();
+  let moduleBodies: ReadonlyMap<string, readonly InventorySymbol[]> | undefined;
+  /**
+   * The declarations one module holds directly: a file's top level, or the body of a
+   * `declare module` whose name is a string. Any other declaration holds none here.
+   */
+  const declaredIn = (moduleId: string): readonly InventorySymbol[] => {
+    if (moduleBodies === undefined) {
+      const byModule = new Map<string, InventorySymbol[]>();
       for (const symbol of held.symbols) {
-        if (fileIds.has(symbol.parent)) {
-          byParent.set(symbol.parent, [...(byParent.get(symbol.parent) ?? []), symbol]);
+        if (!fileIds.has(symbol.parent) && !held.modules.has(symbol.parent)) {
+          continue;
+        }
+        const siblings = byModule.get(symbol.parent);
+        if (siblings === undefined) {
+          byModule.set(symbol.parent, [symbol]);
+        } else {
+          siblings.push(symbol);
         }
       }
-      topLevel = byParent;
+      moduleBodies = byModule;
     }
-    return topLevel.get(fileId) ?? [];
+    return moduleBodies.get(moduleId) ?? [];
   };
 
   const exportsCache = new Map<number, readonly ChainTarget[]>();
@@ -1431,9 +1447,12 @@ export function references<Brand>(
 
     for (const url of urls) {
       const constructor = url.constructor === undefined ? undefined : answered.get(url.constructor);
+      // An augmentation of the global `URL` merges into it, which keeps the
+      // library's declaration; a `URL` the target declares has no other.
       if (
         typeof constructor === "object" &&
-        constructor.declarations.some((handle) => ownPaths.has(handle.path))
+        constructor.declarations.length > 0 &&
+        constructor.declarations.every((handle) => ownPaths.has(handle.path))
       ) {
         continue;
       }
@@ -1604,14 +1623,16 @@ export function references<Brand>(
 
   let typedLookups = 0;
   if (consumer === undefined) {
-    found.push(...overrideReferences(project, held, chains, new Set(tests)));
     const before = options.requestCount?.() ?? 0;
+    found.push(...overrideReferences(project, held, chains, new Set(tests)));
     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)));
-    typedLookups = (options.requestCount?.() ?? 0) - before;
     found.push(...moduleDeclarationReferences(project, held, root, new Set(tests)));
+    typedLookups = (options.requestCount?.() ?? 0) - before;
   }
   const scripts = new Set(
     walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId),