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

package/dist/src/verbs/explain.js

@@ -1,12 +1,11 @@
 import { EXIT_CLEAN, EXIT_USAGE } from "../contract/contract.generated.js";
 import { productionMode, runAnalysis } from "../analysis.js";
-import { listing } from "../components.js";
-import { OUTSIDE, swept as judged } from "../graph.js";
-import { referenceKey } from "../matrix.js";
+import { listing } from "../liveness/components.js";
+import { swept as judged } from "../liveness/graph.js";
 import { partialNotes } from "../partial.js";
 import { resolvePath } from "../paths.js";
 import { positionKey } from "../position.js";
-import { madeByTestCode, withheldBy } from "../tests/file-class.js";
+import { madeByTestCode } from "../tests/file-class.js";
 import { resolve } from "../resolve.js";
 import {} from "./verb.js";
 import { UsageError } from "../usage.js";
@@ -80,172 +79,94 @@ function subjectOf(symbols, named) {
         .sort(bytewise);
     return { candidates: partial.slice(0, MAX_PARTIAL_MATCHES) };
 }
-/** Every reference of the run once, a reference several configurations make counted once. */
-function referencesOf(configured) {
-    const seen = new Set();
-    const held = [];
-    for (const reference of configured.flatMap((one) => one.references)) {
-        const key = referenceKey(reference);
-        if (!seen.has(key)) {
-            seen.add(key);
-            held.push(reference);
-        }
-    }
-    return held;
-}
-/** Every root of the run once per reason, in the order the projects name them. */
-function rootsOf(configured) {
-    const seen = new Set();
-    return configured
-        .flatMap((one) => one.roots)
-        .filter((root) => {
-        const key = [root.id, root.kind, root.source].join("\u0000");
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    });
-}
-/**
- * The shortest path from a root, a loaded consumer or a test file no project holds to one
- * declaration, walked breadth first from every root at once in the order the run names them,
- * a reference of a consumer or of such a file being the first hop of a path of its own, as
- * the sweep seeds them, and following the references the sweep follows: a
- * reference that reads a module reaches what the module exports, and an evaluation or a root
- * reaches the module alone. Under `production` no reference a test file made is followed,
- * which is the set the report's sweep counts.
- */
-function shortestPath(analysis, to, mode, support) {
-    const graph = analysis.swept.matrix.union;
-    const out = new Map();
-    const consumed = [];
-    for (const reference of referencesOf(analysis.configured)) {
-        if (withheldBy(mode, reference, support)) {
-            continue;
-        }
-        const { consumer } = reference;
-        if (consumer !== undefined) {
-            consumed.push({ reference, origin: { k: "consumer", consumer } });
-            continue;
-        }
-        if (reference.unheld === true) {
-            consumed.push({
-                reference,
-                origin: { k: "unheld", file: reference.from.replace(/#$/u, "") },
-            });
-            continue;
-        }
-        const held = out.get(reference.from);
-        if (held === undefined) {
-            out.set(reference.from, [reference]);
-        }
-        else {
-            held.push(reference);
-        }
-    }
-    const steps = [];
-    const seen = new Set();
-    const expanded = new Set();
-    const enter = (step) => {
-        if (!seen.has(step.at)) {
-            seen.add(step.at);
-            steps.push(step);
-        }
-    };
-    const follow = (reference, previous, origin) => {
-        enter({ at: reference.to, hop: { k: "reference", reference }, previous, origin });
-        const target = graph.at(reference.to);
-        if (reference.use === "evaluation" || target === OUTSIDE || expanded.has(reference.to)) {
-            return;
-        }
-        expanded.add(reference.to);
-        for (const exported of graph.exportsOf[target] ?? []) {
-            const id = graph.symbols[exported]?.id;
-            if (id !== undefined) {
-                enter({ at: id, hop: { k: "export", reference, to: id }, previous, origin });
-            }
-        }
-    };
-    for (const root of rootsOf(analysis.configured)) {
-        enter({ at: root.id, hop: undefined, previous: -1, origin: { k: "root", root } });
-    }
-    // A consumed reference is one hop long, so it joins the walk where the roots' first hops do.
-    const firstHops = steps.length;
-    for (let head = 0;; head += 1) {
-        if (head === firstHops) {
-            for (const { reference, origin } of consumed) {
-                follow(reference, -1, origin);
-            }
-        }
-        const step = steps[head];
-        if (step === undefined) {
-            break;
-        }
-        if (step.at === to) {
-            const path = [];
-            for (let at = step; at?.hop !== undefined; at = steps[at.previous]) {
-                path.unshift(at.hop);
-            }
-            return { origin: step.origin, path };
-        }
-        for (const reference of out.get(step.at) ?? []) {
-            follow(reference, head, step.origin);
-        }
-    }
-    return undefined;
-}
 /** Where a path starts, as a line names it. */
-function originText(origin) {
+function originText(origin, graph) {
+    const id = (at) => graph.symbols[at]?.id ?? "";
     switch (origin.k) {
         case "root":
-            return `root ${origin.root.kind} ${origin.root.id}`;
-        case "consumer":
-            return `consumer ${origin.consumer}`;
-        case "unheld":
-            return `test file no project holds ${origin.file}`;
+            return `root ${origin.rooted.kind} ${id(origin.rooted.at)}`;
+        case "consumed": {
+            const reference = graph.references[origin.edge.reference];
+            if (reference?.consumer !== undefined) {
+                return `consumer ${reference.consumer}`;
+            }
+            return reference?.unheld === true
+                ? `test file no project holds ${reference.from.replace(/#$/u, "")}`
+                : `declaration no configuration judges ${reference?.from ?? ""}`;
+        }
+        case "exemption":
+            return `exemption ${origin.record.class} ${positionKey(origin.record.site)}`;
+        case "mark":
+            return `suppression of ${id(origin.at)}`;
+        case "unanswered":
+            return `unanswered question about ${id(origin.at)}`;
     }
 }
 /** What made a reference: a declaration of the target, or a loaded consumer. */
 function madeBy(reference) {
     return reference.consumer === undefined ? reference.from : `consumer ${reference.consumer}`;
 }
-/** One reference of an answer, marked where test code made it, a test-support file's included. */
-function referenceLine(reference, tail, support) {
-    return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${madeByTestCode(reference, support) ? "\tfrom a test file" : ""}\n`;
+/**
+ * One reference of an answer, marked where test code made it, a test-support file's included,
+ * and naming the configurations that make it where they are not every one of the run.
+ */
+function referenceLine(reference, tail, support, configurations) {
+    const partial = configurations.making.length < configurations.run.length;
+    return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${madeByTestCode(reference, support) ? "\tfrom a test file" : ""}${partial ? `\tmade in ${configurations.making.join(" ")}` : ""}\n`;
 }
 /** Why a declaration no finding names and no exemption held back is live, or how it fell. */
-function liveness(analysis, subject, cascade, mode) {
-    const { sweep } = analysis.swept;
+function liveness(analysis, subject, cascade) {
+    const { matrix, sweep } = analysis.swept;
+    const graph = matrix.union;
     const candidate = sweep.candidates.find((one) => one.id === subject.id);
     if (candidate === undefined && !judged(subject.kind)) {
         return `answer: unjudged\n  unjudged: neither liveness relation judges a ${subject.kind}\n`;
     }
     let text = `answer: ${candidate === undefined ? "live" : "dead"}\n`;
     text += `  live under: ${listed(sweep.liveUnder.get(subject.id) ?? [])}\n`;
-    for (const root of rootsOf(analysis.configured).filter((one) => one.id === subject.id)) {
-        text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+    const at = graph.at(subject.id);
+    const seen = new Set();
+    for (const root of graph.rooted.filter((one) => one.at === at)) {
+        const key = `${root.kind}\u0000${root.source}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            text += `  root: ${root.kind}${root.source === "" ? "" : `\tnamed by ${root.source}`}\n`;
+        }
     }
     const support = new Set(analysis.configured.flatMap((one) => one.supportFiles ?? []));
-    const found = shortestPath(analysis, subject.id, mode, support) ??
-        shortestPath(analysis, subject.id, { production: false }, support);
-    if (found !== undefined && found.path.length > 0) {
-        const { origin } = found;
-        text += `  reached from: ${originText(origin)}\n`;
-        for (const hop of found.path) {
-            text += referenceLine(hop.reference, `${madeBy(hop.reference)} -> ${hop.reference.to}`, support);
+    const line = (edge, tail) => {
+        const reference = graph.references[edge.reference];
+        return reference === undefined
+            ? ""
+            : referenceLine(reference, tail(reference), support, {
+                making: graph.configurations[edge.reference] ?? [],
+                run: matrix.configurations,
+            });
+    };
+    const found = sweep.path(subject.id);
+    if (found !== undefined && found.hops.length > 0) {
+        text += `  reached from: ${originText(found.origin, graph)}\n`;
+        for (const hop of found.hops) {
+            text += line(hop.edge, (reference) => `${madeBy(reference)} -> ${reference.to}`);
             if (hop.k === "export") {
-                text += `  export: ${hop.reference.to} -> ${hop.to}\n`;
+                const reference = graph.references[hop.edge.reference];
+                text += `  export: ${reference?.to ?? ""} -> ${graph.symbols[hop.to]?.id ?? ""}\n`;
             }
         }
     }
     else if (found === undefined) {
-        const references = referencesOf(analysis.configured).filter((one) => one.to === subject.id);
+        const references = graph.references.flatMap((one, place) => one.to === subject.id ? [place] : []);
         text +=
             "  unreachable: no path of references reaches it from a root, a loaded consumer or a test file no project holds\n";
         text += `  references: ${String(references.length)}\n`;
-        for (const reference of references) {
-            text += referenceLine(reference, `from ${madeBy(reference)}`, support);
+        for (const place of references) {
+            const reference = graph.references[place];
+            if (reference !== undefined) {
+                text += referenceLine(reference, `from ${madeBy(reference)}`, support, {
+                    making: graph.configurations[place] ?? [],
+                    run: matrix.configurations,
+                });
+            }
         }
     }
     if (candidate !== undefined) {
@@ -294,7 +215,7 @@ function namedElsewhere(findings, subject) {
         .join("");
 }
 /** The one explanation that applies to a declaration, built whole before it is written. */
-function explanation(analysis, subject, cascade, mode) {
+function explanation(analysis, subject, cascade) {
     const graph = analysis.swept.matrix.union;
     const at = graph.at(subject.id);
     let text = `symbol: ${subject.ref}\n`;
@@ -302,7 +223,7 @@ function explanation(analysis, subject, cascade, mode) {
     text += `position: ${subject.id}\n`;
     text += `configurations: ${listed(analysis.swept.matrix.heldIn[at] ?? [])}\n`;
     const found = analysis.result.findings.find((one) => positionKey(one.position) === subject.id);
-    const retained = analysis.swept.retained.filter((one) => one.id === subject.id);
+    const retained = analysis.swept.sweep.retained.filter((one) => one.id === subject.id);
     if (found !== undefined) {
         text += reported(found);
     }
@@ -312,22 +233,22 @@ function explanation(analysis, subject, cascade, mode) {
             text += `  class: ${one.class}\t${positionKey(one.site)}\t${one.detail}\n`;
         }
     }
-    else if (analysis.swept.heldByUnanswered.includes(subject.id)) {
+    else if (analysis.swept.sweep.held.includes(subject.id)) {
         text +=
             "answer: held\n  held by: a question the checker did not answer, which could have kept it live, so no finding names it\n";
     }
     else {
-        text += liveness(analysis, subject, cascade, mode);
+        text += liveness(analysis, subject, cascade);
     }
     return text + namedElsewhere(analysis.result.findings, subject);
 }
 /**
  * Explains one symbol from the analysis the report is built from: why a reported symbol is
  * reported, which exemption classes held a retained one back, that an unanswered question held
- * a held one, and for any other declaration the relations that hold it live and the shortest
- * path from a root, a loaded consumer or a test file no project holds, or the references it
- * has where no path reaches it. A request naming no one declaration exits with the usage
- * code and names what partially matches it. Where the analysis was partial, the error stream says so.
+ * a held one, and for any other declaration the relations that hold it live and the path the
+ * sweep's strongest tier reaching it follows, or the references it has where no path reaches
+ * it. A request naming no one declaration exits with the usage code and names what partially
+ * matches it. Where the analysis was partial, the error stream says so.
  */
 export const explainVerb = ({ out, err, host, inputs, scope, openClient, option }) => {
     const named = namedSymbol(option);
@@ -351,7 +272,7 @@ export const explainVerb = ({ out, err, host, inputs, scope, openClient, option
         }
     }
     else {
-        out.write(explanation(analysis, subject, config.reporters.cascade, mode));
+        out.write(explanation(analysis, subject, config.reporters.cascade));
     }
     for (const note of notes) {
         diagnose(err, note);

package/dist/src/verbs/print-retained.js

@@ -20,7 +20,7 @@ export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient })
         marked: [],
         mode: productionMode(config),
     });
-    for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
+    for (const line of retainedLines(swept.matrix.union.symbols, swept.sweep.retained)) {
         out.write(`${line}\n`);
     }
     for (const note of partialNotes({

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.17",
+  "version": "8.0.0-dev.19",
   "license": "GPL-3.0-or-later",
   "exports": {
     ".": "./src/index.ts"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cplieger/deadset-ts",
-  "version": "8.0.0-dev.17",
+  "version": "8.0.0-dev.19",
   "type": "module",
   "sideEffects": false,
   "description": "Deterministic dead-code analysis for TypeScript, class and type members included",

package/src/analysis.ts

@@ -17,6 +17,7 @@ import {
 } from "./roots/configured-declarations.ts";
 import { decorator } from "./decorator.ts";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.ts";
+import { carriersOf, NO_CARRIERS, type Carriers } from "./exposure.ts";
 import { deprecatedDeclarations, type Deprecation } from "./deprecation.ts";
 import { moduleIdentity, type LoadedConsumer, type NotBuilt } from "./load/discover.ts";
 import type { LibraryUnfound } from "./load/classify.ts";
@@ -35,9 +36,7 @@ import {
   heldRecords,
   disabledClasses,
   exemptionsOf,
-  holdingWhile,
   isUnansweredRecord,
-  retainedIn,
   writtenRecords,
   type Detector,
   type Detectors,
@@ -57,15 +56,7 @@ import { intraFunctionFacts, projectParts, type ProjectParts } from "./intra-fun
 import { type Inventory, type InventorySymbol } from "./inventory.ts";
 import { inventory } from "./inventory/enumerate.ts";
 import { readManifest, type ManifestEntry } from "./roots/manifest.ts";
-import {
-  liveFilesAt,
-  matrixOf,
-  referenceKey,
-  sweepMatrix,
-  type Configured,
-  type Matrix,
-  type SweepResult,
-} from "./matrix.ts";
+import { matrixOf, referenceKey, type Configured, type Matrix } from "./liveness/matrix.ts";
 import {
   ancestors,
   dirnamePath,
@@ -108,7 +99,9 @@ import { accessorsOf, storesOf } from "./stores.ts";
 import { isPartKind, type SuppressionRecord, type Suppressions, type Verdict } from "./suppress.ts";
 import { bindRows, readBaseline, readIgnoreFile, type Recorded } from "./suppress-file.ts";
 import { inlineDirectives, inlineSuppressions, type InlineDirective } from "./suppress-inline.ts";
-import type { Exemption, Mode, SweepInput } from "./sweep.ts";
+import { sweep, type Sweep, type SweepPolicy } from "./liveness/sweep.ts";
+import type { Exemption } from "./exempt.ts";
+import type { Mode } from "./tests/file-class.ts";
 import { readTemplates, templateField } from "./template-field.ts";
 import { bytewise } from "./text/compare.ts";
 import { holdsManifest, manifestAt } from "./fs/manifest.ts";
@@ -434,27 +427,13 @@ export function productionMode(config: PartialConfig): Mode {
 /** The run's sweep, beside the matrix it judged. */
 export interface RunSweep {
   readonly matrix: Matrix;
-  readonly sweep: SweepResult;
-  /** The exemption records that hold under the sweep. */
-  readonly exempt: readonly Exemption[];
-  /**
-   * The exemption records that held back a declaration some configuration of the run
-   * would otherwise judge dead, in the declarations' site order.
-   */
-  readonly retained: readonly Exemption[];
+  readonly sweep: Sweep;
   /** The derived configurations the run dropped. */
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
   readonly unanswered: readonly UnansweredQuestion[];
-  /**
-   * Every declaration an unanswered question could have kept live, and every one only
-   * such a declaration keeps live. The run reports none of them.
-   */
-  readonly heldByUnanswered: readonly string[];
   /** The lines of the units type errors skipped, on which the run reports nothing. */
   readonly skipped: readonly SkippedUnit[];
-  /** The component files the run read, by path below the target root, each once. */
-  readonly componentFiles: readonly string[];
 }
 
 /** One `<script` start tag of a component file the run read no block for. */
@@ -527,6 +506,8 @@ interface ReadRun<Extra> {
   readonly projects: readonly SweptProject<Extra>[];
   /** Every declared consumer, each loaded, in the scope's order. */
   readonly consumers: readonly LoadedConsumer[];
+  /** Whether the scope declares a consumer, loaded or not. */
+  readonly declaresConsumers: boolean;
   /** The derived configurations the run dropped. */
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
@@ -826,6 +807,7 @@ function readRun<Extra>(
     ],
     projects,
     consumers: read.plan.discovery.consumers,
+    declaresConsumers: scope.consumers.length > 0,
     notBuilt: read.classified.notBuilt,
     unanswered: read.unanswered,
     componentsUnread: read.plan.workspace?.componentsUnread ?? [],
@@ -840,33 +822,6 @@ function readRun<Extra>(
   };
 }
 
-/**
- * The run swept under one set of marks with the records that hold. A record a component
- * file's markup holds counts only while the file is live, and what it holds may be what
- * keeps the file live, so each file's markup joins only once a sweep without it finds the
- * file live, until a sweep finds no further file live.
- */
-function holdingSweep<Extra>(
-  read: ReadRun<Extra>,
-  input: Pick<SweepInput, "marked" | "mode">,
-): { readonly swept: SweepInput; readonly result: SweepResult } {
-  const paths = new Set(read.exempt.flatMap((record) => record.whileLive ?? []));
-  let live = new Set<string>();
-  for (;;) {
-    const swept: SweepInput = {
-      ...input,
-      exempt: holdingWhile(read.exempt, live),
-      unanswered: read.unansweredHeld,
-    };
-    const result = sweepMatrix(read.matrix, swept);
-    const next = new Set(liveFilesAt(read.matrix, result, paths).map((one) => one.position.path));
-    if (next.size === live.size) {
-      return { swept, result };
-    }
-    live = next;
-  }
-}
-
 /**
  * The test references exemption evidence written in a test file makes: each is a read of
  * the declaration it would retain, made by the test file at the evidence's site.
@@ -939,62 +894,27 @@ function writtenOnly<Extra>(read: ReadRun<Extra>, mode: Mode): ReadonlySet<strin
   return new Set([...written].filter((id) => !readSome.has(id)));
 }
 
-/**
- * The sweep of a run read once, under one set of marks. Where a question went unanswered,
- * the run is swept once more without what that question could have kept live and without
- * the references that stood in for its answer, and every declaration that sweep judges
- * dead and this one judges live, or dead by another rule, is held by the gap too, as is
- * every declaration that makes such a reference.
- */
+/** The sweep of a run read once, under one set of marks. */
 function sweptOf<Extra>(
   read: ReadRun<Extra>,
-  input: Pick<SweepInput, "marked" | "mode">,
+  input: Pick<SweepPolicy, "marked" | "mode">,
 ): RunSweep {
-  const { swept, result } = holdingSweep(read, input);
-  const exempt = swept.exempt ?? [];
-  const held = new Set(read.unansweredHeld);
-  if (held.size > 0) {
-    // What a declaration reads where the checker did not answer is unknown, so a rule
-    // over what it reads, the test of dead code among them, cannot judge it.
-    for (const { configured } of read.projects) {
-      for (const reference of configured.references) {
-        if (reference.guessed === true) {
-          held.add(reference.from);
-        }
-      }
-    }
-    const dead = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
-    const answered = matrixOf(
-      read.projects.map(({ configured }) => ({
-        ...configured,
-        references: configured.references.filter((one) => one.guessed !== true),
-      })),
-    );
-    const bare: SweepInput = {
-      ...swept,
-      exempt: exempt.filter((record) => !isUnansweredRecord(record)),
-      unanswered: [],
-    };
-    for (const candidate of sweepMatrix(answered, bare).candidates) {
-      const kept = dead.get(candidate.id);
-      if (
-        kept?.testOfDeadCode !== candidate.testOfDeadCode ||
-        kept.relation !== candidate.relation
-      ) {
-        held.add(candidate.id);
-      }
-    }
-  }
+  const componentFiles = [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(
+    bytewise,
+  );
   return {
     matrix: read.matrix,
-    sweep: result,
-    exempt,
-    retained: retainedIn(read.matrix, swept, writtenOnly(read, input.mode)),
+    sweep: sweep(read.matrix, {
+      ...input,
+      exempt: read.exempt,
+      unanswered: read.unansweredHeld,
+      componentFiles,
+      unseenCallers: !read.declaresConsumers,
+      writeOnly: writtenOnly(read, input.mode),
+    }),
     notBuilt: read.notBuilt,
     unanswered: read.unanswered,
-    heldByUnanswered: [...held],
     skipped: read.projects.flatMap((one) => one.skipped),
-    componentFiles: [...new Set(read.projects.flatMap((one) => one.componentFiles))].sort(bytewise),
   };
 }
 
@@ -1011,7 +931,7 @@ export function runSweep(
   host: Host,
   scope: Scope,
   config: ResolvedConfig,
-  input: Pick<SweepInput, "marked" | "mode">,
+  input: Pick<SweepPolicy, "marked" | "mode">,
   detectors: Detectors = DETECTORS,
 ): RunSweep {
   return sweptOf(
@@ -1035,6 +955,7 @@ interface EmitterExtra {
   readonly declarationsNamed: readonly boolean[];
   readonly parts: ProjectParts;
   readonly unseenLoads: readonly UnseenLoad[];
+  readonly carriers: Carriers;
 }
 
 /** The project's own files below the target root that are no test file. */
@@ -1090,6 +1011,8 @@ export function readEmitterRun(
       declarationsNamed: declarationsNamed(project, read.held, configuredDeclarations(config)),
       parts: projectParts(project, read.held, references, targetRoot),
       unseenLoads,
+      // Only a closed world reports an unnecessary export, which is all the carriers decide.
+      carriers: config.consumers.complete ? carriersOf(project, read.held) : NO_CARRIERS,
     }),
   );
   // Whether a declaration carries the marker decides its code, so one whose answer went
@@ -1156,7 +1079,7 @@ export function emitterInputOver(
   scope: Scope,
   config: ResolvedConfig,
   read: ReadRun<EmitterExtra>,
-  input: Pick<SweepInput, "marked" | "mode">,
+  input: Pick<SweepPolicy, "marked" | "mode">,
   selfCheck: SelfCheckFacts,
 ): EmitterInput {
   const targetRoot = scope.target.path;
@@ -1173,7 +1096,7 @@ export function emitterInputOver(
         support: new Set(one.configured.supportFiles ?? []),
         accessors: one.extra.accessors,
       })),
-      swept.exempt,
+      swept.sweep.exempt,
       input.mode,
     ),
     dependencies: dependenciesOf(
@@ -1193,6 +1116,16 @@ export function emitterInputOver(
       generated: new Set(projects.flatMap((one) => [...one.extra.generated.keys()])),
       inOperands: new Set(projects.flatMap((one) => one.extra.inOperands)),
       unseenLoads: projects.flatMap((one) => one.extra.unseenLoads),
+      unwrittenRuns: new Set(
+        projects.flatMap((one) =>
+          one.heldScripts
+            .filter((held) => held.unwritten)
+            .map(
+              (held) =>
+                relativePath(resolvePath(host.workingDirectory(), targetRoot), held.dir) ?? ".",
+            ),
+        ),
+      ),
     },
     boundary: {
       consumers: {
@@ -1203,12 +1136,23 @@ export function emitterInputOver(
       edges: readEdgeSides(host, targetRoot),
       filledOutside: new Set(projects.flatMap((one) => one.filledOutside)),
       possiblyLoaded: new Set(projects.flatMap((one) => one.possiblyLoaded)),
+      carriers: {
+        named: new Map(
+          [
+            ...Map.groupBy(
+              projects.flatMap((one) => [...one.extra.carriers.named]),
+              ([id]) => id,
+            ),
+          ].map(([id, entries]) => [id, [...new Set(entries.flatMap(([, named]) => named))]]),
+        ),
+        unread: new Set(projects.flatMap((one) => [...one.extra.carriers.unread])),
+      },
     },
     selfCheck,
     intraFunction: intraFunctionFacts(
       projects.map((one) => one.extra.parts),
       projects.flatMap((one) => one.configured.references),
-      new Set([...swept.exempt.map((one) => one.id), ...swept.heldByUnanswered]),
+      new Set([...swept.sweep.exempt.map((one) => one.id), ...swept.sweep.held]),
     ),
   };
 }
@@ -1448,14 +1392,16 @@ export function runAnalysis(
  * declarations of its own the run holds for them.
  */
 export function unansweredCounts(analysis: RunAnalysis): readonly UnansweredCount[] {
-  const held = new Set(analysis.swept.heldByUnanswered);
+  const held = new Set(analysis.swept.sweep.held);
   return analysis.run.projects.flatMap((project) => {
     const questions =
       analysis.run.unanswered.filter((one) => one.configFile === project.configFile).length +
       analysis.run.unread.filter(
         (one) => one.kind === "manifest" && one.configFile === project.configFile,
       ).length +
-      analysis.run.heldScripts.filter((one) => one.configFile === project.configFile).length;
+      analysis.run.heldScripts.filter(
+        (one) => one.configFile === project.configFile && one.files.length > 0,
+      ).length;
 
     if (questions === 0) {
       return [];

package/src/augmentations.ts

@@ -14,7 +14,7 @@ import {
   type Node,
 } from "@typescript/native/ast";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
-import { referenceKey } from "./matrix.ts";
+import { referenceKey } from "./liveness/matrix.ts";
 import type { Reference } from "./references.ts";
 import type { ProjectView } from "./session.ts";
 import type { SourceFiles } from "./source-files.ts";