@rangojs/router 0.0.0-experimental.bd6e11bc → 0.0.0-experimental.bdaf10aa

package/src/vite/router-discovery.ts

@@ -16,8 +16,13 @@ import {
   formatNestedRouterConflictError,
   findNestedRouterConflict,
   findRouterFiles,
+  createScanFilter,
 } from "../build/generate-route-types.js";
 import { firstCodeMatchIndex } from "../build/route-types/source-scan.js";
+import {
+  injectClientDebugFlag,
+  internalDebugNoCacheMiddleware,
+} from "./inject-client-debug.js";
 import { createVersionPlugin } from "./plugins/version-plugin.js";
 import { createVirtualStubPlugin } from "./plugins/virtual-stub-plugin.js";
 import {
@@ -41,6 +46,12 @@ import {
   peekSelfGenWrite,
 } from "./discovery/self-gen-tracking.js";
 import { discoverRouters } from "./discovery/discover-routers.js";
+import { describeDiscoveryFailure } from "./discovery/discovery-errors.js";
+import {
+  createDevPrerenderCache,
+  devPrerenderCacheKey,
+  payloadBodiesFromResult,
+} from "./discovery/dev-prerender-cache.js";
 import {
   writeCombinedRouteTypesWithTracking,
   writeRouteTypesFiles,
@@ -309,23 +320,23 @@ export function createRouterDiscoveryPlugin(
   return {
     name: "@rangojs/router:discovery",
 
-    config() {
-      const config: any = {
-        define: {
-          __RANGO_DEBUG__: JSON.stringify(!!process.env.INTERNAL_RANGO_DEBUG),
-        },
-      };
-      // Prerender/static handler modules are bundled naturally with the
-      // rest of the RSC entry.  A previous design forced them into dedicated
-      // __prerender-handlers / __static-handlers chunks via manualChunks,
-      // but Rollup hoisted all shared dependencies into those chunks,
-      // inflating them to ~1 MB with active runtime code.  Handler code is
-      // evicted in closeBundle regardless of which chunk it lands in.
-      return config;
+    // Make INTERNAL_RANGO_DEBUG reach the CLIENT debug logs by just setting the
+    // env var. See injectClientDebugFlag: bakes the resolved flag into the
+    // internal-debug module so FE debug no longer depends on Vite delivering the
+    // `__RANGO_DEBUG__` define to the client (which it does only as an injected
+    // global whose presence varies across consumer setups). Runs in dev and build.
+    transform(_code, id) {
+      return injectClientDebugFlag(id);
     },
 
     configResolved(config) {
       s.projectRoot = config.root;
+      // Compile the optional discovery scan filter (glob include/exclude) now
+      // that the project root is known. findRouterFiles() below — and the
+      // build/HMR rediscovery paths — honor s.scanFilter.
+      s.scanFilter = opts?.discovery
+        ? createScanFilter(s.projectRoot, opts.discovery)
+        : undefined;
       s.isBuildMode = config.command === "build";
       viteCommand = config.command as "serve" | "build";
       viteMode = config.mode;
@@ -384,6 +395,11 @@ export function createRouterDiscoveryPlugin(
       if ((globalThis as any).__rscRouterDiscoveryActive) return;
       s.devServer = server;
 
+      // Serve the internal-debug module no-cache: consumers resolve it into
+      // node_modules, where dev's immutable `?v=` caching pinned browsers to a
+      // stale baked INTERNAL_RANGO_DEBUG. See internalDebugNoCacheMiddleware.
+      server.middlewares.use(internalDebugNoCacheMiddleware());
+
       // Discovery promise that the handler can await if requests arrive
       // before discovery completes
       let resolveDiscovery: () => void;
@@ -424,7 +440,8 @@ export function createRouterDiscoveryPlugin(
         releaseBuildEnv(s).catch(() => {});
       });
 
-      // Mirror the build-path contract (router-discovery.ts ~line 878):
+      // Mirror the build-path contract (the buildStart hook below, which sets
+      // __rscRouterDiscoveryActive before running user modules):
       // set __rscRouterDiscoveryActive before running user modules so any
       // module-level router.reverse() calls return a placeholder instead
       // of throwing. The temp Vite server's module runner has its own
@@ -541,6 +558,14 @@ export function createRouterDiscoveryPlugin(
           );
           console.warn(`[rango] Failed to create temp runner: ${err.message}`);
         }
+        // Reached only on failure (runner unavailable, or create/import threw
+        // AFTER the server was created). Close the just-created server so a
+        // failed discovery does not leak it until the next call or dev shutdown,
+        // and null the refs so the reuse path above starts clean. Mirrors the
+        // close pattern used when an existing server is discarded (above).
+        await prerenderTempServer?.close().catch(() => {});
+        prerenderTempServer = null;
+        prerenderNodeRegistry = null;
         return null;
       }
 
@@ -642,6 +667,30 @@ export function createRouterDiscoveryPlugin(
         return tempRscEnv;
       }
 
+      // Surface a discovery failure on either dev path (Node RSC runner or the
+      // Cloudflare temp Node server). `hashBefore`/`hashAfter` are the discovering
+      // environment's dep-optimizer browserHash snapshots: a change across the
+      // attempt means a reload-causing re-optimization landed mid-flight, so an
+      // empty registry was the transient race (downgraded to a warning) rather
+      // than a genuine misconfig (loud, actionable error). Shared so both catch
+      // sites frame the same failure identically.
+      const emitDiscoveryFailure = (
+        err: unknown,
+        hashBefore: string | undefined,
+        hashAfter: string | undefined,
+      ): void => {
+        const reoptimizeObserved =
+          hashBefore !== undefined &&
+          hashAfter !== undefined &&
+          hashBefore !== hashAfter;
+        const report = describeDiscoveryFailure(err, { reoptimizeObserved });
+        if (report.level === "warn") {
+          console.warn(report.message);
+        } else {
+          console.error(report.message);
+        }
+      };
+
       const discover = async () => {
         const discoverStart = performance.now();
         const rscEnv = (server.environments as any)?.rsc;
@@ -657,18 +706,26 @@ export function createRouterDiscoveryPlugin(
 
           // Create a temp Node.js server to run runtime discovery and generate
           // named route types (static parser can't resolve factory calls).
+          // The temp server is a separate Vite instance with its own dep
+          // optimizer; snapshot ITS browserHash (hoisted so the catch can tell a
+          // transient re-optimization apart from a genuine empty registry, the
+          // same way the Node path below does).
+          let tempRscEnv: any;
+          let optimizerHashBefore: string | undefined;
           try {
             // Acquire build-time env bindings for dev prerender
             await timed(debugDiscovery, "acquireBuildEnv", () =>
               acquireBuildEnv(s, viteCommand, viteMode),
             );
 
-            const tempRscEnv = await timed(
+            tempRscEnv = await timed(
               debugDiscovery,
               "getOrCreateTempServer",
               () => getOrCreateTempServer(),
             );
             if (tempRscEnv) {
+              optimizerHashBefore =
+                tempRscEnv.depsOptimizer?.metadata?.browserHash;
               await timed(debugDiscovery, "discoverRouters (cloudflare)", () =>
                 discoverRouters(s, tempRscEnv),
               );
@@ -677,8 +734,10 @@ export function createRouterDiscoveryPlugin(
               );
             }
           } catch (err: any) {
-            console.warn(
-              `[rango] Cloudflare dev discovery failed: ${err.message}\n${err.stack}`,
+            emitDiscoveryFailure(
+              err,
+              optimizerHashBefore,
+              tempRscEnv?.depsOptimizer?.metadata?.browserHash,
             );
           }
 
@@ -690,6 +749,13 @@ export function createRouterDiscoveryPlugin(
           return;
         }
 
+        // Snapshot the dep-optimizer hash before discovery so the catch can tell
+        // a transient re-optimization race apart from a genuine empty registry.
+        // A reload-causing re-optimization regenerates browserHash; if it changed
+        // across the attempt, an empty read was almost certainly the race below.
+        const optimizerHashBefore: string | undefined =
+          rscEnv.depsOptimizer?.metadata?.browserHash;
+
         try {
           // Acquire build-time env bindings for dev prerender (Node.js path)
           debugDiscovery?.("dev: node path start");
@@ -697,21 +763,31 @@ export function createRouterDiscoveryPlugin(
             acquireBuildEnv(s, viteCommand, viteMode),
           );
 
-          // Set the readiness gate BEFORE discovery so early requests
-          // block until manifest is populated
-          const serverMod = await timed(
-            debugDiscovery,
-            "import @rangojs/router/server",
-            () => rscEnv.runner.import("@rangojs/router/server"),
+          // Discover routers FIRST, then arm the manifest-readiness gate on the
+          // server module discovery actually read the registry from.
+          //
+          // We deliberately do NOT pre-import "@rangojs/router/server" before the
+          // entry to arm the gate early. During a Vite dependency re-optimization
+          // (dev boot after a lockfile change, or `vite dev --force`), a module
+          // imported here before the entry resolves to the pre-optimize copy of
+          // the runner's module graph, while discoverRouters' entry import — which
+          // awaits the in-flight re-optimization — resolves to the post-optimize
+          // copy. createRouter() then populates RouterRegistry on the fresh copy,
+          // but a stale pre-imported "@rangojs/router/server" reads the other
+          // copy's empty Map and discovery throws a spurious "No routers found"
+          // even though the app is configured correctly. discoverRouters imports
+          // the entry first and reads the registry off the same instance, keeping
+          // read and write on one copy. The virtual manifest module's own gate
+          // (s.discoveryDone, armed by beginDiscoveryGate) already blocks early
+          // requests during discovery on the Node path, so arming
+          // manifestReadyPromise after discovery is sufficient here.
+          const serverMod = await timed(debugDiscovery, "discoverRouters", () =>
+            discoverRouters(s, rscEnv),
           );
           if (serverMod?.setManifestReadyPromise) {
             serverMod.setManifestReadyPromise(discoveryPromise);
           }
 
-          await timed(debugDiscovery, "discoverRouters", () =>
-            discoverRouters(s, rscEnv),
-          );
-
           // Store server origin for dev prerender endpoint (virtual module injection)
           s.devServerOrigin = getDevServerOrigin();
 
@@ -729,8 +805,10 @@ export function createRouterDiscoveryPlugin(
             propagateDiscoveryState(rscEnv),
           );
         } catch (err: any) {
-          console.warn(
-            `[rango] Router discovery failed: ${err.message}\n${err.stack}`,
+          emitDiscoveryFailure(
+            err,
+            optimizerHashBefore,
+            rscEnv.depsOptimizer?.metadata?.browserHash,
           );
         } finally {
           debugDiscovery?.(
@@ -763,6 +841,15 @@ export function createRouterDiscoveryPlugin(
       // Registry from the main server's RSC environment (populated by discoverRouters)
       let mainRegistry: Map<string, any> | null = null;
 
+      // Memoized /__rsc_prerender render results, keyed by router-instance
+      // identity (#654). The per-request entry re-import below is what makes
+      // identity a valid freshness key: an HMR-invalidated chain re-runs
+      // createRouter() and replaces the registry instance, so cached bodies
+      // for the old instance become unreachable; an untouched chain returns
+      // the same instance and the cached body is byte-identical to a fresh
+      // render. See dev-prerender-cache.ts for the full invariant.
+      const devPrerenderCache = createDevPrerenderCache();
+
       // Push discovery state (manifest, trie, precomputed entries) to the
       // server module so runtime request handling uses the current routes.
       // Shared by initial discovery and HMR-triggered re-discovery.
@@ -853,9 +940,28 @@ export function createRouterDiscoveryPlugin(
 
         if (!registry) {
           // No main registry: the RSC env has no module runner (Cloudflare dev).
-          // Lazily create a Node.js temp server for prerender evaluation.
-          if (!prerenderNodeRegistry) {
-            await getOrCreateTempServer();
+          // Lazily create a Node.js temp server for prerender evaluation, and
+          // re-import the entry through it on EVERY request — the temp server
+          // has its own file watcher, so a handler-only edit (a file without
+          // urls()/createRouter() that the main watcher's route-file sniff
+          // ignores) invalidates its module graph; the re-import re-evaluates
+          // exactly the dirty subgraph and re-registers fresh router
+          // instances. Before #654 the cached registry was only refreshed on
+          // route-file edits, so handler-only edits served stale prerender
+          // content on this path. Warm-cache re-imports are module-cache hits.
+          const tempRscEnv = await getOrCreateTempServer();
+          if (tempRscEnv) {
+            try {
+              await importEntryAndRegistry(tempRscEnv);
+            } catch (err: any) {
+              console.warn(
+                `[rango] Dev prerender module refresh failed: ${err.message}`,
+              );
+              res.statusCode = 500;
+              res.end(`Prerender handler error: ${err.message}`);
+              logResult(500, "temp module refresh failed");
+              return;
+            }
           }
           registry = prerenderNodeRegistry;
         }
@@ -871,8 +977,38 @@ export function createRouterDiscoveryPlugin(
         const wantRouteName = url.searchParams.get("routeName");
         const wantPassthrough = url.searchParams.get("passthrough") === "1";
 
+        // One render warms BOTH variant keys (matchForPrerender computes the
+        // intercept segments unconditionally), so a route's main and modal
+        // variants cost a single render per HMR generation.
+        const variantDims = {
+          passthrough: wantPassthrough,
+          routeName: wantRouteName,
+        };
+        const keyMain = devPrerenderCacheKey(pathname, {
+          intercept: false,
+          ...variantDims,
+        });
+        const keyIntercept = devPrerenderCacheKey(pathname, {
+          intercept: true,
+          ...variantDims,
+        });
+        const requestedKey = wantIntercept ? keyIntercept : keyMain;
+
         for (const [, routerInstance] of registry) {
           if (!routerInstance.matchForPrerender) continue;
+          // Cache is consulted per router IN LOOP ORDER so multi-router
+          // fall-through semantics are identical to the uncached path: a
+          // router that never produced a payload for this key still runs
+          // its matchForPrerender (cheap trie miss / intentionally-uncached
+          // error retry) before the next router is considered.
+          const cached = devPrerenderCache.get(routerInstance, requestedKey);
+          if (cached !== undefined) {
+            res.setHeader("content-type", "application/json");
+            res.setHeader("x-rango-prerender-cache", "HIT");
+            res.end(cached);
+            logResult(200, "cache hit");
+            return;
+          }
           try {
             const result = await routerInstance.matchForPrerender(
               pathname,
@@ -888,26 +1024,31 @@ export function createRouterDiscoveryPlugin(
             // This prevents returning the wrong entry when multiple routers
             // have prerenderable routes sharing the same pathname.
             if (wantRouteName && result.routeName !== wantRouteName) continue;
+            // Pre-encoded MERGED handle string in the intercept body comes
+            // from the producer (handles are Flight-encoded so
+            // Promise/ReactNode values survive the wire).
+            const bodies = payloadBodiesFromResult(result);
+            devPrerenderCache.set(routerInstance, keyMain, bodies.main);
+            devPrerenderCache.set(
+              routerInstance,
+              keyIntercept,
+              bodies.intercept,
+            );
             res.setHeader("content-type", "application/json");
-            let payload: Record<string, unknown>;
-            if (wantIntercept && result.interceptSegments?.length) {
-              payload = {
-                segments: [...result.segments, ...result.interceptSegments],
-                handles: {
-                  ...result.handles,
-                  ...(result.interceptHandles || {}),
-                },
-              };
-            } else {
-              payload = { segments: result.segments, handles: result.handles };
-            }
-            res.end(JSON.stringify(payload));
+            res.setHeader("x-rango-prerender-cache", "MISS");
+            res.end(wantIntercept ? bodies.intercept : bodies.main);
             logResult(200, `match ${result.routeName}`);
             return;
           } catch (err: any) {
-            console.warn(
-              `[rango] Dev prerender failed for ${pathname}: ${err.message}`,
-            );
+            // matchForPrerender now re-throws render failures instead of baking
+            // an error page (issue #587). In dev there is no frozen artifact, so
+            // we fall through (404 -> live handler). A `throw new Skip()` is the
+            // expected "skip this URL" signal, not a failure, so it stays quiet.
+            if (err?.name !== "Skip") {
+              console.warn(
+                `[rango] Dev prerender error for ${pathname} (serving live instead): ${err.message}`,
+              );
+            }
           }
         }
 

package/src/vite/utils/ast-handler-extract.ts

@@ -1,10 +1,6 @@
 import type MagicString from "magic-string";
 import { hashInlineId, buildExportMap } from "../plugins/expose-id-utils.js";
 
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
 /** Minimal ESTree Program node — avoids importing from `rollup` (not a direct dep). */
 interface ProgramNode {
   type: "Program";
@@ -70,10 +66,6 @@ function findImportInsertionPos(
   return insertionPos;
 }
 
-// ---------------------------------------------------------------------------
-// AST walking helper
-// ---------------------------------------------------------------------------
-
 /**
  * Recursively walk an ESTree AST node, calling `enter` on each node.
  * Parent is passed for context.
@@ -111,10 +103,6 @@ function walkNode(
   ancestors.pop();
 }
 
-// ---------------------------------------------------------------------------
-// AST analysis
-// ---------------------------------------------------------------------------
-
 /**
  * Parse the file with Vite's parseAst and find all calls to `fnName`.
  * Distinguishes between `export const X = fnName(...)` (exportInfo set)
@@ -294,16 +282,23 @@ function isInertExpression(node: any): boolean {
         (e: any) => e === null || isInertExpression(e),
       );
     case "ObjectExpression":
-      return (node.properties ?? []).every(
-        (p: any) =>
+      return (node.properties ?? []).every((p: any) => {
+        // A spread inside an object (`{ ...x }`) is inert iff `x` is inert.
+        if (p.type === "SpreadElement" || p.type === "RestElement") {
+          return isInertExpression(p.argument);
+        }
+        return (
           p.type === "Property" &&
           (!p.computed || isInertExpression(p.key)) &&
-          isInertExpression(p.value),
-      );
+          isInertExpression(p.value)
+        );
+      });
     case "UnaryExpression":
       return isInertExpression(node.argument);
     case "BinaryExpression":
       return isInertExpression(node.left) && isInertExpression(node.right);
+    case "LogicalExpression":
+      return isInertExpression(node.left) && isInertExpression(node.right);
     case "ConditionalExpression":
       return (
         isInertExpression(node.test) &&
@@ -426,10 +421,6 @@ export function extractModuleLevelDeclarations(
   return declarations;
 }
 
-// ---------------------------------------------------------------------------
-// Transform
-// ---------------------------------------------------------------------------
-
 /**
  * Transform inline handler calls by extracting them into virtual modules.
  * Only processes inline calls (exportInfo === null); export const calls are

package/src/vite/utils/bundle-analysis.ts

@@ -5,9 +5,7 @@ import {
 
 /**
  * Find matching close paren in bundled code using depth counting.
- * Uses skipStringOrComment from expose-id-utils to correctly handle
- * template literal ${...} expressions, comments, and nested strings.
- * Returns the position after the closing paren, or -1 if unmatched.
+ * Uses skipStringOrComment to correctly handle template literals, comments, and nested strings.
  * @internal Exported for testing only.
  */
 export function findMatchingParenInBundle(
@@ -30,9 +28,8 @@ export function findMatchingParenInBundle(
 }
 
 /**
- * Scan a bundled chunk for handler exports of a given type and extract
- * their names + $$id values. Optionally detects passthrough flag.
- * @internal Exported for testing only.
+ * Scan a bundled chunk for handler exports and extract their names + $$id values.
+ * Optionally detects passthrough flag. @internal Exported for testing only.
  */
 export function extractHandlerExportsFromChunk(
   chunkCode: string,
@@ -67,7 +64,7 @@ export function extractHandlerExportsFromChunk(
           const closePos = findMatchingParenInBundle(chunkCode, afterOpen);
           if (closePos !== -1) {
             const callBody = chunkCode.slice(callStart.index, closePos);
-            isPassthrough = /passthrough\s*:\s*(!0|true)/.test(callBody);
+            isPassthrough = /passthrough\s*:\s*(!0|true)/.test(callBody); // !0 is minified true
           }
         }
       }
@@ -79,9 +76,8 @@ export function extractHandlerExportsFromChunk(
 }
 
 /**
- * Evict handler code from a bundled chunk, replacing full handler call
- * expressions with lightweight stub objects. Returns the modified code
- * and bytes saved, or null if no changes were made.
+ * Evict handler code from a bundled chunk, replacing full call expressions with stubs.
+ * Returns the modified code and bytes saved, or null if no changes were made.
  * @internal Exported for testing only.
  */
 export function evictHandlerCode(
@@ -110,13 +106,11 @@ export function evictHandlerCode(
     const closePos = findMatchingParenInBundle(modified, afterOpen);
     if (closePos === -1) continue;
 
-    // Skip trailing whitespace and optional semicolon
     let rangeEnd = closePos;
     while (rangeEnd < modified.length && /\s/.test(modified[rangeEnd]))
       rangeEnd++;
     if (modified[rangeEnd] === ";") rangeEnd++;
 
-    // Validate: matched range must contain the expected handlerId
     const matched = modified.slice(startMatch.index, rangeEnd);
     if (!matched.includes(handlerId)) continue;
 
@@ -124,7 +118,6 @@ export function evictHandlerCode(
     modified =
       modified.slice(0, startMatch.index) + stub + modified.slice(rangeEnd);
 
-    // Remove the now-redundant $$id assignment line.
     modified = modified.replace(
       new RegExp(`\\n${eName}\\.\\$\\$id\\s*=\\s*"[^"]+";`),
       "",

package/src/vite/utils/client-chunks.ts

@@ -1,9 +1,3 @@
-// Resolution of the public `clientChunks` option into the callback shape that
-// @vitejs/plugin-rsc expects. See plugin-types.ts (ClientChunks) and
-// docs/client-chunking.md for the contract. The mechanism: a distinct returned
-// name yields a distinct, dynamically-imported client chunk, independent of how
-// the RSC/server build chunked the importing modules.
-
 import type { ClientChunkMeta, ClientChunks } from "../plugin-types.js";
 import { createRangoDebugger, NS } from "../debug.js";
 import { hashRefKey } from "../plugins/client-ref-hashing.js";

package/src/vite/utils/directive-prologue.ts

@@ -0,0 +1,40 @@
+import { parseAst } from "vite";
+
+/**
+ * Detect a leading `"use client"` (or `'use client'`) directive in a module's
+ * directive prologue, tolerating leading comments/whitespace before it.
+ *
+ * A bare `source.trimStart().startsWith` check only strips whitespace, so a
+ * license banner / `// @ts-nocheck` before the directive would be missed. This
+ * walks the leading ExpressionStatement string-literal directives via the AST
+ * (a leading comment is not a `program.body` node), the single source of truth
+ * shared by both the rango plugin's HMR client-module sniff and the version
+ * plugin's getClientModuleSignature — so the two can never drift on what counts
+ * as a client module.
+ *
+ * Returns false when the source cannot be parsed (a syntactically broken file is
+ * not treated as a client module).
+ */
+export function hasUseClientDirective(source: string): boolean {
+  let program: { body?: any[] };
+  try {
+    program = parseAst(source, { lang: "tsx" }) as { body?: any[] };
+  } catch {
+    return false;
+  }
+  for (const node of program.body ?? []) {
+    if (
+      node?.type === "ExpressionStatement" &&
+      node.expression?.type === "Literal" &&
+      typeof node.expression.value === "string"
+    ) {
+      if (node.expression.value === "use client") return true;
+      // Another leading string-literal directive (e.g. "use strict"): keep
+      // scanning the prologue.
+      continue;
+    }
+    // First non-directive statement ends the prologue.
+    break;
+  }
+  return false;
+}

package/src/vite/utils/forward-user-plugins.ts

@@ -1,25 +1,3 @@
-/**
- * Discovery Runner Config Parity
- *
- * The discovery temp server (createTempRscServer) runs the user's handler
- * graph through a throwaway Node Vite server built with `configFile: false`.
- * Without help, that server only sees a fixed Rango-owned plugin set, so any
- * user resolution is absent during discovery, prerender, and static handler
- * rendering — even though it applies at request time. Two flavors of user
- * resolution must be carried across:
- *
- * - Third-party resolveId plugins (e.g. vite-tsconfig-paths) — forwarded as
- *   plugin instances, see selectForwardableResolvePlugins.
- * - Native config-driven resolution, including Vite 8's built-in
- *   `resolve.tsconfigPaths` (which supersedes vite-tsconfig-paths) — forwarded
- *   as the data slice, see pickForwardedRunnerConfig.
- *
- * These helpers extract the resolution-relevant slice of the user's resolved
- * config (resolve.*, define, oxc) and forward the user's resolution plugins
- * into the temp server so discovery resolves modules the same way the real
- * environment does.
- */
-
 import type { Plugin, ResolvedConfig, UserConfig } from "vite";
 
 /**

package/src/vite/utils/manifest-utils.ts

@@ -1,78 +1,7 @@
-/**
- * Flatten prefix tree leaf nodes into precomputed route entries.
- * Leaf nodes have no children (no nested includes), so their routes can be
- * used directly by evaluateLazyEntry() without running the handler.
- * Non-leaf nodes are skipped because they have nested lazy includes that
- * require the handler to run for discovery.
- *
- * A leaf is also skipped when its staticPrefix collides with an ancestor
- * include node's staticPrefix. That happens when a dynamic param collapses the
- * staticPrefix of nested includes onto the parent's (e.g. `/m/:id/edit` -> sp
- * `/m`): precomputing such a leaf under the collapsed prefix would let the
- * ancestor's lazy entry claim a route it cannot register (the route is behind
- * further nested lazy includes), producing a RouteNotFoundError at request time
- * (issue #506). Those routes are resolved via the handler chain instead.
- */
-export function flattenLeafEntries(
-  prefixTree: Record<string, any>,
-  routeManifest: Record<string, string>,
-  result: Array<{ staticPrefix: string; routes: Record<string, string> }>,
-): void {
-  function visit(node: any, ancestorStaticPrefixes: Set<string>): void {
-    const children = node.children || {};
-    if (
-      Object.keys(children).length === 0 &&
-      node.routes &&
-      node.routes.length > 0
-    ) {
-      // Leaf node. Skip if its staticPrefix collides with an ancestor include
-      // node's staticPrefix (dynamic-param collapse) — see doc comment above.
-      if (ancestorStaticPrefixes.has(node.staticPrefix)) {
-        return;
-      }
-      // Collect its routes from the manifest
-      const routes: Record<string, string> = {};
-      for (const name of node.routes) {
-        if (name in routeManifest) {
-          routes[name] = routeManifest[name];
-        }
-      }
-      result.push({ staticPrefix: node.staticPrefix, routes });
-    } else {
-      // Non-leaf: recurse into children, tracking this node's staticPrefix as
-      // an ancestor so a collapsed nested leaf below it is not over-claimed.
-      const nextAncestors = new Set(ancestorStaticPrefixes);
-      nextAncestors.add(node.staticPrefix);
-      for (const child of Object.values(children)) {
-        visit(child, nextAncestors);
-      }
-    }
-  }
-  for (const node of Object.values(prefixTree)) {
-    visit(node, new Set());
-  }
-}
-
-/**
- * Walk prefix tree to map each route name to its scope's staticPrefix.
- */
-export function buildRouteToStaticPrefix(
-  prefixTree: Record<string, any>,
-  result: Record<string, string>,
-): void {
-  function visit(node: any): void {
-    const sp = node.staticPrefix || "";
-    for (const name of node.routes || []) {
-      result[name] = sp;
-    }
-    for (const child of Object.values(node.children || {})) {
-      visit(child);
-    }
-  }
-  for (const node of Object.values(prefixTree)) {
-    visit(node);
-  }
-}
+export {
+  flattenLeafEntries,
+  buildRouteToStaticPrefix,
+} from "../../build/prefix-tree-utils.js";
 
 /**
  * Wrap a value as `JSON.parse('...')` instead of a JS object literal.