@rangojs/router 0.0.0-experimental.ea6d5eec → 0.0.0-experimental.ea9f40f2

package/src/vite/plugins/expose-ids/export-analysis.ts

@@ -5,15 +5,11 @@ import {
   findStatementEnd,
   buildExportMap,
   escapeRegExp,
+  findCallParenAfterGenerics,
 } from "../expose-id-utils.js";
+import { codeMatchIndices } from "../../../build/route-types/source-scan.js";
 import type { CreateExportBinding } from "./types.js";
 
-/**
- * Check whether every non-type export in `code` is accounted for by the given
- * bindings. Returns false if any export exists that is not one of the known
- * create* call locals/exports, allowing callers to bail out for mixed-export
- * files.
- */
 export function isExportOnlyFile(
   code: string,
   bindings: CreateExportBinding[],
@@ -27,10 +23,8 @@ export function isExportOnlyFile(
     for (const e of b.exportNames) knownExports.add(e);
   }
 
-  // Bail on star re-exports (unknown exports)
   if (/export\s*\*/.test(code)) return false;
 
-  // Check `export const/let/var/function/class/default X` declarations
   const declExportPattern =
     /export\s+(const|let|var|function|class|default)\s+(\w+)/g;
   let match: RegExpExecArray | null;
@@ -38,8 +32,6 @@ export function isExportOnlyFile(
     if (!knownExports.has(match[2])) return false;
   }
 
-  // Check `export { X }` and `export { X as Y }` specifiers: the local name
-  // must reference a known create* binding.
   const specExportPattern = /export\s*\{([^}]+)\}/g;
   while ((match = specExportPattern.exec(code)) !== null) {
     const specifiers = match[1]
@@ -59,19 +51,69 @@ export function isExportOnlyFile(
   return true;
 }
 
-// NOTE: This regex may over-count when the fn name appears inside strings or
-// comments, but it's only used for the warning heuristic (totalCalls >
-// supportedBindings) and the inline-extraction pre-check, so over-counting
-// triggers a harmless extra AST parse rather than affecting correctness.
+// Matches the callee identifier only. The optional generic argument list
+// (which may be nested, e.g. createLoader<A<B>>(...)) and the call paren are
+// resolved per match via findCallParenAfterGenerics, so a nested `>` no longer
+// defeats the scan the way `<[^>]*>` did (it stopped at the first `>`).
+function createCallPattern(fnNames: string[]): RegExp {
+  return new RegExp(`\\b(?:${fnNames.map(escapeRegExp).join("|")})\\b`, "g");
+}
+
+/**
+ * Byte offsets of every create*-call site in real code: a callee-identifier
+ * match that is actually followed by a call `(` (after an optional nested
+ * generic list). Non-call references (type positions, the import specifier
+ * itself) yield -1 from findCallParenAfterGenerics and are dropped.
+ */
+function createCallStartIndices(code: string, fnNames: string[]): number[] {
+  return codeMatchIndices(code, createCallPattern(fnNames)).filter(
+    (index) =>
+      findCallParenAfterGenerics(
+        code,
+        index + matchedNameLength(code, index),
+      ) !== -1,
+  );
+}
+
+// Length of the identifier match at `index` (run of identifier chars).
+function matchedNameLength(code: string, index: number): number {
+  let i = index;
+  while (i < code.length && /[A-Za-z0-9_$]/.test(code[i])) i++;
+  return i - index;
+}
+
 export function countCreateCallsForNames(
   code: string,
   fnNames: string[],
 ): number {
-  const pattern = new RegExp(
-    `\\b(?:${fnNames.map(escapeRegExp).join("|")})\\s*(?:<[^>]*>\\s*)?\\(`,
-    "g",
-  );
-  return (code.match(pattern) || []).length;
+  return createCallStartIndices(code, fnNames).length;
+}
+
+export function offsetToLineColumn(
+  code: string,
+  index: number,
+): { line: number; column: number } {
+  let line = 1;
+  let lineStart = 0;
+  const end = Math.min(index, code.length);
+  for (let i = 0; i < end; i++) {
+    if (code[i] === "\n") {
+      line++;
+      lineStart = i + 1;
+    }
+  }
+  return { line, column: index - lineStart + 1 };
+}
+
+export function findUnsupportedCreateCallSites(
+  code: string,
+  fnNames: string[],
+  supportedBindings: CreateExportBinding[],
+): Array<{ line: number; column: number }> {
+  const supported = new Set(supportedBindings.map((b) => b.callExprStart));
+  return createCallStartIndices(code, fnNames)
+    .filter((index) => !supported.has(index))
+    .map((index) => offsetToLineColumn(code, index));
 }
 
 export function getImportedFnNames(
@@ -119,6 +161,18 @@ export function getCalledIdentifierFromCall(callExpr: any): string | null {
   return null;
 }
 
+function unwrapSignatureWrappedCall(init: any, fnNameSet: Set<string>): any {
+  if (init?.type !== "CallExpression") return init;
+  const directId = getCalledIdentifierFromCall(init);
+  if (directId && fnNameSet.has(directId)) return init;
+  const firstArg = init.arguments?.[0];
+  if (firstArg?.type === "CallExpression") {
+    const innerId = getCalledIdentifierFromCall(firstArg);
+    if (innerId && fnNameSet.has(innerId)) return firstArg;
+  }
+  return init;
+}
+
 export function collectCreateExportBindingsFallback(
   code: string,
   fnNames: string[],
@@ -196,7 +250,7 @@ export function collectCreateExportBindings(
 ): CreateExportBinding[] {
   if (!program) {
     try {
-      program = parseAst(code, { jsx: true });
+      program = parseAst(code, { lang: "tsx" });
     } catch {
       return collectCreateExportBindingsFallback(code, fnNames);
     }
@@ -212,10 +266,13 @@ export function collectCreateExportBindings(
     }
 
     for (const decl of varDecl.declarations ?? []) {
-      const calledIdentifier = getCalledIdentifierFromCall(decl?.init);
+      // Unwrap a Fast Refresh signature wrapper (`_s(createLoader(...), ...)`)
+      // so injection targets the inner create* call. Falls back to decl.init.
+      const callExpr = unwrapSignatureWrappedCall(decl?.init, fnNameSet);
+      const calledIdentifier = getCalledIdentifierFromCall(callExpr);
       if (
         decl?.id?.type !== "Identifier" ||
-        decl?.init?.type !== "CallExpression" ||
+        callExpr?.type !== "CallExpression" ||
         !calledIdentifier ||
         !fnNameSet.has(calledIdentifier)
       ) {
@@ -226,9 +283,8 @@ export function collectCreateExportBindings(
       const exportNames = exportMap.get(localName) ?? [];
       if (exportNames.length === 0) continue;
 
-      const callStart = decl.init.start as number;
-      const callEnd = decl.init.end as number;
-      const calleeEnd = decl.init.callee.end as number;
+      const callEnd = callExpr.end as number;
+      const calleeEnd = callExpr.callee.end as number;
 
       let openParenPos = -1;
       for (let i = calleeEnd; i < callEnd; i++) {
@@ -245,10 +301,10 @@ export function collectCreateExportBindings(
       bindings.push({
         localName,
         exportNames,
-        callExprStart: decl.init.start as number,
+        callExprStart: callExpr.start as number,
         callOpenParenPos: openParenPos,
         callCloseParenPos: closeParenPos,
-        argCount: decl.init.arguments?.length ?? 0,
+        argCount: callExpr.arguments?.length ?? 0,
         statementEnd,
       });
     }
@@ -268,10 +324,6 @@ export function collectCreateExportBindings(
     }
   }
 
-  // When the JS parser misidentifies TypeScript generics (e.g.,
-  // createLocationState<{ text: string }>({...})) as binary expressions,
-  // the AST path finds 0 bindings even though calls exist. Fall back to
-  // regex-based detection which handles generics via <[^>]*> matching.
   if (bindings.length === 0) {
     return collectCreateExportBindingsFallback(code, fnNames);
   }
@@ -282,9 +334,23 @@ export function collectCreateExportBindings(
 export function buildUnsupportedShapeWarning(
   filePath: string,
   fnName: string,
+  sites: Array<{ line: number; column: number }> = [],
 ): string {
-  return [
-    `[rsc-router] Unsupported ${fnName} shape in "${filePath}".`,
+  const lines = [`[rango] Unsupported ${fnName} shape in "${filePath}".`];
+
+  if (sites.length === 1) {
+    const s = sites[0];
+    lines.push(
+      `The ${fnName}(...) call at ${filePath}:${s.line}:${s.column} has no stable $$id injected — it is not in a supported shape.`,
+    );
+  } else if (sites.length > 1) {
+    lines.push(
+      `These ${fnName}(...) calls have no stable $$id injected — they are not in a supported shape:`,
+    );
+    for (const s of sites) lines.push(`  - ${filePath}:${s.line}:${s.column}`);
+  }
+
+  lines.push(
     `Supported shapes are:`,
     `  - export const X = ${fnName}(...)`,
     `  - const X = ${fnName}(...); export { X }`,
@@ -292,5 +358,6 @@ export function buildUnsupportedShapeWarning(
     `Potentially unsupported forms include:`,
     `  - export let/var X = ${fnName}(...)`,
     `  - inline ${fnName}(...) calls`,
-  ].join("\n");
+  );
+  return lines.join("\n");
 }

package/src/vite/plugins/expose-ids/handler-transform.ts

@@ -1,39 +1,26 @@
 import MagicString from "magic-string";
-import { hashId } from "../expose-id-utils.js";
+import { makeStubId } from "../expose-id-utils.js";
 import type { HandlerTransformConfig, CreateExportBinding } from "./types.js";
 import { isExportOnlyFile } from "./export-analysis.js";
 
-function analyzeCreateHandleArgs(
-  code: string,
-  startPos: number,
-  endPos: number,
-): { hasArgs: boolean } {
-  const content = code.slice(startPos, endPos).trim();
-  return { hasArgs: content.length > 0 };
-}
-
 export function transformHandles(
   bindings: CreateExportBinding[],
   s: MagicString,
-  code: string,
   filePath: string,
   isBuild: boolean,
 ): boolean {
   let hasChanges = false;
   for (const binding of bindings) {
     const exportName = binding.exportNames[0];
-    const args = analyzeCreateHandleArgs(
-      code,
-      binding.callOpenParenPos + 1,
-      binding.callCloseParenPos,
-    );
 
-    const handleId = isBuild
-      ? hashId(filePath, exportName)
-      : `${filePath}#${exportName}`;
+    const handleId = makeStubId(filePath, exportName, isBuild);
 
+    // Branch on the AST-derived argCount, not a string-trim of the raw arg
+    // slice. A comment-only arg list (`createHandle(/* meta */)`) trims to
+    // non-empty but is zero real arguments; injecting `, "id"` would emit
+    // `createHandle(/* meta */, "id")` — an elided first arg / syntax error.
     let paramInjection: string;
-    if (!args.hasArgs) {
+    if (binding.argCount === 0) {
       paramInjection = `undefined, "${handleId}"`;
     } else {
       paramInjection = `, "${handleId}"`;
@@ -58,9 +45,7 @@ export function transformLocationState(
   for (const binding of bindings) {
     const exportName = binding.exportNames[0];
 
-    const stateKey = isBuild
-      ? hashId(filePath, exportName)
-      : `${filePath}#${exportName}`;
+    const stateKey = makeStubId(filePath, exportName, isBuild);
 
     // Key is injected as a property assignment (not as a function argument).
     // This allows createLocationState to accept options like { flash: true }
@@ -73,10 +58,6 @@ export function transformLocationState(
   return hasChanges;
 }
 
-/**
- * Replace the entire file with lightweight stubs when ALL non-type exports are
- * handler calls of the given type. Returns null for files with mixed exports.
- */
 export function generateWholeFileStubs(
   cfg: HandlerTransformConfig,
   bindings: CreateExportBinding[],
@@ -88,35 +69,24 @@ export function generateWholeFileStubs(
 
   const exportNames = bindings.flatMap((b) => b.exportNames);
   const stubs = exportNames.map((name) => {
-    const handlerId = isBuild ? hashId(filePath, name) : `${filePath}#${name}`;
+    const handlerId = makeStubId(filePath, name, isBuild);
     return `export const ${name} = { __brand: "${cfg.brand}", $$id: "${handlerId}" };`;
   });
 
   return { code: stubs.join("\n") + "\n", map: null };
 }
 
-/**
- * Replace handler call expressions with lightweight stub objects in non-RSC
- * environments. Other exports, imports, and module-level code remain untouched.
- */
-export function generateExprStubs(
+export function stubHandlerExprs(
   cfg: HandlerTransformConfig,
   bindings: CreateExportBinding[],
-  code: string,
+  s: MagicString,
   filePath: string,
-  sourceId: string,
   isBuild: boolean,
-): { code: string; map: ReturnType<MagicString["generateMap"]> } | null {
-  if (bindings.length === 0) return null;
-
-  const s = new MagicString(code);
+): boolean {
   let hasChanges = false;
-
   for (const binding of bindings) {
     const exportName = binding.exportNames[0];
-    const handlerId = isBuild
-      ? hashId(filePath, exportName)
-      : `${filePath}#${exportName}`;
+    const handlerId = makeStubId(filePath, exportName, isBuild);
 
     s.overwrite(
       binding.callExprStart,
@@ -125,22 +95,9 @@ export function generateExprStubs(
     );
     hasChanges = true;
   }
-
-  if (!hasChanges) return null;
-
-  return {
-    code: s.toString(),
-    map: s.generateMap({
-      source: sourceId,
-      includeContent: true,
-      hires: "boundary",
-    }),
-  };
+  return hasChanges;
 }
 
-/**
- * Inject $$id into export const handler calls in RSC environments.
- */
 export function transformHandlerIds(
   cfg: HandlerTransformConfig,
   bindings: CreateExportBinding[],
@@ -152,14 +109,8 @@ export function transformHandlerIds(
   for (const binding of bindings) {
     const exportName = binding.exportNames[0];
 
-    const handlerId = isBuild
-      ? hashId(filePath, exportName)
-      : `${filePath}#${exportName}`;
+    const handlerId = makeStubId(filePath, exportName, isBuild);
 
-    // Injection strategy matches the runtime overload signatures:
-    //   0 args                              -> inject undefined, "id"
-    //   1 arg  (handler)                    -> inject , undefined, "id"
-    //   2+ args                             -> inject , "id"
     let paramInjection: string;
     if (binding.argCount === 0) {
       paramInjection = `undefined, "${handlerId}"`;

package/src/vite/plugins/expose-ids/loader-transform.ts

@@ -1,5 +1,5 @@
 import type MagicString from "magic-string";
-import { hashId } from "../expose-id-utils.js";
+import { makeStubId } from "../expose-id-utils.js";
 import type { CreateExportBinding } from "./types.js";
 import { isExportOnlyFile } from "./export-analysis.js";
 
@@ -9,18 +9,6 @@ export function hasCreateLoaderImport(code: string): boolean {
   );
 }
 
-/**
- * Generate lightweight client stubs for loader files.
- *
- * When a loader file is imported from a client component (e.g., for useLoader()),
- * the client only needs { __brand: "loader", $$id: "..." } objects.
- * This function replaces the entire file contents with just those stub exports,
- * preventing server-only data (constants, DB queries, etc.) from leaking into
- * the client bundle.
- *
- * Only applies when ALL named exports are createLoader() calls (plus type exports
- * which are erased at compile time). Files with mixed exports are left untouched.
- */
 export function generateClientLoaderStubs(
   bindings: CreateExportBinding[],
   code: string,
@@ -32,11 +20,18 @@ export function generateClientLoaderStubs(
   const lines: string[] = [];
 
   for (const binding of bindings) {
-    for (const name of binding.exportNames) {
-      const loaderId = isBuild ? hashId(filePath, name) : `${filePath}#${name}`;
-      lines.push(
-        `export const ${name} = { __brand: "loader", $$id: "${loaderId}" };`,
-      );
+    // Aliases share the primary export's id (matches the server side, which
+    // registers only exportNames[0] in the loader registry, and the mixed-type
+    // whole-file path). Emitting a distinct makeStubId per alias would make a
+    // client component importing the alias fetch an id absent from the server
+    // registry, so the fetchable-loader request would 404.
+    const primaryName = binding.exportNames[0];
+    const loaderId = makeStubId(filePath, primaryName, isBuild);
+    lines.push(
+      `export const ${primaryName} = { __brand: "loader", $$id: "${loaderId}" };`,
+    );
+    for (const alias of binding.exportNames.slice(1)) {
+      lines.push(`export const ${alias} = ${primaryName};`);
     }
   }
 
@@ -54,13 +49,8 @@ export function transformLoaders(
   for (const binding of bindings) {
     const exportName = binding.exportNames[0];
 
-    const loaderId = isBuild
-      ? hashId(filePath, exportName)
-      : `${filePath}#${exportName}`;
+    const loaderId = makeStubId(filePath, exportName, isBuild);
 
-    // Inject $$id as hidden third parameter.
-    // createLoader(fn) -> createLoader(fn, undefined, "id")
-    // createLoader(fn, true) -> createLoader(fn, true, "id")
     const paramInjection =
       binding.argCount === 1 ? `, undefined, "${loaderId}"` : `, "${loaderId}"`;
     s.appendLeft(binding.callCloseParenPos, paramInjection);

package/src/vite/plugins/expose-ids/router-transform.ts

@@ -2,22 +2,65 @@ import type { Plugin } from "vite";
 import MagicString from "magic-string";
 import path from "node:path";
 import { createHash } from "node:crypto";
-import { normalizePath, findMatchingParen } from "../expose-id-utils.js";
-import { getImportedFnNames } from "./export-analysis.js";
+import {
+  normalizePath,
+  findMatchingParen,
+  findCallParenAfterGenerics,
+  skipStringOrComment,
+} from "../expose-id-utils.js";
+import { escapeRegExp } from "../../../regex-escape.js";
+import {
+  getImportedFnNames,
+  buildUnsupportedShapeWarning,
+} from "./export-analysis.js";
+import { codeMatchIndices } from "../../../build/route-types/source-scan.js";
+import { createRangoDebugger, createCounter, NS } from "../../debug.js";
+
+const debug = createRangoDebugger(NS.transform);
+
+/**
+ * Advance past leading whitespace and a single leading line/block comment so a
+ * `createRouter(/* opts *\/ { ... })` call still resolves to its `{`. Only the
+ * first comment-or-whitespace run is skipped (enough for the common prefix
+ * case); a non-trivia token after it stops the scan.
+ */
+function skipLeadingTrivia(code: string, start: number, end: number): number {
+  let i = start;
+  while (i < end) {
+    const skipped = skipStringOrComment(code, i);
+    // skipStringOrComment only advances for strings/comments, not whitespace.
+    if (skipped > i) {
+      i = skipped;
+      continue;
+    }
+    if (/\s/.test(code[i])) {
+      i++;
+      continue;
+    }
+    break;
+  }
+  return i;
+}
 
 export function transformRouter(
   code: string,
   filePath: string,
   routerFnNames: string[],
   absolutePath?: string,
+  warn?: (message: string) => void,
 ): { code: string; map: ReturnType<MagicString["generateMap"]> } | null {
+  // Match only the callee identifier; the generic list (which may be nested,
+  // e.g. createRouter<Config<Env>>(...)) and the opening paren are located
+  // separately via findCallParenAfterGenerics so a nested `>` does not defeat
+  // the scan (a `<[^>]*>` regex stopped at the first `>`).
   const pat = new RegExp(
-    `\\b(?:${routerFnNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\s*(?:<[^>]*>)?\\s*\\(`,
+    `\\b(?:${routerFnNames.map(escapeRegExp).join("|")})\\b`,
     "g",
   );
   let match: RegExpExecArray | null;
   const s = new MagicString(code);
   let changed = false;
+  const unsupportedSites: Array<{ line: number; column: number }> = [];
 
   // Compute the import path for the generated route names file.
   // filePath is relative to project root (e.g., "src/router.tsx")
@@ -25,45 +68,76 @@ export function transformRouter(
   const routeNamesImport = `./${basename}.named-routes.gen.js`;
   const routeNamesVar = `__rsc_rn`;
 
+  // Only inject at call sites in REAL code, not inside comments or string
+  // literals — e.g. a `createRouter({ ... })` snippet in a JSDoc example must
+  // not get a `$$id`/`.named-routes.gen` import injected. The sibling analysis
+  // path (export-analysis.ts) already uses this same comment/string-aware scan;
+  // the raw `pat.exec(code)` loop below would otherwise match in comments too.
+  const codeOffsets = new Set(codeMatchIndices(code, pat));
+  pat.lastIndex = 0;
+
   while ((match = pat.exec(code)) !== null) {
+    if (!codeOffsets.has(match.index)) continue;
     const callStart = match.index;
-    const parenPos = match.index + match[0].length - 1;
+    const calleeEnd = match.index + match[0].length;
+
+    // Resolve the call's opening paren, skipping an optional (possibly nested)
+    // generic argument list. A non-call reference (e.g. a bare identifier or a
+    // type position) yields -1 and is skipped.
+    const parenPos = findCallParenAfterGenerics(code, calleeEnd);
+    if (parenPos === -1) continue;
 
-    // Scope the $$id check to within this call's arguments only,
-    // not the entire remaining file.
     const closeParen = findMatchingParen(code, parenPos + 1);
     const callArgs = code.slice(parenPos + 1, closeParen);
 
-    // Skip if $$id is already present in this call
-    if (callArgs.includes("$$id")) continue;
+    // Skip ONLY a call we already injected into. The injected marker is the
+    // unique `$$routeNames: <var>` property; a bare `$$id` substring check
+    // would also match a user value/comment that merely contains the text
+    // "$$id" (e.g. `createRouter({ meta: { note: "see $$id docs" } })`),
+    // silently dropping named-route wiring for a legitimate config.
+    if (callArgs.includes(`$$routeNames: ${routeNamesVar}`)) continue;
 
-    // Compute line number for this call
+    const sourceFilePath = absolutePath ?? filePath;
     const lineNumber = code.slice(0, callStart).split("\n").length;
     const hash = createHash("sha256")
       .update(`${filePath}:${lineNumber}`)
       .digest("hex")
       .slice(0, 8);
-
-    changed = true;
-    // $$sourceFile uses the absolute path so that downstream consumers
-    // (virtual-module-codegen, runtime-discovery) can resolve gen file
-    // imports correctly via path.dirname / path.join.
-    const sourceFilePath = absolutePath ?? filePath;
     const injected = ` $$id: "${hash}", $$sourceFile: "${sourceFilePath}", $$routeNames: ${routeNamesVar},`;
 
-    const afterParen = callArgs.trimStart();
-    if (afterParen.startsWith("{")) {
-      const bracePos = code.indexOf("{", parenPos + 1);
-      s.appendRight(bracePos + 1, injected);
-    } else if (afterParen.startsWith(")")) {
+    // Skip a leading comment/whitespace run so `createRouter(/* c *\/ {...})`
+    // and a newline-then-comment prefix still resolve to the object literal.
+    // findMatchingParen returns one past the close `)`, so the matching paren
+    // sits at closeParen - 1 and empty args resolve to that `)`.
+    const argsContentStart = skipLeadingTrivia(code, parenPos + 1, closeParen);
+    const firstArgChar = code[argsContentStart];
+
+    if (firstArgChar === "{") {
+      changed = true;
+      s.appendRight(argsContentStart + 1, injected);
+    } else if (argsContentStart >= closeParen - 1) {
+      // Empty args: createRouter(). Wrap a fresh config object.
+      changed = true;
       s.appendRight(parenPos + 1, `{${injected} }`);
+    } else {
+      // Unsupported argument shape (bare identifier, spread, call, etc.). No
+      // stable $$id can be injected here. Record it so the plugin can warn —
+      // and crucially do NOT mark changed, so a dead named-routes.gen import is
+      // not prepended for a call we never touched.
+      const lastNl = code.lastIndexOf("\n", callStart - 1);
+      const column = callStart - (lastNl + 1) + 1;
+      unsupportedSites.push({ line: lineNumber, column });
     }
   }
 
+  if (unsupportedSites.length > 0 && warn) {
+    warn(
+      buildUnsupportedShapeWarning(filePath, "createRouter", unsupportedSites),
+    );
+  }
+
   if (!changed) return null;
 
-  // Prepend the static import as the first line. MagicString tracks the
-  // offset so all downstream source maps remain correct.
   s.prepend(
     `import { NamedRoutes as ${routeNamesVar} } from "${routeNamesImport}";\n`,
   );
@@ -82,17 +156,17 @@ export function transformRouter(
  */
 export function exposeRouterId(): Plugin {
   let projectRoot = "";
+  const counter = createCounter(debug, "expose-router-id");
   return {
     name: "@rangojs/router:expose-router-id",
     configResolved(config) {
       projectRoot = config.root;
     },
+    buildEnd() {
+      counter?.flush();
+    },
     transform(code, id) {
       if (!code.includes("createRouter")) return null;
-      // Accepts both @rangojs/router and @rangojs/router/server subpath.
-      // NOTE: detectImports in expose-id-utils has a stricter check that
-      // excludes /server for its router flag -- that's intentional since
-      // detectImports is only used in exposeInternalIds, not here.
       if (
         !/import\s*\{[^}]*\bcreateRouter\b[^}]*\}\s*from\s*["']@rangojs\/router(?:\/server)?["']/.test(
           code,
@@ -102,9 +176,24 @@ export function exposeRouterId(): Plugin {
       }
       if (id.includes("node_modules")) return null;
 
-      const filePath = normalizePath(path.relative(projectRoot, id));
-      const routerFnNames = getImportedFnNames(code, "createRouter");
-      return transformRouter(code, filePath, routerFnNames, normalizePath(id));
+      const start = counter ? performance.now() : 0;
+      try {
+        const filePath = normalizePath(path.relative(projectRoot, id));
+        const routerFnNames = getImportedFnNames(code, "createRouter");
+        const warn =
+          typeof this.warn === "function"
+            ? (message: string) => this.warn(message)
+            : undefined;
+        return transformRouter(
+          code,
+          filePath,
+          routerFnNames,
+          normalizePath(id),
+          warn,
+        );
+      } finally {
+        counter?.record(id, performance.now() - start);
+      }
     },
   };
 }