@cplieger/deadset-ts 4.0.0 → 5.0.0

package/dist/src/entry-point-gaps.js

@@ -7,15 +7,18 @@
  * Every row carries a reason, because the list is read where the rows are shown
  * one at a time: beside a finding, or in a report's declared gaps.
  */
-/** What is declined for a tool none of whose conventions is entered. */
-const EVERY_CONVENTION = "its configuration and every file it loads by its own convention";
-/** Why a tool none of whose conventions is entered declines them. */
-const UNREAD = "No rule reads it, so a file only it loads is reported as never imported unless " +
-    "ts.entry_files or roots.patterns names it.";
-/** The tools none of whose conventions is entered. */
+/** What is declined for a tool whose own conventions are entered only through its configuration files. */
+const EVERY_CONVENTION = "every file it loads by its own convention beyond its configuration files";
+/** Why a tool whose own conventions are not read declines them. */
+const UNREAD = "No rule reads it beyond a configuration file the file-name form or a string enters, so a " +
+    "file only it loads is reported as never imported unless ts.entry_files or roots.patterns " +
+    "names it.";
+/** Why a configuration's file names that are not relative literals are declined. */
+const NOT_RELATIVE = "A string of a configuration file names a file only where it is a literal starting with ./ " +
+    "or ../, so a file named otherwise is reported as never imported.";
+/** The tools whose own conventions are not read. */
 const UNREAD_TOOLS = [
     "angular",
-    "astro",
     "astro-db",
     "astro-markdoc",
     "astro-og-canvas",
@@ -48,7 +51,6 @@ const UNREAD_TOOLS = [
     "esbuild",
     "eve",
     "execa",
-    "expo",
     "expressive-code",
     "fast",
     "fumadocs",
@@ -85,7 +87,6 @@ const UNREAD_TOOLS = [
     "nano-staged",
     "nest",
     "netlify",
-    "next",
     "next-intl",
     "next-mdx",
     "nitro",
@@ -93,7 +94,6 @@ const UNREAD_TOOLS = [
     "node-modules-inspector",
     "nodemon",
     "npm-package-json-lint",
-    "nuxt",
     "nuxtjs-i18n",
     "nx",
     "nyc",
@@ -118,17 +118,14 @@ const UNREAD_TOOLS = [
     "prettier",
     "prisma",
     "quasar",
-    "qwik",
     "railway",
     "raycast",
     "react-cosmos",
     "react-email",
     "react-native",
-    "react-router",
     "relay",
     "release-it",
     "remark",
-    "remix",
     "rolldown",
     "rollup",
     "rsbuild",
@@ -144,11 +141,9 @@ const UNREAD_TOOLS = [
     "sst",
     "starlight",
     "stencil",
-    "storybook",
     "stylelint",
     "svelte",
     "sveltejs-package",
-    "sveltekit",
     "svgo",
     "svgr",
     "swc",
@@ -171,7 +166,6 @@ const UNREAD_TOOLS = [
     "typescript-content-mapper",
     "unbuild",
     "unocss",
-    "unplugin-auto-import",
     "unplugin-icons",
     "unplugin-vue-components",
     "unplugin-vue-i18n",
@@ -201,9 +195,15 @@ const UNREAD_TOOLS = [
 const PARTLY_ENTERED = [
     {
         tool: "eslint",
-        convention: "the legacy .eslintrc configuration files",
-        reason: "Only the flat configuration's file names are entered, so a legacy configuration " +
-            "file the program holds is reported as never imported.",
+        convention: "a legacy configuration written in YAML or in JSON with comments",
+        reason: "Only a configuration module and a strict JSON configuration file are read, so a " +
+            "dependency only such a file names is reported as unused.",
+    },
+    {
+        tool: "eslint",
+        convention: "a plugin or shareable configuration named without its package's prefix",
+        reason: "A string uses a dependency only where it spells the dependency's name, so a " +
+            "dependency only a shortened name loads is reported as unused.",
     },
     {
         tool: "playwright",
@@ -213,8 +213,8 @@ const PARTLY_ENTERED = [
     },
     {
         tool: "playwright",
-        convention: "the globalSetup and globalTeardown files",
-        reason: "No rule enters them, so a setup file only the runner loads is reported as never imported.",
+        convention: "a globalSetup or globalTeardown file named without a leading ./ or ../",
+        reason: NOT_RELATIVE,
     },
     {
         tool: "playwright",
@@ -222,16 +222,64 @@ const PARTLY_ENTERED = [
         reason: "Only the configuration object's own testDir and testMatch are read, so a test " +
             "directory a project entry moves is not entered.",
     },
+    {
+        tool: "expo",
+        convention: "an app directory the expo-router entry of an app configuration moves",
+        reason: "The convention row reads the app directory at its default places only, so a route " +
+            "below a moved directory is reported as never imported unless ts.entry_files names it.",
+    },
+    {
+        tool: "next",
+        convention: "a page extension next.config adds through pageExtensions",
+        reason: "The convention row roots the default extensions only, so a route file of another " +
+            "extension is reported as never imported unless ts.entry_files names it.",
+    },
+    {
+        tool: "nuxt",
+        convention: "the files of a layer below layers/ beyond its nuxt.config",
+        reason: "The convention row reads the project's own directories, so a layer's pages, plugins " +
+            "and server routes are reported as never imported unless ts.entry_files names them.",
+    },
+    {
+        tool: "qwik",
+        convention: "the routes of @qwik.dev/router",
+        reason: "No convention row holds for that package, so its route files are reported as " +
+            "never imported unless ts.entry_files names them.",
+    },
+    {
+        tool: "react-router",
+        convention: "a route module app/routes.ts names outside the routes directory",
+        reason: "The convention row roots the routes directory, and a string of routes.ts names no " +
+            "file, so a route module elsewhere is reported as never imported unless " +
+            "ts.entry_files names it.",
+    },
+    {
+        tool: "storybook",
+        convention: "a story the stories member of .storybook/main names outside *.stories.* files",
+        reason: "The convention row roots *.stories.* files, so a story file named otherwise is " +
+            "reported as never imported unless ts.entry_files names it.",
+    },
     {
         tool: "stryker",
-        convention: "a configuration file named on the command line",
-        reason: "Only the file names the tool looks for by default are entered.",
+        convention: "a configuration file named on a command line no package.json script writes",
+        reason: "Only the file names the tool looks for by default and the files a script names are entered.",
+    },
+    {
+        tool: "unplugin-auto-import",
+        convention: "an import its generated declarations add for a component's template alone",
+        reason: "Only a global declared as an alias of an export is read, so an export the generated " +
+            "declarations name only for templates is reported as unused.",
     },
     {
         tool: "vite",
-        convention: "its configuration and every entry point it names",
-        reason: "Only a worker a call addresses by a literal is entered; no rule reads the " +
-            "configuration, so a file only it names is reported as never imported.",
+        convention: "an entry point its configuration names without a leading ./ or ../, or computes",
+        reason: NOT_RELATIVE,
+    },
+    {
+        tool: "vite",
+        convention: "the module scripts an index.html loads",
+        reason: "No rule reads an HTML file, so a script only index.html loads is reported as never " +
+            "imported unless ts.entry_files names it.",
     },
     {
         tool: "vitest",
@@ -241,15 +289,14 @@ const PARTLY_ENTERED = [
     },
     {
         tool: "vitest",
-        convention: "the mock files below a __mocks__ directory",
-        reason: "No rule enters a file by its directory, so a mock only the runner's module mocking " +
-            "loads is reported as never imported.",
+        convention: "the setup files of a configuration that moves its root",
+        reason: "A string is read against the configuration file's directory, so a setup file named " +
+            "against a root the configuration moves is not entered.",
     },
     {
         tool: "vitest",
-        convention: "the setup files of a configuration that moves its root",
-        reason: "A configuration writing root reads its setup files against a directory its text " +
-            "may not state, so none of them is entered.",
+        convention: "a setup file named without a leading ./ or ../",
+        reason: NOT_RELATIVE,
     },
     {
         tool: "vitest",
@@ -259,9 +306,8 @@ const PARTLY_ENTERED = [
     },
     {
         tool: "webpack",
-        convention: "its configuration and every entry point it names",
-        reason: "Only a worker a call addresses by a literal is entered; no rule reads the " +
-            "configuration, so a file only it names is reported as never imported.",
+        convention: "an entry point its configuration names without a leading ./ or ../, or computes",
+        reason: NOT_RELATIVE,
     },
 ];
 /** Two strings ordered bytewise. */

package/dist/src/entry-points.js

@@ -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
@@ -12,45 +12,31 @@
  */
 import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
 import { SymbolFlags } from "@typescript/native/unstable/sync";
+import { configurationFiles, filesNamedBy, moduleStrings } from "./configuration-files.js";
 import { globExpression } from "./glob.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.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 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"];
+/** The tool file names the configuration form does not cover. */
 const CONVENTIONS = [
     {
         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}";
 /** The members of a test-runner configuration's `test` object that name setup files. */
@@ -174,6 +160,34 @@ function filesNamed(files, dir, text) {
     }
     return files.named(resolvePath(dir, pathPart(text)));
 }
+/** Whether one file name is the browser-test runner's configuration. */
+function isBrowserTestConfig(name) {
+    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, targetRoot, files) {
+    const { modules, documents } = configurationFiles(host, targetRoot, files);
+    const found = [];
+    const strings = (dir, texts) => {
+        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);
+    }
+    return found;
+}
 /**
  * The setup files one test-runner configuration names: every literal under
  * `test.setupFiles` and `test.globalSetup`, read against the configuration's own
@@ -360,26 +374,27 @@ function workersOf(project, file, files) {
     return found;
 }
 /**
- * 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
  * runner executes.
  */
-export function entryPoints(project, files, testFiles) {
-    const found = [];
+export function entryPoints(project, files, testFiles, host, targetRoot) {
+    const found = [...configurationEntries(host, targetRoot, files)];
     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/dist/src/exempt.js

@@ -108,6 +108,7 @@ export function computeExemptions(input, detectors, holding) {
                 class: exemptionClass,
                 detail: evidence.detail,
                 site: evidence.site,
+                ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
             });
         }
     }
@@ -122,14 +123,14 @@ function compare(a, b) {
 }
 /**
  * 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) {
     const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || compare(a.class, b.class) || compare(a.id, b.id));
     const seen = new Set();
     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;
         }
@@ -137,6 +138,13 @@ export function exemptionsOf(found) {
         return true;
     });
 }
+/**
+ * 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, live) {
+    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) {
     const grouped = new Map();

package/dist/src/findings/completion.js

@@ -15,50 +15,40 @@ const RANK = { certain: 3, probable: 2, possible: 1 };
 function capped(found, ceiling) {
     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) {
     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) {
-    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, code, fallback) {
     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 declarations the roots name as a library's published API, each public member of a
+ * published type included.
+ */
+function publishedIds(union) {
+    return new Set(union.rooted
+        .filter((root) => root.kind === "published-api")
+        .flatMap((root) => union.symbols[root.at]?.id ?? []));
 }
 /**
  * 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`.
+ * 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) {
-    const union = input.swept.matrix.union;
-    const published = new Set(union.rooted
-        .filter((root) => root.kind === "published-api")
-        .map((root) => union.symbols[root.at]?.id));
+    const published = publishedIds(input.swept.matrix.union);
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
         ? "possible"

package/dist/src/findings/emitters.js

@@ -1,5 +1,7 @@
 import { evaluateEdges } from "../edges.js";
+import { liveFilesAt } from "../matrix.js";
 import { ledgerOf } from "../suppress.js";
+import { insideSkipped } from "../type-errors.js";
 import { completed, dialsOf, reportable } from "./completion.js";
 import { dependenciesAndModuleMachinery } from "./dependencies-and-module-machinery.js";
 import { interfaces } from "./interfaces.js";
@@ -33,6 +35,21 @@ function heldRefs(input) {
         .filter((symbol) => held.has(symbol.id))
         .map((symbol) => symbol.ref));
 }
+/**
+ * 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) {
+    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));
+}
 /** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
 function completedOver(input, ...more) {
     return completed(input, [...EMITTERS.values(), ...more].flatMap((emit) => emit(input)));
@@ -64,7 +81,11 @@ export function decidedFindings(input, suppressed = { unmarked: input, records:
     const would = [...unmarked, ...found];
     const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
     const unanswered = heldRefs(input);
-    const kept = reportable(input, found.filter((finding) => !ledger.withheld(finding) && !unanswered.has(finding.symbol.ref)));
+    const markup = markupRefs(input);
+    const kept = reportable(input, 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 {
         findings: evaluated.findings,

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

@@ -40,8 +40,9 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
 /**
  * The code one candidate is reported under, or none, each symbol once under the most
  * specific code: a test of dead code first; no other test-file declaration, member of a
- * dead container or enum member nothing names; then deprecation, a test reference, and
- * the unreferenced codes, an unimportable unused export being the unreachable kind's.
+ * dead container or enum member nothing names, nor a test-support declaration test code
+ * references; then deprecation, a test reference, and the unreferenced codes, an
+ * unimportable unused export being the unreachable kind's.
  */
 function codeOf(judged) {
     const { candidate, symbol } = judged;
@@ -55,6 +56,9 @@ function codeOf(judged) {
     if (symbol.kind === "enum-member" && !referenced) {
         return undefined;
     }
+    if (judged.support && candidate.testRefs > 0) {
+        return undefined;
+    }
     if (candidate.productionRefs === 0 && judged.deprecated) {
         return "DS1006";
     }
@@ -138,6 +142,7 @@ function familyFindings(input, fallen) {
             candidate,
             symbol,
             test: union.test[at] === true,
+            support: union.support[at] === true,
             containerDead: containerDead && !fallen,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),

package/dist/src/graph.js

@@ -32,20 +32,26 @@ const SWEPT = {
 };
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads the configuration it loads, a runtime runs a test file, a setup file, a
- * worker and a command, the manifest names what enters the package, and an entry file, a
- * configured root and a pattern assert a caller. A library's published API only supposes
+ * tool reads the configuration it loads and the files its strings name, a runtime runs a
+ * test file, a setup file, a worker, 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
  * a consumer the run may not see, so it is live under reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
+    convention: true,
     "manifest-entry": true,
     "manifest-binary": true,
+    script: true,
     "published-api": false,
     configured: true,
     pattern: true,
+    "type-error": true,
+    "type-query-alias": true,
+    "configuration-file": true,
+    "configuration-string": true,
     "test-runner": true,
-    "lint-configuration": true,
     "mutation-testing": true,
     "browser-tests": true,
     worker: true,
@@ -65,7 +71,8 @@ export function namesACaller(kind) {
  * from such a declaration still counts toward its target, because reference counting
  * asks whether any declaration names the target. A root naming nothing is dropped.
  */
-export function graphOf(symbols, references, roots, testFiles) {
+export function graphOf(symbols, references, roots, testFiles, supportFiles = []) {
+    const supports = new Set(supportFiles);
     const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
     const at = (id) => index.get(id) ?? OUTSIDE;
     const tests = new Set(testFiles);
@@ -114,6 +121,7 @@ export function graphOf(symbols, references, roots, testFiles) {
         made,
         parent,
         test: symbols.map((symbol) => tests.has(symbol.position.path)),
+        support: symbols.map((symbol) => supports.has(symbol.position.path)),
         subject: symbols.map((symbol) => swept(symbol.kind)),
         exportsOf,
         rooted,

package/dist/src/inventory.js

@@ -1,6 +1,6 @@
 import { isClassDeclaration, isComputedPropertyName, isEnumDeclaration, isEnumMember, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isGetAccessorDeclaration, isIdentifier, isInterfaceDeclaration, isIntersectionTypeNode, isMethodDeclaration, isMethodSignatureDeclaration, isModuleBlock, isModuleDeclaration, isNamespaceExport, isParenthesizedTypeNode, isPrivateIdentifier, isPropertyDeclaration, isPropertySignatureDeclaration, isSetAccessorDeclaration, isTypeAliasDeclaration, isTypeLiteralNode, isUnionTypeNode, isVariableStatement, ModifierFlags, } from "@typescript/native/unstable/ast";
 import { dirnamePath, joinPath, relativePath } from "./paths.js";
-import { byPosition, positionKey, renderPosition } from "./position.js";
+import { byPosition, positionKey, renderPosition, writtenLength, } from "./position.js";
 import { computedComponent, nameComponent, renderRef } from "./ref.js";
 import { isAnswered, UNANSWERED } from "./query.js";
 const MANIFEST = "package.json";
@@ -273,7 +273,9 @@ export function inventory(project, host, targetRoot) {
             typeParameter: undefined,
         });
         exportScopes.push({ owner: fileRecord, nameNode: file });
-        walkStatements(file.statements, fileRecord);
+        // A statement a component file's module appends is not written in the file.
+        const written = writtenLength(file);
+        walkStatements(file.statements.filter((statement) => statement.end <= written), fileRecord);
     }
     /** One declaration of a module, a namespace or a container body. */
     function walkStatements(statements, owner) {

package/dist/src/kinds.js

@@ -39,7 +39,7 @@ const ROWS = [
         code: "DS1004",
         name: "test-only-use",
         languages: ["go", "ts"],
-        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production.",
+        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only test code imports, is a test reference, and a declaration of test-support code is never reported under this code.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -278,7 +278,7 @@ const ROWS = [
         name: "unused-parameter",
         languages: ["go", "ts"],
         rule: "A parameter with no reference inside its function body, on a function whose signature is free to change.",
-        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not used as a value, is not a go:linkname or cgo target, and is not a stub whose body is empty or only panics. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change.",
+        precondition: "The signature must be free, defined as follows: the function is not a method retained by interface satisfaction, is not used as a value, is not a go:linkname or cgo target, is not a function the Go test driver runs (a test, benchmark or fuzz test of a test file, or TestMain), and is not a stub whose body is empty or only panics. A parameter its body never names is dead whatever the callers, so a published declaration of a library is reported too, with the fixability the vocabulary gives the kind: the signature change is a breaking change.",
         defaultSeverity: "warn",
         maxClass: "certain",
         fixability: "manual",