@cplieger/deadset-ts 5.2.2 → 6.0.0

package/src/dependencies.ts

@@ -1,10 +1,10 @@
 /**
- * The dependencies the target's manifest declares, and what the projects' own files
- * need from outside the target. A file needs a package it imports, re-exports from,
- * augments or references the types of, by name or through the file the specifier
- * resolves to; a compiler configuration needs one it names, and a configuration file a
- * tool loads needs each dependency its strings spell. A package one dependency pulls in
- * for itself is that dependency's need, not the target's.
+ * The dependencies the target's manifest and its workspace members' manifests declare, and
+ * what the projects' own files need from outside the target. A file needs a package it
+ * imports, re-exports from, augments or references the types of, by name or through the
+ * file the specifier resolves to; a compiler configuration needs one it names, and a
+ * configuration file a tool loads needs each dependency its strings spell. A package one
+ * dependency pulls in for itself is that dependency's need, not the target's.
  */
 
 import {
@@ -32,7 +32,7 @@ import {
 import type { FindingPosition } from "./finding.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, packageScope, type Inventory } from "./inventory.ts";
-import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.ts";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { DependencySection, Module } from "./ref.ts";
 import { UNANSWERED } from "./query.ts";
 import type { Handle, ProjectView } from "./session.ts";
@@ -53,12 +53,14 @@ const SECTIONS: readonly (readonly [string, DependencySection])[] = [
 /** The owner of a use no declaration of the inventory holds: a configuration's. */
 const PROJECT_OWNER = "";
 
-/** One dependency the target's manifest declares. */
+/** One dependency a manifest the run reads declares. */
 export interface DeclaredDependency {
   readonly name: string;
   readonly section: DependencySection;
   /** Where the manifest writes the dependency's key, below the target root. */
   readonly position: FindingPosition;
+  /** The scope the dependency's reference is written in: its manifest's. */
+  readonly manifest: Module;
 }
 
 /** What a configuration's own reading needs: packages no deletion of a declaration removes. */
@@ -97,9 +99,7 @@ export interface ProjectNeeds {
 
 /** The run's dependency evidence. */
 export interface Dependencies {
-  /** The scope every dependency's reference is written in: the target's manifest. */
-  readonly manifest: Module;
-  /** Every declared dependency, in the order the manifest writes them. */
+  /** Every declared dependency, manifest by manifest, in the order each writes them. */
   readonly declared: readonly DeclaredDependency[];
   /** The installed copy of each declared dependency the run found, by name. */
   readonly installed: ReadonlyMap<string, InstalledDependency>;
@@ -608,8 +608,13 @@ function installedOf(host: Host, root: string, name: string): InstalledDependenc
   }
 }
 
-/** Every dependency the manifest text declares, in the order the text writes them. */
-function declaredIn(text: string, manifest: Record<string, unknown>): DeclaredDependency[] {
+/** Every dependency the manifest text at `path` declares, in the order the text writes them. */
+function declaredIn(
+  text: string,
+  manifest: Record<string, unknown>,
+  path: string,
+  scope: Module,
+): DeclaredDependency[] {
   const sections = membersAt(text, skipWhitespace(text, 0));
   const declared: { readonly dependency: DeclaredDependency; readonly at: number }[] = [];
   for (const [member, section] of SECTIONS) {
@@ -621,7 +626,12 @@ function declaredIn(text: string, manifest: Record<string, unknown>): DeclaredDe
     for (const [name, { key }] of membersAt(text, held.value)) {
       const { line, column } = lineAndColumn(text, key);
       declared.push({
-        dependency: { name, section, position: { path: MANIFEST, line, column, endLine: line } },
+        dependency: {
+          name,
+          section,
+          position: { path, line, column, endLine: line },
+          manifest: scope,
+        },
         at: key,
       });
     }
@@ -630,11 +640,10 @@ function declaredIn(text: string, manifest: Record<string, unknown>): DeclaredDe
 }
 
 /**
- * The run's dependency evidence: the target's manifest read with the position of every
- * dependency it declares, the installed copy of each, what the projects need, and the
- * last uses each deletion candidate holds.
- *
- * Only the manifest at the target root is read, as for entry points. A manifest the
+ * The run's dependency evidence: the target's manifest and each workspace member's in
+ * `members` below the target root, read with the position of every dependency each
+ * declares, the installed copy of each found from its manifest's directory, what the
+ * projects need, and the last uses each deletion candidate holds. A manifest the
  * program cannot read declares nothing.
  */
 export function dependenciesOf(
@@ -642,20 +651,31 @@ export function dependenciesOf(
   targetRoot: string,
   perProject: readonly ProjectNeeds[],
   candidates: readonly string[],
+  members: readonly string[] = [],
 ): Dependencies {
-  const read = readJSON(host, joinPath(targetRoot, MANIFEST));
-  const manifest = isRecord(read?.value) ? read.value : undefined;
-  const scope = packageScope(host, targetRoot)(MANIFEST);
-  const declared =
-    read !== undefined && manifest !== undefined ? declaredIn(read.text, manifest) : [];
-
   const root = resolvePath(host.workingDirectory(), targetRoot);
+  const scopeOf = packageScope(host, targetRoot);
+  const manifests = new Map<string, string>([[root, MANIFEST]]);
+  for (const dir of members) {
+    const below = relativePath(root, dir);
+    if (below !== undefined && !manifests.has(dir)) {
+      manifests.set(dir, `${below}/${MANIFEST}`);
+    }
+  }
+  const declared: DeclaredDependency[] = [];
   const installed = new Map<string, InstalledDependency>();
-  for (const dependency of declared) {
-    if (!installed.has(dependency.name)) {
-      const found = installedOf(host, root, dependency.name);
-      if (found !== undefined) {
-        installed.set(dependency.name, found);
+  for (const [dir, path] of manifests) {
+    const read = readJSON(host, joinPath(dir, MANIFEST));
+    if (read === undefined || !isRecord(read.value)) {
+      continue;
+    }
+    for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
+      declared.push(dependency);
+      if (!installed.has(dependency.name)) {
+        const found = installedOf(host, dir, dependency.name);
+        if (found !== undefined) {
+          installed.set(dependency.name, found);
+        }
       }
     }
   }
@@ -691,5 +711,5 @@ export function dependenciesOf(
       );
     }
   }
-  return { manifest: scope, declared, installed, needed, lastUses };
+  return { declared, installed, needed, lastUses };
 }

package/src/entry-points.ts

@@ -36,6 +36,7 @@ import {
   moduleStrings,
   type ParseFile,
 } from "./configuration-files.ts";
+import type { Selected } from "./conventions.ts";
 import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { htmlEntries } from "./html-entries.ts";
@@ -43,6 +44,7 @@ import { dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { workflowEntries } from "./workflow-steps.ts";
 
 /** Which rule entered a file. */
 export type EntryRule =
@@ -52,14 +54,14 @@ export type EntryRule =
   | "configuration-string"
   /** The test runner: its workspace configuration, its setup files and the test files. */
   | "test-runner"
-  /** The mutation tester's configuration under a name the configuration form does not cover. */
-  | "mutation-testing"
   /** 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"
   /** A file a module script of an HTML file below the target root loads. */
-  | "html-entry";
+  | "html-entry"
+  /** A file a `run:` step of a workflow in the target root's `.github/workflows` names. */
+  | "workflow-step";
 
 /** One file a rule enters. */
 export interface EntryPoint {
@@ -90,9 +92,6 @@ 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 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[] = [
   {
@@ -101,12 +100,6 @@ const CONVENTIONS: readonly Convention[] = [
     extensions: MODULE_EXTENSIONS,
     testRunner: true,
   },
-  {
-    rule: "mutation-testing",
-    stems: ["stryker.conf", ".stryker.config", ".stryker.conf"],
-    extensions: SCRIPT_EXTENSIONS,
-    testRunner: false,
-  },
 ];
 
 /** The stem of the browser-test runner's configuration, whose test directory is read. */
@@ -262,16 +255,35 @@ function isBrowserTestConfig(name: string): boolean {
 /**
  * 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.
+ * or a JSON configuration file names, read against that file's directory. A string at a
+ * selection key of an applied convention row names no file.
  */
 function configurationEntries(
   host: Host,
   targetRoot: string,
   files: SourceFiles,
   parse: ParseFile | undefined,
+  selected: ReadonlyMap<string, Selected>,
 ): readonly EntryPoint[] {
   const { modules, documents, outside } = configurationFiles(host, targetRoot, files, parse);
   const found: EntryPoint[] = [];
+  const unselected = (file: SourceFile): readonly string[] => {
+    const starts = selected.get(file.fileName)?.starts;
+    return moduleStrings(file)
+      .filter((one) => starts?.has(one.node.getStart()) !== true)
+      .map((one) => one.text);
+  };
+  const unselectedIn = (path: string, texts: readonly string[]): readonly string[] => {
+    const left = [...(selected.get(path)?.texts ?? [])];
+    return texts.filter((text) => {
+      const at = left.indexOf(text);
+      if (at < 0) {
+        return true;
+      }
+      left.splice(at, 1);
+      return false;
+    });
+  };
   const strings = (dir: string, texts: readonly string[]): void => {
     for (const text of texts) {
       for (const file of filesNamedBy(files, dir, text)) {
@@ -281,13 +293,10 @@ function configurationEntries(
   };
   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),
-    );
+    strings(dirnamePath(file.fileName), unselected(file));
   }
   for (const document of documents) {
-    strings(dirnamePath(document.path), document.strings);
+    strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
   }
   for (const { file } of outside) {
     strings(
@@ -523,8 +532,9 @@ export function entryPoints<Brand>(
   host: Host,
   targetRoot: string,
   parse?: ParseFile,
+  selected: ReadonlyMap<string, Selected> = new Map(),
 ): readonly EntryPoint[] {
-  const found: EntryPoint[] = [...configurationEntries(host, targetRoot, files, parse)];
+  const found: EntryPoint[] = [...configurationEntries(host, targetRoot, files, parse, selected)];
   const tests = testFiles.map((pattern) => ({ pattern, expression: globExpression(pattern) }));
   for (const [path, file] of files.byPath) {
     const name = basename(path);
@@ -548,5 +558,8 @@ export function entryPoints<Brand>(
   for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
     found.push({ file, rule: "html-entry", source, exports: true });
   }
+  for (const { file, source } of workflowEntries(host, targetRoot, files)) {
+    found.push({ file, rule: "workflow-step", source, exports: true });
+  }
   return found;
 }

package/src/exempt.ts

@@ -24,7 +24,7 @@ import { byPosition, positionKey, type Position } from "./position.ts";
 import { Unanswerable } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { Templates } from "./template-field.ts";
-import { sweep, type Exemption, type Mode, type SweepInput } from "./sweep.ts";
+import { sweep, type Exemption, type Implementing, type Mode, type SweepInput } from "./sweep.ts";
 
 /** One declaration a detector holds back, and where and why. */
 export interface Evidence {
@@ -35,6 +35,8 @@ export interface Evidence {
   readonly site: Position;
   /** The component file, below the target root, whose markup holds the evidence. */
   readonly whileLive?: string;
+  /** Where the evidence is an implementation of interface methods, which and how. */
+  readonly implementing?: Implementing;
 }
 
 /** What a detector reads of one project, while the project's view is open. */
@@ -214,6 +216,7 @@ export function evidenceRecords<Brand>(
         detail: evidence.detail,
         site: evidence.site,
         ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
+        ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
       });
     }
   }

package/src/findings/dependencies-and-module-machinery.ts

@@ -37,7 +37,7 @@ function neededBy(dependencies: Dependencies): ReadonlySet<string> {
 }
 
 /**
- * A dependency, development dependency or peer dependency of the target's manifest
+ * A dependency, development dependency or peer dependency of a manifest the run reads
  * that the target does not need, at the position of its key.
  */
 function unusedDependencies(dependencies: Dependencies): Finding[] {
@@ -48,7 +48,7 @@ function unusedDependencies(dependencies: Dependencies): Finding[] {
       code: UNUSED_DEPENDENCY,
       position: dependency.position,
       symbol: {
-        ref: renderRef(dependencies.manifest, {
+        ref: renderRef(dependency.manifest, {
           of: "dependency",
           name: dependency.name,
           section: dependency.section,

package/src/findings/emitters.ts

@@ -1,3 +1,4 @@
+import type { Confidence } from "../config.ts";
 import { evaluateEdges, type EdgeEvaluation } from "../edges.ts";
 import type { CompletedFinding } from "../finding.ts";
 import { liveFilesAt } from "../matrix.ts";
@@ -82,8 +83,13 @@ export interface DecidedFindings {
   readonly ledger: Ledger<CompletedFinding>;
   /** Every finding a record could name: the run's with no mark, then the run's as swept. */
   readonly would: readonly CompletedFinding[];
+  /** The findings the minimum confidence withheld, by confidence. */
+  readonly withheld: Withheld;
 }
 
+/** How many findings the minimum confidence withheld at each confidence. */
+export type Withheld = Readonly<Record<Confidence, number>>;
+
 /** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
 function completedOver(
   input: EmitterInput,
@@ -116,12 +122,12 @@ function dialsOver(
 }
 
 /**
- * Every finding of one run swept under its suppressions' marks, decided in one pass: every
- * family's findings completed by one step, so every component number is minted once, a
- * pending finding's among them; the finding each record claims withheld, whatever its
- * kind; the rest withheld by the dials, so a root one family reports withholds what
- * another family reports in its component; and every declared edge evaluated over what
- * remains, so a finding it holds pending is in its evaluation and nowhere else.
+ * Every finding of one run swept under its suppressions' marks, decided in one pass: each
+ * family's findings completed by one step, so every component number is minted once, the
+ * finding each record claims withheld, the rest withheld by the dials, so a root one family
+ * reports withholds what another reports in its component, and every declared edge
+ * evaluated over what remains, so a pending finding is in its evaluation alone. What the
+ * minimum confidence withheld is what the same decision at the lowest minimum adds.
  */
 export function decidedFindings(
   input: EmitterInput,
@@ -131,6 +137,43 @@ export function decidedFindings(
   const unmarked =
     suppressed.records.length === 0 ? [] : completedOver(suppressed.unmarked, fallenMembers);
   const would = [...unmarked, ...found];
+  const decided = dialledOver(input, suppressed, found, unmarked);
+  const shown =
+    input.config.analysis.minConfidence === "possible"
+      ? decided
+      : dialledOver(
+          atPossible(input),
+          {
+            unmarked: atPossible(suppressed.unmarked),
+            records: suppressed.records,
+          },
+          found,
+          unmarked,
+        );
+  return { ...decided, would, withheld: withheldOf(decided.findings, shown.findings) };
+}
+
+/** The run's input with the minimum confidence at its lowest, which withholds nothing. */
+function atPossible(input: EmitterInput): EmitterInput {
+  const { config } = input;
+  return {
+    ...input,
+    config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
+  };
+}
+
+/**
+ * The run's completed findings decided under its dials: the finding each record claims
+ * withheld, the rest withheld by the dials, and every declared edge evaluated over what
+ * remains.
+ */
+function dialledOver(
+  input: EmitterInput,
+  suppressed: Suppressed,
+  found: readonly CompletedFinding[],
+  unmarked: readonly CompletedFinding[],
+): Omit<DecidedFindings, "would" | "withheld"> {
+  const would = [...unmarked, ...found];
   const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
   const unanswered = heldRefs(input);
   const markup = markupRefs(input);
@@ -145,12 +188,28 @@ export function decidedFindings(
     ),
   );
   const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
-  return {
-    findings: evaluated.findings,
-    evaluations: evaluated.evaluations,
-    ledger,
-    would,
-  };
+  return { findings: evaluated.findings, evaluations: evaluated.evaluations, ledger };
+}
+
+/** The findings the lowest minimum would report that the run does not, counted by confidence. */
+function withheldOf(
+  reported: readonly CompletedFinding[],
+  shown: readonly CompletedFinding[],
+): Withheld {
+  const kept = new Set(reported.map(findingKey));
+  const counts = { certain: 0, probable: 0, possible: 0 };
+  for (const finding of shown) {
+    if (!kept.has(findingKey(finding))) {
+      counts[finding.confidence] += 1;
+    }
+  }
+  return counts;
+}
+
+/** A finding's identity across two decisions of one run: its position, code and subject. */
+function findingKey(finding: CompletedFinding): string {
+  const { path, line, column } = finding.position;
+  return JSON.stringify([path, line, column, finding.code, finding.symbol.ref]);
 }
 
 /** Every finding the run reports, each family's in table order. */

package/src/findings/interfaces.ts

@@ -1,7 +1,7 @@
 import type { Finding, FindingPosition, PositionedSymbol } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import { byPosition } from "../position.ts";
-import type { Candidate } from "../sweep.ts";
+import type { MatrixCandidate } from "../matrix.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 const UNUSED_INTERFACE = "DS1201";
@@ -31,7 +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 candidateOf: (id: string) => Candidate | undefined;
+  readonly candidateOf: (id: string) => MatrixCandidate | undefined;
   readonly implementationsOf: (id: string) => readonly PositionedSymbol[];
 } {
   const union = input.swept.matrix.union;
@@ -79,15 +79,16 @@ function findingOf(
  * The findings of the interfaces family, `DS1200` to `DS1299`: `DS1201`, a dead
  * 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.
+ * 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, save an interface
+ * the run that counts test references does not reach, which is `DS1201`'s.
  */
 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) && !candidate.unreferencedTest)) {
       continue;
     }
     if (symbol.kind === "interface") {
@@ -122,7 +123,7 @@ export const interfaces: Emitter = (input) => {
 };
 
 /** What one unused interface's finding says, by the references the sweep counted. */
-function unusedMessage(candidate: Candidate): string {
+function unusedMessage(candidate: MatrixCandidate): string {
   if (candidate.relation === "reachability") {
     return UNUSED_DEAD_MESSAGE;
   }

package/src/findings/intra-function.ts

@@ -19,6 +19,24 @@ function overlapClause(overlap: readonly string[]): string {
     : `also reported by ${spelled(overlap)}`;
 }
 
+/**
+ * Whether one parameter's name is reported: every unread one of a function whose
+ * signature is free, and of a function used as a value only one no read parameter follows,
+ * because a caller may pass such a function more arguments than it declares.
+ */
+function parameterReported(
+  part: PartFact,
+  free: ReadonlySet<string>,
+  freeButValued: ReadonlySet<string>,
+): boolean {
+  const place = part.parameter;
+  if (place?.inValue !== true && free.has(part.declaration)) {
+    return true;
+  }
+  const valued = place?.inValue === true || freeButValued.has(part.declaration);
+  return valued && place?.beforeARead !== true;
+}
+
 /**
  * Whether one part is reported. A parameter needs its function's signature free to
  * change; a result needs that, every call in the loaded program to discard it, and every
@@ -34,10 +52,10 @@ function reported(
   if (part.used) {
     return false;
   }
-  const { free, discardedEverywhere } = input.intraFunction;
+  const { free, freeButValued, discardedEverywhere } = input.intraFunction;
   switch (part.code) {
     case UNUSED_PARAMETER:
-      return free.has(part.declaration);
+      return parameterReported(part, free, freeButValued);
     case UNUSED_RESULT:
       return (
         free.has(part.declaration) &&

package/src/findings/unused-declarations.ts

@@ -71,9 +71,16 @@ function codeOf(judged: Judged): string | undefined {
   if (candidate.testOfDeadCode) {
     return "DS1005";
   }
-  if (judged.test || judged.containerDead || NOT_THIS_FAMILY.has(symbol.kind)) {
+  if (
+    (judged.test && !candidate.unreferencedTest) ||
+    judged.containerDead ||
+    NOT_THIS_FAMILY.has(symbol.kind)
+  ) {
     return undefined;
   }
+  if (candidate.unreferencedTest) {
+    return unreferencedCode(symbol);
+  }
   const referenced = candidate.productionRefs + candidate.testRefs > 0;
   if (symbol.kind === "enum-member" && !referenced) {
     return undefined;
@@ -96,6 +103,14 @@ function codeOf(judged: Judged): string | undefined {
   return judged.unreachable ? undefined : "DS1001";
 }
 
+/** The code a declaration nothing references carries, by its shape and its visibility. */
+function unreferencedCode(symbol: InventorySymbol): string {
+  if (MEMBERS.has(symbol.kind)) {
+    return "DS1003";
+  }
+  return symbol.exported ? "DS1001" : "DS1002";
+}
+
 /** The visibility a member's message names, where it narrows the member's reach. */
 function visibilityWord(symbol: InventorySymbol): string {
   switch (symbol.visibility) {

package/src/findings-pass.ts

@@ -8,7 +8,7 @@ import type { AnalysisInputs } from "./analysis.ts";
 import { fails, type Config } from "./config.ts";
 import type { EdgeEvaluation } from "./edges.ts";
 import type { CompletedFinding, Finding } from "./finding.ts";
-import { decidedFindings } from "./findings/emitters.ts";
+import { decidedFindings, type Withheld } from "./findings/emitters.ts";
 import {
   fileRefsOf,
   staleSuppressions,
@@ -26,6 +26,8 @@ export interface PassTotals {
   readonly staleSuppressions: number;
   /** The evaluations that hold a finding pending. */
   readonly pending: number;
+  /** The findings the minimum confidence withheld, by confidence. */
+  readonly withheld: Withheld;
 }
 
 /** What the pass answers about one run. */
@@ -98,6 +100,7 @@ export function findingsPass(inputs: AnalysisInputs): PassResult {
       reasonsRecorded: counts.reasonsRecorded,
       staleSuppressions: records.length,
       pending: decided.evaluations.filter((one) => one.finding !== undefined).length,
+      withheld: decided.withheld,
     },
     ledger,
   };

package/src/graph.ts

@@ -39,11 +39,11 @@ const SWEPT: Readonly<Record<SymbolKind, boolean>> = {
 
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads the configuration it loads and the files its strings name, a runtime runs a
- * test file, a setup file, a worker, a page's module script, a command and a script, the
- * manifest names what enters the package, an alias global stands for the export it names,
- * and an entry file, a configured root and a pattern assert a caller. A library's
- * published API only supposes an unseen consumer, so it is live under reachability alone.
+ * tool reads what it loads and what its strings name, a runtime runs a test, setup or
+ * worker file, a page's module script, a command, a script or a workflow step, the manifest
+ * names what enters the package, an alias global stands for its export, and an entry file,
+ * a configured root and a pattern assert a caller. A library's published API only supposes
+ * an unseen consumer, so it is live under reachability alone.
  */
 const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
   "entry-file": true,
@@ -59,10 +59,10 @@ const NAMES_A_CALLER: Readonly<Record<RootKind, boolean>> = {
   "configuration-file": true,
   "configuration-string": true,
   "test-runner": true,
-  "mutation-testing": true,
   "browser-tests": true,
   worker: true,
   "html-entry": true,
+  "workflow-step": true,
 };
 
 /** Whether the sweep judges a declaration of one kind. */

package/src/implementations.ts

@@ -118,7 +118,7 @@ function typesAt<Brand>(project: ProjectView<Brand>, nodes: readonly Node[]): Ma
 }
 
 /** Whether one class member is a method whose every written body holds no statement. */
-function emptyImplementation<Brand>(project: ProjectView<Brand>, member: TSSymbol): boolean {
+export function emptyImplementation<Brand>(project: ProjectView<Brand>, member: TSSymbol): boolean {
   const own = project.ownPaths();
   let bodies = 0;
   for (const handle of member.declarations) {