@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.10

package/dist/src/file-facts.js

@@ -3,10 +3,10 @@
  * file below the target root, whether or not a project includes it, and the files a
  * program holds by inclusion rather than by an import.
  */
-import { IGNORED_DIRECTORIES } from "./discover.js";
 import { packageScope } from "./inventory.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
 import { renderRef } from "./ref.js";
+import { filesBelow } from "./fs/tree.js";
 /** A file name the compiler reads as a source file. */
 const SOURCE_FILE = /\.(?:ts|tsx|mts|cts)$/u;
 /** A file name the compiler reads as a declaration file, which no build emits code from. */
@@ -30,30 +30,7 @@ function lastLine(text) {
  * that cannot be read is skipped, as discovery skips it.
  */
 export function sourcePaths(host, targetRoot) {
-    const found = [];
-    const pending = [""];
-    for (let dir = pending.pop(); dir !== undefined; dir = pending.pop()) {
-        let entries;
-        try {
-            entries = host.readDirectory(joinPath(targetRoot, dir));
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const path = dir === "" ? entry.name : `${dir}/${entry.name}`;
-            if (entry.directory) {
-                if (!IGNORED_DIRECTORIES.has(entry.name)) {
-                    pending.push(path);
-                }
-                continue;
-            }
-            if (SOURCE_FILE.test(entry.name) && !DECLARATION_FILE.test(entry.name)) {
-                found.push(path);
-            }
-        }
-    }
-    return found.sort((a, b) => (a < b ? -1 : 1));
+    return filesBelow(host, targetRoot, (name) => SOURCE_FILE.test(name) && !DECLARATION_FILE.test(name));
 }
 /**
  * Every source file below the target root, in path order. A file that cannot be read is

package/dist/src/findings/completion.js

@@ -3,29 +3,20 @@
  * the code's row of the issue-kind vocabulary, and the dials that withhold a finding
  * together with every finding that falls with a root they withhold.
  */
+import { CODE, FAMILY_KEY_LENGTH, KIND_ROWS, } from "../contract/contract.generated.js";
 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.
+ * The codes whose subject the run that counts test references holds live, 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 LIVE_SUBJECT = new Set(KIND_ROWS.filter((row) => row.holdsLive).map((row) => row.code));
+/** The fixability grammar/analysis/fixability.md 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. */
 const IN_TESTED = new Set([
@@ -50,8 +41,9 @@ function everyDeclaredLoaded(boundary) {
  * naming its family, else the code's default.
  */
 function severityOf(input, code, fallback) {
-    const { config } = input;
-    return (config.severity.get(code) ?? config.severity.get(code.slice(0, FAMILY_KEY_LENGTH)) ?? fallback);
+    const { severity } = input.config;
+    const key = [code, code.slice(0, FAMILY_KEY_LENGTH)].find((one) => Object.hasOwn(severity, one));
+    return key === undefined ? fallback : (severity[key] ?? fallback);
 }
 /**
  * The declarations the roots name as a library's published API, each public member of a
@@ -87,10 +79,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 +93,38 @@ 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) => {
+        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
@@ -113,33 +133,41 @@ 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.ambient[edge.to] !== true &&
-                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 `DS1602` 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`.
+ * 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.roots_complete && !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
@@ -152,8 +180,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
@@ -170,27 +214,15 @@ 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
+ * The run's dead components with each file a `DS1602` 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 reported = new Set(findings.filter((one) => one.code === CODE.fileNeverImported).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
@@ -251,6 +283,7 @@ 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 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));
@@ -258,11 +291,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) {
@@ -288,7 +322,7 @@ export function completed(input, findings, kinds = KINDS) {
             : 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 file = finding.code === CODE.fileNeverImported ? files.get(finding.position.path) : undefined;
         const found = joined !== undefined
             ? { ...joined, root: false }
             : file !== undefined
@@ -307,17 +341,40 @@ 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
             ? 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 === CODE.fileNeverImported && testUsed.files.has(finding.position.path);
+        const reachabilityClass = used && candidate?.testOfDeadCode !== true ? "possible" : ownClass;
+        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"
@@ -331,7 +388,7 @@ export function completed(input, findings, kinds = KINDS) {
             ? undefined
             : candidate !== undefined
                 ? input.dependencies.lastUses.get(candidate.id)
-                : finding.code === FILE_NEVER_IMPORTED
+                : finding.code === CODE.fileNeverImported
                     ? input.dependencies.fileLastUses.get(finding.position.path)
                     : undefined;
         return {
@@ -341,16 +398,14 @@ export function completed(input, findings, kinds = KINDS) {
             position: finding.position,
             symbol: finding.symbol,
             reachabilityClass,
-            confidence: capped(capped(capped(reachabilityClass, row.maxClass), rootsCeiling(input, finding, candidate)), 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,
             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),
@@ -365,7 +420,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();
@@ -373,16 +428,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];
@@ -395,9 +461,10 @@ function dialed(finding, minConfidence) {
  * root withholds itself alone.
  */
 export function dialsOf(input, findings) {
-    const minConfidence = input.config.analysis.minConfidence;
+    const minConfidence = input.config.analysis.min_confidence;
     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,8 +1,7 @@
+import { CODE } from "../contract/contract.generated.js";
 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",
@@ -25,7 +24,7 @@ function deadCode(input) {
     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) {
+        if (finding.code === CODE.fileNeverImported && id !== undefined) {
             dead.add(id);
             if (finding.unreachableOnly === true) {
                 reachedOnly.add(id);
@@ -57,7 +56,7 @@ function unusedDependencies(input, dependencies) {
         const atPossible = unbuilt || users?.some((id) => published.has(id)) === true;
         return [
             {
-                code: UNUSED_DEPENDENCY,
+                code: CODE.unusedDependency,
                 position: dependency.position,
                 symbol: {
                     ref: renderRef(dependency.manifest, {
@@ -80,5 +79,5 @@ function unusedDependencies(input, dependencies) {
         ];
     });
 }
-/** The findings of the dependencies-and-module-machinery family, `DS1600` to `DS1699`. */
+/** The findings of the dependencies family, `DS1700` to `DS1799`. */
 export const dependenciesAndModuleMachinery = (input) => unusedDependencies(input, input.dependencies);

package/dist/src/findings/emitters.js

@@ -12,7 +12,7 @@ import { readsAndWrites } from "./reads-and-writes.js";
 import { selfCheck } from "./self-check.js";
 import { fallenMembers, unusedDeclarations } from "./unused-declarations.js";
 import { visibilityNarrowing } from "./visibility-narrowing.js";
-/** Every kind family this analyzer reports, each by its emitter, in code order. */
+/** Every emitter this analyzer runs, by the name its tests select it by. */
 export const EMITTERS = new Map([
     ["unused-declarations", unusedDeclarations],
     ["visibility-narrowing", visibilityNarrowing],
@@ -51,7 +51,7 @@ function markupKeys(input) {
         .filter((symbol) => live.has(symbol.parent))
         .map((symbol) => declarationKey(symbol.ref, symbol.position.path)));
 }
-/** Every family's findings over one sweep, and those of any further emitter, completed by one step. */
+/** Every emitter'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)));
 }
@@ -70,8 +70,8 @@ function dialsOver(input, found, suppressed, unmarked) {
 }
 /**
  * Every finding of one run swept under its suppressions' marks, decided in one pass: each
- * family's findings completed by one step, so every component number is minted once, the
- * finding each record claims withheld, the rest withheld by the dials, so a root one family
+ * emitter's findings completed by one step, so every component number is minted once, the
+ * finding each record claims withheld, the rest withheld by the dials, so a root one emitter
  * reports withholds what another reports in its component, and every declared edge
  * evaluated over what remains, so a pending finding is in its evaluation alone.
  */
@@ -86,7 +86,7 @@ function atPossible(input) {
     const { config } = input;
     return {
         ...input,
-        config: { ...config, analysis: { ...config.analysis, minConfidence: "possible" } },
+        config: { ...config, analysis: { ...config.analysis, min_confidence: "possible" } },
     };
 }
 /**

package/dist/src/findings/interfaces.js

@@ -1,6 +1,5 @@
+import { CODE } from "../contract/contract.generated.js";
 import { byPosition } from "../position.js";
-const UNUSED_INTERFACE = "DS1201";
-const UNCALLED_INTERFACE_METHOD = "DS1203";
 /** What each finding says, by what the sweep found about the subject's references. */
 const UNUSED_MESSAGE = "nothing in the target names the interface as a type";
 const UNUSED_DEAD_MESSAGE = "the interface is named as a type only from declarations that are themselves dead";
@@ -45,7 +44,7 @@ function findingOf(code, symbol, message, implementations) {
 }
 /**
  * The findings of the interfaces family, `DS1200` to `DS1299`: `DS1201`, a dead
- * interface, whose members fall with it unreported; and `DS1203`, a method of a live
+ * interface, whose members fall with it unreported; and `DS1202`, a method of a live
  * interface no reference names, unless it is a marker, a method whose every
  * implementation has an empty body. A test file's declaration is neither kind's subject,
  * because a production sweep counts none of the references it can have, save an interface
@@ -60,7 +59,7 @@ export const interfaces = (input) => {
             continue;
         }
         if (symbol.kind === "interface") {
-            found.push(findingOf(UNUSED_INTERFACE, symbol, unusedMessage(candidate), run.implementationsOf(candidate.id)));
+            found.push(findingOf(CODE.unusedInterface, symbol, unusedMessage(candidate), run.implementationsOf(candidate.id)));
             continue;
         }
         if (symbol.kind !== "interface-method" ||
@@ -69,7 +68,7 @@ export const interfaces = (input) => {
             marker(input, candidate.id)) {
             continue;
         }
-        found.push(findingOf(UNCALLED_INTERFACE_METHOD, symbol, UNCALLED_MESSAGE, run.implementationsOf(symbol.parent)));
+        found.push(findingOf(CODE.uncalledInterfaceMethod, symbol, UNCALLED_MESSAGE, run.implementationsOf(symbol.parent)));
     }
     return found;
 };

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

@@ -1,6 +1,7 @@
+import { CODE } from "../contract/contract.generated.js";
 import { KINDS } from "../kinds.js";
 import { parameterRef } from "../ref.js";
-import { UNUSED_PARAMETER, UNUSED_RESULT } from "../intra-function-parts.js";
+import {} from "../intra-function-parts.js";
 import { reachedWithTheTests } from "../sweep.js";
 /** A list of rules as a sentence names them. */
 function spelled(rules) {
@@ -28,7 +29,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 +47,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
@@ -60,9 +63,9 @@ function reported(input, part, callersUnknown) {
     }
     const { free, freeButValued, discardedEverywhere } = input.intraFunction;
     switch (part.code) {
-        case UNUSED_PARAMETER:
+        case CODE.unusedParameter:
             return parameterVerdict(part, free, freeButValued) !== undefined;
-        case UNUSED_RESULT:
+        case CODE.unusedResult:
             return (free.has(part.declaration) &&
                 discardedEverywhere.has(part.declaration) &&
                 !callersUnknown.has(part.declaration));
@@ -71,7 +74,7 @@ function reported(input, part, callersUnknown) {
     }
 }
 /**
- * The findings of the intra-function family, `DS1800` to `DS1899`, each about a part of
+ * The findings of the inside-functions family, `DS1401` to `DS1406`, each about a part of
  * the declaration its reference names, at the part's own position, whatever the sweep
  * decided about a production declaration. A part of test code is reported only where the
  * run that counts test references reaches its declaration and that is no test of dead
@@ -95,7 +98,7 @@ export const intraFunction = (input) => {
         return symbol === undefined ? [] : [symbol.id];
     }));
     const { declared, loaded } = input.boundary.consumers;
-    const closed = input.config.consumersComplete && declared.every((id) => loaded.includes(id));
+    const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
     const published = (id) => {
         const symbol = byId.get(id);
         return (symbol !== undefined &&
@@ -112,11 +115,11 @@ export const intraFunction = (input) => {
     const found = [];
     for (const part of input.intraFunction.parts) {
         const declaration = byId.get(part.declaration);
-        const overlap = KINDS.get(part.code)?.overlap ?? [];
+        const overlap = KINDS.get(part.code)?.overlap?.ts ?? [];
         if (declaration === undefined || !judged(declaration.id) || !reported(input, part, unknown)) {
             continue;
         }
-        const verdict = part.code === UNUSED_PARAMETER
+        const verdict = part.code === CODE.unusedParameter
             ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
             : undefined;
         const message = verdict?.fix === "rename"
@@ -126,7 +129,7 @@ export const intraFunction = (input) => {
             code: part.code,
             position: part.position,
             symbol: {
-                ...(part.code === UNUSED_PARAMETER
+                ...(part.code === CODE.unusedParameter
                     ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
                     : { ref: declaration.ref }),
                 kind: part.kind,

package/dist/src/findings/non-code-artifacts.js

@@ -1,5 +1,4 @@
-const FILE_NEVER_BUILT = "DS1501";
-const FILE_NEVER_IMPORTED = "DS1502";
+import { CODE } from "../contract/contract.generated.js";
 /** The subject kind of a finding about a source file, from the finding schema's vocabulary. */
 const FILE_SUBJECT = "file";
 /** A file's subject starts at its first character. */
@@ -11,8 +10,8 @@ const FILE_START = 1;
  * derived matrix is never complete.
  */
 function completeMatrix(config) {
-    return (config.analysis.matrixComplete &&
-        config.analysis.configurations.some((entry) => entry.shape === "project"));
+    return (config.analysis.matrix.complete &&
+        config.analysis.configurations.some((entry) => "project" in entry));
 }
 /** One finding about a whole file. */
 function fileFinding(code, file, message) {
@@ -40,7 +39,7 @@ function fileNeverBuilt({ config, swept, files }) {
     const message = `no project of the build matrix includes this file (${swept.matrix.configurations.join(", ")})`;
     return files.tree
         .filter((file) => !built.has(file.path))
-        .map((file) => fileFinding(FILE_NEVER_BUILT, file, message));
+        .map((file) => fileFinding(CODE.fileNeverBuilt, file, message));
 }
 /**
  * The paths of the files a reference from a live declaration of another file reaches, a
@@ -125,13 +124,13 @@ function fileNeverImported(input) {
         const file = { path: symbol.position.path, ref: symbol.ref, endLine: symbol.endLine };
         return referenced.has(symbol.position.path)
             ? {
-                ...fileFinding(FILE_NEVER_IMPORTED, file, "only code that is itself dead imports this file, and no root names it or a declaration in it"),
+                ...fileFinding(CODE.fileNeverImported, file, "only code that is itself dead imports this file, and no root names it or a declaration in it"),
                 unreachableOnly: true,
             }
-            : fileFinding(FILE_NEVER_IMPORTED, file, "no import reaches this file and no root names it or a declaration in it");
+            : fileFinding(CODE.fileNeverImported, file, "no import reaches this file and no root names it or a declaration in it");
     });
 }
-/** The findings of the non-code-artifacts family, `DS1500` to `DS1599`. */
+/** The findings of the files family, `DS1600` to `DS1699`. */
 export const nonCodeArtifacts = (input) => [
     ...fileNeverBuilt(input),
     ...fileNeverImported(input),