@rangojs/router 0.0.0-experimental.2 → 0.0.0-experimental.20

package/src/vite/discovery/discover-routers.ts

@@ -0,0 +1,345 @@
+/**
+ * Router Discovery
+ *
+ * Core discovery logic: imports the user's entry file via the RSC
+ * environment's module runner, generates manifests for each discovered
+ * router, and builds route tries for O(path_length) matching.
+ */
+
+import {
+  buildCombinedRouteMapForRouterFile,
+  formatNestedRouterConflictError,
+  findNestedRouterConflict,
+} from "../../build/generate-route-types.js";
+import {
+  flattenLeafEntries,
+  buildRouteToStaticPrefix,
+} from "../utils/manifest-utils.js";
+import type { DiscoveryState, PrecomputedEntry } from "./state.js";
+import {
+  expandPrerenderRoutes,
+  renderStaticHandlers,
+} from "./prerender-collection.js";
+
+/**
+ * Import the user's entry via RSC runner, generate manifests for each
+ * discovered router, build route tries, and optionally run prerender
+ * expansion and static handler rendering (build mode only).
+ *
+ * Returns the imported `@rangojs/router/server` module so the caller
+ * can access the RouterRegistry and manifest setters.
+ */
+export async function discoverRouters(
+  state: DiscoveryState,
+  rscEnv: any,
+): Promise<any> {
+  if (!state.resolvedEntryPath) return;
+
+  // Import the entry file via RSC environment.
+  // For node preset: this is the router file (createRouter() registers in RouterRegistry).
+  // For cloudflare preset: this is the worker entry (which imports the router).
+  await rscEnv.runner.import(state.resolvedEntryPath);
+
+  // Import the router package to access the registry
+  const serverMod = await rscEnv.runner.import("@rangojs/router/server");
+  let registry: Map<string, any> = serverMod.RouterRegistry;
+
+  if (!registry || registry.size === 0) {
+    // No RSC routers found directly. Check for host routers with lazy handlers
+    // that need to be resolved to trigger sub-app createRouter() calls.
+    try {
+      const hostMod = await rscEnv.runner.import("@rangojs/router/host");
+      const hostRegistry: Map<string, any> | undefined =
+        hostMod.HostRouterRegistry;
+
+      if (hostRegistry && hostRegistry.size > 0) {
+        console.log(
+          `[rsc-router] Found ${hostRegistry.size} host router(s), resolving lazy handlers...`,
+        );
+
+        for (const [, entry] of hostRegistry) {
+          for (const route of entry.routes) {
+            if (typeof route.handler === "function") {
+              try {
+                await route.handler();
+              } catch {
+                // Lazy handler may fail in temp server context, that's OK
+              }
+            }
+          }
+          if (entry.fallback && typeof entry.fallback.handler === "function") {
+            try {
+              await entry.fallback.handler();
+            } catch {
+              // Fallback handler may fail in temp server context
+            }
+          }
+        }
+
+        // Re-read RouterRegistry - sub-app createRouter() calls should have populated it
+        const freshServerMod = await rscEnv.runner.import(
+          "@rangojs/router/server",
+        );
+        const freshRegistry: Map<string, any> = freshServerMod.RouterRegistry;
+
+        if (freshRegistry && freshRegistry.size > 0) {
+          // Update references so the manifest generation below uses the fresh data
+          Object.assign(serverMod, freshServerMod);
+          registry = freshRegistry;
+        }
+      }
+    } catch {
+      // @rangojs/router/host not available or import failed, skip
+    }
+
+    // If still no routers after host router resolution, fail
+    if (!registry || registry.size === 0) {
+      throw new Error(
+        `[rsc-router] No routers found in registry after importing ${state.resolvedEntryPath}`,
+      );
+    }
+  }
+
+  // Import build utilities for manifest generation
+  const buildMod = await rscEnv.runner.import("@rangojs/router/build");
+  const generateManifestFull = buildMod.generateManifestFull;
+
+  const nestedRouterConflict = findNestedRouterConflict(
+    [...registry.values()]
+      .map((router) => router.__sourceFile)
+      .filter(
+        (sourceFile): sourceFile is string => typeof sourceFile === "string",
+      ),
+  );
+  if (nestedRouterConflict) {
+    throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
+  }
+
+  // Build into local variables first. Only commit to state after the
+  // full pass succeeds, so a failed re-discovery preserves the last
+  // known-good state instead of leaving it partially wiped.
+  const newMergedRouteManifest: Record<string, string> = {};
+  const newMergedPrecomputedEntries: PrecomputedEntry[] = [];
+  const newPerRouterManifests: typeof state.perRouterManifests = [];
+  const newPerRouterManifestDataMap = new Map<string, any>();
+  const newPerRouterPrecomputedMap = new Map<string, PrecomputedEntry[]>();
+  const newPerRouterTrieMap = new Map<string, any>();
+  let mergedRouteAncestry: Record<string, string[]> = {};
+  let mergedRouteTrailingSlash: Record<string, string> = {};
+
+  let routerMountIndex = 0;
+  // Collect all manifests for trie building (avoid re-running generateManifest)
+  const allManifests: Array<{ id: string; manifest: any }> = [];
+
+  for (const [id, router] of registry) {
+    if (!router.urlpatterns || !generateManifestFull) {
+      continue;
+    }
+
+    const manifest = generateManifestFull(router.urlpatterns, routerMountIndex);
+    routerMountIndex++;
+    allManifests.push({ id, manifest });
+    const routeCount = Object.keys(manifest.routeManifest).length;
+    const staticRoutes = Object.values(manifest.routeManifest).filter(
+      (p: any) => !p.includes(":") && !p.includes("*"),
+    ).length;
+    const dynamicRoutes = routeCount - staticRoutes;
+
+    // Merge into the combined manifest
+    Object.assign(newMergedRouteManifest, manifest.routeManifest);
+
+    // Compute factory-only prefixes: dot-prefixed groups in the runtime
+    // manifest that the static parser cannot see. These are routes created
+    // by factory functions (e.g. createDocsPatterns()) and should always be
+    // supplemented on file change since HMR won't re-discover them.
+    let factoryOnlyPrefixes: Set<string> | undefined;
+    if (router.__sourceFile) {
+      const staticParsed = buildCombinedRouteMapForRouterFile(
+        router.__sourceFile,
+      );
+      const staticNames = new Set(Object.keys(staticParsed.routes));
+      factoryOnlyPrefixes = new Set<string>();
+      for (const name of Object.keys(manifest.routeManifest)) {
+        if (staticNames.has(name)) continue;
+        const dotIdx = name.indexOf(".");
+        if (dotIdx <= 0) continue;
+        const prefix = name.substring(0, dotIdx + 1);
+        if ([...staticNames].some((n) => n.startsWith(prefix))) continue;
+        factoryOnlyPrefixes.add(prefix);
+      }
+      if (factoryOnlyPrefixes.size === 0) factoryOnlyPrefixes = undefined;
+    }
+
+    newPerRouterManifests.push({
+      id,
+      routeManifest: manifest.routeManifest,
+      routeSearchSchemas: manifest.routeSearchSchemas,
+      sourceFile: router.__sourceFile,
+      factoryOnlyPrefixes,
+    });
+
+    // Merge ancestry (internal field, used only for trie building)
+    if (manifest._routeAncestry) {
+      Object.assign(mergedRouteAncestry, manifest._routeAncestry);
+    }
+    // Merge trailing slash config
+    if (manifest.routeTrailingSlash) {
+      Object.assign(mergedRouteTrailingSlash, manifest.routeTrailingSlash);
+    }
+
+    // Flatten prefix tree leaf nodes into precomputed entries.
+    // Leaf nodes (no children) can have their routes used directly by
+    // evaluateLazyEntry() without running the handler at runtime.
+    flattenLeafEntries(
+      manifest.prefixTree,
+      manifest.routeManifest,
+      newMergedPrecomputedEntries,
+    );
+
+    // Store per-router manifest and precomputed entries for isolated virtual modules.
+    newPerRouterManifestDataMap.set(id, manifest.routeManifest);
+    const routerPrecomputed: PrecomputedEntry[] = [];
+    flattenLeafEntries(
+      manifest.prefixTree,
+      manifest.routeManifest,
+      routerPrecomputed,
+    );
+    newPerRouterPrecomputedMap.set(id, routerPrecomputed);
+
+    console.log(
+      `[rsc-router] Router "${id}" -> ${routeCount} routes ` +
+        `(${staticRoutes} static, ${dynamicRoutes} dynamic)`,
+    );
+  }
+
+  // Warn if multiple routers use auto-generated IDs (router_0, router_1, ...).
+  // Auto-IDs are assigned by counter and depend on module evaluation order,
+  // which can differ between build time and runtime (especially with dynamic
+  // imports in host routers). This causes per-router data to be loaded into
+  // the wrong router at runtime.
+  if (registry.size > 1) {
+    const autoIds = [...registry.keys()].filter((id) =>
+      /^router_\d+$/.test(id),
+    );
+    if (autoIds.length > 1) {
+      console.warn(
+        `[rsc-router] WARNING: ${autoIds.length} routers use auto-generated IDs (${autoIds.join(", ")}). ` +
+          `In multi-router setups, each createRouter() must have an explicit \`id\` option ` +
+          `to ensure per-router manifest data is matched correctly at runtime. ` +
+          `Example: createRouter({ id: "site", ... })`,
+      );
+    }
+  }
+
+  // Build route trie from merged manifest + ancestry
+  let newMergedRouteTrie: any = null;
+  if (Object.keys(newMergedRouteManifest).length > 0) {
+    const buildRouteTrie = buildMod.buildRouteTrie;
+    if (buildRouteTrie && mergedRouteAncestry) {
+      // Build routeToStaticPrefix from saved manifests
+      const routeToStaticPrefix: Record<string, string> = {};
+      for (const { manifest } of allManifests) {
+        // Root-level routes have empty static prefix
+        for (const name of Object.keys(manifest.routeManifest)) {
+          if (!(name in routeToStaticPrefix)) {
+            routeToStaticPrefix[name] = "";
+          }
+        }
+        buildRouteToStaticPrefix(manifest.prefixTree, routeToStaticPrefix);
+      }
+
+      // Collect prerender route names and response type routes from all manifests
+      const prerenderRouteNames = new Set<string>();
+      const passthroughRouteNames = new Set<string>();
+      const mergedResponseTypeRoutes: Record<string, string> = {};
+      for (const { manifest } of allManifests) {
+        if (manifest.prerenderRoutes) {
+          for (const name of manifest.prerenderRoutes) {
+            prerenderRouteNames.add(name);
+          }
+        }
+        if (manifest.passthroughRoutes) {
+          for (const name of manifest.passthroughRoutes) {
+            passthroughRouteNames.add(name);
+          }
+        }
+        if (manifest.responseTypeRoutes) {
+          Object.assign(mergedResponseTypeRoutes, manifest.responseTypeRoutes);
+        }
+      }
+
+      newMergedRouteTrie = buildRouteTrie(
+        newMergedRouteManifest,
+        mergedRouteAncestry,
+        routeToStaticPrefix,
+        Object.keys(mergedRouteTrailingSlash).length > 0
+          ? mergedRouteTrailingSlash
+          : undefined,
+        prerenderRouteNames.size > 0 ? prerenderRouteNames : undefined,
+        passthroughRouteNames.size > 0 ? passthroughRouteNames : undefined,
+        Object.keys(mergedResponseTypeRoutes).length > 0
+          ? mergedResponseTypeRoutes
+          : undefined,
+      );
+
+      // Build per-router tries for multi-router isolation.
+      for (const { id, manifest } of allManifests) {
+        if (
+          !manifest._routeAncestry ||
+          Object.keys(manifest._routeAncestry).length === 0
+        )
+          continue;
+        const perRouterStaticPrefix: Record<string, string> = {};
+        for (const name of Object.keys(manifest.routeManifest)) {
+          perRouterStaticPrefix[name] = "";
+        }
+        buildRouteToStaticPrefix(manifest.prefixTree, perRouterStaticPrefix);
+
+        const perRouterPrerenderNames = manifest.prerenderRoutes
+          ? new Set<string>(manifest.prerenderRoutes)
+          : undefined;
+        const perRouterPassthroughNames = manifest.passthroughRoutes
+          ? new Set<string>(manifest.passthroughRoutes)
+          : undefined;
+
+        const perRouterTrie = buildRouteTrie(
+          manifest.routeManifest,
+          manifest._routeAncestry,
+          perRouterStaticPrefix,
+          manifest.routeTrailingSlash &&
+            Object.keys(manifest.routeTrailingSlash).length > 0
+            ? manifest.routeTrailingSlash
+            : undefined,
+          perRouterPrerenderNames && perRouterPrerenderNames.size > 0
+            ? perRouterPrerenderNames
+            : undefined,
+          perRouterPassthroughNames && perRouterPassthroughNames.size > 0
+            ? perRouterPassthroughNames
+            : undefined,
+          manifest.responseTypeRoutes &&
+            Object.keys(manifest.responseTypeRoutes).length > 0
+            ? manifest.responseTypeRoutes
+            : undefined,
+        );
+        newPerRouterTrieMap.set(id, perRouterTrie);
+      }
+    }
+  }
+
+  // Commit all local state to the shared discovery state atomically.
+  // This ensures a failed re-discovery (e.g. from a transient module
+  // evaluation error) preserves the last known-good state.
+  state.mergedRouteManifest = newMergedRouteManifest;
+  state.mergedPrecomputedEntries = newMergedPrecomputedEntries;
+  state.perRouterManifests = newPerRouterManifests;
+  state.perRouterManifestDataMap = newPerRouterManifestDataMap;
+  state.perRouterPrecomputedMap = newPerRouterPrecomputedMap;
+  state.perRouterTrieMap = newPerRouterTrieMap;
+  state.mergedRouteTrie = newMergedRouteTrie;
+
+  // Expand prerender routes and render static handlers (build mode only)
+  await expandPrerenderRoutes(state, rscEnv, registry, allManifests);
+  await renderStaticHandlers(state, rscEnv, registry);
+
+  return serverMod;
+}

package/src/vite/discovery/prerender-collection.ts

@@ -0,0 +1,365 @@
+/**
+ * Prerender Collection
+ *
+ * Expands prerender routes into concrete URLs and renders them at build
+ * time. Also handles Static handler rendering for segment-level static
+ * generation.
+ */
+
+import { contextSet } from "../../context-var.js";
+import {
+  encodePathParam,
+  substituteRouteParams,
+  runWithConcurrency,
+  groupByConcurrency,
+  notifyOnError,
+} from "../utils/prerender-utils.js";
+import type { DiscoveryState } from "./state.js";
+
+/**
+ * Expand prerender routes into concrete URLs and render them via the
+ * RSC runner. Stores collected data in state.prerenderCollectedData.
+ */
+export async function expandPrerenderRoutes(
+  state: DiscoveryState,
+  rscEnv: any,
+  registry: Map<string, any>,
+  allManifests: Array<{ id: string; manifest: any }>,
+): Promise<void> {
+  if (!state.opts?.enableBuildPrerender || !state.isBuildMode) return;
+
+  type PrerenderEntry = {
+    urlPath: string;
+    routeName: string;
+    concurrency: number;
+    buildVars?: Record<string, any>;
+    isPassthroughRoute?: boolean;
+  };
+  const entries: PrerenderEntry[] = [];
+
+  // Build a merged route map for getParams context reverse()
+  const allRoutes: Record<string, string> = {};
+  for (const { manifest: m } of allManifests) {
+    if (m.routeManifest) Object.assign(allRoutes, m.routeManifest);
+  }
+  const getParamsReverse = (name: string, params?: Record<string, string>) => {
+    const pattern = allRoutes[name];
+    if (!pattern) throw new Error(`Unknown route: "${name}"`);
+    if (!params) return pattern;
+    return substituteRouteParams(pattern, params);
+  };
+
+  for (const { manifest } of allManifests) {
+    if (!manifest.prerenderRoutes) continue;
+    const defs = manifest._prerenderDefs || {};
+    for (const routeName of manifest.prerenderRoutes) {
+      const pattern = manifest.routeManifest[routeName];
+      if (!pattern) continue;
+      const def = defs[routeName];
+      const isPassthroughRoute = !!def?.options?.passthrough;
+      const hasDynamic = pattern.includes(":") || pattern.includes("*");
+      if (!hasDynamic) {
+        // Static route: use pattern directly (strip trailing slash for URL)
+        entries.push({
+          urlPath: pattern.replace(/\/$/, "") || "/",
+          routeName,
+          concurrency: 1,
+          isPassthroughRoute,
+        });
+      } else {
+        // Dynamic route: call getParams() to enumerate param combinations
+        if (def?.getParams) {
+          try {
+            const buildVars: Record<string, any> = {};
+            const getParamsCtx = {
+              build: true as const,
+              set: ((keyOrVar: any, value: any) => {
+                contextSet(buildVars, keyOrVar, value);
+              }) as any,
+              reverse: getParamsReverse,
+            };
+            const paramsList = await def.getParams(getParamsCtx);
+            const concurrency = def.options?.concurrency ?? 1;
+            const hasBuildVars =
+              Object.keys(buildVars).length > 0 ||
+              Object.getOwnPropertySymbols(buildVars).length > 0;
+            for (const params of paramsList) {
+              let url = substituteRouteParams(
+                pattern,
+                params as Record<string, string>,
+                encodePathParam,
+              );
+              // Anonymous wildcard fallback: use conventional keys if provided
+              if (url.includes("*")) {
+                const wildcardValue =
+                  (params as Record<string, string>)["*"] ??
+                  (params as Record<string, string>).splat;
+                if (wildcardValue !== undefined) {
+                  url = url.replace(/\*[^/]*$/, encodePathParam(wildcardValue));
+                }
+              }
+              entries.push({
+                urlPath: url.replace(/\/$/, "") || "/",
+                routeName,
+                concurrency,
+                ...(hasBuildVars ? { buildVars } : {}),
+                isPassthroughRoute,
+              });
+            }
+          } catch (err: any) {
+            // Skip in getParams() skips the entire route
+            if (err.name === "Skip") {
+              console.log(
+                `[rsc-router]   SKIP route "${routeName}" - ${err.message}`,
+              );
+              notifyOnError(
+                registry,
+                err,
+                "prerender",
+                routeName,
+                undefined,
+                true,
+              );
+              continue;
+            }
+            // Regular error: fail the build
+            console.error(
+              `[rsc-router] Failed to get params for prerender route "${routeName}": ${err.message}`,
+            );
+            notifyOnError(registry, err, "prerender", routeName);
+            throw err;
+          }
+        } else {
+          console.warn(
+            `[rsc-router] Dynamic prerender route "${routeName}" has no getParams(), skipping`,
+          );
+        }
+      }
+    }
+  }
+
+  if (entries.length === 0) return;
+
+  // Determine the max concurrency for the log header
+  const maxConcurrency = Math.max(...entries.map((e) => e.concurrency));
+  const concurrencyNote =
+    maxConcurrency > 1 ? ` (concurrency: ${maxConcurrency})` : "";
+  console.log(
+    `[rsc-router] Pre-rendering ${entries.length} URL(s)${concurrencyNote}...`,
+  );
+
+  const { hashParams } = await rscEnv.runner.import("@rangojs/router/build");
+
+  const collectedData: Record<string, any> = {};
+  let doneCount = 0;
+  let skipCount = 0;
+  const startTotal = performance.now();
+
+  // Group entries by concurrency for batched rendering.
+  // Within each group, all entries share the same concurrency limit.
+  const groups = groupByConcurrency(entries);
+
+  for (const group of groups) {
+    await runWithConcurrency(
+      group.entries,
+      group.concurrency,
+      async (entry) => {
+        const startUrl = performance.now();
+        for (const [, routerInstance] of registry) {
+          if (!routerInstance.matchForPrerender) continue;
+          try {
+            const result = await routerInstance.matchForPrerender(
+              entry.urlPath,
+              {},
+              entry.buildVars,
+              entry.isPassthroughRoute,
+            );
+            if (!result) continue;
+
+            // Handler returned ctx.passthrough() — skip manifest entry
+            if (result.passthrough) {
+              const elapsed = (performance.now() - startUrl).toFixed(0);
+              console.log(
+                `[rsc-router]   PASS ${entry.urlPath.padEnd(40)} (${elapsed}ms) - live fallback`,
+              );
+              doneCount++;
+              break;
+            }
+
+            const paramHash = hashParams(result.params || {});
+            collectedData[`${result.routeName}/${paramHash}`] = {
+              segments: result.segments,
+              handles: result.handles,
+            };
+            if (result.interceptSegments?.length) {
+              collectedData[`${result.routeName}/${paramHash}/i`] = {
+                segments: [...result.segments, ...result.interceptSegments],
+                handles: {
+                  ...result.handles,
+                  ...(result.interceptHandles || {}),
+                },
+              };
+            }
+            const elapsed = (performance.now() - startUrl).toFixed(0);
+            console.log(
+              `[rsc-router]   OK   ${entry.urlPath.padEnd(40)} (${elapsed}ms)`,
+            );
+            doneCount++;
+            break;
+          } catch (err: any) {
+            if (err.name === "Skip") {
+              const elapsed = (performance.now() - startUrl).toFixed(0);
+              console.log(
+                `[rsc-router]   SKIP ${entry.urlPath.padEnd(40)} (${elapsed}ms) - ${err.message}`,
+              );
+              skipCount++;
+              notifyOnError(
+                registry,
+                err,
+                "prerender",
+                entry.routeName,
+                entry.urlPath,
+                true,
+              );
+              break;
+            }
+            // Regular error: log, notify, and fail the build
+            const elapsed = (performance.now() - startUrl).toFixed(0);
+            console.error(
+              `[rsc-router]   FAIL ${entry.urlPath.padEnd(40)} (${elapsed}ms) - ${err.message}`,
+            );
+            notifyOnError(
+              registry,
+              err,
+              "prerender",
+              entry.routeName,
+              entry.urlPath,
+            );
+            throw err;
+          }
+        }
+      },
+    );
+  }
+
+  const totalElapsed = (performance.now() - startTotal).toFixed(0);
+  if (doneCount > 0) {
+    state.prerenderCollectedData = collectedData;
+  }
+  const parts = [`${doneCount} done`];
+  if (skipCount > 0) parts.push(`${skipCount} skipped`);
+  console.log(
+    `[rsc-router] Pre-render complete: ${parts.join(", ")} (${totalElapsed}ms total)`,
+  );
+}
+
+/**
+ * Render Static handlers at build time. Each Static handler is called
+ * with a synthetic BuildContext and its output is RSC-serialized.
+ * Stores collected data in state.staticCollectedData.
+ */
+export async function renderStaticHandlers(
+  state: DiscoveryState,
+  rscEnv: any,
+  registry: Map<string, any>,
+): Promise<void> {
+  if (
+    !state.opts?.enableBuildPrerender ||
+    !state.isBuildMode ||
+    !state.resolvedStaticModules?.size
+  )
+    return;
+
+  const collected: Record<
+    string,
+    { encoded: string; handles: Record<string, unknown[]> }
+  > = {};
+  let staticDone = 0;
+  let staticSkip = 0;
+  let totalStaticCount = 0;
+
+  // Count handlers for the log header
+  for (const [, exportNames] of state.resolvedStaticModules) {
+    totalStaticCount += exportNames.length;
+  }
+  const startStatic = performance.now();
+  console.log(
+    `[rsc-router] Rendering ${totalStaticCount} static handler(s)...`,
+  );
+
+  for (const [moduleId, exportNames] of state.resolvedStaticModules) {
+    let mod: any;
+    try {
+      mod = await rscEnv!.runner.import(moduleId);
+    } catch (err: any) {
+      console.error(
+        `[rsc-router] Failed to import static module ${moduleId}: ${err.message}`,
+      );
+      notifyOnError(registry, err, "static");
+      throw err;
+    }
+
+    for (const name of exportNames) {
+      const def = mod[name];
+      if (!def || def.__brand !== "staticHandler" || !def.$$id) continue;
+      // Passthrough handlers stay live in the bundle
+      if (def.options?.passthrough) continue;
+
+      const startHandler = performance.now();
+      let handled = false;
+      for (const [, routerInstance] of registry) {
+        if (!routerInstance.renderStaticSegment) continue;
+        try {
+          const result = await routerInstance.renderStaticSegment(
+            def.handler,
+            def.$$id,
+            (def as any).$$routePrefix,
+          );
+          if (result) {
+            collected[def.$$id] = result;
+            const elapsed = (performance.now() - startHandler).toFixed(0);
+            console.log(
+              `[rsc-router]   OK   ${name.padEnd(40)} (${elapsed}ms)`,
+            );
+            staticDone++;
+            handled = true;
+            break;
+          }
+        } catch (err: any) {
+          if (err.name === "Skip") {
+            const elapsed = (performance.now() - startHandler).toFixed(0);
+            console.log(
+              `[rsc-router]   SKIP ${name.padEnd(40)} (${elapsed}ms) - ${err.message}`,
+            );
+            staticSkip++;
+            notifyOnError(registry, err, "static", undefined, undefined, true);
+            handled = true;
+            break;
+          }
+          // Regular error: log, notify, and fail the build
+          const elapsed = (performance.now() - startHandler).toFixed(0);
+          console.error(
+            `[rsc-router]   FAIL ${name.padEnd(40)} (${elapsed}ms) - ${err.message}`,
+          );
+          notifyOnError(registry, err, "static");
+          throw err;
+        }
+      }
+      if (!handled) {
+        console.warn(
+          `[rsc-router] No router could render static handler "${name}"`,
+        );
+      }
+    }
+  }
+
+  const totalStaticElapsed = (performance.now() - startStatic).toFixed(0);
+  if (staticDone > 0) {
+    state.staticCollectedData = collected;
+  }
+  const staticParts = [`${staticDone} done`];
+  if (staticSkip > 0) staticParts.push(`${staticSkip} skipped`);
+  console.log(
+    `[rsc-router] Static render complete: ${staticParts.join(", ")} (${totalStaticElapsed}ms total)`,
+  );
+}