@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/src/session.ts

@@ -15,9 +15,7 @@ import type {
 } from "@typescript/native/sync";
 import type { Node, SourceFile } from "@typescript/native/ast";
 import { componentLayer, mapperManifest } from "./component-layer.ts";
-import { DiscoveryError } from "./discover.ts";
 import type { Host, TemporaryDirectory } from "./host.ts";
-import type { WorkspaceProgram } from "./workspace-programs.ts";
 import { joinPath } from "./paths.ts";
 import {
   queriesOf,
@@ -26,6 +24,7 @@ import {
   type Queries,
   type UnansweredQuestion,
 } from "./query.ts";
+import { MANIFEST } from "./fs/manifest.ts";
 
 /**
  * The compiler the analysis reads through: a client over a protocol to a separate
@@ -36,8 +35,8 @@ import {
 export interface Engine {
   /**
    * Resolves one compiler configuration file, or throws with the reason it cannot
-   * be read. The result is spelled through the client's own signature: the type
-   * the compiler package returns here is not one of its exported names.
+   * be read. The result is spelled through the client's own signature: the type the
+   * compiler package returns here is not one of its exported names.
    */
   parseConfigFile(file: DocumentIdentifier): ReturnType<API["parseConfigFile"]>;
   /** Resolves one configuration's JSON as if `configFile` held it, which no file need. */
@@ -82,6 +81,22 @@ export interface Engine {
   close(): void;
 }
 
+/** The most questions one round trip carries. */
+const BATCH = 2048;
+
+/** Asks one question of every item, in round trips of at most {@link BATCH}, answers in order. */
+export function batched<T, A>(
+  engine: Engine,
+  items: readonly T[],
+  question: (item: T) => APIRequestGenerator<A>,
+): A[] {
+  const answers: A[] = [];
+  for (let at = 0; at < items.length; at += BATCH) {
+    answers.push(...engine.batch(items.slice(at, at + BATCH).map(question)));
+  }
+  return answers;
+}
+
 /** How a run opens its compiler client. */
 export interface EngineOptions {
   /** Collect per-request timing, which the calibration record reads. */
@@ -115,7 +130,7 @@ export function openEngine(options: EngineOptions): Engine {
   if (components !== undefined && components.extensions.length > 0) {
     const made = components.host.temporaryDirectory();
     try {
-      components.host.writeDocument(joinPath(made.path, "package.json"), [
+      components.host.writeDocument(joinPath(made.path, MANIFEST), [
         mapperManifest(components.host.componentMapperCommand()),
       ]);
     } catch (error: unknown) {
@@ -271,13 +286,6 @@ export interface ProjectView<Brand> {
  */
 export type ProjectVisitor<Result> = <Brand>(project: ProjectView<Brand>) => Result;
 
-/** One project a session opened: its configuration and the files of its own program. */
-export interface OpenedFiles {
-  readonly configFile: string;
-  /** The program's source files no default library and no external library holds. */
-  readonly fileNames: () => readonly string[];
-}
-
 /**
  * The source files of one program that `own` admits, in the program's order, none of
  * them one of the compiler's default libraries.
@@ -471,19 +479,30 @@ export function diagnosticsOf<Brand>(project: ProjectView<Brand>): ProjectDiagno
   };
 }
 
+/** How a snapshot builds one configuration other than by opening the project it names. */
+export type ProgramBuild =
+  | { readonly kind: "program"; readonly params: CreateSnapshotProgramParams }
+  /** A configuration only the snapshot holds, at a path no file has. */
+  | { readonly kind: "configuration"; readonly file: string; readonly text: string };
+
 /** 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. */
+  /** One answer per configuration, 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";
+/** One open snapshot's projects, valid only while the session that handed it out runs. */
+export interface OpenedSession {
+  /** One view per configuration the snapshot opened a project for, in the order named. */
+  readonly views: readonly ProjectView<unknown>[];
+}
+
+/** How one session opens its configurations. */
+export interface SessionOptions {
+  /** How the snapshot builds each configuration it does not open as its project. */
+  readonly programs?: ReadonlyMap<string, ProgramBuild> | undefined;
+}
 
 /**
  * The projects one snapshot holds for the configurations named, by configuration file. A
@@ -512,22 +531,18 @@ function projectsOf(
 }
 
 /**
- * Runs `visit` over every project the compiler configurations name, inside one never updated
- * snapshot of one client, and answers in their order. A configuration `programs` describes is
- * built as that program, or opened from the configuration it writes. One the snapshot holds
- * nothing for ends the run under `"refuse"` and is named in the result under `"record"`.
- * `first` runs over every opened project before the first visit and `last` after the last,
- * both while the client answers; the snapshot and the client are then released.
+ * Opens every project the compiler configurations name in one never updated snapshot of one
+ * client, and hands them to `use` while the client answers; the snapshot and the client are
+ * then released. A configuration `options.programs` describes is built as that program, or
+ * opened from the configuration it writes. One the snapshot holds nothing for has no view.
  */
-export function runSession<Result>(
+export function openSession<Result>(
   engine: Engine,
   configFiles: readonly string[],
-  visit: ProjectVisitor<Result>,
-  unopened: Unopened = "refuse",
-  programs: ReadonlyMap<string, WorkspaceProgram> = new Map(),
-  last: () => void = () => undefined,
-  first: (opened: readonly OpenedFiles[]) => void = () => undefined,
-): SessionResult<Result> {
+  options: SessionOptions,
+  use: (opened: OpenedSession, unanswered: () => readonly UnansweredQuestion[]) => Result,
+): Result {
+  const programs = options.programs ?? new Map<string, ProgramBuild>();
   try {
     const built: string[] = [];
     const params: CreateSnapshotProgramParams[] = [];
@@ -552,32 +567,13 @@ export function runSession<Result>(
       const opened = projectsOf(snapshot, built, written);
       const log = new UnansweredLog();
       const views: ProjectView<unknown>[] = [];
-      const missing: string[] = [];
       for (const configFile of configFiles) {
         const project = opened.get(configFile);
-        if (project === undefined) {
-          if (unopened === "refuse") {
-            throw new DiscoveryError(`${configFile} opened no project`, []);
-          }
-          missing.push(configFile);
-          continue;
+        if (project !== undefined) {
+          views.push(viewOf(project, configFile, engine, log));
         }
-        views.push(viewOf(project, configFile, engine, log));
       }
-      first(
-        views.map((view) => ({
-          configFile: view.configFile,
-          fileNames: () => view.ownSourceFiles().map((file) => file.fileName),
-        })),
-      );
-      const projects = views.map((view) => visit(view));
-      last();
-      return {
-        projects,
-        unopened: missing,
-        timing: engine.getTimingInfo(),
-        unanswered: log.questions,
-      };
+      return use({ views }, () => log.questions);
     } finally {
       snapshot.dispose();
     }
@@ -585,3 +581,23 @@ export function runSession<Result>(
     engine.close();
   }
 }
+
+/**
+ * Runs `visit` over the project {@link openSession} opens for each configuration, and answers
+ * in their order; a configuration the snapshot opens nothing for throws before any visit.
+ */
+export function runSession<Result>(
+  engine: Engine,
+  configFiles: readonly string[],
+  visit: ProjectVisitor<Result>,
+): SessionResult<Result> {
+  return openSession(engine, configFiles, {}, (opened) => {
+    const unopened = configFiles.find(
+      (configFile) => !opened.views.some((view) => view.configFile === configFile),
+    );
+    if (unopened !== undefined) {
+      throw new Error(`${unopened} opened no project`);
+    }
+    return { projects: opened.views.map((view) => visit(view)), timing: engine.getTimingInfo() };
+  });
+}

package/src/source-files.ts

@@ -5,7 +5,7 @@
  */
 
 import type { SourceFile } from "@typescript/native/ast";
-import { commonDirectory, emittedFrom } from "./emit-map.ts";
+import { commonDirectory, emittedFrom } from "./load/emit-map.ts";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { ProjectView } from "./session.ts";
 

package/src/suppress-file.ts

@@ -5,18 +5,17 @@
  * ignore file by gaining a maintainer's reason.
  */
 
+import { CODE } from "./contract/contract.generated.ts";
 import type { Host } from "./host.ts";
 import type { InventorySymbol } from "./inventory.ts";
+import { readTargetDocument } from "./fs/document.ts";
 import { jsonChunks } from "./json-chunks.ts";
-import { joinPath } from "./paths.ts";
-import { positionAt, walkDocument } from "./json-document.ts";
+import { isRecord, positionAt, readStrict, StrictJSONError } from "./json-document.ts";
 import type { Position } from "./position.ts";
 import { declarationKey } from "./ref.ts";
 import {
   CODE_FORM,
-  SUPPRESSION_WITHOUT_REASON,
   SuppressionError,
-  UNSCOPED_ENTRY,
   blankReason,
   isEntryPath,
   isPartKind,
@@ -27,6 +26,7 @@ import {
   type SuppressionRecord,
   type Suppressions,
 } from "./suppress.ts";
+import { message } from "./product.ts";
 
 /** The name and the location the grammar fixes for the ignore file. */
 export const IGNORE_FILE = "deadset-ignore.json";
@@ -80,10 +80,6 @@ function documentSite(shape: Shape): Position {
   return { path: shape.file, line: 0, column: 0 };
 }
 
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 /** What one entry or row resolves to. */
 interface Read {
   readonly records: readonly SuppressionRecord[];
@@ -101,7 +97,7 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
   const refuse = (text: string, want: string): never => {
     throw new SuppressionError(shape.mechanism, siteText(site), text, want);
   };
-  if (!isObject(value)) {
+  if (!isRecord(value)) {
     return refuse(JSON.stringify(value), shape.recordWant);
   }
   for (const [key, held] of Object.entries(value)) {
@@ -148,10 +144,10 @@ function readRecord(value: unknown, site: Position, byReference: ByReference, sh
   };
   const refusals: Refusal[] = [];
   if (blankReason(reason)) {
-    refusals.push({ ...written, reported: SUPPRESSION_WITHOUT_REASON });
+    refusals.push({ ...written, reported: CODE.suppressionWithoutReason });
   }
   if (written.path === "") {
-    refusals.push({ ...written, reported: UNSCOPED_ENTRY });
+    refusals.push({ ...written, reported: CODE.unscopedIgnoreEntry });
   }
   if (refusals.length > 0) {
     return { records: [], refusals };
@@ -189,30 +185,26 @@ function readDocument(
   symbols: readonly InventorySymbol[],
   shape: Shape,
 ): Suppressions {
-  const file = joinPath(targetRoot, shape.file);
-  if (host.kindOf(file) === "absent") {
+  const text = readTargetDocument(host, targetRoot, shape.file);
+  if (text === undefined) {
     return { records: [], refusals: [] };
   }
-  const text = host.readFile(file);
   const malformed = (detail: string, site = documentSite(shape)): never => {
     throw new SuppressionError(shape.mechanism, siteText(site), detail, shape.documentWant);
   };
-  let parsed: unknown;
+  let document;
   try {
-    parsed = JSON.parse(text);
+    document = readStrict(text, shape.array);
   } catch (error: unknown) {
-    return malformed(`${shape.file}: ${error instanceof Error ? error.message : String(error)}`);
+    if (!(error instanceof StrictJSONError)) {
+      throw error;
+    }
+    return malformed(error.message, positionAt(text, shape.file, error.offset));
   }
-  if (!isObject(parsed)) {
+  const parsed = document.value;
+  if (!isRecord(parsed)) {
     return malformed(shape.file);
   }
-  const walk = walkDocument(text, shape.array);
-  if (walk.twice !== undefined) {
-    malformed(
-      `the member ${JSON.stringify(walk.twice.name)} is written twice, so neither value is chosen`,
-      positionAt(text, shape.file, walk.twice.offset),
-    );
-  }
   for (const key of Object.keys(parsed)) {
     if (key !== "description" && key !== shape.array) {
       malformed(`the member ${JSON.stringify(key)} is not one the grammar declares`);
@@ -228,7 +220,7 @@ function readDocument(
   const records: SuppressionRecord[] = [];
   const refusals: Refusal[] = [];
   (held as readonly unknown[]).forEach((value, index) => {
-    const offset = walk.starts[index];
+    const offset = document.starts.get(index);
     const site = offset === undefined ? documentSite(shape) : positionAt(text, shape.file, offset);
     const read = readRecord(value, site, byReference, shape);
     records.push(...read.records);
@@ -329,9 +321,9 @@ export function otherSchemeRows(text: string, own: string = OWN_SCHEME): readonl
   try {
     parsed = JSON.parse(text);
   } catch (error: unknown) {
-    return refuse(error instanceof Error ? error.message : String(error));
+    return refuse(message(error));
   }
-  const held = isObject(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
+  const held = isRecord(parsed) ? parsed[BASELINE_SHAPE.array] : undefined;
   if (!Array.isArray(held)) {
     return refuse(BASELINE_SHAPE.documentWant);
   }
@@ -339,7 +331,7 @@ export function otherSchemeRows(text: string, own: string = OWN_SCHEME): readonl
     try {
       readRecord(value, documentSite(BASELINE_SHAPE), new Map(), BASELINE_SHAPE);
     } catch (error: unknown) {
-      return refuse(error instanceof Error ? error.message : String(error));
+      return refuse(message(error));
     }
     // readRecord has checked every member is a string and the code and symbol are present.
     const { code, symbol, path, reason } = value as Readonly<Record<string, string>>;
@@ -386,10 +378,9 @@ function* separatorsEscaped(pieces: Iterable<string>): Generator<string, void, u
  * A baseline holding one row per finding, in the order given, which is the report's, and
  * the other language's rows `kept`, Go's rows ahead of TypeScript's and each scheme's in
  * the order given, so two analyzers writing one document in either order write the same
- * bytes, in the form grammar/suppression.md fixes. Every recorded row carries the
- * provenance as its reason. A finding
- * missing a value a row needs, and an identity missing its name or version, are refused
- * rather than written, because the grammar requires a reason on every row.
+ * bytes, in the form grammar/suppression.md fixes. Every row carries the provenance as
+ * its reason, so a finding missing a value a row needs, or an identity missing its name
+ * or version, is refused rather than written.
  */
 export function writeBaseline(
   findings: readonly Recorded[],

package/src/suppress-inline.ts

@@ -4,6 +4,7 @@
  * below it, or on its own line where it trails a token there.
  */
 
+import { CODE } from "./contract/contract.generated.ts";
 import {
   isConstructorDeclaration,
   SyntaxKind,
@@ -18,7 +19,6 @@ import type { ProjectView } from "./session.ts";
 import { signatureOf } from "./signatures.ts";
 import {
   isPartKind,
-  SUPPRESSION_WITHOUT_REASON,
   SuppressionError,
   siteText,
   type Refusal,
@@ -354,7 +354,7 @@ export function inlineSuppressions(
       case "no-reason":
         for (const code of directive.codes) {
           refusals.push({
-            reported: SUPPRESSION_WITHOUT_REASON,
+            reported: CODE.suppressionWithoutReason,
             code,
             symbol: "",
             path: site.path,

package/src/suppress.ts

@@ -7,7 +7,13 @@
  * withholds every such finding anyway, and stale otherwise.
  */
 
-import { ConfigError } from "./config.ts";
+import {
+  type CODE,
+  KIND_ROWS,
+  SYMBOL_SUBJECTS,
+  type Subject,
+} from "./contract/contract.generated.ts";
+import { UsageError } from "./usage.ts";
 import type { Finding } from "./finding.ts";
 import { positionKey, type Position } from "./position.ts";
 import { isRef } from "./ref.ts";
@@ -15,15 +21,6 @@ import { isRef } from "./ref.ts";
 /** Which document a suppression is written in, spelled as a finding carries it. */
 export type Mechanism = "inline" | "ignore" | "baseline";
 
-/** The code a suppression that carries no reason is reported under. */
-export const SUPPRESSION_WITHOUT_REASON = "DS1701";
-
-/** The code an ignore entry or a baseline row that names no path is reported under. */
-export const UNSCOPED_ENTRY = "DS1702";
-
-/** The code a suppression that withholds nothing is reported under. */
-export const STALE_SUPPRESSION = "DS1703";
-
 /**
  * One suppression record: one code bound to one site. A directive naming two codes is two
  * records with one reason, and a directive above a line that declares two symbols is one
@@ -49,7 +46,7 @@ export interface SuppressionRecord {
  * nothing, and its finding reports the suppression as written.
  */
 export interface Refusal {
-  readonly reported: typeof SUPPRESSION_WITHOUT_REASON | typeof UNSCOPED_ENTRY;
+  readonly reported: typeof CODE.suppressionWithoutReason | typeof CODE.unscopedIgnoreEntry;
   readonly code: string;
   /** The reference the entry names, empty for a directive. */
   readonly symbol: string;
@@ -71,9 +68,9 @@ export interface Suppressions {
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
  * answers it with the usage code.
  */
-export class SuppressionError extends ConfigError {
+export class SuppressionError extends UsageError {
   constructor(mechanism: Mechanism, at: string, text: string, want: string) {
-    super("malformed", at, `${mechanism} ${at}: ${text}: want ${want}`);
+    super(`${mechanism} ${at}: ${text}: want ${want}`);
     this.name = "SuppressionError";
   }
 }
@@ -115,6 +112,7 @@ export const GO_REF_EXPRESSIONS: readonly string[] = [
   `^go://${GO_PATH}#${GO_IDENT}$`,
   `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})+$`,
   `^go://${GO_PATH}#${GO_IDENT}(?:\\.${GO_IDENT})?\\[${GO_IDENT}\\]$`,
+  `^go://${GO_PATH}#(?:${GO_IDENT}(?:\\.${GO_IDENT})?)?\\(${GO_IDENT}\\)$`,
   `^go://${GO_PATH}#${GO_FILE}:file$`,
   `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:require$`,
   `^go://${GO_PATH}#${GO_PATH}(?:@${GO_VERSION})?:replace$`,
@@ -157,48 +155,48 @@ export interface Ledger {
   readonly withheld: (finding: Finding) => boolean;
 }
 
-/**
- * The subject kinds that are a dependency row, each with the code that reports one. An
- * ignore entry or a baseline row naming the row's reference and file withholds its finding
- * and marks nothing, and an inline directive never binds one.
- */
-const DEPENDENCY_SUBJECTS: ReadonlyMap<string, readonly string[]> = new Map([
-  ["dependency", ["DS1601"]],
-  ["module-directive", ["DS1605"]],
-]);
+/** The subject of the kind each live code names. */
+const SUBJECT_OF_CODE: ReadonlyMap<string, Subject> = new Map(
+  KIND_ROWS.map((row): [string, Subject] => [row.code, row.subject]),
+);
+
+/** The subject a finding about one symbol kind is about. */
+function subjectOf(kind: string): Subject | undefined {
+  return Object.hasOwn(SYMBOL_SUBJECTS, kind)
+    ? SYMBOL_SUBJECTS[kind as keyof typeof SYMBOL_SUBJECTS]
+    : undefined;
+}
+
+/** Whether a subject is a row of a document rather than a declaration of the program. */
+function rowOf(subject: Subject | undefined): boolean {
+  return subject === "file" || subject === "dependency" || subject === "record";
+}
 
 /**
- * The subject kinds that are a row of a document rather than a declaration of the program,
- * each with the codes that report one. Apart from a dependency row, nothing withholds a
- * finding about one.
+ * Whether a finding's subject is a row of a document rather than a declaration. Apart
+ * from a dependency row, nothing withholds a finding about one.
  */
-const ROW_SUBJECTS: ReadonlyMap<string, readonly string[]> = new Map([
-  ["file", ["DS1501", "DS1502"]],
-  ...DEPENDENCY_SUBJECTS,
-  ["root", ["DS1704"]],
-  ["configured-declaration", ["DS1706"]],
-  ["suppression", ["DS1701", "DS1702", "DS1703"]],
-  ["edge", ["DS1705"]],
-]);
-
-/** Whether a finding's subject is a row of a document rather than a declaration. */
 export function isRowSubject(kind: string): boolean {
-  return ROW_SUBJECTS.has(kind);
+  return rowOf(subjectOf(kind));
 }
 
 /** Whether a code reports a row of a document. */
 export function isRowCode(code: string): boolean {
-  return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+  return rowOf(SUBJECT_OF_CODE.get(code));
 }
 
-/** Whether a finding's subject is a dependency row. */
+/**
+ * Whether a finding's subject is a dependency row. An ignore entry or a baseline row
+ * naming the row's reference and file withholds its finding and marks nothing, and an
+ * inline directive never binds one.
+ */
 export function isDependencySubject(kind: string): boolean {
-  return DEPENDENCY_SUBJECTS.has(kind);
+  return subjectOf(kind) === "dependency";
 }
 
 /** Whether a code reports a dependency row, which only an ignore entry or a baseline row names. */
 export function isDependencyCode(code: string): boolean {
-  return [...DEPENDENCY_SUBJECTS.values()].some((codes) => codes.includes(code));
+  return SUBJECT_OF_CODE.get(code) === "dependency";
 }
 
 /** Whether a code reports a row of a document that no record of any mechanism can name. */
@@ -207,33 +205,20 @@ export function isUnsuppressibleCode(code: string): boolean {
 }
 
 /**
- * The subject kinds that are a part of a declaration rather than a declaration: a part
+ * Whether a finding's subject is a part of the declaration its reference names: a part
  * has no reference of its own, so a finding about one names the declaration that holds
  * it, and the part is decided inside that declaration whatever uses it.
  */
-const PART_SUBJECTS: ReadonlySet<string> = new Set([
-  "parameter",
-  "receiver",
-  "result",
-  "statement",
-  "case",
-  "store",
-]);
-
-/** Whether a finding's subject is a part of the declaration its reference names. */
 export function isPartSubject(kind: string): boolean {
-  return PART_SUBJECTS.has(kind);
+  return subjectOf(kind) === "part";
 }
 
-/** The prefix of the codes of the part kinds, the intra-function range. */
-const PART_KIND_PREFIX = "DS18";
-
 /**
  * Whether a code is a part kind, whose record withholds its finding and marks nothing:
  * the record says the part is wanted, not that the declaration holding it is.
  */
 export function isPartKind(code: string): boolean {
-  return code.startsWith(PART_KIND_PREFIX);
+  return SUBJECT_OF_CODE.get(code) === "part";
 }
 
 /** One finding's identity: its code and the position of the thing it names. */
@@ -253,14 +238,14 @@ export function pairs(record: SuppressionRecord, finding: Finding): boolean {
   if (record.code !== finding.code) {
     return false;
   }
-  if (DEPENDENCY_SUBJECTS.has(finding.symbol.kind)) {
+  if (isDependencySubject(finding.symbol.kind)) {
     return (
       record.mechanism !== "inline" &&
       record.symbol === finding.symbol.ref &&
       record.path === finding.position.path
     );
   }
-  if (ROW_SUBJECTS.has(finding.symbol.kind)) {
+  if (isRowSubject(finding.symbol.kind)) {
     return false;
   }
   if (record.bound !== "" && record.bound === positionKey(finding.position)) {

package/src/sweep.ts

@@ -33,6 +33,8 @@ export interface Exemption {
    * The record holds only while one of them is called through its interface.
    */
   readonly implementing?: Implementing;
+  /** Whether the record holds only where a write the mode counts stores into the declaration. */
+  readonly whileWritten?: true;
 }
 
 /** The interface methods one retained class member implements, and whether its body is empty. */
@@ -195,10 +197,14 @@ export function runnerCalls(symbol: InventorySymbol): boolean {
  * That run's roots are the graph's own and, of each test file, its top level and every
  * function it exports, which a test runner may call, and every export of a manual mock,
  * which the runner reads; any other export of a test file, and test-support code, which
- * runs where a test imports it, are judged as any file's are.
- * `held` seeds it as a mark or an exemption seeds a sweep.
+ * runs where a test imports it, are judged as any file's are. `held` seeds it as a mark
+ * seeds a sweep; with `namespaces` false a file read reaches none of the file's exports.
  */
-export function reachedWithTheTests(graph: Graph, held: readonly string[]): readonly boolean[] {
+export function reachedWithTheTests(
+  graph: Graph,
+  held: readonly string[],
+  namespaces = true,
+): readonly boolean[] {
   const tests = graph.symbols.flatMap((symbol, at) => {
     const exported = symbol.exported && graph.symbols[graph.parent[at] ?? OUTSIDE]?.kind === "file";
     const called = exported && runnerCalls(symbol);
@@ -208,9 +214,12 @@ export function reachedWithTheTests(graph: Graph, held: readonly string[]): read
       ? [{ at, kind: "test-runner" as const }]
       : [];
   });
-  return reachable({ ...graph, rooted: [...graph.rooted, ...tests] }, flagged(graph, held), {
-    production: false,
-  });
+  return reachable(
+    { ...graph, rooted: [...graph.rooted, ...tests] },
+    flagged(graph, held),
+    { production: false },
+    namespaces,
+  );
 }
 
 /**
@@ -240,7 +249,12 @@ function flagged(graph: Graph, ids: readonly string[]): boolean[] {
  * included, while a root reaches through the references the mode counts. The held seed
  * runs first, so what it reaches is expanded under the wider rule.
  */
-function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly boolean[] {
+function reachable(
+  graph: Graph,
+  held: readonly boolean[],
+  mode: Mode,
+  namespaces = true,
+): readonly boolean[] {
   const reached = graph.symbols.map(() => false);
   const expanded = graph.symbols.map(() => false);
   const queue: number[] = [];
@@ -269,7 +283,7 @@ function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly
         if (!holding && mode.production && edge.test) {
           continue;
         }
-        enter(edge.to, !edge.evaluation);
+        enter(edge.to, namespaces && !edge.evaluation);
       }
     }
   };
@@ -285,7 +299,7 @@ function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly
   }
   // A consumer's reference reaches what it names as one of the target's own does.
   for (const edge of callsOf(graph, mode)) {
-    enter(edge.to, !edge.evaluation);
+    enter(edge.to, namespaces && !edge.evaluation);
   }
   walk(false);
   return reached;