@cplieger/deadset-ts 8.0.0-dev.17 → 8.0.0-dev.18

package/src/findings/interfaces.ts

@@ -2,7 +2,7 @@ import { CODE } from "../contract/contract.generated.ts";
 import type { Finding, FindingPosition, PositionedSymbol } from "../finding.ts";
 import type { InventorySymbol } from "../inventory.ts";
 import { byPosition } from "../position.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 /** What each finding says, by what the sweep found about the subject's references. */
@@ -21,7 +21,7 @@ function positionOf(symbol: InventorySymbol): FindingPosition {
 function indexed(input: EmitterInput): {
   readonly symbolOf: (id: string) => InventorySymbol | undefined;
   readonly inTest: (id: string) => boolean;
-  readonly candidateOf: (id: string) => MatrixCandidate | undefined;
+  readonly candidateOf: (id: string) => Candidate | undefined;
   readonly implementationsOf: (id: string) => readonly PositionedSymbol[];
 } {
   const union = input.swept.matrix.union;
@@ -113,7 +113,7 @@ export const interfaces: Emitter = (input) => {
 };
 
 /** What one unused interface's finding says, by the references the sweep counted. */
-function unusedMessage(candidate: MatrixCandidate): string {
+function unusedMessage(candidate: Candidate): string {
   if (candidate.relation === "reachability") {
     return UNUSED_DEAD_MESSAGE;
   }

package/src/findings/intra-function.ts

@@ -3,7 +3,7 @@ import type { Finding } from "../finding.ts";
 import { KINDS } from "../kinds.ts";
 import { parameterRef } from "../ref.ts";
 import { type PartFact } from "../intra-function-parts.ts";
-import { reachedWithTheTests } from "../sweep.ts";
+import { reachedWithTheTests } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 
 /** A list of rules as a sentence names them. */
@@ -109,8 +109,8 @@ export const intraFunction: Emitter = (input) => {
   const union = input.swept.matrix.union;
   const byId = new Map(union.symbols.map((symbol) => [symbol.id, symbol]));
   const reached = reachedWithTheTests(union, [
-    ...input.swept.exempt.map((record) => record.id),
-    ...input.swept.heldByUnanswered,
+    ...input.swept.sweep.exempt.map((record) => record.id),
+    ...input.swept.sweep.held,
   ]);
   const testsOfDeadCode = new Set(
     input.swept.sweep.candidates.filter((one) => one.testOfDeadCode).map((one) => one.id),

package/src/findings/reads-and-writes.ts

@@ -1,10 +1,12 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding, FindingDetails, FindingPosition } from "../finding.ts";
-import type { InventorySymbol } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { WORDS, type InventorySymbol } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import { positionKey } from "../position.ts";
 import { declarationKey } from "../ref.ts";
+import { reachabilityClasses } from "./completion.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
+
 import { bytewise } from "../text/compare.ts";
 
 /** The codes this emitter reports. */
@@ -18,7 +20,7 @@ const SIGNATURES: ReadonlySet<string> = new Set(["function", "method", "type"]);
 interface Run {
   readonly input: EmitterInput;
   readonly symbols: ReadonlyMap<string, InventorySymbol>;
-  readonly candidates: ReadonlyMap<string, MatrixCandidate>;
+  readonly candidates: ReadonlyMap<string, Candidate>;
 }
 
 function indexed(input: EmitterInput): Run {
@@ -112,19 +114,16 @@ function parametersOnlyNamedBy(
 }
 
 /** What one write-only finding says, the declarations its deletion takes with it included. */
-function writeOnlyMessage(
-  run: Run,
-  namedBy: ReadonlyMap<string, ReadonlySet<string>>,
-  symbol: InventorySymbol,
-  held: Uses,
-): string {
+function writeOnlyMessage(run: Run, written: Written, subject: Subject): string {
+  const { symbol, held } = subject;
   const writes = held.writes.length === 1 ? "once" : `at ${String(held.writes.length)} positions`;
   const read = run.input.stores.readInTests.has(symbol.id)
     ? "read only from test files"
     : "never read";
   const cascade = [
-    ...parametersOnlyNamedBy(run, namedBy, symbol).map((name) => `type parameter ${name}`),
+    ...parametersOnlyNamedBy(run, written.namedBy, symbol).map((name) => `type parameter ${name}`),
     ...[...held.alone].sort(bytewise).map((name) => `import ${name}`),
+    ...(written.named.get(symbol.id) ?? []),
   ];
   const word = SUBJECT_WORDS[symbol.kind] ?? "member";
   const message = `${word} ${symbol.name} is written ${writes} and ${read}`;
@@ -133,17 +132,55 @@ function writeOnlyMessage(
     : `${message}, and deleting it with its writes deletes ${cascade.join(" and ")} too`;
 }
 
+/** One declaration the write-only kind reports, with its uses. */
+interface Subject {
+  readonly symbol: InventorySymbol;
+  readonly held: Uses;
+}
+
 /**
- * `DS1301`: a module-level variable, a type member or a class member the counted
- * references store into and never read, named with every position written.
+ * What the write-only kind answers of one run: its subjects in site order, and the
+ * declarations that fall with them, each named under the innermost subject of every chain
+ * of carriers its references hold.
+ */
+interface Written {
+  readonly subjects: readonly Subject[];
+  readonly namedBy: ReadonlyMap<string, ReadonlySet<string>>;
+  readonly named: ReadonlyMap<string, readonly string[]>;
+  readonly falls: ReadonlySet<string>;
+}
+
+/**
+ * The kinds of declaration that fall with a write-only subject: a declaration of its own.
+ * A member falls with its container, and a type parameter is the type-parameter clause's.
+ */
+const FALLING: ReadonlySet<InventorySymbol["kind"]> = new Set([
+  "function",
+  "class",
+  "interface",
+  "type",
+  "enum",
+  "namespace",
+  "variable",
+]);
+
+const WRITTEN = new WeakMap<EmitterInput, Written>();
+
+/**
+ * `DS1301`'s subjects: a module-level variable, a type member or a class member the
+ * counted references store into and never read.
  *
  * The subject is a live declaration: a store is a reference, so the sweep holds a
  * written one live and its candidates are never this kind's. Every reference that is
  * not a store reads, and so does an exemption record naming the declaration.
  */
-function writeOnlySymbols(run: Run): readonly Finding[] {
+function writtenOf(run: Run): Written {
+  const known = WRITTEN.get(run.input);
+  if (known !== undefined) {
+    return known;
+  }
   const { stores } = run.input;
-  const { matrix } = run.input.swept;
+  const { matrix, sweep } = run.input.swept;
   const uses = new Map<string, Uses>();
   for (const reference of stores.references) {
     let held = uses.get(reference.to);
@@ -174,26 +211,54 @@ function writeOnlySymbols(run: Run): readonly Finding[] {
     }
   }
 
-  const found: Finding[] = [];
-  for (const symbol of matrix.union.symbols) {
+  const subjects = matrix.union.symbols.flatMap((symbol): Subject[] => {
     const held = uses.get(symbol.id);
-    if (
-      held === undefined ||
+    return held === undefined ||
       held.writes.length === 0 ||
       held.reads > 0 ||
       !writable(run, symbol) ||
       stores.exempt.has(symbol.id) ||
       run.candidates.has(symbol.id)
+      ? []
+      : [{ symbol, held }];
+  });
+  const subjectIds = new Set(subjects.map((subject) => subject.symbol.id));
+  const classOf = reachabilityClasses(run.input);
+  const named = new Map<string, string[]>();
+  const falls = new Set<string>();
+  for (const symbol of matrix.union.symbols) {
+    const chains = sweep.carried.get(symbol.id);
+    if (
+      chains === undefined ||
+      subjectIds.has(symbol.id) ||
+      !FALLING.has(symbol.kind) ||
+      classOf(symbol.id) !== "certain"
     ) {
       continue;
     }
-    found.push(
-      findingAbout(symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, namedBy, symbol, held), {
-        writePositions: held.writes,
-      }),
-    );
+    const innermost = chains.map((chain) => chain.find((id) => subjectIds.has(id)));
+    if (innermost.includes(undefined)) {
+      continue;
+    }
+    falls.add(symbol.id);
+    for (const subject of new Set(innermost)) {
+      const name = `${WORDS[symbol.kind]} ${symbol.name}`;
+      named.set(subject ?? "", [...(named.get(subject ?? "") ?? []), name]);
+    }
   }
-  return found;
+  const written = { subjects, namedBy, named, falls };
+  WRITTEN.set(run.input, written);
+  return written;
+}
+
+/** `DS1301`: each subject, named with every position written and what falls with it. */
+function writeOnlySymbols(run: Run): readonly Finding[] {
+  const written = writtenOf(run);
+  return written.subjects.map((subject) =>
+    findingAbout(subject.symbol, CODE.writeOnlySymbol, writeOnlyMessage(run, written, subject), {
+      writePositions: subject.held.writes,
+    }),
+  );
 }
 
 /**
@@ -253,12 +318,20 @@ function unusedTypeParameters(run: Run): readonly Finding[] {
  */
 export function writeOnlyDeclarations(input: EmitterInput): ReadonlySet<string> {
   return new Set(
-    writeOnlySymbols(indexed(input)).map((finding) =>
-      declarationKey(finding.symbol.ref, finding.position.path),
+    writtenOf(indexed(input)).subjects.map(({ symbol }) =>
+      declarationKey(symbol.ref, symbol.position.path),
     ),
   );
 }
 
+/**
+ * The declarations that fall with a write-only subject, whatever the severity: a finding
+ * about one would name code its subject's deletion already deletes.
+ */
+export function fallingWithWrites(input: EmitterInput): ReadonlySet<string> {
+  return writtenOf(indexed(input)).falls;
+}
+
 /**
  * The findings of the reads-and-writes kinds, `DS1301`, `DS1005` and `DS1006`, in that
  * order and each code's in site order.

package/src/findings/unused-declarations.ts

@@ -1,9 +1,8 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
-import type { InventorySymbol, SymbolKind } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { WORDS, type InventorySymbol, type SymbolKind } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
-import { testsUnseenAPI } from "./completion.ts";
 import { unreachableExports } from "./visibility-narrowing.ts";
 
 /** The kinds of declaration that are members of a class, an interface, a type or an enum. */
@@ -26,39 +25,18 @@ const NOT_REPORTED_HERE: ReadonlySet<SymbolKind> = new Set([
   "type-parameter",
 ]);
 
-/** The reader's word for each kind of declaration a finding of this emitter names. */
-const WORDS: Readonly<Record<SymbolKind, string>> = {
-  file: "file",
-  function: "function",
-  class: "class",
-  interface: "interface",
-  type: "type alias",
-  enum: "enum",
-  namespace: "namespace",
-  variable: "variable",
-  "export-alias": "re-export",
-  method: "method",
-  "class-member": "class member",
-  "interface-method": "interface method",
-  "type-member": "type member",
-  "enum-member": "enum member",
-  "type-parameter": "type parameter",
-};
-
 /** What the test-of-dead-code kind says, which states the rule it applies. */
 const TEST_OF_DEAD_CODE = "every target symbol this test references is reported dead";
 
 /** What the run holds about one candidate that decides its code. */
 interface Judged {
-  readonly candidate: MatrixCandidate;
+  readonly candidate: Candidate;
   readonly symbol: InventorySymbol;
   /** Whether a test file declares it. */
   readonly test: boolean;
   readonly deprecated: boolean;
   /** Whether the unreachable-export kind reports it. */
   readonly unreachable: boolean;
-  /** Whether it is a test with a target that is published API no declared consumer judges. */
-  readonly testsUnseenAPI: boolean;
 }
 
 /**
@@ -72,7 +50,7 @@ interface Judged {
 function codeOf(judged: Judged): string | undefined {
   const { candidate, symbol } = judged;
   if (candidate.testOfDeadCode) {
-    return judged.testsUnseenAPI ? undefined : CODE.testOfDeadCode;
+    return CODE.testOfDeadCode;
   }
   if ((judged.test && !candidate.unreferencedTest) || NOT_REPORTED_HERE.has(symbol.kind)) {
     return undefined;
@@ -245,7 +223,6 @@ function emitterFindings(input: EmitterInput, fallen: boolean): Finding[] {
   const union = input.swept.matrix.union;
   const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
   const unreachable = unreachableExports(input);
-  const unseenAPI = testsUnseenAPI(input);
   let brands: ReadonlySet<string> | undefined;
 
   const found: Finding[] = [];
@@ -265,7 +242,6 @@ function emitterFindings(input: EmitterInput, fallen: boolean): Finding[] {
       test: union.test[at] === true,
       deprecated: input.deprecated.has(symbol.id),
       unreachable: unreachable.has(symbol.id),
-      testsUnseenAPI: candidate.testOfDeadCode && unseenAPI(candidate.id),
     };
     const code = codeOf(judged);
     if (

package/src/findings/visibility-narrowing.ts

@@ -1,11 +1,12 @@
 import { CODE } from "../contract/contract.generated.ts";
 import type { Finding } from "../finding.ts";
-import { OUTSIDE, type Graph } from "../graph.ts";
-import type { InventorySymbol, SymbolKind } from "../inventory.ts";
-import type { MatrixCandidate } from "../matrix.ts";
+import { OUTSIDE, type Graph } from "../liveness/graph.ts";
+import { WORDS, type InventorySymbol } from "../inventory.ts";
+import type { Candidate } from "../liveness/sweep.ts";
 import { declarationKey } from "../ref.ts";
 import type { RootKind } from "../roots/root-set.ts";
-import { runnerCalls } from "../sweep.ts";
+import { runnerCalls } from "../liveness/sweep.ts";
+import { exposedTypes, exposes } from "../exposure.ts";
 import type { Emitter, EmitterInput } from "./emitter.ts";
 import { writeOnlyDeclarations } from "./reads-and-writes.ts";
 
@@ -19,18 +20,6 @@ type Reach = "file" | "package" | "outside";
  */
 const PUBLISHING: ReadonlySet<RootKind> = new Set<RootKind>(["manifest-entry", "published-api"]);
 
-/** The reader's word for each kind of declaration this emitter reports. */
-const WORDS: Partial<Readonly<Record<SymbolKind, string>>> = {
-  function: "function",
-  class: "class",
-  interface: "interface",
-  type: "type alias",
-  enum: "enum",
-  namespace: "namespace",
-  variable: "variable",
-  "export-alias": "re-export",
-};
-
 /** Per declaration of the run, the facts both rules read. */
 interface Facts {
   readonly graph: Graph;
@@ -142,10 +131,6 @@ function topLevelExport(facts: Facts, at: number, symbol: InventorySymbol): bool
   return symbol.exported && parent !== OUTSIDE && facts.graph.symbols[parent]?.kind === "file";
 }
 
-function wordOf(symbol: InventorySymbol): string {
-  return WORDS[symbol.kind] ?? symbol.kind;
-}
-
 /** The visibility each narrowing code names, which only the narrowing codes carry. */
 const NARROWER: Readonly<Record<string, "file" | "package">> = {
   [CODE.redundantExportKeyword]: "file",
@@ -181,7 +166,11 @@ function narrowing(
   facts: Facts,
   at: number,
   symbol: InventorySymbol,
-  world: { readonly closed: boolean; readonly writeOnly: ReadonlySet<string> },
+  world: {
+    readonly closed: boolean;
+    readonly writeOnly: ReadonlySet<string>;
+    readonly exposed: ReadonlySet<string> | "every";
+  },
 ): Finding | undefined {
   const { closed } = world;
   const file = facts.fileOf[at] ?? OUTSIDE;
@@ -195,7 +184,7 @@ function narrowing(
   ) {
     return undefined;
   }
-  const word = wordOf(symbol);
+  const word = WORDS[symbol.kind];
   switch (facts.reach[at]) {
     case "file":
       if (facts.published[file] === true && !closed) {
@@ -207,7 +196,7 @@ function narrowing(
         `exported ${word} is referenced only inside the file that declares it`,
       );
     case "package":
-      if (!closed || !publishes(facts.rootedBy[at])) {
+      if (!closed || !publishes(facts.rootedBy[at]) || exposes(world.exposed, symbol)) {
         return undefined;
       }
       return findingOf(
@@ -231,7 +220,7 @@ function unreachable(
   facts: Facts,
   at: number,
   symbol: InventorySymbol,
-  candidate: MatrixCandidate,
+  candidate: Candidate,
   input: EmitterInput,
 ): Finding | undefined {
   if (
@@ -252,7 +241,7 @@ function unreachable(
   return findingOf(
     symbol,
     CODE.unreachableExport,
-    `exported ${wordOf(symbol)} ${found}, and nothing outside can import the file that declares it`,
+    `exported ${WORDS[symbol.kind]} ${found}, and nothing outside can import the file that declares it`,
   );
 }
 
@@ -267,7 +256,17 @@ export function narrowings(input: EmitterInput): readonly Finding[] {
   const facts = factsOf(input.swept.matrix.union);
   const { declared, loaded } = input.boundary.consumers;
   const closed = input.config.consumers.complete && declared.every((id) => loaded.includes(id));
-  const world = { closed, writeOnly: writeOnlyDeclarations(input) };
+  const world = {
+    closed,
+    writeOnly: writeOnlyDeclarations(input),
+    exposed: closed
+      ? exposedTypes(
+          facts.graph,
+          facts.reach.map((reach) => reach === "outside"),
+          input.boundary.carriers,
+        )
+      : new Set<string>(),
+  };
   const candidates = new Map(
     input.swept.sweep.candidates.map((candidate) => [candidate.id, candidate]),
   );

package/src/interface-satisfaction.ts

@@ -32,7 +32,7 @@ import { aliasChains } from "./alias-chain.ts";
 import { emptyImplementation } from "./findings/implementations.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
 import type { Reference } from "./references.ts";
-import type { Exemption } from "./sweep.ts";
+import type { Exemption } from "./exempt.ts";
 import { nodeKey, type Inventory } from "./inventory.ts";
 import { renderPosition } from "./position.ts";
 import { must } from "./query.ts";

package/src/inventory.ts

@@ -50,6 +50,25 @@ export type SymbolKind =
   | "enum-member"
   | "type-parameter";
 
+/** The reader's word for each kind of declaration, as a finding names it. */
+export const WORDS: Readonly<Record<SymbolKind, string>> = {
+  file: "file",
+  function: "function",
+  class: "class",
+  interface: "interface",
+  type: "type alias",
+  enum: "enum",
+  namespace: "namespace",
+  variable: "variable",
+  "export-alias": "re-export",
+  method: "method",
+  "class-member": "class member",
+  "interface-method": "interface method",
+  "type-member": "type member",
+  "enum-member": "enum member",
+  "type-parameter": "type parameter",
+};
+
 /**
  * How a member may be named from outside its container. A `private` member is still
  * reachable at run time by its name; a private name does not exist outside the class body.

package/src/{components.ts → liveness/components.ts}

@@ -4,10 +4,10 @@
  * and every dead declaration that falls with them, being dead only through them.
  */
 
-import type { Cascade } from "./config.ts";
+import type { Cascade } from "../config.ts";
 import { OUTSIDE, type Graph } from "./graph.ts";
-import type { InventorySymbol } from "./inventory.ts";
-import { PRODUCT } from "./product.ts";
+import type { InventorySymbol } from "../inventory.ts";
+import { PRODUCT } from "../product.ts";
 
 /** The fewest digits a component identifier's number is written with. */
 const ID_DIGITS = 4;

package/src/{graph.ts → liveness/graph.ts}

@@ -1,14 +1,14 @@
 /**
- * One project's declarations, the references between them and the roots that seed
- * reachability, indexed for the sweep. The graph reads no file and asks the compiler
- * nothing, so a sweep over it is a function of the values it was built from, and the
- * inventory's order is the order every set a sweep answers reads in.
+ * The run's declarations, the references every configuration makes between them and the
+ * roots that seed reachability, indexed for the sweep. The graph reads no file and asks the
+ * compiler nothing, so a sweep over it is a function of the values it was built from, and
+ * the inventory's order is the order every set a sweep answers reads in.
  */
 
-import type { InventorySymbol, SymbolKind } from "./inventory.ts";
-import type { Reference } from "./references.ts";
-import { madeByTestCode } from "./tests/file-class.ts";
-import type { Root, RootKind } from "./roots/root-set.ts";
+import type { InventorySymbol, SymbolKind } from "../inventory.ts";
+import type { Reference } from "../references.ts";
+import { madeByTestCode } from "../tests/file-class.ts";
+import type { Root, RootKind } from "../roots/root-set.ts";
 
 /** The position of a declaration the inventory does not hold. */
 export const OUTSIDE = -1;
@@ -80,7 +80,11 @@ export function namesACaller(kind: RootKind): boolean {
 /** One reference as the sweep reads it: the declaration named, and whether a test file made it. */
 export interface Edge {
   readonly to: number;
+  /** The reference's place in {@link Graph.references}. */
+  readonly reference: number;
   readonly test: boolean;
+  /** Whether only the name answered, which counts at the sweep's guessed tier alone. */
+  readonly guessed: boolean;
   /**
    * Whether the reference evaluates the module whose file it names, which reaches the
    * module's top level and none of what it exports.
@@ -105,9 +109,11 @@ export interface Counts {
 }
 
 /** One root the inventory holds, at the position of the declaration it names. */
-interface Rooted {
+export interface Rooted {
   readonly at: number;
   readonly kind: RootKind;
+  /** What names the root, as the root set spells it. */
+  readonly source: string;
 }
 
 /** The index the sweep and the component pass read. */
@@ -118,6 +124,12 @@ export interface Graph {
   readonly out: readonly (readonly Edge[])[];
   /** Per declaration, the references made to it, whoever made them. */
   readonly made: readonly Counts[];
+  /** Per declaration, those of {@link Graph.made} only a name answered. */
+  readonly guessedMade: readonly Counts[];
+  /** The references the graph was built from, in the order given. */
+  readonly references: readonly Reference[];
+  /** Per reference, the configurations that make it, in the run's order. */
+  readonly configurations: readonly (readonly string[])[];
   /** Per declaration, the position of its container, or {@link OUTSIDE} for a file. */
   readonly parent: readonly number[];
   /** Per declaration, whether a test file holds it. */
@@ -137,17 +149,44 @@ export interface Graph {
   /** Every root naming a declaration the inventory holds, in the order the root set gives them. */
   readonly rooted: readonly Rooted[];
   /**
-   * Every reference a loaded consumer or an unheld file makes to a declaration the
-   * inventory holds, in the order given. Such a file is a caller the analysis read, so the
-   * sweep holds what it names live under both relations and reaches on from there.
+   * Every reference a loaded consumer, an unheld file or a declaration no configuration
+   * judges makes to a declaration the inventory holds, in the order given. Such code is a
+   * caller the analysis read, so the sweep holds what it names live under both relations
+   * and reaches on from there.
    */
   readonly consumed: readonly Edge[];
   /** The position of the declaration one identifier names, or {@link OUTSIDE}. */
   at(id: string): number;
 }
 
+/** What the run says of a graph's references beyond the references themselves. */
+interface Sources {
+  /**
+   * The declarations a configuration holds only for their references, judged by none: each
+   * reference one makes enters as a consumer's does, since deleting what it names breaks
+   * that configuration's compile (matrix.5).
+   */
+  readonly unjudged?: ReadonlySet<string>;
+  /** Per reference, in the order given, the configurations that make it. */
+  readonly configurations?: readonly (readonly string[])[];
+}
+
+/** Adds one reference's count to the counts of the declaration it names. */
+function count(
+  counts: { production: number; test: number; consumerTest: number },
+  test: boolean,
+  consumer: boolean,
+): void {
+  if (test) {
+    counts.test += 1;
+    counts.consumerTest += consumer ? 1 : 0;
+  } else {
+    counts.production += 1;
+  }
+}
+
 /**
- * Indexes one project's inventory, references and roots. `testFiles` are the paths the
+ * Indexes the run's inventory, references and roots. `testFiles` are the paths the
  * reference pass classified as test files, so a declaration one holds is a test
  * declaration. A reference to a declaration the inventory does not hold is dropped; one
  * from such a declaration still counts toward its target, because reference counting
@@ -160,42 +199,48 @@ export function graphOf(
   testFiles: readonly string[],
   supportFiles: readonly string[] = [],
   ambient: ReadonlySet<string> = new Set(),
+  sources: Sources = {},
 ): Graph {
   const supports = new Set(supportFiles);
   const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
   const at = (id: string): number => index.get(id) ?? OUTSIDE;
   const tests = new Set(testFiles);
+  const unjudged = sources.unjudged ?? new Set<string>();
 
   const out: Edge[][] = symbols.map(() => []);
   const made = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
+  const guessedMade = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
   const consumed: Edge[] = [];
-  for (const reference of references) {
+  references.forEach((reference, place) => {
     const to = at(reference.to);
     if (to === OUTSIDE) {
-      continue;
+      return;
     }
     const test = madeByTestCode(reference, supports);
+    const consumer = reference.consumer !== undefined;
+    const guessed = reference.guessed === true;
     const counts = made[to];
     if (counts !== undefined) {
-      if (test) {
-        counts.test += 1;
-        counts.consumerTest += reference.consumer === undefined ? 0 : 1;
-      } else {
-        counts.production += 1;
-      }
+      count(counts, test, consumer);
+    }
+    const guesses = guessedMade[to];
+    if (guessed && guesses !== undefined) {
+      count(guesses, test, consumer);
     }
     const edge = {
       to,
+      reference: place,
       test,
+      guessed,
       evaluation: reference.use === "evaluation",
-      consumer: reference.consumer !== undefined,
+      consumer,
     };
-    if (edge.consumer || reference.unheld === true) {
+    if (consumer || reference.unheld === true || unjudged.has(reference.from)) {
       consumed.push(edge);
-      continue;
+      return;
     }
     out[at(reference.from)]?.push(edge);
-  }
+  });
 
   const parent = symbols.map((symbol) => at(symbol.parent));
   const exportsOf: number[][] = symbols.map(() => []);
@@ -210,7 +255,7 @@ export function graphOf(
   for (const root of roots) {
     const position = at(root.id);
     if (position !== OUTSIDE) {
-      rooted.push({ at: position, kind: root.kind });
+      rooted.push({ at: position, kind: root.kind, source: root.source });
     }
   }
 
@@ -218,6 +263,9 @@ export function graphOf(
     symbols,
     out,
     made,
+    guessedMade,
+    references,
+    configurations: sources.configurations ?? references.map(() => []),
     parent,
     test: symbols.map((symbol) => tests.has(symbol.position.path)),
     support: symbols.map((symbol) => supports.has(symbol.position.path)),