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

package/dist/src/position.js

@@ -1,4 +1,5 @@
 import { relativePath } from "./paths.js";
+import { bytewise } from "./text/compare.js";
 /**
  * A file the program holds whose path is not below the target root, which leaves
  * the analysis unable to name a declaration it found. It ends the run rather than
@@ -58,7 +59,7 @@ export function positionKey(position) {
  */
 export function byPosition(a, b) {
     if (a.path !== b.path) {
-        return a.path < b.path ? -1 : 1;
+        return bytewise(a.path, b.path);
     }
     if (a.line !== b.line) {
         return a.line - b.line;

package/dist/src/print.js

@@ -1,4 +1,5 @@
 import { renderOrigin, } from "./config.js";
+import { bytewise } from "./text/compare.js";
 /** One declaration entry as a document writes it: the members of its shape alone. */
 function declarationOf(entry) {
     switch (entry.shape) {
@@ -50,7 +51,7 @@ export function printConfig(config, provenance) {
         },
         consumers: { complete: config.consumersComplete },
         roots: { patterns: config.rootPatterns },
-        severity: Object.fromEntries([...config.severity].sort(([a], [b]) => (a < b ? -1 : 1))),
+        severity: Object.fromEntries([...config.severity].sort(([a], [b]) => bytewise(a, b))),
         exemptions: { disabled: config.exemptionsDisabled },
         reporters: {
             formats: config.reporters.formats,
@@ -76,7 +77,7 @@ export function printConfig(config, provenance) {
             roots_complete: config.ts.rootsComplete,
         },
         provenance: Object.fromEntries([...provenance]
-            .sort(([a], [b]) => (a < b ? -1 : 1))
+            .sort(([a], [b]) => bytewise(a, b))
             .map(([path, origin]) => [path, renderOrigin(origin)])),
     };
     return `${JSON.stringify(document, undefined, 2)}\n`;

package/dist/src/product.js

@@ -0,0 +1,13 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.js";
+/** The language this analyzer reads. */
+export const LANGUAGE = "ts";
+/** The analyzer's name: the one its language's row names, which every output spells it with. */
+export const PRODUCT = LANGUAGE_ROWS[LANGUAGE].analyzer;
+/** Writes one diagnostic line to the error stream, named for the analyzer. */
+export function diagnose(err, text) {
+    err.write(`${PRODUCT}: ${text}\n`);
+}
+/** The text one thrown value carries. */
+export function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/references.js

@@ -1,10 +1,10 @@
 import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isMetaProperty, isModuleBlock, isModuleDeclaration, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
+import { parenthesesRemoved } from "./unwrap.js";
 import { aliasChains } from "./alias-chain.js";
 import { contextualUses } from "./contextual-uses.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { specifierCandidates } from "./configuration-files.js";
 import { namespaceUses } from "./namespace-objects.js";
-import { globExpression } from "./glob.js";
 import { declarationsByName, isParameterProperty, nodeKey, } from "./inventory.js";
 import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
@@ -20,6 +20,8 @@ import { typeParameterReads } from "./type-parameter-reads.js";
 import { typeQueryAliases } from "./type-query-alias.js";
 import { computedKeyNames, iterationReferences, keyNameOf, keyedUses, } from "./symbol-keys.js";
 import { handedOn, valuesOf } from "./value-flow.js";
+import { bytewise } from "./text/compare.js";
+import { globExpression } from "./text/glob.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
  * among them: where its value is discarded it reads its target only to write the result
@@ -77,14 +79,6 @@ function valueDiscarded(node) {
 function isName(node) {
     return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateIdentifier;
 }
-/** The expression one node is, through however many parentheses are written around it. */
-function unparenthesized(node) {
-    let held = node;
-    while (isParenthesizedExpression(held)) {
-        held = held.expression;
-    }
-    return held;
-}
 /**
  * Records the name one store writes into.
  *
@@ -94,7 +88,7 @@ function unparenthesized(node) {
  * target writes each name it binds, through its spreads and nested patterns.
  */
 function markWrite(target, writes, accesses) {
-    const held = unparenthesized(target);
+    const held = parenthesesRemoved(target);
     if (isName(held)) {
         writes.add(held.pos);
         return;
@@ -109,7 +103,7 @@ function markWrite(target, writes, accesses) {
         accesses.add(held);
         // A store through a member's value lands in storage every holder of the value
         // reads, so it reads the member; a variable only ever stored into stays written.
-        if (!isPropertyAccessExpression(unparenthesized(held.expression))) {
+        if (!isPropertyAccessExpression(parenthesesRemoved(held.expression))) {
             markWrite(held.expression, writes, accesses);
         }
         return;
@@ -181,7 +175,7 @@ function markStores(node, writes, reads, accesses) {
 }
 /** Whether one node is `import.meta.url`. */
 function isImportMetaURL(node) {
-    const at = unparenthesized(node);
+    const at = parenthesesRemoved(node);
     return (isPropertyAccessExpression(at) &&
         isMetaProperty(at.expression) &&
         at.expression.keywordToken === SyntaxKind.ImportKeyword &&
@@ -190,7 +184,7 @@ function isImportMetaURL(node) {
 /** The module URL one node builds, where it builds one. */
 function moduleURLOf(node) {
     const relative = (argument) => {
-        const at = argument === undefined ? undefined : unparenthesized(argument);
+        const at = argument === undefined ? undefined : parenthesesRemoved(argument);
         return at !== undefined &&
             (isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at)) &&
             /^\.\.?\//u.test(at.text)
@@ -205,7 +199,7 @@ function moduleURLOf(node) {
             : undefined;
     }
     if (isCallExpression(node)) {
-        const callee = unparenthesized(node.expression);
+        const callee = parenthesesRemoved(node.expression);
         const specifier = relative(node.arguments[0]);
         if (specifier !== undefined &&
             isPropertyAccessExpression(callee) &&
@@ -490,7 +484,7 @@ export function testFileRulesOf(testFiles, paths, supportFiles = []) {
             };
         }),
         ...(support === 0 ? [] : [{ rule: TEST_SUPPORT_RULE, matched: support }]),
-    ].sort((a, b) => compare(a.rule, b.rule));
+    ].sort((a, b) => bytewise(a.rule, b.rule));
 }
 const importedCache = new WeakMap();
 /**
@@ -609,20 +603,13 @@ function aloneIn(file, uses, writes, found) {
             .filter(([, nodes]) => nodes.some((node) => inside(node, write.value)) &&
             nodes.every((node) => sameTarget.some((one) => inside(node, one.value))))
             .map(([name]) => name)
-            .sort(compare);
+            .sort(bytewise);
         if (names.length > 0) {
             result.push({ index: write.index, names });
         }
     }
     return result;
 }
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 /**
  * Every reference one project's own files make to the project's own declarations, in
  * position order, and the files the test-file rules classified.
@@ -1192,14 +1179,14 @@ export function references(project, held, targetRoot, options) {
     const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
     found.push(...augmentationReferences(held, found, scripts, libraryMerged(scripts)));
     found.sort((a, b) => byPosition(a.position, b.position) ||
-        compare(a.to, b.to) ||
-        compare(a.from, b.from) ||
-        compare(a.use, b.use));
+        bytewise(a.to, b.to) ||
+        bytewise(a.from, b.from) ||
+        bytewise(a.use, b.use));
     return {
         references: consumer === undefined
             ? found
             : found.map((reference) => ({ ...reference, consumer: consumer.id })),
-        testFilePaths: tests.sort(compare),
+        testFilePaths: tests.sort(bytewise),
         cost: {
             batched,
             fileBatches,

package/dist/src/report-schema.js

@@ -0,0 +1,272 @@
+/**
+ * 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";
+import { bytewise } from "./text/compare.js";
+import { isRecord } from "./json-document.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 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 (isRecord(value)) {
+        return `{${Object.keys(value)
+            .sort(bytewise)
+            .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 = isRecord(schema)
+                ? schema[token.replaceAll("~1", "/").replaceAll("~0", "~")]
+                : undefined;
+        }
+        if (!isRecord(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 (isRecord(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 = isRecord(schema["properties"]) ? schema["properties"] : {};
+        const additional = schema["additionalProperties"];
+        for (const name of Object.keys(value).sort(bytewise)) {
+            const member = `${at}/${escape(name)}`;
+            const declared = properties[name];
+            if (isRecord(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 (isRecord(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 (isRecord(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 (isRecord(schema["not"]) && this.matches(doc, schema["not"], value, at)) {
+            refuse("not", "the value matches a schema it must not match");
+        }
+        if (isRecord(schema["if"])) {
+            const branch = this.matches(doc, schema["if"], value, at) ? schema["then"] : schema["else"];
+            if (isRecord(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,14 +3,9 @@
  * 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];
-/** The name this analyzer writes every document under and mints every identifier with. */
-export const ANALYZER_NAME = "deadset-ts";
-/** The language this analyzer claims. */
-export const LANGUAGE = "ts";
+import { SCHEMA_VERSION, SCHEMA_VERSIONS } from "./contract/contract.generated.js";
+import { bytewise } from "./text/compare.js";
+import { LANGUAGE, PRODUCT } from "./product.js";
 /**
  * Each component the findings name, once, with the members the first finding naming it
  * carries, in the order the findings are: `findings` paired with their wire forms and
@@ -18,21 +13,17 @@ 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()];
 }
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
 function wirePosition(position) {
     return {
         path: position.path,
@@ -140,19 +131,19 @@ function wireStale(stale) {
 }
 /** The canonical key over two findings: path, line, column, code, then the symbol reference. */
 function canonical(a, b) {
-    return (compare(a.position.path, b.position.path) ||
+    return (bytewise(a.position.path, b.position.path) ||
         a.position.line - b.position.line ||
         a.position.column - b.position.column ||
-        compare(a.code, b.code) ||
-        compare(a.symbol.ref, b.symbol.ref));
+        bytewise(a.code, b.code) ||
+        bytewise(a.symbol.ref, b.symbol.ref));
 }
 /** The canonical key over two stale suppressions, each component from the record's own member. */
 function canonicalStale(a, b) {
-    return (compare(a.position.path, b.position.path) ||
+    return (bytewise(a.position.path, b.position.path) ||
         a.position.line - b.position.line ||
         a.position.column - b.position.column ||
-        compare(a.code, b.code) ||
-        compare(a.symbol, b.symbol));
+        bytewise(a.code, b.code) ||
+        bytewise(a.symbol, b.symbol));
 }
 /** One declared gap as a report carries it, its members in the schema's order. */
 function wireGap(gap) {
@@ -165,9 +156,9 @@ function wireGap(gap) {
 }
 /** Edge evaluations by edge, then side, then their compact encodings. */
 function byEdge(a, b) {
-    return (compare(a.edge, b.edge) ||
-        compare(a.side, b.side) ||
-        compare(JSON.stringify(a), JSON.stringify(b)));
+    return (bytewise(a.edge, b.edge) ||
+        bytewise(a.side, b.side) ||
+        bytewise(JSON.stringify(a), JSON.stringify(b)));
 }
 /**
  * The lines a reader deletes by acting on every finding: each distinct component a root
@@ -216,19 +207,19 @@ export function buildReport(input) {
     const findings = paired.map(([wire]) => wire);
     const evaluated = input.result.edgeEvaluations.flatMap((one) => one.finding === undefined ? [] : [[wireFinding(one.finding), one.finding]]);
     const unavailable = [...new Map(input.unavailable.map((one) => [one.id, one])).values()]
-        .sort((a, b) => compare(a.id, b.id))
+        .sort((a, b) => bytewise(a.id, b.id))
         .map((one) => ({ id: one.id, role: "consumer", reason: one.reason }));
     const loaded = [...input.loaded]
-        .sort((a, b) => compare(a.id, b.id) || compare(a.path, b.path))
+        .sort((a, b) => bytewise(a.id, b.id) || bytewise(a.path, b.path))
         .map((one) => ({ id: one.id, role: "consumer", path: one.path }));
     return {
         schema_version: SCHEMA_VERSION,
         contract_version: input.contractVersion,
         analyzer: {
-            name: ANALYZER_NAME,
+            name: PRODUCT,
             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,
@@ -237,10 +228,10 @@ export function buildReport(input) {
         },
         target: { kind: input.target.kind, root: input.target.root, identity: input.target.identity },
         configurations: [...input.configurations]
-            .sort((a, b) => compare(a.id, b.id))
+            .sort((a, b) => bytewise(a.id, b.id))
             .map((one) => ({ id: one.id, project: one.project })),
         configurations_not_built: [...input.notBuilt]
-            .sort((a, b) => compare(a.id, b.id))
+            .sort((a, b) => bytewise(a.id, b.id))
             .map((one) => ({ id: one.id, project: one.project, error: one.error })),
         consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
         findings,
@@ -253,10 +244,10 @@ export function buildReport(input) {
         // name, so the compact encodings alone order them.
         declared_gaps: input.declaredGaps
             .map(wireGap)
-            .sort((a, b) => compare(JSON.stringify(a), JSON.stringify(b))),
+            .sort((a, b) => bytewise(JSON.stringify(a), JSON.stringify(b))),
         excluded_by_cgo: [],
         test_file_rules: [...input.testFileRules]
-            .sort((a, b) => compare(a.rule, b.rule) || a.matched - b.matched)
+            .sort((a, b) => bytewise(a.rule, b.rule) || a.matched - b.matched)
             .map((one) => ({ rule: one.rule, matched: one.matched })),
         type_error_skips: [
             ...new Map(input.typeErrorSkips.map((one) => {
@@ -264,14 +255,14 @@ export function buildReport(input) {
                 return [JSON.stringify(skip), skip];
             })),
         ]
-            .sort(([a, x], [b, y]) => compare(x.path, y.path) || x.line - y.line || compare(a, b))
+            .sort(([a, x], [b, y]) => bytewise(x.path, y.path) || x.line - y.line || bytewise(a, b))
             .map(([, skip]) => skip),
         notes: [...new Map((input.notes ?? []).map((one) => [JSON.stringify(one), one])).entries()]
-            .sort(([a, x], [b, y]) => compare(x.kind, y.kind) || compare(x.path, y.path) || compare(a, b))
+            .sort(([a, x], [b, y]) => bytewise(x.kind, y.kind) || bytewise(x.path, y.path) || bytewise(a, b))
             .map(([, note]) => note),
         unanswered_questions: [...input.unanswered]
-            .sort((a, b) => compare(a.configuration, b.configuration) ||
-            compare(JSON.stringify(a), JSON.stringify(b)))
+            .sort((a, b) => bytewise(a.configuration, b.configuration) ||
+            bytewise(JSON.stringify(a), JSON.stringify(b)))
             .map((one) => ({
             configuration: one.configuration,
             questions: one.questions,
@@ -298,16 +289,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/reporters/sarif.js

@@ -5,6 +5,8 @@ import { lineHashes, symbolFingerprint } from "./fingerprint.js";
 import { RenderError } from "./reporter.js";
 import { utf8Bytes } from "./sha256.js";
 import { withheldLine } from "./text.js";
+import { bytewise } from "../text/compare.js";
+import { message } from "../product.js";
 const SCHEMA = "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";
 const VERSION = "2.1.0";
 /** The unit a finding's column counts. */
@@ -101,7 +103,7 @@ function lineHashCache(read) {
                 text = read(at.path);
             }
             catch (error) {
-                throw new RenderError(`read ${at.path} for its line fingerprint: ${error instanceof Error ? error.message : String(error)}`);
+                throw new RenderError(`read ${at.path} for its line fingerprint: ${message(error)}`);
             }
             hashes = lineHashes(text);
             held.set(at.path, hashes);
@@ -226,7 +228,7 @@ export function sarif(report, options) {
         ...report.findings.map((found) => findingResult(found, index, hashOf, members)),
         ...report.stale_suppressions.map((stale) => staleResult(stale, index, hashOf)),
     ];
-    const languages = [...report.analyzer.languages].sort().join("+");
+    const languages = [...report.analyzer.languages].sort(bytewise).join("+");
     const withheld = withheldLine(report.totals);
     const log = {
         $schema: SCHEMA,