@starci/hfs 4.0.10 → 4.1.0

package/runtime/scripts/hfs/architecture/cross-app-duplicate.mjs

@@ -17,57 +17,66 @@ export const CROSS_APP_DUPLICATE_RULE_IDS = ['FE_CROSS_APP_DUPLICATE'];
 const RULE = 'FE_CROSS_APP_DUPLICATE';
 const SOURCE = /\.[cm]?tsx?$/u;
 
-export function checkCrossAppDuplicate({ graph, context }) {
-  const ts = context.ts;
-  const { SyntaxKind } = ts;
-  const resolver = graph.resolver;
-  const declaredApps = resolver.repo.apps.map(app => app.name);
-  /** The app a file belongs to: the slot binding when a slot owns it, else the declared app whose directory holds it. */
-  const appOf = rel => resolver.classifyPath(rel).bindings?.app ?? declaredApps.find(name => rel.startsWith(`apps/${name}/`)) ?? null;
-  const onlyModuleEdges = file => file.sourceFile.statements.every(statement => ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)
-    || (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)));
+/** The app a file belongs to: the slot binding when a slot owns it, else the declared app whose directory holds it. */
+const appOf = (resolver, declaredApps, rel) => resolver.classifyPath(rel).bindings?.app ?? declaredApps.find(name => rel.startsWith(`apps/${name}/`)) ?? null;
 
-  const tokens = sourceFile => {
-    const parts = [];
-    const visit = node => {
-      if (node.kind >= SyntaxKind.FirstJSDocNode && node.kind <= SyntaxKind.LastJSDocNode) return;
-      if (node.kind === SyntaxKind.JsxText && node.containsOnlyTriviaWhiteSpaces) return;
-      const children = node.getChildren(sourceFile);
-      if (!children.length) {
-        if (node.kind !== SyntaxKind.EndOfFileToken) parts.push(node.kind === SyntaxKind.JsxText ? node.getText(sourceFile).replace(/\s+/gu, ' ').trim() : node.getText(sourceFile));
-        return;
-      }
-      for (const child of children) visit(child);
-    };
-    visit(sourceFile);
-    return parts.join('\u0000');
-  };
+const onlyModuleEdges = (ts, file) => file.sourceFile.statements.every(statement => ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)
+  || (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)));
+
+const leafText = (SyntaxKind, node, sourceFile) => (node.kind === SyntaxKind.JsxText ? node.getText(sourceFile).replace(/\s+/gu, ' ').trim() : node.getText(sourceFile));
+
+function collectTokens(SyntaxKind, sourceFile, node, parts) {
+  if (node.kind >= SyntaxKind.FirstJSDocNode && node.kind <= SyntaxKind.LastJSDocNode) return;
+  if (node.kind === SyntaxKind.JsxText && node.containsOnlyTriviaWhiteSpaces) return;
+  const children = node.getChildren(sourceFile);
+  if (!children.length) {
+    if (node.kind !== SyntaxKind.EndOfFileToken) parts.push(leafText(SyntaxKind, node, sourceFile));
+    return;
+  }
+  for (const child of children) collectTokens(SyntaxKind, sourceFile, child, parts);
+}
 
+const tokenText = (SyntaxKind, sourceFile) => {
+  const parts = [];
+  collectTokens(SyntaxKind, sourceFile, sourceFile, parts);
+  return parts.join('\u0000');
+};
+
+/** Groups the comparable files by the hash of their token text; returns the groups and the number of files compared. */
+function groupByContent(graph, ts, declaredApps) {
   const groups = new Map();
   let files = 0;
   for (const file of graph.files.values()) {
     if (!SOURCE.test(file.rel) || /\.d\.[cm]?tsx?$/u.test(file.rel)) continue;
-    const app = appOf(file.rel);
-    if (!app || onlyModuleEdges(file) || !file.sourceFile.statements.length) continue;
+    const app = appOf(graph.resolver, declaredApps, file.rel);
+    if (!app || onlyModuleEdges(ts, file) || !file.sourceFile.statements.length) continue;
     files += 1;
-    const key = createHash('sha256').update(tokens(file.sourceFile)).digest('hex');
+    const key = createHash('sha256').update(tokenText(ts.SyntaxKind, file.sourceFile)).digest('hex');
     if (!groups.has(key)) groups.set(key, []);
     groups.get(key).push({ rel: file.rel, app });
   }
+  return { groups, files };
+}
+
+const duplicateViolation = (group, item) => {
+  const twins = group.filter(other => other.app !== item.app).map(other => other.rel);
+  return {
+    ruleId: RULE, path: item.rel, line: 1, column: 1, twins,
+    message: `${item.rel} is token-for-token the same file as ${twins.join(', ')} in another app (comments and whitespace ignored); shared code is a packages/<pkg> slot. Move it to a package (packages/<pkg>) and let each app re-export it (${path.posix.basename(item.rel)} keeps only an import or export statement).`,
+  };
+};
 
+export function checkCrossAppDuplicate({ graph, context }) {
+  const ts = context.ts;
+  const declaredApps = graph.resolver.repo.apps.map(app => app.name);
+  const { groups, files } = groupByContent(graph, ts, declaredApps);
   const violations = [];
   let duplicated = 0;
   for (const group of groups.values()) {
     if (new Set(group.map(item => item.app)).size < 2) continue;
     duplicated += 1;
     group.sort((a, b) => a.rel.localeCompare(b.rel));
-    for (const item of group) {
-      const twins = group.filter(other => other.app !== item.app).map(other => other.rel);
-      violations.push({
-        ruleId: RULE, path: item.rel, line: 1, column: 1, twins,
-        message: `${item.rel} is token-for-token the same file as ${twins.join(', ')} in another app (comments and whitespace ignored); shared code is a packages/<pkg> slot. Move it to a package (packages/<pkg>) and let each app re-export it (${path.posix.basename(item.rel)} keeps only an import or export statement).`,
-      });
-    }
+    for (const item of group) violations.push(duplicateViolation(group, item));
   }
   return { violations, coverage: { status: 'checked', files, duplicatedGroups: duplicated } };
 }

package/runtime/scripts/hfs/architecture/dead-exports.mjs

@@ -62,65 +62,104 @@ function extraEntries(graph, entry) {
   return (found.slot ? graph.resolver.slot(found.slot)?.entries ?? [] : []).map(name => `${found.root}/${name}`).filter(rel => graph.files.has(rel));
 }
 
+const importBindings = (ts, declaration) => {
+  const clause = declaration.importClause;
+  if (!clause) return { all: false, pairs: [] }; // side-effect import: uses nothing
+  const pairs = [];
+  if (clause.name) pairs.push({ imported: 'default', exported: null });
+  const named = clause.namedBindings;
+  if (named && named.kind === ts.SyntaxKind.NamespaceImport) return { all: true, pairs: [] };
+  if (named) for (const element of named.elements) pairs.push({ imported: (element.propertyName ?? element.name).text, exported: null });
+  return { all: false, pairs };
+};
+
+const exportBindings = (ts, declaration) => {
+  const clause = declaration.exportClause;
+  if (!clause || clause.kind === ts.SyntaxKind.NamespaceExport) return { all: true, pairs: [] };
+  return { all: false, pairs: clause.elements.map(element => ({ imported: (element.propertyName ?? element.name).text, exported: element.name.text })) };
+};
+
+const importTypeBindings = (ts, declaration) => {
+  let qualifier = declaration.qualifier;
+  if (!qualifier) return { all: true, pairs: [] };
+  while (qualifier.kind === ts.SyntaxKind.QualifiedName) qualifier = qualifier.left;
+  return { all: false, pairs: [{ imported: qualifier.text, exported: null }] };
+};
+
 /** Names an import/export declaration takes from its target: {all} or {pairs: [{imported, exported}]}. */
 function bindingsOf(ts, declaration) {
-  const kind = ts.SyntaxKind;
   if (!declaration) return { all: true, pairs: [] };
-  if (declaration.kind === kind.ImportDeclaration) {
-    const clause = declaration.importClause;
-    if (!clause) return { all: false, pairs: [] }; // side-effect import: uses nothing
-    const pairs = [];
-    if (clause.name) pairs.push({ imported: 'default', exported: null });
-    const named = clause.namedBindings;
-    if (named && named.kind === kind.NamespaceImport) return { all: true, pairs: [] };
-    if (named) for (const element of named.elements) pairs.push({ imported: (element.propertyName ?? element.name).text, exported: null });
-    return { all: false, pairs };
-  }
-  if (declaration.kind === kind.ExportDeclaration) {
-    const clause = declaration.exportClause;
-    if (!clause || clause.kind === kind.NamespaceExport) return { all: true, pairs: [] };
-    return { all: false, pairs: clause.elements.map(element => ({ imported: (element.propertyName ?? element.name).text, exported: element.name.text })) };
-  }
-  if (declaration.kind === kind.ImportTypeNode) {
-    let qualifier = declaration.qualifier;
-    if (!qualifier) return { all: true, pairs: [] };
-    while (qualifier.kind === kind.QualifiedName) qualifier = qualifier.left;
-    return { all: false, pairs: [{ imported: qualifier.text, exported: null }] };
-  }
+  if (declaration.kind === ts.SyntaxKind.ImportDeclaration) return importBindings(ts, declaration);
+  if (declaration.kind === ts.SyntaxKind.ExportDeclaration) return exportBindings(ts, declaration);
+  if (declaration.kind === ts.SyntaxKind.ImportTypeNode) return importTypeBindings(ts, declaration);
   // ImportEqualsDeclaration, dynamic import(), require(): the whole module is taken.
   return { all: true, pairs: [] };
 }
 
+const addExportName = (found, sourceFile, name, node) => {
+  if (found.has(name)) return;
+  found.set(name, sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1);
+};
+
+const addBindingNames = (ts, found, sourceFile, name, node) => {
+  if (name.kind === ts.SyntaxKind.Identifier) addExportName(found, sourceFile, name.text, node);
+  else for (const element of name.elements) if (element.kind === ts.SyntaxKind.BindingElement) addBindingNames(ts, found, sourceFile, element.name, node);
+};
+
+const addExportDeclarationNames = (ts, statement, add) => {
+  if (statement.exportClause?.kind === ts.SyntaxKind.NamedExports) {
+    for (const element of statement.exportClause.elements) add(element.name.text, element);
+  } else if (statement.exportClause?.kind === ts.SyntaxKind.NamespaceExport) add(statement.exportClause.name.text, statement);
+};
+
+const addStatementNames = (ts, found, sourceFile, statement) => {
+  const kind = ts.SyntaxKind;
+  const add = (name, node) => addExportName(found, sourceFile, name, node);
+  if (statement.kind === kind.ExportDeclaration) return addExportDeclarationNames(ts, statement, add);
+  if (statement.kind === kind.ExportAssignment) return add('default', statement);
+  const modifiers = statement.modifiers ?? [];
+  if (!modifiers.some(modifier => modifier.kind === kind.ExportKeyword)) return undefined;
+  if (modifiers.some(modifier => modifier.kind === kind.DefaultKeyword)) return add('default', statement);
+  if (statement.kind === kind.VariableStatement) {
+    for (const declaration of statement.declarationList.declarations) addBindingNames(ts, found, sourceFile, declaration.name, declaration);
+    return undefined;
+  }
+  return statement.name && statement.name.kind === kind.Identifier ? add(statement.name.text, statement) : undefined;
+};
+
 /** The exported names of an entry source file, each with the line of its declaration. */
 export function exportedNames(ts, sourceFile) {
-  const kind = ts.SyntaxKind;
   const found = new Map();
-  const add = (name, node) => {
-    if (found.has(name)) return;
-    found.set(name, sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1);
-  };
-  const bindingNames = (name, node) => {
-    if (name.kind === kind.Identifier) add(name.text, node);
-    else for (const element of name.elements) if (element.kind === kind.BindingElement) bindingNames(element.name, node);
-  };
-  for (const statement of sourceFile.statements) {
-    if (statement.kind === kind.ExportDeclaration) {
-      if (statement.exportClause?.kind === kind.NamedExports) for (const element of statement.exportClause.elements) add(element.name.text, element);
-      else if (statement.exportClause?.kind === kind.NamespaceExport) add(statement.exportClause.name.text, statement);
-      continue;
-    }
-    if (statement.kind === kind.ExportAssignment) { add('default', statement); continue; }
-    const modifiers = statement.modifiers ?? [];
-    if (!modifiers.some(modifier => modifier.kind === kind.ExportKeyword)) continue;
-    if (modifiers.some(modifier => modifier.kind === kind.DefaultKeyword)) { add('default', statement); continue; }
-    if (statement.kind === kind.VariableStatement) for (const declaration of statement.declarationList.declarations) bindingNames(declaration.name, declaration);
-    else if (statement.name && statement.name.kind === kind.Identifier) add(statement.name.text, statement);
-  }
+  for (const statement of sourceFile.statements) addStatementNames(ts, found, sourceFile, statement);
   return found;
 }
 
 const withoutSlash = value => value.replace(/\/$/, '');
 
+const addConfigTextRoots = (graph, directory, text, roots) => {
+  for (const match of text.matchAll(CONFIG_STRING)) {
+    const target = path.posix.join(directory, match[1]);
+    const hit = CONFIG_EXTENSIONS.map(extension => `${target}${extension}`).find(candidate => graph.files.has(candidate));
+    if (hit) roots.add(hit);
+  }
+};
+
+const addAppConfigRoots = (graph, config, app, roots) => {
+  const directory = `apps/${app.name}`;
+  let names = [];
+  try { names = fs.readdirSync(path.join(config.root, ...directory.split('/'))); } catch { return; }
+  for (const name of names) {
+    if (graph.resolver.classifyPath(`${directory}/${name}`).slot !== 'fe.app.next' || !/\.[cm]?[jt]sx?$/.test(name)) continue;
+    let text = '';
+    try { text = fs.readFileSync(path.join(config.root, ...directory.split('/'), name), 'utf8'); } catch { continue; }
+    addConfigTextRoots(graph, directory, text, roots);
+  }
+};
+
+const addFrameworkConfigRoots = (graph, config, roots) => {
+  for (const app of config.apps ?? []) addAppConfigRoots(graph, config, app, roots);
+};
+
 /** The files the graph serves from: what an app slot requires, every route file, every package entry, every config-named file. */
 function rootFiles(graph, config) {
   const roots = new Set();
@@ -129,7 +168,7 @@ function rootFiles(graph, config) {
     if (!node.owner || node.tier !== 'app') continue;
     const slot = graph.resolver.slot(node.owner.slot);
     const inside = rel.slice(withoutSlash(node.owner.root).length + 1);
-    if ((slot?.requires ?? []).some(name => name === inside)) roots.add(rel);
+    if ((slot?.requires ?? []).includes(inside)) roots.add(rel);
   }
   for (const [key, owner] of graph.ownerRoots) {
     if (owner.tier !== 'package') continue;
@@ -137,49 +176,29 @@ function rootFiles(graph, config) {
     if (entry) roots.add(entry);
   }
   // A framework config of an app (slot fe.app.next) names sources by string, never by import.
-  for (const app of config.apps ?? []) {
-    const directory = `apps/${app.name}`;
-    let names = [];
-    try { names = fs.readdirSync(path.join(config.root, ...directory.split('/'))); } catch { continue; }
-    for (const name of names) {
-      if (graph.resolver.classifyPath(`${directory}/${name}`).slot !== 'fe.app.next' || !/\.[cm]?[jt]sx?$/.test(name)) continue;
-      let text = '';
-      try { text = fs.readFileSync(path.join(config.root, ...directory.split('/'), name), 'utf8'); } catch { continue; }
-      for (const match of text.matchAll(CONFIG_STRING)) {
-        const target = path.posix.join(directory, match[1]);
-        const hit = CONFIG_EXTENSIONS.map(extension => `${target}${extension}`).find(candidate => graph.files.has(candidate));
-        if (hit) roots.add(hit);
-      }
-    }
-  }
+  addFrameworkConfigRoots(graph, config, roots);
   return roots;
 }
 
+const unusedFileViolation = (rel, node) => ({
+  ruleId: 'HFS_UNUSED_FILE',
+  path: rel, line: 1, column: 1,
+  slot: node.slot, owner: node.owner?.root ?? null,
+  message: `${rel} is not reached from any root (an app main.ts or app.module.ts, a route file, a package entry): nothing imports it, so no process runs it. Delete the file, or import it where it is used (a spec alone does not count).`,
+});
+
 /** HFS_UNUSED_FILE: production files no root reaches through runtime or type-only imports and re-exports. */
 function deadFiles(graph, config) {
   const roots = rootFiles(graph, config);
-  const forward = new Map();
-  for (const edge of graph.edges) {
-    if (!forward.has(edge.from)) forward.set(edge.from, []);
-    forward.get(edge.from).push(edge.to);
-  }
+  const forward = Map.groupBy(graph.edges, edge => edge.from);
   const reached = new Set(roots);
   const queue = [...roots];
-  while (queue.length) for (const next of forward.get(queue.shift()) ?? []) if (!reached.has(next)) { reached.add(next); queue.push(next); }
-  const violations = [];
-  let judged = 0;
-  for (const [rel, node] of [...graph.files].sort(([a], [b]) => a.localeCompare(b))) {
-    if (node.tier === null || UNJUDGED_TIERS.has(node.tier) || node.tier === 'route') continue;
-    judged += 1;
-    if (reached.has(rel)) continue;
-    violations.push({
-      ruleId: 'HFS_UNUSED_FILE',
-      path: rel, line: 1, column: 1,
-      slot: node.slot, owner: node.owner?.root ?? null,
-      message: `${rel} is not reached from any root (an app main.ts or app.module.ts, a route file, a package entry): nothing imports it, so no process runs it. Delete the file, or import it where it is used (a spec alone does not count).`,
-    });
-  }
-  return { violations, judged, roots: roots.size };
+  while (queue.length) for (const { to } of forward.get(queue.shift()) ?? []) if (!reached.has(to)) { reached.add(to); queue.push(to); }
+  const judgedFiles = [...graph.files]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .filter(([, node]) => !(node.tier === null || UNJUDGED_TIERS.has(node.tier) || node.tier === 'route'));
+  const violations = judgedFiles.filter(([rel]) => !reached.has(rel)).map(([rel, node]) => unusedFileViolation(rel, node));
+  return { violations, judged: judgedFiles.length, roots: roots.size };
 }
 
 /** The unit spec of a webhook, gateway or subscription door: a door has no service of its own, so its spec is the only unit spec of its kind. */
@@ -214,75 +233,113 @@ function inIntegrationOf(graph, to, provider) {
   return owner?.slot === INTEGRATION_SLOT && owner.bindings?.provider === provider;
 }
 
+/** The pseudo edges of one test consumer file: its import/export declarations that resolve to graph files it may reach. */
+function consumerFileEdges({ ts, options, graph, config }, rel, provider) {
+  const abs = path.join(config.root, ...rel.split('/'));
+  let text;
+  try { text = fs.readFileSync(abs, 'utf8'); } catch { return []; }
+  const sourceFile = ts.createSourceFile(abs, text, ts.ScriptTarget.Latest, true);
+  const edges = [];
+  for (const statement of sourceFile.statements) {
+    if (!(ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)) || !statement.moduleSpecifier || !ts.isStringLiteralLike(statement.moduleSpecifier)) continue;
+    const resolved = ts.resolveModuleName(statement.moduleSpecifier.text, abs, options, ts.sys).resolvedModule?.resolvedFileName;
+    const to = resolved ? graph.abs(canonical(resolved)) : null;
+    if (to && (provider === null || inIntegrationOf(graph, to, provider))) edges.push({ from: rel, to, edge: { declaration: statement }, reexport: false });
+  }
+  return edges;
+}
+
 /**
  * Pseudo edges (read from disk, outside the production program) to graph files: from the unit role specs, the fixture builders and
  * the test world files to anything, and from an integration spec only to the integration of its own provider folder.
  */
 function testConsumerEdges({ context, graph, config }) {
-  const { ts } = context;
-  const options = context.projects?.[0]?.options ?? {};
-  const edges = [];
+  const resolution = { ts: context.ts, options: context.projects?.[0]?.options ?? {}, graph, config };
   const consumers = [...treeOf(config.root).files]
     .map(file => ({ file, any: testConsumer(graph, file) }))
     .map(({ file, any }) => ({ file, provider: any ? null : integrationSpecProvider(graph, file), any }))
     .filter(({ any, provider }) => any || provider !== null)
     .sort((a, b) => a.file.localeCompare(b.file));
-  for (const { file: rel, provider } of consumers) {
-    const abs = path.join(config.root, ...rel.split('/'));
-    let text;
-    try { text = fs.readFileSync(abs, 'utf8'); } catch { continue; }
-    const sourceFile = ts.createSourceFile(abs, text, ts.ScriptTarget.Latest, true);
-    for (const statement of sourceFile.statements) {
-      if (!(ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)) || !statement.moduleSpecifier || !ts.isStringLiteralLike(statement.moduleSpecifier)) continue;
-      const resolved = ts.resolveModuleName(statement.moduleSpecifier.text, abs, options, ts.sys).resolvedModule?.resolvedFileName;
-      const to = resolved ? graph.abs(canonical(resolved)) : null;
-      if (to && (provider === null || inIntegrationOf(graph, to, provider))) edges.push({ from: rel, to, edge: { declaration: statement }, reexport: false });
-    }
-  }
-  return edges;
+  return consumers.flatMap(({ file: rel, provider }) => consumerFileEdges(resolution, rel, provider));
 }
 
-export function checkDeadExports({ context, graph, config }) {
-  const { ts } = context;
-  const violations = [];
+const edgeIndex = edges => {
   const edgesTo = new Map();
-  const unitOf = rel => {
-    const known = graph.unit(rel);
-    if (known) return known;
-    const classified = graph.resolver.classifyPath(rel);
-    const owner = classified.slot ? graph.resolver.ownerOf(rel) : null;
-    return owner ? `${owner.slot}:${owner.root}` : null;
-  };
-  for (const edge of [...graph.edges, ...testConsumerEdges({ context, graph, config })]) {
+  for (const edge of edges) {
     if (!edgesTo.has(edge.to)) edgesTo.set(edge.to, []);
     edgesTo.get(edge.to).push(edge);
   }
+  return edgesTo;
+};
 
-  /** What the importers of `file` take from it; edges from inside `ownerKey` are skipped when given. */
-  const consumed = (file, ownerKey, depth, visiting) => {
-    const result = { all: false, names: new Set() };
-    for (const edge of edgesTo.get(file) ?? []) {
-      if (ownerKey && unitOf(edge.from) === ownerKey) continue;
-      const bindings = bindingsOf(ts, edge.edge.declaration);
-      if (bindings.all) { result.all = true; continue; }
-      for (const pair of bindings.pairs) {
-        if (pair.exported === null) { result.names.add(pair.imported); continue; }
-        // A re-export by name: the name is used when the re-exporting file's own export is used further on.
-        const reexporter = edge.from;
-        if (visiting.has(reexporter) || depth >= CHAIN_DEPTH) { result.names.add(pair.imported); continue; }
-        if (!(edgesTo.get(reexporter)?.length)) {
-          // nobody imports the re-exporting file: a framework entry (route file) uses it, an unused owner entry does not
-          const holder = graph.files.get(reexporter);
-          if (!holder?.owner || graph.resolver.slot(holder.owner.slot)?.tier === 'app') result.names.add(pair.imported);
-          continue;
-        }
-        const next = consumed(reexporter, null, depth + 1, new Set([...visiting, reexporter]));
-        if (next.all || next.names.has(pair.exported)) result.names.add(pair.imported);
-      }
-    }
-    return result;
-  };
+const unitOfFile = (graph, rel) => {
+  const known = graph.unit(rel);
+  if (known) return known;
+  const classified = graph.resolver.classifyPath(rel);
+  const owner = classified.slot ? graph.resolver.ownerOf(rel) : null;
+  return owner ? `${owner.slot}:${owner.root}` : null;
+};
+
+const consumeReexportedName = (context, result, edge, pair, depth, visiting) => {
+  if (pair.exported === null) { result.names.add(pair.imported); return; }
+  // A re-export by name: the name is used when the re-exporting file's own export is used further on.
+  const reexporter = edge.from;
+  if (visiting.has(reexporter) || depth >= CHAIN_DEPTH) { result.names.add(pair.imported); return; }
+  if (!(context.edgesTo.get(reexporter)?.length)) {
+    // nobody imports the re-exporting file: a framework entry (route file) uses it, an unused owner entry does not
+    const holder = context.graph.files.get(reexporter);
+    if (!holder?.owner || context.graph.resolver.slot(holder.owner.slot)?.tier === 'app') result.names.add(pair.imported);
+    return;
+  }
+  const next = consumedNames(context, reexporter, null, depth + 1, new Set([...visiting, reexporter]));
+  if (next.all || next.names.has(pair.exported)) result.names.add(pair.imported);
+};
 
+/** What the importers of `file` take from it; edges from inside `ownerKey` are skipped when given. */
+const consumedNames = (context, file, ownerKey, depth, visiting) => {
+  const result = { all: false, names: new Set() };
+  for (const edge of context.edgesTo.get(file) ?? []) {
+    if (ownerKey && unitOfFile(context.graph, edge.from) === ownerKey) continue;
+    const bindings = bindingsOf(context.ts, edge.edge.declaration);
+    if (bindings.all) { result.all = true; continue; }
+    for (const pair of bindings.pairs) consumeReexportedName(context, result, edge, pair, depth, visiting);
+  }
+  return result;
+};
+
+/** Adds to `used` the entry exports reached by a consumer outside the owner that imports a file the entry re-exports by name. */
+const addReexportedUses = (context, key, publicEntry, used) => {
+  const { ts, graph } = context;
+  for (const edge of graph.edges) {
+    if (edge.from !== publicEntry || !edge.reexport || graph.unit(edge.to) !== key) continue;
+    const reexport = bindingsOf(ts, edge.edge.declaration);
+    const inner = consumedNames(context, edge.to, key, 0, new Set([publicEntry, edge.to]));
+    if (reexport.all) continue;
+    for (const pair of reexport.pairs) if (inner.all || inner.names.has(pair.imported)) used.names.add(pair.exported);
+  }
+};
+
+const unusedExportViolation = (publicEntry, name, line, owner) => ({
+  ruleId: 'HFS_UNUSED_EXPORT',
+  path: publicEntry, line, column: 1,
+  name, owner: owner.root, slot: owner.slot,
+  message: `${publicEntry} exports ${name}, but no production file outside ${owner.root || 'the repository root'} imports it; remove the export (only a unit role spec, a fixture builder, a test world file, or an integration spec of this integration's own provider folder counts besides production files).`,
+});
+
+/** The unused-export violations and the export count of one public entry of an owner. */
+const publicEntryExports = (context, key, owner, publicEntry) => {
+  const names = exportedNames(context.ts, context.graph.files.get(publicEntry).sourceFile);
+  const used = consumedNames(context, publicEntry, key, 0, new Set([publicEntry]));
+  addReexportedUses(context, key, publicEntry, used);
+  const violations = [...names]
+    .filter(([name]) => !(used.all || used.names.has(name)))
+    .map(([name, line]) => unusedExportViolation(publicEntry, name, line, owner));
+  return { violations, exports: names.size };
+};
+
+const ownerExportFindings = (context, config) => {
+  const { graph } = context;
+  const violations = [];
   let owners = 0;
   let exports = 0;
   for (const [key, owner] of graph.ownerRoots) {
@@ -291,30 +348,20 @@ export function checkDeadExports({ context, graph, config }) {
     if (!entry) continue;
     owners += 1;
     for (const publicEntry of [entry, ...extraEntries(graph, entry)]) {
-      const names = exportedNames(ts, graph.files.get(publicEntry).sourceFile);
-      const used = consumed(publicEntry, key, 0, new Set([publicEntry]));
-      // A consumer outside the owner that imports a file the entry re-exports by name reaches the entry's export of that name.
-      for (const edge of graph.edges) {
-        if (edge.from !== publicEntry || !edge.reexport || graph.unit(edge.to) !== key) continue;
-        const reexport = bindingsOf(ts, edge.edge.declaration);
-        const inner = consumed(edge.to, key, 0, new Set([publicEntry, edge.to]));
-        if (reexport.all) continue;
-        for (const pair of reexport.pairs) if (inner.all || inner.names.has(pair.imported)) used.names.add(pair.exported);
-      }
-      for (const [name, line] of names) {
-        exports += 1;
-        if (used.all || used.names.has(name)) continue;
-        violations.push({
-          ruleId: 'HFS_UNUSED_EXPORT',
-          path: publicEntry, line, column: 1,
-          name, owner: owner.root, slot: owner.slot,
-          message: `${publicEntry} exports ${name}, but no production file outside ${owner.root || 'the repository root'} imports it; remove the export (only a unit role spec, a fixture builder, a test world file, or an integration spec of this integration's own provider folder counts besides production files).`,
-        });
-      }
+      const found = publicEntryExports(context, key, owner, publicEntry);
+      exports += found.exports;
+      violations.push(...found.violations);
     }
   }
+  return { violations, owners, exports };
+};
+
+export function checkDeadExports({ context, graph, config }) {
+  const edgesTo = edgeIndex([...graph.edges, ...testConsumerEdges({ context, graph, config })]);
+  const analysis = { ...context, graph, edgesTo };
+  const exports = ownerExportFindings(analysis, config);
   const files = deadFiles(graph, config);
-  const deadExports = violations.length;
-  violations.push(...files.violations);
-  return { violations, coverage: { status: 'checked', owners, exports, dead: deadExports, files: files.judged, roots: files.roots, unusedFiles: files.violations.length } };
+  const dead = exports.violations.length;
+  exports.violations.push(...files.violations);
+  return { violations: exports.violations, coverage: { status: 'checked', owners: exports.owners, exports: exports.exports, dead, files: files.judged, roots: files.roots, unusedFiles: files.violations.length } };
 }