@rangojs/router 0.0.0-experimental.110 → 0.0.0-experimental.112

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";
 
@@ -33,7 +33,7 @@ export function generateClientLoaderStubs(
 
   for (const binding of bindings) {
     for (const name of binding.exportNames) {
-      const loaderId = isBuild ? hashId(filePath, name) : `${filePath}#${name}`;
+      const loaderId = makeStubId(filePath, name, isBuild);
       lines.push(
         `export const ${name} = { __brand: "loader", $$id: "${loaderId}" };`,
       );
@@ -54,9 +54,7 @@ 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")

package/src/vite/plugins/expose-internal-ids.ts

@@ -39,7 +39,6 @@ import {
   transformHandles,
   transformLocationState,
   generateWholeFileStubs,
-  generateExprStubs,
   stubHandlerExprs,
   transformHandlerIds,
 } from "./expose-ids/handler-transform.js";
@@ -424,17 +423,6 @@ ${lazyImports.join(",\n")}
           if (wholeFile) return wholeFile;
         }
 
-        // --- PrerenderHandler: RSC build module tracking ---
-        if (hasPrerenderHandlerCode && isRscEnv && isBuild) {
-          const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
-          const exportNames = getBindings(code, fnNames).map(
-            (b) => b.exportNames[0],
-          );
-          if (exportNames.length > 0) {
-            prerenderHandlerModules.set(id, exportNames);
-          }
-        }
-
         // --- Inline handler extraction to virtual modules ---
         // Runs before stubs/tracking so inline calls become imports, then
         // the existing regex fast path handles both the original file's
@@ -710,14 +698,27 @@ ${lazyImports.join(",\n")}
           }
         }
 
-        // --- StaticHandler: RSC build module tracking ---
-        if (hasStaticHandlerCode && isRscEnv && isBuild) {
-          const fnNames = getFnNames(STATIC_CONFIG.fnName);
-          const exportNames = getBindings(code, fnNames).map(
-            (b) => b.exportNames[0],
-          );
-          if (exportNames.length > 0) {
-            staticHandlerModules.set(id, exportNames);
+        // RSC build module tracking (prerender + static), consumed via the
+        // plugin API for prerender freezing. Export-binding sets are invariant
+        // across the inline-extraction loop, so tracking both here is equivalent
+        // to the pre-extraction prerender tracking this replaces.
+        if (isRscEnv && isBuild) {
+          const trackTypes: Array<
+            [boolean, HandlerTransformConfig, Map<string, string[]>]
+          > = [
+            [
+              hasPrerenderHandlerCode,
+              PRERENDER_CONFIG,
+              prerenderHandlerModules,
+            ],
+            [hasStaticHandlerCode, STATIC_CONFIG, staticHandlerModules],
+          ];
+          for (const [has, cfg, trackMap] of trackTypes) {
+            if (!has) continue;
+            const exportNames = getBindings(code, getFnNames(cfg.fnName)).map(
+              (b) => b.exportNames[0],
+            );
+            if (exportNames.length > 0) trackMap.set(id, exportNames);
           }
         }
 
@@ -758,48 +759,19 @@ ${lazyImports.join(",\n")}
               isBuild,
             ) || changed;
         }
-        if (hasPrerenderHandlerCode) {
-          const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
-          const bindings = getBindings(code, fnNames);
-          if (isRscEnv) {
-            changed =
-              transformHandlerIds(
-                PRERENDER_CONFIG,
-                bindings,
-                s,
-                filePath,
-                isBuild,
-              ) || changed;
-          } else {
-            // Non-RSC mixed-export file: replace Prerender() calls with stubs
-            // on the shared MagicString so sourcemaps stay accurate.
-            changed =
-              stubHandlerExprs(
-                PRERENDER_CONFIG,
-                bindings,
-                s,
-                filePath,
-                isBuild,
-              ) || changed;
-          }
-        }
-        if (hasStaticHandlerCode) {
-          const fnNames = getFnNames(STATIC_CONFIG.fnName);
-          const bindings = getBindings(code, fnNames);
-          if (isRscEnv) {
-            changed =
-              transformHandlerIds(
-                STATIC_CONFIG,
-                bindings,
-                s,
-                filePath,
-                isBuild,
-              ) || changed;
-          } else {
-            changed =
-              stubHandlerExprs(STATIC_CONFIG, bindings, s, filePath, isBuild) ||
-              changed;
-          }
+        // Prerender + Static share the RSC inject-id vs non-RSC stub dispatch.
+        // Call sites are disjoint (distinct fnNames), so loop order is irrelevant.
+        const finalHandlerConfigs = [
+          hasPrerenderHandlerCode && PRERENDER_CONFIG,
+          hasStaticHandlerCode && STATIC_CONFIG,
+        ].filter((c): c is HandlerTransformConfig => !!c);
+        for (const cfg of finalHandlerConfigs) {
+          const bindings = getBindings(code, getFnNames(cfg.fnName));
+          changed =
+            (isRscEnv
+              ? transformHandlerIds(cfg, bindings, s, filePath, isBuild)
+              : stubHandlerExprs(cfg, bindings, s, filePath, isBuild)) ||
+            changed;
         }
 
         if (!changed) return;

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

@@ -1,6 +1,7 @@
 import type { Plugin } from "vite";
 import { resolve } from "node:path";
 import * as Vite from "vite";
+import { resolveRscEntryFromConfig } from "../utils/shared-utils.js";
 
 /**
  * Plugin that auto-injects VERSION and routes-manifest into custom entry.rsc files.
@@ -20,18 +21,7 @@ export function createVersionInjectorPlugin(
 
     configResolved(config) {
       let entryPath = rscEntryPath;
-      // Cloudflare preset: read entry from resolved environment config.
-      // The @cloudflare/vite-plugin reads wrangler config (toml/json/jsonc)
-      // and sets optimizeDeps.entries on the RSC environment.
-      if (!entryPath) {
-        const rscEnvConfig = (config.environments as any)?.["rsc"];
-        const entries = rscEnvConfig?.optimizeDeps?.entries;
-        if (typeof entries === "string") {
-          entryPath = entries;
-        } else if (Array.isArray(entries) && entries.length > 0) {
-          entryPath = entries[0];
-        }
-      }
+      if (!entryPath) entryPath = resolveRscEntryFromConfig(config);
       if (entryPath) {
         resolvedEntryPath = resolve(config.root, entryPath);
       }

package/src/vite/router-discovery.ts

@@ -52,6 +52,7 @@ import {
 import { postprocessBundle } from "./discovery/bundle-postprocess.js";
 import { createDiscoveryGate } from "./discovery/gate-state.js";
 import { resetStagedBuildAssets } from "./utils/prerender-utils.js";
+import { resolveRscEntryFromConfig } from "./utils/shared-utils.js";
 import {
   pickForwardedRunnerConfig,
   selectForwardableResolvePlugins,
@@ -347,17 +348,10 @@ export function createRouterDiscoveryPlugin(
       if (!s.resolvedEntryPath && opts?.routerPathRef?.path) {
         s.resolvedEntryPath = opts.routerPathRef.path;
       }
-      // Cloudflare preset: read entry from resolved environment config.
-      // The @cloudflare/vite-plugin reads wrangler config (toml/json/jsonc)
-      // and sets optimizeDeps.entries on the RSC environment.
+      // Cloudflare preset: entry comes from the resolved RSC env config.
       if (!s.resolvedEntryPath) {
-        const rscEnvConfig = (config.environments as any)?.["rsc"];
-        const entries = rscEnvConfig?.optimizeDeps?.entries;
-        if (typeof entries === "string") {
-          s.resolvedEntryPath = entries;
-        } else if (Array.isArray(entries) && entries.length > 0) {
-          s.resolvedEntryPath = entries[0];
-        }
+        const entry = resolveRscEntryFromConfig(config);
+        if (entry) s.resolvedEntryPath = entry;
       }
       // Generate combined named-routes.gen.ts from static source parsing.
       // Runs before the dev server starts so the gen file exists immediately for IDE.
@@ -794,20 +788,15 @@ export function createRouterDiscoveryPlugin(
         if (s.mergedRouteTrie && serverMod.setRouteTrie) {
           serverMod.setRouteTrie(s.mergedRouteTrie);
         }
-        if (serverMod.setRouterManifest) {
-          for (const [routerId, manifest] of s.perRouterManifestDataMap) {
-            serverMod.setRouterManifest(routerId, manifest);
-          }
-        }
-        if (serverMod.setRouterTrie) {
-          for (const [routerId, trie] of s.perRouterTrieMap) {
-            serverMod.setRouterTrie(routerId, trie);
-          }
-        }
-        if (serverMod.setRouterPrecomputedEntries) {
-          for (const [routerId, entries] of s.perRouterPrecomputedMap) {
-            serverMod.setRouterPrecomputedEntries(routerId, entries);
-          }
+        const perRouterSetters: Array<[Map<string, any>, string]> = [
+          [s.perRouterManifestDataMap, "setRouterManifest"],
+          [s.perRouterTrieMap, "setRouterTrie"],
+          [s.perRouterPrecomputedMap, "setRouterPrecomputedEntries"],
+        ];
+        for (const [map, fn] of perRouterSetters) {
+          const setter = serverMod[fn];
+          if (typeof setter !== "function") continue;
+          for (const [routerId, value] of map) setter(routerId, value);
         }
       };
 
@@ -1024,6 +1013,16 @@ export function createRouterDiscoveryPlugin(
                 );
                 s.lastDiscoveryError = null;
               }
+              // Cloudflare dev: on a successful cycle drop the workerd runner's
+              // cached worker-entry chain so the next request re-evaluates
+              // createRouter() with the new routes. Fired here in the work path
+              // (not the caller's .then()) so a queued follow-up cycle that
+              // succeeds after an earlier failed cycle still reloads:
+              // runRefreshCycle recurses queued work without awaiting it, so the
+              // original call already resolved on the failed cycle. A failed
+              // cycle throws above and never reaches here, so a broken edit
+              // never reloads the worker onto bad source.
+              if (rscEnv && !rscEnv.runner) forceCloudflareWorkerReload(rscEnv);
             } catch (err: any) {
               s.lastDiscoveryError = {
                 message: err?.message ?? String(err),
@@ -1045,6 +1044,49 @@ export function createRouterDiscoveryPlugin(
           });
         };
 
+        // Cloudflare dev only. workerd serves every request through the
+        // runner-worker singleton, which re-resolves the worker entry per
+        // request via runner.import("virtual:cloudflare/worker-entry"). The
+        // route table lives in the user's createRouter() instance, captured
+        // when that entry chain (entry -> router -> urls) was last evaluated
+        // and then cached in the runner's evaluatedModules. The route-file
+        // watcher refreshes discovery + types on the Node side, but the worker
+        // keeps serving the cached (stale) router: route-definition modules
+        // have no import.meta.hot boundary, so Vite never sends the worker an
+        // HMR update for them and the entry chain is never evicted.
+        //
+        // Fix: after discovery completes, (1) invalidate the worker env's
+        // Node-side module graph, then (2) send a full-reload to the worker.
+        // Step (2) alone is insufficient: the full-reload handler clears the
+        // runner's evaluatedModules and re-imports entrypoints, but each
+        // re-import fetches the module back through this Node-side graph, which
+        // still holds the pre-edit transform of urls.tsx — so createRouter()
+        // rebuilds the stale route table and the new route 404s/hits the
+        // catch-all. Invalidating the graph forces a fresh transform on
+        // re-fetch (the same mechanism refreshTempRscEnv uses for discovery),
+        // so the re-import re-runs createRouter() with the new routes. This is
+        // the programmatic equivalent of the dev-server "r + enter" restart,
+        // scoped to the worker environment instead of tearing down the server.
+        const forceCloudflareWorkerReload = (rscEnv: any) => {
+          if (!rscEnv?.hot) return;
+          try {
+            const graph = rscEnv.moduleGraph;
+            if (graph?.invalidateAll) {
+              graph.invalidateAll();
+              debugDiscovery?.("hmr: invalidated workerd rsc module graph");
+            }
+            rscEnv.hot.send({ type: "full-reload" });
+            debugDiscovery?.(
+              "hmr: forced workerd rsc env reload (full-reload)",
+            );
+          } catch (err: any) {
+            debugDiscovery?.(
+              "hmr: workerd reload failed: %s",
+              err?.message ?? err,
+            );
+          }
+        };
+
         const scheduleRouteRegeneration = () => {
           clearTimeout(routeChangeTimer);
           routeChangeTimer = setTimeout(() => {
@@ -1083,12 +1125,15 @@ export function createRouterDiscoveryPlugin(
             // routes that the static parser cannot resolve. Resolves the
             // discovery gate when complete.
             if (s.perRouterManifests.length > 0) {
+              // The cloudflare workerd reload fires inside refreshRuntimeDiscovery
+              // on the successful cycle (see forceCloudflareWorkerReload call
+              // there) so queued follow-up cycles also trigger it.
               refreshRuntimeDiscovery().catch((err: any) => {
                 console.warn(
                   `[rango] Runtime re-discovery error: ${err.message}`,
                 );
-                // Even on error, unblock the gate so workerd's reload
-                // doesn't hang indefinitely against the previous manifest.
+                // Even on error, unblock the gate so workerd's reload doesn't
+                // hang indefinitely against the previous manifest.
                 resolveDiscoveryGate();
               });
             }

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

@@ -1,4 +1,4 @@
-import type { Plugin } from "vite";
+import type { Plugin, ResolvedConfig } from "vite";
 import * as Vite from "vite";
 import { getPublishedPackageName } from "./package-resolution.js";
 import { performanceTracksOptimizeDepsPlugin } from "../plugins/performance-tracks.js";
@@ -10,6 +10,18 @@ import {
   VIRTUAL_IDS,
 } from "../plugins/virtual-entries.js";
 
+// Cloudflare preset: @cloudflare/vite-plugin sets optimizeDeps.entries (string
+// or array) on the rsc environment. Single source for both the discovery plugin
+// and the version injector so they target the same entry.
+export function resolveRscEntryFromConfig(
+  config: ResolvedConfig,
+): string | undefined {
+  const entries = (config.environments as any)?.["rsc"]?.optimizeDeps?.entries;
+  if (typeof entries === "string") return entries;
+  if (Array.isArray(entries) && entries.length > 0) return entries[0];
+  return undefined;
+}
+
 /**
  * Rolldown plugin to provide the version virtual module during dependency
  * optimization. Vite 8 optimizes deps with Rolldown (a Rollup-style plugin

package/src/browser/action-response-classifier.ts

@@ -1,99 +0,0 @@
-/**
- * Discriminated union of post-reconciliation action response scenarios.
- *
- * Error and full-update-unsupported are handled inline in the bridge
- * before reconciliation. This classifier only runs for partial responses
- * that have been successfully reconciled.
- */
-export type ActionScenario =
-  | {
-      type: "navigated-away";
-      historyKeyChanged: boolean;
-      onInterceptRoute: boolean;
-    }
-  | { type: "hmr-missing" }
-  | { type: "consolidation-needed"; segmentIds: string[] }
-  | { type: "concurrent-skip"; otherFetchingCount: number }
-  | { type: "normal" };
-
-/**
- * Pure data inputs for classifying a partial action response.
- * All values come from the bridge but no browser APIs or side effects.
- */
-export interface ClassifierInput {
-  /** window.location.pathname captured at action start */
-  actionStartPathname: string;
-  /** window.location.pathname at classification time */
-  currentPathname: string;
-  /** window.history.state?.key captured at action start */
-  actionStartLocationKey: string | undefined;
-  /** window.history.state?.key at classification time */
-  currentLocationKey: string | undefined;
-  /** Number of segments after reconciliation */
-  reconciledSegmentCount: number;
-  /** Number of matched segment IDs from server */
-  matchedCount: number;
-  /** Segment IDs needing consolidation (from concurrent action tracking) */
-  consolidationSegments: string[] | null;
-  /** Number of other actions still in "fetching" phase */
-  otherFetchingActionCount: number;
-  /** Current intercept source URL (null when not on intercept route) */
-  currentInterceptSource: string | null;
-}
-
-/**
- * Classify a partial action response into one of 5 post-reconciliation
- * scenarios.
- *
- * Called after error and full-update cases are handled inline by the bridge.
- * The classification order matches the priority chain:
- * 1. User navigated away during action
- * 2. HMR missing segments (fewer reconciled than matched)
- * 3. Consolidation needed (concurrent actions finished)
- * 4. Concurrent skip (other actions still fetching)
- * 5. Normal (single action, no issues)
- *
- * This is a pure function with no side effects - the bridge handles
- * all UI updates, store mutations, and network requests based on the
- * returned scenario.
- */
-export function classifyActionResponse(input: ClassifierInput): ActionScenario {
-  // Check if user navigated away during the action
-  const userNavigatedAway =
-    input.currentPathname !== input.actionStartPathname ||
-    input.currentLocationKey !== input.actionStartLocationKey;
-
-  if (userNavigatedAway) {
-    const historyKeyChanged =
-      input.currentLocationKey !== input.actionStartLocationKey;
-    return {
-      type: "navigated-away",
-      historyKeyChanged,
-      onInterceptRoute: input.currentInterceptSource !== null,
-    };
-  }
-
-  // HMR resilience: segments missing after reconciliation
-  if (input.reconciledSegmentCount < input.matchedCount) {
-    return { type: "hmr-missing" };
-  }
-
-  // Consolidation needed for concurrent actions
-  if (input.consolidationSegments && input.consolidationSegments.length > 0) {
-    return {
-      type: "consolidation-needed",
-      segmentIds: input.consolidationSegments,
-    };
-  }
-
-  // Other actions still fetching - skip UI update
-  if (input.otherFetchingActionCount > 0) {
-    return {
-      type: "concurrent-skip",
-      otherFetchingCount: input.otherFetchingActionCount,
-    };
-  }
-
-  // Normal single-action completion
-  return { type: "normal" };
-}