@rangojs/router 0.27.0 → 0.28.0

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

@@ -437,7 +437,7 @@ async function discoverRoutersPass(
   // while runtime (trie-ranked: wildcard last) matches the real route and
   // misses the manifest — wrong-content bake for plain Prerender routes, a
   // guaranteed 404 once handler eviction runs. Dev never hits this because
-  // propagateDiscoveryState (router-discovery.ts) pushes the same setters on
+  // propagateDiscoveryState (dev-server-phase.ts) pushes the same setters on
   // every discovery/HMR pass; configureServer early-returns in build mode, so
   // collection was the one findMatch consumer running trieless. Mirrors the
   // dev perRouterSetters loop; deliberately does NOT markRouterTrieAuthoritative

package/src/vite/discovery/discovery-errors.ts

@@ -209,7 +209,7 @@ export interface DiscoveryFailureReport {
  *   - a transient artifact of a Vite dependency re-optimization racing with boot
  *     discovery (a module read before the entry import resolves to the
  *     pre-optimize copy of the runner graph while createRouter() populated the
- *     post-optimize copy — see router-discovery.ts).
+ *     post-optimize copy — see dev-server-phase.ts).
  *
  * We can only tell them apart when the caller observed the dep optimizer's
  * `browserHash` change across the discovery attempt (`reoptimizeObserved`): a

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

@@ -7,6 +7,7 @@
  */
 
 import { contextSet, hasContextVars } from "../../context-var.js";
+import { prerenderManifestEntries } from "../../prerender/store.js";
 import { sha256 } from "./build-versions.js";
 import {
   createGetParamsReverse,
@@ -17,6 +18,7 @@ import {
   notifyOnError,
   resolvePrerenderError,
   stageBuildAssetModule,
+  warnLiveIntercepts,
 } from "../utils/prerender-utils.js";
 import type { DiscoveryState } from "./state.js";
 import { createRangoDebugger, NS } from "../debug.js";
@@ -250,6 +252,7 @@ export async function expandPrerenderRoutes(
   const manifestEntries: Record<string, string> = {};
   let doneCount = 0;
   let skipCount = 0;
+  const warnedLiveIntercepts = new Set<string>();
   // #587: a render error reaches here (matchForPrerender now re-throws it rather
   // than baking the error boundary). Default "fail" fails the build; "warn" logs
   // and skips baking the URL.
@@ -288,20 +291,20 @@ export async function expandPrerenderRoutes(
               break;
             }
 
+            const stage = ([key, value]: [string, string]): void => {
+              manifestEntries[key] = stageBuildAssetModule(
+                state.projectRoot,
+                "__pr",
+                value,
+              );
+              recordBuildData(state, "prerender", key, value, { routerId });
+            };
             const paramHash = hashParams(result.params || {});
-            const mainKey = `${result.routeName}/${paramHash}`;
-            const mainValue = JSON.stringify({
-              segments: result.segments,
-              handles: result.handles,
-            });
-            manifestEntries[mainKey] = stageBuildAssetModule(
-              state.projectRoot,
-              "__pr",
-              mainValue,
+            const [main, intercept] = prerenderManifestEntries(
+              result,
+              paramHash,
             );
-            recordBuildData(state, "prerender", mainKey, mainValue, {
-              routerId,
-            });
+            stage(main);
             // Prerender + ppr composition: flag the URL as a build-time shell
             // candidate for the post-build capture phase (producer B, #699).
             // The payload JSON is retained in memory so that phase can seed an
@@ -313,38 +316,20 @@ export async function expandPrerenderRoutes(
                 paramHash,
                 ppr: result.ppr === true ? true : result.ppr,
               });
-              (state.prerenderPayloadValues ??= new Map()).set(
-                mainKey,
-                mainValue,
-              );
-            }
-            if (result.interceptSegments?.length) {
-              const interceptKey = `${result.routeName}/${paramHash}/i`;
-              const interceptValue = JSON.stringify({
-                segments: [...result.segments, ...result.interceptSegments],
-                // interceptHandles is the pre-encoded MERGED (main + intercept)
-                // handle string (the producer merged before encoding).
-                handles: result.interceptHandles ?? "",
-              });
-              manifestEntries[interceptKey] = stageBuildAssetModule(
-                state.projectRoot,
-                "__pr",
-                interceptValue,
-              );
-              recordBuildData(
-                state,
-                "prerender",
-                interceptKey,
-                interceptValue,
-                {
-                  routerId,
-                },
-              );
+              (state.prerenderPayloadValues ??= new Map()).set(...main);
             }
+            if (intercept) stage(intercept);
             const elapsed = (performance.now() - startUrl).toFixed(0);
             console.log(
               `[rango]   OK   ${entry.urlPath.padEnd(40)} (${elapsed}ms)`,
             );
+            warnLiveIntercepts(
+              warnedLiveIntercepts,
+              routerId,
+              result.routeName,
+              entry.urlPath,
+              result.liveIntercepts,
+            );
             doneCount++;
             break;
           } catch (err: any) {

package/src/vite/discovery/state.ts

@@ -124,6 +124,9 @@ export interface DiscoveryState {
   resolvedEntryPath: string | undefined;
   projectRoot: string;
   isBuildMode: boolean;
+  /** Vite's resolved command and mode (configResolved), for resolveBuildEnv. */
+  viteCommand: "serve" | "build";
+  viteMode: string;
   userResolveAlias: any;
   /**
    * Data-only slice of the user's resolved config (resolve.* incl. native
@@ -212,6 +215,15 @@ export interface DiscoveryState {
   devDiscoveryEpoch?: number;
   devServerOrigin: string | null;
   devServer: any;
+  /**
+   * Dev: the pending transition({ when }) definition error, re-sent as the
+   * Vite error overlay until a discovery succeeds (dev-server-phase.ts).
+   */
+  transitionWhenOverlay: {
+    message: string;
+    stack: string;
+    plugin: string;
+  } | null;
   selfWrittenGenFiles: Map<string, { at: number; hash: string }>;
   SELF_WRITE_WINDOW_MS: number;
 
@@ -261,6 +273,8 @@ export function createDiscoveryState(
     resolvedEntryPath: entryPath,
     projectRoot: "",
     isBuildMode: false,
+    viteCommand: "build",
+    viteMode: "production",
     userResolveAlias: undefined,
     userRunnerConfig: undefined,
     userResolvePlugins: [],
@@ -300,6 +314,7 @@ export function createDiscoveryState(
     devDiscoveryEpoch: opts?.preset === "cloudflare" ? Date.now() : undefined,
     devServerOrigin: null,
     devServer: null,
+    transitionWhenOverlay: null,
     selfWrittenGenFiles: new Map(),
     SELF_WRITE_WINDOW_MS: 5_000,
     lastDiscoveryError: null,

package/src/vite/plugins/version-plugin.ts

@@ -115,7 +115,7 @@ function getClientModuleSignature(
  * Build: exports a placeholder for the per-router versions table. The module
  * holds nothing that varies between builds; the table is written into the
  * built chunk after the server output is hashed (the buildApp post hook in
- * router-discovery.ts). See docs/design/per-app-cache-version.md.
+ * discovery/build-discovery-phase.ts). See docs/design/per-app-cache-version.md.
  * @internal
  */
 export function createVersionPlugin(): Plugin {

package/src/vite/plugins/virtual-entries.ts

@@ -354,7 +354,7 @@ export function getVirtualVersionContent(version: string): string {
 /**
  * Free identifier the production version module ships in place of the table.
  * The versions are hashes of the built server code, so they cannot be part of
- * it: the buildApp post hook (router-discovery.ts) replaces this token in the
+ * it: the buildApp post hook (discovery/build-discovery-phase.ts) replaces this token in the
  * written chunk once the hashes are final (runRouterVersionsPhase,
  * discovery/router-versions-phase.ts). An unreplaced token throws a ReferenceError
  * when the module evaluates, so a build that skipped the step cannot serve