@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/src/{workflow-steps.ts → entries/workflow-steps.ts}

@@ -6,13 +6,13 @@
  */
 
 import type { SourceFile } from "@typescript/native/ast";
-import { pathsNamed, readCommands } from "./commands/read.ts";
-import type { Host } from "./host.ts";
-import { isRecord } from "./json-document.ts";
-import { joinPath, resolvePath } from "./paths.ts";
-import type { SourceFiles } from "./source-files.ts";
-import { filesIn } from "./fs/tree.ts";
-import { yamlDocument } from "./text/yaml.ts";
+import { pathsNamed, readCommands, type CommandReading } from "../commands/read.ts";
+import type { Host } from "../host.ts";
+import { isRecord } from "../json-document.ts";
+import { joinPath, resolvePath } from "../paths.ts";
+import type { SourceFiles } from "../source-files.ts";
+import { filesIn } from "../fs/tree.ts";
+import { yamlDocument } from "../text/yaml.ts";
 
 /** One file a workflow step, git hook or recipe runs or names. */
 interface WorkflowEntry {
@@ -204,18 +204,36 @@ export function commandFileTexts(host: Host, targetRoot: string): readonly strin
   ].flatMap((path) => readText(host, path) ?? []);
 }
 
+/** What the target root's workflow steps, git hooks, hook managers and makefile run, read once per run. */
+export interface Workflows {
+  /** Each command read, its held text followed by the directory the file writes for it. */
+  readonly readings: readonly CommandReading[];
+  /** The whole text of each file a command is read from. */
+  readonly texts: readonly string[];
+}
+
+/** Reads the target root's workflow steps, git hooks, hook managers and makefile. */
+export function readWorkflows(host: Host, targetRoot: string): Workflows {
+  return {
+    readings: workflowCommands(host, targetRoot).map(({ text, dir, writtenDirectory }) => {
+      const reading = readCommands(text, dir);
+      return { ...reading, held: [reading.held, writtenDirectory ?? ""].join("\n") };
+    }),
+    texts: commandFileTexts(host, targetRoot),
+  };
+}
+
 /**
  * The own files the target root's workflow steps, git hooks and recipes run or name, as
  * `pathsNamed` reads each command.
  */
 export function workflowEntries(
-  host: Host,
-  targetRoot: string,
+  workflows: Workflows,
   files: SourceFiles,
 ): readonly WorkflowEntry[] {
   const found: WorkflowEntry[] = [];
-  for (const { text, dir } of workflowCommands(host, targetRoot)) {
-    for (const { path, written } of pathsNamed(readCommands(text, dir))) {
+  for (const reading of workflows.readings) {
+    for (const { path, written } of pathsNamed(reading)) {
       for (const file of files.named(path)) {
         found.push({ file, source: written });
       }

package/src/exempt.ts

@@ -8,6 +8,7 @@
  */
 
 import { EXEMPTION_CLASSES } from "./contract/contract.generated.ts";
+import type { GeneratedFact } from "./generated-file.ts";
 import type { ResolvedConfig } from "./config.ts";
 import {
   TS_EXEMPTION_CLASSES,
@@ -51,8 +52,8 @@ export interface DetectorInput<Brand> {
   readonly ts: ResolvedConfig["ts"];
   /** The absolute path of each declared consumer, whose modules are part of the analysis. */
   readonly consumers: readonly string[];
-  /** The project's generated files, by path below the target root, each with the detail its retentions name. */
-  readonly generated?: ReadonlyMap<string, string>;
+  /** The project's generated files, by path below the target root, each with what decided it. */
+  readonly generated?: ReadonlyMap<string, GeneratedFact>;
 }
 
 /**

package/src/extensions.ts

@@ -0,0 +1,45 @@
+/** The extension lists the analysis reads files by, each written once. */
+
+/**
+ * The extensions tried, in order, after a path written without one: a relative specifier
+ * of a configuration file (`roots.5`) and a path a command runs or loads (`roots.13`).
+ */
+export const APPENDED_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+] as const;
+
+/** The extensions of a module a tool runs or loads as its configuration (`roots.2`). */
+export const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"] as const;
+
+/** The extensions of a file a build writes from a source file. */
+export const OUTPUT_EXTENSIONS = [
+  ".js",
+  ".mjs",
+  ".cjs",
+  ".jsx",
+  ".d.ts",
+  ".d.mts",
+  ".d.cts",
+] as const;
+
+/** One list as a glob's brace list, its dots dropped: `{js,mjs}`. */
+export function braced(extensions: readonly string[]): string {
+  return `{${extensions.map((one) => one.slice(1)).join(",")}}`;
+}
+
+/** The extension of one list a name ends with, the longest where several do. */
+export function extensionOf(name: string, extensions: readonly string[]): string | undefined {
+  return extensions
+    .filter((one) => name.endsWith(one))
+    .reduce<string | undefined>(
+      (longest, one) => (one.length > (longest?.length ?? 0) ? one : longest),
+      undefined,
+    );
+}

package/src/facts.ts

@@ -0,0 +1,46 @@
+/**
+ * The facts document `--facts` writes, `bindings.1` and `bindings.2`: the run's generated
+ * files under the one decision the generated-file class reads, and the binding identities
+ * they publish. No binding state is computed, so it states `evaluated: false` (`bindings.10`).
+ */
+
+import { FACTS_VERSION } from "./contract/contract.generated.ts";
+import type { BindingRecord } from "./bindings.ts";
+import type { GeneratedFact } from "./generated-file.ts";
+import { LANGUAGE, PRODUCT } from "./product.ts";
+import { bytewise } from "./text/compare.ts";
+
+/** The facts document of one run, as the text written to the path `--facts` names. */
+export function factsDocument(
+  version: string,
+  generated: ReadonlyMap<string, GeneratedFact>,
+  bindings: readonly BindingRecord[],
+): string {
+  const document = {
+    facts_version: FACTS_VERSION,
+    analyzer: { name: PRODUCT, version },
+    language: LANGUAGE,
+    evaluated: false,
+    generated: [...generated]
+      .sort(([a], [b]) => bytewise(a, b))
+      .map(([path, fact]) => ({
+        path,
+        line: fact.line,
+        evidence: fact.evidence,
+        detail: fact.detail,
+        ...(fact.generator === undefined
+          ? {}
+          : {
+              generator: {
+                row: fact.generator.row,
+                ...(fact.generator.version === undefined
+                  ? {}
+                  : { version: fact.generator.version }),
+              },
+              schema_files: fact.generator.schemaFiles,
+            }),
+      })),
+    bindings,
+  };
+  return `${JSON.stringify(document, null, 2)}\n`;
+}

package/src/file-facts.ts

@@ -10,7 +10,7 @@ import { packageScope } from "./load/package-scope.ts";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import { renderRef } from "./ref.ts";
 import type { ProjectView } from "./session.ts";
-import type { UnseenLoad } from "./unseen-loads.ts";
+import type { UnseenLoad } from "./roots/unseen-loads.ts";
 import { filesBelow } from "./fs/tree.ts";
 
 /** A file name the compiler reads as a source file. */

package/src/findings/boundary.ts

@@ -27,4 +27,6 @@ export interface Boundary {
   readonly edges: readonly EdgeSide[];
   /** The members a function outside the analysis fills, which it may read unseen. */
   readonly filledOutside?: ReadonlySet<string>;
+  /** The files and declarations only a bundler's retry of an import Node leaves unresolved names. */
+  readonly possiblyLoaded?: ReadonlySet<string>;
 }

package/src/findings/completion.ts

@@ -110,12 +110,13 @@ function testedByIn(input: EmitterInput): ReadonlySet<string> {
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A member an `in` expression tests by name, and one a function outside the
- * analysis fills, is `possible`.
+ * consumer set. A member an `in` expression tests by name, one a function outside the
+ * analysis fills, and one {@link possiblyLoaded} names, is `possible`.
  */
 function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
   const tested = testedByIn(input);
   const filled = input.boundary.filledOutside ?? new Set<string>();
+  const possible = possiblyLoaded(input);
   const published = publishedIds(input.swept.matrix.union);
   const { declared } = input.boundary.consumers;
   const outside: Confidence =
@@ -125,7 +126,7 @@ function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
         ? "certain"
         : "probable";
   return (id) => {
-    if (tested.has(id) || filled.has(id)) {
+    if (tested.has(id) || filled.has(id) || possible.has(id)) {
       return "possible";
     }
     return published.has(id) ? outside : "certain";
@@ -182,6 +183,36 @@ function testCeilings(
       : "certain";
 }
 
+/**
+ * What only a bundler's retry of an import Node leaves unresolved names (program.38), and each
+ * dead declaration that reaches through dead declarations, as confidence.20 reads what only
+ * tests reach: each is dead only while no loader the analysis does not see loads the file.
+ */
+function possiblyLoaded(input: EmitterInput): ReadonlySet<string> {
+  const seeds = input.boundary.possiblyLoaded ?? new Set<string>();
+  if (seeds.size === 0) {
+    return seeds;
+  }
+  const union = input.swept.matrix.union;
+  const dead = new Set(input.swept.sweep.candidates.map((one) => one.id));
+  const reached = new Set<string>();
+  const pending = union.symbols.flatMap((symbol, at) => (seeds.has(symbol.id) ? [at] : []));
+  for (let at = pending.pop(); at !== undefined; at = pending.pop()) {
+    const symbol = union.symbols[at];
+    if (symbol === undefined || reached.has(symbol.id)) {
+      continue;
+    }
+    reached.add(symbol.id);
+    for (const edge of union.out[at] ?? []) {
+      const to = union.symbols[edge.to];
+      if (to !== undefined && dead.has(to.id)) {
+        pending.push(edge.to);
+      }
+    }
+  }
+  return reached;
+}
+
 /**
  * The subjects dead only because production code only tests use is: each declaration the
  * sweep marks test-used, each `DS1602` file of such code, and each test of dead code every
@@ -373,6 +404,9 @@ export function completed(
     union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]),
   );
   const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+  const fileIds = new Map(
+    union.symbols.flatMap((one) => (one.kind === "file" ? [[one.position.path, one.id]] : [])),
+  );
   const classOf = reachabilityClasses(input);
   const ceilingOf = testCeilings(input, classOf);
   const testUsed = testUsedSubjects(input);
@@ -465,7 +499,12 @@ export function completed(
         ? union.made[at]
         : { production: candidate.productionRefs, test: candidate.testRefs };
     const ownClass =
-      judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+      judged !== undefined
+        ? classOf(judged.id)
+        : (finding.reachabilityClass ??
+          (finding.code === CODE.fileNeverImported
+            ? classOf(fileIds.get(finding.position.path) ?? "")
+            : "certain"));
     const used =
       judged !== undefined
         ? candidate !== undefined && testUsed.declarations.has(judged.id)

package/src/findings/emitter.ts

@@ -3,7 +3,7 @@ import type { ResolvedConfig } from "../config.ts";
 import type { Dependencies } from "../dependencies.ts";
 import type { FileFacts } from "../file-facts.ts";
 import type { Finding } from "../finding.ts";
-import type { Implementations } from "../implementations.ts";
+import type { Implementations } from "./implementations.ts";
 import type { IntraFunctionFacts } from "../intra-function-parts.ts";
 import type { Stores } from "../stores.ts";
 import type { Boundary } from "./boundary.ts";

package/src/findings/emitters.ts

@@ -161,18 +161,22 @@ function dialledOver(
   unmarked: readonly CompletedFinding[],
 ): Omit<DecidedFindings, "would"> {
   const would = [...unmarked, ...found];
-  const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
   const unanswered = heldKeys(input);
+  const heldIds = new Set(input.swept.heldByUnanswered);
+  const keyOf = (finding: CompletedFinding): string =>
+    declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
+  const held = (finding: CompletedFinding): boolean =>
+    unanswered.has(keyOf(finding)) || insideSkipped(input.swept.skipped, finding.position);
+  const ledger = ledgerOf(
+    suppressed.records,
+    would,
+    dialsOver(input, found, suppressed, unmarked),
+    { withholds: held, holdsRecord: (record) => heldIds.has(record.bound) },
+  );
   const markup = markupKeys(input);
-  const candidates = found.filter((finding) => {
-    const key = declarationKey(finding.symbol.holder ?? 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) => !ledger.withheld(finding) && !held(finding) && !markup.has(keyOf(finding)),
+  );
   const kept = reportable(input, candidates);
   const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
   return {

package/src/{implementations.ts → findings/implementations.ts}

@@ -15,10 +15,10 @@ import {
   type Node,
 } from "@typescript/native/ast";
 import { SymbolFlags, type Symbol as TSSymbol, type Type } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
-import { must, Unanswerable } from "./query.ts";
-import type { ProjectView } from "./session.ts";
+import { aliasChains } from "../alias-chain.ts";
+import { nodeKey, type Inventory } from "../inventory.ts";
+import { must, Unanswerable } from "../query.ts";
+import type { ProjectView } from "../session.ts";
 
 /** What one run knows about how its interfaces are implemented. */
 export interface Implementations {

package/src/{in-operands.ts → findings/in-operands.ts}

@@ -11,9 +11,9 @@ import {
   SyntaxKind,
   type Node,
 } from "@typescript/native/ast";
-import type { ProjectView } from "./session.ts";
-import { sourceFilesOf } from "./source-files.ts";
-import { bytewise } from "./text/compare.ts";
+import type { ProjectView } from "../session.ts";
+import { sourceFilesOf } from "../source-files.ts";
+import { bytewise } from "../text/compare.ts";
 
 /**
  * The text of each string literal, or template literal with no substitution, written as

package/src/findings/self-check.ts

@@ -1,12 +1,12 @@
-import { CODE } from "../contract/contract.generated.ts";
+import { CODE, REMEDIES, type Subject } from "../contract/contract.generated.ts";
 import { REPOSITORY_DOCUMENT } from "../config.ts";
 import type { Finding, FindingDetails, SuppressionEntry } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import { FIXED_SEVERITY_CODES } from "../kinds.ts";
 import type { Position } from "../position.ts";
 import {
-  isDependencyCode,
-  isUnsuppressibleCode,
+  names,
+  subjectOfCode,
   type Mechanism,
   type Refusal,
   type SuppressionRecord,
@@ -72,6 +72,43 @@ export function fileRefsOf(symbols: readonly InventorySymbol[]): FileRefs {
   return (path) => byPath.get(path);
 }
 
+/**
+ * Why a record of `mechanism` naming `codes` can match nothing, one clause per subject whose
+ * findings kinds.json's remedies table lets no record of that mechanism name, in subject order.
+ */
+function unnameable(codes: readonly string[], mechanism: Mechanism): readonly string[] {
+  return (Object.keys(REMEDIES) as Subject[]).flatMap((subject) => {
+    const named = codes.filter((code) => subjectOfCode(code) === subject);
+    if (named.length === 0 || names(subject, mechanism)) {
+      return [];
+    }
+    const { names: what, suppressions } = REMEDIES[subject];
+    const reports = `${spelled(named)} ${named.length === 1 ? "reports" : "each report"} ${what}`;
+    if (suppressions.length > 0) {
+      const records = suppressions.map((one) => articled(WRITTEN[one]));
+      return [`${reports}, which only ${spelledOr(records)} can name`];
+    }
+    const settable = named.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+    const remedy =
+      settable.length === 0
+        ? "fix what the finding names instead"
+        : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+    return [`${reports}, which no suppression can name; ${remedy}`];
+  });
+}
+
+/** A record's written name with its indefinite article. */
+function articled(name: string): string {
+  return `${/^[aeiou]/u.test(name) ? "an" : "a"} ${name}`;
+}
+
+/** A list as a sentence names alternatives. */
+function spelledOr(items: readonly string[]): string {
+  return items.length < 2
+    ? items.join("")
+    : `${items.slice(0, -1).join(", ")} or ${items.at(-1) ?? ""}`;
+}
+
 /** A list of codes as a sentence names them. */
 function spelled(codes: readonly string[]): string {
   if (codes.length < 2) {
@@ -176,26 +213,8 @@ export function staleSuppressions(
     const reports = [...new Set(records.flatMap((one) => one.reports))]
       .filter((code) => !codes.includes(code))
       .sort(bytewise);
-    const rows = codes.filter(isUnsuppressibleCode);
-    const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
-    const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
-    const remedy =
-      settable.length === 0
-        ? "fix what the finding names instead"
-        : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
     const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
-    const because = [
-      ...(rows.length > 0
-        ? [
-            `${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}`,
-          ]
-        : []),
-      ...(dependencies.length > 0
-        ? [
-            `${spelled(dependencies)} ${dependencies.length === 1 ? "reports a dependency row" : "report dependency rows"}, which only an ignore entry or a baseline row can name`,
-          ]
-        : []),
-    ];
+    const because = unnameable(codes, first.mechanism);
     const instead =
       because.length > 0
         ? `, because ${because.join("; ")}${declared === "" ? "" : `; ${declared}`}`

package/src/findings/visibility-narrowing.ts

@@ -4,7 +4,7 @@ import { OUTSIDE, type Graph } from "../graph.ts";
 import type { InventorySymbol, SymbolKind } from "../inventory.ts";
 import type { MatrixCandidate } from "../matrix.ts";
 import { declarationKey } from "../ref.ts";
-import type { RootKind } from "../roots.ts";
+import type { RootKind } from "../roots/root-set.ts";
 import { runnerCalls } from "../sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 import { writeOnlyDeclarations } from "./reads-and-writes.ts";

package/src/findings-pass.ts

@@ -16,13 +16,7 @@ import {
   type StaleRecord,
   type StaleSuppression,
 } from "./findings/self-check.ts";
-import {
-  isDependencySubject,
-  isRowSubject,
-  pairs,
-  suppressionCounts,
-  type Ledger,
-} from "./suppress.ts";
+import { namesKind, pairs, suppressionCounts, type Ledger } from "./suppress.ts";
 import type { Provenance, Recorded } from "./suppress-file.ts";
 import { bytewise } from "./text/compare.ts";
 import { PRODUCT } from "./product.ts";
@@ -131,15 +125,14 @@ export interface RecordableFinding {
 
 /**
  * The rows one round of a baseline write records from its findings, in their order. A
- * finding about a row of a document other than a dependency row is not recorded: no record
- * withholds one, so a row recording it would be stale on the first read back. Two findings
- * that would record the same row, two parts of one declaration under one code, record it
- * once.
+ * finding no baseline row can name is not recorded: a row recording it would be stale on
+ * the first read back. Two findings that would record the same row, two parts of one
+ * declaration under one code, record it once.
  */
 export function recordedFindings(findings: readonly RecordableFinding[]): readonly Recorded[] {
   const rows = new Map<string, Recorded>();
   for (const finding of findings) {
-    if (isRowSubject(finding.symbol.kind) && !isDependencySubject(finding.symbol.kind)) {
+    if (!namesKind(finding.symbol.kind, "baseline")) {
       continue;
     }
     const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };

package/src/framework-lifecycle.ts

@@ -1,9 +1,10 @@
 /**
- * The framework-lifecycle class: a member a `ts.lifecycle_contracts` entry lists is held
- * back on each class that is the entry's component, being a class a decorator or a call
- * the entry's `components` name is attached to or passes, or one extending, directly or
- * through a chain, a class its `bases` name. A component's members are its type's, so a
- * member a base class declares answers for every subclass.
+ * The framework-lifecycle class: a member a lifecycle contract lists is held back on each
+ * class that is the contract's component, being a class a decorator or a call the
+ * contract's `components` name is attached to or passes, or one extending, directly or
+ * through a chain, a class its `bases` name. The contracts are the platform's custom
+ * elements and each `ts.lifecycle_contracts` entry. A component's members are its type's,
+ * so a member a base class declares answers for every subclass.
  */
 
 import {
@@ -26,13 +27,37 @@ import {
   resolveEntries,
   spelledEntry,
   type ResolvedEntry,
-} from "./configured-declarations.ts";
+} from "./roots/configured-declarations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
+/**
+ * The platform's own contract (references-ts.38): `CustomElementRegistry.define` reads
+ * these members off the class it registers, its constructor's and its prototype's
+ * (https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-define),
+ * and calls each callback as a custom element reaction.
+ */
+const CUSTOM_ELEMENTS: LifecycleContract = {
+  components: [{ global: "CustomElementRegistry.define" }],
+  members: [
+    "observedAttributes:static",
+    "disabledFeatures:static",
+    "formAssociated:static",
+    "connectedCallback",
+    "disconnectedCallback",
+    "connectedMoveCallback",
+    "adoptedCallback",
+    "attributeChangedCallback",
+    "formAssociatedCallback",
+    "formResetCallback",
+    "formDisabledCallback",
+    "formStateRestoreCallback",
+  ],
+};
+
 /** One class that is a component of one contract, and what says it is. */
 interface Component {
   readonly contract: LifecycleContract;
@@ -238,16 +263,17 @@ function byBases<Brand>(
 
 /**
  * The framework-lifecycle detector: each member a contract lists, on each class that
- * is a component of that contract's framework, recorded where the class was found to
- * be one.
+ * is a component of that contract's framework, recorded once per place where the class
+ * was found to be one.
  */
 export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
   const { project, held, targetRoot } = input;
-  if (input.ts.lifecycle_contracts.length === 0) {
+  const declared = [CUSTOM_ELEMENTS, ...input.ts.lifecycle_contracts];
+  const contracts = resolveContracts(project, held, declared);
+  if (contracts.every((one) => one.components.length === 0 && one.bases.length === 0)) {
     return [];
   }
   const chains = aliasChains(project, held);
-  const contracts = resolveContracts(project, held, input.ts.lifecycle_contracts);
   const components = [
     ...byComponents(project, held, chains, contracts),
     ...byBases(project, held, chains, contracts),
@@ -256,7 +282,7 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
     return [];
   }
   const ids = new Set(components.map((one) => one.id));
-  const sides: readonly ClassSide[] = input.ts.lifecycle_contracts.some((contract) =>
+  const sides: readonly ClassSide[] = declared.some((contract) =>
     contract.members.some((name) => name.endsWith(":static")),
   )
     ? ["instance", "static"]
@@ -264,7 +290,7 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
   const members = sides.map((side) => classMembers(project, held, ids, side));
   const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
 
-  const found: Evidence[] = [];
+  const found = new Map<string, Evidence>();
   for (const component of components) {
     const listed = new Set(component.contract.members);
     const site = renderPosition(
@@ -275,10 +301,12 @@ export function frameworkLifecycle<Brand>(input: DetectorInput<Brand>): readonly
     for (const member of members.flatMap((side) => side.get(component.id) ?? [])) {
       const symbol = byId.get(member.id);
       const spelled = symbol === undefined ? undefined : memberComponent(symbol, byId);
-      if (spelled !== undefined && listed.has(spelled)) {
-        found.push({ id: member.id, detail: component.detail, site });
+      // A configured contract may name the platform's registry too; one record answers both.
+      const key = `${member.id}\0${component.detail}\0${site.path}:${String(site.line)}:${String(site.column)}`;
+      if (spelled !== undefined && listed.has(spelled) && !found.has(key)) {
+        found.set(key, { id: member.id, detail: component.detail, site });
       }
     }
   }
-  return found;
+  return [...found.values()];
 }