@cplieger/deadset-ts 3.13.0 → 4.0.0

package/src/references.ts

@@ -28,12 +28,13 @@ import {
   type SourceFile,
 } from "@typescript/native/unstable/ast";
 import type { Symbol as TSSymbol } from "@typescript/native/unstable/sync";
-import { aliasChains } from "./alias-chain.ts";
+import { aliasChains, type ChainTarget } from "./alias-chain.ts";
 import { destructuring, propertyReadsOf, type PropertyRead } from "./destructuring.ts";
 import { globExpression } from "./glob.ts";
-import { nodeKey, type Inventory } from "./inventory.ts";
+import { declarationsByName, nodeKey, type Inventory } from "./inventory.ts";
 import { relativePath } from "./paths.ts";
 import { byPosition, renderPosition, type Position } from "./position.ts";
+import { DEFAULT_BATCH_CAP, UNANSWERED, type Answer } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /**
@@ -63,21 +64,15 @@ import type { ProjectView } from "./session.ts";
 export type Use = "read" | "write" | "evaluation" | "decorator";
 
 /**
- * Which accessor answered for one reference, so that the cost of a run is attributable
- * and a table of references shows the path each row took.
- *
- * - `batch` is the batched lookup over a file's name nodes, which answers for almost
- *   every one of them.
- * - `resolved-symbol` is the per-node lookup for the residue a batch left.
- * - `shorthand` is the per-node lookup for `{ a }`, whose name resolves to the property
- *   the literal declares rather than to the declaration that name reads.
- * - `alias` is a step along an import or export chain, from one link to what it names.
- * - `syntax` is the tree alone, which says what a decorator is attached to.
- * - `destructured` is the property a pattern names, looked up on the type of the value
- *   the pattern destructures.
+ * Which path answered for one reference: `batch`, the batched lookup over a file's name
+ * nodes; `resolved-symbol`, the per-node lookup for the residue a batch left;
+ * `shorthand`, the lookup for the value `{ a }` reads; `alias`, a step along an import
+ * or export chain; `syntax`, the tree alone, which says what a decorator is attached to;
+ * `destructured`, the property a pattern names, on the destructured value's type; and
+ * `by-name`, every declaration bearing the name a site spells, where the checker failed.
  */
 export type Resolution =
-  "batch" | "resolved-symbol" | "shorthand" | "alias" | "syntax" | "destructured";
+  "batch" | "resolved-symbol" | "shorthand" | "alias" | "syntax" | "destructured" | "by-name";
 
 /** One use of one declaration by one declaration. */
 export interface Reference {
@@ -187,13 +182,6 @@ export interface ReferenceOptions {
   readonly consumer?: ConsumerSide;
 }
 
-/**
- * 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;
-
 /**
  * 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
@@ -564,6 +552,53 @@ export function testFileRulesOf(
     .sort((a, b) => compare(a.rule, b.rule));
 }
 
+const importedCache = new WeakMap<
+  SourceFile,
+  ReadonlyMap<string, readonly (string | undefined)[]>
+>();
+
+/**
+ * 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: SourceFile): ReadonlyMap<string, readonly (string | undefined)[]> {
+  const known = importedCache.get(file);
+  if (known !== undefined) {
+    return known;
+  }
+  const names = new Map<string, (string | undefined)[]>();
+  const bind = (local: string, imported: string | undefined): void => {
+    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: string, b: string): number {
   if (a === b) {
@@ -633,17 +668,42 @@ export function references<Brand>(
    * 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: Link, symbol: TSSymbol): readonly string[] =>
-    link.alias ? chains.nextDeclared(symbol) : chains.declarationsOf(symbol);
+  const carriedBy = (link: Link, symbol: TSSymbol): readonly ChainTarget[] =>
+    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: Node): readonly string[] => {
+    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: Site, answered: ReadonlyMap<Node, TSSymbol>): TSSymbol | undefined => {
+  const symbolFor = (
+    site: Site,
+    answered: ReadonlyMap<Node, Answer<TSSymbol>>,
+  ): Answer<TSSymbol | undefined> => {
     if (site.shorthand !== undefined) {
       shorthandLookups += 1;
       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;
@@ -688,11 +748,14 @@ export function references<Brand>(
         ...evaluations.map((evaluation) => evaluation.node),
       ]),
     ];
-    const answered = new Map<Node, TSSymbol>();
+    const answered = new Map<Node, Answer<TSSymbol>>();
     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];
@@ -708,13 +771,17 @@ export function references<Brand>(
         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,
         });
       }
@@ -726,14 +793,16 @@ export function references<Brand>(
         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,
           });
         }
@@ -748,13 +817,21 @@ export function references<Brand>(
         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,
         });
       }
@@ -764,7 +841,7 @@ export function references<Brand>(
       const direct: Resolution =
         site.shorthand !== undefined
           ? "shorthand"
-          : answered.has(site.node)
+          : typeof answered.get(site.node) === "object"
             ? "batch"
             : "resolved-symbol";
       const symbol = symbolFor(site, answered);
@@ -774,13 +851,17 @@ export function references<Brand>(
       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/src/reflective-lookup.ts

@@ -24,10 +24,10 @@ import {
   type SourceFile,
 } from "@typescript/native/unstable/ast";
 import { TypeFlags, type Type } from "@typescript/native/unstable/sync";
-import { typesAt } from "./class-members.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import { memberNames } from "./member-names.ts";
 import { renderPosition } from "./position.ts";
+import { isAnswered, UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** The `Reflect` methods whose second argument is a property key. */
@@ -95,14 +95,17 @@ function lookupsOf(file: SourceFile): readonly Lookup[] {
   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<Brand>(project: ProjectView<Brand>, type: Type): boolean {
   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);
 }
 
 /**
@@ -119,7 +122,7 @@ export function reflectiveLookup<Brand>(input: DetectorInput<Brand>): readonly E
 
   // 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],
   );
@@ -127,9 +130,11 @@ export function reflectiveLookup<Brand>(input: DetectorInput<Brand>): readonly E
   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);
       }
@@ -142,9 +147,14 @@ export function reflectiveLookup<Brand>(input: DetectorInput<Brand>): readonly E
     lookup.receiver === undefined ? [] : [lookup.receiver],
   );
   const mapped = new Set<Node>();
-  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/src/report.ts

@@ -142,6 +142,15 @@ export interface ReportConfiguration {
   readonly project: string;
 }
 
+/** One project configuration the run derived and could not build, with why. */
+export interface ReportNotBuilt {
+  readonly id: string;
+  /** The compiler configuration file below the target root. */
+  readonly project: string;
+  /** The first line of the error that dropped it, naming no path outside the target. */
+  readonly error: string;
+}
+
 /** One consumer the run loaded, at the directory a report names it by. */
 interface ReportConsumer {
   readonly id: string;
@@ -172,7 +181,7 @@ export interface Report {
   };
   readonly target: { readonly kind: TargetKind; readonly root: string; readonly identity: string };
   readonly configurations: readonly ReportConfiguration[];
-  readonly configurations_not_built: readonly never[];
+  readonly configurations_not_built: readonly ReportNotBuilt[];
   readonly consumers: {
     readonly declared: number;
     readonly loaded: readonly {
@@ -203,6 +212,7 @@ export interface ReportInput {
   readonly declaredGaps: readonly DeclaredGap[];
   readonly target: { readonly kind: TargetKind; readonly root: string; readonly identity: string };
   readonly configurations: readonly ReportConfiguration[];
+  readonly notBuilt: readonly ReportNotBuilt[];
   readonly loaded: readonly ReportConsumer[];
   readonly unavailable: readonly UnavailableConsumer[];
   readonly result: PassResult;
@@ -436,7 +446,9 @@ export function buildReport(input: ReportInput): Report {
     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/src/reporters/annotations.ts

@@ -1,4 +1,5 @@
 import { fails } from "../config.ts";
+import { coalesced } from "../json-chunks.ts";
 import { KINDS } from "../kinds.ts";
 import type { Report } from "../report.ts";
 import type { RenderOptions } from "./reporter.ts";
@@ -42,26 +43,27 @@ function command(
  * failing severity is an error and one below it a warning; a stale suppression is an error,
  * because its kind is fixed on at the failing severity.
  */
-export function annotations(report: Report, options: RenderOptions): string {
-  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,
-    ),
+export function annotations(report: Report, options: RenderOptions): Iterable<string> {
+  return coalesced(
+    (function* lines(): Generator<string, void, undefined> {
+      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`;
+      }
+    })(),
   );
-  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("");
 }

package/src/reporters/json.ts

@@ -1,7 +1,8 @@
+import { jsonChunks } from "../json-chunks.ts";
 import type { Report } from "../report.ts";
 
 /** 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: Report): string => `${JSON.stringify(report, null, INDENT)}\n`;
+/** The report document itself, in pieces: the report, indented, with a closing newline. */
+export const json = (report: Report): Iterable<string> => jsonChunks(report, INDENT);

package/src/reporters/reporter.ts

@@ -12,8 +12,8 @@ export interface RenderOptions {
   readonly template: Template | undefined;
 }
 
-/** One rendering of a report, as the text of the file it is written to. */
-type Reporter = (report: Report, options: RenderOptions) => string;
+/** One rendering of a report, as the pieces of the file it is written to, in order. */
+type Reporter = (report: Report, options: RenderOptions) => Iterable<string>;
 
 /**
  * One format this analyzer renders: its reporter, and the suffix appended to the report's

package/src/reporters/sarif.ts

@@ -1,4 +1,5 @@
 import type { Confidence, Severity } from "../config.ts";
+import { jsonChunks } from "../json-chunks.ts";
 import { KINDS, type KindRow } from "../kinds.ts";
 import type { Report, WireFinding, WireStaleSuppression } from "../report.ts";
 import { lineHashes, symbolFingerprint } from "./fingerprint.ts";
@@ -260,7 +261,7 @@ function staleResult(
  * count it. A file the rendering cannot read, or a line it does not hold, fails the
  * rendering, because a line fingerprint computed from other bytes opens a second alert.
  */
-export function sarif(report: Report, options: RenderOptions): string {
+export function sarif(report: Report, options: RenderOptions): Iterable<string> {
   const kinds = kindsOf(report.analyzer.languages);
   const ruleList = rules(kinds);
   const index = new Map(kinds.map((kind, at) => [kind.code, at]));
@@ -291,5 +292,5 @@ export function sarif(report: Report, options: RenderOptions): string {
       },
     ],
   };
-  return `${JSON.stringify(log, null, INDENT)}\n`;
+  return jsonChunks(log, INDENT);
 }

package/src/reporters/template.ts

@@ -7,6 +7,7 @@
  * and a member the document does not carry fails the rendering.
  */
 
+import { CHUNK_LENGTH } from "../json-chunks.ts";
 import { RenderError } from "./reporter.ts";
 import { utf8Bytes } from "./sha256.ts";
 
@@ -849,12 +850,24 @@ function call(name: string, args: readonly Value[]): Value {
 /** One execution of a template over a document. */
 class Execution {
   private readonly scopes: Map<string, Value>[];
-  out = "";
+  /** The rendering so far, in pieces of about {@link CHUNK_LENGTH}, the last still growing. */
+  readonly pieces: string[] = [""];
 
   constructor(root: Value) {
     this.scopes = [new Map([["$", root]])];
   }
 
+  private write(text: string): void {
+    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;
+    }
+  }
+
   private lookup(name: string): Value {
     for (let i = this.scopes.length - 1; i >= 0; i -= 1) {
       const scope = this.scopes[i];
@@ -963,12 +976,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;
         }
@@ -1041,12 +1054,41 @@ 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: unknown): Value | undefined {
+  if (Array.isArray(value)) {
+    return value.map((element: unknown) => plainOf(element) ?? null);
+  }
+  if (typeof value === "object" && value !== null) {
+    const held: Record<string, Value> = {};
+    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: Template, document: unknown): string {
-  const root = JSON.parse(JSON.stringify(document)) as Value;
+export function renderTemplate(template: Template, document: unknown): readonly string[] {
+  const root = plainOf(document) ?? null;
   const execution = new Execution(root);
   execution.run(template.nodes, root);
-  return execution.out;
+  return execution.pieces.filter((piece) => piece !== "");
 }

package/src/reporters/text.ts

@@ -1,3 +1,4 @@
+import { coalesced } from "../json-chunks.ts";
 import type { Report, WireTotals } from "../report.ts";
 
 /** The kind token and the confidence a stale suppression is rendered with, both fixed. */
@@ -29,16 +30,15 @@ function summary(totals: WireTotals): string {
  * summary is deliberately not in that shape, so a filter for finding lines yields exactly
  * them. Nothing else is written: no timestamp, duration or host detail.
  */
-export const text = (report: Report): string => {
-  const lines = report.findings.map(
-    (found) =>
-      `${found.position.path}:${String(found.position.line)}:${String(found.position.column)}: ${found.symbol.kind} ${found.symbol.name}: ${found.message} [${found.confidence}] (${found.code})`,
+export const text = (report: Report): Iterable<string> =>
+  coalesced(
+    (function* lines(): Generator<string, void, undefined> {
+      for (const found of report.findings) {
+        yield `${found.position.path}:${String(found.position.line)}:${String(found.position.column)}: ${found.symbol.kind} ${found.symbol.name}: ${found.message} [${found.confidence}] (${found.code})\n`;
+      }
+      for (const stale of report.stale_suppressions) {
+        yield `${stale.position.path}:${String(stale.position.line)}:${String(stale.position.column)}: ${STALE_KIND} ${stale.symbol}: ${stale.message} [${STALE_CONFIDENCE}] (${stale.code})\n`;
+      }
+      yield `${summary(report.totals)}\n`;
+    })(),
   );
-  for (const stale of report.stale_suppressions) {
-    lines.push(
-      `${stale.position.path}:${String(stale.position.line)}:${String(stale.position.column)}: ${STALE_KIND} ${stale.symbol}: ${stale.message} [${STALE_CONFIDENCE}] (${stale.code})`,
-    );
-  }
-  lines.push(summary(report.totals));
-  return `${lines.join("\n")}\n`;
-};