@cplieger/deadset-ts 3.12.1 → 4.0.0

package/dist/src/query.js

@@ -0,0 +1,207 @@
+/**
+ * The one way the analysis asks a project's checker anything. A question the compiler
+ * server panics on answers {@link UNANSWERED}, and a batch it panics on whole is asked
+ * again one question at a time; every caller reads an unanswered question as keeping a
+ * declaration live, and each is recorded once so a run can say where it was partial.
+ * Questions of one accessor about many locations go out together, through the array
+ * form where it has one and otherwise as one batch, one round trip per capped run.
+ */
+import { isIdentifier } from "@typescript/native/unstable/ast";
+/**
+ * The greatest number of locations one batched request asks about. A batch is
+ * answered by an array of its own length, so an uncapped batch over a large file
+ * makes one answer proportional to that file. The figure bounds the size of one
+ * answer rather than the work: the median file is one batch at this cap and the
+ * largest production file a handful.
+ */
+export const DEFAULT_BATCH_CAP = 4096;
+/** The answer to a question the checker could not answer. */
+export const UNANSWERED = Symbol("unanswered");
+/** Whether one answer is an answer. */
+export function isAnswered(answer) {
+    return answer !== UNANSWERED;
+}
+/**
+ * The stop a pass raises where it cannot go on without an answer the checker did not
+ * give. Whoever runs the pass catches it and keeps live everything the pass could
+ * have kept live, so a pass that throws it never computes a finding from the gap.
+ */
+export class Unanswerable extends Error {
+    constructor() {
+        super("the checker did not answer a question this pass needs");
+        this.name = "Unanswerable";
+    }
+}
+/** The answer itself, or the stop of a pass that cannot go on without it. */
+export function must(answer) {
+    if (answer === UNANSWERED) {
+        throw new Unanswerable();
+    }
+    return answer;
+}
+/**
+ * Whether one failure is the server's report that a question panicked. The server
+ * recovers the panic and answers the question with its text, so the session
+ * survives it; any other failure, a closed channel among them, is not one this layer
+ * contains.
+ */
+function panicked(error) {
+    return error instanceof Error && error.message.startsWith("panic:");
+}
+const ASK_DIRECTLY = (_accessor, _locations, question) => question();
+/** What one run could not ask, each question once. */
+export class UnansweredLog {
+    #seen = new Map();
+    /** Records one question, once however many times it is asked. */
+    note(question) {
+        const key = [question.configFile, question.accessor, question.location].join("\u0000");
+        if (!this.#seen.has(key)) {
+            this.#seen.set(key, question);
+        }
+    }
+    /** Every question recorded, in the order first asked. */
+    get questions() {
+        return [...this.#seen.values()];
+    }
+}
+function nodeLocation(node) {
+    return `${node.getSourceFile().fileName}:${String(node.pos)}`;
+}
+function symbolLocation(symbol) {
+    return `symbol ${String(symbol.id)} ${symbol.name}`;
+}
+function typeLocation(type) {
+    return `type ${String(type.id)}`;
+}
+/**
+ * The guarded questions over one project's checker. `configFile` names the project
+ * in the log, `batch` sends many questions in one round trip, `log` is the run's,
+ * shared by every project, and every question is put through `ask`.
+ */
+export function queriesOf(checker, configFile, batch, log, ask = ASK_DIRECTLY) {
+    const note = (accessor, location) => {
+        log.note({ configFile, accessor, location });
+    };
+    const one = (accessor, location, question) => {
+        try {
+            return ask(accessor, () => [location()], question);
+        }
+        catch (error) {
+            if (!panicked(error)) {
+                throw error;
+            }
+            note(accessor, location());
+            return UNANSWERED;
+        }
+    };
+    /**
+     * One question per item of `items`, in runs of at most `cap`, each run in one
+     * round trip. A run fails as a whole only where the server panics outside any one
+     * question, and is then asked one question at a time.
+     */
+    const each = (accessor, items, cap, locate, question, alone) => {
+        function* guarded(item) {
+            try {
+                return yield* ask(accessor, () => [locate(item)], () => question(item));
+            }
+            catch (error) {
+                if (!panicked(error)) {
+                    throw error;
+                }
+                note(accessor, locate(item));
+                return UNANSWERED;
+            }
+        }
+        const answers = [];
+        for (let from = 0; from < items.length; from += cap) {
+            const run = items.slice(from, from + cap);
+            try {
+                answers.push(...batch(run.map(guarded)));
+            }
+            catch (error) {
+                if (!panicked(error)) {
+                    throw error;
+                }
+                answers.push(...run.map((item) => one(accessor, () => locate(item), () => alone(item))));
+            }
+        }
+        return answers;
+    };
+    /**
+     * One accessor's array form over `items`, in runs of at most `cap`. A run the server
+     * panics on is asked again as two halves, down to one item, so the items it can
+     * answer are answered and only an item that panics alone is unanswered.
+     */
+    const many = (accessor, items, cap, locate, question) => {
+        const answers = [];
+        const settle = (run) => {
+            try {
+                answers.push(...ask(accessor, () => run.map(locate), () => question(run)));
+                return;
+            }
+            catch (error) {
+                if (!panicked(error)) {
+                    throw error;
+                }
+            }
+            const [only] = run;
+            if (run.length === 1 && only !== undefined) {
+                note(accessor, locate(only));
+                answers.push(UNANSWERED);
+                return;
+            }
+            const half = Math.ceil(run.length / 2);
+            settle(run.slice(0, half));
+            settle(run.slice(half));
+        };
+        for (let from = 0; from < items.length; from += cap) {
+            settle(items.slice(from, from + cap));
+        }
+        return answers;
+    };
+    return {
+        symbolsAt: (nodes, cap = DEFAULT_BATCH_CAP) => many("getSymbolAtLocation", nodes, cap, nodeLocation, (run) => checker.getSymbolAtLocation(run)),
+        resolvedSymbol: (node) => isIdentifier(node)
+            ? one("getResolvedSymbol", () => nodeLocation(node), () => checker.getResolvedSymbol(node))
+            : undefined,
+        shorthandValue: (node) => one("getShorthandAssignmentValueSymbol", () => nodeLocation(node), () => checker.getShorthandAssignmentValueSymbol(node)),
+        immediateAliased: (symbol) => one("getImmediateAliasedSymbol", () => symbolLocation(symbol), () => checker.getImmediateAliasedSymbol(symbol)),
+        aliased: (symbol) => one("getAliasedSymbol", () => symbolLocation(symbol), () => checker.getAliasedSymbol(symbol)),
+        resolveName: (name, meaning, location, excludeGlobals) => one("resolveName", () => (location === undefined ? `name ${name}` : nodeLocation(location)), () => checker.resolveName(name, meaning, location, excludeGlobals)),
+        exportsOfModule: (module) => one("getExportsOfModule", () => symbolLocation(module), () => checker.getExportsOfModule(module)),
+        membersOf: (symbol) => one("getMembers", () => symbolLocation(symbol), () => symbol.getMembers()),
+        exportsOf: (symbol) => one("getExports", () => symbolLocation(symbol), () => symbol.getExports()),
+        parentOf: (symbol) => one("getParent", () => symbolLocation(symbol), () => symbol.getParent()),
+        jsDocTags: (symbols, cap = DEFAULT_BATCH_CAP) => each("getJsDocTags", symbols, cap, symbolLocation, (symbol) => symbol.getJsDocTags.gen(checker), (symbol) => symbol.getJsDocTags(checker)),
+        typesAt: (nodes, cap = DEFAULT_BATCH_CAP) => many("getTypeAtLocation", nodes, cap, nodeLocation, (run) => checker.getTypeAtLocation(run)),
+        typeAt: (node) => one("getTypeAtLocation", () => nodeLocation(node), () => checker.getTypeAtLocation(node)),
+        typesOfSymbols: (symbols, cap = DEFAULT_BATCH_CAP) => many("getTypeOfSymbol", symbols, cap, symbolLocation, (run) => checker.getTypeOfSymbol(run)),
+        typeOfSymbol: (symbol) => one("getTypeOfSymbol", () => symbolLocation(symbol), () => checker.getTypeOfSymbol(symbol)),
+        declaredTypeOf: (symbol) => one("getDeclaredTypeOfSymbol", () => symbolLocation(symbol), () => checker.getDeclaredTypeOfSymbol(symbol)),
+        contextualTypes: (nodes, cap = DEFAULT_BATCH_CAP) => each("getContextualType", nodes, cap, nodeLocation, (node) => checker.getContextualType.gen(node), (node) => checker.getContextualType(node)),
+        propertiesOf: (type) => one("getPropertiesOfType", () => typeLocation(type), () => checker.getPropertiesOfType(type)),
+        indexInfosOf: (type) => one("getIndexInfosOfType", () => typeLocation(type), () => checker.getIndexInfosOfType(type)),
+        typeArguments: (type) => type.isTypeReference()
+            ? one("getTypeArguments", () => typeLocation(type), () => checker.getTypeArguments(type))
+            : [],
+        nonNullable: (type) => one("getNonNullableType", () => typeLocation(type), () => checker.getNonNullableType(type)),
+        isArray: (type) => one("isArrayType", () => typeLocation(type), () => checker.isArrayType(type)),
+        assignableEach: (pairs, cap = DEFAULT_BATCH_CAP) => each("isTypeAssignableTo", pairs, cap, (pair) => `${typeLocation(pair.source)} to ${typeLocation(pair.target)}`, (pair) => checker.isTypeAssignableTo.gen(pair.source, pair.target), (pair) => checker.isTypeAssignableTo(pair.source, pair.target)),
+        baseTypes: (type) => type.isClassOrInterface()
+            ? one("getBaseTypes", () => typeLocation(type), () => checker.getBaseTypes(type))
+            : [],
+        constituents: (type) => type.isUnionType() || type.isIntersectionType()
+            ? one("getTypes", () => typeLocation(type), () => type.getTypes())
+            : [type],
+        targetOf: (type) => type.isTypeReference()
+            ? one("getTarget", () => typeLocation(type), () => type.getTarget())
+            : type,
+        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)),
+        parameterType: (signature, index) => one("getParameterType", () => `signature ${String(signature.id)} parameter ${String(index)}`, () => checker.getParameterType(signature, index)),
+        signatureOf: (declaration) => one("getSignatureFromDeclaration", () => nodeLocation(declaration), () => checker.getSignatureFromDeclaration(declaration)),
+        returnTypeOf: (signature) => one("getReturnTypeOfSignature", () => `signature ${String(signature.id)}`, () => checker.getReturnTypeOfSignature(signature)),
+        typeToString: (type) => one("typeToString", () => typeLocation(type), () => checker.typeToString(type)),
+    };
+}

package/dist/src/references.js

@@ -2,15 +2,10 @@ import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isDecor
 import { aliasChains } from "./alias-chain.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { globExpression } from "./glob.js";
-import { nodeKey } from "./inventory.js";
+import { declarationsByName, nodeKey } from "./inventory.js";
 import { relativePath } from "./paths.js";
 import { byPosition, renderPosition } from "./position.js";
-/**
- * The batch cap a run takes when the configuration names none. It bounds the size of
- * one answer rather than the work: the median file is one batch at this cap and the
- * largest production file a handful.
- */
-export const DEFAULT_BATCH_CAP = 4096;
+import { DEFAULT_BATCH_CAP, UNANSWERED } from "./query.js";
 /**
  * The operators whose left side one assignment stores into. A compound assignment is
  * among them: it reads its target only to write the result back, so nothing else
@@ -294,6 +289,49 @@ export function testFileRulesOf(testFiles, paths) {
     })
         .sort((a, b) => compare(a.rule, b.rule));
 }
+const importedCache = new WeakMap();
+/**
+ * Each local name one file's imports bind, mapped to the names it imports: the
+ * exported name of a named import, `default` for a default import, and `undefined` for
+ * a namespace import or an import assignment, which binds a whole module.
+ */
+function importedNames(file) {
+    const known = importedCache.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const names = new Map();
+    const bind = (local, imported) => {
+        names.set(local, [...(names.get(local) ?? []), imported]);
+    };
+    for (const statement of file.statements) {
+        if (isImportEqualsDeclaration(statement)) {
+            bind(statement.name.text, undefined);
+            continue;
+        }
+        const clause = isImportDeclaration(statement) ? statement.importClause : undefined;
+        if (clause === undefined) {
+            continue;
+        }
+        if (clause.name !== undefined) {
+            bind(clause.name.text, "default");
+        }
+        const bindings = clause.namedBindings;
+        if (bindings === undefined) {
+            continue;
+        }
+        if (bindings.kind === SyntaxKind.NamespaceImport) {
+            bind(bindings.name.text, undefined);
+        }
+        else {
+            for (const element of bindings.elements) {
+                bind(element.name.text, element.propertyName?.text ?? element.name.text);
+            }
+        }
+    }
+    importedCache.set(file, names);
+    return names;
+}
 /** Two strings ordered bytewise, which is the order every set of a run is read in. */
 function compare(a, b) {
     if (a === b) {
@@ -347,7 +385,26 @@ export function references(project, held, targetRoot, options) {
      * Each later link is a declaration of its own that references the next, so one link
      * per re-export is what lets a chain be followed one declaration at a time.
      */
-    const carriedBy = (link, symbol) => link.alias ? chains.nextDeclared(symbol) : chains.declarationsOf(symbol);
+    const carriedBy = (link, symbol) => link.alias
+        ? chains.nextDeclared(symbol)
+        : chains.declarationsOf(symbol).map((id) => ({ id, stepped: false, guessed: false }));
+    /**
+     * Every declaration bearing the name one node spells, or the name an import of its
+     * file binds that name to, which is what a reference the checker could not resolve is
+     * counted as: it may be a use of any of them, and a declaration it may use is kept
+     * live. A name a namespace import binds may be a use of any file.
+     */
+    const named = (node) => {
+        const byName = declarationsByName(held);
+        const text = node.getText();
+        const imported = importedNames(node.getSourceFile()).get(text) ?? [];
+        return [
+            ...new Set([
+                ...(byName.get(text) ?? []),
+                ...imported.flatMap((name) => name === undefined ? [...fileIds] : (byName.get(name) ?? [])),
+            ]),
+        ];
+    };
     /** The symbol one site resolves to, asking only the accessor the site's form names. */
     const symbolFor = (site, answered) => {
         if (site.shorthand !== undefined) {
@@ -355,7 +412,7 @@ export function references(project, held, targetRoot, options) {
             return project.shorthandValueAt(project.handle(site.shorthand));
         }
         const batched = answered.get(site.node);
-        if (batched !== undefined) {
+        if (batched === UNANSWERED || typeof batched === "object") {
             return batched;
         }
         residueFallbacks += 1;
@@ -397,7 +454,7 @@ export function references(project, held, targetRoot, options) {
         batched += batching.length;
         for (let from = 0; from < batching.length; from += cap) {
             const run = batching.slice(from, from + cap);
-            const answers = project.symbolsAt(run.map((node) => project.handle(node)));
+            const answers = project.symbolsAt(run.map((node) => project.handle(node)), cap);
             fileBatches += 1;
             run.forEach((node, index) => {
                 const symbol = answers[index];
@@ -412,13 +469,16 @@ export function references(project, held, targetRoot, options) {
                 continue;
             }
             const position = renderPosition(file, root, link.at.getStart());
-            for (const id of carriedBy(link, symbol)) {
+            const carried = symbol === UNANSWERED
+                ? named(link.at).map((id) => ({ id, stepped: false, guessed: true }))
+                : carriedBy(link, symbol);
+            for (const target of carried) {
                 found.push({
                     from: link.from,
-                    to: id,
+                    to: target.id,
                     position,
                     use: "read",
-                    resolution: link.alias ? "alias" : "batch",
+                    resolution: target.guessed ? "by-name" : link.alias ? "alias" : "batch",
                     test,
                 });
             }
@@ -429,14 +489,16 @@ export function references(project, held, targetRoot, options) {
                 continue;
             }
             const position = renderPosition(file, root, evaluation.node.getStart());
-            for (const id of chains.declarationsOf(module)) {
+            // A module the checker could not resolve may be any file of the target.
+            const evaluated = module === UNANSWERED ? [...fileIds] : chains.declarationsOf(module);
+            for (const id of evaluated) {
                 if (fileIds.has(id)) {
                     found.push({
                         from: evaluation.from,
                         to: id,
                         position,
                         use: "evaluation",
-                        resolution: "batch",
+                        resolution: module === UNANSWERED ? "by-name" : "batch",
                         test,
                     });
                 }
@@ -450,13 +512,20 @@ export function references(project, held, targetRoot, options) {
                 return;
             }
             const position = renderPosition(file, root, read.key.getStart());
-            for (const target of chains.chainOf(symbol)) {
+            const targets = symbol === UNANSWERED
+                ? (declarationsByName(held).get(read.name) ?? []).map((id) => ({
+                    id,
+                    stepped: false,
+                    guessed: true,
+                }))
+                : chains.chainOf(symbol);
+            for (const target of targets) {
                 found.push({
                     from: read.from,
                     to: target.id,
                     position,
                     use: "read",
-                    resolution: "destructured",
+                    resolution: target.guessed ? "by-name" : "destructured",
                     test,
                 });
             }
@@ -464,7 +533,7 @@ export function references(project, held, targetRoot, options) {
         for (const site of uses) {
             const direct = site.shorthand !== undefined
                 ? "shorthand"
-                : answered.has(site.node)
+                : typeof answered.get(site.node) === "object"
                     ? "batch"
                     : "resolved-symbol";
             const symbol = symbolFor(site, answered);
@@ -474,13 +543,16 @@ export function references(project, held, targetRoot, options) {
             const position = renderPosition(file, root, site.node.getStart());
             // A re-export something imports is used and so is the declaration behind it, so
             // the use names every link of the chain its name stands at the head of.
-            for (const target of chains.chainOf(symbol)) {
+            const targets = symbol === UNANSWERED
+                ? named(site.node).map((id) => ({ id, stepped: false, guessed: true }))
+                : chains.chainOf(symbol);
+            for (const target of targets) {
                 found.push({
                     from: site.from,
                     to: target.id,
                     position,
                     use: site.use,
-                    resolution: target.stepped ? "alias" : direct,
+                    resolution: target.guessed ? "by-name" : target.stepped ? "alias" : direct,
                     test,
                 });
             }

package/dist/src/reflective-lookup.js

@@ -8,11 +8,15 @@
  * string reaches every member of that name on any type, static members included,
  * and every record names the string's own position. A key that is not literal text
  * holds nothing back: a computed name is the case no exact rule serves. `Reflect` is
- * the global one only: a local declaration of that name is a different object.
+ * the global one only: a local declaration of that name is a different object. An
+ * element access through a receiver whose type declares a string index signature, and is
+ * not `any`, reads that signature and holds nothing back.
  */
 import { isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { TypeFlags } from "@typescript/native/unstable/sync";
 import { memberNames } from "./member-names.js";
 import { renderPosition } from "./position.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 /** The `Reflect` methods whose second argument is a property key. */
 const REFLECT_KEYED = new Set(["get", "set", "has"]);
 /** The text one key denotes, where it is literal text. */
@@ -34,6 +38,7 @@ function lookupsOf(file) {
                     name,
                     callee: `[${JSON.stringify(name)}]`,
                     reflect: undefined,
+                    receiver: node.expression,
                 });
             }
         }
@@ -48,7 +53,13 @@ function lookupsOf(file) {
                 REFLECT_KEYED.has(method.text) &&
                 key !== undefined &&
                 name !== undefined) {
-                found.push({ key, name, callee: `Reflect.${method.text}`, reflect: target });
+                found.push({
+                    key,
+                    name,
+                    callee: `Reflect.${method.text}`,
+                    reflect: target,
+                    receiver: undefined,
+                });
             }
         }
         node.forEachChild(visit);
@@ -56,6 +67,18 @@ function lookupsOf(file) {
     file.forEachChild(visit);
     return found;
 }
+/**
+ * Whether a receiver's type is not `any` and declares a string index signature. A type
+ * whose index signatures the checker did not answer for is read as declaring none, so
+ * the lookup retains what it names.
+ */
+function readsAMapping(project, type) {
+    if ((type.flags & TypeFlags.Any) !== 0) {
+        return false;
+    }
+    const infos = project.queries.indexInfosOf(type);
+    return isAnswered(infos) && infos.some((info) => (info.keyType.flags & TypeFlags.String) !== 0);
+}
 /**
  * The reflective-lookup detector: every member whose name a literal key of a lookup
  * spells, recorded at the key.
@@ -69,24 +92,43 @@ export function reflectiveLookup(input) {
     }
     // Whether each written `Reflect` is the global one, asked in one batch: a
     // declaration of that name in one of the project's own files shadows it.
-    const ownFiles = new Set(files.map((file) => file.fileName));
+    const ownFiles = project.ownPaths();
     const reflects = lookups.flatMap((lookup) => lookup.reflect === undefined ? [] : [lookup.reflect]);
     const global = new Set();
     if (reflects.length > 0) {
         project.symbolsAt(reflects.map((node) => project.handle(node))).forEach((symbol, index) => {
             const node = reflects[index];
-            const declaredHere = symbol?.declarations.some((declaration) => ownFiles.has(declaration.path));
+            // A name the checker did not answer for is read as the global, which retains.
+            const declaredHere = symbol === UNANSWERED
+                ? false
+                : symbol?.declarations.some((declaration) => ownFiles.has(declaration.path));
             if (node !== undefined && declaredHere === false) {
                 global.add(node);
             }
         });
     }
+    // An element access through a receiver that maps every string key to one value type
+    // reads that mapping rather than a member, asked in one batch.
+    const receivers = lookups.flatMap((lookup) => lookup.receiver === undefined ? [] : [lookup.receiver]);
+    const mapped = new Set();
+    project.queries.typesAt(receivers).forEach((type, index) => {
+        const receiver = receivers[index];
+        if (receiver !== undefined &&
+            type !== undefined &&
+            isAnswered(type) &&
+            readsAMapping(project, type)) {
+            mapped.add(receiver);
+        }
+    });
     const members = memberNames(files, held);
     const found = [];
     for (const lookup of lookups) {
         if (lookup.reflect !== undefined && !global.has(lookup.reflect)) {
             continue;
         }
+        if (lookup.receiver !== undefined && mapped.has(lookup.receiver)) {
+            continue;
+        }
         const site = renderPosition(lookup.key.getSourceFile(), targetRoot, lookup.key.getStart());
         for (const member of members.get(lookup.name) ?? []) {
             found.push({ id: member.id, detail: `looked up by ${lookup.callee}`, site });

package/dist/src/report.js

@@ -4,7 +4,12 @@
  * renders this document, so no two renderings disagree about which findings exist.
  */
 /** The version of the report schema this analyzer writes a report to. */
-export const SCHEMA_VERSION = "6.0.0";
+const SCHEMA_VERSION = "6.1.0";
+/**
+ * Every report schema version this analyzer reads: the schema versions the Contract it
+ * implements admits, each an instance of the one it writes.
+ */
+export const SCHEMA_VERSIONS_ACCEPTED = ["6.0.0", 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. */
@@ -52,6 +57,7 @@ function wireDetails(details) {
                     ...(entry.reason === undefined ? {} : { reason: entry.reason }),
                 },
             }),
+        ...(details.overlap === undefined ? {} : { overlap: details.overlap }),
     };
 }
 /** One finding as the finding schema spells it, member for member in its order. */
@@ -79,6 +85,9 @@ 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,
@@ -198,7 +207,7 @@ export function buildReport(input) {
             name: ANALYZER_NAME,
             version: input.version,
             languages: [LANGUAGE],
-            schema_versions_accepted: [SCHEMA_VERSION],
+            schema_versions_accepted: SCHEMA_VERSIONS_ACCEPTED,
             conformance: {
                 corpus_version: input.conformance.corpusVersion,
                 result: input.conformance.result,
@@ -209,7 +218,9 @@ export function buildReport(input) {
         configurations: [...input.configurations]
             .sort((a, b) => compare(a.id, b.id))
             .map((one) => ({ id: one.id, project: one.project })),
-        configurations_not_built: [],
+        configurations_not_built: [...input.notBuilt]
+            .sort((a, b) => compare(a.id, b.id))
+            .map((one) => ({ id: one.id, project: one.project, error: one.error })),
         consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
         findings,
         edge_evaluations: input.result.edgeEvaluations.map(wireEvaluation).sort(byEdge),

package/dist/src/reporters/annotations.js

@@ -1,4 +1,5 @@
 import { fails } from "../config.js";
+import { coalesced } from "../json-chunks.js";
 import { KINDS } from "../kinds.js";
 /** The escapes a workflow command's message needs, so a line break does not end the command. */
 const DATA_ESCAPES = { "%": "%25", "\r": "%0D", "\n": "%0A" };
@@ -28,9 +29,12 @@ function command(level, at, endLine, title, message) {
  * because its kind is fixed on at the failing severity.
  */
 export function annotations(report, options) {
-    const lines = report.findings.map((found) => command(fails(found.severity, options.failOn) ? "error" : "warning", found.position, found.position.end_line, `${found.code} ${found.kind}`, found.message));
-    for (const stale of report.stale_suppressions) {
-        lines.push(command("error", stale.position, stale.position.line, `${stale.code} ${kindName(stale.code)}`, stale.message));
-    }
-    return lines.map((line) => `${line}\n`).join("");
+    return coalesced((function* lines() {
+        for (const found of report.findings) {
+            yield `${command(fails(found.severity, options.failOn) ? "error" : "warning", found.position, found.position.end_line, `${found.code} ${found.kind}`, found.message)}\n`;
+        }
+        for (const stale of report.stale_suppressions) {
+            yield `${command("error", stale.position, stale.position.line, `${stale.code} ${kindName(stale.code)}`, stale.message)}\n`;
+        }
+    })());
 }

package/dist/src/reporters/json.js

@@ -1,4 +1,5 @@
+import { jsonChunks } from "../json-chunks.js";
 /** The indentation of the report document, which with the schema's member order fixes its bytes. */
 const INDENT = 2;
-/** The report document itself: the report, indented, with a closing newline. */
-export const json = (report) => `${JSON.stringify(report, null, INDENT)}\n`;
+/** The report document itself, in pieces: the report, indented, with a closing newline. */
+export const json = (report) => jsonChunks(report, INDENT);