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

package/dist/src/report-schema.js

@@ -0,0 +1,273 @@
+/**
+ * Holds a report to `contract/report.schema.json` and `contract/finding.schema.json`
+ * before it is written, reading the schemas the generator copies from the Contract, so
+ * this analyzer never writes a document a reader refuses. It evaluates the keywords the
+ * Contract's schemas use; the schemas' patterns are written to match alike in RE2 and in
+ * ECMAScript.
+ */
+import { REPORT_SCHEMAS } from "./contract/report.generated.js";
+/**
+ * Every keyword the validator evaluates or knows to carry no assertion. A schema naming
+ * another fails every check rather than passing values the keyword would refuse.
+ */
+const KEYWORDS = new Set([
+    ...["$schema", "$id", "$comment", "$defs", "title", "description", "default", "examples"],
+    ...["$ref", "type", "enum", "const", "pattern", "minLength", "minimum", "maximum"],
+    ...["properties", "additionalProperties", "required", "minProperties"],
+    ...["items", "minItems", "maxItems", "uniqueItems"],
+    ...["allOf", "anyOf", "oneOf", "not", "if", "then", "else"],
+]);
+const patterns = new Map();
+function pattern(source) {
+    let held = patterns.get(source);
+    if (held === undefined) {
+        held = new RegExp(source, "u");
+        patterns.set(source, held);
+    }
+    return held;
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function typeOf(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (typeof value === "number") {
+        return Number.isInteger(value) ? "integer" : "number";
+    }
+    return typeof value;
+}
+function hasType(value, name) {
+    const held = typeOf(value);
+    return held === name || (name === "number" && held === "integer");
+}
+/** One value's encoding with object members sorted, so two equal values encode alike. */
+function canonical(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(canonical).join(",")}]`;
+    }
+    if (isObject(value)) {
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+/** A string's length in code points, which JSON Schema's minLength counts. */
+function codePoints(value) {
+    let counted = 0;
+    for (const _point of value) {
+        counted += 1;
+    }
+    return counted;
+}
+const escape = (name) => name.replaceAll("~", "~0").replaceAll("/", "~1");
+/** A schema evaluated in the document it is read from, so a relative `$ref` resolves there. */
+class Checker {
+    documents;
+    constructor(documents) {
+        this.documents = documents;
+    }
+    resolve(doc, ref) {
+        const [file = "", pointer = ""] = ref.split("#");
+        const target = file === "" ? doc : file;
+        let schema = this.documents[target];
+        for (const token of pointer.split("/").filter((one) => one !== "")) {
+            schema = isObject(schema)
+                ? schema[token.replaceAll("~1", "/").replaceAll("~0", "~")]
+                : undefined;
+        }
+        if (!isObject(schema)) {
+            throw new Error(`report schema: ${ref} names no schema`);
+        }
+        return [target, schema];
+    }
+    matches(doc, schema, value, at) {
+        const found = [];
+        this.check(doc, schema, value, at, found);
+        return found.length === 0;
+    }
+    check(doc, schema, value, at, found) {
+        for (const keyword of Object.keys(schema)) {
+            if (!KEYWORDS.has(keyword) && !keyword.startsWith("x-")) {
+                throw new Error(`report schema: the keyword ${keyword} is not one this validator evaluates`);
+            }
+        }
+        const refuse = (keyword, reason, pointer = at) => {
+            found.push({ pointer, keyword, reason });
+        };
+        if (typeof schema["$ref"] === "string") {
+            const [target, referenced] = this.resolve(doc, schema["$ref"]);
+            this.check(target, referenced, value, at, found);
+        }
+        const types = schema["type"];
+        const named = types === undefined ? [] : Array.isArray(types) ? types : [types];
+        if (named.length > 0 && !named.some((one) => hasType(value, String(one)))) {
+            refuse("type", `the value is ${typeOf(value)}, want ${named.join(", ")}`);
+            return;
+        }
+        this.checkValue(schema, value, refuse);
+        if (Array.isArray(value)) {
+            this.checkArray(doc, schema, value, at, found, refuse);
+        }
+        else if (isObject(value)) {
+            this.checkObject(doc, schema, value, at, found, refuse);
+        }
+        this.checkApplicators(doc, schema, value, at, found, refuse);
+    }
+    checkValue(schema, value, refuse) {
+        const values = schema["enum"];
+        if (Array.isArray(values) && !values.some((one) => canonical(one) === canonical(value))) {
+            refuse("enum", `${canonical(value)} is not one of the values the schema lists`);
+        }
+        if (schema["const"] !== undefined && canonical(schema["const"]) !== canonical(value)) {
+            refuse("const", `${canonical(value)} is not ${canonical(schema["const"])}`);
+        }
+        if (typeof value === "string") {
+            if (typeof schema["pattern"] === "string" && !pattern(schema["pattern"]).test(value)) {
+                refuse("pattern", `${JSON.stringify(value)} does not match ${schema["pattern"]}`);
+            }
+            if (typeof schema["minLength"] === "number" && codePoints(value) < schema["minLength"]) {
+                refuse("minLength", `${JSON.stringify(value)} is shorter than ${String(schema["minLength"])} characters`);
+            }
+        }
+        if (typeof value === "number") {
+            if (typeof schema["minimum"] === "number" && value < schema["minimum"]) {
+                refuse("minimum", `${String(value)} is below ${String(schema["minimum"])}`);
+            }
+            if (typeof schema["maximum"] === "number" && value > schema["maximum"]) {
+                refuse("maximum", `${String(value)} is above ${String(schema["maximum"])}`);
+            }
+        }
+    }
+    checkObject(doc, schema, value, at, found, refuse) {
+        const properties = isObject(schema["properties"]) ? schema["properties"] : {};
+        const additional = schema["additionalProperties"];
+        for (const name of Object.keys(value).sort()) {
+            const member = `${at}/${escape(name)}`;
+            const declared = properties[name];
+            if (isObject(declared)) {
+                this.check(doc, declared, value[name], member, found);
+            }
+            else if (additional === false) {
+                refuse("additionalProperties", `the member ${JSON.stringify(name)} is not one the schema declares`);
+            }
+            else if (isObject(additional)) {
+                this.check(doc, additional, value[name], member, found);
+            }
+        }
+        for (const name of Array.isArray(schema["required"]) ? schema["required"] : []) {
+            if (!Object.hasOwn(value, name)) {
+                refuse("required", `the member ${JSON.stringify(name)} is absent`);
+            }
+        }
+        const fewest = schema["minProperties"];
+        if (typeof fewest === "number" && Object.keys(value).length < fewest) {
+            refuse("minProperties", `the object holds ${String(Object.keys(value).length)} members, fewer than ${String(fewest)}`);
+        }
+    }
+    checkArray(doc, schema, value, at, found, refuse) {
+        const items = schema["items"];
+        if (isObject(items)) {
+            value.forEach((item, i) => {
+                this.check(doc, items, item, `${at}/${String(i)}`, found);
+            });
+        }
+        if (typeof schema["minItems"] === "number" && value.length < schema["minItems"]) {
+            refuse("minItems", `the array holds ${String(value.length)} items, fewer than ${String(schema["minItems"])}`);
+        }
+        if (typeof schema["maxItems"] === "number" && value.length > schema["maxItems"]) {
+            refuse("maxItems", `the array holds ${String(value.length)} items, more than ${String(schema["maxItems"])}`);
+        }
+        if (schema["uniqueItems"] === true && new Set(value.map(canonical)).size !== value.length) {
+            refuse("uniqueItems", "the array lists one value twice");
+        }
+    }
+    checkApplicators(doc, schema, value, at, found, refuse) {
+        const list = (keyword) => Array.isArray(schema[keyword]) ? schema[keyword] : [];
+        for (const each of list("allOf")) {
+            this.check(doc, each, value, at, found);
+        }
+        const matching = (keyword) => list(keyword).filter((each) => this.matches(doc, each, value, at)).length;
+        if (schema["anyOf"] !== undefined && matching("anyOf") === 0) {
+            refuse("anyOf", "the value matches none of the alternatives");
+        }
+        if (schema["oneOf"] !== undefined && matching("oneOf") !== 1) {
+            refuse("oneOf", `the value matches ${String(matching("oneOf"))} of the alternatives, want exactly one`);
+        }
+        if (isObject(schema["not"]) && this.matches(doc, schema["not"], value, at)) {
+            refuse("not", "the value matches a schema it must not match");
+        }
+        if (isObject(schema["if"])) {
+            const branch = this.matches(doc, schema["if"], value, at) ? schema["then"] : schema["else"];
+            if (isObject(branch)) {
+                this.check(doc, branch, value, at, found);
+            }
+        }
+    }
+}
+/**
+ * A validator over one set of schema documents, each named as a `$ref` names it, rooted
+ * at one of them: what it refuses in a value, none for an instance.
+ */
+export function schemaRefusals(documents, root) {
+    const checker = new Checker(documents);
+    const top = documents[root];
+    if (top === undefined) {
+        throw new Error(`the schema set holds no document ${root}`);
+    }
+    return (value) => {
+        const found = [];
+        checker.check(root, top, value, "", found);
+        return found;
+    };
+}
+const reportSchema = schemaRefusals(REPORT_SCHEMAS, "report.schema.json");
+/**
+ * What the report schema refuses in one report document, none for an instance, and, as
+ * no schema keyword can state it, a components listing that is not one entry per
+ * component a finding or an edge evaluation's finding names.
+ */
+export function reportRefusals(document) {
+    const found = reportSchema(document);
+    return found.length > 0 ? found : listingRefusals(document);
+}
+/** The components listing held to the components the findings name, once each. */
+function listingRefusals(report) {
+    if (report.components === undefined) {
+        return [];
+    }
+    const refuse = (pointer, reason) => [
+        { pointer, keyword: "components", reason },
+    ];
+    const listed = new Set();
+    for (const [i, entry] of report.components.entries()) {
+        if (listed.has(entry.id)) {
+            return refuse(`/components/${String(i)}`, `the entry lists component ${entry.id} a second time`);
+        }
+        listed.add(entry.id);
+    }
+    const named = [
+        ...report.findings.map((finding, i) => [`/findings/${String(i)}`, finding.component.id]),
+        ...report.edge_evaluations.flatMap((one, i) => one.finding === undefined
+            ? []
+            : [[`/edge_evaluations/${String(i)}/finding`, one.finding.component.id]]),
+    ];
+    for (const [pointer, id] of named) {
+        if (!listed.has(id)) {
+            return refuse(pointer, `the finding names component ${id}, which the components listing lacks`);
+        }
+    }
+    const ids = new Set(named.map(([, id]) => id));
+    for (const [i, entry] of report.components.entries()) {
+        if (!ids.has(entry.id)) {
+            return refuse(`/components/${String(i)}`, `the entry lists component ${entry.id}, which no finding names`);
+        }
+    }
+    return [];
+}

package/dist/src/report.js

@@ -3,10 +3,7 @@
  * in the order its schema lists them, built from what one run answered. Every reporter
  * renders this document, so no two renderings disagree about which findings exist.
  */
-/** The version of the report schema this analyzer writes a report to. */
-const SCHEMA_VERSION = "9.0.0";
-/** Every report schema version this analyzer reads: the one the Contract it implements admits. */
-export const SCHEMA_VERSIONS_ACCEPTED = [SCHEMA_VERSION];
+import { SCHEMA_VERSION, SCHEMA_VERSIONS } from "./contract/contract.generated.js";
 /** The name this analyzer writes every document under and mints every identifier with. */
 export const ANALYZER_NAME = "deadset-ts";
 /** The language this analyzer claims. */
@@ -18,10 +15,13 @@ export const LANGUAGE = "ts";
  */
 function componentsOf(findings) {
     const listed = new Map();
-    for (const [wire, finding] of findings) {
+    for (const [written, finding] of findings) {
         const { members } = finding.component;
-        if (members !== undefined && !listed.has(wire.component.id)) {
-            listed.set(wire.component.id, { id: wire.component.id, members: members.map(wireSymbol) });
+        if (members !== undefined && !listed.has(written.component.id)) {
+            listed.set(written.component.id, {
+                id: written.component.id,
+                members: members.map(wireSymbol),
+            });
         }
     }
     return [...listed.values()];
@@ -228,7 +228,7 @@ export function buildReport(input) {
             name: ANALYZER_NAME,
             version: input.version,
             languages: [LANGUAGE],
-            schema_versions_accepted: SCHEMA_VERSIONS_ACCEPTED,
+            schema_versions_accepted: SCHEMA_VERSIONS,
             conformance: {
                 corpus_version: input.conformance.corpusVersion,
                 result: input.conformance.result,
@@ -298,16 +298,22 @@ export function sortFindings(report, by) {
     return { ...report, findings: [...report.findings].sort(by === "size" ? bySize : canonical) };
 }
 /**
- * The report holding the first `most` findings of its order, the rest counted as omitted.
- * Every other total keeps describing the whole set. Zero keeps every finding.
+ * The report holding the first `most` findings of its order, the rest counted as omitted,
+ * and listing only the components those findings name. Every other total keeps describing
+ * the whole set. Zero keeps every finding.
  */
 export function capFindings(report, most) {
     if (most <= 0 || report.findings.length <= most) {
         return report;
     }
+    const findings = report.findings.slice(0, most);
+    const named = new Set([...findings, ...report.edge_evaluations.flatMap((one) => one.finding ?? [])].map((finding) => finding.component.id));
     return {
         ...report,
-        findings: report.findings.slice(0, most),
+        findings,
+        ...(report.components === undefined
+            ? {}
+            : { components: report.components.filter((listed) => named.has(listed.id)) }),
         totals: { ...report.totals, omitted: report.findings.length - most },
     };
 }

package/dist/src/resolve.js

@@ -1,11 +1,10 @@
+import { SEVERITIES, LANGUAGES, CONFIDENCES, FORMATS, FAMILY_KEY_LENGTH, } from "./contract/contract.generated.js";
 import { ConfigError, defaultConfig, } from "./config.js";
 import { CONVENTION_ROWS } from "./convention-rows.js";
 import { FIXED_SEVERITY_CODES, LIVE_CODES } from "./kinds.js";
 import { checkDocument, malformed, nestFlags, SCHEMA_ROOT, SEVERITY_SECTION, } from "./schema.js";
 /** Names the command-line flags in a refusal, where a document is named by its path. */
 const FLAGS_LABEL = "the command-line flags";
-/** The length of a severity key naming a whole family: the prefix and two digits. */
-export const FAMILY_KEY_LENGTH = 4;
 const SEVERITY_KEY = /^DS[0-9]{2}([0-9]{2})?$/u;
 const EXEMPTION_CLASS = /^[a-z][a-z0-9-]*$/u;
 const CONTRACT_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/u;
@@ -30,12 +29,8 @@ const PROJECT_SEGMENT = String.raw `(?:[^/.\x00-\x1f\x7f][^/\x00-\x1f\x7f]*|\.[^
  */
 const PROJECT_PATH = new RegExp(`^${PROJECT_SEGMENT}(?:/${PROJECT_SEGMENT})*$`, "u");
 const TARGET_KINDS = ["application", "library"];
-const CONFIDENCES = ["certain", "probable", "possible"];
 const GENERATED_FILES = ["exclude", "include"];
 const CONSUMER_TESTS = ["test", "production"];
-const LANGUAGES = ["go", "ts"];
-const SEVERITIES = ["allow", "warn", "deny"];
-const FORMATS = ["text", "json", "github", "sarif", "template"];
 const SORTS = ["position", "size"];
 const CASCADES = ["roots", "full"];
 /**

package/dist/src/run.js

@@ -1,3 +1,4 @@
+import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.js";
 import { ConfigError, REPOSITORY_DOCUMENT } from "./config.js";
 import { DiscoveryError, renderDiagnostic } from "./discover.js";
 import { joinPath, resolvePath } from "./paths.js";
@@ -11,7 +12,7 @@ import { printRootsVerb } from "./verbs/print-roots.js";
 import { ANALYZE_OPTIONS, analyzeVerb } from "./verbs/analyze.js";
 import { describeVerb } from "./verbs/describe.js";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.js";
-import { EXIT_FAILURE, EXIT_USAGE } from "./verbs/verb.js";
+import {} from "./verbs/verb.js";
 import { versionVerb } from "./verbs/version.js";
 /** Every verb this command answers, in the order the usage text lists them. */
 const VERBS = [

package/dist/src/setup-failure.js

@@ -1,11 +1,7 @@
-/**
- * A setup failure: a file or a component the analysis needs and the project does not
- * provide. Each one names what is missing and the fix, on one line of the error stream
- * that starts with its class.
- */
+import { SETUP_FAILURE_PREFIX } from "./contract/contract.generated.js";
 /** The failure as the one line of the error stream that names it. */
 export function setupLine(failure) {
-    return `setup failure: ${failure.setupClass}: ${failure.detail}`;
+    return `${SETUP_FAILURE_PREFIX}${failure.setupClass}: ${failure.detail}`;
 }
 /**
  * A run that met a setup failure where none may be dropped: in a configuration the

package/dist/src/suppress-file.js

@@ -4,11 +4,12 @@
  * one record shape, so one decoder and one matcher serve both, and a row moves into the
  * ignore file by gaining a maintainer's reason.
  */
+import { CODE } from "./contract/contract.generated.js";
 import { jsonChunks } from "./json-chunks.js";
 import { joinPath } from "./paths.js";
 import { positionAt, walkDocument } from "./json-document.js";
 import { declarationKey } from "./ref.js";
-import { CODE_FORM, SUPPRESSION_WITHOUT_REASON, SuppressionError, UNSCOPED_ENTRY, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
+import { CODE_FORM, SuppressionError, blankReason, isEntryPath, isPartKind, isSymbolRef, siteText, } from "./suppress.js";
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
 /** The name and the location the grammar fixes for the baseline. */
@@ -99,10 +100,10 @@ function readRecord(value, site, byReference, shape) {
     };
     const refusals = [];
     if (blankReason(reason)) {
-        refusals.push({ ...written, reported: SUPPRESSION_WITHOUT_REASON });
+        refusals.push({ ...written, reported: CODE.suppressionWithoutReason });
     }
     if (written.path === "") {
-        refusals.push({ ...written, reported: UNSCOPED_ENTRY });
+        refusals.push({ ...written, reported: CODE.unscopedIgnoreEntry });
     }
     if (refusals.length > 0) {
         return { records: [], refusals };

package/dist/src/suppress-inline.js

@@ -3,13 +3,14 @@
  * one or more codes and a reason, and binding to every declaration that begins on the line
  * below it, or on its own line where it trails a token there.
  */
+import { CODE } from "./contract/contract.generated.js";
 import { isConstructorDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { importBindings } from "./import-bindings.js";
 import { isParameterProperty, nodeKey } from "./inventory.js";
 import { byPosition, positionKey, renderPosition } from "./position.js";
 import { importRef } from "./ref.js";
 import { signatureOf } from "./signatures.js";
-import { isPartKind, SUPPRESSION_WITHOUT_REASON, SuppressionError, siteText, } from "./suppress.js";
+import { isPartKind, SuppressionError, siteText, } from "./suppress.js";
 /**
  * The three expressions the grammar applies to the text of each line comment, in this
  * order: a comment in the namespace, a well-formed directive, and a directive that lacks
@@ -274,7 +275,7 @@ export function inlineSuppressions(perProject) {
             case "no-reason":
                 for (const code of directive.codes) {
                     refusals.push({
-                        reported: SUPPRESSION_WITHOUT_REASON,
+                        reported: CODE.suppressionWithoutReason,
                         code,
                         symbol: "",
                         path: site.path,

package/dist/src/suppress.js

@@ -6,15 +6,10 @@
  * withholds a finding its code would have produced there, dormant when the configuration
  * withholds every such finding anyway, and stale otherwise.
  */
+import { KIND_ROWS, SYMBOL_SUBJECTS, } from "./contract/contract.generated.js";
 import { ConfigError } from "./config.js";
 import { positionKey } from "./position.js";
 import { isRef } from "./ref.js";
-/** The code a suppression that carries no reason is reported under. */
-export const SUPPRESSION_WITHOUT_REASON = "DS1701";
-/** The code an ignore entry or a baseline row that names no path is reported under. */
-export const UNSCOPED_ENTRY = "DS1702";
-/** The code a suppression that withholds nothing is reported under. */
-export const STALE_SUPPRESSION = "DS1703";
 /**
  * A directive, an entry or a document the grammar refuses before any finding exists: an
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
@@ -71,73 +66,59 @@ export function isSymbolRef(value) {
 export function blankReason(reason) {
     return reason === undefined || /^[ \t\r\n]*$/u.test(reason);
 }
+/** The subject of the kind each live code names. */
+const SUBJECT_OF_CODE = new Map(KIND_ROWS.map((row) => [row.code, row.subject]));
+/** The subject a finding about one symbol kind is about. */
+function subjectOf(kind) {
+    return Object.hasOwn(SYMBOL_SUBJECTS, kind)
+        ? SYMBOL_SUBJECTS[kind]
+        : undefined;
+}
+/** Whether a subject is a row of a document rather than a declaration of the program. */
+function rowOf(subject) {
+    return subject === "file" || subject === "dependency" || subject === "record";
+}
 /**
- * The subject kinds that are a dependency row, each with the code that reports one. An
- * ignore entry or a baseline row naming the row's reference and file withholds its finding
- * and marks nothing, and an inline directive never binds one.
- */
-const DEPENDENCY_SUBJECTS = new Map([
-    ["dependency", ["DS1601"]],
-    ["module-directive", ["DS1605"]],
-]);
-/**
- * The subject kinds that are a row of a document rather than a declaration of the program,
- * each with the codes that report one. Apart from a dependency row, nothing withholds a
- * finding about one.
+ * Whether a finding's subject is a row of a document rather than a declaration. Apart
+ * from a dependency row, nothing withholds a finding about one.
  */
-const ROW_SUBJECTS = new Map([
-    ["file", ["DS1501", "DS1502"]],
-    ...DEPENDENCY_SUBJECTS,
-    ["root", ["DS1704"]],
-    ["configured-declaration", ["DS1706"]],
-    ["suppression", ["DS1701", "DS1702", "DS1703"]],
-    ["edge", ["DS1705"]],
-]);
-/** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind) {
-    return ROW_SUBJECTS.has(kind);
+    return rowOf(subjectOf(kind));
 }
 /** Whether a code reports a row of a document. */
 export function isRowCode(code) {
-    return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+    return rowOf(SUBJECT_OF_CODE.get(code));
 }
-/** Whether a finding's subject is a dependency row. */
+/**
+ * Whether a finding's subject is a dependency row. An ignore entry or a baseline row
+ * naming the row's reference and file withholds its finding and marks nothing, and an
+ * inline directive never binds one.
+ */
 export function isDependencySubject(kind) {
-    return DEPENDENCY_SUBJECTS.has(kind);
+    return subjectOf(kind) === "dependency";
 }
 /** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
 export function isDependencyCode(code) {
-    return [...DEPENDENCY_SUBJECTS.values()].some((codes) => codes.includes(code));
+    return SUBJECT_OF_CODE.get(code) === "dependency";
 }
 /** Whether a code reports a row of a document that no record of any mechanism can name. */
 export function isUnsuppressibleCode(code) {
     return isRowCode(code) && !isDependencyCode(code);
 }
 /**
- * The subject kinds that are a part of a declaration rather than a declaration: a part
+ * Whether a finding's subject is a part of the declaration its reference names: a part
  * has no reference of its own, so a finding about one names the declaration that holds
  * it, and the part is decided inside that declaration whatever uses it.
  */
-const PART_SUBJECTS = new Set([
-    "parameter",
-    "receiver",
-    "result",
-    "statement",
-    "case",
-    "store",
-]);
-/** Whether a finding's subject is a part of the declaration its reference names. */
 export function isPartSubject(kind) {
-    return PART_SUBJECTS.has(kind);
+    return subjectOf(kind) === "part";
 }
-/** The prefix of the codes of the part kinds, the intra-function range. */
-const PART_KIND_PREFIX = "DS18";
 /**
  * Whether a code is a part kind, whose record withholds its finding and marks nothing:
  * the record says the part is wanted, not that the declaration holding it is.
  */
 export function isPartKind(code) {
-    return code.startsWith(PART_KIND_PREFIX);
+    return SUBJECT_OF_CODE.get(code) === "part";
 }
 /** One finding's identity: its code and the position of the thing it names. */
 function claimKey(finding) {
@@ -155,12 +136,12 @@ export function pairs(record, finding) {
     if (record.code !== finding.code) {
         return false;
     }
-    if (DEPENDENCY_SUBJECTS.has(finding.symbol.kind)) {
+    if (isDependencySubject(finding.symbol.kind)) {
         return (record.mechanism !== "inline" &&
             record.symbol === finding.symbol.ref &&
             record.path === finding.position.path);
     }
-    if (ROW_SUBJECTS.has(finding.symbol.kind)) {
+    if (isRowSubject(finding.symbol.kind)) {
         return false;
     }
     if (record.bound !== "" && record.bound === positionKey(finding.position)) {

package/dist/src/verbs/analyze.js

@@ -1,3 +1,4 @@
+import { CONTRACT_VERSION, EXIT_CLEAN, EXIT_FAILURE, } from "../contract/contract.generated.js";
 import { runAnalysis, runBaselineWrite, unansweredCounts, } from "../analysis.js";
 import { ConfigError, kindOf } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
@@ -6,13 +7,13 @@ import { analyzerProvenance, verdictOf } from "../findings-pass.js";
 import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { partialNotes } from "../partial.js";
 import { buildReport, LANGUAGE, capFindings, sortFindings, } from "../report.js";
+import { reportRefusals } from "../report-schema.js";
 import { json } from "../reporters/json.js";
 import { RENDERINGS } from "../reporters/reporters.js";
 import { parseTemplate, TemplateError } from "../reporters/template.js";
 import { resolve } from "../resolve.js";
 import { otherSchemeRows, rowReason, writeBaseline } from "../suppress-file.js";
-import { CONTRACT_VERSION } from "../version.js";
-import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
+import {} from "./verb.js";
 /** The options `analyze` takes beside the ones every verb takes. */
 export const ANALYZE_OPTIONS = {
     plain: ["report", "baseline-write", "exit-code", "template"],
@@ -257,6 +258,10 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
         return EXIT_FAILURE;
     }
     try {
+        const [refused] = reportRefusals(report);
+        if (refused !== undefined) {
+            throw new Error(`the report breaks the report schema at ${refused.pointer || "the document"}: ${refused.keyword}: ${refused.reason}`);
+        }
         host.writeDocument(documents.report, json(report));
         const options = {
             readSource: (path) => host.readFile(joinPath(targetRoot, path)),

package/dist/src/verbs/describe.js

@@ -1,7 +1,7 @@
+import { CONTRACT_VERSION, EXIT_CLEAN, EXIT_FAILURE, EXIT_USAGE, SCHEMA_VERSIONS, } from "../contract/contract.generated.js";
 import { CONFORMANCE } from "../conformance.js";
-import { ANALYZER_NAME, LANGUAGE, SCHEMA_VERSIONS_ACCEPTED } from "../report.js";
-import { CONTRACT_VERSION } from "../version.js";
-import { EXIT_CLEAN, EXIT_FAILURE, EXIT_USAGE } from "./verb.js";
+import { ANALYZER_NAME, LANGUAGE } from "../report.js";
+import {} from "./verb.js";
 /**
  * The document `describe` writes: the analyzer, the Contract version it implements, the
  * report schema versions it reads, the languages it claims, and its recorded result over
@@ -12,7 +12,7 @@ export function describeDocument(version, recorded) {
         name: ANALYZER_NAME,
         version,
         contract_version: CONTRACT_VERSION,
-        schema_versions_accepted: SCHEMA_VERSIONS_ACCEPTED,
+        schema_versions_accepted: SCHEMA_VERSIONS,
         languages: [LANGUAGE],
         ...(recorded === undefined
             ? {}

package/dist/src/verbs/explain.js

@@ -1,3 +1,4 @@
+import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.js";
 import { runAnalysis } from "../analysis.js";
 import { listing } from "../components.js";
 import { ConfigError } from "../config.js";
@@ -7,7 +8,7 @@ import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
 import { positionKey } from "../position.js";
 import { resolve } from "../resolve.js";
-import { EXIT_CLEAN, EXIT_USAGE } from "./verb.js";
+import {} from "./verb.js";
 /**
  * The three spellings of an explanation request, each naming the symbol to explain. They are
  * one request, because exactly one state holds for a symbol and the answer is that state.

package/dist/src/verbs/print-config.js

@@ -1,6 +1,7 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.js";
 import { printConfig } from "../print.js";
 import { resolve } from "../resolve.js";
-import { EXIT_CLEAN } from "./verb.js";
+import {} from "./verb.js";
 /** Writes the resolved configuration with the source of every setting. */
 export const printConfigVerb = ({ out, inputs }) => {
     const { config, provenance } = resolve(inputs());