@cplieger/deadset-ts 3.11.0 → 3.12.0

package/dist/src/references.js

@@ -3,6 +3,7 @@ import { aliasChains } from "./alias-chain.js";
 import { destructuring, propertyReadsOf } from "./destructuring.js";
 import { globExpression } from "./glob.js";
 import { nodeKey } from "./inventory.js";
+import { relativePath } from "./paths.js";
 import { byPosition, renderPosition } from "./position.js";
 /**
  * The batch cap a run takes when the configuration names none. It bounds the size of
@@ -306,7 +307,9 @@ function compare(a, b) {
  *
  * `held` is the inventory of the same project, whose declaration map is what a resolved
  * symbol is looked up in; `targetRoot` is the absolute path every position is rendered
- * against, which is the root the inventory was read against.
+ * against, which is the root the inventory was read against. A pass over a consumer
+ * walks the consumer's files instead and renders against its root, as
+ * {@link ReferenceOptions.consumer} states.
  *
  * The order is by the referencing position, then by the declaration named, the
  * declaration referencing it and the use. That is a total order because one name
@@ -326,7 +329,14 @@ export function references(project, held, targetRoot, options) {
     let fileBatches = 0;
     let residueFallbacks = 0;
     let shorthandLookups = 0;
-    const files = project.ownSourceFiles();
+    const consumer = options.consumer;
+    const root = consumer?.root ?? targetRoot;
+    const files = consumer === undefined
+        ? project.ownSourceFiles()
+        : project
+            .ownSourceFiles()
+            .filter((file) => relativePath(consumer.root, file.fileName) !== undefined &&
+            relativePath(targetRoot, file.fileName) === undefined);
     const fileIds = new Set(held.symbols.filter((symbol) => symbol.kind === "file").map((symbol) => symbol.id));
     /** The identifier of the declaration one node of this program is, where it is one. */
     const declaredAt = (node) => declarations.get(nodeKey(node.getSourceFile(), node));
@@ -352,7 +362,7 @@ export function references(project, held, targetRoot, options) {
         return project.resolvedSymbolAt(project.handle(site.node));
     };
     for (const file of files) {
-        const path = renderPosition(file, targetRoot, 0).path;
+        const path = renderPosition(file, root, 0).path;
         const test = patterns.some((pattern) => pattern.test(path));
         if (test) {
             tests.push(path);
@@ -365,7 +375,7 @@ export function references(project, held, targetRoot, options) {
             found.push({
                 from: declaration,
                 to: declaration,
-                position: renderPosition(file, targetRoot, decorator.getStart()),
+                position: renderPosition(file, root, decorator.getStart()),
                 use: "decorator",
                 resolution: "syntax",
                 test,
@@ -401,7 +411,7 @@ export function references(project, held, targetRoot, options) {
             if (symbol === undefined) {
                 continue;
             }
-            const position = renderPosition(file, targetRoot, link.at.getStart());
+            const position = renderPosition(file, root, link.at.getStart());
             for (const id of carriedBy(link, symbol)) {
                 found.push({
                     from: link.from,
@@ -418,7 +428,7 @@ export function references(project, held, targetRoot, options) {
             if (module === undefined) {
                 continue;
             }
-            const position = renderPosition(file, targetRoot, evaluation.node.getStart());
+            const position = renderPosition(file, root, evaluation.node.getStart());
             for (const id of chains.declarationsOf(module)) {
                 if (fileIds.has(id)) {
                     found.push({
@@ -439,7 +449,7 @@ export function references(project, held, targetRoot, options) {
             if (symbol === undefined || read === undefined) {
                 return;
             }
-            const position = renderPosition(file, targetRoot, read.key.getStart());
+            const position = renderPosition(file, root, read.key.getStart());
             for (const target of chains.chainOf(symbol)) {
                 found.push({
                     from: read.from,
@@ -461,7 +471,7 @@ export function references(project, held, targetRoot, options) {
             if (symbol === undefined) {
                 continue;
             }
-            const position = renderPosition(file, targetRoot, site.node.getStart());
+            const position = renderPosition(file, root, site.node.getStart());
             // A re-export something imports is used and so is the declaration behind it, so
             // the use names every link of the chain its name stands at the head of.
             for (const target of chains.chainOf(symbol)) {
@@ -482,7 +492,9 @@ export function references(project, held, targetRoot, options) {
         compare(a.use, b.use));
     return {
         configFile: project.configFile,
-        references: found,
+        references: consumer === undefined
+            ? found
+            : found.map((reference) => ({ ...reference, consumer: consumer.id })),
         testFilePaths: tests.sort(compare),
         cost: {
             batched,

package/dist/src/report.js

@@ -188,6 +188,9 @@ export function buildReport(input) {
     const unavailable = [...new Map(input.unavailable.map((one) => [one.id, one])).values()]
         .sort((a, b) => compare(a.id, b.id))
         .map((one) => ({ id: one.id, role: "consumer", reason: one.reason }));
+    const loaded = [...input.loaded]
+        .sort((a, b) => compare(a.id, b.id) || compare(a.path, b.path))
+        .map((one) => ({ id: one.id, role: "consumer", path: one.path }));
     return {
         schema_version: SCHEMA_VERSION,
         contract_version: input.contractVersion,
@@ -207,7 +210,7 @@ export function buildReport(input) {
             .sort((a, b) => compare(a.id, b.id))
             .map((one) => ({ id: one.id, project: one.project })),
         configurations_not_built: [],
-        consumers: { declared: unavailable.length, loaded: [], unavailable },
+        consumers: { declared: loaded.length + unavailable.length, loaded, unavailable },
         findings,
         edge_evaluations: input.result.edgeEvaluations.map(wireEvaluation).sort(byEdge),
         stale_suppressions: input.result.staleSuppressions.map(wireStale).sort(canonicalStale),

package/dist/src/session.js

@@ -71,6 +71,21 @@ function viewOf(project) {
         },
     };
 }
+/**
+ * The same project, its own source files narrowed to the ones `keep` admits. A consumer's
+ * program holds the target's files it imports beside its own, and a pass that enumerates
+ * the target's declarations in that program reads those files alone.
+ */
+export function narrowedTo(project, keep) {
+    let kept;
+    return {
+        ...project,
+        ownSourceFiles: () => {
+            kept ??= project.ownSourceFiles().filter(keep);
+            return kept;
+        },
+    };
+}
 /** The three diagnostic sets one project carries, read before any analysis. */
 export function diagnosticsOf(project) {
     return {

package/dist/src/sweep.js

@@ -67,6 +67,13 @@ export function sweep(graph, input) {
     });
     return { liveUnder: live, candidates };
 }
+/**
+ * The references a loaded consumer makes that the mode counts. A production mode counts
+ * none a consumer's test file made, as it counts none of the target's.
+ */
+function callsOf(graph, mode) {
+    return graph.consumed.filter((edge) => !mode.production || !edge.test);
+}
 /** Per declaration of the graph, whether one of the identifiers names it. */
 function flagged(graph, ids) {
     const flags = graph.symbols.map(() => false);
@@ -126,6 +133,10 @@ function reachable(graph, held, mode) {
     for (const root of graph.rooted) {
         enter(root.at, false);
     }
+    // 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);
+    }
     walk(false);
     return reached;
 }

package/dist/src/verbs/analyze.js

@@ -1,8 +1,8 @@
 import { runAnalysis } from "../analysis.js";
 import { ConfigError } from "../config.js";
 import { CONFORMANCE, DECLARED_GAPS } from "../conformance.js";
+import { moduleIdentity } from "../consumers.js";
 import { analyzerProvenance, recordedFindings, verdictOf } from "../findings-pass.js";
-import { packageScope } from "../inventory.js";
 import { joinPath, normalizePath, relativePath, resolvePath } from "../paths.js";
 import { buildReport, capFindings, sortFindings, } from "../report.js";
 import { json } from "../reporters/json.js";
@@ -20,8 +20,6 @@ export const ANALYZE_OPTIONS = {
 /** The two values `--exit-code` takes; on, the default, puts the run's verdict in the exit code. */
 const EXIT_CODE_ON = "on";
 const EXIT_CODE_OFF = "off";
-/** Why a declared consumer is not loaded, which every report names it with. */
-const NOT_LOADED = "this analyzer loads no consumer beside the target";
 /** A path of the run no report can name, which ends the run with the failure code. */
 class ReportPathError extends Error {
     constructor(message) {
@@ -73,10 +71,6 @@ function configurationsOf(projects, targetRoot) {
         return { id: one.id, project };
     });
 }
-/** The name one module publishes itself under: the scope's, else its manifest's. */
-function identityOf(module, host) {
-    return module.id === "" ? packageScope(host, module.path)("index.ts").package : module.id;
-}
 /** A count with its noun, so a message reads for one record as well as for several. */
 function counted(n, noun) {
     return `${String(n)} ${noun}${n === 1 ? "" : "s"}`;
@@ -163,12 +157,13 @@ export const analyzeVerb = ({ err, host, inputs, scope, openClient, option, repe
             version,
             conformance: CONFORMANCE,
             declaredGaps: DECLARED_GAPS,
-            target: { kind, root, identity: identityOf(scoped.target, host) },
+            target: { kind, root, identity: moduleIdentity(host, scoped.target) },
             configurations: configurationsOf(run.projects, targetRoot),
-            unavailable: scoped.consumers.map((consumer) => ({
-                id: identityOf(consumer, host),
-                reason: NOT_LOADED,
+            loaded: run.consumers.map((consumer) => ({
+                id: consumer.id,
+                path: runRelative(invoked, consumer.path),
             })),
+            unavailable: [],
             result,
             testFileRules: run.testFileRules,
         });

package/dist/src/verbs/explain.js

@@ -2,6 +2,7 @@ import { runAnalysis } from "../analysis.js";
 import { listing } from "../components.js";
 import { ConfigError } from "../config.js";
 import { OUTSIDE, swept as judged } from "../graph.js";
+import { referenceKey } from "../matrix.js";
 import { positionKey } from "../position.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_USAGE } from "./verb.js";
@@ -78,7 +79,7 @@ function referencesOf(configured) {
     const seen = new Set();
     const held = [];
     for (const reference of configured.flatMap((one) => one.references)) {
-        const key = [reference.from, reference.to, positionKey(reference.position), reference.use].join("\u0000");
+        const key = referenceKey(reference);
         if (!seen.has(key)) {
             seen.add(key);
             held.push(reference);
@@ -101,8 +102,9 @@ function rootsOf(configured) {
     });
 }
 /**
- * The shortest path from a root to one declaration, walked breadth first from every root at
- * once in the order the run names them, following the references the sweep follows: a
+ * The shortest path from a root or a loaded consumer to one declaration, walked breadth first
+ * from every root at once in the order the run names them, a consumer's reference being the
+ * first hop of a path of its own, 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.
@@ -110,10 +112,16 @@ function rootsOf(configured) {
 function shortestPath(analysis, to, production) {
     const graph = analysis.swept.matrix.union;
     const out = new Map();
+    const consumed = [];
     for (const reference of referencesOf(analysis.configured)) {
         if (production && reference.test) {
             continue;
         }
+        const { consumer } = reference;
+        if (consumer !== undefined) {
+            consumed.push({ ...reference, consumer });
+            continue;
+        }
         const held = out.get(reference.from);
         if (held === undefined) {
             out.set(reference.from, [reference]);
@@ -131,10 +139,32 @@ function shortestPath(analysis, to, production) {
             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, root });
+        enter({ at: root.id, hop: undefined, previous: -1, origin: { k: "root", root } });
     }
-    for (let head = 0; head < steps.length; head += 1) {
+    // A consumer's 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 of consumed) {
+                follow(reference, -1, { k: "consumer", consumer: reference.consumer });
+            }
+        }
         const step = steps[head];
         if (step === undefined) {
             break;
@@ -144,35 +174,18 @@ function shortestPath(analysis, to, production) {
             for (let at = step; at?.hop !== undefined; at = steps[at.previous]) {
                 path.unshift(at.hop);
             }
-            return { root: step.root, path };
+            return { origin: step.origin, path };
         }
         for (const reference of out.get(step.at) ?? []) {
-            enter({
-                at: reference.to,
-                hop: { k: "reference", reference },
-                previous: head,
-                root: step.root,
-            });
-            const target = graph.at(reference.to);
-            if (reference.use === "evaluation" || target === OUTSIDE || expanded.has(reference.to)) {
-                continue;
-            }
-            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: head,
-                        root: step.root,
-                    });
-                }
-            }
+            follow(reference, head, step.origin);
         }
     }
     return undefined;
 }
+/** 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}`;
+}
 function referenceLine(reference, tail) {
     return `  reference: ${positionKey(reference.position)}\t${reference.use}\t${tail}${reference.test ? "\tfrom a test file" : ""}\n`;
 }
@@ -190,9 +203,10 @@ function liveness(analysis, subject, cascade) {
     }
     const found = shortestPath(analysis, subject.id, true) ?? shortestPath(analysis, subject.id, false);
     if (found !== undefined && found.path.length > 0) {
-        text += `  reached from: root ${found.root.kind} ${found.root.id}\n`;
+        const { origin } = found;
+        text += `  reached from: ${origin.k === "root" ? `root ${origin.root.kind} ${origin.root.id}` : `consumer ${origin.consumer}`}\n`;
         for (const hop of found.path) {
-            text += referenceLine(hop.reference, `${hop.reference.from} -> ${hop.reference.to}`);
+            text += referenceLine(hop.reference, `${madeBy(hop.reference)} -> ${hop.reference.to}`);
             if (hop.k === "export") {
                 text += `  export: ${hop.reference.to} -> ${hop.to}\n`;
             }
@@ -200,10 +214,10 @@ function liveness(analysis, subject, cascade) {
     }
     else if (found === undefined) {
         const references = referencesOf(analysis.configured).filter((one) => one.to === subject.id);
-        text += "  unreachable: no path of references reaches it from a root\n";
+        text += "  unreachable: no path of references reaches it from a root or a loaded consumer\n";
         text += `  references: ${String(references.length)}\n`;
         for (const reference of references) {
-            text += referenceLine(reference, `from ${reference.from}`);
+            text += referenceLine(reference, `from ${madeBy(reference)}`);
         }
     }
     if (candidate !== undefined) {
@@ -277,9 +291,9 @@ function explanation(analysis, subject, cascade) {
  * Explains one symbol from the analysis the report is built from, so an explanation cannot
  * disagree with a finding: why a reported symbol is reported, which exemption classes held a
  * retained one back, and for any other declaration the relations that hold it live and the
- * shortest path of references from a root, 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.
+ * shortest path of references from a root or a loaded consumer, 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.
  */
 export const explainVerb = ({ out, err, host, inputs, scope, openClient, option }) => {
     const named = namedSymbol(option);

package/jsr.json

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

package/package.json

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

package/src/analysis.ts

@@ -10,6 +10,12 @@
 
 import type { Diagnostic } from "@typescript/native/unstable/sync";
 import type { Config, Provenance } from "./config.ts";
+import {
+  consumerLoads,
+  consumerReferences,
+  moduleIdentity,
+  type LoadedConsumer,
+} from "./consumers.ts";
 import { decorator } from "./decorator.ts";
 import { dependenciesOf, projectNeeds } from "./dependencies.ts";
 import { deprecatedDeclarations } from "./deprecation.ts";
@@ -41,11 +47,18 @@ import { injectionContainer } from "./injection-container.ts";
 import { interfaceSatisfaction } from "./interface-satisfaction.ts";
 import { inventory, type Inventory } from "./inventory.ts";
 import { readManifest } from "./manifest.ts";
-import { matrixOf, sweepMatrix, type Configured, type Matrix, type SweepResult } from "./matrix.ts";
+import {
+  matrixOf,
+  referenceKey,
+  sweepMatrix,
+  type Configured,
+  type Matrix,
+  type SweepResult,
+} from "./matrix.ts";
 import { relativePath, resolvePath } from "./paths.ts";
 import { byPosition, type Position } from "./position.ts";
 import { reflectiveLookup } from "./reflective-lookup.ts";
-import { references, testFileRulesOf, type TestFileRule } from "./references.ts";
+import { references, testFileRulesOf, type Reference, type TestFileRule } from "./references.ts";
 import { roots, unmatchedEverywhere, type RootKind, type Roots } from "./roots.ts";
 import type { Scope } from "./scope.ts";
 import { serializationContract } from "./serialization-contract.ts";
@@ -125,11 +138,27 @@ interface ProjectRead {
   readonly rooted: Roots;
 }
 
+/** What a run read of the consumers its scope declares. */
+interface ConsumerReads {
+  /** Every declared consumer, each loaded, in the scope's order. */
+  readonly loaded: readonly LoadedConsumer[];
+  /** Every reference a consumer makes to a declaration of the target, each once. */
+  readonly references: readonly Reference[];
+}
+
+/** What a run read of its projects: each target project's answer, and its consumers. */
+interface ReadProjects<Answer> {
+  readonly answers: readonly Answer[];
+  readonly consumers: ConsumerReads;
+}
+
 /**
- * Reads every project the scope discovers, in one snapshot: each is checked for errors
- * first, then enumerated, then rooted, and `stage` reads the rest of what it needs from
- * the project while its view is open. A project carrying an error fails the run with no
- * answer, as every verb that reads declarations does.
+ * Reads every project the scope discovers, and every project of every consumer it
+ * declares, in one snapshot. Each is checked for errors first. A target project is then
+ * enumerated and rooted, and `stage` reads the rest of what it needs from the project
+ * while its view is open; a consumer project is read for its references to the target's
+ * declarations. A project carrying an error fails the run with no answer, as every verb
+ * that reads declarations does, and so does a declared consumer that cannot be loaded.
  */
 function readProjects<Answer>(
   engine: Engine,
@@ -137,10 +166,16 @@ function readProjects<Answer>(
   scope: Scope,
   config: Config,
   stage: <Brand>(project: ProjectView<Brand>, read: ProjectRead) => Answer,
-): readonly Answer[] {
+): ReadProjects<Answer> {
   const targetRoot = scope.target.path;
   const discovered = discoverProjects(engine, host, scope, config.analysis.configurations);
   const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
+  const loads = consumerLoads(engine, host, scope, discovered.configFiles);
+  const consumerOf = new Map(
+    loads.flatMap((load) =>
+      load.configFiles.map((configFile) => [configFile, load.consumer] as const),
+    ),
+  );
   const options = {
     manifest: readManifest(host, targetRoot),
     patterns: config.rootPatterns,
@@ -149,24 +184,51 @@ function readProjects<Answer>(
     publishedAPI: config.targetKind === "library",
   };
   const failures: Diagnostic[] = [];
-  const { projects } = runSession(engine, discovered.configFiles, (project) => {
-    const errors = diagnosticErrors(diagnosticsOf(project));
-    if (errors.length > 0) {
-      failures.push(...errors);
-      return undefined;
-    }
-    const held = inventory(project, host, targetRoot);
-    const rooted = roots(project, held, targetRoot, options);
-    const configuration = ids.get(project.configFile) ?? project.configFile;
-    return stage(project, { configuration, configFile: project.configFile, held, rooted });
-  });
+  const consumed = new Map<string, Reference>();
+  const { projects } = runSession(
+    engine,
+    [...discovered.configFiles, ...consumerOf.keys()],
+    (project) => {
+      const errors = diagnosticErrors(diagnosticsOf(project));
+      if (errors.length > 0) {
+        failures.push(...errors);
+        return undefined;
+      }
+      const consumer = consumerOf.get(project.configFile);
+      if (consumer !== undefined) {
+        for (const reference of consumerReferences(
+          project,
+          host,
+          targetRoot,
+          {
+            id: consumer.id,
+            root: consumer.path,
+          },
+          config,
+        )) {
+          consumed.set(referenceKey(reference), reference);
+        }
+        return undefined;
+      }
+      const held = inventory(project, host, targetRoot);
+      const rooted = roots(project, held, targetRoot, options);
+      const configuration = ids.get(project.configFile) ?? project.configFile;
+      return stage(project, { configuration, configFile: project.configFile, held, rooted });
+    },
+  );
   if (failures.length > 0) {
     throw new DiscoveryError(
       `${String(failures.length)} error(s); no answer was produced`,
       failures,
     );
   }
-  return projects.filter((answer): answer is Answer => answer !== undefined);
+  return {
+    answers: projects.filter((answer): answer is Answer => answer !== undefined),
+    consumers: {
+      loaded: loads.map((load) => load.consumer),
+      references: [...consumed.values()],
+    },
+  };
 }
 
 /**
@@ -183,7 +245,7 @@ export function runRoots(
   provenance: Provenance,
 ): RunRoots {
   const targetRoot = scope.target.path;
-  const projects = readProjects(engine, host, scope, config, (_project, read) => read);
+  const projects = readProjects(engine, host, scope, config, (_project, read) => read).answers;
 
   const configurations: string[] = [];
   const merged = new Map<string, Omit<RunRoot, "configurations"> & { configurations: string[] }>();
@@ -266,12 +328,15 @@ interface ReadRun<Extra> {
   readonly matrix: Matrix;
   readonly exempt: readonly Exemption[];
   readonly projects: readonly SweptProject<Extra>[];
+  /** Every declared consumer, each loaded, in the scope's order. */
+  readonly consumers: readonly LoadedConsumer[];
 }
 
 /**
  * Reads every project of the run, its references and exemptions, and `extra`'s answer,
  * while the project's view is open, and merges the projects into one matrix in the run's
- * order.
+ * order. Every configuration holds every consumer's references beside its own, because a
+ * consumer calls the target whichever configuration the target is built under.
  */
 function readRun<Extra>(
   engine: Engine,
@@ -288,7 +353,7 @@ function readRun<Extra>(
     ? { delimiters: config.analysis.templateDelimiters, files: [] }
     : readTemplates(host, targetRoot, config.analysis);
   const consumers = scope.consumers.map((consumer) => consumer.path);
-  const projects = readProjects(engine, host, scope, config, (project, projectRead) => {
+  const read = readProjects(engine, host, scope, config, (project, projectRead) => {
     const resolved = references(project, projectRead.held, targetRoot, {
       testFiles: config.ts.testFiles,
     });
@@ -315,10 +380,23 @@ function readRun<Extra>(
       extra: extra(project, projectRead),
     };
   });
+  const consumed = read.consumers.references;
+  const projects = read.answers.map((one) =>
+    consumed.length === 0
+      ? one
+      : {
+          ...one,
+          configured: {
+            ...one.configured,
+            references: [...one.configured.references, ...consumed],
+          },
+        },
+  );
   return {
     matrix: matrixOf(projects.map((one) => one.configured)),
     exempt: exemptionsOf(projects.flatMap((one) => one.exempt)),
     projects,
+    consumers: read.consumers.loaded,
   };
 }
 
@@ -430,7 +508,10 @@ function emitterInputOver(
       heldByInclusion: new Set(projects.flatMap((one) => one.extra.heldByInclusion)),
     },
     boundary: {
-      consumers: { declared: scope.consumers.map((consumer) => consumer.id), loaded: [] },
+      consumers: {
+        declared: scope.consumers.map((consumer) => moduleIdentity(host, consumer)),
+        loaded: read.consumers.map((consumer) => consumer.id),
+      },
       encapsulated: readManifest(host, targetRoot).declaresExports,
       edges: readEdgeSides(host, targetRoot),
     },
@@ -442,8 +523,8 @@ function emitterInputOver(
  * What every emitter reads of the run the scope and the configuration describe, swept
  * under the caller's marks: the run's sweep, the facts beside it each kind family reads,
  * and the sides of the target's declared cross-language edges that name a symbol of this
- * language. The run loads no consumer, and it reads no suppression document, so the
- * self-check family has nothing to report.
+ * language. The run reads no suppression document, so the self-check family has nothing
+ * to report.
  */
 export function runEmitterInput(
   engine: Engine,
@@ -526,6 +607,7 @@ function runAnalysisInputs(
         config.ts.testFiles,
         read.projects.flatMap((one) => one.configured.testFiles),
       ),
+      consumers: read.consumers,
     },
     configured: read.projects.map((one) => one.configured),
   };
@@ -544,6 +626,8 @@ export interface RunFacts {
   readonly projects: readonly RunProject[];
   /** The rules that classified files as test files, each counted over every project at once. */
   readonly testFileRules: readonly TestFileRule[];
+  /** Every consumer the run loaded beside the target, in the scope's order. */
+  readonly consumers: readonly LoadedConsumer[];
 }
 
 /** The findings of one run, beside what a report states about the run itself. */

package/src/conformance-record.ts

@@ -3,8 +3,8 @@
 export const RECORD = {
   conformance: {
     corpusVersion: "1.9.0",
-    result: "fail",
-    digest: "sha256:8c29f19fc189f4f5d9ea210d556b62d12c3701c221eb7a8adde499b7060bec0d",
+    result: "pass",
+    digest: "sha256:3e9e40876551faa2c196311bf06d47d220ab5127a9fb8921969aae552c42e824",
   },
   gaps: [
     {
@@ -13,17 +13,5 @@ export const RECORD = {
       reason:
         "The reference pass resolves a string-literal element access to the member it names, so the member is live by that reference and the retained listing names no class for it.",
     },
-    {
-      fixture: "redundant-export-keyword",
-      capability: "DS1104",
-      reason:
-        "No consumer is loaded beside the target, so the published surface is unknown and no export is narrowed; review an export only the target uses by hand.",
-    },
-    {
-      fixture: "unused-exported-consumer",
-      capability: "DS1001",
-      reason:
-        "No consumer is loaded beside the target, so an export nothing in the target references is reported at the possible class rather than the certain one.",
-    },
   ],
 } as const;