@rangojs/router 0.0.0-experimental.10 → 0.0.0-experimental.100

package/src/vite/discovery/route-types-writer.ts

@@ -0,0 +1,258 @@
+/**
+ * Route Types Writer
+ *
+ * Generates and writes TypeScript route type files (named-routes.gen.ts)
+ * from discovered router manifests and static source parsing.
+ */
+
+import { dirname, basename, join, resolve } from "node:path";
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from "node:fs";
+import {
+  generateRouteTypesSource,
+  writeCombinedRouteTypes,
+  findRouterFiles,
+  buildCombinedRouteMapForRouterFile,
+} from "../../build/generate-route-types.js";
+import type { DiscoveryState } from "./state.js";
+import { markSelfGenWrite } from "./self-gen-tracking.js";
+import { isAutoGeneratedRouteName } from "../../route-name.js";
+
+/**
+ * Filter out auto-generated route names from a manifest.
+ * Unnamed routes get "$path_"-prefixed names at runtime (see path-helper.ts).
+ * These should not appear in the typed gen file. User-defined names
+ * containing "$" (e.g. "$admin") are valid and preserved.
+ */
+function filterUserNamedRoutes(
+  manifest: Record<string, string>,
+): Record<string, string> {
+  const filtered: Record<string, string> = {};
+  for (const [name, pattern] of Object.entries(manifest)) {
+    if (!isAutoGeneratedRouteName(name)) {
+      filtered[name] = pattern;
+    }
+  }
+  return filtered;
+}
+
+/**
+ * Write combined route types for all router files.
+ * Only writes when content has changed to avoid triggering HMR loops.
+ */
+export function writeCombinedRouteTypesWithTracking(
+  state: DiscoveryState,
+  opts?: { preserveIfLarger?: boolean },
+): void {
+  const routerFiles =
+    state.cachedRouterFiles ??
+    findRouterFiles(state.projectRoot, state.scanFilter);
+  state.cachedRouterFiles = routerFiles;
+
+  // Snapshot pre-write content to detect which files actually change.
+  const preContent = new Map<string, string>();
+  for (const routerFilePath of routerFiles) {
+    const routerDir = dirname(routerFilePath);
+    const routerBasename = basename(routerFilePath).replace(
+      /\.(tsx?|jsx?)$/,
+      "",
+    );
+    const outPath = join(routerDir, `${routerBasename}.named-routes.gen.ts`);
+    try {
+      preContent.set(outPath, readFileSync(outPath, "utf-8"));
+    } catch {
+      // File doesn't exist yet — any write is a real change.
+    }
+  }
+
+  writeCombinedRouteTypes(state.projectRoot, routerFiles, opts);
+
+  // Mark only files that were actually written so the watcher can
+  // distinguish self-triggered change events from manual edits.
+  // Marking unchanged files creates stale entries that interfere with
+  // multi-server setups (e.g. shared webServer + isolated HMR server).
+  for (const routerFilePath of routerFiles) {
+    const routerDir = dirname(routerFilePath);
+    const routerBasename = basename(routerFilePath).replace(
+      /\.(tsx?|jsx?)$/,
+      "",
+    );
+    const outPath = join(routerDir, `${routerBasename}.named-routes.gen.ts`);
+    if (!existsSync(outPath)) continue;
+    try {
+      const content = readFileSync(outPath, "utf-8");
+      if (content !== preContent.get(outPath)) {
+        markSelfGenWrite(state, outPath, content);
+      }
+    } catch {
+      // Ignore transient fs errors while files are being rewritten.
+    }
+  }
+}
+
+/**
+ * Write per-router route types files from runtime discovery data.
+ */
+export function writeRouteTypesFiles(state: DiscoveryState): void {
+  if (state.perRouterManifests.length === 0) return;
+
+  // Delete old combined named-routes.gen.ts if it exists
+  try {
+    const entryDir = dirname(
+      resolve(state.projectRoot, state.resolvedEntryPath!),
+    );
+    const oldCombinedPath = join(entryDir, "named-routes.gen.ts");
+    if (existsSync(oldCombinedPath)) {
+      unlinkSync(oldCombinedPath);
+      console.log(
+        `[rsc-router] Removed stale combined route types: ${oldCombinedPath}`,
+      );
+    }
+  } catch {}
+
+  for (const {
+    id,
+    routeManifest,
+    routeSearchSchemas,
+    sourceFile,
+  } of state.perRouterManifests) {
+    if (!sourceFile) continue;
+
+    // Validate sourceFile points to a real project file, not node_modules or
+    // a Vite internal path. A bad sourceFile leads to route types written to
+    // the wrong location, causing non-deterministic type resolution.
+    if (sourceFile.includes("node_modules")) {
+      throw new Error(
+        `[rsc-router] Router "${id}" has sourceFile inside node_modules: ${sourceFile}\n` +
+          `This means createRouter() stack trace parsing matched a Vite internal frame.\n` +
+          `Set an explicit \`id\` on createRouter() or check the call site.`,
+      );
+    }
+
+    const routerDir = dirname(sourceFile);
+    const routerBasename = basename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
+    const outPath = join(routerDir, `${routerBasename}.named-routes.gen.ts`);
+
+    // Filter out auto-generated route names (e.g. "$path____debug_reverse-test")
+    // to match the static parser's output and prevent HMR oscillation.
+    const userRoutes = filterUserNamedRoutes(routeManifest);
+    let effectiveSearchSchemas = routeSearchSchemas;
+
+    // Runtime manifest may omit search schema metadata in some module-runner
+    // flows. Fall back to static source parsing from the router file.
+    if (
+      (!effectiveSearchSchemas ||
+        Object.keys(effectiveSearchSchemas).length === 0) &&
+      sourceFile
+    ) {
+      const staticParsed = buildCombinedRouteMapForRouterFile(sourceFile);
+      if (Object.keys(staticParsed.searchSchemas).length > 0) {
+        const filtered: Record<string, Record<string, string>> = {};
+        for (const name of Object.keys(userRoutes)) {
+          const schema = staticParsed.searchSchemas[name];
+          if (schema) filtered[name] = schema;
+        }
+        if (Object.keys(filtered).length > 0) {
+          effectiveSearchSchemas = filtered;
+        }
+      }
+    }
+
+    const source = generateRouteTypesSource(
+      userRoutes,
+      effectiveSearchSchemas && Object.keys(effectiveSearchSchemas).length > 0
+        ? effectiveSearchSchemas
+        : undefined,
+    );
+    const existing = existsSync(outPath)
+      ? readFileSync(outPath, "utf-8")
+      : null;
+    if (existing !== source) {
+      markSelfGenWrite(state, outPath, source);
+      writeFileSync(outPath, source);
+      console.log(`[rsc-router] Generated route types -> ${outPath}`);
+    }
+  }
+}
+
+/**
+ * Supplement gen files with route groups from runtime manifests that the
+ * static parser cannot resolve (factory calls like createDocsPatterns()).
+ * Only adds groups whose dot-prefix (e.g. "docs.") is entirely absent
+ * from the static output. Groups partially visible to the static parser
+ * are left alone so renames/removals propagate immediately without
+ * requiring a server restart.
+ *
+ * The runtime manifest (cachedManifest / perRouterManifestMap) is updated
+ * automatically: the virtual:rsc-router/routes-manifest module imports the
+ * gen file, so when we write new content here, Vite's HMR invalidates the
+ * virtual module and re-evaluates it on the next request.
+ */
+export function supplementGenFilesWithRuntimeRoutes(
+  state: DiscoveryState,
+): void {
+  // Cache static parsing results to avoid redundant I/O + parsing per router.
+  const parseCache = new Map<
+    string,
+    ReturnType<typeof buildCombinedRouteMapForRouterFile>
+  >();
+  const getParsed = (file: string) => {
+    let cached = parseCache.get(file);
+    if (!cached) {
+      cached = buildCombinedRouteMapForRouterFile(file);
+      parseCache.set(file, cached);
+    }
+    return cached;
+  };
+
+  for (const {
+    routeManifest,
+    routeSearchSchemas,
+    sourceFile,
+    factoryOnlyPrefixes,
+  } of state.perRouterManifests) {
+    if (!sourceFile) continue;
+    if (!factoryOnlyPrefixes || factoryOnlyPrefixes.size === 0) continue;
+
+    const staticParsed = getParsed(sourceFile);
+
+    // Merge: static routes (authoritative) + factory-only groups from runtime.
+    const mergedRoutes: Record<string, string> = { ...staticParsed.routes };
+    const mergedSearchSchemas: Record<string, Record<string, string>> = {
+      ...staticParsed.searchSchemas,
+    };
+
+    for (const [name, pattern] of Object.entries(routeManifest)) {
+      // Skip internal runtime-only names from unnamed routes/includes.
+      if (isAutoGeneratedRouteName(name)) continue;
+      const dotIdx = name.indexOf(".");
+      if (dotIdx <= 0) continue;
+      const prefix = name.substring(0, dotIdx + 1);
+      if (factoryOnlyPrefixes.has(prefix)) {
+        mergedRoutes[name] = pattern;
+        // Also merge search schemas from factory-generated routes
+        if (routeSearchSchemas?.[name]) {
+          mergedSearchSchemas[name] = routeSearchSchemas[name];
+        }
+      }
+    }
+
+    const routerDir = dirname(sourceFile);
+    const routerBasename = basename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
+    const outPath = join(routerDir, `${routerBasename}.named-routes.gen.ts`);
+    const source = generateRouteTypesSource(
+      mergedRoutes,
+      Object.keys(mergedSearchSchemas).length > 0
+        ? mergedSearchSchemas
+        : undefined,
+    );
+    const existing = existsSync(outPath)
+      ? readFileSync(outPath, "utf-8")
+      : null;
+    if (existing !== source) {
+      markSelfGenWrite(state, outPath, source);
+      writeFileSync(outPath, source);
+    }
+  }
+  // No manual manifest update needed: the virtual module imports the gen
+  // file, so Vite's HMR automatically re-evaluates it with fresh data.
+}

package/src/vite/discovery/self-gen-tracking.ts

@@ -0,0 +1,73 @@
+/**
+ * Self-Generated File Tracking
+ *
+ * Tracks gen files recently written by the discovery plugin so the
+ * file watcher can distinguish self-triggered change events from
+ * manual edits.
+ */
+
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import type { DiscoveryState } from "./state.js";
+
+export function markSelfGenWrite(
+  state: DiscoveryState,
+  filePath: string,
+  content: string,
+): void {
+  const hash = createHash("sha256").update(content).digest("hex");
+  state.selfWrittenGenFiles.set(filePath, { at: Date.now(), hash });
+}
+
+export function consumeSelfGenWrite(
+  state: DiscoveryState,
+  filePath: string,
+): boolean {
+  return checkSelfGenWrite(state, filePath, true);
+}
+
+/**
+ * Non-consuming variant. Used by the `handleHotUpdate` plugin hook to
+ * suppress vite's HMR cascade for our own gen-file writes WITHOUT
+ * consuming the entry — `consumeSelfGenWrite` (called later from the
+ * chokidar `change` handler in `handleRouteFileChange`) still needs to
+ * see and consume the same entry to short-circuit our regen path.
+ *
+ * Both hooks fire for the same file change event:
+ *   - `handleHotUpdate` runs first (vite's HMR pipeline).
+ *   - chokidar `change` callback runs after (filesystem watcher).
+ */
+export function peekSelfGenWrite(
+  state: DiscoveryState,
+  filePath: string,
+): boolean {
+  return checkSelfGenWrite(state, filePath, false);
+}
+
+function checkSelfGenWrite(
+  state: DiscoveryState,
+  filePath: string,
+  consume: boolean,
+): boolean {
+  const info = state.selfWrittenGenFiles.get(filePath);
+  if (!info) return false;
+  if (Date.now() - info.at > state.SELF_WRITE_WINDOW_MS) {
+    state.selfWrittenGenFiles.delete(filePath);
+    return false;
+  }
+  try {
+    const current = readFileSync(filePath, "utf-8");
+    const currentHash = createHash("sha256").update(current).digest("hex");
+    if (currentHash === info.hash) {
+      if (consume) state.selfWrittenGenFiles.delete(filePath);
+      return true;
+    }
+    // Hash mismatch: file was changed externally. Keep the entry so a
+    // subsequent watcher event from our own write can still be consumed
+    // (e.g. when multiple Vite servers watch the same directory).
+    return false;
+  } catch {
+    state.selfWrittenGenFiles.delete(filePath);
+    return false;
+  }
+}

package/src/vite/discovery/state.ts

@@ -0,0 +1,117 @@
+/**
+ * Discovery State
+ *
+ * Shared mutable state for the router discovery plugin.
+ * Created once by createRouterDiscoveryPlugin() and passed
+ * to all extracted helper functions.
+ */
+
+import type { ScanFilter } from "../../build/generate-route-types.js";
+
+export const VIRTUAL_ROUTES_MANIFEST_ID = "virtual:rsc-router/routes-manifest";
+
+export interface PluginOptions {
+  enableBuildPrerender?: boolean;
+  staticRouteTypesGeneration?: boolean;
+  // Mutable ref for deferred auto-discovery (node preset).
+  // The auto-discover config() hook populates this before configResolved.
+  routerPathRef?: { path?: string };
+  /** Build-time env option from rango() config. */
+  buildEnv?: import("../plugin-types.js").BuildEnvOption;
+  /** Deployment preset (needed for buildEnv "auto" resolution). */
+  preset?: "node" | "cloudflare";
+}
+
+export interface PrecomputedEntry {
+  staticPrefix: string;
+  routes: Record<string, string>;
+}
+
+export interface ChunkInfo {
+  fileName: string;
+  exports: Array<{ name: string; handlerId: string; passthrough: boolean }>;
+}
+
+export interface PerRouterManifestEntry {
+  id: string;
+  routeManifest: Record<string, string>;
+  routeSearchSchemas?: Record<string, Record<string, string>>;
+  sourceFile?: string;
+  factoryOnlyPrefixes?: Set<string>;
+}
+
+export interface DiscoveryState {
+  resolvedEntryPath: string | undefined;
+  projectRoot: string;
+  isBuildMode: boolean;
+  userResolveAlias: any;
+  scanFilter: ScanFilter | undefined;
+  cachedRouterFiles: string[] | undefined;
+  opts: PluginOptions | undefined;
+
+  mergedRouteManifest: Record<string, string> | null;
+  perRouterManifests: PerRouterManifestEntry[];
+  mergedPrecomputedEntries: PrecomputedEntry[] | null;
+  mergedRouteTrie: any;
+
+  perRouterTrieMap: Map<string, any>;
+  perRouterPrecomputedMap: Map<string, PrecomputedEntry[]>;
+  perRouterManifestDataMap: Map<string, Record<string, string>>;
+
+  prerenderManifestEntries: Record<string, string> | null;
+  staticManifestEntries: Record<string, string> | null;
+  handlerChunkInfoMap: Map<string, ChunkInfo>;
+  staticHandlerChunkInfoMap: Map<string, ChunkInfo>;
+  rscEntryFileName: string | null;
+  resolvedPrerenderModules: Map<string, string[]> | undefined;
+  resolvedStaticModules: Map<string, string[]> | undefined;
+
+  discoveryDone: Promise<void> | null;
+  devServerOrigin: string | null;
+  devServer: any;
+  selfWrittenGenFiles: Map<string, { at: number; hash: string }>;
+  SELF_WRITE_WINDOW_MS: number;
+
+  /** Resolved build-time env bindings (set during buildStart/configureServer). */
+  resolvedBuildEnv?: Record<string, unknown>;
+  /** Cleanup function for build-time env resources (e.g., miniflare). */
+  buildEnvDispose?: (() => Promise<void> | void) | null;
+}
+
+export function createDiscoveryState(
+  entryPath: string | undefined,
+  opts: PluginOptions | undefined,
+): DiscoveryState {
+  return {
+    resolvedEntryPath: entryPath,
+    projectRoot: "",
+    isBuildMode: false,
+    userResolveAlias: undefined,
+    scanFilter: undefined,
+    cachedRouterFiles: undefined,
+    opts,
+
+    mergedRouteManifest: null,
+    perRouterManifests: [],
+    mergedPrecomputedEntries: null,
+    mergedRouteTrie: null,
+
+    perRouterTrieMap: new Map(),
+    perRouterPrecomputedMap: new Map(),
+    perRouterManifestDataMap: new Map(),
+
+    prerenderManifestEntries: null,
+    staticManifestEntries: null,
+    handlerChunkInfoMap: new Map(),
+    staticHandlerChunkInfoMap: new Map(),
+    rscEntryFileName: null,
+    resolvedPrerenderModules: undefined,
+    resolvedStaticModules: undefined,
+
+    discoveryDone: null,
+    devServerOrigin: null,
+    devServer: null,
+    selfWrittenGenFiles: new Map(),
+    SELF_WRITE_WINDOW_MS: 5_000,
+  };
+}

package/src/vite/discovery/virtual-module-codegen.ts

@@ -0,0 +1,203 @@
+/**
+ * Virtual Module Code Generation
+ *
+ * Generates the code for virtual:rsc-router/routes-manifest and
+ * per-router virtual modules used by the load() hook.
+ */
+
+import { dirname, basename, join } from "node:path";
+import { jsonParseExpression } from "../utils/manifest-utils.js";
+import { VIRTUAL_ROUTES_MANIFEST_ID } from "./state.js";
+import type { DiscoveryState } from "./state.js";
+
+/**
+ * Generate the code for the main virtual:rsc-router/routes-manifest module.
+ */
+export function generateRoutesManifestModule(state: DiscoveryState): string {
+  const hasManifest =
+    state.mergedRouteManifest &&
+    Object.keys(state.mergedRouteManifest).length > 0;
+
+  if (hasManifest) {
+    // Build gen file import statements for each router with a sourceFile.
+    // This creates a dependency in Vite's module graph: when the gen file
+    // changes (e.g. after HMR route edits), Vite invalidates this virtual
+    // module and re-evaluates it on the next request, calling
+    // setCachedManifest() with fresh data. No manual sync needed.
+    const genFileImports: string[] = [];
+    const genFileVars: string[] = [];
+    const routersWithoutGenFile: Array<{
+      id: string;
+      manifest: Record<string, string>;
+    }> = [];
+    let varIdx = 0;
+
+    for (const entry of state.perRouterManifests) {
+      if (entry.sourceFile) {
+        const routerDir = dirname(entry.sourceFile);
+        const routerBasename = basename(entry.sourceFile).replace(
+          /\.(tsx?|jsx?)$/,
+          "",
+        );
+        const genPath = join(
+          routerDir,
+          `${routerBasename}.named-routes.gen.js`,
+        ).replaceAll("\\", "/");
+        const varName = `_r${varIdx++}`;
+        genFileImports.push(
+          `import { NamedRoutes as ${varName} } from ${JSON.stringify(genPath)};`,
+        );
+        genFileVars.push(varName);
+      } else {
+        // Routers without sourceFile: inline their manifest data directly
+        routersWithoutGenFile.push({
+          id: entry.id,
+          manifest: entry.routeManifest,
+        });
+      }
+    }
+
+    const lines = [
+      `import { setCachedManifest, setPrecomputedEntries, setRouteTrie, setRouterManifest, registerRouterManifestLoader, clearAllRouterData } from "@rangojs/router/server";`,
+      ...genFileImports,
+      // Clear stale per-router cached data (manifest, trie, precomputed entries)
+      // before re-populating. In Cloudflare dev mode, program reloads re-evaluate
+      // this virtual module but the route-map-builder singleton retains old data
+      // because it's not in the HMR invalidation chain. Without this clear, the
+      // handler finds stale trie data and never rebuilds from updated urlpatterns.
+      `clearAllRouterData();`,
+    ];
+
+    // Flatten NamedRoutes entries: search schema objects -> plain string paths
+    if (genFileVars.length > 0) {
+      lines.push(
+        `function __flat(r) { const o = {}; for (const [k, v] of Object.entries(r)) o[k] = typeof v === "string" ? v : v.path; return o; }`,
+      );
+    }
+
+    // Build the merged manifest from gen file imports + inlined data
+    if (genFileVars.length === 1 && routersWithoutGenFile.length === 0) {
+      lines.push(`setCachedManifest(__flat(${genFileVars[0]}));`);
+    } else {
+      const parts: string[] = [];
+      for (const v of genFileVars) parts.push(`...__flat(${v})`);
+      for (const { manifest } of routersWithoutGenFile)
+        parts.push(`...${jsonParseExpression(manifest)}`);
+      lines.push(`setCachedManifest({ ${parts.join(", ")} });`);
+    }
+
+    // Set per-router manifests
+    let genVarIdx = 0;
+    for (const entry of state.perRouterManifests) {
+      if (entry.sourceFile) {
+        const varName = genFileVars[genVarIdx++];
+        lines.push(
+          `setRouterManifest(${JSON.stringify(entry.id)}, __flat(${varName}));`,
+        );
+      } else {
+        lines.push(
+          `setRouterManifest(${JSON.stringify(entry.id)}, ${jsonParseExpression(entry.routeManifest)});`,
+        );
+      }
+    }
+
+    // In dev mode, skip trie and precomputed entries injection. These are
+    // computed once during initial discovery and become stale after route
+    // changes. A stale trie would incorrectly match removed routes. The
+    // handler falls back to Phase 2 regex matching against the live
+    // router.urlpatterns, which is always correct after a program reload.
+    // In build mode, the trie is always fresh (built from the final route
+    // tree) so it's safe to inject.
+    if (state.isBuildMode) {
+      if (
+        state.mergedPrecomputedEntries &&
+        state.mergedPrecomputedEntries.length > 0
+      ) {
+        lines.push(
+          `setPrecomputedEntries(${jsonParseExpression(state.mergedPrecomputedEntries)});`,
+        );
+      }
+      if (state.mergedRouteTrie) {
+        lines.push(
+          `setRouteTrie(${jsonParseExpression(state.mergedRouteTrie)});`,
+        );
+      }
+    }
+
+    // Register lazy loaders for per-router manifest modules.
+    // Each import() uses a static string literal so Rollup creates separate chunks.
+    for (const routerId of state.perRouterManifestDataMap.keys()) {
+      lines.push(
+        `registerRouterManifestLoader(${JSON.stringify(routerId)}, () => import(${JSON.stringify(VIRTUAL_ROUTES_MANIFEST_ID + "/" + routerId)}));`,
+      );
+    }
+    if (!state.isBuildMode && state.devServerOrigin) {
+      lines.push(
+        `globalThis.__PRERENDER_DEV_URL = ${JSON.stringify(state.devServerOrigin)};`,
+      );
+    }
+    return lines.join("\n");
+  }
+
+  // No manifest: either discovery hasn't completed or no runner (Cloudflare dev).
+  // Still inject __PRERENDER_DEV_URL so the prerender store can fetch on-demand.
+  // Re-resolve origin now since the server is listening by module load time.
+  if (!state.isBuildMode) {
+    const origin =
+      state.devServerOrigin ||
+      state.devServer?.resolvedUrls?.local?.[0]?.replace(/\/$/, "") ||
+      (state.devServer &&
+        `http://localhost:${state.devServer.config.server.port || 5173}`);
+    if (origin) {
+      state.devServerOrigin = origin;
+      return `globalThis.__PRERENDER_DEV_URL = ${JSON.stringify(origin)};`;
+    }
+  }
+  return `// Route manifest will be populated at runtime`;
+}
+
+/**
+ * Generate the code for a per-router virtual module.
+ */
+export function generatePerRouterModule(
+  state: DiscoveryState,
+  routerId: string,
+): string {
+  // Find the per-router entry to get the gen file path
+  const routerEntry = state.perRouterManifests.find((e) => e.id === routerId);
+  const trie = state.perRouterTrieMap.get(routerId);
+  const entries = state.perRouterPrecomputedMap.get(routerId);
+  const lines: string[] = [];
+
+  if (routerEntry?.sourceFile) {
+    // Import manifest from the gen file so HMR auto-propagates
+    const routerDir = dirname(routerEntry.sourceFile);
+    const routerBasename = basename(routerEntry.sourceFile).replace(
+      /\.(tsx?|jsx?)$/,
+      "",
+    );
+    const genPath = join(
+      routerDir,
+      `${routerBasename}.named-routes.gen.js`,
+    ).replaceAll("\\", "/");
+    lines.push(`import { NamedRoutes as _r } from ${JSON.stringify(genPath)};`);
+    lines.push(
+      `function __flat(r) { const o = {}; for (const [k, v] of Object.entries(r)) o[k] = typeof v === "string" ? v : v.path; return o; }`,
+    );
+    lines.push(`export const manifest = __flat(_r);`);
+  } else {
+    const manifest = state.perRouterManifestDataMap.get(routerId);
+    if (manifest) {
+      lines.push(`export const manifest = ${jsonParseExpression(manifest)};`);
+    }
+  }
+  if (trie) {
+    lines.push(`export const trie = ${jsonParseExpression(trie)};`);
+  }
+  if (entries && entries.length > 0) {
+    lines.push(
+      `export const precomputedEntries = ${jsonParseExpression(entries)};`,
+    );
+  }
+  return lines.join("\n") || "// empty router manifest";
+}