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

package/dist/src/paths.js

@@ -1,11 +1,7 @@
 /**
- * Filesystem paths, as the supported platform spells them: a solidus separates
- * segments and a leading solidus makes a path absolute.
- *
- * They are written here rather than taken from the platform's own library because
- * every module below the command line stays free of the platform, and because the
- * supported platform set is one, so a second spelling would be a rule nothing
- * exercises.
+ * Filesystem paths as the supported platform spells them: a solidus between segments, a
+ * leading one for an absolute path. They are written here rather than taken from the
+ * platform's library so every module below the command line stays free of the platform.
  */
 const SEPARATOR = "/";
 /** Whether one path names a place without a directory to resolve it against. */
@@ -61,6 +57,24 @@ export function dirnamePath(path) {
     }
     return cut === 0 ? SEPARATOR : normalized.slice(0, cut);
 }
+/**
+ * `dir` and every directory above it, nearest first, normalized. With `top`, the list ends
+ * at `top` and is empty where `dir` is neither `top` nor below it; without, it ends at the
+ * root of the path.
+ */
+export function ancestors(dir, top) {
+    const end = top === undefined ? undefined : normalizePath(top);
+    const found = [];
+    for (let at = normalizePath(dir);; at = dirnamePath(at)) {
+        if (end !== undefined && at !== end && relativePath(end, at) === undefined) {
+            return [];
+        }
+        found.push(at);
+        if (at === end || dirnamePath(at) === at) {
+            return found;
+        }
+    }
+}
 /**
  * The extension of one path's last segment, from its last full stop, or the empty string
  * where it has none. A segment that only starts with a full stop has none.
@@ -92,14 +106,11 @@ export function queriedModulePath(specifier) {
     return raw ? undefined : specifier.slice(0, query);
 }
 /**
- * One path as it reads below a root, or undefined when it is not below the root.
- * Both are normalized first, so a root written with a trailing separator or a `.`
- * segment reaches the same answer, and the comparison is then lexical, so a root
- * and a path spelled through different symbolic links name nothing in common. The
- * root itself is not below itself.
- *
- * The caller resolves both against the same directory before calling: a relative
- * root and an absolute path are two spellings this cannot reconcile.
+ * One path as it reads below a root, or undefined when it is not strictly below the root:
+ * the root itself is not below itself. Both are normalized, then compared lexically, so a
+ * root and a path spelled through different symbolic links name nothing in common. The
+ * caller resolves both against the same directory first: a relative root and an absolute
+ * path cannot be reconciled.
  */
 export function relativePath(root, path) {
     const at = normalizePath(root);

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,83 +1,15 @@
-import { renderOrigin, } from "./config.js";
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry) {
-    switch (entry.shape) {
-        case "symbol":
-            return { symbol: entry.symbol };
-        case "module":
-            return { module: entry.module, name: entry.name };
-        case "global":
-            return { global: entry.global };
-    }
-}
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry) {
-    const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-    if (entry.shape === "installed") {
-        return installed;
-    }
-    return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
+import { renderOrigin } from "./config.js";
+import { bytewise } from "./text/compare.js";
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
 export function printConfig(config, provenance) {
-    const document = {
-        contract_version: config.contractVersion,
-        target: { kind: config.targetKind },
-        analysis: {
-            languages: config.analysis.languages,
-            min_confidence: config.analysis.minConfidence,
-            generated_files: config.analysis.generatedFiles,
-            consumer_tests: config.analysis.consumerTests,
-            configurations: config.analysis.configurations.map((entry) => entry.shape === "project"
-                ? { id: entry.id, project: entry.project }
-                : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags }),
-            matrix: { complete: config.analysis.matrixComplete },
-            template_dirs: config.analysis.templateDirs,
-            template_delimiters: {
-                left: config.analysis.templateDelimiters.left,
-                right: config.analysis.templateDelimiters.right,
-            },
-        },
-        consumers: { complete: config.consumersComplete },
-        roots: { patterns: config.rootPatterns },
-        severity: Object.fromEntries([...config.severity].sort(([a], [b]) => (a < b ? -1 : 1))),
-        exemptions: { disabled: config.exemptionsDisabled },
-        reporters: {
-            formats: config.reporters.formats,
-            sort: config.reporters.sort,
-            cascade: config.reporters.cascade,
-            max_findings: config.reporters.maxFindings,
-            fail_on: config.reporters.failOn,
-        },
-        providers: { analyzers: config.providers.analyzers.map(providerOf) },
-        go: {},
-        ts: {
-            test_files: config.ts.testFiles,
-            entry_files: config.ts.entryFiles,
-            component_extensions: config.ts.componentExtensions,
-            disabled_conventions: config.ts.disabledConventions,
-            injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-            lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-                components: entry.components.map(declarationOf),
-                bases: entry.bases.map(declarationOf),
-                members: entry.members,
-            })),
-            serializers: config.ts.serializers.map(declarationOf),
-            roots_complete: config.ts.rootsComplete,
-        },
-        provenance: Object.fromEntries([...provenance]
-            .sort(([a], [b]) => (a < b ? -1 : 1))
-            .map(([path, origin]) => [path, renderOrigin(origin)])),
-    };
-    return `${JSON.stringify(document, undefined, 2)}\n`;
+    const origins = [...provenance]
+        .sort(([a], [b]) => bytewise(a, b))
+        .map(([path, origin]) => [path, renderOrigin(origin)]);
+    return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, 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/query.js

@@ -220,6 +220,7 @@ export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
         symbolOfType: (type) => one("getSymbol", () => typeLocation(type), () => type.getSymbol()),
         signaturesOf: (type, kind) => one("getSignaturesOfType", () => typeLocation(type), () => checker.getSignaturesOfType(type, kind)),
         resolvedSignature: (node) => one("getResolvedSignature", () => nodeLocation(node), () => checker.getResolvedSignature(node)),
+        resolvedSignatures: (nodes, cap = DEFAULT_BATCH_CAP) => each("getResolvedSignature", nodes, cap, nodeLocation, (node) => checker.getResolvedSignature.gen(node), (node) => checker.getResolvedSignature(node)),
         parameterType: (signature, index) => one("getParameterType", () => `signature ${String(signature.id)} parameter ${String(index)}`, () => checker.getParameterType(signature, index)),
         genericOf: (signature) => signature.target === undefined
             ? undefined

package/dist/src/ref.js

@@ -48,6 +48,7 @@ export const REF_EXPRESSIONS = [
     `^${SCOPE}#${TS_HEAD}:import$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+:static$`,
+    `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})+\\.${TS_QUOTED}:case$`,
     `^${SCOPE}#${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?<${TS_IDENT}>$`,
     `^${SCOPE}#(?:${TS_HEAD}(?:\\.${TS_MEMBER})*(?::static)?)?\\(${TS_IDENT}\\)$`,
     `^${MANIFEST_SCOPE}#${TS_PACKAGE}:(?:dependency|dev-dependency|peer-dependency)$`,

package/dist/src/references.js

@@ -1,12 +1,12 @@
-import { isArrayLiteralExpression, isAsExpression, isBinaryExpression, isCallExpression, isDecorator, isDeleteExpression, isElementAccessExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isForInStatement, isForOfStatement, isForStatement, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNewExpression, isNamespaceExport, isNoSubstitutionTemplateLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVoidExpression, SyntaxKind, } from "@typescript/native/ast";
+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 { augmentationReferences } from "./augmentations.js";
+import { ambientGlobalInterfaces, augmentationReferences } from "./augmentations.js";
 import { elementAccessReferences } from "./element-access.js";
 import { indexedAccessReferences } from "./indexed-access.js";
 import { keyofComparisonReferences } from "./keyof-comparisons.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.
@@ -1135,6 +1122,37 @@ export function references(project, held, targetRoot, options) {
             }
         }
     }
+    /** The ambient global interfaces of the walked files that merge into a declaration outside the project's own files. */
+    const libraryMerged = (scripts) => {
+        const names = new Map();
+        const visit = (node) => {
+            if (isInterfaceDeclaration(node)) {
+                const id = declaredAt(node);
+                if (id !== undefined) {
+                    names.set(id, node.name);
+                }
+            }
+            else if (isModuleDeclaration(node) || isModuleBlock(node)) {
+                node.forEachChild(visit);
+            }
+        };
+        for (const { file } of walked) {
+            file.forEachChild(visit);
+        }
+        const global = new Set(ambientGlobalInterfaces(held, [...names.keys()], scripts));
+        const asked = [...names].filter(([id]) => global.has(id));
+        if (asked.length === 0) {
+            return new Set();
+        }
+        const answers = project.symbolsAt(asked.map(([, name]) => project.handle(name)));
+        return new Set(asked.flatMap(([id], at) => {
+            const symbol = answers[at];
+            return typeof symbol === "object" &&
+                symbol.declarations.some((handle) => !ownPaths.has(handle.path))
+                ? [id]
+                : [];
+        }));
+    };
     const usesOf = new Map(walked.map((one) => [one.file, one.uses]));
     for (const [file, writes] of valued) {
         const uses = usesOf.get(file) ?? [];
@@ -1159,16 +1177,16 @@ export function references(project, held, targetRoot, options) {
         typedLookups = (options.requestCount?.() ?? 0) - before;
     }
     const scripts = new Set(walked.filter((one) => one.file.externalModuleIndicator === undefined).map((one) => one.fileId));
-    found.push(...augmentationReferences(held, found, scripts));
+    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,51 @@
+/**
+ * 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.
+ */
+import { REPORT_SCHEMAS } from "./contract/report.generated.js";
+import { schemaRefusals } from "./schema.js";
+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, member: "" },
+    ];
+    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,20 +3,26 @@
  * 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";
-/** Two strings ordered bytewise. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
+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
+ * sorted, then the edge evaluations' findings.
+ */
+function componentsOf(findings) {
+    const listed = new Map();
+    for (const [written, finding] of findings) {
+        const { members } = finding.component;
+        if (members !== undefined && !listed.has(written.component.id)) {
+            listed.set(written.component.id, {
+                id: written.component.id,
+                members: members.map(wireSymbol),
+            });
+        }
     }
-    return a < b ? -1 : 1;
+    return [...listed.values()];
 }
 function wirePosition(position) {
     return {
@@ -85,9 +91,6 @@ export function wireFinding(finding) {
             root: finding.component.root,
             symbol_count: finding.component.symbolCount,
             deletable_lines: finding.component.deletableLines,
-            ...(finding.component.members === undefined
-                ? {}
-                : { members: finding.component.members.map(wireSymbol) }),
         },
         retained_by: finding.retainedBy,
         configurations: finding.configurations,
@@ -128,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) {
@@ -153,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
@@ -198,21 +201,25 @@ function totalsOf(findings, result) {
 }
 /** Builds the report of one run, every array in the order the Contract fixes for it. */
 export function buildReport(input) {
-    const findings = input.result.findings.map(wireFinding).sort(canonical);
+    const paired = input.result.findings
+        .map((finding) => [wireFinding(finding), finding])
+        .sort(([a], [b]) => canonical(a, b));
+    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,
@@ -221,23 +228,26 @@ 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,
+        ...(input.listsComponents === true
+            ? { components: componentsOf([...paired, ...evaluated]) }
+            : {}),
         edge_evaluations: input.result.edgeEvaluations.map(wireEvaluation).sort(byEdge),
         stale_suppressions: input.result.staleSuppressions.map(wireStale).sort(canonicalStale),
         // Every gap shares the one component of the canonical key a gap supplies, the analyzer's
         // 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) => {
@@ -245,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,
@@ -279,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 },
     };
 }