@cplieger/deadset-ts 6.0.1 → 6.1.0

package/src/convention-rows.ts

@@ -31,6 +31,20 @@ export interface ShortNameReading extends MoveReading {
   readonly package: string;
 }
 
+/**
+ * One configuration property whose value makes the tool's output import a runtime helper
+ * package, so the package is used where the property holds that value.
+ */
+export interface HelperReading extends MoveReading {
+  /**
+   * The value: `true`, or a string the property holds, alone, as an element of an array,
+   * or as the first element of an array that is such an element.
+   */
+  readonly value: true | string;
+  /** The package the output imports its helpers from. */
+  readonly package: string;
+}
+
 /** One directory a row's globs name that a configuration property moves. */
 export interface DirectoryMove {
   /** The placeholder the row's globs and later moves write as `<id>`. */
@@ -71,6 +85,8 @@ export interface ConventionRow {
   readonly selections?: readonly MoveReading[];
   /** The members of a `package.json` the tool reads its configuration from. */
   readonly manifestKeys?: readonly string[];
+  /** The settings that make the tool's output import a runtime helper package. */
+  readonly helpers?: readonly HelperReading[];
 }
 
 const SCRIPT = "{js,jsx,ts,tsx}";
@@ -105,6 +121,12 @@ const SOLIDSTART_PLUGIN = { module: "@solidjs/start/config", export: "solidStart
 
 const NUXT_CONFIG = [`nuxt.config.${ANY_MODULE}`];
 
+const BABEL_CONFIG = [
+  "babel.config.{json,js,cjs,mjs,cts,mts,ts}",
+  ".babelrc",
+  ".babelrc.{json,js,cjs,mjs,cts}",
+];
+
 const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
 const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
 const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
@@ -132,6 +154,19 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "babel",
+    package: "@babel/core",
+    range: ">=7.0.0 <9.0.0",
+    entries: [],
+    moves: [],
+    helpers: ["@babel/plugin-transform-runtime", "@babel/transform-runtime"].map((value) => ({
+      property: "plugins",
+      files: BABEL_CONFIG,
+      value,
+      package: "@babel/runtime",
+    })),
+  },
   {
     name: "eslint",
     package: "eslint",
@@ -304,6 +339,21 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "rolldown",
+    package: "rolldown",
+    range: ">=1.0.0 <2.0.0",
+    entries: [],
+    moves: [],
+    helpers: [
+      {
+        property: "transform.helpers.mode",
+        files: [`rolldown.config.${ANY_MODULE}`],
+        value: "Runtime",
+        package: "@oxc-project/runtime",
+      },
+    ],
+  },
   {
     name: "solidstart",
     package: "@solidjs/start",
@@ -350,7 +400,10 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
     range: ">=7.0.0 <11.0.0",
     entries: [STRYKER_MODULE],
     moves: [],
-    selections: [{ property: "mutate", files: [STRYKER_CONFIG] }],
+    selections: [
+      { property: "mutate", files: [STRYKER_CONFIG] },
+      { property: "ignorePatterns", files: [STRYKER_CONFIG] },
+    ],
     shortNames: [
       {
         property: "testRunner",
@@ -481,6 +534,36 @@ export const CONVENTION_ROWS: readonly ConventionRow[] = [
       },
     ],
   },
+  {
+    name: "swc",
+    package: "@swc/core",
+    range: ">=1.0.0 <2.0.0",
+    entries: [],
+    moves: [],
+    helpers: [
+      {
+        property: "jsc.externalHelpers",
+        files: [".swcrc"],
+        value: true,
+        package: "@swc/helpers",
+      },
+    ],
+  },
+  {
+    name: "vite",
+    package: "vite",
+    range: ">=8.0.0 <9.0.0",
+    entries: [],
+    moves: [],
+    helpers: [
+      {
+        property: "oxc.helpers.mode",
+        files: [VITE_CONFIG],
+        value: "Runtime",
+        package: "@oxc-project/runtime",
+      },
+    ],
+  },
   {
     name: "vitest",
     package: "vitest",

package/src/conventions.ts

@@ -50,6 +50,7 @@ import {
   CONVENTION_ROWS,
   type ConventionRow,
   type DirectoryMove,
+  type HelperReading,
   type MoveReading,
   type OptionsCall,
   type ShortNameReading,
@@ -110,7 +111,10 @@ export interface Conventions {
   readonly globs: readonly ConventionGlob[];
   readonly generated: readonly GeneratedDirectory[];
   readonly failures: readonly ConventionFailure[];
-  /** The dependencies the applied rows' short names and manifest keys use, by name, each once. */
+  /**
+   * The dependencies the applied rows' short names, manifest keys and helper settings use,
+   * by name, each once.
+   */
   readonly uses: readonly string[];
   /** Per configuration file, absolute, the strings its applied rows' selection keys hold. */
   readonly selected: ReadonlyMap<string, Selected>;
@@ -136,6 +140,9 @@ type ParseSource = (fileName: string, text: string) => SourceFile;
 
 const JSON_EXTENSION = ".json";
 
+/** A configuration file with no extension that its tool reads as a JSON document. */
+const JSON_RC = /^\.[\w-]+rc$/u;
+
 /** The sections an installed package is required by, so its absence fails the run. */
 const REQUIRED_SECTIONS = ["dependencies", "devDependencies"] as const;
 
@@ -533,11 +540,10 @@ function readPath(
 }
 
 /**
- * Every string literal one file writes at one property's path inside the objects it is
- * read from, as {@link readProperty} reads them: the value itself, or each element of an
- * array value, whatever else the path holds.
+ * Every value one file writes at one property's path inside the objects it is read from,
+ * as {@link readProperty} reads them, whatever else the path holds.
  */
-function stringsAt(file: SourceFile, property: string, call?: OptionsCall): readonly Node[] {
+function valuesAt(file: SourceFile, property: string, call?: OptionsCall): readonly Node[] {
   const declared = declaredValues(file);
   const objects =
     call === undefined
@@ -558,10 +564,8 @@ function stringsAt(file: SourceFile, property: string, call?: OptionsCall): read
       const held = unwrapped(member.initializer);
       if (rest.length > 0) {
         visit(held, rest);
-      } else if (literalText(held) !== undefined) {
+      } else {
         found.push(held);
-      } else if (isArrayLiteralExpression(held)) {
-        found.push(...held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined));
       }
     }
   };
@@ -573,6 +577,36 @@ function stringsAt(file: SourceFile, property: string, call?: OptionsCall): read
   return found;
 }
 
+/** The string literals among values: each value itself, or each element of an array value. */
+function stringsAt(file: SourceFile, property: string, call?: OptionsCall): readonly Node[] {
+  return valuesAt(file, property, call).flatMap((held) => {
+    if (literalText(held) !== undefined) {
+      return [held];
+    }
+    return isArrayLiteralExpression(held)
+      ? held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined)
+      : [];
+  });
+}
+
+/** Whether one value holds a helper setting's value, as {@link HelperReading} states it. */
+function holdsValue(held: Node, value: true | string): boolean {
+  if (value === true) {
+    return held.kind === SyntaxKind.TrueKeyword;
+  }
+  if (literalText(held) === value) {
+    return true;
+  }
+  return (
+    isArrayLiteralExpression(held) &&
+    held.elements.some((element) => {
+      const one = unwrapped(element);
+      const first = isArrayLiteralExpression(one) ? one.elements[0] : one;
+      return first !== undefined && literalText(first) === value;
+    })
+  );
+}
+
 /** The strings an applied row's selection keys hold, added per configuration file to `into`. */
 function selectedStrings(
   host: Host,
@@ -760,7 +794,11 @@ function readingFiles(
       } catch {
         continue;
       }
-      found.push({ name, text, file: parse(path, text) });
+      found.push({
+        name,
+        text,
+        file: parse(JSON_RC.test(name) ? `${path}${JSON_EXTENSION}` : path, text),
+      });
     }
   }
   return found;
@@ -808,6 +846,33 @@ function shortNameUses(
   return [...used].filter((name) => declared.has(name)).sort(compare);
 }
 
+/** The declared dependencies an applied row's helper settings use. */
+function helperUses(
+  host: Host,
+  parse: ParseSource,
+  dir: string,
+  manifest: unknown,
+  readings: readonly HelperReading[],
+): readonly string[] {
+  const declared = new Set(
+    DEPENDENCY_SECTIONS.flatMap((section) => {
+      const held = isRecord(manifest) ? manifest[section] : undefined;
+      return isRecord(held) ? Object.keys(held) : [];
+    }),
+  );
+  return readings
+    .filter(
+      (reading) =>
+        declared.has(reading.package) &&
+        readingFiles(host, parse, dir, reading.files).some(({ file }) =>
+          valuesAt(file, reading.property, reading.call).some((held) =>
+            holdsValue(held, reading.value),
+          ),
+        ),
+    )
+    .map((reading) => reading.package);
+}
+
 /** Two strings ordered bytewise. */
 function compare(a: string, b: string): number {
   if (a === b) {
@@ -897,6 +962,9 @@ export function readConventions(
       for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
         uses.add(name);
       }
+      for (const name of helperUses(host, parse, manifest.dir, declared, row.helpers ?? [])) {
+        uses.add(name);
+      }
       selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
       const excludes = [
         ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),

package/src/edges.ts

@@ -200,9 +200,10 @@ function compare(a: string, b: string): number {
 
 /**
  * Evaluates every declared side of this language over the run's findings. A side naming a
- * symbol the run enumerates nothing under is `absent`; one naming a symbol the run holds a
- * finding about is `dead` and carries that finding, pending until a merge reads the other
- * side and reported nowhere else, a narrowing finding included; any other is `live`.
+ * symbol the run enumerates nothing under is `absent`; otherwise it is evaluated once per
+ * declaration its reference spells. A declaration the run holds a finding about is `dead`
+ * and carries that finding, pending until a merge reads the other side and reported
+ * nowhere else, a narrowing finding included; any other is `live`.
  */
 export function evaluateEdges<F extends Finding>(
   findings: readonly F[],
@@ -212,10 +213,10 @@ export function evaluateEdges<F extends Finding>(
   if (sides.length === 0) {
     return { findings, evaluations: [] };
   }
-  const byRef = new Map<string, string>();
+  const byRef = new Map<string, string[]>();
   for (const symbol of symbols) {
-    if (symbol.kind !== "file" && !byRef.has(symbol.ref)) {
-      byRef.set(symbol.ref, symbol.id);
+    if (symbol.kind !== "file") {
+      byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
     }
   }
   const held = new Map<string, number>();
@@ -226,18 +227,20 @@ export function evaluateEdges<F extends Finding>(
   });
 
   const pending = new Set<number>();
-  const evaluations = sides.map((side): EdgeEvaluation<F> => {
-    const id = byRef.get(side.symbol);
-    if (id === undefined) {
-      return { ...side, state: "absent" };
+  const evaluations = sides.flatMap((side): EdgeEvaluation<F>[] => {
+    const ids = byRef.get(side.symbol);
+    if (ids === undefined) {
+      return [{ ...side, state: "absent" }];
     }
-    const at = held.get(id);
-    const finding = at === undefined ? undefined : findings[at];
-    if (at === undefined || finding === undefined) {
-      return { ...side, state: "live" };
-    }
-    pending.add(at);
-    return { ...side, state: "dead", finding };
+    return ids.map((id) => {
+      const at = held.get(id);
+      const finding = at === undefined ? undefined : findings[at];
+      if (at === undefined || finding === undefined) {
+        return { ...side, state: "live" };
+      }
+      pending.add(at);
+      return { ...side, state: "dead", finding };
+    });
   });
   evaluations.sort((a, b) => compare(a.edge, b.edge) || compare(a.side, b.side));
   return { findings: findings.filter((_finding, at) => !pending.has(at)), evaluations };

package/src/findings/emitters.ts

@@ -127,8 +127,7 @@ function dialsOver(
  * family's findings completed by one step, so every component number is minted once, the
  * finding each record claims withheld, the rest withheld by the dials, so a root one family
  * reports withholds what another reports in its component, and every declared edge
- * evaluated over what remains, so a pending finding is in its evaluation alone. What the
- * minimum confidence withheld is what the same decision at the lowest minimum adds.
+ * evaluated over what remains, so a pending finding is in its evaluation alone.
  */
 export function decidedFindings(
   input: EmitterInput,
@@ -138,20 +137,7 @@ export function decidedFindings(
   const unmarked =
     suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked, fallenMembers);
   const would = [...unmarked, ...found];
-  const decided = dialledOver(input, suppressed, found, unmarked);
-  const shown =
-    input.config.analysis.minConfidence === "possible"
-      ? decided
-      : dialledOver(
-          atPossible(input),
-          {
-            unmarked: atPossible(suppressed.unmarked),
-            records: suppressed.records,
-          },
-          found,
-          unmarked,
-        );
-  return { ...decided, would, withheld: withheldOf(decided.findings, shown.findings) };
+  return { ...dialledOver(input, suppressed, found, unmarked), would };
 }
 
 /** The run's input with the minimum confidence at its lowest, which withholds nothing. */
@@ -173,48 +159,46 @@ function dialledOver(
   suppressed: Suppressed,
   found: readonly CompletedFinding[],
   unmarked: readonly CompletedFinding[],
-): Omit<DecidedFindings, "would" | "withheld"> {
+): Omit<DecidedFindings, "would"> {
   const would = [...unmarked, ...found];
   const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
   const unanswered = heldKeys(input);
   const markup = markupKeys(input);
-  const kept = reportable(
-    input,
-    found.filter((finding) => {
-      const key = declarationKey(finding.symbol.ref, finding.position.path);
-      return (
-        !ledger.withheld(finding) &&
-        !unanswered.has(key) &&
-        !markup.has(key) &&
-        !insideSkipped(input.swept.skipped, finding.position)
-      );
-    }),
-  );
+  const candidates = found.filter((finding) => {
+    const key = declarationKey(finding.symbol.ref, finding.position.path);
+    return (
+      !ledger.withheld(finding) &&
+      !unanswered.has(key) &&
+      !markup.has(key) &&
+      !insideSkipped(input.swept.skipped, finding.position)
+    );
+  });
+  const kept = reportable(input, candidates);
   const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
-  return { findings: evaluated.findings, evaluations: evaluated.evaluations, ledger };
+  return {
+    findings: evaluated.findings,
+    evaluations: evaluated.evaluations,
+    ledger,
+    withheld: withheldOf(input, candidates),
+  };
 }
 
-/** The findings the lowest minimum would report that the run does not, counted by confidence. */
-function withheldOf(
-  reported: readonly CompletedFinding[],
-  shown: readonly CompletedFinding[],
-): Withheld {
-  const kept = new Set(reported.map(findingKey));
+/**
+ * The findings the dials withhold only because their confidence is below the minimum, each
+ * counted at the confidence this run gives it: the dials at the lowest minimum keep them.
+ */
+function withheldOf(input: EmitterInput, candidates: readonly CompletedFinding[]): Withheld {
+  const dials = dialsOf(input, candidates);
+  const lowest = dialsOf(atPossible(input), candidates);
   const counts = { certain: 0, probable: 0, possible: 0 };
-  for (const finding of shown) {
-    if (!kept.has(findingKey(finding))) {
+  for (const finding of candidates) {
+    if (dials.withholds(finding) && !lowest.withholds(finding)) {
       counts[finding.confidence] += 1;
     }
   }
   return counts;
 }
 
-/** A finding's identity across two decisions of one run: its position, code and subject. */
-function findingKey(finding: CompletedFinding): string {
-  const { path, line, column } = finding.position;
-  return JSON.stringify([path, line, column, finding.code, finding.symbol.ref]);
-}
-
 /** Every finding the run reports, each family's in table order. */
 export function findingsOf(input: EmitterInput): readonly CompletedFinding[] {
   return decidedFindings(input).findings;

package/src/inventory.ts

@@ -1110,7 +1110,12 @@ function refOf(record: Building, chain: readonly Component[]): string {
     return renderRef(record.module, { of: "module" });
   }
   if (record.kind === "export-alias") {
-    return renderRef(record.module, { of: "alias", name: record.component.text });
+    const block = record.parentChain.at(-1);
+    return renderRef(record.module, {
+      of: "alias",
+      name: record.component.text,
+      ...(block === undefined ? {} : { block: block.text }),
+    });
   }
   return renderRef(record.module, {
     of: "declaration",

package/src/module-declarations.ts

@@ -26,7 +26,7 @@ import {
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
-import { nameComponent } from "./ref.ts";
+import { aliasFragment, nameComponent } from "./ref.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -110,7 +110,7 @@ interface Named {
  * The module declarations of an inventory a specifier names by name or pattern, each with
  * the members that hold the export names given.
  */
-export function namedBy(
+function namedBy(
   held: Inventory,
 ): (specifier: string, names: readonly string[]) => readonly Named[] {
   if (held.modules.size === 0) {
@@ -139,7 +139,7 @@ export function namedBy(
       const wanted = new Set(
         names.flatMap((one) => [
           `${ref}.${nameComponent(one)}`,
-          `${scope}#${nameComponent(one)}:alias`,
+          `${scope}#${aliasFragment(one, name)}`,
         ]),
       );
       const members = (children.get(id) ?? []).filter((child) => wanted.has(child.ref));

package/src/outside-tests.ts

@@ -1,10 +1,10 @@
 /**
  * The test files no compiler configuration of a run holds. The runner executes them all
  * the same, so each module one names is a test reference: the own file a relative
- * specifier names, and the declarations that file exports under the names read from it,
- * or a module declaration the specifier names by name or pattern and its members of
- * those names. Such a file is read without a program, so what its body references
- * beyond the modules it names is not known.
+ * specifier names, and the declarations that file exports under the names read from it.
+ * No compiler run reads a module declaration for such a file, so its imports name none.
+ * Such a file is read without a program, so what its body references beyond the modules
+ * it names is not known.
  */
 
 import {
@@ -23,7 +23,7 @@ import { RESOLVED_EXTENSIONS, type ParseFile } from "./configuration-files.ts";
 import { emittedFrom } from "./emit-map.ts";
 import type { Host } from "./host.ts";
 import type { Inventory } from "./inventory.ts";
-import { namedBy, namesImported } from "./module-declarations.ts";
+import { namesImported } from "./module-declarations.ts";
 import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.ts";
 import { renderPosition } from "./position.ts";
 import { nameComponent } from "./ref.ts";
@@ -154,7 +154,6 @@ export function outsideTestReferences(
       exported.set(key, [...(exported.get(key) ?? []), symbol.id]);
     }
   }
-  const declared = namedBy(held);
   const found: Reference[] = [];
   for (const { path, file } of tests) {
     const from = `${path}#`;
@@ -164,11 +163,6 @@ export function outsideTestReferences(
       const read = (to: string, use: Reference["use"]): void => {
         found.push({ from, to, position, use, resolution: "syntax", test: true, unheld: true });
       };
-      for (const declaration of declared(named.text, named.names)) {
-        for (const to of [declaration.id, ...declaration.members]) {
-          read(to, "read");
-        }
-      }
       const written = named.text.includes("?") ? queriedModulePath(named.text) : named.text;
       if (written === undefined) {
         continue;

package/src/overrides.ts

@@ -1,9 +1,10 @@
 /**
  * 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 overriding a member of a class
- * declared outside the target, at any depth of its `extends` chain, is called by outside
- * code holding the instance through that class, so its own class references it.
+ * 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.
  */
 
 import {
@@ -19,8 +20,9 @@ import {
 import type { AliasChains } from "./alias-chain.ts";
 import { memberComponent } from "./class-members.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { SymbolFlags, type Symbol as TSSymbol } from "@typescript/native/unstable/sync";
+import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/unstable/sync";
 import { UNANSWERED } from "./query.ts";
+import { nameComponent } from "./ref.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 
@@ -60,7 +62,7 @@ function extending<Brand>(
 
 /**
  * The references each base class member makes to its overrides, for the classes of one
- * project that extend another class of the target, and each class makes to its methods
+ * project that extend another class of the target, and each class makes to its members
  * that override a member of a class declared outside the target. A member a nearer base
  * already overrides is reached through that override. A private member is not
  * overridden. Each reference is placed at the override and made by its file.
@@ -134,7 +136,7 @@ export function overrideReferences<Brand>(
   const outsideNames = outsideMemberNames(project, bases, outsideBases);
   for (const [classId, names] of outsideNames) {
     for (const [component, member] of members.get(classId) ?? []) {
-      if (member.kind === "method" && names.has(component)) {
+      if (names.has(component)) {
         found.push({
           from: classId,
           to: member.id,
@@ -166,7 +168,8 @@ export function overrideReferences<Brand>(
 
 /**
  * Per class of the target with a class declared outside the target in its `extends`
- * chain, the names of the members that outside class's instances carry.
+ * chain, the member components that outside class's instances and constructor carry, a
+ * static one spelled as a static member's component is.
  */
 function outsideMemberNames<Brand>(
   project: ProjectView<Brand>,
@@ -175,10 +178,16 @@ function outsideMemberNames<Brand>(
 ): ReadonlyMap<string, ReadonlySet<string>> {
   const direct = new Map<string, ReadonlySet<string>>();
   for (const [classId, base] of outsideBases) {
-    const type = project.queries.declaredTypeOf(base);
-    const properties = type === UNANSWERED ? UNANSWERED : project.queries.propertiesOf(type);
-    if (properties !== UNANSWERED) {
-      direct.set(classId, new Set(properties.map((property) => property.escapedName)));
+    const instance = project.queries.declaredTypeOf(base);
+    const statics = project.queries.typeOfSymbol(base);
+    const components = [
+      ...namesOf(project, instance === UNANSWERED ? undefined : instance).map(nameComponent),
+      ...namesOf(project, statics === UNANSWERED ? undefined : statics).map(
+        (name) => `${nameComponent(name)}:static`,
+      ),
+    ];
+    if (components.length > 0) {
+      direct.set(classId, new Set(components));
     }
   }
   const names = new Map<string, ReadonlySet<string>>();
@@ -200,3 +209,9 @@ function outsideMemberNames<Brand>(
   }
   return names;
 }
+
+/** 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);
+  return properties === UNANSWERED ? [] : properties.map((property) => property.name);
+}

package/src/ref.ts

@@ -47,7 +47,7 @@ const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/package\\.json`;
 export const REF_EXPRESSIONS: readonly string[] = [
   `^${SCOPE}#$`,
   `^${SCOPE}#${TS_HEAD}$`,
-  `^${SCOPE}#${TS_HEAD}:alias$`,
+  `^${SCOPE}#(?:${TS_QUOTED}\\.)?${TS_HEAD}:alias$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
   `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
@@ -107,8 +107,12 @@ export type Fragment =
       readonly static: boolean;
       readonly typeParameter?: string;
     }
-  /** One export specifier, a symbol of its own beside the declaration it names. */
-  | { readonly of: "alias"; readonly name: string }
+  /**
+   * One export specifier, a symbol of its own beside the declaration it names. One
+   * written inside a `declare module` block carries the block's name, which is always
+   * quoted, so the aliases two blocks of one file declare under one name stay apart.
+   */
+  | { readonly of: "alias"; readonly name: string; readonly block?: string }
   /** One dependency of a manifest, scoped by that manifest. */
   | { readonly of: "dependency"; readonly name: string; readonly section: DependencySection };
 
@@ -124,6 +128,10 @@ export function nameComponent(name: string): string {
   if (IDENTIFIER.test(name) || PRIVATE_NAME.test(name)) {
     return name;
   }
+  return quoted(name);
+}
+
+function quoted(name: string): string {
   const escaped = name
     .replaceAll("\\", "\\\\")
     .replaceAll("'", "\\'")
@@ -142,6 +150,12 @@ export function computedComponent(text: string): string {
   return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
 
+/** 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)}.`;
+  return `${head}${nameComponent(name)}:alias`;
+}
+
 function spell(component: Component): string {
   return component.computed ? computedComponent(component.text) : nameComponent(component.text);
 }
@@ -157,7 +171,7 @@ export function renderRef(module: Module, fragment: Fragment): string {
     case "module":
       return `${scope}#`;
     case "alias":
-      return `${scope}#${nameComponent(fragment.name)}:alias`;
+      return `${scope}#${aliasFragment(fragment.name, fragment.block)}`;
     case "dependency":
       return `${scope}#${fragment.name}:${fragment.section}`;
     case "declaration": {