@cplieger/deadset-ts 8.0.0-dev.16 → 8.0.0-dev.18

package/dist/src/findings/completion.js

@@ -4,9 +4,9 @@
  * together with every finding that falls with a root they withhold.
  */
 import { CODE, FAMILY_KEY_LENGTH, KIND_ROWS, } from "../contract/contract.generated.js";
-import { componentId } from "../components.js";
-import { deadComponents } from "../matrix.js";
-import { OUTSIDE } from "../graph.js";
+import { componentId } from "../liveness/components.js";
+import { deadComponents } from "../liveness/sweep.js";
+import { OUTSIDE } from "../liveness/graph.js";
 import { KINDS } from "../kinds.js";
 import { byPosition, positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
@@ -79,12 +79,13 @@ function testedByIn(input) {
  * 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) {
+export function reachabilityClasses(input) {
     const tested = testedByIn(input);
     const filled = input.boundary.filledOutside ?? new Set();
+    const possible = possiblyLoaded(input);
     const published = publishedIds(input.swept.matrix.union);
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
@@ -93,25 +94,12 @@ function reachabilityClasses(input) {
             ? "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";
     };
 }
-/**
- * Whether one test of dead code references a target symbol that is published API of a run
- * that declares no consumer, which outside programs the run cannot see may use, so the
- * target counts as live for the test and the test is no test of dead code.
- */
-export function testsUnseenAPI(input) {
-    if (input.boundary.consumers.declared.length > 0) {
-        return () => false;
-    }
-    const union = input.swept.matrix.union;
-    const published = publishedIds(union);
-    return (id) => testTargets(union, id).some((target) => published.has(target));
-}
 /** The target symbols one test of dead code references, by id: production declarations the sweep judges. */
 function testTargets(union, id) {
     return (union.out[union.at(id)] ?? []).flatMap((edge) => {
@@ -137,6 +125,35 @@ function testCeilings(input, classOf) {
         ? testTargets(union, id).reduce((lowest, target) => capped(lowest, classOf(target)), "certain")
         : "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) {
+    const seeds = input.boundary.possiblyLoaded ?? new Set();
+    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();
+    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
@@ -281,6 +298,7 @@ export function completed(input, findings, kinds = KINDS) {
     const union = swept.matrix.union;
     const positions = new Map(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);
@@ -365,7 +383,12 @@ export function completed(input, findings, kinds = KINDS) {
         const counts = candidate === undefined
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
-        const ownClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const ownClass = 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)
             : finding.code === CODE.fileNeverImported && testUsed.files.has(finding.position.path);

package/dist/src/findings/emitters.js

@@ -1,5 +1,4 @@
 import { evaluateEdges } from "../edges.js";
-import { liveFilesAt } from "../matrix.js";
 import { declarationKey } from "../ref.js";
 import { ledgerOf } from "../suppress.js";
 import { insideSkipped } from "../type-errors.js";
@@ -8,7 +7,7 @@ import { dependenciesAndModuleMachinery } from "./dependencies-and-module-machin
 import { interfaces } from "./interfaces.js";
 import { intraFunction } from "./intra-function.js";
 import { nonCodeArtifacts } from "./non-code-artifacts.js";
-import { readsAndWrites } from "./reads-and-writes.js";
+import { fallingWithWrites, readsAndWrites } from "./reads-and-writes.js";
 import { selfCheck } from "./self-check.js";
 import { fallenMembers, unusedDeclarations } from "./unused-declarations.js";
 import { visibilityNarrowing } from "./visibility-narrowing.js";
@@ -23,37 +22,25 @@ export const EMITTERS = new Map([
     ["self-check", selfCheck],
     ["intra-function", intraFunction],
 ]);
-/**
- * The keys of every declaration an unanswered question could have kept live, which the run
- * reports nothing about: a finding about one would be computed from the gap.
- */
-function heldKeys(input) {
-    const held = new Set(input.swept.heldByUnanswered);
-    if (held.size === 0) {
-        return held;
-    }
+/** The keys of the declarations the identifiers name, as {@link findingKey} keys a finding. */
+function keysOf(input, ids) {
+    const named = new Set(ids);
     return new Set(input.swept.matrix.union.symbols
-        .filter((symbol) => held.has(symbol.id))
+        .filter((symbol) => named.has(symbol.id))
         .map((symbol) => declarationKey(symbol.ref, symbol.position.path)));
 }
+/** The key of the declaration a finding is about, or of the one holding the part it is about. */
+function findingKey(finding) {
+    return declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
+}
 /**
- * The keys of every top-level declaration of a live component file. The file's
- * markup may use each of them, which no analysis of the markup can rule out, so the run
- * reports nothing about one while the file is live.
+ * Every emitter's findings over one sweep, and those of any further emitter, completed by
+ * one step, but none about a declaration that falls with a write-only subject: that
+ * subject's finding names it, so no finding about it exists for a record to match.
  */
-function markupKeys(input) {
-    const { swept } = input;
-    if (swept.componentFiles.length === 0) {
-        return new Set();
-    }
-    const live = new Set(liveFilesAt(swept.matrix, swept.sweep, new Set(swept.componentFiles)).map((symbol) => symbol.id));
-    return new Set(swept.matrix.union.symbols
-        .filter((symbol) => live.has(symbol.parent))
-        .map((symbol) => declarationKey(symbol.ref, symbol.position.path)));
-}
-/** Every emitter's findings over one sweep, and those of any further emitter, completed by one step. */
 function completedOver(input, ...more) {
-    return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)));
+    const falls = keysOf(input, fallingWithWrites(input));
+    return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input))).filter((finding) => !falls.has(findingKey(finding)));
 }
 /**
  * The dials over the findings a record could name, each read against the sweep that
@@ -96,13 +83,15 @@ function atPossible(input) {
  */
 function dialledOver(input, suppressed, found, unmarked) {
     const would = [...unmarked, ...found];
-    const unanswered = heldKeys(input);
-    const heldIds = new Set(input.swept.heldByUnanswered);
-    const keyOf = (finding) => declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
-    const held = (finding) => unanswered.has(keyOf(finding)) || insideSkipped(input.swept.skipped, finding.position);
+    const { sweep } = input.swept;
+    // A hold is a gap of the analysis, which leaves a record it touches dormant; a live
+    // component file's markup is no gap, so a record on one of its bindings stays in effect.
+    const unanswered = keysOf(input, sweep.held);
+    const markup = keysOf(input, sweep.bindings);
+    const heldIds = new Set(sweep.held);
+    const held = (finding) => unanswered.has(findingKey(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) => !ledger.withheld(finding) && !held(finding) && !markup.has(keyOf(finding)));
+    const candidates = found.filter((finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(findingKey(finding)));
     const kept = reportable(input, candidates);
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
     return {

package/dist/src/{implementations.js → findings/implementations.js}

@@ -7,9 +7,9 @@
  */
 import { isClassDeclaration, isHeritageClause, isInterfaceDeclaration, isMethodDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.js";
-import { nodeKey } from "./inventory.js";
-import { must, Unanswerable } from "./query.js";
+import { aliasChains } from "../alias-chain.js";
+import { nodeKey } from "../inventory.js";
+import { must, Unanswerable } from "../query.js";
 /** The interfaces, the classes and the `implements` entries of one project's own files. */
 function walk(project, held) {
     const interfaces = [];

package/dist/src/{in-operands.js → findings/in-operands.js}

@@ -4,8 +4,8 @@
  * links the read to a declaration, so only a text match can tell which member it reads.
  */
 import { isBinaryExpression, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { sourceFilesOf } from "./source-files.js";
-import { bytewise } from "./text/compare.js";
+import { sourceFilesOf } from "../source-files.js";
+import { bytewise } from "../text/compare.js";
 /**
  * The text of each string literal, or template literal with no substitution, written as
  * the left operand of an `in` expression in a file of the project that is no test file.

package/dist/src/findings/intra-function.js

@@ -2,7 +2,7 @@ import { CODE } from "../contract/contract.generated.js";
 import { KINDS } from "../kinds.js";
 import { parameterRef } from "../ref.js";
 import {} from "../intra-function-parts.js";
-import { reachedWithTheTests } from "../sweep.js";
+import { reachedWithTheTests } from "../liveness/sweep.js";
 /** A list of rules as a sentence names them. */
 function spelled(rules) {
     if (rules.length < 2) {
@@ -84,8 +84,8 @@ export const intraFunction = (input) => {
     const union = input.swept.matrix.union;
     const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
     const reached = reachedWithTheTests(union, [
-        ...input.swept.exempt.map((record) => record.id),
-        ...input.swept.heldByUnanswered,
+        ...input.swept.sweep.exempt.map((record) => record.id),
+        ...input.swept.sweep.held,
     ]);
     const testsOfDeadCode = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
     const judged = (id) => {

package/dist/src/findings/reads-and-writes.js

@@ -1,6 +1,8 @@
 import { CODE } from "../contract/contract.generated.js";
+import { WORDS } from "../inventory.js";
 import { positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
+import { reachabilityClasses } from "./completion.js";
 import { bytewise } from "../text/compare.js";
 /** The containers whose type parameters `DS1006` reports: a function, a class method and a type alias. */
 const SIGNATURES = new Set(["function", "method", "type"]);
@@ -70,14 +72,16 @@ function parametersOnlyNamedBy(run, namedBy, member) {
         .map((symbol) => symbol.name);
 }
 /** What one write-only finding says, the declarations its deletion takes with it included. */
-function writeOnlyMessage(run, namedBy, symbol, held) {
+function writeOnlyMessage(run, written, subject) {
+    const { symbol, held } = subject;
     const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
     const read = run.input.stores.readInTests.has(symbol.id)
         ? "read only from test files"
         : "never read";
     const cascade = [
-        ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
+        ...parametersOnlyNamedBy(run, written.namedBy, symbol).map((name) => `type parameter ${name}`),
         ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
+        ...(written.named.get(symbol.id) ?? []),
     ];
     const word = SUBJECT_WORDS[symbol.kind] ?? "member";
     const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
@@ -86,16 +90,34 @@ function writeOnlyMessage(run, namedBy, symbol, held) {
         : `${message}, and deleting it with its writes deletes ${cascade.join(" and ")} too`;
 }
 /**
- * `DS1301`: a module-level variable, a type member or a class member the counted
- * references store into and never read, named with every position written.
+ * The kinds of declaration that fall with a write-only subject: a declaration of its own.
+ * A member falls with its container, and a type parameter is the type-parameter clause's.
+ */
+const FALLING = new Set([
+    "function",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "namespace",
+    "variable",
+]);
+const WRITTEN = new WeakMap();
+/**
+ * `DS1301`'s subjects: a module-level variable, a type member or a class member the
+ * counted references store into and never read.
  *
  * The subject is a live declaration: a store is a reference, so the sweep holds a
  * written one live and its candidates are never this kind's. Every reference that is
  * not a store reads, and so does an exemption record naming the declaration.
  */
-function writeOnlySymbols(run) {
+function writtenOf(run) {
+    const known = WRITTEN.get(run.input);
+    if (known !== undefined) {
+        return known;
+    }
     const { stores } = run.input;
-    const { matrix } = run.input.swept;
+    const { matrix, sweep } = run.input.swept;
     const uses = new Map();
     for (const reference of stores.references) {
         let held = uses.get(reference.to);
@@ -124,22 +146,49 @@ function writeOnlySymbols(run) {
             namedBy.set(reference.to, (namedBy.get(reference.to) ?? new Set()).add(reference.from));
         }
     }
-    const found = [];
-    for (const symbol of matrix.union.symbols) {
+    const subjects = matrix.union.symbols.flatMap((symbol) => {
         const held = uses.get(symbol.id);
-        if (held === undefined ||
+        return held === undefined ||
             held.writes.length === 0 ||
             held.reads > 0 ||
             !writable(run, symbol) ||
             stores.exempt.has(symbol.id) ||
-            run.candidates.has(symbol.id)) {
+            run.candidates.has(symbol.id)
+            ? []
+            : [{ symbol, held }];
+    });
+    const subjectIds = new Set(subjects.map((subject) => subject.symbol.id));
+    const classOf = reachabilityClasses(run.input);
+    const named = new Map();
+    const falls = new Set();
+    for (const symbol of matrix.union.symbols) {
+        const chains = sweep.carried.get(symbol.id);
+        if (chains === undefined ||
+            subjectIds.has(symbol.id) ||
+            !FALLING.has(symbol.kind) ||
+            classOf(symbol.id) !== "certain") {
             continue;
         }
-        found.push(findingAbout(symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, namedBy, symbol, held), {
-            writePositions: held.writes,
-        }));
+        const innermost = chains.map((chain) => chain.find((id) => subjectIds.has(id)));
+        if (innermost.includes(undefined)) {
+            continue;
+        }
+        falls.add(symbol.id);
+        for (const subject of new Set(innermost)) {
+            const name = `${WORDS[symbol.kind]} ${symbol.name}`;
+            named.set(subject ?? "", [...(named.get(subject ?? "") ?? []), name]);
+        }
     }
-    return found;
+    const written = { subjects, namedBy, named, falls };
+    WRITTEN.set(run.input, written);
+    return written;
+}
+/** `DS1301`: each subject, named with every position written and what falls with it. */
+function writeOnlySymbols(run) {
+    const written = writtenOf(run);
+    return written.subjects.map((subject) => findingAbout(subject.symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, written, subject), {
+        writePositions: subject.held.writes,
+    }));
 }
 /**
  * The candidates no reference of any file names whose container is not itself dead, of
@@ -184,7 +233,14 @@ function unusedTypeParameters(run) {
  * supersedes narrowing it.
  */
 export function writeOnlyDeclarations(input) {
-    return new Set(writeOnlySymbols(indexed(input)).map((finding) => declarationKey(finding.symbol.ref, finding.position.path)));
+    return new Set(writtenOf(indexed(input)).subjects.map(({ symbol }) => declarationKey(symbol.ref, symbol.position.path)));
+}
+/**
+ * The declarations that fall with a write-only subject, whatever the severity: a finding
+ * about one would name code its subject's deletion already deletes.
+ */
+export function fallingWithWrites(input) {
+    return writtenOf(indexed(input)).falls;
 }
 /**
  * The findings of the reads-and-writes kinds, `DS1301`, `DS1005` and `DS1006`, in that

package/dist/src/findings/unused-declarations.js

@@ -1,5 +1,5 @@
 import { CODE } from "../contract/contract.generated.js";
-import { testsUnseenAPI } from "./completion.js";
+import { WORDS } from "../inventory.js";
 import { unreachableExports } from "./visibility-narrowing.js";
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
 const MEMBERS = new Set([
@@ -19,24 +19,6 @@ const NOT_REPORTED_HERE = new Set([
     "interface-method",
     "type-parameter",
 ]);
-/** The reader's word for each kind of declaration a finding of this emitter names. */
-const WORDS = {
-    file: "file",
-    function: "function",
-    class: "class",
-    interface: "interface",
-    type: "type alias",
-    enum: "enum",
-    namespace: "namespace",
-    variable: "variable",
-    "export-alias": "re-export",
-    method: "method",
-    "class-member": "class member",
-    "interface-method": "interface method",
-    "type-member": "type member",
-    "enum-member": "enum member",
-    "type-parameter": "type parameter",
-};
 /** What the test-of-dead-code kind says, which states the rule it applies. */
 const TEST_OF_DEAD_CODE = "every target symbol this test references is reported dead";
 /**
@@ -50,7 +32,7 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
 function codeOf(judged) {
     const { candidate, symbol } = judged;
     if (candidate.testOfDeadCode) {
-        return judged.testsUnseenAPI ? undefined : CODE.testOfDeadCode;
+        return CODE.testOfDeadCode;
     }
     if ((judged.test && !candidate.unreferencedTest) || NOT_REPORTED_HERE.has(symbol.kind)) {
         return undefined;
@@ -201,7 +183,6 @@ function emitterFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
-    const unseenAPI = testsUnseenAPI(input);
     let brands;
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
@@ -220,7 +201,6 @@ function emitterFindings(input, fallen) {
             test: union.test[at] === true,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),
-            testsUnseenAPI: candidate.testOfDeadCode && unseenAPI(candidate.id),
         };
         const code = codeOf(judged);
         if (code === undefined ||

package/dist/src/findings/visibility-narrowing.js

@@ -1,7 +1,9 @@
 import { CODE } from "../contract/contract.generated.js";
-import { OUTSIDE } from "../graph.js";
+import { OUTSIDE } from "../liveness/graph.js";
+import { WORDS } from "../inventory.js";
 import { declarationKey } from "../ref.js";
-import { runnerCalls } from "../sweep.js";
+import { runnerCalls } from "../liveness/sweep.js";
+import { exposedTypes, exposes } from "../exposure.js";
 import { writeOnlyDeclarations } from "./reads-and-writes.js";
 /**
  * The root kinds by which a consumer importing the package reaches a declaration. A
@@ -9,17 +11,6 @@ import { writeOnlyDeclarations } from "./reads-and-writes.js";
  * from outside the reference graph: a runtime, a tool, a framework or the configuration.
  */
 const PUBLISHING = new Set(["manifest-entry", "published-api"]);
-/** The reader's word for each kind of declaration this emitter reports. */
-const WORDS = {
-    function: "function",
-    class: "class",
-    interface: "interface",
-    type: "type alias",
-    enum: "enum",
-    namespace: "namespace",
-    variable: "variable",
-    "export-alias": "re-export",
-};
 function publishes(kinds) {
     return [...(kinds ?? [])].some((kind) => PUBLISHING.has(kind));
 }
@@ -102,9 +93,6 @@ function topLevelExport(facts, at, symbol) {
     const parent = facts.graph.parent[at] ?? OUTSIDE;
     return symbol.exported && parent !== OUTSIDE && facts.graph.symbols[parent]?.kind === "file";
 }
-function wordOf(symbol) {
-    return WORDS[symbol.kind] ?? symbol.kind;
-}
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER = {
     [CODE.redundantExportKeyword]: "file",
@@ -145,7 +133,7 @@ function narrowing(facts, at, symbol, world) {
         (facts.named[at] ?? 0) === 0) {
         return undefined;
     }
-    const word = wordOf(symbol);
+    const word = WORDS[symbol.kind];
     switch (facts.reach[at]) {
         case "file":
             if (facts.published[file] === true && !closed) {
@@ -153,7 +141,7 @@ function narrowing(facts, at, symbol, world) {
             }
             return findingOf(symbol, CODE.redundantExportKeyword, `exported ${word} is referenced only inside the file that declares it`);
         case "package":
-            if (!closed || !publishes(facts.rootedBy[at])) {
+            if (!closed || !publishes(facts.rootedBy[at]) || exposes(world.exposed, symbol)) {
                 return undefined;
             }
             return findingOf(symbol, CODE.unnecessaryExport, `exported ${word} is referenced only inside the package that declares it`);
@@ -181,7 +169,7 @@ function unreachable(facts, at, symbol, candidate, input) {
     const found = candidate.relation === "reachability"
         ? "is referenced only from declarations that are themselves dead"
         : "has no reference in the target";
-    return findingOf(symbol, CODE.unreachableExport, `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`);
+    return findingOf(symbol, CODE.unreachableExport, `exported ${WORDS[symbol.kind]} ${found}, and nothing outside can import the file that declares it`);
 }
 /**
  * The visibility-narrowing kinds over one run: `DS1501`, `DS1101` and `DS1503`. A finding
@@ -194,7 +182,13 @@ export function narrowings(input) {
     const facts = factsOf(input.swept.matrix.union);
     const { declared, loaded } = input.boundary.consumers;
     const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
-    const world = { closed, writeOnly: writeOnlyDeclarations(input) };
+    const world = {
+        closed,
+        writeOnly: writeOnlyDeclarations(input),
+        exposed: closed
+            ? exposedTypes(facts.graph, facts.reach.map((reach) => reach === "outside"), input.boundary.carriers)
+            : new Set(),
+    };
     const candidates = new Map(input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const generated = input.config.analysis.generated_files === "include" ? undefined : input.files.generated;
     const findings = [];

package/dist/src/framework-lifecycle.js

@@ -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 { isClassDeclaration, isClassExpression, isHeritageClause, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
@@ -13,6 +14,29 @@ import { entriesAt, names, namesADeclaration, resolveEntries, spelledEntry, } fr
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
+/**
+ * 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 = {
+    components: [{ global: "CustomElementRegistry.define" }],
+    members: [
+        "observedAttributes:static",
+        "disabledFeatures:static",
+        "formAssociated:static",
+        "connectedCallback",
+        "disconnectedCallback",
+        "connectedMoveCallback",
+        "adoptedCallback",
+        "attributeChangedCallback",
+        "formAssociatedCallback",
+        "formResetCallback",
+        "formDisabledCallback",
+        "formStateRestoreCallback",
+    ],
+};
 /** Every contract's components and bases, resolved in one pass over the entries. */
 function resolveContracts(project, held, contracts) {
     const entries = contracts.flatMap((contract) => [
@@ -155,16 +179,17 @@ function byBases(project, held, chains, contracts) {
 }
 /**
  * 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(input) {
     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),
@@ -173,22 +198,24 @@ export function frameworkLifecycle(input) {
         return [];
     }
     const ids = new Set(components.map((one) => one.id));
-    const sides = input.ts.lifecycle_contracts.some((contract) => contract.members.some((name) => name.endsWith(":static")))
+    const sides = declared.some((contract) => contract.members.some((name) => name.endsWith(":static")))
         ? ["instance", "static"]
         : ["instance"];
     const members = sides.map((side) => classMembers(project, held, ids, side));
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
-    const found = [];
+    const found = new Map();
     for (const component of components) {
         const listed = new Set(component.contract.members);
         const site = renderPosition(component.site.getSourceFile(), targetRoot, component.site.getStart());
         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()];
 }