@cplieger/deadset-ts 3.13.0 → 4.0.1

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

@@ -14,9 +14,9 @@
  */
 import { isCallExpression, isElementAccessExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, } from "@typescript/native/unstable/ast";
 import { TypeFlags } from "@typescript/native/unstable/sync";
-import { typesAt } from "./class-members.js";
 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. */
@@ -67,14 +67,17 @@ function lookupsOf(file) {
     file.forEachChild(visit);
     return found;
 }
-/** Whether a receiver's type is not `any` and declares a string index signature. */
+/**
+ * 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;
     }
-    return project.checker
-        .getIndexInfosOfType(type)
-        .some((info) => (info.keyType.flags & TypeFlags.String) !== 0);
+    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
@@ -89,13 +92,16 @@ 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);
             }
@@ -105,9 +111,12 @@ export function reflectiveLookup(input) {
     // 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();
-    typesAt(project, receivers).forEach((type, index) => {
+    project.queries.typesAt(receivers).forEach((type, index) => {
         const receiver = receivers[index];
-        if (receiver !== undefined && type !== undefined && readsAMapping(project, type)) {
+        if (receiver !== undefined &&
+            type !== undefined &&
+            isAnswered(type) &&
+            readsAMapping(project, type)) {
             mapped.add(receiver);
         }
     });

package/dist/src/report.js

@@ -218,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);

package/dist/src/reporters/sarif.js

@@ -1,3 +1,4 @@
+import { jsonChunks } from "../json-chunks.js";
 import { KINDS } from "../kinds.js";
 import { lineHashes, symbolFingerprint } from "./fingerprint.js";
 import { RenderError } from "./reporter.js";
@@ -236,5 +237,5 @@ export function sarif(report, options) {
             },
         ],
     };
-    return `${JSON.stringify(log, null, INDENT)}\n`;
+    return jsonChunks(log, INDENT);
 }

package/dist/src/reporters/template.js

@@ -6,6 +6,7 @@
  * and `println`. Any other function, `define`, `template` and `block` are refused at parse,
  * and a member the document does not carry fails the rendering.
  */
+import { CHUNK_LENGTH } from "../json-chunks.js";
 import { RenderError } from "./reporter.js";
 import { utf8Bytes } from "./sha256.js";
 /** A template that does not parse, which refuses the invocation before any analysis. */
@@ -735,10 +736,22 @@ function call(name, args) {
 /** One execution of a template over a document. */
 class Execution {
     scopes;
-    out = "";
+    /** The rendering so far, in pieces of about {@link CHUNK_LENGTH}, the last still growing. */
+    pieces = [""];
     constructor(root) {
         this.scopes = [new Map([["$", root]])];
     }
+    write(text) {
+        const last = this.pieces.length - 1;
+        const held = (this.pieces[last] ?? "") + text;
+        if (held.length >= CHUNK_LENGTH) {
+            this.pieces[last] = held;
+            this.pieces.push("");
+        }
+        else {
+            this.pieces[last] = held;
+        }
+    }
     lookup(name) {
         for (let i = this.scopes.length - 1; i >= 0; i -= 1) {
             const scope = this.scopes[i];
@@ -762,7 +775,7 @@ class Execution {
         let held = value;
         for (const name of names) {
             if (!isObject(held)) {
-                throw new RenderError(`can't evaluate field ${name} in a ${kindOf(held)}`);
+                throw new RenderError(`cannot evaluate field ${name} in a ${kindOf(held)}`);
             }
             if (!Object.hasOwn(held, name)) {
                 throw new RenderError(`the document has no member ${JSON.stringify(name)} here`);
@@ -794,7 +807,7 @@ class Execution {
         }
         if (head.k !== "func") {
             if (rest.length > 0 || piped !== undefined) {
-                throw new RenderError("can't give an argument to a non-function");
+                throw new RenderError("cannot give an argument to a non-function");
             }
             return this.arg(head, dot);
         }
@@ -842,12 +855,12 @@ class Execution {
         for (const node of nodes) {
             switch (node.k) {
                 case "text":
-                    this.out += node.text;
+                    this.write(node.text);
                     break;
                 case "action": {
                     const value = this.pipeline(node.pipe, dot, true);
                     if (node.pipe.vars.length === 0) {
-                        this.out += formatted(value, false);
+                        this.write(formatted(value, false));
                     }
                     break;
                 }
@@ -890,7 +903,7 @@ class Execution {
                     .map((key) => [key, value[key] ?? null]);
             }
             else {
-                throw new RenderError(`range can't iterate over a ${kindOf(value)}`);
+                throw new RenderError(`range cannot iterate over a ${kindOf(value)}`);
             }
             if (entries.length === 0) {
                 this.run(node.otherwise, dot);
@@ -925,12 +938,40 @@ class Execution {
     }
 }
 /**
- * The template's rendering of one document. The rendering is built whole, so a template
- * that fails partway renders nothing, and the failure names what it could not evaluate.
+ * One document as the JSON value it encodes: what `JSON.stringify` would write for it,
+ * read back, without writing it. A member holding nothing is left out, and an array
+ * element holding nothing, like a number that is not finite, is null.
+ */
+function plainOf(value) {
+    if (Array.isArray(value)) {
+        return value.map((element) => plainOf(element) ?? null);
+    }
+    if (typeof value === "object" && value !== null) {
+        const held = {};
+        for (const [key, member] of Object.entries(value)) {
+            const plain = plainOf(member);
+            if (plain !== undefined) {
+                held[key] = plain;
+            }
+        }
+        return held;
+    }
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value === "string" || typeof value === "boolean" || value === null) {
+        return value;
+    }
+    return undefined;
+}
+/**
+ * The template's rendering of one document, in pieces of about {@link CHUNK_LENGTH}.
+ * The rendering is complete before it is answered, so a template that fails partway
+ * renders nothing, and the failure names what it could not evaluate.
  */
 export function renderTemplate(template, document) {
-    const root = JSON.parse(JSON.stringify(document));
+    const root = plainOf(document) ?? null;
     const execution = new Execution(root);
     execution.run(template.nodes, root);
-    return execution.out;
+    return execution.pieces.filter((piece) => piece !== "");
 }