@cplieger/deadset-ts 5.2.3 → 6.0.1

package/README.md

@@ -4,7 +4,7 @@
 
 deadset-ts finds dead code in TypeScript projects, down to class members, type members and dead stores inside functions, and writes a report your CI can fail on.
 
-It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261006.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
+It reads your `tsconfig.json` projects, `allowJs` JavaScript and Vue, Svelte and Astro scripts included, with the type information of TypeScript 7.1.0-dev.20261007.1, its one dependency. Your project keeps its own TypeScript version. A type error under that version skips the function or statement that holds it. deadset-ts reports and never edits your code. It is pre-release, tested only on Linux, needs Node.js 24 or later and is licensed under GPL-3.0-or-later.
 
 ## Why use it
 

package/dist/src/analysis.js

@@ -27,7 +27,7 @@ import { NO_SELF_CHECK, unmatchedRootFindings, } from "./findings/self-check.js"
 import { frameworkLifecycle } from "./framework-lifecycle.js";
 import { implementations, mergeImplementations } from "./implementations.js";
 import { injectionContainer } from "./injection-container.js";
-import { interfaceSatisfaction } from "./interface-satisfaction.js";
+import { interfaceSatisfaction, settledSatisfaction } from "./interface-satisfaction.js";
 import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { packageEntries, readManifest } from "./manifest.js";
@@ -278,6 +278,7 @@ function readProjects(engine, host, scope, config, stage) {
         componentsUnread: workspace?.componentsUnread ?? [],
         conventionsApplied: conventions.applied,
         conventionUses: conventions.uses,
+        memberDirs: workspace?.memberDirs ?? [],
         outsideTests,
     };
 }
@@ -406,15 +407,17 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     // Test-support code is code only test code imports in any configuration of the run: a
     // configuration that holds no test file says nothing about what the tests import.
     const support = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles));
-    const answers = withOutside.map((one) => {
+    const settled = settledSatisfaction(withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
+    const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
-        const detected = heldRecords(one.evidence, {
+        const satisfied = settled[index];
+        const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
             disabled,
             mode,
             testFiles: new Set([...one.testFiles, ...support]),
         });
         const exempt = detected.records;
-        const made = supportReferences(one.references, support);
+        const made = supportReferences([...one.references, ...(satisfied?.references ?? [])], support);
         const held = new Set(projectRead.held.symbols.map((symbol) => symbol.position.path));
         const supportFiles = [...support].filter((path) => held.has(path)).sort();
         const configured = {
@@ -473,6 +476,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         componentsUnread: read.componentsUnread,
         conventionsApplied: read.conventionsApplied,
         conventionUses: read.conventionUses,
+        memberDirs: read.memberDirs,
     };
 }
 /**
@@ -633,6 +637,25 @@ function readEmitterRun(engine, host, scope, config, mode, detectors) {
         ? run
         : { ...run, unansweredHeld: [...new Set([...run.unansweredHeld, ...unread])] };
 }
+/**
+ * The workspace members whose manifest the run reads whole enough to judge its
+ * dependencies: a built project holds a file below the member's directory, and no derived
+ * configuration at or below it was dropped. A file no built project holds may import any
+ * dependency the member declares.
+ */
+function membersWhollyRead(host, targetRoot, read) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const held = new Set(read.matrix.union.symbols.map((symbol) => symbol.position.path));
+    const dropped = read.notBuilt.map((one) => relativePath(root, one.configFile) ?? "");
+    return read.memberDirs.filter((dir) => {
+        const below = relativePath(root, dir);
+        if (below === undefined) {
+            return false;
+        }
+        const inside = (path) => path.startsWith(`${below}/`);
+        return [...held].some(inside) && !dropped.some(inside);
+    });
+}
 /**
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
  * each kind family reads, every per-project one read in the same session as the sweep.
@@ -649,7 +672,7 @@ function emitterInputOver(host, scope, config, read, input, selfCheck) {
             references: one.configured.references,
             accessors: one.extra.accessors,
         })), swept.exempt, input.mode),
-        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id)),
+        dependencies: dependenciesOf(host, targetRoot, [...projects.map((one) => one.extra.needs), configurationNeeds(read.conventionUses)], swept.sweep.candidates.map((candidate) => candidate.id), membersWhollyRead(host, targetRoot, read)),
         implementations: mergeImplementations(projects.map((one) => one.extra.implementations)),
         files: {
             tree: sourceTree(host, targetRoot),

package/dist/src/augmentations.js

@@ -0,0 +1,50 @@
+/**
+ * The references a use of an augmentation's declaration makes to what holds it. No name
+ * spells a `declare global` block, so a use of a declaration it holds is a use of the
+ * block. An interface or namespace an augmentation block holds merges with the one of its
+ * name, which the language or a library may type a value by where the target never names
+ * it, as it types `import.meta` or `process.env`, so a use of its member is a use of it.
+ */
+/** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
+function isGlobalBlock(symbol, held, files) {
+    return (symbol.kind === "namespace" &&
+        files.has(symbol.parent) &&
+        symbol.ref.endsWith("#global") &&
+        !held.modules.has(symbol.id));
+}
+/**
+ * For each reference to a declaration an augmentation block holds, a read at the same place
+ * of every interface and namespace between it and the block, and of a `declare global` block
+ * itself.
+ */
+export function augmentationReferences(held, found) {
+    const files = new Set(held.symbols.filter((one) => one.kind === "file").map((one) => one.id));
+    const globals = new Set(held.symbols.filter((one) => isGlobalBlock(one, held, files)).map((one) => one.id));
+    if (globals.size === 0 && held.modules.size === 0) {
+        return [];
+    }
+    const byId = new Map(held.symbols.map((one) => [one.id, one]));
+    const holders = (id) => {
+        const ids = [];
+        for (let at = byId.get(byId.get(id)?.parent ?? ""); at !== undefined; at = byId.get(at.parent)) {
+            if (globals.has(at.id)) {
+                return [...ids, at.id];
+            }
+            if (held.modules.has(at.id)) {
+                return ids;
+            }
+            if (at.kind === "interface" || at.kind === "namespace") {
+                ids.push(at.id);
+            }
+        }
+        return [];
+    };
+    return found.flatMap((reference) => holders(reference.to).map((to) => ({
+        from: reference.from,
+        to,
+        position: reference.position,
+        use: "read",
+        resolution: reference.resolution,
+        test: reference.test,
+    })));
+}

package/dist/src/components.js

@@ -25,13 +25,13 @@ export function listing(component, cascade) {
 }
 /**
  * Groups the declarations `dead` marks into components, ordered by their first member's
- * site; `dead` and `testOfDeadCode` hold one flag per declaration of the graph. Root
- * members sit on the cycles no other cycle references. A cycle two roots both reach is
- * dead only through both, so a component is a weakly connected part of the dead
- * subgraph: no dead declaration of one references a declaration of another.
+ * site; `dead`, `testOfDeadCode` and `unreferencedTest` hold one flag per declaration of
+ * the graph. Root members sit on the cycles no other cycle references. A cycle two roots
+ * both reach is dead only through both, so a component is a weakly connected part of the
+ * dead subgraph: no dead declaration of one references a declaration of another.
  */
-export function componentsOf(graph, dead, testOfDeadCode) {
-    const { at, adjacent } = deadSubgraph(graph, dead, testOfDeadCode);
+export function componentsOf(graph, dead, testOfDeadCode, unreferencedTest = []) {
+    const { at, adjacent } = deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest);
     if (at.length === 0) {
         return [];
     }
@@ -90,17 +90,17 @@ function linesSpanned(symbols) {
 }
 /**
  * The dead declarations by their place in the subgraph, a test file's declaration only
- * where it is a test of dead code, and the edges between them: each
- * reference one makes to another, an edge each way between a dead member and its dead
- * container (one direction alone leaves the member a component the container reaches),
- * and an edge back from each production target of an admitted test, which puts the test in
- * the component of the code it exercises because a subject never references its test.
+ * where it is a test of dead code or nothing the tests reach, and the edges between them:
+ * each reference one makes to another, except an unreferenced test-file declaration's
+ * reference to production code, which decides nothing of its target, an edge each way
+ * between a dead member and its dead container, and an edge back from each production
+ * target of an admitted test, which puts the test in its subject's component.
  */
-function deadSubgraph(graph, dead, testOfDeadCode) {
+function deadSubgraph(graph, dead, testOfDeadCode, unreferencedTest) {
     const at = [];
     const position = graph.symbols.map((_symbol, index) => {
-        // A test file's declaration belongs to a component only as a test of dead code.
-        if (dead[index] !== true || (graph.test[index] === true && testOfDeadCode[index] !== true)) {
+        const judged = testOfDeadCode[index] === true || unreferencedTest[index] === true;
+        if (dead[index] !== true || (graph.test[index] === true && !judged)) {
             return UNVISITED;
         }
         at.push(index);
@@ -110,7 +110,7 @@ function deadSubgraph(graph, dead, testOfDeadCode) {
     at.forEach((index, from) => {
         for (const edge of graph.out[index] ?? []) {
             const to = position[edge.to] ?? UNVISITED;
-            if (to === UNVISITED) {
+            if (to === UNVISITED || (unreferencedTest[index] === true && graph.test[edge.to] !== true)) {
                 continue;
             }
             adjacent[from]?.push(to);

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "3.0.0",
+        corpusVersion: "4.0.0",
         result: "pass",
-        digest: "sha256:db52e3164347cab70f45f438b4ac9ce89573be9303503daeb237a3c40361b001",
+        digest: "sha256:8250b61deb71467139bf4cbcaf10802cdabb1a2c2261a11a571fc1ff55bfc3dc",
     },
     gaps: [],
 };

package/dist/src/convention-rows.js

@@ -32,6 +32,8 @@ const APP_DIRECTORY_ENTRIES = [
 const SOLIDSTART_PLUGIN = { module: "@solidjs/start/config", export: "solidStart" };
 const NUXT_CONFIG = [`nuxt.config.${ANY_MODULE}`];
 const STRYKER_CONFIG = "{stryker,.stryker}.{conf,config}.{json,js,mjs,cjs}";
+const STRYKER_MODULE = "{stryker,.stryker}.{conf,config}.{js,mjs,cjs}";
+const VITEST_CONFIG = `{vitest,vite}.config.${ANY_MODULE}`;
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS = [
     {
@@ -146,6 +148,14 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "prettier",
+        package: "prettier",
+        range: ">=3.0.0 <4.0.0",
+        entries: [`{prettier.config,.prettierrc}.${ANY_MODULE}`],
+        moves: [],
+        manifestKeys: ["prettier"],
+    },
     {
         name: "qwik-city",
         package: "@builder.io/qwik-city",
@@ -263,8 +273,9 @@ export const CONVENTION_ROWS = [
         name: "stryker",
         package: "@stryker-mutator/core",
         range: ">=7.0.0 <11.0.0",
-        entries: [],
+        entries: [STRYKER_MODULE],
         moves: [],
+        selections: [{ property: "mutate", files: [STRYKER_CONFIG] }],
         shortNames: [
             {
                 property: "testRunner",
@@ -408,9 +419,13 @@ export const CONVENTION_ROWS = [
         shortNames: [
             {
                 property: "test.coverage.provider",
-                files: [`{vitest,vite}.config.${ANY_MODULE}`],
+                files: [VITEST_CONFIG],
                 package: "@vitest/coverage-{}",
             },
         ],
+        selections: [
+            { property: "test.coverage.include", files: [VITEST_CONFIG] },
+            { property: "test.coverage.exclude", files: [VITEST_CONFIG] },
+        ],
     },
 ];

package/dist/src/conventions.js

@@ -8,6 +8,7 @@
 import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNonNullExpression, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { lineOf } from "./component-files.js";
 import { CONVENTION_ROWS, } from "./convention-rows.js";
+import { documentStrings } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
 import { satisfies } from "./version-range.js";
@@ -349,6 +350,74 @@ function readPath(object, keys, values, elements) {
     }
     return undefined;
 }
+/**
+ * Every string literal one file writes at one property's path inside the objects it is
+ * read from, as {@link readProperty} reads them: the value itself, or each element of an
+ * array value, whatever else the path holds.
+ */
+function stringsAt(file, property, call) {
+    const declared = declaredValues(file);
+    const objects = call === undefined
+        ? defaultExports(file).map((one) => objectOf(one, declared, true))
+        : optionsArguments(file, call).map((one) => one === undefined ? undefined : objectOf(one, declared, false));
+    const found = [];
+    const visit = (object, keys) => {
+        if (!isObjectLiteralExpression(object)) {
+            return;
+        }
+        const [key, ...rest] = keys;
+        for (const member of object.properties) {
+            if (!isPropertyAssignment(member) || keyOf(member) !== key) {
+                continue;
+            }
+            const held = unwrapped(member.initializer);
+            if (rest.length > 0) {
+                visit(held, rest);
+            }
+            else if (literalText(held) !== undefined) {
+                found.push(held);
+            }
+            else if (isArrayLiteralExpression(held)) {
+                found.push(...held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined));
+            }
+        }
+    };
+    for (const object of objects) {
+        if (object !== undefined) {
+            visit(object, property.split("."));
+        }
+    }
+    return found;
+}
+/** The strings an applied row's selection keys hold, added per configuration file to `into`. */
+function selectedStrings(host, parse, dir, readings, into) {
+    for (const reading of readings) {
+        for (const { name, file } of readingFiles(host, parse, dir, reading.files)) {
+            const path = joinPath(dir, name);
+            const held = into.get(path) ?? { starts: new Set(), texts: [] };
+            for (const node of stringsAt(file, reading.property, reading.call)) {
+                held.starts.add(node.getStart());
+                held.texts.push(literalText(node) ?? "");
+            }
+            into.set(path, held);
+        }
+    }
+}
+/**
+ * The dependencies one manifest declares that a string at any depth of one of its members
+ * names, alone or followed by `/` and a subpath, a member's name aside.
+ */
+function manifestKeyUses(manifest, keys) {
+    if (!isRecord(manifest)) {
+        return [];
+    }
+    const declared = DEPENDENCY_SECTIONS.flatMap((section) => {
+        const held = manifest[section];
+        return isRecord(held) ? Object.keys(held) : [];
+    });
+    const strings = keys.flatMap((key) => documentStrings(manifest[key]));
+    return declared.filter((name) => strings.some((text) => text === name || text.startsWith(`${name}/`)));
+}
 /**
  * Every value one file writes at one property's path inside the object it is read from:
  * the options argument of every call `call` names, or the file's default export. A string
@@ -511,6 +580,7 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     const generated = [];
     const failures = [];
     const uses = new Set();
+    const selected = new Map();
     for (const manifest of manifests) {
         const declared = readJSON(host, joinPath(manifest.dir, "package.json"));
         const versions = new Map();
@@ -571,6 +641,10 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
                 uses.add(name);
             }
+            for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
+                uses.add(name);
+            }
+            selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
             const excludes = [
                 ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
             ].map(globExpression);
@@ -591,7 +665,14 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
     unique.sort((a, b) => compare(a.name, b.name) ||
         compare(a.manifest, b.manifest) ||
         compare(JSON.stringify(a), JSON.stringify(b)));
-    return { applied: unique, globs, generated, failures, uses: [...uses].sort(compare) };
+    return {
+        applied: unique,
+        globs,
+        generated,
+        failures,
+        uses: [...uses].sort(compare),
+        selected,
+    };
 }
 /**
  * Every own file of one project below a directory an applied row names as generated, by

package/dist/src/dependencies.js

@@ -1,15 +1,15 @@
 /**
- * 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 { isExportDeclaration, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isNamespaceExport, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, } from "./configuration-files.js";
 import { nodeKey, packageScope } from "./inventory.js";
-import { dirnamePath, isAbsolutePath, joinPath, resolvePath } from "./paths.js";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
 const MANIFEST = "package.json";
@@ -476,8 +476,8 @@ function installedOf(host, root, name) {
         }
     }
 }
-/** Every dependency the manifest text declares, in the order the text writes them. */
-function declaredIn(text, manifest) {
+/** Every dependency the manifest text at `path` declares, in the order the text writes them. */
+function declaredIn(text, manifest, path, scope) {
     const sections = membersAt(text, skipWhitespace(text, 0));
     const declared = [];
     for (const [member, section] of SECTIONS) {
@@ -489,7 +489,12 @@ function declaredIn(text, manifest) {
         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,
             });
         }
@@ -497,25 +502,36 @@ function declaredIn(text, manifest) {
     return declared.sort((a, b) => a.at - b.at).map(({ dependency }) => dependency);
 }
 /**
- * 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(host, targetRoot, perProject, candidates) {
-    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) : [];
+export function dependenciesOf(host, targetRoot, perProject, candidates, members = []) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
+    const scopeOf = packageScope(host, targetRoot);
+    const manifests = new Map([[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 = [];
     const installed = new Map();
-    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);
+                }
             }
         }
     }
@@ -547,5 +563,5 @@ export function dependenciesOf(host, targetRoot, perProject, candidates) {
             lastUses.set(id, sole.sort((a, b) => (a < b ? -1 : 1)));
         }
     }
-    return { manifest: scope, declared, installed, needed, lastUses };
+    return { declared, installed, needed, lastUses };
 }

package/dist/src/entry-points.js

@@ -17,10 +17,9 @@ import { globExpression } from "./glob.js";
 import { htmlEntries } from "./html-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
+import { workflowEntries } from "./workflow-steps.js";
 /** The extensions the test runner and the browser-test runner load a configuration from. */
 const MODULE_EXTENSIONS = ["js", "mjs", "cjs", "ts", "mts", "cts"];
-/** The extensions the mutation tester's configuration is loaded from. */
-const SCRIPT_EXTENSIONS = ["js", "mjs", "cjs"];
 /** The tool file names the configuration form does not cover. */
 const CONVENTIONS = [
     {
@@ -29,12 +28,6 @@ const CONVENTIONS = [
         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. */
 const BROWSER_TEST_CONFIG = "playwright.config";
@@ -168,11 +161,29 @@ function isBrowserTestConfig(name) {
 /**
  * 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, targetRoot, files, parse) {
+function configurationEntries(host, targetRoot, files, parse, selected) {
     const { modules, documents, outside } = configurationFiles(host, targetRoot, files, parse);
     const found = [];
+    const unselected = (file) => {
+        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, texts) => {
+        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, texts) => {
         for (const text of texts) {
             for (const file of filesNamedBy(files, dir, text)) {
@@ -182,10 +193,10 @@ function configurationEntries(host, targetRoot, files, parse) {
     };
     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(dirnamePath(file.fileName), moduleStrings(file).map((one) => one.text));
@@ -385,8 +396,8 @@ function workersOf(project, file, files) {
  * file's path below the target root; a file one of them matches is a test file the
  * runner executes.
  */
-export function entryPoints(project, files, testFiles, host, targetRoot, parse) {
-    const found = [...configurationEntries(host, targetRoot, files, parse)];
+export function entryPoints(project, files, testFiles, host, targetRoot, parse, selected = new Map()) {
+    const found = [...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);
@@ -410,5 +421,8 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse)
     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/dist/src/exempt.js

@@ -117,6 +117,7 @@ export function evidenceRecords(input, detectors, disabled) {
                 detail: evidence.detail,
                 site: evidence.site,
                 ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
+                ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
             });
         }
     }

package/dist/src/findings/completion.js

@@ -6,7 +6,8 @@
 import { componentId } from "../components.js";
 import { OUTSIDE } from "../graph.js";
 import { KINDS } from "../kinds.js";
-import { byPosition } from "../position.js";
+import { byPosition, positionKey } from "../position.js";
+import { declarationKey } from "../ref.js";
 import { FAMILY_KEY_LENGTH } from "../resolve.js";
 import { isPartSubject, isRowSubject } from "../suppress.js";
 /** The classes ranked by the claim each makes, the strongest highest. */
@@ -117,7 +118,7 @@ function findingComponents(swept, cascade) {
 export function completed(input, findings, kinds = KINDS) {
     const { swept } = input;
     const union = swept.matrix.union;
-    const positions = new Map(union.symbols.map((symbol, at) => [symbol.ref, at]));
+    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 classOf = reachabilityClasses(input);
     const componentOf = findingComponents(swept, input.config.reporters.cascade);
@@ -135,10 +136,14 @@ export function completed(input, findings, kinds = KINDS) {
             throw new Error(`${finding.code} names no live row of the issue-kind vocabulary`);
         }
         // A row's reference may spell a declaration's, as an ignore entry naming one does, and
-        // a row is still never the declaration.
+        // a row is still never the declaration. Two declarations of one file can share a
+        // reference, so the one the finding is positioned at is the subject where there is one.
+        const declared = union.at(positionKey(finding.position));
         const at = isRowSubject(finding.symbol.kind)
             ? OUTSIDE
-            : (positions.get(finding.symbol.ref) ?? OUTSIDE);
+            : union.symbols[declared]?.ref === finding.symbol.ref
+                ? declared
+                : (positions.get(declarationKey(finding.symbol.ref, finding.position.path)) ?? OUTSIDE);
         // A part names the declaration that holds it, and is decided inside it rather than by
         // the declaration's liveness, so it carries none of the declaration's sweep facts.
         const part = isPartSubject(finding.symbol.kind);

package/dist/src/findings/dependencies-and-module-machinery.js

@@ -30,7 +30,7 @@ function neededBy(dependencies) {
     return needed;
 }
 /**
- * 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) {
@@ -41,7 +41,7 @@ function unusedDependencies(dependencies) {
         code: UNUSED_DEPENDENCY,
         position: dependency.position,
         symbol: {
-            ref: renderRef(dependencies.manifest, {
+            ref: renderRef(dependency.manifest, {
                 of: "dependency",
                 name: dependency.name,
                 section: dependency.section,