@cplieger/deadset-ts 6.0.1 → 6.1.0

package/dist/src/configured-declarations.js

@@ -143,8 +143,8 @@ function modulesNamed(project, specifiers) {
     return modules;
 }
 /**
- * The declaration each entry names in one project. A symbol entry names the
- * inventory's declaration whose reference it spells exactly; a module entry names the
+ * The declaration each entry names in one project. A symbol entry names every
+ * declaration of the inventory whose reference it spells exactly; a module entry names the
  * declaration its path reaches from the exports of the module its specifier resolves
  * to; a global entry names the declaration its path reaches from the global scope.
  * Every alias along a path is followed to the declaration it stands for.
@@ -153,12 +153,14 @@ export function resolveEntries(project, held, entries) {
     if (entries.length === 0) {
         return [];
     }
-    const byRef = new Map(held.symbols.map((symbol) => [symbol.ref, symbol.id]));
+    const byRef = new Map();
+    for (const symbol of held.symbols) {
+        byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
+    }
     const modules = modulesNamed(project, new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))));
     return entries.map((entry) => {
         if (entry.shape === "symbol") {
-            const id = byRef.get(entry.symbol);
-            return { entry, handles: new Set(), ids: new Set(id === undefined ? [] : [id]) };
+            return { entry, handles: new Set(), ids: new Set(byRef.get(entry.symbol) ?? []) };
         }
         const { components, static: isStatic } = componentsOf(entry.shape === "module" ? entry.name : entry.global);
         const [first = "", ...rest] = components;

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "4.0.0",
+        corpusVersion: "4.1.0",
         result: "pass",
-        digest: "sha256:8250b61deb71467139bf4cbcaf10802cdabb1a2c2261a11a571fc1ff55bfc3dc",
+        digest: "sha256:167f770cdff2776fa7ab28b7ff6121c4d7bdb01d83c5ba0057d9303281614008",
     },
     gaps: [],
 };

package/dist/src/convention-rows.js

@@ -31,6 +31,11 @@ const APP_DIRECTORY_ENTRIES = [
 ];
 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}`;
@@ -57,6 +62,19 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        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",
@@ -229,6 +247,21 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        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",
@@ -275,7 +308,10 @@ export const CONVENTION_ROWS = [
         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",
@@ -406,6 +442,36 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        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/dist/src/conventions.js

@@ -13,6 +13,8 @@ import { globExpression } from "./glob.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
 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"];
 const DEPENDENCY_SECTIONS = [
@@ -351,11 +353,10 @@ function readPath(object, keys, values, elements) {
     return undefined;
 }
 /**
- * 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, property, call) {
+function valuesAt(file, property, call) {
     const declared = declaredValues(file);
     const objects = call === undefined
         ? defaultExports(file).map((one) => objectOf(one, declared, true))
@@ -374,12 +375,9 @@ function stringsAt(file, property, call) {
             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));
-            }
         }
     };
     for (const object of objects) {
@@ -389,6 +387,32 @@ function stringsAt(file, property, call) {
     }
     return found;
 }
+/** The string literals among values: each value itself, or each element of an array value. */
+function stringsAt(file, property, call) {
+    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, value) {
+    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, parse, dir, readings, into) {
     for (const reading of readings) {
@@ -527,7 +551,11 @@ function readingFiles(host, parse, dir, files) {
             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;
@@ -563,6 +591,17 @@ function shortNameUses(host, parse, dir, manifest, readings) {
     }
     return [...used].filter((name) => declared.has(name)).sort(compare);
 }
+/** The declared dependencies an applied row's helper settings use. */
+function helperUses(host, parse, dir, manifest, readings) {
+    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, b) {
     if (a === b) {
@@ -644,6 +683,9 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             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/dist/src/edges.js

@@ -154,9 +154,10 @@ function compare(a, b) {
 }
 /**
  * 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(findings, sides, symbols) {
     if (sides.length === 0) {
@@ -164,8 +165,8 @@ export function evaluateEdges(findings, sides, symbols) {
     }
     const byRef = new Map();
     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();
@@ -175,18 +176,20 @@ export function evaluateEdges(findings, sides, symbols) {
         }
     });
     const pending = new Set();
-    const evaluations = sides.map((side) => {
-        const id = byRef.get(side.symbol);
-        if (id === undefined) {
-            return { ...side, state: "absent" };
+    const evaluations = sides.flatMap((side) => {
+        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/dist/src/findings/emitters.js

@@ -73,21 +73,13 @@ function dialsOver(input, found, suppressed, unmarked) {
  * 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, suppressed = { unmarked: input, records: [] }) {
     const found = completedOver(input);
     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. */
 function atPossible(input) {
@@ -107,32 +99,37 @@ function dialledOver(input, suppressed, found, unmarked) {
     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 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, shown) {
-    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, candidates) {
+    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) {
-    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) {
     return decidedFindings(input).findings;

package/dist/src/inventory.js

@@ -787,7 +787,12 @@ function refOf(record, chain) {
         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/dist/src/module-declarations.js

@@ -9,7 +9,7 @@ import { isCallExpression, isExportDeclaration, isExternalModuleReference, isImp
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
-import { nameComponent } from "./ref.js";
+import { aliasFragment, nameComponent } from "./ref.js";
 /** Whether a node is a specifier's text: a string literal or a template with no substitution. */
 function literalText(node) {
     return node !== undefined && (isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node));
@@ -78,7 +78,7 @@ function namesModule(specifier, name) {
  * 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(held) {
+function namedBy(held) {
     if (held.modules.size === 0) {
         return () => [];
     }
@@ -103,7 +103,7 @@ export function namedBy(held) {
         const scope = ref.slice(0, ref.indexOf("#"));
         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));
         return [{ id, members: members.map((child) => child.id) }];

package/dist/src/outside-tests.js

@@ -1,15 +1,15 @@
 /**
  * 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 { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
 import { emittedFrom } from "./emit-map.js";
-import { namedBy, namesImported } from "./module-declarations.js";
+import { namesImported } from "./module-declarations.js";
 import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";
 import { renderPosition } from "./position.js";
 import { nameComponent } from "./ref.js";
@@ -102,7 +102,6 @@ export function outsideTestReferences(tests, held, targetRoot) {
             exported.set(key, [...(exported.get(key) ?? []), symbol.id]);
         }
     }
-    const declared = namedBy(held);
     const found = [];
     for (const { path, file } of tests) {
         const from = `${path}#`;
@@ -112,11 +111,6 @@ export function outsideTestReferences(tests, held, targetRoot) {
             const read = (to, use) => {
                 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/dist/src/overrides.js

@@ -1,15 +1,17 @@
 /**
  * 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 { isClassDeclaration, isClassExpression, isExpressionWithTypeArguments, isPropertyAccessExpression, isQualifiedName, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { memberComponent } from "./class-members.js";
 import { nodeKey } from "./inventory.js";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { UNANSWERED } from "./query.js";
+import { nameComponent } from "./ref.js";
 /** The member kinds a subclass overrides. */
 const OVERRIDABLE = new Set(["method", "class-member"]);
 /** The node naming the class one `extends` entry names. */
@@ -40,7 +42,7 @@ function extending(project, held) {
 }
 /**
  * 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.
@@ -102,7 +104,7 @@ export function overrideReferences(project, held, chains, testFiles) {
     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,
@@ -133,15 +135,20 @@ export function overrideReferences(project, held, chains, testFiles) {
 }
 /**
  * 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(project, bases, outsideBases) {
     const direct = new Map();
     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();
@@ -163,3 +170,8 @@ function outsideMemberNames(project, bases, outsideBases) {
     }
     return names;
 }
+/** The names of a type's properties; none where the type or its properties are unanswered. */
+function namesOf(project, type) {
+    const properties = type === undefined ? UNANSWERED : project.queries.propertiesOf(type);
+    return properties === UNANSWERED ? [] : properties.map((property) => property.name);
+}

package/dist/src/ref.js

@@ -43,7 +43,7 @@ const MANIFEST_SCOPE = `${PREFIX}${TS_PACKAGE}/package\\.json`;
 export const REF_EXPRESSIONS = [
     `^${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}>$`,
@@ -66,6 +66,9 @@ export function nameComponent(name) {
     if (IDENTIFIER.test(name) || PRIVATE_NAME.test(name)) {
         return name;
     }
+    return quoted(name);
+}
+function quoted(name) {
     const escaped = name
         .replaceAll("\\", "\\\\")
         .replaceAll("'", "\\'")
@@ -82,6 +85,11 @@ export function nameComponent(name) {
 export function computedComponent(text) {
     return `[${text.replaceAll(ASCII_WHITESPACE, "")}]`;
 }
+/** The fragment of an export alias, inside the `declare module` block named, if one is. */
+export function aliasFragment(name, block) {
+    const head = block === undefined ? "" : `${quoted(block)}.`;
+    return `${head}${nameComponent(name)}:alias`;
+}
 function spell(component) {
     return component.computed ? computedComponent(component.text) : nameComponent(component.text);
 }
@@ -96,7 +104,7 @@ export function renderRef(module, fragment) {
         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": {

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "6.0.0";
+export const CONTRACT_VERSION = "6.1.0";

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",

package/src/configured-declarations.ts

@@ -207,8 +207,8 @@ function modulesNamed<Brand>(
 }
 
 /**
- * The declaration each entry names in one project. A symbol entry names the
- * inventory's declaration whose reference it spells exactly; a module entry names the
+ * The declaration each entry names in one project. A symbol entry names every
+ * declaration of the inventory whose reference it spells exactly; a module entry names the
  * declaration its path reaches from the exports of the module its specifier resolves
  * to; a global entry names the declaration its path reaches from the global scope.
  * Every alias along a path is followed to the declaration it stands for.
@@ -221,15 +221,17 @@ export function resolveEntries<Brand>(
   if (entries.length === 0) {
     return [];
   }
-  const byRef = new Map(held.symbols.map((symbol) => [symbol.ref, symbol.id]));
+  const byRef = new Map<string, string[]>();
+  for (const symbol of held.symbols) {
+    byRef.set(symbol.ref, [...(byRef.get(symbol.ref) ?? []), symbol.id]);
+  }
   const modules = modulesNamed(
     project,
     new Set(entries.flatMap((entry) => (entry.shape === "module" ? [entry.module] : []))),
   );
   return entries.map((entry) => {
     if (entry.shape === "symbol") {
-      const id = byRef.get(entry.symbol);
-      return { entry, handles: new Set<string>(), ids: new Set(id === undefined ? [] : [id]) };
+      return { entry, handles: new Set<string>(), ids: new Set(byRef.get(entry.symbol) ?? []) };
     }
     const { components, static: isStatic } = componentsOf(
       entry.shape === "module" ? entry.name : entry.global,

package/src/conformance-record.ts

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
   conformance: {
-    corpusVersion: "4.0.0",
+    corpusVersion: "4.1.0",
     result: "pass",
-    digest: "sha256:8250b61deb71467139bf4cbcaf10802cdabb1a2c2261a11a571fc1ff55bfc3dc",
+    digest: "sha256:167f770cdff2776fa7ab28b7ff6121c4d7bdb01d83c5ba0057d9303281614008",
   },
   gaps: [],
 } as const;