@cplieger/deadset-ts 4.0.1 → 5.1.0

package/src/entry-points.ts

@@ -1,8 +1,8 @@
 /**
  * The files a tool or the platform enters without any import naming them: the
- * configuration files the test runner, the linter, the mutation tester and the
- * browser-test runner load by their file name, the test files the runner executes,
- * and a worker a call addresses by a string literal.
+ * configuration files a tool loads by their file name and the files their strings
+ * name, the test files the runner executes, and a worker a call addresses by a string
+ * literal.
  *
  * Each rule is read from the program and nothing else: a file name the tool
  * itself looks for, a literal written in a configuration file, or a literal
@@ -30,7 +30,14 @@ import {
   type SourceFile,
 } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
+import {
+  configurationFiles,
+  filesNamedBy,
+  moduleStrings,
+  type ParseFile,
+} from "./configuration-files.ts";
 import { globExpression } from "./glob.ts";
+import type { Host } from "./host.ts";
 import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
@@ -38,13 +45,15 @@ import type { SourceFiles } from "./source-files.ts";
 
 /** Which rule entered a file. */
 export type EntryRule =
-  /** The test runner: its configuration, its setup files and the test files. */
+  /** A configuration module, by the form of its name. */
+  | "configuration-file"
+  /** A file a relative string of a configuration module or a JSON configuration file names. */
+  | "configuration-string"
+  /** The test runner: its workspace configuration, its setup files and the test files. */
   | "test-runner"
-  /** The linter's flat configuration. */
-  | "lint-configuration"
-  /** The mutation tester's configuration, and the test-runner configuration it names. */
+  /** The mutation tester's configuration under a name the configuration form does not cover. */
   | "mutation-testing"
-  /** The browser-test runner's configuration and the test files below its test directory. */
+  /** The test files below the browser-test runner's test directory. */
   | "browser-tests"
   /** A worker or service worker a call addresses by a string literal. */
   | "worker";
@@ -78,42 +87,28 @@ interface Convention {
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"] as const;
 
-/** The extensions the linter's flat configuration and the mutation tester's are loaded from. */
+/** The extensions the mutation tester's configuration is loaded from. */
 const SCRIPT_EXTENSIONS = ["js", "mjs", "cjs"] as const;
 
+/** The tool file names the configuration form does not cover. */
 const CONVENTIONS: readonly Convention[] = [
   {
     rule: "test-runner",
-    stems: ["vitest.config", "vitest.workspace", "vitest.projects"],
+    stems: ["vitest.workspace", "vitest.projects"],
     extensions: MODULE_EXTENSIONS,
     testRunner: true,
   },
-  {
-    rule: "lint-configuration",
-    stems: ["eslint.config"],
-    extensions: MODULE_EXTENSIONS,
-    testRunner: false,
-  },
   {
     rule: "mutation-testing",
-    stems: ["stryker.config", "stryker.conf", ".stryker.config", ".stryker.conf"],
+    stems: ["stryker.conf", ".stryker.config", ".stryker.conf"],
     extensions: SCRIPT_EXTENSIONS,
     testRunner: false,
   },
-  {
-    rule: "mutation-testing",
-    stems: ["vitest.stryker.config"],
-    extensions: MODULE_EXTENSIONS,
-    testRunner: true,
-  },
-  {
-    rule: "browser-tests",
-    stems: ["playwright.config"],
-    extensions: MODULE_EXTENSIONS,
-    testRunner: false,
-  },
 ];
 
+/** The stem of the browser-test runner's configuration, whose test directory is read. */
+const BROWSER_TEST_CONFIG = "playwright.config";
+
 /** The browser-test runner's own test-file pattern, which holds where a configuration names none. */
 const BROWSER_TEST_MATCH = "**/*.{spec,test}.{js,ts,jsx,tsx,cjs,cts,cjsx,ctsx,mjs,mts,mjsx,mtsx}";
 
@@ -256,6 +251,50 @@ function filesNamed(files: SourceFiles, dir: string, text: string): readonly Sou
   return files.named(resolvePath(dir, pathPart(text)));
 }
 
+/** Whether one file name is the browser-test runner's configuration. */
+function isBrowserTestConfig(name: string): boolean {
+  return MODULE_EXTENSIONS.some((ext) => name === `${BROWSER_TEST_CONFIG}.${ext}`);
+}
+
+/**
+ * The files the configuration files of one project enter: each configuration module,
+ * with what it exports, and each own file a relative string of a configuration module
+ * or a JSON configuration file names, read against that file's directory.
+ */
+function configurationEntries(
+  host: Host,
+  targetRoot: string,
+  files: SourceFiles,
+  parse: ParseFile | undefined,
+): readonly EntryPoint[] {
+  const { modules, documents, outside } = configurationFiles(host, targetRoot, files, parse);
+  const found: EntryPoint[] = [];
+  const strings = (dir: string, texts: readonly string[]): void => {
+    for (const text of texts) {
+      for (const file of filesNamedBy(files, dir, text)) {
+        found.push({ file, rule: "configuration-string", source: text, exports: true });
+      }
+    }
+  };
+  for (const { file, form } of modules) {
+    found.push({ file, rule: "configuration-file", source: form, exports: true });
+    strings(
+      dirnamePath(file.fileName),
+      moduleStrings(file).map((one) => one.text),
+    );
+  }
+  for (const document of documents) {
+    strings(dirnamePath(document.path), document.strings);
+  }
+  for (const { file } of outside) {
+    strings(
+      dirnamePath(file.fileName),
+      moduleStrings(file).map((one) => one.text),
+    );
+  }
+  return found;
+}
+
 /**
  * The setup files one test-runner configuration names: every literal under
  * `test.setupFiles` and `test.globalSetup`, read against the configuration's own
@@ -467,8 +506,8 @@ function workersOf<Brand>(
 }
 
 /**
- * Every file of one project the lifted rules enter, in no particular order and
- * possibly more than once: a file two rules enter appears once per rule.
+ * Every file of one project the rules enter, in no particular order and possibly more
+ * than once: a file two rules enter appears once per rule.
  *
  * `testFiles` is the configuration's test-file patterns, matched against each
  * file's path below the target root; a file one of them matches is a test file the
@@ -478,19 +517,23 @@ export function entryPoints<Brand>(
   project: ProjectView<Brand>,
   files: SourceFiles,
   testFiles: readonly string[],
+  host: Host,
+  targetRoot: string,
+  parse?: ParseFile,
 ): readonly EntryPoint[] {
-  const found: EntryPoint[] = [];
+  const found: EntryPoint[] = [...configurationEntries(host, targetRoot, files, parse)];
   const tests = testFiles.map((pattern) => ({ pattern, expression: globExpression(pattern) }));
   for (const [path, file] of files.byPath) {
-    const named = conventionOf(basename(path));
+    const name = basename(path);
+    const named = conventionOf(name);
     if (named !== undefined) {
       found.push({ file, rule: named.convention.rule, source: named.spelled, exports: true });
       if (named.convention.testRunner) {
         found.push(...setupFilesOf(file, files));
       }
-      if (named.convention.rule === "browser-tests") {
-        found.push(...browserTestsOf(file, files));
-      }
+    }
+    if (isBrowserTestConfig(name)) {
+      found.push(...browserTestsOf(file, files));
     }
     for (const { pattern, expression } of tests) {
       if (expression.test(path)) {

package/src/exempt-classes.ts

@@ -49,7 +49,12 @@ export const EXEMPTION_CLASSES = [
     confidence: "certain",
     typescriptVisibility: { private: false, privateName: false },
   },
-  { class: "generated-file", languages: ["go"], confidence: "certain" },
+  {
+    class: "generated-file",
+    languages: ["go", "ts"],
+    confidence: "certain",
+    typescriptVisibility: { private: true, privateName: false },
+  },
   { class: "linkname-cgo-asm-plugin", languages: ["go"], confidence: "certain" },
   {
     class: "template-field",

package/src/exempt.ts

@@ -33,6 +33,8 @@ export interface Evidence {
   /** One clause naming the relation, then the thing it relates to. */
   readonly detail: string;
   readonly site: Position;
+  /** The component file, below the target root, whose markup holds the evidence. */
+  readonly whileLive?: string;
 }
 
 /** What a detector reads of one project, while the project's view is open. */
@@ -46,6 +48,11 @@ export interface DetectorInput<Brand> {
   readonly ts: TSSection;
   /** 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
+   * convention row that names its directory as generated.
+   */
+  readonly generated?: ReadonlyMap<string, string>;
 }
 
 /**
@@ -160,8 +167,29 @@ export function computeExemptions<Brand>(
   detectors: Detectors,
   holding: Holding,
 ): readonly Exemption[] {
+  return detectExemptions(input, detectors, holding).records;
+}
+
+/** One project's records, and the evidence a production mode found in a test file. */
+export interface Detected {
+  readonly records: readonly Exemption[];
+  /**
+   * Under a production mode, each record whose evidence is written in a test file. It
+   * holds nothing, and it is a test reference to its declaration, as a reference the
+   * test file wrote would be.
+   */
+  readonly inTestFiles: readonly Exemption[];
+}
+
+/** The records of {@link computeExemptions}, beside the test-file evidence it set aside. */
+export function detectExemptions<Brand>(
+  input: DetectorInput<Brand>,
+  detectors: Detectors,
+  holding: Holding,
+): Detected {
   const visibility = new Map(input.held.symbols.map((symbol) => [symbol.id, symbol.visibility]));
   const found: Exemption[] = [];
+  const inTestFiles: Exemption[] = [];
   for (const exemptionClass of TS_EXEMPTION_CLASSES) {
     const detect = detectors.get(exemptionClass);
     if (detect === undefined || holding.disabled.has(exemptionClass)) {
@@ -172,18 +200,21 @@ export function computeExemptions<Brand>(
       if (!retainable(allowed, visibility.get(evidence.id))) {
         continue;
       }
-      if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
-        continue;
-      }
-      found.push({
+      const record = {
         id: evidence.id,
         class: exemptionClass,
         detail: evidence.detail,
         site: evidence.site,
-      });
+        ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
+      };
+      if (holding.mode.production && holding.testFiles.has(evidence.site.path)) {
+        inTestFiles.push(record);
+        continue;
+      }
+      found.push(record);
     }
   }
-  return exemptionsOf(found);
+  return { records: exemptionsOf(found), inTestFiles };
 }
 
 /** Two strings ordered bytewise. */
@@ -196,8 +227,8 @@ function compare(a: string, b: string): number {
 
 /**
  * Records as a run holds them: ordered by site, then class, then declaration, and one
- * per declaration, class and detail, the one at the first site. A fact found at many
- * sites, or by several projects, is one record.
+ * per declaration, class, detail and file it holds while live, the one at the first
+ * site. A fact found at many sites, or by several projects, is one record.
  */
 export function exemptionsOf(found: readonly Exemption[]): readonly Exemption[] {
   const ordered = [...found].sort(
@@ -205,7 +236,7 @@ export function exemptionsOf(found: readonly Exemption[]): readonly Exemption[]
   );
   const seen = new Set<string>();
   return ordered.filter((record) => {
-    const fact = [record.id, record.class, record.detail].join("\u0000");
+    const fact = [record.id, record.class, record.detail, record.whileLive ?? ""].join("\u0000");
     if (seen.has(fact)) {
       return false;
     }
@@ -214,6 +245,21 @@ export function exemptionsOf(found: readonly Exemption[]): readonly Exemption[]
   });
 }
 
+/**
+ * The records that hold while the component files at `live` are live: every record that
+ * holds whatever is live, and each one a live file's markup holds, as a record of the run.
+ */
+export function holdingWhile(
+  records: readonly Exemption[],
+  live: ReadonlySet<string>,
+): readonly Exemption[] {
+  return exemptionsOf(
+    records.flatMap(({ whileLive, ...record }) =>
+      whileLive === undefined || live.has(whileLive) ? [record] : [],
+    ),
+  );
+}
+
 /** The records per declaration, each declaration's in the order given. */
 function byDeclaration(records: readonly Exemption[]): ReadonlyMap<string, readonly Exemption[]> {
   const grouped = new Map<string, Exemption[]>();
@@ -229,17 +275,18 @@ function byDeclaration(records: readonly Exemption[]): ReadonlyMap<string, reado
 }
 
 /**
- * The records that held back a declaration some configuration of the run would
- * otherwise judge dead: each configuration's graph is swept once more with no
- * exemption and the marks it was given, and a record is retained when one of those
- * sweeps judged its declaration a candidate. A record that holds a declaration back in
- * one configuration is retained whatever another configuration answers about it, as a
- * run of that configuration alone would report the declaration without it. A record
- * on a declaration that a relation or a mark holds live in every configuration held
- * nothing back. The order is the declarations' site order, and for one declaration
- * the input's.
+ * The records that held back a declaration: one some configuration's graph, swept
+ * again with no exemption and its marks, judges a candidate, whatever another
+ * configuration answers, or one in `writeOnly`, which the run would report as written
+ * and never read without the record's read. A declaration a relation or a mark holds
+ * live in every configuration is held back by no record. The order is the
+ * declarations' site order, and for one declaration the input's.
  */
-export function retainedIn(matrix: Matrix, input: SweepInput): readonly Exemption[] {
+export function retainedIn(
+  matrix: Matrix,
+  input: SweepInput,
+  writeOnly: ReadonlySet<string> = new Set(),
+): readonly Exemption[] {
   const exempt = input.exempt ?? [];
   if (exempt.length === 0) {
     return [];
@@ -250,7 +297,9 @@ export function retainedIn(matrix: Matrix, input: SweepInput): readonly Exemptio
       sweep(graph, bare).candidates.map((candidate) => candidate.id),
     ),
   );
-  const held = byDeclaration(exempt.filter((record) => dead.has(record.id)));
+  const held = byDeclaration(
+    exempt.filter((record) => dead.has(record.id) || writeOnly.has(record.id)),
+  );
   return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
 }
 

package/src/file-facts.ts

@@ -47,6 +47,8 @@ export interface FileFacts {
    * reference names is included by the file that names it.
    */
   readonly heldByInclusion: ReadonlySet<string>;
+  /** The paths below the target root of the files below a directory an applied row names as generated. */
+  readonly generated?: ReadonlySet<string>;
 }
 
 /** The line of the last character of one text, counted from one; an empty text is one line. */

package/src/findings/completion.ts

@@ -8,7 +8,7 @@ import type { RunSweep } from "../analysis.ts";
 import { componentId, type Component } from "../components.ts";
 import type { Cascade, Confidence, Severity } from "../config.ts";
 import type { CompletedFinding, Finding, FindingComponent, PositionedSymbol } from "../finding.ts";
-import { OUTSIDE } from "../graph.ts";
+import { OUTSIDE, type Graph } from "../graph.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
 import { byPosition } from "../position.ts";
 import { FAMILY_KEY_LENGTH } from "../resolve.ts";
@@ -24,56 +24,47 @@ function capped(found: Confidence, ceiling: Confidence): Confidence {
   return RANK[found] <= RANK[ceiling] ? found : ceiling;
 }
 
-/** The kind whose default turns on what the run knows about the target's consumers. */
-const UNUSED_EXPORTED = "DS1001";
-
 /** Whether the run loaded every consumer the scope declared, which holds of a scope declaring none. */
 function everyDeclaredLoaded(boundary: Boundary): boolean {
   const { declared, loaded } = boundary.consumers;
   return declared.every((id) => loaded.includes(id));
 }
 
-/**
- * Whether a library's published API may have a caller the run cannot see: the target is
- * a library, and the run either holds no consumer information or did not load a consumer
- * the scope declared. A configuration declaring the consumer set complete holds consumer
- * information whether or not it declares a consumer, because it says no other exists.
- */
-function openWorld(input: EmitterInput): boolean {
-  const known = input.config.consumersComplete || input.boundary.consumers.declared.length > 0;
-  return input.config.targetKind === "library" && !(known && everyDeclaredLoaded(input.boundary));
-}
-
 /**
  * The severity the configuration gives one code: the key naming the code, else the key
- * naming its family, else the code's default. The unused-exported kind defaults to
- * `allow` while a library's published API is open to callers the run cannot see.
+ * naming its family, else the code's default.
  */
 function severityOf(input: EmitterInput, code: string, fallback: Severity): Severity {
   const { config } = input;
-  const named = config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH));
-  if (named !== undefined) {
-    return named;
-  }
-  return code === UNUSED_EXPORTED && openWorld(input) ? "allow" : fallback;
+  return (
+    config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback
+  );
 }
 
 /**
- * The reachability class of one declaration of the run. A declaration of a library's
- * published API has callers outside the target: it is `certain` where the run loaded
- * every consumer the scope declared and declared at least one, `probable` where it
- * declared consumers and did not load them all, and `possible` where it declared none.
- * Whether the configuration declares the consumer set complete decides nothing here.
- * Every other declaration has every reference in the loaded program, a private member
- * and a `#private` name among them, and is `certain`.
+ * The declarations the roots name as a library's published API, each public member of a
+ * published type included.
  */
-function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
-  const union = input.swept.matrix.union;
-  const published = new Set(
+function publishedIds(union: Graph): ReadonlySet<string> {
+  return new Set(
     union.rooted
       .filter((root) => root.kind === "published-api")
-      .map((root) => union.symbols[root.at]?.id),
+      .flatMap((root) => union.symbols[root.at]?.id ?? []),
   );
+}
+
+/**
+ * The reachability class of one declaration of the run. A declaration of a library's
+ * published API, a public member of a published type included, has callers outside the
+ * target: it is `certain` where the run loaded every consumer the scope declared and
+ * declared at least one, `probable` where it declared consumers and did not load them
+ * all, and `possible` where it declared none. Whether the configuration declares the
+ * consumer set complete decides nothing here. Every other declaration has every reference
+ * in the loaded program, a private member and a `#private` name among them, and is
+ * `certain`.
+ */
+function reachabilityClasses(input: EmitterInput): (id: string) => Confidence {
+  const published = publishedIds(input.swept.matrix.union);
   const { declared } = input.boundary.consumers;
   const outside: Confidence =
     declared.length === 0
@@ -155,8 +146,9 @@ export function completed(
   const classOf = reachabilityClasses(input);
   const componentOf = findingComponents(swept, input.config.reporters.cascade);
   let minted = swept.sweep.components.length;
+  const dead = new Set(swept.sweep.components.map((component) => component.id));
 
-  return findings.map((finding): CompletedFinding => {
+  const done = findings.map((finding): CompletedFinding => {
     const row = kinds.get(finding.code);
     if (row === undefined) {
       throw new Error(`${finding.code} names no live row of the issue-kind vocabulary`);
@@ -192,6 +184,7 @@ export function completed(
         ? union.made[at]
         : { production: candidate.productionRefs, test: candidate.testRefs };
     const reachabilityClass = judged === undefined ? "certain" : classOf(judged.id);
+    const generated = input.files.generated?.has(finding.position.path) === true;
     return {
       code: finding.code,
       kind: row.name,
@@ -202,7 +195,7 @@ export function completed(
       confidence: capped(reachabilityClass, row.maxClass),
       ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
       testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
-      generated: false,
+      generated,
       component,
       retainedBy: [],
       configurations:
@@ -211,12 +204,38 @@ export function completed(
           ? swept.matrix.configurations
           : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
       consumersLoaded: input.boundary.consumers.loaded,
-      fixability: row.fixability,
+      fixability: generated ? "none" : row.fixability,
       severity: severityOf(input, finding.code, row.defaultSeverity),
       message: finding.message,
       details: finding.details ?? {},
     };
   });
+  return componentCapped(done, dead);
+}
+
+/**
+ * The findings with every finding of a dead component capped by the lowest confidence
+ * among the component's root members, so the minimum confidence reports or withholds a
+ * component whole.
+ */
+function componentCapped(
+  findings: readonly CompletedFinding[],
+  dead: ReadonlySet<string>,
+): readonly CompletedFinding[] {
+  const lowest = new Map<string, Confidence>();
+  for (const finding of findings) {
+    const { id, root } = finding.component;
+    if (root && dead.has(id)) {
+      const held = lowest.get(id);
+      lowest.set(id, held === undefined ? finding.confidence : capped(held, finding.confidence));
+    }
+  }
+  return findings.map((finding) => {
+    const cap = lowest.get(finding.component.id);
+    return cap === undefined || RANK[cap] >= RANK[finding.confidence]
+      ? finding
+      : { ...finding, confidence: cap };
+  });
 }
 
 /** Whether the dials withhold a finding by its own severity or confidence. */

package/src/findings/emitters.ts

@@ -1,6 +1,8 @@
 import { evaluateEdges, type EdgeEvaluation } from "../edges.ts";
 import type { CompletedFinding } from "../finding.ts";
+import { liveFilesAt } from "../matrix.ts";
 import { ledgerOf, type Dials, type Ledger, type SuppressionRecord } from "../suppress.ts";
+import { insideSkipped } from "../type-errors.ts";
 import { completed, dialsOf, reportable } from "./completion.ts";
 import { dependenciesAndModuleMachinery } from "./dependencies-and-module-machinery.ts";
 import type { Emitter, EmitterInput, Emitters } from "./emitter.ts";
@@ -40,6 +42,28 @@ function heldRefs(input: EmitterInput): ReadonlySet<string> {
   );
 }
 
+/**
+ * The references 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 markupRefs(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) => symbol.ref),
+  );
+}
+
 /** What the suppressions of a run swept under their marks are decided against. */
 export interface Suppressed {
   /** The same run swept with no mark, which is where a kind about liveness reports a marked declaration. */
@@ -109,9 +133,16 @@ export function decidedFindings(
   const would = [...unmarked, ...found];
   const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
   const unanswered = heldRefs(input);
+  const markup = markupRefs(input);
   const kept = reportable(
     input,
-    found.filter((finding) => !ledger.withheld(finding) && !unanswered.has(finding.symbol.ref)),
+    found.filter(
+      (finding) =>
+        !ledger.withheld(finding) &&
+        !unanswered.has(finding.symbol.ref) &&
+        !markup.has(finding.symbol.ref) &&
+        !insideSkipped(input.swept.skipped, finding.position),
+    ),
   );
   const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
   return {

package/src/findings/interfaces.ts

@@ -31,6 +31,7 @@ function compare(a: string, b: string): number {
 function indexed(input: EmitterInput): {
   readonly symbolOf: (id: string) => InventorySymbol | undefined;
   readonly inTest: (id: string) => boolean;
+  readonly inSupport: (id: string) => boolean;
   readonly candidateOf: (id: string) => Candidate | undefined;
   readonly implementationsOf: (id: string) => readonly PositionedSymbol[];
 } {
@@ -43,6 +44,7 @@ function indexed(input: EmitterInput): {
   return {
     symbolOf,
     inTest: (id) => union.test[union.at(id)] === true,
+    inSupport: (id) => union.support[union.at(id)] === true,
     candidateOf: (id) => candidates.get(id),
     implementationsOf: (id) =>
       [...(input.implementations.classes.get(id) ?? [])]
@@ -80,14 +82,19 @@ function findingOf(
  * interface, whose members fall with it unreported; and `DS1203`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
  * implementation has an empty body. A test file's declaration is neither kind's
- * subject, because a production sweep counts none of the references it can have.
+ * subject, because a production sweep counts none of the references it can have, and
+ * neither is a test-support declaration test code references, which that code keeps live.
  */
 export const interfaces: Emitter = (input) => {
   const run = indexed(input);
   const found: Finding[] = [];
   for (const candidate of input.swept.sweep.candidates) {
     const symbol = run.symbolOf(candidate.id);
-    if (symbol === undefined || run.inTest(candidate.id)) {
+    if (
+      symbol === undefined ||
+      run.inTest(candidate.id) ||
+      (run.inSupport(candidate.id) && candidate.testRefs > 0)
+    ) {
       continue;
     }
     if (symbol.kind === "interface") {