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

package/src/findings/emitters.ts

@@ -1,7 +1,6 @@
 import type { Confidence } from "../contract/contract.generated.ts";
 import { evaluateEdges, type EdgeEvaluation } from "../edges.ts";
 import type { CompletedFinding } from "../finding.ts";
-import { liveFilesAt } from "../matrix.ts";
 import { declarationKey } from "../ref.ts";
 import { ledgerOf, type Dials, type Ledger, type SuppressionRecord } from "../suppress.ts";
 import { insideSkipped } from "../type-errors.ts";
@@ -11,7 +10,7 @@ import type { Emitter, EmitterInput, Emitters } from "./emitter.ts";
 import { interfaces } from "./interfaces.ts";
 import { intraFunction } from "./intra-function.ts";
 import { nonCodeArtifacts } from "./non-code-artifacts.ts";
-import { readsAndWrites } from "./reads-and-writes.ts";
+import { fallingWithWrites, readsAndWrites } from "./reads-and-writes.ts";
 import { selfCheck } from "./self-check.ts";
 import { fallenMembers, unusedDeclarations } from "./unused-declarations.ts";
 import { visibilityNarrowing } from "./visibility-narrowing.ts";
@@ -28,42 +27,19 @@ export const EMITTERS: Emitters = new Map<string, Emitter>([
   ["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: EmitterInput): ReadonlySet<string> {
-  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: EmitterInput, ids: Iterable<string>): ReadonlySet<string> {
+  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 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.
- */
-function markupKeys(input: EmitterInput): ReadonlySet<string> {
-  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)),
-  );
+/** The key of the declaration a finding is about, or of the one holding the part it is about. */
+function findingKey(finding: CompletedFinding): string {
+  return declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
 }
 
 /** What the suppressions of a run swept under their marks are decided against. */
@@ -91,15 +67,20 @@ interface DecidedFindings {
 /** How many findings the minimum confidence withheld at each confidence. */
 export type Withheld = Readonly<Record<Confidence, number>>;
 
-/** Every emitter's findings over one sweep, and those of any further emitter, completed by one step. */
+/**
+ * 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 completedOver(
   input: EmitterInput,
   ...more: readonly Emitter[]
 ): readonly CompletedFinding[] {
+  const falls = keysOf(input, fallingWithWrites(input));
   return completed(
     input,
     [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)),
-  );
+  ).filter((finding) => !falls.has(findingKey(finding)));
 }
 
 /**
@@ -161,21 +142,22 @@ function dialledOver(
   unmarked: readonly CompletedFinding[],
 ): Omit<DecidedFindings, "would"> {
   const would = [...unmarked, ...found];
-  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 { 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: CompletedFinding): boolean =>
-    unanswered.has(keyOf(finding)) || insideSkipped(input.swept.skipped, finding.position);
+    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)),
+    (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);

package/src/findings/interfaces.ts

@@ -2,7 +2,7 @@ import { CODE } from "../contract/contract.generated.ts";
 import type { Finding, FindingPosition, PositionedSymbol } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import { byPosition } from "../position.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 /** What each finding says, by what the sweep found about the subject's references. */
@@ -21,7 +21,7 @@ function positionOf(symbol: InventorySymbol): FindingPosition {
 function indexed(input: EmitterInput): {
   readonly symbolOf: (id: string) => InventorySymbol | undefined;
   readonly inTest: (id: string) => boolean;
-  readonly candidateOf: (id: string) => MatrixCandidate | undefined;
+  readonly candidateOf: (id: string) => Candidate | undefined;
   readonly implementationsOf: (id: string) => readonly PositionedSymbol[];
 } {
   const union = input.swept.matrix.union;
@@ -113,7 +113,7 @@ export const interfaces: Emitter = (input) => {
 };
 
 /** What one unused interface's finding says, by the references the sweep counted. */
-function unusedMessage(candidate: MatrixCandidate): string {
+function unusedMessage(candidate: Candidate): string {
   if (candidate.relation === "reachability") {
     return UNUSED_DEAD_MESSAGE;
   }

package/src/findings/intra-function.ts

@@ -3,7 +3,7 @@ import type { Finding } from "../finding.ts";
 import { KINDS } from "../kinds.ts";
 import { parameterRef } from "../ref.ts";
 import { type PartFact } from "../intra-function-parts.ts";
-import { reachedWithTheTests } from "../sweep.ts";
+import { reachedWithTheTests } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 /** A list of rules as a sentence names them. */
@@ -109,8 +109,8 @@ export const intraFunction: Emitter = (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),

package/src/findings/non-code-artifacts.ts

@@ -164,8 +164,19 @@ function fileNeverImported(input: EmitterInput): readonly Finding[] {
     });
 }
 
-/** The findings of the files family, `DS1600` to `DS1699`. */
-export const nonCodeArtifacts: Emitter = (input) => [
-  ...fileNeverBuilt(input),
-  ...fileNeverImported(input),
-];
+/**
+ * The findings of the files family, `DS1600` to `DS1699`, each at the class `possible` in a
+ * package a command of which may run a file whose path no word of it writes, since that
+ * command may run the file (confidence.35).
+ */
+export const nonCodeArtifacts: Emitter = (input) => {
+  const unwritten = [...(input.files.unwrittenRuns ?? [])];
+  return [...fileNeverBuilt(input), ...fileNeverImported(input)].map((finding) =>
+    unwritten.some(
+      (dir) =>
+        dir === "." || finding.position.path === dir || finding.position.path.startsWith(`${dir}/`),
+    )
+      ? { ...finding, reachabilityClass: "possible" as const }
+      : finding,
+  );
+};

package/src/findings/reads-and-writes.ts

@@ -1,10 +1,12 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding, FindingDetails, FindingPosition } from "../finding.ts";
-import type { InventorySymbol } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { WORDS, type InventorySymbol } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import { positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
+import { reachabilityClasses } from "./completion.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
+
 import { bytewise } from "../text/compare.ts";
 
 /** The codes this emitter reports. */
@@ -18,7 +20,7 @@ const SIGNATURES: ReadonlySet<string> = new Set(["function", "method", "type"]);
 interface Run {
   readonly input: EmitterInput;
   readonly symbols: ReadonlyMap<string, InventorySymbol>;
-  readonly candidates: ReadonlyMap<string, MatrixCandidate>;
+  readonly candidates: ReadonlyMap<string, Candidate>;
 }
 
 function indexed(input: EmitterInput): Run {
@@ -112,19 +114,16 @@ function parametersOnlyNamedBy(
 }
 
 /** What one write-only finding says, the declarations its deletion takes with it included. */
-function writeOnlyMessage(
-  run: Run,
-  namedBy: ReadonlyMap<string, ReadonlySet<string>>,
-  symbol: InventorySymbol,
-  held: Uses,
-): string {
+function writeOnlyMessage(run: Run, written: Written, subject: Subject): string {
+  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}`;
@@ -133,17 +132,55 @@ function writeOnlyMessage(
     : `${message}, and deleting it with its writes deletes ${cascade.join(" and ")} too`;
 }
 
+/** One declaration the write-only kind reports, with its uses. */
+interface Subject {
+  readonly symbol: InventorySymbol;
+  readonly held: Uses;
+}
+
 /**
- * `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.
+ * What the write-only kind answers of one run: its subjects in site order, and the
+ * declarations that fall with them, each named under the innermost subject of every chain
+ * of carriers its references hold.
+ */
+interface Written {
+  readonly subjects: readonly Subject[];
+  readonly namedBy: ReadonlyMap<string, ReadonlySet<string>>;
+  readonly named: ReadonlyMap<string, readonly string[]>;
+  readonly falls: ReadonlySet<string>;
+}
+
+/**
+ * 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: ReadonlySet<InventorySymbol["kind"]> = new Set([
+  "function",
+  "class",
+  "interface",
+  "type",
+  "enum",
+  "namespace",
+  "variable",
+]);
+
+const WRITTEN = new WeakMap<EmitterInput, Written>();
+
+/**
+ * `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: Run): readonly Finding[] {
+function writtenOf(run: Run): Written {
+  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<string, Uses>();
   for (const reference of stores.references) {
     let held = uses.get(reference.to);
@@ -174,26 +211,54 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
     }
   }
 
-  const found: Finding[] = [];
-  for (const symbol of matrix.union.symbols) {
+  const subjects = matrix.union.symbols.flatMap((symbol): Subject[] => {
     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)
+      ? []
+      : [{ symbol, held }];
+  });
+  const subjectIds = new Set(subjects.map((subject) => subject.symbol.id));
+  const classOf = reachabilityClasses(run.input);
+  const named = new Map<string, string[]>();
+  const falls = new Set<string>();
+  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: Run): readonly Finding[] {
+  const written = writtenOf(run);
+  return written.subjects.map((subject) =>
+    findingAbout(subject.symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, written, subject), {
+      writePositions: subject.held.writes,
+    }),
+  );
 }
 
 /**
@@ -253,12 +318,20 @@ function unusedTypeParameters(run: Run): readonly Finding[] {
  */
 export function writeOnlyDeclarations(input: EmitterInput): ReadonlySet<string> {
   return new Set(
-    writeOnlySymbols(indexed(input)).map((finding) =>
-      declarationKey(finding.symbol.ref, finding.position.path),
+    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: EmitterInput): ReadonlySet<string> {
+  return writtenOf(indexed(input)).falls;
+}
+
 /**
  * The findings of the reads-and-writes kinds, `DS1301`, `DS1005` and `DS1006`, in that
  * order and each code's in site order.

package/src/findings/unused-declarations.ts

@@ -1,9 +1,8 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
-import type { InventorySymbol, SymbolKind } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { WORDS, type InventorySymbol, type SymbolKind } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
-import { testsUnseenAPI } from "./completion.ts";
 import { unreachableExports } from "./visibility-narrowing.ts";
 
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
@@ -26,39 +25,18 @@ const NOT_REPORTED_HERE: ReadonlySet<SymbolKind> = new Set([
   "type-parameter",
 ]);
 
-/** The reader's word for each kind of declaration a finding of this emitter names. */
-const WORDS: Readonly<Record<SymbolKind, string>> = {
-  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";
 
 /** What the run holds about one candidate that decides its code. */
 interface Judged {
-  readonly candidate: MatrixCandidate;
+  readonly candidate: Candidate;
   readonly symbol: InventorySymbol;
   /** Whether a test file declares it. */
   readonly test: boolean;
   readonly deprecated: boolean;
   /** Whether the unreachable-export kind reports it. */
   readonly unreachable: boolean;
-  /** Whether it is a test with a target that is published API no declared consumer judges. */
-  readonly testsUnseenAPI: boolean;
 }
 
 /**
@@ -72,7 +50,7 @@ interface Judged {
 function codeOf(judged: Judged): string | undefined {
   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;
@@ -245,7 +223,6 @@ function emitterFindings(input: EmitterInput, fallen: boolean): Finding[] {
   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: ReadonlySet<string> | undefined;
 
   const found: Finding[] = [];
@@ -265,7 +242,6 @@ function emitterFindings(input: EmitterInput, fallen: boolean): Finding[] {
       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 (

package/src/findings/visibility-narrowing.ts

@@ -1,11 +1,12 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
-import { OUTSIDE, type Graph } from "../graph.ts";
-import type { InventorySymbol, SymbolKind } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { OUTSIDE, type Graph } from "../liveness/graph.ts";
+import { WORDS, type InventorySymbol } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import { declarationKey } from "../ref.ts";
 import type { RootKind } from "../roots/root-set.ts";
-import { runnerCalls } from "../sweep.ts";
+import { runnerCalls } from "../liveness/sweep.ts";
+import { exposedTypes, exposes } from "../exposure.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 import { writeOnlyDeclarations } from "./reads-and-writes.ts";
 
@@ -19,18 +20,6 @@ type Reach = "file" | "package" | "outside";
  */
 const PUBLISHING: ReadonlySet<RootKind> = new Set<RootKind>(["manifest-entry", "published-api"]);
 
-/** The reader's word for each kind of declaration this emitter reports. */
-const WORDS: Partial<Readonly<Record<SymbolKind, string>>> = {
-  function: "function",
-  class: "class",
-  interface: "interface",
-  type: "type alias",
-  enum: "enum",
-  namespace: "namespace",
-  variable: "variable",
-  "export-alias": "re-export",
-};
-
 /** Per declaration of the run, the facts both rules read. */
 interface Facts {
   readonly graph: Graph;
@@ -142,10 +131,6 @@ function topLevelExport(facts: Facts, at: number, symbol: InventorySymbol): bool
   return symbol.exported && parent !== OUTSIDE && facts.graph.symbols[parent]?.kind === "file";
 }
 
-function wordOf(symbol: InventorySymbol): string {
-  return WORDS[symbol.kind] ?? symbol.kind;
-}
-
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER: Readonly<Record<string, "file" | "package">> = {
   [CODE.redundantExportKeyword]: "file",
@@ -181,7 +166,11 @@ function narrowing(
   facts: Facts,
   at: number,
   symbol: InventorySymbol,
-  world: { readonly closed: boolean; readonly writeOnly: ReadonlySet<string> },
+  world: {
+    readonly closed: boolean;
+    readonly writeOnly: ReadonlySet<string>;
+    readonly exposed: ReadonlySet<string> | "every";
+  },
 ): Finding | undefined {
   const { closed } = world;
   const file = facts.fileOf[at] ?? OUTSIDE;
@@ -195,7 +184,7 @@ function narrowing(
   ) {
     return undefined;
   }
-  const word = wordOf(symbol);
+  const word = WORDS[symbol.kind];
   switch (facts.reach[at]) {
     case "file":
       if (facts.published[file] === true && !closed) {
@@ -207,7 +196,7 @@ function narrowing(
         `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(
@@ -231,7 +220,7 @@ function unreachable(
   facts: Facts,
   at: number,
   symbol: InventorySymbol,
-  candidate: MatrixCandidate,
+  candidate: Candidate,
   input: EmitterInput,
 ): Finding | undefined {
   if (
@@ -252,7 +241,7 @@ function unreachable(
   return findingOf(
     symbol,
     CODE.unreachableExport,
-    `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`,
+    `exported ${WORDS[symbol.kind]} ${found}, and nothing outside can import the file that declares it`,
   );
 }
 
@@ -267,7 +256,17 @@ export function narrowings(input: EmitterInput): readonly Finding[] {
   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<string>(),
+  };
   const candidates = new Map(
     input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]),
   );

package/src/interface-satisfaction.ts

@@ -32,7 +32,7 @@ import { aliasChains } from "./alias-chain.ts";
 import { emptyImplementation } from "./findings/implementations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import type { Reference } from "./references.ts";
-import type { Exemption } from "./sweep.ts";
+import type { Exemption } from "./exempt.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";

package/src/inventory.ts

@@ -50,6 +50,25 @@ export type SymbolKind =
   | "enum-member"
   | "type-parameter";
 
+/** The reader's word for each kind of declaration, as a finding names it. */
+export const WORDS: Readonly<Record<SymbolKind, string>> = {
+  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",
+};
+
 /**
  * How a member may be named from outside its container. A `private` member is still
  * reachable at run time by its name; a private name does not exist outside the class body.

package/src/{components.ts → liveness/components.ts}

@@ -4,10 +4,10 @@
  * and every dead declaration that falls with them, being dead only through them.
  */
 
-import type { Cascade } from "./config.ts";
+import type { Cascade } from "../config.ts";
 import { OUTSIDE, type Graph } from "./graph.ts";
-import type { InventorySymbol } from "./inventory.ts";
-import { PRODUCT } from "./product.ts";
+import type { InventorySymbol } from "../inventory.ts";
+import { PRODUCT } from "../product.ts";
 
 /** The fewest digits a component identifier's number is written with. */
 const ID_DIGITS = 4;