@starci/hfs 4.11.22 → 4.12.0

package/runtime/scripts/hfs/architecture/cross-app-duplicate.d.mts

@@ -0,0 +1,27 @@
+import type { TypeScriptApi } from './config.mjs';
+import type { ArchitectureViolation, HfsGraph } from './hfs-graph.mjs';
+/**
+ * R21 `cross-app-duplicate` (FE_CROSS_APP_DUPLICATE): the slot manifest's `crossApp` law says apps never import each other and
+ * shared code is a `packages/<pkg>` slot. `HFS_DUPLICATE_CODE` sees blocks of a size inside the owner graph; this sees whole
+ * files of any size, route-tree files included: two TypeScript files under different apps whose token-normalised content is
+ * equal (comments and whitespace do not exist in the token sequence; identifiers and literals are kept) are one file copied
+ * instead of moved to a package.
+ *
+ * Exempt: a file made only of import and export statements. It is the sanctioned shape of a Next route file that must exist
+ * per app and re-exports one package symbol (`export { default } from "@family/ui/global-error"`), and it holds nothing to move.
+ * Not source, so not judged: declaration files and everything that is not .ts/.tsx (JSON catalogs, CSS).
+ */
+export declare const CROSS_APP_DUPLICATE_RULE_IDS: string[];
+export declare function checkCrossAppDuplicate({ graph, context }: {
+    graph: HfsGraph;
+    context: {
+        ts: TypeScriptApi;
+    };
+}): {
+    violations: ArchitectureViolation[];
+    coverage: {
+        status: string;
+        files: number;
+        duplicatedGroups: number;
+    };
+};

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

@@ -1,6 +1,5 @@
 import { createHash } from 'node:crypto';
 import path from 'node:path';
-
 /**
  * R21 `cross-app-duplicate` (FE_CROSS_APP_DUPLICATE): the slot manifest's `crossApp` law says apps never import each other and
  * shared code is a `packages/<pkg>` slot. `HFS_DUPLICATE_CODE` sees blocks of a size inside the owner graph; this sees whole
@@ -13,70 +12,70 @@ import path from 'node:path';
  * Not source, so not judged: declaration files and everything that is not .ts/.tsx (JSON catalogs, CSS).
  */
 export const CROSS_APP_DUPLICATE_RULE_IDS = ['FE_CROSS_APP_DUPLICATE'];
-
 const RULE = 'FE_CROSS_APP_DUPLICATE';
 const SOURCE = /\.[cm]?tsx?$/u;
-
 /** 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 onlyModuleEdges = (ts, file) => file.sourceFile.statements.every(statement => ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement)
-  || (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)));
-
+    || (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);
+    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');
+    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(graph.resolver, declaredApps, file.rel);
-    if (!app || onlyModuleEdges(ts, file) || !file.sourceFile.statements.length) continue;
-    files += 1;
-    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 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(graph.resolver, declaredApps, file.rel);
+        if (!app || onlyModuleEdges(ts, file) || !file.sourceFile.statements.length)
+            continue;
+        files += 1;
+        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).`,
-  };
+    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) violations.push(duplicateViolation(group, item));
-  }
-  return { violations, coverage: { status: 'checked', files, duplicatedGroups: duplicated } };
+    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)
+            violations.push(duplicateViolation(group, item));
+    }
+    return { violations, coverage: { status: 'checked', files, duplicatedGroups: duplicated } };
 }

package/runtime/scripts/hfs/architecture/dead-exports-bindings.d.mts

@@ -0,0 +1,21 @@
+import type { NamespaceImport, Node, SourceFile, TypeChecker } from 'typescript';
+import type { TypeScriptApi } from './config.mjs';
+/** One name an import/export takes from its target (`exported` is set for a re-export under another name). */
+export interface BindingPair {
+    imported: string;
+    exported: string | null;
+}
+/** Names an import/export declaration takes from its target: everything, or the listed pairs. */
+export interface Bindings {
+    all: boolean;
+    pairs: BindingPair[];
+}
+/** The part of the dead-export analysis context the binding analysis reads and caches into. */
+export interface BindingsContext {
+    ts: TypeScriptApi;
+    checkerFor?: (fileName: string) => TypeChecker;
+    namespaceCheckers: WeakMap<SourceFile, TypeChecker>;
+    namespaceUses: WeakMap<NamespaceImport, Bindings>;
+}
+/** Names an import/export declaration takes from its target: {all} or {pairs: [{imported, exported}]}. */
+export declare function bindingsOf(context: BindingsContext, declaration: Node | null | undefined): Bindings;

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

@@ -1,149 +1,173 @@
 // Import and namespace consumption analysis shared by dead-export edges.
 import path from 'node:path';
-
 /** Disk/staged test consumers have no production checker; bind their local names without resolving dependencies. */
 const namespaceChecker = (context, sourceFile, namespace) => {
-  if (context.namespaceCheckers.has(sourceFile)) return context.namespaceCheckers.get(sourceFile);
-  const { ts } = context;
-  let checker = context.checkerFor?.(sourceFile.fileName);
-  if (!checker?.getSymbolAtLocation(namespace.name)) {
-    const options = { noResolve: true, noLib: true, types: [], allowJs: true, target: ts.ScriptTarget.Latest };
-    const host = ts.createCompilerHost(options);
-    const filename = path.resolve(sourceFile.fileName);
-    host.getSourceFile = file => path.resolve(file) === filename ? sourceFile : undefined;
-    host.fileExists = file => path.resolve(file) === filename;
-    host.readFile = file => path.resolve(file) === filename ? sourceFile.text : undefined;
-    checker = ts.createProgram([filename], options, host).getTypeChecker();
-  }
-  context.namespaceCheckers.set(sourceFile, checker);
-  return checker;
+    const cached = context.namespaceCheckers.get(sourceFile);
+    if (cached)
+        return cached;
+    const { ts } = context;
+    let checker = context.checkerFor?.(sourceFile.fileName);
+    if (!checker?.getSymbolAtLocation(namespace.name)) {
+        const options = { noResolve: true, noLib: true, types: [], allowJs: true, target: ts.ScriptTarget.Latest };
+        const host = ts.createCompilerHost(options);
+        const filename = path.resolve(sourceFile.fileName);
+        host.getSourceFile = file => path.resolve(file) === filename ? sourceFile : undefined;
+        host.fileExists = file => path.resolve(file) === filename;
+        host.readFile = file => path.resolve(file) === filename ? sourceFile.text : undefined;
+        checker = ts.createProgram([filename], options, host).getTypeChecker();
+    }
+    context.namespaceCheckers.set(sourceFile, checker);
+    return checker;
 };
-
-const transparentExpression = (ts, node) => node && (ts.isParenthesizedExpression(node) || ts.isAsExpression(node)
-  || ts.isTypeAssertionExpression(node) || ts.isNonNullExpression(node) || ts.isSatisfiesExpression(node));
-
-const literalMember = (ts, node) => {
-  while (transparentExpression(ts, node)) node = node.expression;
-  return node && (ts.isStringLiteralLike(node) || ts.isNumericLiteral(node)) ? node.text : null;
+const transparentExpression = (ts, node) => !!node && (ts.isParenthesizedExpression(node) || ts.isAsExpression(node)
+    || ts.isTypeAssertionExpression(node) || ts.isNonNullExpression(node) || ts.isSatisfiesExpression(node));
+const literalMember = (ts, input) => {
+    let node = input;
+    while (transparentExpression(ts, node))
+        node = node.expression;
+    return node && (ts.isStringLiteralLike(node) || ts.isNumericLiteral(node)) ? node.text : null;
 };
-
 const destructuredMember = (ts, name) => {
-  if (ts.isIdentifier(name)) return name.text;
-  if (ts.isComputedPropertyName(name)) return literalMember(ts, name.expression);
-  return literalMember(ts, name);
+    if (ts.isIdentifier(name))
+        return name.text;
+    if (ts.isComputedPropertyName(name))
+        return literalMember(ts, name.expression);
+    return literalMember(ts, name);
 };
-
 /** A destructuring alias consumes the property's name, while a rest/computed binding may consume every export. */
 const destructuredBindings = (ts, pattern) => {
-  const names = [];
-  const elements = ts.isObjectBindingPattern(pattern) ? pattern.elements : pattern.properties;
-  for (const element of elements) {
-    if (element.dotDotDotToken || ts.isSpreadAssignment(element)) return { all: true, pairs: [] };
-    const name = destructuredMember(ts, element.propertyName ?? element.name);
-    if (name === null) return { all: true, pairs: [] };
-    names.push(name);
-  }
-  return { all: false, pairs: names.map(imported => ({ imported, exported: null })) };
+    const names = [];
+    const elements = ts.isObjectBindingPattern(pattern) ? pattern.elements : pattern.properties;
+    for (const element of elements) {
+        if (ts.isSpreadAssignment(element) || (ts.isBindingElement(element) && element.dotDotDotToken))
+            return { all: true, pairs: [] };
+        const name = destructuredMember(ts, ts.isBindingElement(element) ? element.propertyName ?? element.name : element.name);
+        if (name === null)
+            return { all: true, pairs: [] };
+        names.push(name);
+    }
+    return { all: false, pairs: names.map(imported => ({ imported, exported: null })) };
 };
-
 const namespaceReference = (ts, checker, symbol, node) => {
-  if (checker.getSymbolAtLocation(node) === symbol) return true;
-  const parent = node.parent;
-  if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) return checker.getShorthandAssignmentValueSymbol(parent) === symbol;
-  return ts.isExportSpecifier(parent) && node === (parent.propertyName ?? parent.name)
-    && checker.getExportSpecifierLocalTargetSymbol(parent) === symbol;
+    if (checker.getSymbolAtLocation(node) === symbol)
+        return true;
+    const parent = node.parent;
+    if (ts.isShorthandPropertyAssignment(parent) && parent.name === node)
+        return checker.getShorthandAssignmentValueSymbol(parent) === symbol;
+    return ts.isExportSpecifier(parent) && node === (parent.propertyName ?? parent.name)
+        && checker.getExportSpecifierLocalTargetSymbol(parent) === symbol;
 };
-
-const unwrappedNamespace = (ts, node) => {
-  while (transparentExpression(ts, node.parent)) node = node.parent;
-  return node;
+const unwrappedNamespace = (ts, input) => {
+    let node = input;
+    while (transparentExpression(ts, node.parent))
+        node = node.parent;
+    return node;
 };
-
 const indexedNamespaceMember = (ts, node) => {
-  if (!ts.isTypeQueryNode(node.parent) || node.parent.exprName !== node) return null;
-  let query = node.parent;
-  while (ts.isParenthesizedTypeNode(query.parent)) query = query.parent;
-  const indexed = query.parent;
-  return ts.isIndexedAccessTypeNode(indexed) && indexed.objectType === query && ts.isLiteralTypeNode(indexed.indexType)
-    ? literalMember(ts, indexed.indexType.literal) : null;
+    if (!ts.isTypeQueryNode(node.parent) || node.parent.exprName !== node)
+        return null;
+    let query = node.parent;
+    while (ts.isParenthesizedTypeNode(query.parent))
+        query = query.parent;
+    const indexed = query.parent;
+    return ts.isIndexedAccessTypeNode(indexed) && indexed.objectType === query && ts.isLiteralTypeNode(indexed.indexType)
+        ? literalMember(ts, indexed.indexType.literal) : null;
 };
-
 /** The first member is the entry export even in a chain such as namespace.Enum.Member or namespace.Type.Inner. */
 const namespaceUse = (ts, reference) => {
-  const node = unwrappedNamespace(ts, reference);
-  const parent = node.parent;
-  let name = null;
-  if (ts.isPropertyAccessExpression(parent) && parent.expression === node) name = parent.name.text;
-  else if (ts.isQualifiedName(parent) && parent.left === node) name = parent.right.text;
-  else if (ts.isElementAccessExpression(parent) && parent.expression === node) name = literalMember(ts, parent.argumentExpression);
-  else if (ts.isVariableDeclaration(parent) && parent.initializer === node && ts.isObjectBindingPattern(parent.name)) return destructuredBindings(ts, parent.name);
-  else if (ts.isBinaryExpression(parent) && parent.right === node && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken
-    && ts.isObjectLiteralExpression(parent.left)) return destructuredBindings(ts, parent.left);
-  else name = indexedNamespaceMember(ts, node);
-  return name === null ? { all: true, pairs: [] } : { all: false, pairs: [{ imported: name, exported: null }] };
+    const node = unwrappedNamespace(ts, reference);
+    const parent = node.parent;
+    let name = null;
+    if (ts.isPropertyAccessExpression(parent) && parent.expression === node)
+        name = parent.name.text;
+    else if (ts.isQualifiedName(parent) && parent.left === node)
+        name = parent.right.text;
+    else if (ts.isElementAccessExpression(parent) && parent.expression === node)
+        name = literalMember(ts, parent.argumentExpression);
+    else if (ts.isVariableDeclaration(parent) && parent.initializer === node && ts.isObjectBindingPattern(parent.name))
+        return destructuredBindings(ts, parent.name);
+    else if (ts.isBinaryExpression(parent) && parent.right === node && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken
+        && ts.isObjectLiteralExpression(parent.left))
+        return destructuredBindings(ts, parent.left);
+    else
+        name = indexedNamespaceMember(ts, node);
+    return name === null ? { all: true, pairs: [] } : { all: false, pairs: [{ imported: name, exported: null }] };
 };
-
 const namespaceBindings = (context, declaration, namespace) => {
-  if (context.namespaceUses.has(namespace)) return context.namespaceUses.get(namespace);
-  const { ts } = context;
-  const sourceFile = declaration.getSourceFile();
-  const checker = namespaceChecker(context, sourceFile, namespace);
-  const symbol = checker.getSymbolAtLocation(namespace.name);
-  const result = { all: false, pairs: [] };
-  const visit = node => {
-    if (ts.isJSDocSeeTag(node) || ts.isJSDocLink(node) || ts.isJSDocLinkCode(node) || ts.isJSDocLinkPlain(node)) return;
-    if (ts.isIdentifier(node) && node !== namespace.name && namespaceReference(ts, checker, symbol, node)) {
-      const used = namespaceUse(ts, node);
-      result.all ||= used.all;
-      result.pairs.push(...used.pairs);
-    }
-    if (!result.all) {
-      ts.forEachChild(node, visit);
-      for (const doc of node.jsDoc ?? []) visit(doc);
-    }
-  };
-  // An unavailable binding must never turn an unknown consumer into a false unused-export finding.
-  if (symbol) visit(sourceFile);
-  else result.all = true;
-  context.namespaceUses.set(namespace, result);
-  return result;
+    const cached = context.namespaceUses.get(namespace);
+    if (cached)
+        return cached;
+    const { ts } = context;
+    const sourceFile = declaration.getSourceFile();
+    const checker = namespaceChecker(context, sourceFile, namespace);
+    const symbol = checker.getSymbolAtLocation(namespace.name);
+    const result = { all: false, pairs: [] };
+    const visit = (node) => {
+        if (ts.isJSDocSeeTag(node) || ts.isJSDocLink(node) || ts.isJSDocLinkCode(node) || ts.isJSDocLinkPlain(node))
+            return;
+        if (ts.isIdentifier(node) && node !== namespace.name && namespaceReference(ts, checker, symbol, node)) {
+            const used = namespaceUse(ts, node);
+            result.all ||= used.all;
+            result.pairs.push(...used.pairs);
+        }
+        if (!result.all) {
+            ts.forEachChild(node, visit);
+            // `jsDoc` is a compiler-internal field of the nodes that carry documentation comments.
+            for (const doc of node.jsDoc ?? [])
+                visit(doc);
+        }
+    };
+    // An unavailable binding must never turn an unknown consumer into a false unused-export finding.
+    if (symbol)
+        visit(sourceFile);
+    else
+        result.all = true;
+    context.namespaceUses.set(namespace, result);
+    return result;
 };
-
 const importBindings = (context, declaration) => {
-  const { ts } = context;
-  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) {
-    const namespace = namespaceBindings(context, declaration, named);
-    return { all: namespace.all, pairs: [...pairs, ...namespace.pairs] };
-  }
-  if (named) for (const element of named.elements) pairs.push({ imported: (element.propertyName ?? element.name).text, exported: null });
-  return { all: false, pairs };
+    const { ts } = context;
+    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) {
+        const namespace = namespaceBindings(context, declaration, named);
+        return { all: namespace.all, pairs: [...pairs, ...namespace.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 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 }] };
+    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}]}. */
 export function bindingsOf(context, declaration) {
-  const { ts } = context;
-  if (!declaration) return { all: true, pairs: [] };
-  if (declaration.kind === ts.SyntaxKind.ImportDeclaration) return importBindings(context, 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 { ts } = context;
+    if (!declaration)
+        return { all: true, pairs: [] };
+    if (ts.isImportDeclaration(declaration))
+        return importBindings(context, declaration);
+    if (ts.isExportDeclaration(declaration))
+        return exportBindings(ts, declaration);
+    if (ts.isImportTypeNode(declaration))
+        return importTypeBindings(ts, declaration);
+    // ImportEqualsDeclaration, dynamic import(), require(): the whole module is taken.
+    return { all: true, pairs: [] };
 }

package/runtime/scripts/hfs/architecture/dead-exports.d.mts

@@ -0,0 +1,32 @@
+import type { CompilerOptions, SourceFile } from 'typescript';
+import type { ArchitectureConfig, TypeScriptApi } from './config.mjs';
+import type { ArchitectureViolation, CheckContext, HfsGraph, OwnerRoot } from './hfs-graph.mjs';
+/** The TypeScript context of the dead-code check: the check context plus the program projects (their compiler options). */
+export interface DeadExportsContext extends CheckContext {
+    projects?: {
+        options: CompilerOptions;
+    }[];
+}
+/** What `checkDeadExports` receives. */
+export interface DeadExportsInput {
+    context: DeadExportsContext;
+    graph: HfsGraph;
+    config: ArchitectureConfig;
+}
+export declare const DEAD_EXPORT_RULE_IDS: string[];
+/** The public entry file (repository-relative) of an owner unit, or null when the owner has none in the graph. */
+export declare function entryOf(graph: HfsGraph, config: ArchitectureConfig, key: string, owner: OwnerRoot): string | null;
+/** The exported names of an entry source file, each with the line of its declaration. */
+export declare function exportedNames(ts: TypeScriptApi, sourceFile: SourceFile): Map<string, number>;
+export declare function checkDeadExports({ context, graph, config }: DeadExportsInput): {
+    violations: ArchitectureViolation[];
+    coverage: {
+        status: string;
+        owners: number;
+        exports: number;
+        dead: number;
+        files: number;
+        roots: number;
+        unusedFiles: number;
+    };
+};