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

package/dist/src/entry-points.js

@@ -10,11 +10,12 @@
  * 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, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, } from "@typescript/native/ast";
+import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isExportAssignment, isIdentifier, isMetaProperty, isNewExpression, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPropertyAccessExpression, isPropertyAssignment, isSatisfiesExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
 import { configurationFiles, filesNamedBy, moduleStrings, } from "./configuration-files.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 { workflowEntries } from "./workflow-steps.js";
@@ -37,8 +38,11 @@ const BROWSER_TEST_MATCH = "**/*.{spec,test}.{js,ts,jsx,tsx,cjs,cts,cjsx,ctsx,mj
 const SETUP_MEMBERS = ["setupFiles", "globalSetup"];
 /** A member that moves the directory every path of a test-runner configuration is read from. */
 const ROOT_MEMBER = "root";
-/** The prefixes a literal is relative with, in a module specifier and a URL reference alike. */
-const RELATIVE_PREFIXES = ["./", "../"];
+/**
+ * A URL reference's scheme. A reference with none that does not start with a solidus is
+ * relative, the bare name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
 /** The constructors whose first argument addresses a worker script. */
 const WORKER_CONSTRUCTORS = new Set(["Worker", "SharedWorker"]);
 /** The file's name, the last segment of its path. */
@@ -138,9 +142,16 @@ function literalsOf(value) {
     }
     return found;
 }
-/** Whether a literal is relative in the sense a module specifier and a URL reference share. */
+/**
+ * Whether a literal is a relative URL reference, which is also how the test runner reads a
+ * setup file's path against its root.
+ */
 function isRelative(text) {
-    return RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix));
+    return text !== "" && !text.startsWith("/") && !URL_SCHEME.test(text);
+}
+/** Whether a module specifier is relative, which a bare name is not: it names a package. */
+function isModuleRelative(text) {
+    return text.startsWith("./") || text.startsWith("../");
 }
 /** A URL reference with its query and its fragment removed, which name no part of the file. */
 function pathPart(text) {
@@ -348,10 +359,10 @@ function workerSitesOf(file) {
     return found;
 }
 /**
- * The workers one file addresses. A call's names must resolve to the platform's own
- * declarations, which no file of the target declares and no import brings in; a
- * name the target binds itself is the target's own constructor or object, which
- * addresses no worker this rule knows. One batch per file that writes such a call.
+ * The workers one file addresses. A call's names must resolve to a symbol the platform
+ * declares, which a file of the target may augment and no import brings in; a name only
+ * the target declares is the target's own constructor or object, which addresses no
+ * worker this rule knows. One batch per file that writes such a call.
  */
 function workersOf(project, file, files) {
     const sites = workerSitesOf(file);
@@ -371,8 +382,7 @@ function workersOf(project, file, files) {
         }
         if (symbol !== undefined &&
             (symbol.flags & SymbolFlags.Alias) === 0 &&
-            symbol.declarations.length > 0 &&
-            symbol.declarations.every((handle) => !files.byName.has(handle.path))) {
+            symbol.declarations.some((handle) => !files.byName.has(handle.path))) {
             platform.add(name);
         }
     });
@@ -388,6 +398,87 @@ 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)) {
+        return false;
+    }
+    const { expression, name } = node.expression;
+    return (isIdentifier(name) &&
+        name.text === "glob" &&
+        isMetaProperty(expression) &&
+        expression.keywordToken === SyntaxKind.ImportKeyword);
+}
+/**
+ * The files one file loads by a computed path, each with what exports: every own file
+ * below the directory a relative literal start of an `import()` or `require()` argument
+ * names, other than the calling file's own directory or one holding it, which would name
+ * every sibling, and
+ * every own file a relative literal glob of `import.meta.glob` matches, both read against
+ * the calling file's directory, as a bundler's context module reads them.
+ */
+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) {
+            return;
+        }
+        for (const candidate of files.byName.values()) {
+            if (candidate !== file && relativePath(target, candidate.fileName) !== undefined) {
+                found.push({ file: candidate, rule: "computed-import", source: prefix, exports: true });
+            }
+        }
+    };
+    const globbed = (pattern) => {
+        if (!isModuleRelative(pattern)) {
+            return;
+        }
+        const expression = globExpression(resolvePath(dir, pattern));
+        for (const candidate of files.byName.values()) {
+            if (candidate !== file && expression.test(candidate.fileName)) {
+                found.push({ file: candidate, rule: "computed-import", source: pattern, exports: true });
+            }
+        }
+    };
+    const visit = (node) => {
+        if (isCallExpression(node)) {
+            const [first] = node.arguments;
+            const callee = node.expression;
+            const loads = callee.kind === SyntaxKind.ImportKeyword ||
+                (isIdentifier(callee) && callee.text === "require");
+            if (loads && first !== undefined) {
+                const prefix = leadingLiteral(first);
+                if (prefix !== undefined) {
+                    below(prefix);
+                }
+            }
+            else if (isMetaGlob(node) && first !== undefined) {
+                for (const pattern of literalsOf(first) ?? []) {
+                    globbed(pattern);
+                }
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return found;
+}
 /**
  * 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.
@@ -417,10 +508,20 @@ export function entryPoints(project, files, testFiles, host, targetRoot, parse,
             }
         }
         found.push(...workersOf(project, file, files));
+        found.push(...computedImportsOf(file, files));
     }
     for (const { file, source } of htmlEntries(host, targetRoot, files, parse)) {
         found.push({ file, rule: "html-entry", source, exports: true });
     }
+    for (const { file, source, names } of documentEntries(host, targetRoot, files)) {
+        found.push({
+            file,
+            rule: "document-import",
+            source,
+            exports: true,
+            ...(names === undefined ? {} : { names }),
+        });
+    }
     for (const { file, source } of workflowEntries(host, targetRoot, files)) {
         found.push({ file, rule: "workflow-step", source, exports: true });
     }

package/dist/src/findings/completion.js

@@ -4,12 +4,27 @@
  * together with every finding that falls with a root they withhold.
  */
 import { componentId } from "../components.js";
+import { deadComponents } from "../matrix.js";
 import { OUTSIDE } from "../graph.js";
 import { KINDS } from "../kinds.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 unused-file code, whose deletion removes every use its file writes. */
+const FILE_NEVER_IMPORTED = "DS1502";
+/**
+ * The codes whose subject the run that counts test references holds live, as
+ * finding.schema.json lists them, so a test file's candidate reported under one carries
+ * none of a dead declaration's sweep facts.
+ */
+const LIVE_SUBJECT = new Set([
+    "DS1101",
+    "DS1102",
+    "DS1104",
+    "DS1204",
+    "DS1301",
+]);
 /** The fixability grammar/analysis.md "Fixability" gives a finding about a held declaration. */
 const MANUAL = "manual";
 /** The member kinds an object property can declare, which an `in` expression tests by name. */
@@ -72,15 +87,11 @@ 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. Test-support code test code references, outside the test-of-dead-code
- * rule, what it contains, and a member an `in` expression tests by name are `possible`.
+ * consumer set. A member an `in` expression tests by name is `possible`.
  */
 function reachabilityClasses(input) {
     const tested = testedByIn(input);
     const published = publishedIds(input.swept.matrix.union);
-    const usedByTests = new Set(input.swept.sweep.candidates
-        .filter((candidate) => candidate.heldByTests !== undefined)
-        .map((candidate) => candidate.id));
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
         ? "possible"
@@ -88,12 +99,25 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (usedByTests.has(id) || tested.has(id)) {
+        if (tested.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";
     };
 }
+/** 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) => {
+        const target = union.symbols[edge.to];
+        const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
+        return target !== undefined &&
+            !testCode &&
+            union.ambient[edge.to] !== true &&
+            union.subject[edge.to] === true
+            ? [target.id]
+            : [];
+    });
+}
 /**
  * The confidence ceiling of a test of dead code: the lowest reachability class among the
  * target symbols it references, because its deadness is theirs, whether or not they share
@@ -102,28 +126,46 @@ function reachabilityClasses(input) {
 function testCeilings(input, classOf) {
     const union = input.swept.matrix.union;
     const tests = new Set(input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id));
-    return (id) => {
-        let lowest = "certain";
-        if (!tests.has(id)) {
-            return lowest;
-        }
-        for (const edge of union.out[union.at(id)] ?? []) {
-            const target = union.symbols[edge.to];
-            const testCode = union.test[edge.to] === true || union.support[edge.to] === true;
-            if (target !== undefined && !testCode && union.subject[edge.to] === true) {
-                lowest = capped(lowest, classOf(target.id));
-            }
+    return (id) => tests.has(id)
+        ? testTargets(union, id).reduce((lowest, target) => capped(lowest, classOf(target)), "certain")
+        : "certain";
+}
+/**
+ * The subjects dead only because production code only tests use is: each declaration the
+ * sweep marks test-used, each `DS1502` file of such code, and each test of dead code every
+ * target of which is one. Nothing they hold references a dead declaration outside them, so
+ * the rest of a component they share is reported without them.
+ */
+function testUsedSubjects(input) {
+    const { matrix, sweep } = input.swept;
+    const union = matrix.union;
+    const used = new Set(sweep.candidates.filter((one) => one.testUsed).map((one) => one.id));
+    for (const test of sweep.candidates.filter((one) => one.testOfDeadCode)) {
+        const targets = testTargets(union, test.id);
+        if (targets.length > 0 && targets.every((target) => used.has(target))) {
+            used.add(test.id);
         }
-        return lowest;
-    };
+    }
+    const files = new Set(union.symbols.flatMap((symbol, at) => matrix.testUsed[at] === true ? [symbol.position.path] : []));
+    return { declarations: used, files };
+}
+/**
+ * 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`.
+ */
+function rootsCeiling(input, finding, candidate) {
+    const unreachable = candidate?.relation === "reachability" || finding.unreachableOnly === true;
+    return unreachable && !input.config.ts.rootsComplete ? "probable" : "certain";
 }
 /**
  * The component each dead declaration of the run falls in, and none for a live one, with
  * its members listed in the canonical order where the run lists a component in full.
  */
-function findingComponents(swept, cascade) {
+function findingComponents(swept, components, cascade) {
     const held = new Map();
-    for (const component of swept.sweep.components) {
+    for (const component of components) {
         for (const member of component.members) {
             held.set(member, component);
         }
@@ -159,6 +201,59 @@ function findingComponents(swept, cascade) {
             };
     };
 }
+/**
+ * The run's dead components with each file a `DS1502` finding reports dead among them, so
+ * the file's declarations fall with it, and with the components each subject that is no
+ * declaration falls with joined into one.
+ */
+function runComponents(swept, findings) {
+    const union = swept.matrix.union;
+    const reported = new Set(findings.filter((one) => one.code === FILE_NEVER_IMPORTED).map((one) => one.position.path));
+    const files = new Map(union.symbols.flatMap((symbol, at) => symbol.kind === "file" && reported.has(symbol.position.path) ? [[at, symbol]] : []));
+    const computed = files.size === 0
+        ? swept.sweep.components
+        : deadComponents(swept.matrix, swept.sweep, new Set(files.keys()));
+    const place = new Map();
+    computed.forEach((component, at) => {
+        for (const member of component.members) {
+            place.set(member, at);
+        }
+    });
+    const leader = computed.map((_component, at) => at);
+    const find = (at) => {
+        let top = at;
+        while ((leader[top] ?? top) !== top) {
+            top = leader[top] ?? top;
+        }
+        return top;
+    };
+    for (const { fallsWith } of findings) {
+        const joined = (fallsWith ?? []).flatMap((id) => place.get(id) ?? []).map(find);
+        const first = Math.min(...joined);
+        for (const one of joined) {
+            leader[one] = first;
+        }
+    }
+    const merged = new Map();
+    computed.forEach((component, at) => {
+        const top = find(at);
+        const into = merged.get(top);
+        merged.set(top, into === undefined
+            ? component
+            : {
+                id: into.id,
+                members: [...into.members, ...component.members],
+                roots: [...into.roots, ...component.roots],
+                deletableLines: into.deletableLines + component.deletableLines,
+                held: into.held && component.held,
+            });
+    });
+    return {
+        components: [...merged.values()],
+        computed: computed.length,
+        files: new Map([...files.values()].map((symbol) => [symbol.position.path, symbol.id])),
+    };
+}
 /**
  * Every finding of the run completed, in the order given. A dead declaration carries its
  * candidate's relation, counts, configurations and component; a live one carries no relation and
@@ -174,10 +269,13 @@ export function completed(input, findings, kinds = KINDS) {
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
     const classOf = reachabilityClasses(input);
     const ceilingOf = testCeilings(input, classOf);
-    const componentOf = findingComponents(swept, input.config.reporters.cascade);
-    const held = new Set(swept.sweep.components.filter((one) => one.held).flatMap((one) => one.members));
-    let minted = swept.sweep.components.length;
-    const dead = new Set(swept.sweep.components.map((component) => component.id));
+    const testUsed = testUsedSubjects(input);
+    const { components, computed, files } = runComponents(swept, findings);
+    const componentOf = findingComponents(swept, components, input.config.reporters.cascade);
+    const held = new Set(components.filter((one) => one.held).flatMap((one) => one.members));
+    // A join keeps its first component's identifier, so a minted one counts past every computed one.
+    let minted = computed;
+    const dead = new Set(components.map((component) => component.id));
     const fallingWith = new Map();
     for (const { heldByTests } of swept.sweep.candidates) {
         if (heldByTests !== undefined) {
@@ -193,18 +291,30 @@ export function completed(input, findings, kinds = KINDS) {
         // 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 ref = finding.symbol.holder ?? finding.symbol.ref;
         const at = isRowSubject(finding.symbol.kind)
             ? OUTSIDE
-            : union.symbols[declared]?.ref === finding.symbol.ref
+            : union.symbols[declared]?.ref === ref
                 ? declared
-                : (positions.get(declarationKey(finding.symbol.ref, finding.position.path)) ?? OUTSIDE);
+                : (positions.get(declarationKey(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);
         const symbol = union.symbols[at];
         const judged = !part && union.subject[at] === true ? symbol : undefined;
-        const candidate = judged === undefined ? undefined : candidates.get(judged.id);
-        const found = symbol === undefined || part ? undefined : componentOf(symbol.id);
+        const candidate = judged === undefined || LIVE_SUBJECT.has(finding.code)
+            ? undefined
+            : candidates.get(judged.id);
+        const fallsWith = finding.fallsWith?.[0];
+        const joined = fallsWith === undefined ? undefined : componentOf(fallsWith);
+        const file = finding.code === FILE_NEVER_IMPORTED ? files.get(finding.position.path) : undefined;
+        const found = joined !== undefined
+            ? { ...joined, root: false }
+            : file !== undefined
+                ? componentOf(file)
+                : symbol === undefined || part
+                    ? undefined
+                    : componentOf(symbol.id);
         // A test file's declaration is a component member only as a test of dead code, and
         // test code keeps the test-support code it references out of every component.
         if (candidate !== undefined &&
@@ -226,7 +336,12 @@ export function completed(input, findings, kinds = KINDS) {
         const counts = candidate === undefined
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
-        const reachabilityClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const ownClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const used = judged !== undefined
+            ? 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 generated = input.files.generated?.has(finding.position.path) === true;
         const fixability = generated
             ? "none"
@@ -236,9 +351,13 @@ export function completed(input, findings, kinds = KINDS) {
                 row.findingFixabilities?.includes(MANUAL) === true
                 ? MANUAL
                 : row.fixability;
-        const lastUses = fixability === "deletable" && candidate !== undefined
-            ? input.dependencies.lastUses.get(candidate.id)
-            : undefined;
+        const lastUses = fixability !== "deletable"
+            ? undefined
+            : candidate !== undefined
+                ? input.dependencies.lastUses.get(candidate.id)
+                : finding.code === FILE_NEVER_IMPORTED
+                    ? input.dependencies.fileLastUses.get(finding.position.path)
+                    : undefined;
         return {
             code: finding.code,
             kind: row.name,
@@ -246,7 +365,8 @@ export function completed(input, findings, kinds = KINDS) {
             position: finding.position,
             symbol: finding.symbol,
             reachabilityClass,
-            confidence: capped(capped(reachabilityClass, row.maxClass), judged === undefined ? "certain" : ceilingOf(judged.id)),
+            confidence: used ? "possible" : untested,
+            ...(used ? { componentConfidence: untested } : {}),
             ...(candidate === undefined ? {} : { livenessRelation: candidate.relation }),
             testOnly: judged !== undefined && counts?.production === 0 && counts.test > 0,
             generated,
@@ -270,7 +390,7 @@ export function completed(input, findings, kinds = KINDS) {
 /**
  * The findings with every finding of a dead component capped by the lowest confidence
  * among the component's root members, so the minimum confidence reports or withholds a
- * component whole.
+ * component whole but for the findings test-used code lowers on their own.
  */
 function componentCapped(findings, dead) {
     const lowest = new Map();
@@ -278,16 +398,27 @@ function componentCapped(findings, dead) {
         const { id, root } = finding.component;
         if (root && dead.has(id)) {
             const held = lowest.get(id);
-            lowest.set(id, held === undefined ? finding.confidence : capped(held, finding.confidence));
+            const own = componentConfidenceOf(finding);
+            lowest.set(id, held === undefined ? own : capped(held, own));
         }
     }
     return findings.map((finding) => {
         const cap = lowest.get(finding.component.id);
-        return cap === undefined || RANK[cap] >= RANK[finding.confidence]
-            ? finding
-            : { ...finding, confidence: cap };
+        if (cap === undefined) {
+            return finding;
+        }
+        const own = finding.componentConfidence;
+        return {
+            ...finding,
+            confidence: capped(finding.confidence, cap),
+            ...(own === undefined ? {} : { componentConfidence: capped(own, cap) }),
+        };
     });
 }
+/** The confidence a finding gives its component's cap and the dials. */
+function componentConfidenceOf(finding) {
+    return finding.componentConfidence ?? finding.confidence;
+}
 /** Whether the dials withhold a finding by its own severity or confidence. */
 function dialed(finding, minConfidence) {
     return finding.severity === "allow" || RANK[finding.confidence] < RANK[minConfidence];
@@ -302,7 +433,8 @@ function dialed(finding, minConfidence) {
 export function dialsOf(input, findings) {
     const minConfidence = input.config.analysis.minConfidence;
     const components = new Set(findings
-        .filter((finding) => finding.component.root && dialed(finding, minConfidence))
+        .filter((finding) => finding.component.root &&
+        dialed({ ...finding, confidence: componentConfidenceOf(finding) }, minConfidence))
         .map((finding) => finding.component.id));
     return {
         allows: (code) => {

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

@@ -1,38 +1,84 @@
 import { declarationKey } from "../dependencies.js";
 import { renderRef } from "../ref.js";
+import { nonCodeArtifacts } from "./non-code-artifacts.js";
 const UNUSED_DEPENDENCY = "DS1601";
+const FILE_NEVER_IMPORTED = "DS1502";
 const MESSAGES = {
     dependency: "no import in the target needs the declared dependency",
     "dev-dependency": "no import in the target needs the declared development dependency",
     "peer-dependency": "no import in the target needs the declared peer dependency",
 };
+const DEAD_USERS_MESSAGES = {
+    dependency: "only code that is itself dead uses the declared dependency",
+    "dev-dependency": "only code that is itself dead uses the declared development dependency",
+    "peer-dependency": "only code that is itself dead uses the declared peer dependency",
+};
+/**
+ * The run's dead code: test code keeps the code it references out of every dead component
+ * unless that code is dead as well, and a file's top level is dead where the file is.
+ */
+function deadCode(input) {
+    const { swept } = input;
+    const union = swept.matrix.union;
+    const files = new Map(union.symbols.filter((one) => one.kind === "file").map((one) => [one.position.path, one.id]));
+    const dead = new Set(swept.sweep.components.flatMap((component) => component.members));
+    const reachedOnly = new Set(swept.sweep.candidates.filter((one) => one.relation === "reachability").map((one) => one.id));
+    for (const finding of nonCodeArtifacts(input)) {
+        const id = files.get(finding.position.path);
+        if (finding.code === FILE_NEVER_IMPORTED && id !== undefined) {
+            dead.add(id);
+            if (finding.unreachableOnly === true) {
+                reachedOnly.add(id);
+            }
+        }
+    }
+    const published = new Set(union.rooted
+        .filter((root) => root.kind === "published-api")
+        .flatMap((root) => union.symbols[root.at]?.id ?? []));
+    return { dead, reachedOnly, published };
+}
 /**
  * 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.
+ * that the target does not need, at the position of its key, and one whose every use is
+ * held by dead code, which is dead only through that code and falls with its component:
+ * at `possible` where one of its holders is published, and found under reachability alone
+ * where one of them is.
  */
-function unusedDependencies(dependencies) {
-    return dependencies.declared
-        .filter((dependency) => !dependencies.needed.has(declarationKey(dependency)) &&
-        !dependencies.ran.has(declarationKey(dependency)))
-        .map((dependency) => ({
-        code: UNUSED_DEPENDENCY,
-        position: dependency.position,
-        symbol: {
-            ref: renderRef(dependency.manifest, {
-                of: "dependency",
-                name: dependency.name,
-                section: dependency.section,
-            }),
-            kind: "dependency",
-            name: dependency.name,
-            sizeLines: 1,
-        },
-        message: MESSAGES[dependency.section],
-        details: { dependencyClass: dependency.section },
-        ...(dependencies.unbuilt.has(dependency.position.path)
-            ? { reachabilityClass: "possible" }
-            : {}),
-    }));
+function unusedDependencies(input, dependencies) {
+    const { dead, reachedOnly, published } = deadCode(input);
+    return dependencies.declared.flatMap((dependency) => {
+        const key = declarationKey(dependency);
+        const held = dependencies.heldBy.get(key);
+        const users = held?.every((id) => dead.has(id)) === true ? held : undefined;
+        if (dependencies.ran.has(key) || (dependencies.needed.has(key) && users === undefined)) {
+            return [];
+        }
+        const unbuilt = dependencies.unbuilt.has(dependency.position.path);
+        const atPossible = unbuilt || users?.some((id) => published.has(id)) === true;
+        return [
+            {
+                code: UNUSED_DEPENDENCY,
+                position: dependency.position,
+                symbol: {
+                    ref: renderRef(dependency.manifest, {
+                        of: "dependency",
+                        name: dependency.name,
+                        section: dependency.section,
+                    }),
+                    kind: "dependency",
+                    name: dependency.name,
+                    sizeLines: 1,
+                },
+                message: (users === undefined ? MESSAGES : DEAD_USERS_MESSAGES)[dependency.section],
+                details: { dependencyClass: dependency.section },
+                ...(atPossible ? { reachabilityClass: "possible" } : {}),
+                ...(users?.some((id) => reachedOnly.has(id)) === true
+                    ? { unreachableOnly: true }
+                    : {}),
+                ...(users === undefined ? {} : { fallsWith: users }),
+            },
+        ];
+    });
 }
 /** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
-export const dependenciesAndModuleMachinery = ({ dependencies }) => unusedDependencies(dependencies);
+export const dependenciesAndModuleMachinery = (input) => unusedDependencies(input, input.dependencies);

package/dist/src/findings/emitters.js

@@ -100,7 +100,7 @@ function dialledOver(input, suppressed, found, unmarked) {
     const unanswered = heldKeys(input);
     const markup = markupKeys(input);
     const candidates = found.filter((finding) => {
-        const key = declarationKey(finding.symbol.ref, finding.position.path);
+        const key = declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
         return (!ledger.withheld(finding) &&
             !unanswered.has(key) &&
             !markup.has(key) &&