@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.211

package/src/fonts/ast.ts

@@ -1,24 +1,35 @@
 /**
- * Acorn-based AST utilities for extracting static font configs from source code.
+ * AST utilities for extracting static font configs from source code.
+ * Uses OXC via Vite's `parseAst` — handles JS/JSX/TS/TSX natively.
  *
- * Replaces the fragile regex-based extraction in fonts.ts and local.ts.
- * Uses acorn (already a Vite dependency) for robust parsing that handles
- * comments, trailing commas, multi-line configs, and other edge cases
- * the regex approach missed.
+ * Provides two tiers of API:
+ *
+ * 1. **Source-text helpers** (`extractFontConfigAst`, `extractLocalFontConfigAst`,
+ *    `detectDynamicFontCallAst`) — parse a snippet and return extracted config.
+ *    Still used by tests and callers that have only a string.
+ *
+ * 2. **AST-node helpers** (`extractGoogleFontConfigFromNode`,
+ *    `extractLocalFontConfigFromNode`, `findFontCallSites`) — operate on
+ *    nodes from an already-parsed Program so the transform hook can share
+ *    one parse with all analysis steps.
  *
  * Design doc: 24-fonts.md §"Step 1: Static Analysis"
  */
 
-import { parse } from 'acorn';
-import type { GoogleFontConfig } from './types.js';
-import type { LocalFontConfig, LocalFontSrc } from './types.js';
+import { parseAst as viteParseAst } from 'vite';
+import type { GoogleFontConfig } from './types.ts';
+import type { LocalFontConfig, LocalFontSrc } from './types.ts';
+import type { AstNode, IdentifierNode, PositionedNode, FlaggedUsage } from './ast-walk.ts';
+import {
+  offsetToLineColumn,
+  walkForDynamicCalls,
+  walkForNestedFontCalls,
+  walkForUnconsumedReferences,
+} from './ast-walk.ts';
 
-// ── AST node types (minimal subset of estree) ────────────────────────────────
+export type { FlaggedUsage } from './ast-walk.ts';
 
-interface AstNode {
-  type: string;
-  [key: string]: unknown;
-}
+// ── AST node types (font-config-specific, on top of ast-walk.ts's base) ──────
 
 interface LiteralNode extends AstNode {
   type: 'Literal';
@@ -41,25 +52,19 @@ interface PropertyNode extends AstNode {
   value: AstNode;
 }
 
-interface IdentifierNode extends AstNode {
-  type: 'Identifier';
-  name: string;
-}
-
 // ── Core AST extraction helpers ──────────────────────────────────────────────
 
 /**
  * Parse a JavaScript expression string into an AST node.
  *
- * Wraps the expression in parens so acorn treats it as an expression statement.
+ * Wraps the expression in parens so OXC (via vite.parseAst) treats it as an expression statement.
  * Returns null if parsing fails.
  */
 function parseExpression(source: string): AstNode | null {
   try {
-    const ast = parse(`(${source})`, {
-      ecmaVersion: 'latest',
-      sourceType: 'module',
-    }) as unknown as { body: Array<{ expression: AstNode }> };
+    const ast = viteParseAst(`(${source})`, { lang: 'tsx' }) as unknown as {
+      body: Array<{ expression: AstNode }>;
+    };
     return ast.body[0]?.expression ?? null;
   } catch {
     return null;
@@ -145,18 +150,112 @@ function objectProperties(node: ObjectExpressionNode): Map<string, AstNode> {
 export function extractFontConfigAst(callSource: string): GoogleFontConfig | null {
   const node = parseExpression(callSource);
   if (!node || node.type !== 'ObjectExpression') return null;
+  return extractGoogleConfig(node as ObjectExpressionNode);
+}
 
+// ── Local font config extraction ─────────────────────────────────────────────
+
+/**
+ * Extract a single LocalFontSrc entry from an ObjectExpression AST node.
+ */
+function extractLocalFontSrcEntry(node: AstNode): LocalFontSrc | null {
+  if (node.type !== 'ObjectExpression') return null;
   const props = objectProperties(node as ObjectExpressionNode);
+
+  const pathNode = props.get('path');
+  if (!pathNode) return null;
+  const path = extractString(pathNode);
+  if (path === undefined) return null;
+
+  const entry: LocalFontSrc = { path };
+
+  const weightNode = props.get('weight');
+  if (weightNode) {
+    const w = extractString(weightNode);
+    if (w !== undefined) entry.weight = w;
+  }
+
+  const styleNode = props.get('style');
+  if (styleNode) {
+    const s = extractString(styleNode);
+    if (s !== undefined) entry.style = s;
+  }
+
+  return entry;
+}
+
+/**
+ * Extract a LocalFontConfig from the source text of a localFont() call's
+ * object argument.
+ *
+ * Returns null if parsing or extraction fails.
+ */
+export function extractLocalFontConfigAst(callSource: string): LocalFontConfig | null {
+  const node = parseExpression(callSource);
+  if (!node || node.type !== 'ObjectExpression') return null;
+  return extractLocalConfig(node as ObjectExpressionNode);
+}
+
+// ── Dynamic call detection ───────────────────────────────────────────────────
+
+/**
+ * Detect if source code contains dynamic/computed font function calls
+ * that cannot be statically analyzed.
+ *
+ * Uses OXC (via vite.parseAst) to parse the full source and inspect CallExpression nodes.
+ * Returns the offending expression string if found, null if all calls are static.
+ */
+export function detectDynamicFontCallAst(source: string, importedNames: string[]): string | null {
+  if (importedNames.length === 0) return null;
+
+  let ast;
+  try {
+    ast = viteParseAst(source, { lang: 'tsx' }) as unknown as { body: AstNode[] };
+  } catch {
+    // If we can't parse the source at all, fall back to no detection
+    return null;
+  }
+
+  const nameSet = new Set(importedNames);
+  return walkForDynamicCalls(ast as unknown as AstNode, nameSet, source);
+}
+
+// ── AST-node-level config extraction ─────────────────────────────────────────
+//
+// These work on an already-parsed ObjectExpression node so the transform
+// hook can share one OXC (via vite.parseAst) parse of the full source file with all analysis
+// steps (TIM-827).
+
+/**
+ * Extract a GoogleFontConfig from an ObjectExpression AST node.
+ *
+ * This is the node-level equivalent of `extractFontConfigAst` — it skips
+ * the parse step because the caller already has a parsed Program.
+ */
+export function extractGoogleFontConfigFromNode(node: AstNode): GoogleFontConfig | null {
+  if (node.type !== 'ObjectExpression') return null;
+  return extractGoogleConfig(node as ObjectExpressionNode);
+}
+
+/**
+ * Extract a LocalFontConfig from an ObjectExpression AST node.
+ */
+export function extractLocalFontConfigFromNode(node: AstNode): LocalFontConfig | null {
+  if (node.type !== 'ObjectExpression') return null;
+  return extractLocalConfig(node as ObjectExpressionNode);
+}
+
+/** Shared implementation for GoogleFontConfig extraction from an object node. */
+function extractGoogleConfig(objNode: ObjectExpressionNode): GoogleFontConfig {
+  const props = objectProperties(objNode);
   const config: GoogleFontConfig = {};
 
-  // subsets: string[]
   const subsetsNode = props.get('subsets');
   if (subsetsNode) {
     const arr = extractStringArray(subsetsNode);
     if (arr) config.subsets = arr;
   }
 
-  // weight: string | string[]
   const weightNode = props.get('weight');
   if (weightNode) {
     const arr = extractStringArray(weightNode);
@@ -168,21 +267,18 @@ export function extractFontConfigAst(callSource: string): GoogleFontConfig | nul
     }
   }
 
-  // display: string
   const displayNode = props.get('display');
   if (displayNode) {
     const s = extractString(displayNode);
     if (s !== undefined) config.display = s as GoogleFontConfig['display'];
   }
 
-  // variable: string
   const variableNode = props.get('variable');
   if (variableNode) {
     const s = extractString(variableNode);
     if (s !== undefined) config.variable = s;
   }
 
-  // style: string | string[]
   const styleNode = props.get('style');
   if (styleNode) {
     const arr = extractStringArray(styleNode);
@@ -194,7 +290,6 @@ export function extractFontConfigAst(callSource: string): GoogleFontConfig | nul
     }
   }
 
-  // preload: boolean
   const preloadNode = props.get('preload');
   if (preloadNode) {
     const b = extractBoolean(preloadNode);
@@ -204,74 +299,29 @@ export function extractFontConfigAst(callSource: string): GoogleFontConfig | nul
   return config;
 }
 
-// ── Local font config extraction ─────────────────────────────────────────────
-
-/**
- * Extract a single LocalFontSrc entry from an ObjectExpression AST node.
- */
-function extractLocalFontSrcEntry(node: AstNode): LocalFontSrc | null {
-  if (node.type !== 'ObjectExpression') return null;
-  const props = objectProperties(node as ObjectExpressionNode);
-
-  const pathNode = props.get('path');
-  if (!pathNode) return null;
-  const path = extractString(pathNode);
-  if (path === undefined) return null;
-
-  const entry: LocalFontSrc = { path };
+/** Shared implementation for LocalFontConfig extraction from an object node. */
+function extractLocalConfig(objNode: ObjectExpressionNode): LocalFontConfig | null {
+  const props = objectProperties(objNode);
 
-  const weightNode = props.get('weight');
-  if (weightNode) {
-    const w = extractString(weightNode);
-    if (w !== undefined) entry.weight = w;
-  }
-
-  const styleNode = props.get('style');
-  if (styleNode) {
-    const s = extractString(styleNode);
-    if (s !== undefined) entry.style = s;
-  }
-
-  return entry;
-}
-
-/**
- * Extract a LocalFontConfig from the source text of a localFont() call's
- * object argument.
- *
- * Returns null if parsing or extraction fails.
- */
-export function extractLocalFontConfigAst(callSource: string): LocalFontConfig | null {
-  const node = parseExpression(callSource);
-  if (!node || node.type !== 'ObjectExpression') return null;
-
-  const props = objectProperties(node as ObjectExpressionNode);
-
-  // display: string
   const displayNode = props.get('display');
   const display = displayNode
     ? (extractString(displayNode) as LocalFontConfig['display'])
     : undefined;
 
-  // variable: string
   const variableNode = props.get('variable');
   const variable = variableNode ? extractString(variableNode) : undefined;
 
-  // family: string
   const familyNode = props.get('family');
   const family = familyNode ? extractString(familyNode) : undefined;
 
-  // src: string | LocalFontSrc[]
   const srcNode = props.get('src');
   if (!srcNode) return null;
 
-  // String form: src: './fonts/MyFont.woff2'
   const srcString = extractString(srcNode);
   if (srcString !== undefined) {
     return { src: srcString, display, variable, family };
   }
 
-  // Array form: src: [{ path: '...', weight: '...' }, ...]
   if (srcNode.type === 'ArrayExpression') {
     const arr = srcNode as ArrayExpressionNode;
     const entries: LocalFontSrc[] = [];
@@ -287,73 +337,374 @@ export function extractLocalFontConfigAst(callSource: string): LocalFontConfig |
   return null;
 }
 
-// ── Dynamic call detection ───────────────────────────────────────────────────
+// ── Font module specifiers ───────────────────────────────────────────────────
+
+const GOOGLE_FONT_SOURCES = new Set([
+  '@timber/fonts/google',
+  '@timber-js/app/fonts/google',
+  'next/font/google',
+]);
+
+const LOCAL_FONT_SOURCES = new Set([
+  '@timber/fonts/local',
+  '@timber-js/app/fonts/local',
+  'next/font/local',
+]);
+
+// ── Parsed source types ──────────────────────────────────────────────────────
+
+/** A font import binding discovered from an ImportDeclaration. */
+export interface FontBinding {
+  /** The local name used in the module (after `as`, if present). */
+  localName: string;
+  /**
+   * The original exported name (before `as`). For Google fonts this is
+   * the PascalCase_With_Underscores name that maps to the family. For
+   * local fonts (`default` import), this is `'default'`.
+   */
+  importedName: string;
+  /** `'google'` or `'local'`. */
+  provider: 'google' | 'local';
+  /** The AST node of the ImportDeclaration (for removal via magic-string). */
+  importNode: AstNode & { start: number; end: number };
+}
+
+/** A font function call site discovered from a CallExpression. */
+export interface FontCallSite {
+  /** The binding that this call references. */
+  binding: FontBinding;
+  /**
+   * The variable name this call is assigned to, if the call appears in a
+   * VariableDeclarator. `null` for bare expression statements.
+   */
+  assignedName: string | null;
+  /** The first argument AST node (expected to be an ObjectExpression). */
+  configNode: AstNode;
+  /**
+   * The outermost AST node to replace. For a VariableDeclaration with a
+   * single declarator this is the full declaration; for a bare expression
+   * statement it is the ExpressionStatement. The transform replaces
+   * `source[replaceStart..replaceEnd]`.
+   */
+  replaceStart: number;
+  replaceEnd: number;
+  /** Line number (1-based) of the call for error messages. */
+  line: number;
+  /** Column (0-based) of the call for error messages. */
+  column: number;
+}
+
+/** Result of `findFontCallSites` — everything the transform needs. */
+export interface FontAnalysis {
+  bindings: FontBinding[];
+  callSites: FontCallSite[];
+  /**
+   * Import nodes that should be removed (deduplicated). Only imports that
+   * produced at least one font binding are listed — removing an import
+   * whose bindings the transform doesn't rewrite (e.g. a namespace
+   * import) would leave dangling references behind.
+   */
+  importNodesToRemove: Array<{ start: number; end: number }>;
+  /** First dynamic call expression text, or `null`. */
+  dynamicCall: string | null;
+  /**
+   * Font calls found in nested scopes (functions, if-blocks, etc.).
+   * These are errors — font calls must be module-level.
+   */
+  nestedCalls: FlaggedUsage[];
+  /**
+   * Namespace imports of font modules (`import * as fonts from ...`).
+   * These are errors — the transform cannot rewrite `fonts.Inter(...)`
+   * member calls, so the fonts would silently never load.
+   */
+  namespaceImports: FlaggedUsage[];
+  /**
+   * References to font bindings that were not consumed by a recognized
+   * call site (`export default Inter({...})`, object-literal nesting,
+   * member access on the call result, aliasing, re-exports). These are
+   * errors — the import is removed, so any leftover reference would be a
+   * silent runtime ReferenceError.
+   */
+  unsupportedUsages: FlaggedUsage[];
+}
+
+interface ImportDeclarationNode extends PositionedNode {
+  type: 'ImportDeclaration';
+  source: LiteralNode & { value: string };
+  specifiers: Array<
+    PositionedNode & {
+      type: string;
+      local: IdentifierNode;
+      imported?: IdentifierNode;
+    }
+  >;
+}
+
+interface CallExpressionNode extends PositionedNode {
+  type: 'CallExpression';
+  callee: AstNode;
+  arguments: PositionedNode[];
+}
+
+interface VariableDeclaratorNode extends PositionedNode {
+  type: 'VariableDeclarator';
+  id: PositionedNode;
+  init: PositionedNode | null;
+}
+
+interface VariableDeclarationNode extends PositionedNode {
+  type: 'VariableDeclaration';
+  declarations: VariableDeclaratorNode[];
+}
+
+interface ExpressionStatementNode extends PositionedNode {
+  type: 'ExpressionStatement';
+  expression: PositionedNode;
+}
+
+interface ExportNamedDeclarationNode extends PositionedNode {
+  type: 'ExportNamedDeclaration';
+  declaration: VariableDeclarationNode | ExpressionStatementNode | null;
+}
+
+// ── Type guards for AST narrowing ────────────────────────────────────────────
+//
+// OXC's parsed nodes all share the base `PositionedNode` shape with
+// `type: string`. TypeScript can't narrow a union that includes a
+// `string`-typed catch-all, so we use explicit type guards instead of
+// bare `.type ===` checks.
+
+function isImportDeclaration(node: PositionedNode): node is ImportDeclarationNode {
+  return node.type === 'ImportDeclaration';
+}
+
+function isVariableDeclaration(node: PositionedNode): node is VariableDeclarationNode {
+  return node.type === 'VariableDeclaration';
+}
+
+function isExpressionStatement(node: PositionedNode): node is ExpressionStatementNode {
+  return node.type === 'ExpressionStatement';
+}
+
+function isExportNamedDeclaration(node: PositionedNode): node is ExportNamedDeclarationNode {
+  return node.type === 'ExportNamedDeclaration';
+}
+
+function isCallExpression(node: PositionedNode): node is CallExpressionNode {
+  return node.type === 'CallExpression';
+}
+
+function isIdentifier(node: AstNode): node is IdentifierNode {
+  return node.type === 'Identifier';
+}
+
+interface ProgramNode extends PositionedNode {
+  type: 'Program';
+  body: PositionedNode[];
+}
 
 /**
- * Detect if source code contains dynamic/computed font function calls
- * that cannot be statically analyzed.
+ * Parse a full source file and find all font imports and call sites.
  *
- * Uses acorn to parse the full source and inspect CallExpression nodes.
- * Returns the offending expression string if found, null if all calls are static.
+ * Returns `null` if the source has no font-related imports.
  */
-export function detectDynamicFontCallAst(source: string, importedNames: string[]): string | null {
-  if (importedNames.length === 0) return null;
-
-  let ast;
+export function findFontCallSites(source: string): FontAnalysis | null {
+  let program: ProgramNode;
   try {
-    ast = parse(source, {
-      ecmaVersion: 'latest',
-      sourceType: 'module',
-    }) as unknown as { body: AstNode[] };
+    program = viteParseAst(source, { lang: 'tsx' }) as unknown as ProgramNode;
   } catch {
-    // If we can't parse the source at all, fall back to no detection
     return null;
   }
 
-  const nameSet = new Set(importedNames);
-  const result = walkForDynamicCalls(ast as unknown as AstNode, nameSet, source);
-  return result;
-}
-
-/**
- * Recursively walk the AST looking for CallExpression nodes where
- * the callee is one of the imported font names and the first argument
- * is not an ObjectExpression (i.e. it's dynamic).
- */
-function walkForDynamicCalls(node: AstNode, names: Set<string>, source: string): string | null {
-  if (!node || typeof node !== 'object') return null;
-
-  if (node.type === 'CallExpression') {
-    const callee = node.callee as AstNode;
-    if (callee.type === 'Identifier' && names.has((callee as IdentifierNode).name)) {
-      const args = node.arguments as AstNode[];
-      if (args.length > 0 && args[0].type !== 'ObjectExpression') {
-        // Extract the argument source text
-        const argStart = (args[0] as AstNode & { start: number }).start;
-        const argEnd = (args[0] as AstNode & { end: number }).end;
-        const argText = source.slice(argStart, argEnd);
-        const calleeName = (callee as IdentifierNode).name;
-        return `${calleeName}(${argText})`;
+  // Step 1: Find all font import declarations and build the bindings list.
+  const bindings: FontBinding[] = [];
+  const importNodesToRemove: Array<{ start: number; end: number }> = [];
+  const namespaceImports: FlaggedUsage[] = [];
+
+  for (const stmt of program.body) {
+    if (!isImportDeclaration(stmt)) continue;
+    const importDecl = stmt;
+    const specSource = importDecl.source.value;
+
+    let provider: 'google' | 'local' | null = null;
+    if (GOOGLE_FONT_SOURCES.has(specSource)) provider = 'google';
+    else if (LOCAL_FONT_SOURCES.has(specSource)) provider = 'local';
+    if (!provider) continue;
+
+    let producedBinding = false;
+    for (const spec of importDecl.specifiers) {
+      if (spec.type === 'ImportSpecifier' && provider === 'google') {
+        producedBinding = true;
+        bindings.push({
+          localName: spec.local.name,
+          importedName: spec.imported?.name ?? spec.local.name,
+          provider,
+          importNode: importDecl,
+        });
+      } else if (spec.type === 'ImportDefaultSpecifier' && provider === 'local') {
+        producedBinding = true;
+        bindings.push({
+          localName: spec.local.name,
+          importedName: 'default',
+          provider,
+          importNode: importDecl,
+        });
+      } else if (spec.type === 'ImportNamespaceSpecifier') {
+        // `import * as fonts from ...` cannot be rewritten — the transform
+        // only matches direct identifier calls, so `fonts.Inter(...)` would
+        // silently fall through to the runtime fallback module and never
+        // load a real font. Collected as a build error.
+        const pos = offsetToLineColumn(source, spec.start);
+        namespaceImports.push({ name: spec.local.name, line: pos.line, column: pos.column });
       }
     }
+
+    // Only remove imports whose bindings the transform actually rewrites.
+    // Removing an import that produced no binding (namespace imports,
+    // default imports of the google module) would orphan its references.
+    if (producedBinding) {
+      importNodesToRemove.push({ start: stmt.start, end: stmt.end });
+    }
   }
 
-  // Walk all child properties
-  for (const key of Object.keys(node)) {
-    if (key === 'type') continue;
-    const child = node[key];
-    if (Array.isArray(child)) {
-      for (const item of child) {
-        if (item && typeof item === 'object' && (item as AstNode).type) {
-          const result = walkForDynamicCalls(item as AstNode, names, source);
-          if (result) return result;
+  if (bindings.length === 0 && namespaceImports.length === 0) return null;
+
+  // Step 2: Walk the AST for CallExpression nodes whose callee is a font binding.
+  const bindingsByName = new Map(bindings.map((b) => [b.localName, b]));
+  const callSites: FontCallSite[] = [];
+  // Start offsets of recognized (and dynamic-flagged) CallExpressions, so
+  // the unsupported-reference walk in step 4 can skip them.
+  const consumedCallStarts = new Set<number>();
+  let dynamicCall: string | null = null;
+
+  for (const stmt of program.body) {
+    // Unwrap `export const roboto = Roboto(...)` — the AST wraps the
+    // VariableDeclaration inside an ExportNamedDeclaration node.
+    const effectiveStmt =
+      isExportNamedDeclaration(stmt) && stmt.declaration ? stmt.declaration : stmt;
+
+    // VariableDeclaration: `const inter = Inter({ ... })`
+    if (isVariableDeclaration(effectiveStmt)) {
+      for (const declarator of effectiveStmt.declarations) {
+        if (!declarator.init) continue;
+        if (!isCallExpression(declarator.init)) continue;
+        const call = declarator.init;
+        const site = matchCallExpression(call, bindingsByName, source);
+        if (!site) continue;
+
+        if (site === 'dynamic') {
+          consumedCallStarts.add(call.start);
+          if (!dynamicCall && isIdentifier(call.callee)) {
+            const argStart = call.arguments[0].start;
+            const argEnd = call.arguments[0].end;
+            dynamicCall = `${call.callee.name}(${source.slice(argStart, argEnd)})`;
+          }
+          continue;
+        }
+
+        const assignedName = isIdentifier(declarator.id) ? declarator.id.name : null;
+
+        const { line, column } = offsetToLineColumn(source, call.start);
+        consumedCallStarts.add(call.start);
+        callSites.push({
+          binding: site.binding,
+          assignedName,
+          configNode: site.configNode,
+          replaceStart: call.start,
+          replaceEnd: call.end,
+          line,
+          column,
+        });
+      }
+    }
+
+    // ExpressionStatement: `Inter({ ... })` as a bare call
+    if (isExpressionStatement(effectiveStmt)) {
+      if (isCallExpression(effectiveStmt.expression)) {
+        const call = effectiveStmt.expression;
+        const site = matchCallExpression(call, bindingsByName, source);
+        if (site && site !== 'dynamic') {
+          const { line, column } = offsetToLineColumn(source, call.start);
+          consumedCallStarts.add(call.start);
+          callSites.push({
+            binding: site.binding,
+            assignedName: null,
+            configNode: site.configNode,
+            replaceStart: effectiveStmt.start,
+            replaceEnd: effectiveStmt.end,
+            line,
+            column,
+          });
+        } else if (site === 'dynamic') {
+          consumedCallStarts.add(call.start);
+          if (!dynamicCall && isIdentifier(call.callee)) {
+            const argStart = call.arguments[0].start;
+            const argEnd = call.arguments[0].end;
+            dynamicCall = `${call.callee.name}(${source.slice(argStart, argEnd)})`;
+          }
         }
       }
-    } else if (child && typeof child === 'object' && (child as AstNode).type) {
-      const result = walkForDynamicCalls(child as AstNode, names, source);
-      if (result) return result;
     }
   }
 
-  return null;
+  // Step 3: Walk nested scopes to find font calls that aren't module-level.
+  // Font calls must be at module scope (same constraint as Next.js).
+  // If the import is removed but a nested call remains, it's a ReferenceError.
+  const nestedCalls: FlaggedUsage[] = [];
+  for (const stmt of program.body) {
+    if (stmt.type === 'ImportDeclaration') continue;
+    walkForNestedFontCalls(stmt as AstNode, bindingsByName, source, nestedCalls, false);
+  }
+
+  // Step 4: Walk for references to font bindings that were not consumed by
+  // a recognized call site. The transform removes the import declarations,
+  // so any leftover reference (`export default Inter({...})`, object-literal
+  // nesting, `Inter({...}).className`, `const f = Inter`, `export { Inter }`)
+  // would become a silent runtime ReferenceError. Collected as build errors.
+  const unsupportedUsages: FlaggedUsage[] = [];
+  for (const stmt of program.body) {
+    if (stmt.type === 'ImportDeclaration') continue;
+    walkForUnconsumedReferences(
+      stmt as AstNode,
+      bindingsByName,
+      consumedCallStarts,
+      source,
+      unsupportedUsages
+    );
+  }
+
+  return {
+    bindings,
+    callSites,
+    importNodesToRemove,
+    dynamicCall,
+    nestedCalls,
+    namespaceImports,
+    unsupportedUsages,
+  };
+}
+
+/**
+ * Match a CallExpression against the font bindings map.
+ *
+ * Returns the binding + config node if the call is a static font call,
+ * `'dynamic'` if it's a font call with a non-object argument, or `null`
+ * if the callee doesn't match any font binding.
+ */
+function matchCallExpression(
+  call: CallExpressionNode,
+  bindings: Map<string, FontBinding>,
+  _source: string
+): { binding: FontBinding; configNode: AstNode } | 'dynamic' | null {
+  if (!isIdentifier(call.callee)) return null;
+  const calleeName = call.callee.name;
+  const binding = bindings.get(calleeName);
+  if (!binding) return null;
+
+  const args = call.arguments;
+  if (args.length === 0 || args[0].type !== 'ObjectExpression') {
+    return 'dynamic';
+  }
+
+  return { binding, configNode: args[0] };
 }