@cplieger/deadset-ts 3.13.0 → 4.0.1

package/dist/src/implementations.js

@@ -9,7 +9,7 @@ import { isClassDeclaration, isHeritageClause, isInterfaceDeclaration, isMethodD
 import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { must, Unanswerable } from "./query.js";
 /** The interfaces, the classes and the `implements` entries of one project's own files. */
 function walk(project, held) {
     const interfaces = [];
@@ -41,23 +41,21 @@ function walk(project, held) {
     }
     return { interfaces, classes, clauses };
 }
-/** The type at each node, asked in capped batches. */
+/** The type at each node. */
 function typesAt(project, nodes) {
     const typeAt = new Map();
-    for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-        const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
-        project.checker.getTypeAtLocation(run).forEach((type, index) => {
-            const node = run[index];
-            if (type !== undefined && node !== undefined) {
-                typeAt.set(node, type);
-            }
-        });
-    }
+    project.queries.typesAt(nodes).forEach((answer, index) => {
+        const type = must(answer);
+        const node = nodes[index];
+        if (type !== undefined && node !== undefined) {
+            typeAt.set(node, type);
+        }
+    });
     return typeAt;
 }
 /** Whether one class member is a method whose every written body holds no statement. */
 function emptyImplementation(project, member) {
-    const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+    const own = project.ownPaths();
     let bodies = 0;
     for (const handle of member.declarations) {
         // A body outside the target is one this analysis cannot read, so it is not empty.
@@ -77,15 +75,32 @@ function emptyImplementation(project, member) {
     }
     return bodies > 0;
 }
-/** How one project's interfaces are implemented by its classes. */
+/**
+ * How one project's interfaces are implemented by its classes. Where the checker leaves
+ * a question unanswered, what was read stands and every interface method of the project
+ * is named in {@link Implementations.unknown}.
+ */
 export function implementations(project, held) {
     const classes = new Map();
     const bodies = new Map();
+    try {
+        implementedIn(project, held, classes, bodies);
+        return { classes, bodies, unknown: new Set() };
+    }
+    catch (error) {
+        if (!(error instanceof Unanswerable)) {
+            throw error;
+        }
+        const methods = held.symbols.filter((symbol) => symbol.kind === "interface-method");
+        return { classes, bodies, unknown: new Set(methods.map((symbol) => symbol.id)) };
+    }
+}
+function implementedIn(project, held, classes, bodies) {
     const walked = walk(project, held);
     if (walked.interfaces.length === 0 || walked.classes.length === 0) {
-        return { classes, bodies };
+        return;
     }
-    const checker = project.checker;
+    const queries = project.queries;
     const typeAt = typesAt(project, [
         ...walked.interfaces.map((one) => one.nameNode),
         ...walked.classes.map((one) => one.nameNode),
@@ -114,8 +129,8 @@ export function implementations(project, held) {
             classAt.set(owner.id, { owner, type });
         }
     }
-    const membersOf = (at) => (at.members ??= checker.getPropertiesOfType(at.type));
-    const classMembers = (at) => (at.members ??= new Map(checker.getPropertiesOfType(at.type).map((member) => [member.escapedName, member])));
+    const membersOf = (at) => (at.members ??= must(queries.propertiesOf(at.type)));
+    const classMembers = (at) => (at.members ??= new Map(must(queries.propertiesOf(at.type)).map((member) => [member.escapedName, member])));
     const methodIds = new Set(held.symbols.filter((symbol) => symbol.kind === "interface-method").map((symbol) => symbol.id));
     const chains = aliasChains(project, held);
     const record = (at, implementer) => {
@@ -161,11 +176,13 @@ export function implementations(project, held) {
         if (entry === undefined || implementer === undefined) {
             continue;
         }
-        const at = byType.get(entry.isTypeReference() ? entry.getTarget().id : entry.id);
+        const at = byType.get(must(queries.targetOf(entry)).id);
         if (at !== undefined) {
             pair(at, implementer);
         }
     }
+    // Every pair whose names line up is asked about at once.
+    const candidates = [];
     for (const at of byType.values()) {
         const members = at.generic ? [] : membersOf(at);
         if (members.length === 0) {
@@ -178,16 +195,21 @@ export function implementations(project, held) {
             }
             const written = classMembers(implementer);
             if (required.every((member) => written.has(member.escapedName)) &&
-                members.some((member) => written.has(member.escapedName)) &&
-                checker.isTypeAssignableTo(implementer.type, at.type)) {
-                pair(at, implementer);
+                members.some((member) => written.has(member.escapedName))) {
+                candidates.push({ at, implementer });
             }
         }
     }
-    return { classes, bodies };
+    const assignable = queries.assignableEach(candidates.map((one) => ({ source: one.implementer.type, target: one.at.type })));
+    candidates.forEach((one, index) => {
+        if (must(assignable[index] ?? false)) {
+            pair(one.at, one.implementer);
+        }
+    });
 }
 /** Every project's answers as one run's, each implementation once. */
 export function mergeImplementations(per) {
+    const unknown = new Set(per.flatMap((one) => [...one.unknown]));
     const classes = new Map();
     const bodies = new Map();
     for (const one of per) {
@@ -206,5 +228,5 @@ export function mergeImplementations(per) {
             }
         }
     }
-    return { classes, bodies };
+    return { classes, bodies, unknown };
 }

package/dist/src/interface-satisfaction.js

@@ -17,7 +17,7 @@ import { SymbolFlags } from "@typescript/native/unstable/sync";
 import { aliasChains } from "./alias-chain.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { must } from "./query.js";
 /** The operators of an assignment whose right side is stored into the left side's type. */
 const STORES = new Set([
     SyntaxKind.EqualsToken,
@@ -157,7 +157,7 @@ function walk(files, declarations) {
  */
 export function interfaceSatisfaction(input) {
     const { project, held, targetRoot } = input;
-    const checker = project.checker;
+    const queries = project.queries;
     const files = project.ownSourceFiles();
     const { classes, clauses, flows } = walk(files, held.declarations);
     if (classes.length === 0) {
@@ -171,15 +171,13 @@ export function interfaceSatisfaction(input) {
         ...flows.filter((flow) => flow.self === undefined).map((flow) => flow.value),
     ];
     const typeAt = new Map();
-    for (let from = 0; from < asked.length; from += DEFAULT_BATCH_CAP) {
-        const run = asked.slice(from, from + DEFAULT_BATCH_CAP);
-        checker.getTypeAtLocation(run).forEach((type, index) => {
-            const node = run[index];
-            if (type !== undefined && node !== undefined) {
-                typeAt.set(node, type);
-            }
-        });
-    }
+    queries.typesAt(asked).forEach((answer, index) => {
+        const type = must(answer);
+        const node = asked[index];
+        if (type !== undefined && node !== undefined) {
+            typeAt.set(node, type);
+        }
+    });
     const classOfType = new Map();
     const instanceOf = new Map();
     for (const owner of classes) {
@@ -197,7 +195,7 @@ export function interfaceSatisfaction(input) {
         }
         let parts = constituents.get(type.id);
         if (parts === undefined) {
-            parts = type.getTypes();
+            parts = must(queries.constituents(type));
             constituents.set(type.id, parts);
         }
         return parts;
@@ -213,7 +211,7 @@ export function interfaceSatisfaction(input) {
             return [];
         }
         if (!targets.has(part.id)) {
-            targets.set(part.id, classOfType.get(part.getTarget().id));
+            targets.set(part.id, classOfType.get(must(queries.targetOf(part)).id));
         }
         const generic = targets.get(part.id);
         return generic === undefined ? [] : [{ owner: generic, type: part }];
@@ -222,7 +220,7 @@ export function interfaceSatisfaction(input) {
     /** The interface types one position's type is or holds, each with the interface's name. */
     const interfacesOf = (type) => partsOf(type).flatMap((part) => {
         if (!interfaceNames.has(part.id)) {
-            const symbol = part.isObjectType() ? part.getSymbol() : undefined;
+            const symbol = part.isObjectType() ? must(queries.symbolOfType(part)) : undefined;
             interfaceNames.set(part.id, symbol !== undefined && (symbol.flags & SymbolFlags.Interface) !== 0
                 ? symbol.name
                 : undefined);
@@ -251,7 +249,8 @@ export function interfaceSatisfaction(input) {
             reach(clause.owner, source, reached.type, reached.name, clause.entry);
         }
     }
-    for (const flow of flows) {
+    // The positions of every flow carrying a class are asked for at once.
+    const carrying = flows.flatMap((flow) => {
         const self = flow.self === undefined ? undefined : instanceOf.get(flow.self.id);
         const valueType = typeAt.get(flow.value);
         const sources = flow.self !== undefined && self !== undefined
@@ -259,38 +258,42 @@ export function interfaceSatisfaction(input) {
             : valueType === undefined
                 ? []
                 : classesOf(valueType);
-        if (sources.length === 0) {
-            continue;
-        }
-        const position = checker.getContextualType(flow.value);
+        return sources.length === 0 ? [] : [{ flow, sources }];
+    });
+    const positions = queries.contextualTypes(carrying.map((one) => one.flow.value));
+    carrying.forEach(({ flow, sources }, index) => {
+        const position = must(positions[index]);
         if (position === undefined) {
-            continue;
+            return;
         }
         for (const reached of interfacesOf(position)) {
             for (const source of sources) {
                 reach(source.owner, source.type, reached.type, reached.name, flow.value);
             }
         }
-    }
+    });
     const chains = aliasChains(project, held);
     const required = new Map();
     const members = new Map();
     const found = [];
-    for (const pair of pairs.values()) {
-        if (!checker.isTypeAssignableTo(pair.source, pair.target)) {
+    const asking = [...pairs.values()];
+    const assignable = queries.assignableEach(asking);
+    for (const [index, pair] of asking.entries()) {
+        if (!must(assignable[index] ?? false)) {
             continue;
         }
         let names = required.get(pair.target.id);
         if (names === undefined) {
-            names = new Set(checker.getPropertiesOfType(pair.target).map((property) => property.escapedName));
+            names = new Set(must(queries.propertiesOf(pair.target)).map((property) => property.escapedName));
             required.set(pair.target.id, names);
         }
         let answering = members.get(pair.owner.id);
         if (answering === undefined) {
             const instance = instanceOf.get(pair.owner.id) ?? pair.source;
-            answering = new Map(checker
-                .getPropertiesOfType(instance)
-                .map((property) => [property.escapedName, chains.declarationsOf(property)]));
+            answering = new Map(must(queries.propertiesOf(instance)).map((property) => [
+                property.escapedName,
+                chains.declarationsOf(property),
+            ]));
             members.set(pair.owner.id, answering);
         }
         const detail = `satisfies ${pair.name}`;

package/dist/src/intra-function-parts.js

@@ -4,10 +4,10 @@
  * call sites that use or discard it, each statement control flow cannot reach, each
  * write to a local that no read reaches, and each case an earlier case covers.
  */
-import { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isCallExpression, isCaseClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+import { isArrowFunction, isAwaitExpression, isBigIntLiteral, isBinaryExpression, isBlock, isBreakStatement, isCallExpression, isCaseClause, isClassDeclaration, isClassExpression, isContinueStatement, isDecorator, isDefaultClause, isEmptyStatement, isExportAssignment, isExportSpecifier, isExpressionStatement, isFunctionDeclaration, isHeritageClause, isIdentifier, isIfStatement, isImportClause, isImportSpecifier, isInterfaceDeclaration, isMethodDeclaration, isModuleDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isParenthesizedExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isQualifiedName, isReturnStatement, isShorthandPropertyAssignment, isStringLiteral, isSwitchStatement, isThrowStatement, isTypeAliasDeclaration, isTypeReferenceNode, isVariableStatement, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
 import { nodeKey } from "./inventory.js";
 import { positionKey, renderPosition } from "./position.js";
-import { DEFAULT_BATCH_CAP } from "./references.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 import { signatureOf } from "./signatures.js";
 /** The codes of the parts this module reads. */
 export const UNUSED_PARAMETER = "DS1801";
@@ -195,8 +195,15 @@ function extendedNames(files) {
     const visit = (node) => {
         if (isHeritageClause(node) && node.token === SyntaxKind.ExtendsKeyword) {
             for (const type of node.types) {
-                const expression = unwrapped(type.expression);
-                const named = isPropertyAccessExpression(expression) ? expression.name : expression;
+                // A class's clause holds expressions; an interface's holds type references.
+                let named;
+                if (isTypeReferenceNode(type)) {
+                    named = isQualifiedName(type.typeName) ? type.typeName.right : type.typeName;
+                }
+                else {
+                    const expression = unwrapped(type.expression);
+                    named = isPropertyAccessExpression(expression) ? expression.name : expression;
+                }
                 if (isIdentifier(named)) {
                     names.add(named.text);
                 }
@@ -230,31 +237,33 @@ function hierarchyFixes(declared, extended) {
     }
     return owner.name !== undefined && extended.has(owner.name.text);
 }
-/** The symbol identifier each of a batch of identifiers resolves to, where the batch answers. */
+/**
+ * The symbol identifier each of a batch of identifiers resolves to, where the batch
+ * resolves it, and {@link UNANSWERED} where the checker did not answer.
+ */
 function resolvedIds(project, nodes) {
     const ids = new Map();
-    for (let from = 0; from < nodes.length; from += DEFAULT_BATCH_CAP) {
-        const run = nodes.slice(from, from + DEFAULT_BATCH_CAP);
-        project.symbolsAt(run.map((node) => project.handle(node))).forEach((symbol, index) => {
-            const node = run[index];
-            if (symbol !== undefined && node !== undefined) {
-                ids.set(node, symbol.id);
-            }
-        });
-    }
+    project.symbolsAt(nodes.map((node) => project.handle(node))).forEach((symbol, index) => {
+        const node = nodes[index];
+        if (node !== undefined && symbol !== undefined) {
+            ids.set(node, symbol === UNANSWERED ? UNANSWERED : symbol.id);
+        }
+    });
     return ids;
 }
 /**
  * Whether one identifier reads the binding a name node declares: it resolves to the
- * same symbol, or the checker resolves it to nothing, which is read as a use rather than
- * risk a finding; a shorthand property reads the binding of its own name.
+ * same symbol, or the checker resolves it to nothing or does not answer for either
+ * name, which is read as a use rather than risk a finding; a shorthand property reads
+ * the binding of its own name.
  */
 function readsBinding(use, declared, ids) {
     if (isShorthandPropertyAssignment(use.parent)) {
         return true;
     }
     const at = ids.get(use);
-    return at === undefined || at === ids.get(declared);
+    const own = ids.get(declared);
+    return at === undefined || at === UNANSWERED || own === UNANSWERED || at === own;
 }
 /**
  * The parts of one project's own declarations. `references` are the project's own
@@ -575,9 +584,17 @@ function resultParts(project, root, sites, references, calls) {
         if (!discardedAt.has(id) || generator || !returnsAValue(signature)) {
             continue;
         }
-        const typed = project.checker.getSignatureFromDeclaration(signature);
-        const result = typed === undefined ? undefined : project.checker.getReturnTypeOfSignature(typed);
-        if (result === undefined || NO_VALUE.has(project.checker.typeToString(result))) {
+        // A question the checker leaves unanswered withholds the finding.
+        const typed = project.queries.signatureOf(signature);
+        if (typed === undefined || !isAnswered(typed)) {
+            continue;
+        }
+        const result = project.queries.returnTypeOf(typed);
+        if (result === undefined || !isAnswered(result)) {
+            continue;
+        }
+        const spelled = project.queries.typeToString(result);
+        if (!isAnswered(spelled) || NO_VALUE.has(spelled)) {
             continue;
         }
         const at = signature.type ?? node.name ?? node;

package/dist/src/inventory.js

@@ -2,6 +2,7 @@ import { isClassDeclaration, isComputedPropertyName, isEnumDeclaration, isEnumMe
 import { dirnamePath, joinPath, relativePath } from "./paths.js";
 import { byPosition, positionKey, renderPosition } from "./position.js";
 import { computedComponent, nameComponent, renderRef } from "./ref.js";
+import { isAnswered, UNANSWERED } from "./query.js";
 const MANIFEST = "package.json";
 /**
  * Resolves each file's package scope: the name of the nearest manifest at or above
@@ -493,12 +494,28 @@ export function inventory(project, host, targetRoot) {
     const handles = batched.map((node) => project.handle(node));
     const resolved = project.symbolsAt(handles);
     const symbolOf = new Map();
+    // A scope or a container whose symbol or table went unanswered keeps what its syntax
+    // declares, and everything under it is recorded unanswered.
+    const unansweredOwners = new Set();
     batched.forEach((node, index) => {
         const symbol = resolved[index];
-        if (symbol !== undefined) {
+        if (typeof symbol === "object") {
             symbolOf.set(node, symbol);
         }
     });
+    resolved.slice(0, exportScopes.length).forEach((symbol, index) => {
+        const scope = exportScopes[index];
+        if (symbol === UNANSWERED && scope !== undefined) {
+            unansweredOwners.add(scope.owner);
+        }
+    });
+    containers
+        .filter((container) => container.nameNode !== undefined)
+        .forEach((container, index) => {
+        if (resolved[exportScopes.length + index] === UNANSWERED) {
+            unansweredOwners.add(container.owner);
+        }
+    });
     let exportTables = 0;
     for (const scope of exportScopes) {
         const symbol = symbolOf.get(scope.nameNode);
@@ -506,7 +523,11 @@ export function inventory(project, host, targetRoot) {
             continue;
         }
         exportTables += 1;
-        for (const [, exported] of symbol.getExports()) {
+        const table = project.queries.exportsOf(symbol);
+        if (!isAnswered(table)) {
+            unansweredOwners.add(scope.owner);
+        }
+        for (const [, exported] of isAnswered(table) ? table : []) {
             for (const declaration of exported.declarations) {
                 const held = project.declarationAt(declaration);
                 if (held === undefined) {
@@ -527,11 +548,23 @@ export function inventory(project, host, targetRoot) {
         if (symbol !== undefined) {
             if (!container.membersAreExports) {
                 memberTables += 1;
-                outsideOwnFiles += readTable(container, symbol.getMembers(), seen, false);
+                const table = project.queries.membersOf(symbol);
+                if (isAnswered(table)) {
+                    outsideOwnFiles += readTable(container, table, seen, false);
+                }
+                else {
+                    unansweredOwners.add(container.owner);
+                }
             }
             if (container.membersAreExports || container.isClass) {
                 memberTables += 1;
-                outsideOwnFiles += readTable(container, symbol.getExports(), seen, container.isClass);
+                const table = project.queries.exportsOf(symbol);
+                if (isAnswered(table)) {
+                    outsideOwnFiles += readTable(container, table, seen, container.isClass);
+                }
+                else {
+                    unansweredOwners.add(container.owner);
+                }
             }
         }
         completeFromTree(container, seen);
@@ -635,6 +668,7 @@ export function inventory(project, host, targetRoot) {
         }
         return undefined;
     }
+    const byId = new Map(building.map((record) => [positionKey(record.position), record]));
     const symbols = building
         .map(render)
         .sort((a, b) => byPosition(a.position, b.position) || (a.ref < b.ref ? -1 : 1));
@@ -645,8 +679,47 @@ export function inventory(project, host, targetRoot) {
         cost: { batches: 1, exportTables, memberTables },
         starReExports,
         outsideOwnFiles,
+        unanswered: symbols
+            .filter((symbol) => underUnanswered(byId.get(symbol.id), unansweredOwners))
+            .map((symbol) => symbol.id),
+        byName: namesOf(building),
     };
 }
+/** Whether one declaration is, or is declared under, a scope or container left unanswered. */
+function underUnanswered(record, owners) {
+    for (let at = record; at !== undefined; at = at.parent) {
+        if (owners.has(at)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Every declaration but a file, by each name a use may spell it with. */
+function namesOf(building) {
+    const byName = new Map();
+    for (const record of building) {
+        if (record.kind === "file") {
+            continue;
+        }
+        const id = positionKey(record.position);
+        const names = record.typeParameter === undefined
+            ? [record.component.text, record.localName]
+            : [record.typeParameter];
+        for (const name of new Set(names)) {
+            if (name === undefined) {
+                continue;
+            }
+            const ids = byName.get(name);
+            if (ids === undefined) {
+                byName.set(name, [id]);
+            }
+            else if (!ids.includes(id)) {
+                ids.push(id);
+            }
+        }
+    }
+    return byName;
+}
 /** The chain of components that names one declaration, read from the module inward. */
 function chainOf(record) {
     return [...record.parentChain, record.component];
@@ -691,3 +764,11 @@ function refOf(record, chain) {
         ...(record.typeParameter === undefined ? {} : { typeParameter: record.typeParameter }),
     });
 }
+/**
+ * Every declaration of an inventory other than a file, by each name a use may spell it
+ * with. It is how a reference the checker could not resolve is still counted, as a
+ * reference to every declaration that bears the name it spells.
+ */
+export function declarationsByName(held) {
+    return held.byName;
+}

package/dist/src/json-chunks.js

@@ -0,0 +1,76 @@
+/**
+ * A document written in pieces, so no stage of writing it holds the whole document as
+ * one string: a string has a length limit far below what a large report reaches.
+ */
+/** The length a piece grows to before it is handed on. */
+export const CHUNK_LENGTH = 1 << 16;
+/**
+ * The pieces of `pieces` joined into runs of about {@link CHUNK_LENGTH}, the last one
+ * shorter. A piece longer than that is handed on whole.
+ */
+export function* coalesced(pieces) {
+    let held = [];
+    let length = 0;
+    for (const piece of pieces) {
+        held.push(piece);
+        length += piece.length;
+        if (length >= CHUNK_LENGTH) {
+            yield held.join("");
+            held = [];
+            length = 0;
+        }
+    }
+    if (length > 0) {
+        yield held.join("");
+    }
+}
+/** Whether `JSON.stringify` writes nothing for a value where an object member holds it. */
+function omitted(value) {
+    return value === undefined || typeof value === "function" || typeof value === "symbol";
+}
+function* valueOf(value, prefix, step) {
+    // With no indentation the document is compact: no line breaks, and no space after a key.
+    const nl = step === "" ? "" : "\n";
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            yield "[]";
+            return;
+        }
+        const inner = prefix + step;
+        yield "[";
+        for (let at = 0; at < value.length; at += 1) {
+            yield at === 0 ? `${nl}${inner}` : `,${nl}${inner}`;
+            const element = value[at];
+            yield* omitted(element) ? ["null"] : valueOf(element, inner, step);
+        }
+        yield `${nl}${prefix}]`;
+        return;
+    }
+    if (typeof value === "object" && value !== null) {
+        const inner = prefix + step;
+        let first = true;
+        for (const [key, member] of Object.entries(value)) {
+            if (omitted(member)) {
+                continue;
+            }
+            yield `${first ? "{" : ","}${nl}${inner}${JSON.stringify(key)}:${step === "" ? "" : " "}`;
+            first = false;
+            yield* valueOf(member, inner, step);
+        }
+        yield first ? "{}" : `${nl}${prefix}}`;
+        return;
+    }
+    yield JSON.stringify(value);
+}
+/**
+ * One JSON document in pieces whose concatenation is the value as `JSON.stringify`
+ * writes it at `indent` spaces, followed by a newline. The value is plain data: objects,
+ * arrays, strings, finite numbers, booleans and null, an object member holding nothing
+ * being left out as `JSON.stringify` leaves it out.
+ */
+export function jsonChunks(value, indent) {
+    return coalesced((function* document() {
+        yield* valueOf(value, "", " ".repeat(indent));
+        yield "\n";
+    })());
+}

package/dist/src/partial.js

@@ -0,0 +1,23 @@
+/** A count with its noun, so a line reads for one as well as for several. */
+function counted(n, one, many) {
+    return `${String(n)} ${n === 1 ? one : many}`;
+}
+/**
+ * One line per configuration the run dropped, and one counting the questions the checker
+ * left unanswered by project, so a reader of the error stream sees where the analysis was
+ * partial. The lines carry no prefix; the caller writes them as its own diagnostics.
+ */
+export function partialNotes(partial) {
+    const notes = [...partial.notBuilt]
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+        .map((one) => `the derived configuration ${one.id} was not built and is not analyzed: ${one.error}`);
+    if (partial.unanswered.length > 0) {
+        const byProject = new Map();
+        for (const question of partial.unanswered) {
+            byProject.set(question.configFile, (byProject.get(question.configFile) ?? 0) + 1);
+        }
+        const where = [...byProject].map(([configFile, n]) => `${configFile}: ${String(n)}`).join(", ");
+        notes.push(`the checker answered ${counted(partial.unanswered.length, "question", "questions")} with a failure (${where}); every declaration an answer could have kept live is kept live and reported by nothing`);
+    }
+    return notes;
+}