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

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

@@ -1,38 +1,83 @@
+import { CODE } from "../contract/contract.generated.js";
 import { declarationKey } from "../dependencies.js";
 import { renderRef } from "../ref.js";
-const UNUSED_DEPENDENCY = "DS1601";
+import { nonCodeArtifacts } from "./non-code-artifacts.js";
 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 === CODE.fileNeverImported && 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: CODE.unusedDependency,
+                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);
+/** 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" } },
     };
 }
 /**
@@ -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) &&

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,5 +1,7 @@
+import { CODE } from "../contract/contract.generated.js";
 import { KINDS } from "../kinds.js";
-import { UNUSED_PARAMETER, UNUSED_RESULT } from "../intra-function-parts.js";
+import { parameterRef } from "../ref.js";
+import {} from "../intra-function-parts.js";
 import { reachedWithTheTests } from "../sweep.js";
 /** A list of rules as a sentence names them. */
 function spelled(rules) {
@@ -8,24 +10,45 @@ function spelled(rules) {
     }
     return `${rules.slice(0, -1).join(", ")} and ${rules.at(-1) ?? ""}`;
 }
-/** The clause a message ends with: the other rules that report the kind, or that none is known. */
-function overlapClause(overlap) {
-    return overlap.length === 1 && overlap[0] === "none known"
+/** The compiler's rule of the parameter kind's overlap list, which reports only in a file it checks. */
+const COMPILER_PARAMETER_RULE = "tsc --noUnusedParameters";
+/**
+ * The clause a message ends with: the other rules that report the part, or that none is
+ * known. A parameter of a file the compiler does not check is no report of the compiler's.
+ */
+function overlapClause(overlap, part) {
+    const rules = part.parameter?.checked === false
+        ? overlap.filter((rule) => rule !== COMPILER_PARAMETER_RULE)
+        : overlap;
+    return rules.length === 1 && rules[0] === "none known"
         ? "no other rule is known to report it"
-        : `also reported by ${spelled(overlap)}`;
+        : `also reported by ${spelled(rules)}`;
 }
 /**
- * Whether one parameter's name is reported: every unread one of a function whose
- * signature is free, and of a function used as a value only one no read parameter follows,
- * because a caller may pass such a function more arguments than it declares.
+ * Whether one unread parameter is reported, and how. Of a free signature it is deleted. A
+ * 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 or
+ * where it is a name a contextually typed object pattern binds.
  */
-function parameterReported(part, free, freeButValued) {
+function parameterVerdict(part, free, freeButValued) {
     const place = part.parameter;
     if (place?.inValue !== true && free.has(part.declaration)) {
-        return true;
+        return place?.annotated === undefined ? { fix: "delete", confidence: "certain" } : undefined;
     }
     const valued = place?.inValue === true || freeButValued.has(part.declaration);
-    return valued && place?.beforeARead !== true;
+    if (!valued) {
+        return undefined;
+    }
+    if (place?.beforeARead === true) {
+        return { fix: "rename" };
+    }
+    if (place?.annotated === "steers") {
+        return undefined;
+    }
+    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
@@ -40,9 +63,9 @@ function reported(input, part, callersUnknown) {
     }
     const { free, freeButValued, discardedEverywhere } = input.intraFunction;
     switch (part.code) {
-        case UNUSED_PARAMETER:
-            return parameterReported(part, free, freeButValued);
-        case UNUSED_RESULT:
+        case CODE.unusedParameter:
+            return parameterVerdict(part, free, freeButValued) !== undefined;
+        case CODE.unusedResult:
             return (free.has(part.declaration) &&
                 discardedEverywhere.has(part.declaration) &&
                 !callersUnknown.has(part.declaration));
@@ -51,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
@@ -75,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 &&
@@ -92,24 +115,35 @@ 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 === CODE.unusedParameter
+            ? parameterVerdict(part, input.intraFunction.free, input.intraFunction.freeButValued)
+            : undefined;
+        const message = verdict?.fix === "rename"
+            ? `${part.message}, and a read parameter follows it, so rename it to _${part.name}`
+            : part.message;
         found.push({
             code: part.code,
             position: part.position,
             symbol: {
-                ref: declaration.ref,
+                ...(part.code === CODE.unusedParameter
+                    ? { ref: parameterRef(declaration.ref, part.name), holder: declaration.ref }
+                    : { ref: declaration.ref }),
                 kind: part.kind,
                 name: part.name,
                 sizeLines: part.position.endLine - part.position.line + 1,
             },
-            message: `${part.message}; ${overlapClause(overlap)}`,
+            message: `${message}; ${overlapClause(overlap, part)}`,
             details: {
                 ...(part.kind === "store" ? { writePositions: [part.position] } : {}),
                 overlap,
             },
+            ...(verdict?.fix === "delete" && verdict.confidence !== "certain"
+                ? { reachabilityClass: verdict.confidence }
+                : {}),
         });
     }
     return found;

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,44 +39,28 @@ 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 every file a reference written in another file reaches, naming the
- * file or a declaration in it, a loaded consumer's file included. An import is such a
- * reference, so an import from any file reaches what it names, whatever reaches the
- * importing file.
+ * The paths of the files a reference from a live declaration of another file reaches, a
+ * loaded consumer's file included, a root names, or a declared edge names a declaration in,
+ * and of every file a reference written anywhere reaches. A file holding a declaration the
+ * sweep judged live is kept whatever held it live, and so is a file a program holds by
+ * inclusion, which acts on every file of the program without an import naming it. A
+ * reference from a file's top level counts once the file is kept.
  */
-function reachedFromOutside(union) {
-    const reached = new Set();
+function keptFiles({ swept, files, boundary }) {
+    const union = swept.matrix.union;
+    const edgeNamed = new Set(boundary.edges.map((side) => side.symbol));
+    const dead = new Set(swept.sweep.candidates.map((candidate) => candidate.id));
+    const kept = new Set(files.heldByInclusion);
+    const referenced = new Set();
     for (const edge of union.consumed) {
         const to = union.symbols[edge.to];
         if (to !== undefined) {
-            reached.add(to.position.path);
+            kept.add(to.position.path);
         }
     }
-    union.out.forEach((edges, from) => {
-        const fromPath = union.symbols[from]?.position.path;
-        for (const edge of edges) {
-            const to = union.symbols[edge.to];
-            if (to !== undefined && to.position.path !== fromPath) {
-                reached.add(to.position.path);
-            }
-        }
-    });
-    return reached;
-}
-/**
- * The paths of the files an import reaches, a root names, or a declared edge names a
- * declaration in. A file holding a declaration the sweep judged live is kept whatever
- * held it live, and so is a file a program holds by inclusion, which acts on every
- * file of the program without an import naming it.
- */
-function keptFiles({ swept, files, boundary }) {
-    const union = swept.matrix.union;
-    const edgeNamed = new Set(boundary.edges.map((side) => side.symbol));
-    const dead = new Set(swept.sweep.candidates.map((candidate) => candidate.id));
-    const kept = new Set([...reachedFromOutside(union), ...files.heldByInclusion]);
     for (const root of union.rooted) {
         const named = union.symbols[root.at];
         if (named !== undefined) {
@@ -89,16 +72,65 @@ function keptFiles({ swept, files, boundary }) {
             kept.add(symbol.position.path);
         }
     }
-    return kept;
+    const fromTopLevel = new Map();
+    const pending = [];
+    const keep = (path) => {
+        if (!kept.has(path)) {
+            kept.add(path);
+            pending.push(path);
+        }
+    };
+    union.out.forEach((edges, from) => {
+        const source = union.symbols[from];
+        if (source === undefined) {
+            return;
+        }
+        for (const edge of edges) {
+            const to = union.symbols[edge.to]?.position.path;
+            if (to === undefined || to === source.position.path) {
+                continue;
+            }
+            referenced.add(to);
+            if (source.kind === FILE_SUBJECT) {
+                fromTopLevel.set(source.position.path, [
+                    ...(fromTopLevel.get(source.position.path) ?? []),
+                    to,
+                ]);
+            }
+            else if (!dead.has(source.id)) {
+                pending.push(to);
+            }
+        }
+    });
+    pending.push(...kept);
+    for (let path = pending.pop(); path !== undefined; path = pending.pop()) {
+        kept.add(path);
+        for (const to of fromTopLevel.get(path) ?? []) {
+            keep(to);
+        }
+        fromTopLevel.delete(path);
+    }
+    return { kept, referenced };
 }
-/** Every file of the run that no import reaches and no root or edge names. */
+/**
+ * Every file of the run that no reference from live code reaches and no root or edge
+ * names. A file only dead code imports is found dead under reachability alone.
+ */
 function fileNeverImported(input) {
-    const kept = keptFiles(input);
+    const { kept, referenced } = keptFiles(input);
     return input.swept.matrix.union.symbols
         .filter((symbol) => symbol.kind === FILE_SUBJECT && !kept.has(symbol.position.path))
-        .map((symbol) => fileFinding(FILE_NEVER_IMPORTED, { path: symbol.position.path, ref: symbol.ref, endLine: symbol.endLine }, "no import reaches this file and no root names it or a declaration in it"));
+        .map((symbol) => {
+        const file = { path: symbol.position.path, ref: symbol.ref, endLine: symbol.endLine };
+        return referenced.has(symbol.position.path)
+            ? {
+                ...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(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),

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

@@ -1,7 +1,9 @@
+import { CODE } from "../contract/contract.generated.js";
 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"]);
+import { bytewise } from "../text/compare.js";
+/** The containers whose type parameters `DS1006` 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 {
@@ -75,7 +77,7 @@ function writeOnlyMessage(run, namedBy, symbol, held) {
         : "never read";
     const cascade = [
         ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
-        ...[...held.alone].sort().map((name) => `import ${name}`),
+        ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
     ];
     const word = SUBJECT_WORDS[symbol.kind] ?? "member";
     const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
@@ -133,7 +135,7 @@ function writeOnlySymbols(run) {
             run.candidates.has(symbol.id)) {
             continue;
         }
-        found.push(findingAbout(symbol, "DS1301", writeOnlyMessage(run, namedBy, symbol, held), {
+        found.push(findingAbout(symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, namedBy, symbol, held), {
             writePositions: held.writes,
         }));
     }
@@ -157,23 +159,24 @@ function unnamed(run, kind) {
     });
 }
 /**
- * `DS1302`: a member of an enum declaration that nothing names. A member an enum-group
+ * `DS1005`: a member of an enum declaration that nothing names. A member an enum-group
  * record holds back is no candidate, so a member a conversion can produce never reaches
  * this kind.
  */
 function unusedEnumMembers(run) {
-    return unnamed(run, "enum-member").map((symbol) => findingAbout(symbol, "DS1302", `enum member ${symbol.name} is named nowhere`));
+    return unnamed(run, "enum-member").map((symbol) => findingAbout(symbol, CODE.unusedEnumMember, `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.
+ * `DS1006`: 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")
         .filter((symbol) => SIGNATURES.has(run.symbols.get(symbol.parent)?.kind ?? ""))
-        .map((symbol) => findingAbout(symbol, "DS1303", `type parameter ${symbol.name} is named in neither its signature nor its body`));
+        .map((symbol) => findingAbout(symbol, CODE.unusedTypeParameter, `type parameter ${symbol.name} is named in neither its signature nor its body`));
 }
 /**
  * The keys of the declarations the write-only kind reports, whatever the
@@ -184,8 +187,8 @@ export function writeOnlyDeclarations(input) {
     return new Set(writeOnlySymbols(indexed(input)).map((finding) => declarationKey(finding.symbol.ref, finding.position.path)));
 }
 /**
- * The findings of the reads-and-writes family, `DS1300` to `DS1399`, in code order and
- * each code's in site order.
+ * The findings of the reads-and-writes kinds, `DS1301`, `DS1005` and `DS1006`, in that
+ * order and each code's in site order.
  */
 export const readsAndWrites = (input) => {
     const run = indexed(input);

package/dist/src/findings/self-check.js

@@ -1,10 +1,8 @@
+import { CODE } from "../contract/contract.generated.js";
 import { REPOSITORY_DOCUMENT } from "../config.js";
 import { FIXED_SEVERITY_CODES } from "../kinds.js";
-import { isDependencyCode, isUnsuppressibleCode, STALE_SUPPRESSION, SUPPRESSION_WITHOUT_REASON, } from "../suppress.js";
-/** The code a configured root that matches nothing is reported under. */
-const UNMATCHED_ROOT = "DS1704";
-/** The code a configured declaration that names nothing is reported under. */
-const UNMATCHED_DECLARATION = "DS1706";
+import { isDependencyCode, isUnsuppressibleCode, } from "../suppress.js";
+import { bytewise } from "../text/compare.js";
 /** The subject kind of a finding about a configured declaration. */
 const DECLARATION_SUBJECT = "configured-declaration";
 /** The subject kind of a finding about a suppression record. */
@@ -63,7 +61,7 @@ function suppressionRef(symbol, path, files) {
 }
 /** One finding per refused suppression: the grammar's reason refusal and its scope refusal. */
 function refusedSuppressions(refusals, files) {
-    return refusals.map((refused) => aboutSuppression(refused.reported, suppressionRef(refused.symbol, refused.path, files), refused.site, `${WRITTEN[refused.mechanism]} for ${refused.code} ${refused.reported === SUPPRESSION_WITHOUT_REASON
+    return refusals.map((refused) => aboutSuppression(refused.reported, suppressionRef(refused.symbol, refused.path, files), refused.site, `${WRITTEN[refused.mechanism]} for ${refused.code} ${refused.reported === CODE.suppressionWithoutReason
         ? "carries no reason"
         : "names a symbol and no path"}`, { mechanism: refused.mechanism, entry: writtenEntry(refused) }));
 }
@@ -83,10 +81,10 @@ export function staleSuppressions(stale, files) {
         bySite.set(key, held);
     }
     return [...bySite.values()].map(({ first, records }) => {
-        const codes = [...new Set(records.map((one) => one.record.code))].sort();
+        const codes = [...new Set(records.map((one) => one.record.code))].sort(bytewise);
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
-            .sort();
+            .sort(bytewise);
         const rows = codes.filter(isUnsuppressibleCode);
         const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
         const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
@@ -112,7 +110,7 @@ export function staleSuppressions(stale, files) {
                 ? ""
                 : `, and ${declared}`;
         return {
-            code: STALE_SUPPRESSION,
+            code: CODE.staleSuppression,
             mechanism: first.mechanism,
             entry: {
                 code: first.code,
@@ -141,7 +139,7 @@ function documentPosition(document) {
  */
 function unmatchedDeclarationFindings(unmatched) {
     return unmatched.map((one) => ({
-        code: UNMATCHED_DECLARATION,
+        code: CODE.unmatchedConfiguredDeclaration,
         position: documentPosition(one.document),
         symbol: { ref: one.ref, kind: DECLARATION_SUBJECT, name: one.ref, sizeLines: 1 },
         message: `${one.key} entry names no declaration in any project`,
@@ -157,7 +155,7 @@ function unmatchedDeclarationFindings(unmatched) {
 export function unmatchedRootFindings(sources, document) {
     const position = documentPosition(document);
     return sources.map((source) => ({
-        code: UNMATCHED_ROOT,
+        code: CODE.unmatchedRoot,
         position,
         symbol: { ref: source, kind: ROOT_SUBJECT, name: source, sizeLines: 1 },
         message: source.includes("*") || source.includes("?")
@@ -166,7 +164,7 @@ export function unmatchedRootFindings(sources, document) {
     }));
 }
 /**
- * The findings of the self-check family, `DS1700` to `DS1799`: a suppression refused for
+ * The findings of the configuration family, `DS9000` to `DS9099`: a suppression refused for
  * carrying no reason or naming no path, and a configured root or declaration that named
  * nothing. A
  * suppression that matched nothing is a record of the report's stale suppressions, which