@cplieger/deadset-ts 3.13.0 → 4.0.1

package/src/roots.ts

@@ -15,6 +15,7 @@ import { globExpression } from "./glob.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import type { Manifest, ManifestEntry } from "./manifest.ts";
 import { byPosition } from "./position.ts";
+import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { sourceFilesOf } from "./source-files.ts";
 
@@ -70,6 +71,12 @@ export interface Roots {
    * {@link unmatchedEverywhere} is what turns one into the other.
    */
   readonly unmatched: readonly string[];
+  /**
+   * Every declaration of the project, where the checker left the module or export table
+   * of an entry or a published file unanswered, and none otherwise: which of them that
+   * file exports is unknown.
+   */
+  readonly unanswered: readonly string[];
 }
 
 /** What decides the roots beside the declarations themselves. */
@@ -225,7 +232,7 @@ export function roots<Brand>(
     enter(point.file, point.rule, point.source, point.exports);
   }
 
-  const exportsOf = exportTables(project, held, [
+  const { tables: exportsOf, answered } = exportTables(project, held, [
     ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
     ...published,
   ]);
@@ -258,47 +265,62 @@ export function roots<Brand>(
     return site || compare(a.kind, b.kind) || compare(a.source, b.source);
   });
 
-  return { configFile: project.configFile, liveUnderReachability: ordered, unmatched };
+  return {
+    configFile: project.configFile,
+    liveUnderReachability: ordered,
+    unmatched,
+    unanswered: answered ? [] : held.symbols.map((symbol) => symbol.id),
+  };
 }
 
 /**
  * Every declaration each file's module exports, by the file's name: the declaration
  * each name of the export table is, and every link of a re-export's chain. A name
- * whose declaration is outside the project's own files belongs to another program
- * and names nothing here.
- *
- * One batch resolves every file to its module and one request per module reads
- * its export table, star re-exports resolved into it. A file that is no module
- * exports nothing.
+ * whose declaration is outside the project's own files names nothing here. One batch
+ * resolves every file to its module and one request per module reads its export
+ * table, star re-exports resolved into it. A file that is no module exports nothing.
+ * `answered` is false where the checker left a table or a link of a chain unanswered.
  */
 function exportTables<Brand>(
   project: ProjectView<Brand>,
   held: Inventory,
   wanted: readonly SourceFile[],
-): ReadonlyMap<string, readonly string[]> {
+): { readonly tables: ReadonlyMap<string, readonly string[]>; readonly answered: boolean } {
   const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
   const tables = new Map<string, readonly string[]>();
+  let answered = true;
   if (unique.length === 0) {
-    return tables;
+    return { tables, answered };
   }
   const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
   const chains = aliasChains(project, held);
 
+  const topLevel = (file: SourceFile): readonly string[] => {
+    const fileId = held.declarations.get(nodeKey(file, file));
+    return held.symbols.filter((symbol) => symbol.parent === fileId).map((symbol) => symbol.id);
+  };
   unique.forEach((file, index) => {
     const module = modules[index];
     if (module === undefined) {
       tables.set(file.fileName, []);
       return;
     }
+    const table = module === UNANSWERED ? UNANSWERED : project.queries.exportsOfModule(module);
+    if (table === UNANSWERED) {
+      answered = false;
+      tables.set(file.fileName, topLevel(file));
+      return;
+    }
     const ids = new Set<string>();
-    for (const exported of project.checker.getExportsOfModule(module)) {
+    for (const exported of table) {
       for (const target of chains.chainOf(exported)) {
+        answered &&= !target.guessed;
         ids.add(target.id);
       }
     }
     tables.set(file.fileName, [...ids]);
   });
-  return tables;
+  return { tables, answered };
 }
 
 /** The kinds of container whose export table, not its members' visibility, says what it publishes. */

package/src/schema.ts

@@ -261,9 +261,9 @@ export function unimplementedKey(label: string, path: string): ConfigError {
   const nearest = nearestKey(path);
   let hint = "";
   if (nearest === path) {
-    hint = `; ${JSON.stringify(path)} is one setting written as nested objects, not as one key`;
+    hint = `. ${JSON.stringify(path)} is one setting written as nested objects, not as one key`;
   } else if (nearest !== "") {
-    hint = `; the nearest implemented key is ${JSON.stringify(nearest)}`;
+    hint = `. The nearest implemented key is ${JSON.stringify(nearest)}`;
   }
   return new ConfigError(
     "unimplemented-key",

package/src/serialization-contract.ts

@@ -57,6 +57,7 @@ import {
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
+import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import { valueReach, type Reached } from "./value-reach.ts";
 
@@ -316,12 +317,13 @@ function erasedParameters<Brand>(
     if (!parameter.rest) {
       return (type.flags & ERASED) !== 0;
     }
-    const [element] = type.isTypeReference() ? project.checker.getTypeArguments(type) : [];
+    const [element] = must(project.queries.typeArguments(type));
     return element !== undefined && (element.flags & ERASED) !== 0;
   });
   const bySymbol = new Map<number, Parameter>();
   project
     .symbolsAt(erased.map((parameter) => project.handle(parameter.name)))
+    .map(must)
     .forEach((symbol, index) => {
       const parameter = erased[index];
       if (symbol !== undefined && parameter !== undefined) {
@@ -347,11 +349,11 @@ function handedOn<Brand>(
     ),
   );
   const plain = candidates.filter((one) => !one.value.shorthand);
-  const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name)));
+  const resolved = project.symbolsAt(plain.map((one) => project.handle(one.value.name))).map(must);
   const symbolOf = new Map(plain.map((one, index) => [one, resolved[index]]));
   return candidates.flatMap((one) => {
     const symbol = one.value.shorthand
-      ? project.shorthandValueAt(project.handle(one.value.name))
+      ? must(project.shorthandValueAt(project.handle(one.value.name)))
       : symbolOf.get(one);
     const parameter = symbol === undefined ? undefined : erased.get(symbol.id);
     return parameter === undefined ? [] : [{ parameter, site: one.site, argument: one.argument }];
@@ -382,8 +384,8 @@ function destinations<Brand>(
   walked: Walked,
 ): Destinations {
   const { project, held } = input;
-  const checker = project.checker;
-  const own = new Set(project.ownSourceFiles().map((file) => file.fileName));
+  const queries = project.queries;
+  const own = project.ownPaths();
   const named = resolveEntries(project, held, [JSON_STRINGIFY, ...input.ts.serializers]).filter(
     namesADeclaration,
   );
@@ -422,7 +424,7 @@ function destinations<Brand>(
       form !== undefined &&
       method !== undefined &&
       outside(method) &&
-      FUNCTION_INTERFACES.has(method.getParent()?.name ?? "")
+      FUNCTION_INTERFACES.has(must(project.queries.parentOf(method))?.name ?? "")
     ) {
       return form.invocation;
     }
@@ -439,16 +441,16 @@ function destinations<Brand>(
       const invoked = invocation(call);
       // Through a method of the prototype the resolved signature is the method's, so
       // the parameters are read off the callee's own signatures, any one erasing.
-      const type = invoked.indirect ? checker.getTypeAtLocation(invoked.callee) : undefined;
+      const type = invoked.indirect ? must(queries.typeAt(invoked.callee)) : undefined;
       const signatures = invoked.indirect
         ? type === undefined
           ? []
-          : checker.getSignaturesOfType(type, SignatureKind.Call)
-        : [checker.getResolvedSignature(call)].filter((one) => one !== undefined);
+          : must(queries.signaturesOf(type, SignatureKind.Call))
+        : [must(queries.resolvedSignature(call))].filter((one) => one !== undefined);
       indexes = new Set(
         invoked.arguments.flatMap((_unused, index) =>
           signatures.some((signature) => {
-            const parameter = checker.getParameterType(signature, index);
+            const parameter = must(queries.parameterType(signature, index));
             return parameter !== undefined && (parameter.flags & ERASED) !== 0;
           })
             ? [index]

package/src/session.ts

@@ -1,6 +1,6 @@
 import { API, SymbolFlags } from "@typescript/native/unstable/sync";
 import type {
-  Checker,
+  APIRequestGenerator,
   Diagnostic,
   DocumentIdentifier,
   NodeHandle,
@@ -10,9 +10,15 @@ import type {
   Symbol as TSSymbol,
   TimingInfo,
 } from "@typescript/native/unstable/sync";
-import { isIdentifier } from "@typescript/native/unstable/ast";
 import type { Node, SourceFile } from "@typescript/native/unstable/ast";
 import { DiscoveryError } from "./discover.ts";
+import {
+  queriesOf,
+  UnansweredLog,
+  type Answer,
+  type Queries,
+  type UnansweredQuestion,
+} from "./query.ts";
 
 /**
  * The compiler the analysis reads through. It is a client over a protocol to a
@@ -31,7 +37,15 @@ export interface Engine {
    */
   parseConfigFile(file: DocumentIdentifier): ReturnType<API["parseConfigFile"]>;
   /** Opens one snapshot holding every project named. */
-  updateSnapshot(openProjects: readonly string[]): Snapshot;
+  createSnapshot(openProjects: readonly string[]): Snapshot;
+  /** Sends many questions in one round trip and answers each, in order. */
+  batch<T>(questions: readonly APIRequestGenerator<T>[]): T[];
+  /**
+   * Puts one question to a project's checker, by the accessor's name and the locations
+   * it asks about. Every guarded question passes through here, so a caller that
+   * observes or fails questions does it at this seam.
+   */
+  ask<T>(accessor: string, locations: () => readonly string[], question: () => T): T;
   /** Round-trip latency, bytes transferred and server time, when collection is on. */
   getTimingInfo(): TimingInfo;
   /** Releases the client and the process behind it. */
@@ -56,7 +70,10 @@ export function openEngine(options: EngineOptions): Engine {
   let closed = false;
   return {
     parseConfigFile: (file) => api.parseConfigFile(file),
-    updateSnapshot: (openProjects) => api.updateSnapshot({ openProjects: [...openProjects] }),
+    createSnapshot: (openProjects) => api.createSnapshot({ openProjects: [...openProjects] }),
+    batch: <T>(questions: readonly APIRequestGenerator<T>[]) =>
+      api.batch<readonly APIRequestGenerator<T>[]>(...questions),
+    ask: (_accessor, _locations, question) => question(),
     getTimingInfo: () => api.getTimingInfo(),
     close: () => {
       if (closed) {
@@ -90,38 +107,45 @@ export interface ProjectView<Brand> {
   readonly configFile: string;
   /** The project's program, whose walk is local to this process. */
   readonly program: Program;
-  /** The project's checker. Every call on it is a round trip. */
-  readonly checker: Checker;
+  /**
+   * The questions the project's checker answers, each guarded. Every one is a round
+   * trip, and one may go unanswered.
+   */
+  readonly queries: Queries;
   /** The source files the program holds that are the target's own. */
   ownSourceFiles(): readonly SourceFile[];
+  /**
+   * The keys of the target's own files, which is how a declaration handle names the
+   * file it is in.
+   */
+  ownPaths(): ReadonlySet<string>;
   /** A handle to one node of this project's program. */
   handle(node: Node): Handle<Brand>;
   /**
-   * The symbols a batch of this project's nodes resolve to, one round trip for
-   * the batch, in the order the handles were given. The batch is how a file's
-   * identifiers reach the checker, and `undefined` marks a node the batch did not
-   * resolve.
+   * The symbols a batch of this project's nodes resolve to, in the order the handles
+   * were given, in runs of at most `cap`. The batch is how a file's identifiers reach
+   * the checker, and `undefined` marks a node the batch did not resolve.
    */
-  symbolsAt(handles: readonly Handle<Brand>[]): readonly (TSSymbol | undefined)[];
+  symbolsAt(handles: readonly Handle<Brand>[], cap?: number): Answer<TSSymbol | undefined>[];
   /**
    * The symbol one node resolves to, asked for that node alone. The accessor behind
-   * it takes one identifier and offers no array overload, so it is one round trip per
-   * node and it answers only for the residue a batch left unresolved. A node that is
-   * not an identifier has no such answer.
+   * it takes one identifier and offers no array form, so it answers only for the
+   * residue a batch left unresolved. A node that is not an identifier has no such
+   * answer.
    */
-  resolvedSymbolAt(handle: Handle<Brand>): TSSymbol | undefined;
+  resolvedSymbolAt(handle: Handle<Brand>): Answer<TSSymbol | undefined>;
   /**
    * The symbol the value of one shorthand property assignment names, which is the
    * declaration `{ a }` reads; the symbol the property's own name resolves to is the
    * property the literal declares. The handle names the assignment, not its name.
    */
-  shorthandValueAt(handle: Handle<Brand>): TSSymbol | undefined;
+  shorthandValueAt(handle: Handle<Brand>): Answer<TSSymbol | undefined>;
   /**
    * The symbol one alias names, one link along: an import or export specifier
    * resolves to the declaration it carries forward, or to the next alias of a chain.
    * `undefined` where the symbol is no alias, or where the alias resolves to nothing.
    */
-  aliasStepOf(symbol: TSSymbol): TSSymbol | undefined;
+  aliasStepOf(symbol: TSSymbol): Answer<TSSymbol | undefined>;
   /**
    * The node one symbol's declaration handle names, read in this project's program,
    * or `undefined` where this project's program does not hold that file.
@@ -142,49 +166,70 @@ export interface ProjectView<Brand> {
  */
 export type ProjectVisitor<Result> = <Brand>(project: ProjectView<Brand>) => Result;
 
-function viewOf<Brand>(project: Project): ProjectView<Brand> {
+function viewOf<Brand>(
+  project: Project,
+  configFile: string,
+  engine: Engine,
+  log: UnansweredLog,
+): ProjectView<Brand> {
+  const queries = queriesOf(
+    project.checker,
+    configFile,
+    (questions) => engine.batch(questions),
+    log,
+    (accessor, locations, question) => engine.ask(accessor, locations, question),
+  );
   // The snapshot is never updated, so a project's own file set is the same answer
   // every time it is asked for. It is read once because the question is not free:
   // deciding it consults the metadata of every file the program holds, the compiler's
   // own library files included, and a run asks for the set once per pass.
   let ownFiles: readonly SourceFile[] | undefined;
+  let ownKeys: ReadonlySet<string> | undefined;
+  const ownSourceFiles = (): readonly SourceFile[] => {
+    ownFiles ??= project.program
+      .getSourceFileNames()
+      // The metadata decides which files belong to the target, and it is read by
+      // name. Fetching each file first and filtering afterwards costs one round
+      // trip per library file the answer then discards, and a program holds far
+      // more library files than target files.
+      .filter((name) => {
+        const metadata = project.program.getSourceFileMetadata(name);
+        return (
+          metadata !== undefined && !metadata.isDefaultLibrary && !metadata.isFromExternalLibrary
+        );
+      })
+      .map((name) => project.program.getSourceFile(name))
+      .filter((file): file is SourceFile => file !== undefined);
+    return ownFiles;
+  };
   return {
-    configFile: project.configFileName,
+    configFile,
     program: project.program,
-    checker: project.checker,
-    ownSourceFiles: () => {
-      ownFiles ??= project.program
-        .getSourceFileNames()
-        // The metadata decides which files belong to the target, and it is read by
-        // name. Fetching each file first and filtering afterwards costs one round
-        // trip per library file the answer then discards, and a program holds far
-        // more library files than target files.
-        .filter((name) => {
-          const metadata = project.program.getSourceFileMetadata(name);
-          return (
-            metadata !== undefined && !metadata.isDefaultLibrary && !metadata.isFromExternalLibrary
-          );
-        })
-        .map((name) => project.program.getSourceFile(name))
-        .filter((file): file is SourceFile => file !== undefined);
-      return ownFiles;
+    queries,
+    ownSourceFiles,
+    ownPaths: () => {
+      ownKeys ??= new Set(ownSourceFiles().map((file) => file.path));
+      return ownKeys;
     },
     handle: (node) => ({ node }),
-    symbolsAt: (handles) => project.checker.getSymbolAtLocation(handles.map(({ node }) => node)),
-    resolvedSymbolAt: ({ node }) =>
-      isIdentifier(node) ? project.checker.getResolvedSymbol(node) : undefined,
-    shorthandValueAt: ({ node }) => project.checker.getShorthandAssignmentValueSymbol(node),
+    symbolsAt: (handles, cap) =>
+      queries.symbolsAt(
+        handles.map(({ node }) => node),
+        cap,
+      ),
+    resolvedSymbolAt: ({ node }) => queries.resolvedSymbol(node),
+    shorthandValueAt: ({ node }) => queries.shorthandValue(node),
     aliasStepOf: (symbol) => {
       // The step is asked of an alias only: asked of any other symbol, the compiler
       // fails an assertion and the session ends.
       if ((symbol.flags & SymbolFlags.Alias) === 0) {
         return undefined;
       }
-      const held = project.checker.getImmediateAliasedSymbol(symbol);
+      const held = queries.immediateAliased(symbol);
       // An alias that resolves to nothing answers with the checker's own unknown
       // symbol, which declares nothing; a symbol that is no alias answers with
       // nothing at all.
-      return held === undefined || held.declarations.length === 0 ? undefined : held;
+      return typeof held === "object" && held.declarations.length === 0 ? undefined : held;
     },
     declarationAt: (handle) => {
       const node = handle.resolve(project);
@@ -203,11 +248,17 @@ export function narrowedTo<Brand>(
   keep: (file: SourceFile) => boolean,
 ): ProjectView<Brand> {
   let kept: readonly SourceFile[] | undefined;
+  let keys: ReadonlySet<string> | undefined;
+  const ownSourceFiles = (): readonly SourceFile[] => {
+    kept ??= project.ownSourceFiles().filter(keep);
+    return kept;
+  };
   return {
     ...project,
-    ownSourceFiles: () => {
-      kept ??= project.ownSourceFiles().filter(keep);
-      return kept;
+    ownSourceFiles,
+    ownPaths: () => {
+      keys ??= new Set(ownSourceFiles().map((file) => file.path));
+      return keys;
     },
   };
 }
@@ -218,6 +269,11 @@ export interface ProjectDiagnostics {
   readonly syntactic: readonly Diagnostic[];
   readonly semantic: readonly Diagnostic[];
   readonly configParsing: readonly Diagnostic[];
+  /** The line and column of one offset into one of the program's files, counted from one. */
+  readonly locate: (
+    fileName: string,
+    offset: number,
+  ) => { line: number; column: number } | undefined;
 }
 
 /** The three diagnostic sets one project carries, read before any analysis. */
@@ -227,15 +283,31 @@ export function diagnosticsOf<Brand>(project: ProjectView<Brand>): ProjectDiagno
     syntactic: project.program.getSyntacticDiagnostics(),
     semantic: project.program.getSemanticDiagnostics(),
     configParsing: project.program.getConfigFileParsingDiagnostics(),
+    locate: (fileName, offset) => {
+      const file = project.program.getSourceFile(fileName);
+      if (file === undefined || offset < 0 || offset > file.text.length) {
+        return undefined;
+      }
+      const { line, character } = file.getLineAndCharacterOfPosition(offset);
+      return { line: line + 1, column: character + 1 };
+    },
   };
 }
 
 /** One run's result: what the visitor answered for each project, and what it cost. */
 export interface SessionResult<Result> {
+  /** One answer per configuration the snapshot opened a project for, in the order named. */
   readonly projects: readonly Result[];
+  /** The configurations the snapshot opened no project for, in the order named. */
+  readonly unopened: readonly string[];
   readonly timing: TimingInfo;
+  /** Every question the checker could not answer, each once, in the order first asked. */
+  readonly unanswered: readonly UnansweredQuestion[];
 }
 
+/** What a run does about a configuration the snapshot opened no project for. */
+type Unopened = "refuse" | "record";
+
 /**
  * Runs `visit` over every project the compiler configurations name, inside one
  * snapshot of one client, in the order they are named, and answers in that order.
@@ -244,30 +316,46 @@ export interface SessionResult<Result> {
  * with its own program and checker; it is never updated, because the analysis
  * reads and the tree does not change under it. The order the snapshot lists its
  * projects in is the compiler's own, so each named configuration is looked up in it
- * instead, and a configuration the snapshot opened no project for ends the run: the
- * run would otherwise answer for fewer projects than it was asked to analyze. The
- * snapshot is disposed once when the last project has been visited, and the client
- * is released after it, whether the visit completed or threw.
+ * instead. A configuration the snapshot opened no project for ends the run under
+ * `"refuse"` and is named in the result under `"record"`. The snapshot is disposed once
+ * the last project has been visited, and the client is released after it, whether the
+ * visit completed or threw.
  */
 export function runSession<Result>(
   engine: Engine,
   configFiles: readonly string[],
   visit: ProjectVisitor<Result>,
+  unopened: Unopened = "refuse",
 ): SessionResult<Result> {
   try {
-    const snapshot = engine.updateSnapshot(configFiles);
+    const snapshot = engine.createSnapshot(configFiles);
     try {
-      const opened = new Map(
-        snapshot.getProjects().map((project) => [project.configFileName, project]),
-      );
-      const projects = configFiles.map((configFile) => {
+      const opened = new Map<string, Project>();
+      for (const project of snapshot.getProjects()) {
+        if (project.configFileName !== undefined) {
+          opened.set(project.configFileName, project);
+        }
+      }
+      const log = new UnansweredLog();
+      const projects: Result[] = [];
+      const missing: string[] = [];
+      for (const configFile of configFiles) {
         const project = opened.get(configFile);
         if (project === undefined) {
-          throw new DiscoveryError(`${configFile} opened no project`, []);
+          if (unopened === "refuse") {
+            throw new DiscoveryError(`${configFile} opened no project`, []);
+          }
+          missing.push(configFile);
+          continue;
         }
-        return visit(viewOf(project));
-      });
-      return { projects, timing: engine.getTimingInfo() };
+        projects.push(visit(viewOf(project, configFile, engine, log)));
+      }
+      return {
+        projects,
+        unopened: missing,
+        timing: engine.getTimingInfo(),
+        unanswered: log.questions,
+      };
     } finally {
       snapshot.dispose();
     }

package/src/suppress-file.ts

@@ -7,6 +7,7 @@
 
 import type { Host } from "./host.ts";
 import type { InventorySymbol } from "./inventory.ts";
+import { jsonChunks } from "./json-chunks.ts";
 import { joinPath } from "./paths.ts";
 import { positionAt, walkDocument } from "./json-document.ts";
 import type { Position } from "./position.ts";
@@ -292,7 +293,10 @@ export function rowReason(provenance: Provenance): string {
  * identity missing its name or version, are refused rather than written, because the
  * grammar requires a reason on every row.
  */
-export function writeBaseline(findings: readonly Recorded[], provenance: Provenance): string {
+export function writeBaseline(
+  findings: readonly Recorded[],
+  provenance: Provenance,
+): Iterable<string> {
   if (provenance.analyzer === "" || provenance.version === "") {
     throw new Error(
       `a baseline row would carry no reason: the analyzer identity names ${JSON.stringify(provenance.analyzer)} at version ${JSON.stringify(provenance.version)}`,
@@ -307,5 +311,5 @@ export function writeBaseline(findings: readonly Recorded[], provenance: Provena
     }
     return { code: found.code, symbol: found.symbol, path: found.path, reason };
   });
-  return `${JSON.stringify({ description: BASELINE_DESCRIPTION, baseline }, null, 2)}\n`;
+  return jsonChunks({ description: BASELINE_DESCRIPTION, baseline }, 2);
 }

package/src/sweep.ts

@@ -51,6 +51,11 @@ export interface SweepInput {
    * holds nothing back.
    */
   readonly exempt?: readonly Exemption[];
+  /**
+   * The declarations a question the checker did not answer could have kept live. Each
+   * is held as an exempt declaration is. Absent, the sweep holds nothing back for one.
+   */
+  readonly unanswered?: readonly string[];
   readonly mode: Mode;
 }
 
@@ -94,10 +99,10 @@ export interface Liveness {
  */
 export function sweep(graph: Graph, input: SweepInput): Liveness {
   const marked = flagged(graph, input.marked);
-  const exempt = flagged(
-    graph,
-    (input.exempt ?? []).map((record) => record.id),
-  );
+  const exempt = flagged(graph, [
+    ...(input.exempt ?? []).map((record) => record.id),
+    ...(input.unanswered ?? []),
+  ]);
   const held = marked.map((mark, at) => mark || exempt[at] === true);
   // Every root, every mark and every exemption seeds reachability. A root of a kind that
   // names a caller, and a mark, are live under reference counting as well; a root that