@cplieger/deadset-ts 8.0.0-dev.5 → 8.0.0-dev.7

package/dist/src/exempt-classes.js

@@ -1,62 +1,4 @@
-/**
- * The exemption classes of the Contract's vocabulary, in its order: each class's name, its
- * languages and, for a TypeScript class, which private members it may retain. The rows are
- * written out, as the fixed severity codes are, and a test holds them equal to the Contract.
- * A class name is a type, so a table or a record naming a class outside the vocabulary, or
- * one of another language only, does not compile.
- */
-/** Every class of the vocabulary, in the order the Contract lists them. */
-export const EXEMPTION_CLASSES = [
-    {
-        class: "interface-satisfaction",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: false, privateName: false },
-    },
-    { class: "encoding-reflection", languages: ["go"] },
-    { class: "format-verb-contract", languages: ["go"] },
-    { class: "errors-duck-typing", languages: ["go"] },
-    {
-        class: "enum-group",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: false, privateName: false },
-    },
-    {
-        class: "generated-file",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    { class: "linkname-cgo-asm-plugin", languages: ["go"] },
-    {
-        class: "template-field",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "reflective-lookup",
-        languages: ["go", "ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "decorator",
-        languages: ["ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "injection-container",
-        languages: ["ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "framework-lifecycle",
-        languages: ["ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-    {
-        class: "serialization-contract",
-        languages: ["ts"],
-        typescriptVisibility: { private: true, privateName: false },
-    },
-];
+import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
 function runsOnTS(row) {
     const languages = row.languages;
     return languages.includes("ts");
@@ -69,7 +11,5 @@ const VISIBILITY = new Map(TS_ROWS.map((row) => [row.class, row.typescriptVisibi
 export function typescriptVisibilityOf(exemptionClass) {
     return VISIBILITY.get(exemptionClass) ?? { private: false, privateName: false };
 }
-/** Whether one name is a class of the vocabulary, whichever language it runs on. */
-export function isExemptionClass(name) {
-    return EXEMPTION_CLASSES.some((row) => row.class === name);
-}
+/** Every class of the vocabulary, whichever language it runs on, in the vocabulary's order. */
+export const EXEMPTION_CLASS_NAMES = EXEMPTION_CLASSES.map((row) => row.class);

package/dist/src/exempt.js

@@ -6,26 +6,18 @@
  * which records held something back. It names no class's detector: the composition
  * hands it the table of the classes it has.
  */
-import { ConfigError } from "./config.js";
-import { EXEMPTION_CLASSES, isExemptionClass, TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
+import { EXEMPTION_CLASSES } from "./contract/contract.generated.js";
+import { TS_EXEMPTION_CLASSES, typescriptVisibilityOf, } from "./exempt-classes.js";
 import { byPosition, positionKey } from "./position.js";
 import { Unanswerable } from "./query.js";
 import { sweep } from "./sweep.js";
+import { bytewise } from "./text/compare.js";
 /**
- * The classes `exemptions.disabled` switches off. A name is refused unless the
- * vocabulary holds it; a class that runs on another language only is admitted and
- * switches nothing off here, so one configuration serves every analyzer.
+ * The classes `exemptions.disabled` switches off. A class that runs on another language
+ * only switches nothing off here, so one configuration serves every analyzer.
  */
 export function disabledClasses(config) {
-    const disabled = new Set();
-    for (const name of config.exemptionsDisabled) {
-        if (!isExemptionClass(name)) {
-            const known = EXEMPTION_CLASSES.map((row) => row.class).join(", ");
-            throw new ConfigError("malformed", "exemptions.disabled", `exemptions.disabled: ${JSON.stringify(name)} is not an exemption class: the classes are ${known}`);
-        }
-        disabled.add(name);
-    }
-    return disabled;
+    return new Set(config.exemptionsDisabled);
 }
 /**
  * Whether a class whose row states `allowed` may retain a member of one visibility. A
@@ -40,20 +32,8 @@ function retainable(allowed, visibility) {
     }
     return true;
 }
-/**
- * The kinds of declaration each class can hold back, which a detector that stops holds
- * back whole. A class with no row here holds back every declaration but a file.
- */
-const RETAINABLE = new Map([
-    ["interface-satisfaction", new Set(["method", "class-member"])],
-    ["enum-group", new Set(["enum-member"])],
-    ["injection-container", new Set(["method", "class-member"])],
-    ["framework-lifecycle", new Set(["method", "class-member"])],
-    [
-        "serialization-contract",
-        new Set(["method", "class-member", "interface-method", "type-member"]),
-    ],
-]);
+/** The kinds of declaration each class can hold back, which a detector that stops holds back whole. */
+const RETAINABLE = new Map(EXEMPTION_CLASSES.flatMap((row) => "ts" in row.retainsKinds ? [[row.class, new Set(row.retainsKinds.ts)]] : []));
 /** The detail of a record a detector that could not finish holds. */
 const UNANSWERED_DETAIL = "kept live by a question the checker did not answer";
 /** Whether one record is held by a detector that could not finish. */
@@ -76,7 +56,7 @@ function detected(exemptionClass, detect, input) {
         }
         const kinds = RETAINABLE.get(exemptionClass);
         return input.held.symbols
-            .filter((symbol) => (kinds === undefined ? symbol.kind !== "file" : kinds.has(symbol.kind)))
+            .filter((symbol) => kinds?.has(symbol.kind) === true)
             .map((symbol) => ({ id: symbol.id, detail: UNANSWERED_DETAIL, site: symbol.position }));
     }
 }
@@ -133,20 +113,13 @@ export function heldRecords(records, holding) {
     }
     return { records: exemptionsOf(found), inTestFiles };
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * Records as a run holds them: ordered by site, then class, then declaration, and one
  * per declaration, class, detail and file it holds while live, the one at the first
  * site. A fact found at many sites, or by several projects, is one record.
  */
 export function exemptionsOf(found) {
-    const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || compare(a.class, b.class) || compare(a.id, b.id));
+    const ordered = [...found].sort((a, b) => byPosition(a.site, b.site) || bytewise(a.class, b.class) || bytewise(a.id, b.id));
     const seen = new Set();
     return ordered.filter((record) => {
         const fact = [record.id, record.class, record.detail, record.whileLive ?? ""].join("\u0000");
@@ -197,8 +170,8 @@ export function retainedIn(matrix, input, writeOnly = new Set()) {
     return matrix.union.symbols.flatMap((symbol) => held.get(symbol.id) ?? []);
 }
 /**
- * One line per held-back declaration, in site order: its reference, then each record's
- * class, site and detail, all separated by tabs.
+ * One line per held-back declaration, in site order: its reference and position, then
+ * each record's class, site and detail, all separated by tabs.
  */
 export function retainedLines(symbols, retained) {
     const held = byDeclaration(retained);
@@ -212,6 +185,6 @@ export function retainedLines(symbols, retained) {
             positionKey(record.site),
             record.detail,
         ]);
-        return [[symbol.ref, ...fields].join("\t")];
+        return [[symbol.ref, positionKey(symbol.position), ...fields].join("\t")];
     });
 }

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([
@@ -147,7 +138,7 @@ function testCeilings(input, classOf) {
 }
 /**
  * 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
+ * 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.
  */
@@ -224,13 +215,13 @@ function membersListed(swept) {
         .sort((a, b) => byPosition(a.position, b.position));
 }
 /**
- * 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
@@ -330,7 +321,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
@@ -376,7 +367,7 @@ export function completed(input, findings, kinds = KINDS) {
         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);
+            : 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
@@ -396,7 +387,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 {

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.
  */

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) {
@@ -62,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));
@@ -73,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
@@ -114,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"
@@ -128,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. */
@@ -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),

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

@@ -1,6 +1,8 @@
+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, a class method and a type alias. */
+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;
@@ -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,15 +159,15 @@ 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, a class method or a type alias that neither
+ * `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
@@ -174,7 +176,7 @@ function unusedEnumMembers(run) {
 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
@@ -185,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