@cplieger/deadset-ts 6.1.1-dev.1 → 7.0.0-dev.2

package/src/suppress.ts

@@ -65,9 +65,6 @@ export interface Suppressions {
   readonly refusals: readonly Refusal[];
 }
 
-/** A target that carries no suppression. */
-export const NO_SUPPRESSIONS: Suppressions = { records: [], refusals: [] };
-
 /**
  * A directive, an entry or a document the grammar refuses before any finding exists: an
  * instruction the analysis cannot carry out. It is a malformed input, so the command line
@@ -151,27 +148,26 @@ export interface Dials<F extends Finding = Finding> {
 }
 
 /** What every record did, and the findings the records withhold. */
-export interface Ledger<F extends Finding = Finding> {
+export interface Ledger {
   /** One verdict per record, in reading order. */
   readonly verdicts: readonly Verdict[];
-  /** Per record, the finding it claimed, where it claimed one. */
-  readonly claims: readonly (F | undefined)[];
   /** Whether a record withholds one finding of the run. */
   readonly withheld: (finding: Finding) => boolean;
 }
 
 /**
- * The subject kinds that are a row of a document rather than a declaration of the program.
- * A record binds to a declaration, so nothing withholds a finding about one.
+ * The subject kinds that are a row of a document rather than a declaration of the program,
+ * each with the codes that report one. A record binds to a declaration, so nothing
+ * withholds a finding about one.
  */
-const ROW_SUBJECTS: ReadonlySet<string> = new Set([
-  "file",
-  "dependency",
-  "module-directive",
-  "root",
-  "configured-declaration",
-  "suppression",
-  "edge",
+const ROW_SUBJECTS: ReadonlyMap<string, readonly string[]> = new Map([
+  ["file", ["DS1501", "DS1502"]],
+  ["dependency", ["DS1601"]],
+  ["module-directive", ["DS1605"]],
+  ["root", ["DS1704"]],
+  ["configured-declaration", ["DS1706"]],
+  ["suppression", ["DS1701", "DS1702", "DS1703"]],
+  ["edge", ["DS1705"]],
 ]);
 
 /** Whether a finding's subject is a row of a document, which no record can withhold. */
@@ -179,6 +175,11 @@ export function isRowSubject(kind: string): boolean {
   return ROW_SUBJECTS.has(kind);
 }
 
+/** Whether a code reports a row of a document, so no record naming it can match. */
+export function isRowCode(code: string): boolean {
+  return [...ROW_SUBJECTS.values()].some((codes) => codes.includes(code));
+}
+
 /**
  * The subject kinds that are a part of a declaration rather than a declaration: a part
  * has no reference of its own, so a finding about one names the declaration that holds
@@ -242,20 +243,17 @@ export function ledgerOf<F extends Finding>(
   records: readonly SuppressionRecord[],
   would: readonly F[],
   dials: Dials<F>,
-): Ledger<F> {
+): Ledger {
   const taken = new Set<string>();
   const verdicts: Verdict[] = [];
-  const claims: (F | undefined)[] = [];
   for (const record of records) {
     if (record.bound !== "" && dials.withholdsCode(record.code, record.bound)) {
       verdicts.push("dormant");
-      claims.push(undefined);
       continue;
     }
     const claimed = would.find(
       (finding) => !taken.has(claimKey(finding)) && pairs(record, finding),
     );
-    claims.push(claimed);
     if (claimed === undefined) {
       verdicts.push("stale");
       continue;
@@ -265,13 +263,12 @@ export function ledgerOf<F extends Finding>(
   }
   return {
     verdicts,
-    claims,
     withheld: (finding) => taken.has(claimKey(finding)) && !ROW_SUBJECTS.has(finding.symbol.kind),
   };
 }
 
 /** The two suppression counts a report's totals carry. */
-export interface SuppressionCounts {
+interface SuppressionCounts {
   /** The records in effect. */
   readonly inEffect: number;
   /** The directives, entries and rows that carry a reason, each once whatever its codes. */
@@ -279,9 +276,9 @@ export interface SuppressionCounts {
 }
 
 /** The suppression counts of one run's records and the ledger over them. */
-export function suppressionCounts<F extends Finding>(
+export function suppressionCounts(
   records: readonly SuppressionRecord[],
-  ledger: Ledger<F>,
+  ledger: Ledger,
 ): SuppressionCounts {
   const sites = new Set(
     records.map((record) => `${record.mechanism}\u0000${positionKey(record.site)}`),

package/src/sweep.ts

@@ -278,34 +278,46 @@ function reachable(graph: Graph, held: readonly boolean[], mode: Mode): readonly
 /**
  * Admits every test declaration whose set of referenced production declarations is
  * non-empty and wholly dead, and returns which it admitted. The set is read from every
- * reference the test makes, not the ones the mode counts: a production sweep counts none,
- * which is what makes the targets dead. A test referencing one live target is never
- * admitted, and neither is a marked or exempt test.
+ * reference the test makes, which a production sweep does not count. A test-support
+ * declaration that a test referencing a live target also references is a live target of
+ * every test referencing it. A marked or exempt test is never admitted.
  */
 function admitTestsOfDeadCode(
   graph: Graph,
   dead: boolean[],
   held: readonly boolean[],
 ): readonly boolean[] {
-  const admitted = graph.symbols.map(() => false);
-  graph.symbols.forEach((_symbol, at) => {
-    const testCode = graph.test[at] === true || graph.support[at] === true;
-    if (!testCode || graph.subject[at] !== true || held[at] === true) {
-      return;
-    }
+  const testCode = (at: number): boolean => graph.test[at] === true || graph.support[at] === true;
+  const judged = graph.symbols.map((_symbol, at) => {
     let targets = 0;
     let live = 0;
-    for (const edge of graph.out[at] ?? []) {
-      const target = graph.test[edge.to] === true || graph.support[edge.to] === true;
-      if (target || graph.subject[edge.to] !== true) {
-        continue;
+    if (testCode(at) && graph.subject[at] === true && held[at] !== true) {
+      for (const edge of graph.out[at] ?? []) {
+        if (testCode(edge.to) || graph.subject[edge.to] !== true) {
+          continue;
+        }
+        targets += 1;
+        if (dead[edge.to] !== true) {
+          live += 1;
+        }
       }
-      targets += 1;
-      if (dead[edge.to] !== true) {
-        live += 1;
+    }
+    return { targets, live };
+  });
+  const shared = new Set<number>();
+  judged.forEach(({ live }, at) => {
+    if (live > 0) {
+      for (const edge of graph.out[at] ?? []) {
+        if (graph.support[edge.to] === true) {
+          shared.add(edge.to);
+        }
       }
     }
-    if (targets > 0 && live === 0) {
+  });
+  const admitted = graph.symbols.map(() => false);
+  judged.forEach(({ targets, live }, at) => {
+    const sharing = (graph.out[at] ?? []).some((edge) => shared.has(edge.to) && edge.to !== at);
+    if (targets > 0 && live === 0 && !sharing) {
       dead[at] = true;
       admitted[at] = true;
     }

package/src/symbol-keys.ts

@@ -0,0 +1,172 @@
+/**
+ * The members a unique symbol keys, used through element accesses. `value[key]`, where
+ * `key` is a constant of a `unique symbol` type, reads the member of the receiver's type
+ * whose computed name is that same constant, and a store through the access writes it.
+ * No name node resolves to such a member: the key's name resolves to the constant.
+ */
+
+import {
+  isComputedPropertyName,
+  isIdentifier,
+  isNoSubstitutionTemplateLiteral,
+  isNumericLiteral,
+  isParenthesizedExpression,
+  isPropertyAccessExpression,
+  isStringLiteral,
+  type ElementAccessExpression,
+  type Node,
+} from "@typescript/native/unstable/ast";
+import type { Symbol as TSSymbol, Type } from "@typescript/native/unstable/sync";
+import type { AliasChains } from "./alias-chain.ts";
+import type { InventorySymbol } from "./inventory.ts";
+import { isAnswered, type PropertyTables } from "./query.ts";
+import type { ProjectView } from "./session.ts";
+
+/** One element access whose key is a name, and how the access uses the member it selects. */
+export interface KeyedAccess {
+  readonly access: ElementAccessExpression;
+  /** The identifier whose symbol is the key: the argument, or the name its property access ends in. */
+  readonly key: Node;
+  readonly from: string;
+  readonly use: "read" | "write" | "both";
+}
+
+/** One keyed access with the symbol its key resolved to. */
+interface ResolvedKey {
+  readonly access: KeyedAccess;
+  readonly symbol: TSSymbol;
+}
+
+/** The members one keyed access selects, by their inventory identifiers. */
+interface KeyedUse {
+  readonly access: KeyedAccess;
+  readonly ids: readonly string[];
+}
+
+/** The identifier an element access's argument names its key by, where it is a name. */
+export function keyNameOf(argument: Node): Node | undefined {
+  let at = argument;
+  while (isParenthesizedExpression(at)) {
+    at = at.expression;
+  }
+  if (isIdentifier(at)) {
+    return at;
+  }
+  return isPropertyAccessExpression(at) && isIdentifier(at.name) ? at.name : undefined;
+}
+
+/**
+ * The last identifier of each computed member name the inventory holds, `mark` for
+ * `[mark]` and `iterator` for `[Symbol.iterator]`: an access whose key is spelled by no
+ * such identifier selects no member a unique symbol keys, and is not asked about.
+ */
+export function computedKeyNames(symbols: readonly InventorySymbol[]): ReadonlySet<string> {
+  const names = new Set<string>();
+  for (const symbol of symbols) {
+    const key = /\[([^\]]+)\]$/u.exec(symbol.name)?.[1];
+    const last = key?.split(".").pop()?.trim();
+    if (last !== undefined && /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(last)) {
+      names.add(last);
+    }
+  }
+  return names;
+}
+
+/** Whether a computed name's expression is literal text, which names a member by its text. */
+function isLiteralKey(expression: Node): boolean {
+  return (
+    isStringLiteral(expression) ||
+    isNumericLiteral(expression) ||
+    isNoSubstitutionTemplateLiteral(expression)
+  );
+}
+
+/**
+ * The members each keyed access selects. The receivers' types are asked in one batch,
+ * each object type's properties once, and the key of every property declared under a
+ * computed name in one batch more; a property is selected where its key and the
+ * access's key are one symbol.
+ */
+export function keyedUses<Brand>(
+  project: ProjectView<Brand>,
+  chains: AliasChains,
+  resolved: readonly ResolvedKey[],
+  properties: PropertyTables,
+  cap: number,
+): readonly KeyedUse[] {
+  if (resolved.length === 0) {
+    return [];
+  }
+  const queries = project.queries;
+  const ownPaths = project.ownPaths();
+  const types = queries.typesAt(
+    resolved.map((one) => one.access.access.expression),
+    cap,
+  );
+
+  const parts = new Map<number, readonly Type[]>();
+  const partsOf = (type: Type): readonly Type[] => {
+    const known = parts.get(type.id);
+    if (known !== undefined) {
+      return known;
+    }
+    let found: readonly Type[] = [];
+    if (type.isUnionType() || type.isIntersectionType()) {
+      const constituents = queries.constituents(type);
+      found = isAnswered(constituents) ? constituents.flatMap(partsOf) : [];
+    } else if (type.isObjectType()) {
+      found = [type];
+    }
+    parts.set(type.id, found);
+    return found;
+  };
+
+  /** Each receiver's properties declared in the target under a computed name, with that name's expression. */
+  const candidates = new Map<number, { property: TSSymbol; key: Node }[]>();
+  const keyNodes: Node[] = [];
+  const candidatesOf = (type: Type): readonly { property: TSSymbol; key: Node }[] => {
+    const known = candidates.get(type.id);
+    if (known !== undefined) {
+      return known;
+    }
+    const found: { property: TSSymbol; key: Node }[] = [];
+    const read = properties.of(type);
+    for (const property of isAnswered(read.properties) ? read.properties : []) {
+      const handle = property.declarations.find((one) => ownPaths.has(one.path));
+      const node = handle === undefined ? undefined : project.declarationAt(handle)?.node;
+      const name = (node as { readonly name?: Node } | undefined)?.name;
+      if (name !== undefined && isComputedPropertyName(name) && !isLiteralKey(name.expression)) {
+        found.push({ property, key: name.expression });
+        keyNodes.push(name.expression);
+      }
+    }
+    candidates.set(type.id, found);
+    return found;
+  };
+
+  const perAccess = resolved.map((_one, index) => {
+    const type = types[index];
+    return type === undefined || !isAnswered(type) ? [] : partsOf(type).flatMap(candidatesOf);
+  });
+  const keyOf = new Map<Node, number>();
+  const asked = [...new Set(keyNodes)];
+  (asked.length === 0
+    ? []
+    : project.symbolsAt(
+        asked.map((node) => project.handle(node)),
+        cap,
+      )
+  ).forEach((symbol, index) => {
+    const node = asked[index];
+    if (node !== undefined && symbol !== undefined && isAnswered(symbol)) {
+      keyOf.set(node, symbol.id);
+    }
+  });
+
+  return resolved.flatMap((one, index) => {
+    const ids = (perAccess[index] ?? [])
+      .filter((candidate) => keyOf.get(candidate.key) === one.symbol.id)
+      .flatMap((candidate) => chains.declarationsOf(candidate.property));
+    return ids.length === 0 ? [] : [{ access: one.access, ids: [...new Set(ids)] }];
+  });
+}

package/src/template-field.ts

@@ -22,7 +22,7 @@ import { isAbsolutePath, joinPath, normalizePath, relativePath } from "./paths.t
 import { isComponentFile, type Position } from "./position.ts";
 
 /** One template, by its path below the target root. */
-export interface TemplateFile {
+interface TemplateFile {
   readonly path: string;
   readonly text: string;
 }

package/src/test-joins.ts

@@ -0,0 +1,120 @@
+/**
+ * The test files a derived matrix holds although no configuration's file list names them.
+ * The test runner compiles such a file with the options of the nearest compiler
+ * configuration at or above it, so the file joins that configuration's program as a file
+ * its list names, unless a `package.json` below that configuration's directory makes the
+ * file another package's, which its own test runner compiles.
+ */
+
+import { sourcePaths } from "./file-facts.ts";
+import type { Host } from "./host.ts";
+import { dirnamePath, joinPath, relativePath } from "./paths.ts";
+import type { Engine } from "./session.ts";
+import { writtenPath, type WorkspaceProgram } from "./workspace-programs.ts";
+
+const PREFERRED = "/tsconfig.json";
+
+/** The configurations of one directory in the order a file joins them: `tsconfig.json` first. */
+function byPreference(a: string, b: string): number {
+  const first = a.endsWith(PREFERRED) ? 0 : 1;
+  const second = b.endsWith(PREFERRED) ? 0 : 1;
+  return first - second || (a < b ? -1 : a > b ? 1 : 0);
+}
+
+/**
+ * Per configuration of `configFiles`, the absolute paths of the test files that join it:
+ * each file below `root` a pattern of `patterns` names, that no configuration's file list
+ * holds, joins the configuration nearest at or above its directory when no `package.json`
+ * sits between them. A configuration the compiler cannot read lists nothing and is joined
+ * by nothing.
+ */
+export function joinedTestFiles(
+  engine: Engine,
+  host: Host,
+  root: string,
+  configFiles: readonly string[],
+  patterns: readonly RegExp[],
+): ReadonlyMap<string, readonly string[]> {
+  const listed = new Set<string>();
+  const byDir = new Map<string, string[]>();
+  for (const configFile of configFiles) {
+    let fileNames: readonly string[];
+    try {
+      fileNames = engine.parseConfigFile(configFile).fileNames;
+    } catch {
+      continue;
+    }
+    fileNames.forEach((name) => listed.add(name));
+    const dir = dirnamePath(configFile);
+    byDir.set(dir, [...(byDir.get(dir) ?? []), configFile].sort(byPreference));
+  }
+  const joins = new Map<string, string[]>();
+  for (const path of sourcePaths(host, root)) {
+    const file = joinPath(root, path);
+    if (listed.has(file) || !patterns.some((pattern) => pattern.test(path))) {
+      continue;
+    }
+    for (let dir = dirnamePath(file); ; dir = dirnamePath(dir)) {
+      const [nearest] = byDir.get(dir) ?? [];
+      if (nearest !== undefined) {
+        joins.set(nearest, [...(joins.get(nearest) ?? []), file]);
+        break;
+      }
+      if (
+        host.kindOf(joinPath(dir, "package.json")) === "file" ||
+        dir === root ||
+        relativePath(root, dir) === undefined
+      ) {
+        break;
+      }
+    }
+  }
+  return joins;
+}
+
+/**
+ * How the snapshot reads each configuration a test file joins: the program `programs`
+ * describes with the files added to its root files, or a configuration only the snapshot
+ * holds that extends the one `programs` writes, or the configuration itself, and lists
+ * every file the configuration lists and the joined ones.
+ */
+export function withJoinedTests(
+  engine: Engine,
+  host: Host,
+  programs: ReadonlyMap<string, WorkspaceProgram>,
+  joins: ReadonlyMap<string, readonly string[]>,
+): ReadonlyMap<string, WorkspaceProgram> {
+  const found = new Map(programs);
+  for (const [configFile, files] of joins) {
+    const program = programs.get(configFile);
+    if (program?.kind === "program") {
+      found.set(configFile, {
+        kind: "program",
+        params: {
+          ...program.params,
+          rootFiles: [...(program.params.rootFiles ?? []), ...files],
+        },
+      });
+      continue;
+    }
+    let listed: readonly string[];
+    try {
+      listed =
+        program?.kind === "configuration"
+          ? engine.parseConfigJson(JSON.parse(program.text), program.file).fileNames
+          : engine.parseConfigFile(configFile).fileNames;
+    } catch {
+      continue;
+    }
+    const value =
+      program?.kind === "configuration"
+        ? { ...(JSON.parse(program.text) as Record<string, unknown>), files: [...listed, ...files] }
+        : { extends: configFile, files: [...listed, ...files] };
+    found.set(configFile, {
+      kind: "configuration",
+      file: program?.kind === "configuration" ? program.file : writtenPath(host, configFile),
+      text: `${JSON.stringify({ ...value, include: [] }, null, 2)}\n`,
+    });
+  }
+  return found;
+}

package/src/value-reach.ts

@@ -38,7 +38,7 @@ export interface Reached {
 }
 
 /** What each type's values carry, each type asked of the checker once. */
-export interface ValueReach {
+interface ValueReach {
   reachedFrom(type: Type): Reached;
 }
 

package/src/verbs/verb.ts

@@ -1,5 +1,4 @@
 import type { Config, Inputs } from "../config.ts";
-import type { Emitters } from "../findings/emitter.ts";
 import type { Host } from "../host.ts";
 import type { Writer } from "../run.ts";
 import type { Scope } from "../scope.ts";
@@ -16,7 +15,7 @@ export const EXIT_FAILURE = 3;
  * options that follow its name, read only when the verb asks for what they name, so
  * a verb that asks for nothing refuses no option.
  */
-export interface Invocation {
+interface Invocation {
   readonly out: Writer;
   readonly err: Writer;
   readonly host: Host;
@@ -29,8 +28,6 @@ export interface Invocation {
    * closed if the verb throws.
    */
   readonly openClient: (config: Config) => Engine;
-  /** The emitter of every kind family, which a verb that reports findings runs. */
-  readonly emitters: Emitters;
   /** The arguments after the verb's name, as written. */
   readonly args: readonly string[];
   /** The last value one of the verb's own options was given, undefined where none was. */

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "6.1.0";
+export const CONTRACT_VERSION = "7.0.0";

package/src/workflow-steps.ts

@@ -69,6 +69,24 @@ export function runCommands(text: string): readonly string[] {
   return found;
 }
 
+/** Every token the `run:` steps of the workflow files in the target root's `.github/workflows` hold. */
+export function workflowTokens(host: Host, targetRoot: string): readonly string[] {
+  const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
+  const found: string[] = [];
+  for (const path of workflowFiles(host, dir)) {
+    let text: string;
+    try {
+      text = host.readFile(path);
+    } catch {
+      continue;
+    }
+    for (const command of runCommands(text)) {
+      found.push(...scriptTokens(command));
+    }
+  }
+  return found;
+}
+
 /**
  * The own files the `run:` steps of every workflow file in the target root's
  * `.github/workflows` name: a token equal to a file's path below the target root, with or
@@ -79,25 +97,14 @@ export function workflowEntries(
   targetRoot: string,
   files: SourceFiles,
 ): readonly WorkflowEntry[] {
-  const dir = joinPath(resolvePath(host.workingDirectory(), targetRoot), WORKFLOWS);
   const found: WorkflowEntry[] = [];
-  for (const path of workflowFiles(host, dir)) {
-    let text: string;
-    try {
-      text = host.readFile(path);
-    } catch {
+  for (const token of workflowTokens(host, targetRoot)) {
+    if (COMPUTED.test(token)) {
       continue;
     }
-    for (const command of runCommands(text)) {
-      for (const token of scriptTokens(command)) {
-        if (COMPUTED.test(token)) {
-          continue;
-        }
-        const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
-        if (file !== undefined) {
-          found.push({ file, source: token });
-        }
-      }
+    const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
+    if (file !== undefined) {
+      found.push({ file, source: token });
     }
   }
   return found;

package/src/workspace-programs.ts

@@ -22,12 +22,10 @@ import type { Engine } from "./session.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";
 
 /** One member import no member source answers for. */
-export interface UnresolvedImport {
+interface UnresolvedImport {
   /** The importing file, absolute. */
   readonly file: string;
   readonly specifier: string;
-  readonly member: string;
-  readonly subpath: string;
   readonly reason: string;
 }
 
@@ -36,8 +34,6 @@ export interface MemberReading {
   readonly configFile: string;
   /** The files the configuration itself compiles, absolute. */
   readonly fileNames: readonly string[];
-  /** The static resolutions its program is built with; none for a configuration opened as a project. */
-  readonly entries: readonly ModuleResolutionEntry[];
   readonly unresolved: readonly UnresolvedImport[];
   /**
    * Why the configuration's component files are not read, where the snapshots read
@@ -53,7 +49,7 @@ export type WorkspaceProgram =
   | { readonly kind: "configuration"; readonly file: string; readonly text: string };
 
 /** The programs one run builds instead of opening projects, with what reading them did. */
-export interface WorkspacePrograms {
+interface WorkspacePrograms {
   /** Per configuration that imports a member, how the snapshot reads it. */
   readonly programs: ReadonlyMap<string, WorkspaceProgram>;
   readonly readings: readonly MemberReading[];
@@ -126,7 +122,7 @@ function unstatable(reading: Reading): string | undefined {
 }
 
 /** The path beside `configFile` its written configuration takes, which no file has. */
-function writtenPath(host: Host, configFile: string): string {
+export function writtenPath(host: Host, configFile: string): string {
   const stem = configFile.replace(/\.json$/u, "");
   for (let counter = 0; ; counter += 1) {
     const path = `${stem}.deadset-ts${counter === 0 ? "" : `-${String(counter)}`}.json`;
@@ -320,8 +316,6 @@ function scan(
       reading.unresolved.push({
         file: usage.file,
         specifier,
-        member: answer.member,
-        subpath: answer.subpath,
         reason: answer.reason,
       });
     }
@@ -449,7 +443,6 @@ export function workspacePrograms(
     readings: readings.map((reading) => ({
       configFile: reading.configFile,
       fileNames: reading.parsed.fileNames,
-      entries: reading.entries,
       unresolved: reading.unresolved,
       componentsUnread: unread.get(reading.configFile),
     })),

package/src/workspace-resolution.ts

@@ -30,7 +30,6 @@ export type MemberResolution =
   | {
       readonly kind: "unresolved";
       readonly member: string;
-      readonly subpath: string;
       readonly reason: string;
     };
 
@@ -343,7 +342,6 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
         return {
           kind: "unresolved",
           member: name,
-          subpath,
           reason: `${String(linked.dirs.length)} workspace packages are named ${name} (${linked.dirs.join(", ")}) and nothing links the importer to one of them; install the workspace, or declare the dependency with a range only one of them satisfies`,
         };
       }
@@ -381,7 +379,6 @@ export function workspaceResolver(host: Host, workspace: Workspace): WorkspaceRe
       return {
         kind: "unresolved",
         member: name,
-        subpath,
         reason: built
           ? `its manifest names ${named}, output no tsconfig*.json of the package maps back to source, and nothing installed links the importer to it; install the workspace, or point an exports condition the importing configuration's customConditions lists at its source`
           : member.configurations.length === 0

package/src/workspace-run.ts

@@ -20,7 +20,7 @@ import {
 import { workspaceResolver } from "./workspace-resolution.ts";
 
 /** One run's workspace. */
-export interface WorkspaceRun {
+interface WorkspaceRun {
   /** Per configuration that imports a member, how the snapshot reads it. */
   readonly programs: ReadonlyMap<string, WorkspaceProgram>;
   /**