@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.4

package/dist/src/dependencies.js

@@ -14,7 +14,7 @@ import { scriptTokens } from "./manifest.js";
 import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
-import { workflowTokens } from "./workflow-steps.js";
+import { workflowCommands, workflowTokens } from "./workflow-steps.js";
 const MANIFEST = "package.json";
 const MODULES_DIR = "node_modules";
 const MODULES_SEGMENT = `/${MODULES_DIR}/`;
@@ -664,6 +664,98 @@ function scriptTokensOf(manifest) {
     }
     return found;
 }
+/**
+ * The runtime flags whose value is a module loaded before the entry, as `--flag value` or
+ * `--flag=value`: https://nodejs.org/api/cli.html#--importmodule,
+ * https://nodejs.org/api/cli.html#--experimental-loadermodule,
+ * https://nodejs.org/api/cli.html#-r---require-module
+ */
+const PRELOAD_FLAGS = new Set([
+    "--experimental-loader",
+    "--import",
+    "--loader",
+    "--require",
+    "-r",
+]);
+/**
+ * The programs that pass a preload flag to the runtime they start: Node itself, and the
+ * runners that forward Node's flags or read the same `--require`:
+ * https://mochajs.org/#-require-module-r-module, https://tsx.is/node-enhancement,
+ * https://typestrong.org/ts-node/docs/options#require,
+ * https://github.com/remy/nodemon#running-non-node-scripts
+ */
+const PRELOADING_PROGRAMS = new Set([
+    "mocha",
+    "node",
+    "nodemon",
+    "ts-node",
+    "tsx",
+]);
+/** The programs that run the command after them, and an environment assignment before it. */
+const LAUNCHERS = new Set(["cross-env", "env", "npx"]);
+const ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/u;
+/** The commands one script string runs, split at the shell's list and pipeline operators. */
+const COMMAND_SEPARATORS = /&&|\|\||;|\||&/u;
+/**
+ * The command strings one manifest runs: each of its `scripts`, and the `exec` command of
+ * nodemon's configuration, in the manifest's `nodemonConfig` or the `nodemon.json` beside
+ * it, which nodemon runs the watched script with:
+ * https://github.com/remy/nodemon#config-files
+ */
+function manifestCommands(host, dir, manifest) {
+    const scripts = manifest["scripts"];
+    const nodemon = [manifest["nodemonConfig"], readJSON(host, joinPath(dir, "nodemon.json"))?.value];
+    return [
+        ...(isRecord(scripts) ? Object.values(scripts) : []),
+        ...nodemon.map((config) => (isRecord(config) ? config["exec"] : undefined)),
+    ].filter((command) => typeof command === "string");
+}
+/**
+ * The packages `scripts` preload by a runtime flag's bare module specifier, a flag
+ * counting only in a command whose program passes it to the runtime, and for Node only
+ * before the script it runs, whose own arguments come after it.
+ */
+function preloadsOf(scripts) {
+    const found = new Set();
+    for (const script of scripts) {
+        for (const command of script.split(COMMAND_SEPARATORS)) {
+            const tokens = scriptTokens(command);
+            let at = 0;
+            while (at < tokens.length &&
+                (ASSIGNMENT.test(tokens[at] ?? "") || LAUNCHERS.has(tokens[at] ?? ""))) {
+                at += 1;
+            }
+            const path = tokens[at] ?? "";
+            const program = path.slice(path.lastIndexOf("/") + 1);
+            if (!PRELOADING_PROGRAMS.has(program)) {
+                continue;
+            }
+            for (at += 1; at < tokens.length; at += 1) {
+                const token = tokens[at] ?? "";
+                if (!token.startsWith("-")) {
+                    if (program === "node") {
+                        break;
+                    }
+                    continue;
+                }
+                const equals = token.indexOf("=");
+                const flag = equals < 0 ? token : token.slice(0, equals);
+                if (!PRELOAD_FLAGS.has(flag)) {
+                    continue;
+                }
+                if (equals < 0) {
+                    at += 1;
+                }
+                const value = equals < 0 ? tokens[at] : token.slice(equals + 1);
+                const name = value === undefined ? undefined : packageOfSpecifier(value);
+                if (name !== undefined) {
+                    found.add(name);
+                }
+            }
+        }
+    }
+    return found;
+}
 /** Whether a path below the target root lies in the directory `dir` below it, `""` being the root. */
 function isInside(path, dir) {
     return dir === "" || path.startsWith(`${dir}/`);
@@ -735,6 +827,7 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
         }
     }
     const workflow = new Set(workflowTokens(host, targetRoot));
+    const workflowPreloads = preloadsOf(workflowCommands(host, targetRoot));
     const declared = [];
     const ran = new Set();
     const peers = new Map();
@@ -745,12 +838,16 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             continue;
         }
         const tokens = scriptTokensOf(read.value);
+        const preloads = preloadsOf(manifestCommands(host, dir, read.value));
         for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
             const found = installedOf(host, dir, dependency.name);
             if (found === undefined && uninstalledHere.has(dir)) {
                 continue;
             }
             declared.push(dependency);
+            if (preloads.has(dependency.name) || workflowPreloads.has(dependency.name)) {
+                ran.add(declarationKey(dependency));
+            }
             if (found === undefined) {
                 continue;
             }

package/dist/src/discover.js

@@ -1,6 +1,6 @@
 import { DiagnosticCategory } from "@typescript/native/sync";
 import { baseUrlPaths } from "./base-url.js";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { SetupError } from "./setup-failure.js";
 import { writtenPath } from "./workspace-programs.js";
 /** Directory names discovery does not descend into. */
@@ -224,47 +224,6 @@ export function consumerProjects(engine, host, root) {
 function derivedId(targetRoot, configFile) {
     return relativePath(targetRoot, configFile) ?? configFile;
 }
-/**
- * The code of a configuration whose `extends` chain returns to a configuration it already
- * passed. The parse reports it and returns, and a snapshot opened from it never answers:
- * https://github.com/microsoft/TypeScript/issues/64754
- */
-const CIRCULAR_EXTENDS = 18000;
-/** The configuration files one parsed configuration's own `extends` names by path. */
-function extendedPaths(parsed, configFile) {
-    const { raw } = parsed;
-    const named = typeof raw === "object" && raw !== null ? Reflect.get(raw, "extends") : [];
-    return (Array.isArray(named) ? named : [named])
-        .filter((one) => typeof one === "string")
-        .filter((one) => one.startsWith("./") || one.startsWith("../") || isAbsolutePath(one))
-        .map((one) => resolvePath(dirnamePath(configFile), one));
-}
-/**
- * The `extends` chain from `configFile` to the first configuration it reaches twice, each
- * link by path, or undefined where no chain written by path returns.
- */
-function extendsCycle(engine, configFile, parsed) {
-    const walk = (chain, at) => {
-        for (const next of extendedPaths(at, chain.at(-1) ?? configFile)) {
-            if (chain.includes(next)) {
-                return [...chain, next];
-            }
-            let read;
-            try {
-                read = engine.parseConfigFile(next);
-            }
-            catch {
-                continue;
-            }
-            const cycle = walk([...chain, next], read);
-            if (cycle !== undefined) {
-                return cycle;
-            }
-        }
-        return undefined;
-    };
-    return walk([configFile], parsed);
-}
 /** The configuration files one parsed configuration's `references` name. */
 function referencesOf(parsed) {
     // The parse answers a directory reference as the directory; the compiler reads a
@@ -272,53 +231,26 @@ function referencesOf(parsed) {
     // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
     return (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"));
 }
-/** Why one parsed configuration's own `extends` chain cannot be opened, where it is circular. */
-function circularity(engine, configFile, parsed) {
-    const chain = extendsCycle(engine, configFile, parsed);
-    if (chain === undefined && !parsed.errors.some(({ code }) => code === CIRCULAR_EXTENDS)) {
-        return undefined;
-    }
-    return `TS${String(CIRCULAR_EXTENDS)}: Circularity detected while resolving configuration: ${(chain ?? [configFile]).join(" -> ")}`;
-}
 /**
- * Why a configuration the `references` reach, transitively, cannot be opened, where one's
- * `extends` chain is circular: the compiler opens every referenced project with the one
- * that references it.
+ * The code of a configuration whose `extends` chain returns to a configuration it already
+ * passed. A snapshot that opens two configurations whose `extends` chains reach one such
+ * cycle panics (`OwnerCache.AddOwner: entry not found`, typescript 7.1.0-dev.20261014.1),
+ * so the analysis refuses one before any snapshot is asked to open it.
  */
-function referencedCircularity(engine, references, visited) {
-    for (const reference of references) {
-        if (visited.has(reference)) {
-            continue;
-        }
-        visited.add(reference);
-        let parsed;
-        try {
-            parsed = engine.parseConfigFile(reference);
-        }
-        catch {
-            continue;
-        }
-        const reason = circularity(engine, reference, parsed) ??
-            referencedCircularity(engine, referencesOf(parsed), visited);
-        if (reason !== undefined) {
-            return reason;
-        }
-    }
-    return undefined;
-}
+const CIRCULAR_EXTENDS = 18000;
 /**
- * The configuration files one configuration's `references` name, or why the compiler
- * cannot read the configuration: it throws, or its `extends` chain or that of a
- * configuration it references is circular, which the analysis refuses before any
- * snapshot is asked to open it.
+ * The configurations one configuration file's `references` name, or why it cannot be read:
+ * the compiler throws, or its parse reports the `extends` chain circular.
  */
 function readConfiguration(engine, configFile) {
     try {
         const parsed = engine.parseConfigFile(configFile);
-        const references = referencesOf(parsed);
-        const reason = circularity(engine, configFile, parsed) ??
-            referencedCircularity(engine, references, new Set([configFile]));
-        return reason === undefined ? { references } : { reason };
+        const circular = parsed.errors.find(({ code }) => code === CIRCULAR_EXTENDS);
+        // The compiler leaves the message's `{0}` unfilled:
+        // https://github.com/microsoft/TypeScript/pull/64755
+        return circular === undefined
+            ? { references: referencesOf(parsed) }
+            : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
     }
     catch (error) {
         return { reason: error instanceof Error ? error.message : String(error) };

package/dist/src/entry-points.js

@@ -10,14 +10,16 @@
  * value that is not a literal is not evaluated and not guessed, so a file it would
  * have named is entered by nothing here.
  */
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.js";
+import { buildScriptEntries } from "./build-scripts.js";
 import { globExpression } from "./glob.js";
 import { htmlEntries } from "./html-entries.js";
 import { documentEntries } from "./mdx-entries.js";
 import { dirnamePath, relativePath, resolvePath } from "./paths.js";
 import { UNANSWERED } from "./query.js";
+import { computedLoadDirectory, leadingLiteral } from "./unseen-loads.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"];
@@ -210,7 +212,7 @@ function configurationEntries(host, targetRoot, files, parse, selected) {
         strings(dirnamePath(document.path), unselectedIn(document.path, document.strings));
     }
     for (const { file } of outside) {
-        strings(dirnamePath(file.fileName), moduleStrings(file).map((one) => one.text));
+        strings(dirnamePath(file.fileName), unselected(file));
     }
     return found;
 }
@@ -398,17 +400,6 @@ function workersOf(project, file, files) {
     }
     return found;
 }
-/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
-function leadingLiteral(node) {
-    const at = unwrapped(node);
-    if (isTemplateExpression(at)) {
-        return at.head.text;
-    }
-    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
-        return literalOf(unwrapped(at.left)) ?? leadingLiteral(at.left);
-    }
-    return undefined;
-}
 /** Whether one call is `import.meta.glob(...)`. */
 function isMetaGlob(node) {
     if (!isCallExpression(node) || !isPropertyAccessExpression(node.expression)) {
@@ -432,11 +423,8 @@ function computedImportsOf(file, files) {
     const dir = dirnamePath(file.fileName);
     const found = [];
     const below = (prefix) => {
-        const target = resolvePath(dir, prefix);
-        if (!isModuleRelative(prefix) ||
-            !prefix.endsWith("/") ||
-            target === dir ||
-            relativePath(target, dir) !== undefined) {
+        const target = computedLoadDirectory(dir, prefix);
+        if (target === undefined) {
             return;
         }
         for (const candidate of files.byName.values()) {
@@ -522,6 +510,9 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse,
             ...(names === undefined ? {} : { names }),
         });
     }
+    for (const { file, source } of buildScriptEntries(host, targetRoot, files, parse)) {
+        found.push({ file, rule: "bundler-entry", source, exports: true });
+    }
     for (const { file, source } of workflowEntries(host, targetRoot, files)) {
         found.push({ file, rule: "workflow-step", source, exports: true });
     }

package/dist/src/exempt.js

@@ -106,11 +106,19 @@ export function evidenceRecords(input, detectors, disabled) {
                 site: evidence.site,
                 ...(evidence.whileLive === undefined ? {} : { whileLive: evidence.whileLive }),
                 ...(evidence.implementing === undefined ? {} : { implementing: evidence.implementing }),
+                ...(evidence.whileWritten === undefined ? {} : { whileWritten: evidence.whileWritten }),
             });
         }
     }
     return found;
 }
+/**
+ * The records that hold given the declarations a write the mode counts stores into: one
+ * that holds only while written holds where its declaration is among them.
+ */
+export function writtenRecords(records, written) {
+    return records.flatMap(({ whileWritten, ...record }) => whileWritten === undefined || written.has(record.id) ? [record] : []);
+}
 /** The records that hold under one mode, beside the evidence a production mode found in a test file. */
 export function heldRecords(records, holding) {
     const found = [];

package/dist/src/findings/completion.js

@@ -87,10 +87,12 @@ function testedByIn(input) {
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A member an `in` expression tests by name is `possible`.
+ * consumer set. A member an `in` expression tests by name, and one a function outside the
+ * analysis fills, is `possible`.
  */
 function reachabilityClasses(input) {
     const tested = testedByIn(input);
+    const filled = input.boundary.filledOutside ?? new Set();
     const published = publishedIds(input.swept.matrix.union);
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
@@ -99,12 +101,25 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (tested.has(id)) {
+        if (tested.has(id) || filled.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";
     };
 }
+/**
+ * Whether one test of dead code references a target symbol that is published API of a run
+ * that declares no consumer, which outside programs the run cannot see may use, so the
+ * target counts as live for the test and the test is no test of dead code.
+ */
+export function testsUnseenAPI(input) {
+    if (input.boundary.consumers.declared.length > 0) {
+        return () => false;
+    }
+    const union = input.swept.matrix.union;
+    const published = publishedIds(union);
+    return (id) => testTargets(union, id).some((target) => published.has(target));
+}
 /** The target symbols one test of dead code references, by id: production declarations the sweep judges. */
 function testTargets(union, id) {
     return (union.out[union.at(id)] ?? []).flatMap((edge) => {
@@ -151,13 +166,16 @@ function testUsedSubjects(input) {
 }
 /**
  * The ceiling the roots the run found put on one dead subject: a subject other declarations
- * reference, found dead only because no root reaches them, is `probable` unless
- * the configuration declares the roots complete, because a root the analysis cannot see
- * would make it live; every other declaration has none below `certain`.
+ * reference, found dead only because no root reaches them, is `probable` unless the
+ * configuration declares the roots complete and no configuration holding the subject loads
+ * a module the analysis cannot resolve, because a root the analysis cannot see would make
+ * it live; every other declaration has none below `certain`.
  */
-function rootsCeiling(input, finding, candidate) {
+function rootsCeiling(input, finding, candidate, configurations) {
     const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
-    return unreachable && !input.config.ts.rootsComplete ? "probable" : "certain";
+    const unseen = new Set((input.files.unseenLoads ?? []).map((load) => load.configuration));
+    const complete = input.config.ts.rootsComplete && !configurations.some((one) => unseen.has(one));
+    return unreachable && !complete ? "probable" : "certain";
 }
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
@@ -170,8 +188,24 @@ function findingComponents(swept, components, cascade) {
             held.set(member, component);
         }
     }
+    const listed = membersListed(swept);
+    return (id) => {
+        const component = held.get(id);
+        return component === undefined
+            ? undefined
+            : {
+                id: component.id,
+                root: component.roots.includes(id),
+                symbolCount: component.members.length,
+                deletableLines: component.deletableLines,
+                ...(cascade === "full" ? { members: listed(component.members) } : {}),
+            };
+    };
+}
+/** The members of a component as the run lists them, positioned and in the canonical order. */
+function membersListed(swept) {
     const symbols = new Map(swept.matrix.union.symbols.map((symbol) => [symbol.id, symbol]));
-    const listed = (component) => component.members
+    return (members) => members
         .flatMap((member) => {
         const symbol = symbols.get(member);
         return symbol === undefined
@@ -188,18 +222,6 @@ function findingComponents(swept, components, cascade) {
             ];
     })
         .sort((a, b) => byPosition(a.position, b.position));
-    return (id) => {
-        const component = held.get(id);
-        return component === undefined
-            ? undefined
-            : {
-                id: component.id,
-                root: component.roots.includes(id),
-                symbolCount: component.members.length,
-                deletableLines: component.deletableLines,
-                ...(cascade === "full" ? { members: listed(component) } : {}),
-            };
-    };
 }
 /**
  * The run's dead components with each file a `DS1502` finding reports dead among them, so
@@ -277,11 +299,12 @@ export function completed(input, findings, kinds = KINDS) {
     let minted = computed;
     const dead = new Set(components.map((component) => component.id));
     const fallingWith = new Map();
-    for (const { heldByTests } of swept.sweep.candidates) {
+    for (const { id, heldByTests } of swept.sweep.candidates) {
         if (heldByTests !== undefined) {
-            fallingWith.set(heldByTests, (fallingWith.get(heldByTests) ?? 0) + 1);
+            fallingWith.set(heldByTests, [...(fallingWith.get(heldByTests) ?? []), id]);
         }
     }
+    const listed = membersListed(swept);
     const done = findings.map((finding) => {
         const row = kinds.get(finding.code);
         if (row === undefined) {
@@ -326,11 +349,25 @@ export function completed(input, findings, kinds = KINDS) {
         let component = found;
         if (component === undefined) {
             minted += 1;
+            const falling = symbol?.kind === "interface" ? fallingWith.get(symbol.id) : undefined;
             component = {
                 id: componentId(minted),
                 root: true,
-                symbolCount: symbol?.kind === "interface" ? (fallingWith.get(symbol.id) ?? 1) : 1,
+                symbolCount: falling?.length ?? 1,
                 deletableLines: 0,
+                ...(input.config.reporters.cascade !== "full"
+                    ? {}
+                    : falling === undefined
+                        ? {
+                            members: [
+                                {
+                                    ref: finding.symbol.ref,
+                                    name: finding.symbol.name,
+                                    position: finding.position,
+                                },
+                            ],
+                        }
+                        : { members: listed(falling) }),
             };
         }
         const counts = candidate === undefined
@@ -341,7 +378,11 @@ export function completed(input, findings, kinds = KINDS) {
             ? candidate !== undefined && testUsed.declarations.has(judged.id)
             : finding.code === FILE_NEVER_IMPORTED && testUsed.files.has(finding.position.path);
         const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
-        const untested = capped(capped(capped(ownClass, row.maxClass), rootsCeiling(input, finding, candidate)), judged === undefined ? "certain" : ceilingOf(judged.id));
+        const configurations = candidate?.configurations ??
+            (judged === undefined && !part
+                ? swept.matrix.configurations
+                : (swept.matrix.heldIn[at] ?? swept.matrix.configurations));
+        const untested = capped(capped(capped(ownClass, row.maxClass), rootsCeiling(input, finding, candidate, configurations)), judged === undefined ? "certain" : ceilingOf(judged.id));
         const generated = input.files.generated?.has(finding.position.path) === true;
         const fixability = generated
             ? "none"
@@ -372,10 +413,7 @@ export function completed(input, findings, kinds = KINDS) {
             generated,
             component,
             retainedBy: [],
-            configurations: candidate?.configurations ??
-                (judged === undefined && !part
-                    ? swept.matrix.configurations
-                    : (swept.matrix.heldIn[at] ?? swept.matrix.configurations)),
+            configurations,
             consumersLoaded: input.boundary.consumers.loaded,
             fixability,
             severity: severityOf(input, finding.code, row.defaultSeverity),

package/dist/src/findings/intra-function.js

@@ -28,7 +28,8 @@ function overlapClause(overlap, part) {
  * caller may pass a function used as a value more arguments than it declares, so there one
  * a read parameter follows is renamed to an underscore name, which the compilers read as
  * declared unread, and one no read parameter follows is deleted: kept where the call's
- * inference may read its annotation, at `probable` where nothing reads the annotation.
+ * inference may read its annotation, at `probable` where nothing reads the annotation or
+ * where it is a name a contextually typed object pattern binds.
  */
 function parameterVerdict(part, free, freeButValued) {
     const place = part.parameter;
@@ -45,7 +46,8 @@ function parameterVerdict(part, free, freeButValued) {
     if (place?.annotated === "steers") {
         return undefined;
     }
-    return { fix: "delete", confidence: place?.annotated === "free" ? "probable" : "certain" };
+    const unseen = place?.annotated === "free" || place?.contextualPattern === true;
+    return { fix: "delete", confidence: unseen ? "probable" : "certain" };
 }
 /**
  * Whether one part is reported. A parameter needs its function's signature free to

package/dist/src/findings/reads-and-writes.js

@@ -1,7 +1,7 @@
 import { positionKey } from "../position.js";
 import { declarationKey } from "../ref.js";
-/** The containers whose type parameters `DS1303` reports: a function and a class method. */
-const SIGNATURES = new Set(["function", "method"]);
+/** The containers whose type parameters `DS1303` reports: a function, a class method and a type alias. */
+const SIGNATURES = new Set(["function", "method", "type"]);
 function indexed(input) {
     const { matrix, sweep } = input.swept;
     return {
@@ -165,10 +165,11 @@ function unusedEnumMembers(run) {
     return unnamed(run, "enum-member").map((symbol) => findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`));
 }
 /**
- * `DS1303`: a type parameter of a function or a class method that neither the
- * declaration's signature nor its body names. A type parameter of a class, an interface,
- * a type alias or a method signature belongs to a type declaration and is never
- * reported, because a phantom parameter makes two instantiations distinct types.
+ * `DS1303`: a type parameter of a function, a class method or a type alias that neither
+ * the declaration's signature nor its body names. An alias names no type of its own, so
+ * a parameter its type never names makes no two instantiations distinct. One of a class,
+ * an interface or a method signature is never reported: a class or an interface merges
+ * only with declarations of the same parameters.
  */
 function unusedTypeParameters(run) {
     return unnamed(run, "type-parameter")

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

@@ -1,3 +1,4 @@
+import { testsUnseenAPI } from "./completion.js";
 import { unreachableExports } from "./visibility-narrowing.js";
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
 const MEMBERS = new Set([
@@ -48,7 +49,7 @@ const TEST_OF_DEAD_CODE = "every target symbol this test references is reported
 function codeOf(judged) {
     const { candidate, symbol } = judged;
     if (candidate.testOfDeadCode) {
-        return "DS1005";
+        return judged.testsUnseenAPI ? undefined : "DS1005";
     }
     if ((judged.test && !candidate.unreferencedTest) || NOT_THIS_FAMILY.has(symbol.kind)) {
         return undefined;
@@ -199,6 +200,7 @@ function familyFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
+    const unseenAPI = testsUnseenAPI(input);
     let brands;
     const found = [];
     for (const candidate of input.swept.sweep.candidates) {
@@ -217,6 +219,7 @@ function familyFindings(input, fallen) {
             test: union.test[at] === true,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),
+            testsUnseenAPI: candidate.testOfDeadCode && unseenAPI(candidate.id),
         };
         const code = codeOf(judged);
         if (code === undefined ||

package/dist/src/graph.js

@@ -34,9 +34,9 @@ const SWEPT = {
  * Whether a root of each kind names a caller, which holds it live under both relations: a
  * 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.
+ * names what enters the package, an alias global stands for its export, an outside
+ * declaration names a global interface merging into it, and an entry file, a configured root
+ * and a pattern assert a caller. A published API supposes a consumer: reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
@@ -49,8 +49,10 @@ const NAMES_A_CALLER = {
     pattern: true,
     "type-error": true,
     "type-query-alias": true,
+    "global-augmentation": true,
     "configuration-file": true,
     "configuration-string": true,
+    "bundler-entry": true,
     "test-runner": true,
     "browser-tests": true,
     worker: true,