@rangojs/router 0.0.0-experimental.18 → 0.0.0-experimental.19

package/src/vite/router-discovery.ts

@@ -292,10 +292,7 @@ export function createRouterDiscoveryPlugin(
             serverMod.setManifestReadyPromise(discoveryPromise);
           }
 
-          const serverModAfterDiscovery = await discoverRouters(s, rscEnv);
-
-          // Save registry for the /__rsc_prerender endpoint (avoids creating a temp server)
-          mainRegistry = serverModAfterDiscovery?.RouterRegistry ?? null;
+          await discoverRouters(s, rscEnv);
 
           // Store server origin for dev prerender endpoint (virtual module injection)
           s.devServerOrigin = getDevServerOrigin();
@@ -307,37 +304,8 @@ export function createRouterDiscoveryPlugin(
           // won't cause unnecessary HMR triggers.
           writeRouteTypesFiles(s);
 
-          // Populate the route map in the RSC env
-          if (s.mergedRouteManifest && serverMod?.setCachedManifest) {
-            serverMod.setCachedManifest(s.mergedRouteManifest);
-          }
-          if (
-            s.mergedPrecomputedEntries &&
-            s.mergedPrecomputedEntries.length > 0 &&
-            serverMod?.setPrecomputedEntries
-          ) {
-            serverMod.setPrecomputedEntries(s.mergedPrecomputedEntries);
-          }
-          if (s.mergedRouteTrie && serverMod?.setRouteTrie) {
-            serverMod.setRouteTrie(s.mergedRouteTrie);
-          }
-          // Populate per-router isolated data eagerly in dev (HMR).
-          // In production builds, per-router data is loaded lazily via import().
-          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);
-            }
-          }
+          // Populate the route map and per-router data in the RSC env
+          await propagateDiscoveryState(rscEnv);
         } catch (err: any) {
           console.warn(
             `[rsc-router] Router discovery failed: ${err.message}\n${err.stack}`,
@@ -365,6 +333,49 @@ export function createRouterDiscoveryPlugin(
       // Registry from the main server's RSC environment (populated by discoverRouters)
       let mainRegistry: Map<string, any> | null = null;
 
+      // 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.
+      const propagateDiscoveryState = async (rscEnv: any) => {
+        const serverMod = await rscEnv.runner.import("@rangojs/router/server");
+        if (!serverMod) return;
+        // Clear stale per-router and global route data before repopulating.
+        // Without this, removed routers/routes survive in the per-router maps
+        // and shrunk precomputed entries or tries are never purged.
+        if (serverMod.clearAllRouterData) {
+          serverMod.clearAllRouterData();
+        }
+        mainRegistry = serverMod.RouterRegistry ?? null;
+        if (s.mergedRouteManifest && serverMod.setCachedManifest) {
+          serverMod.setCachedManifest(s.mergedRouteManifest);
+        }
+        if (
+          s.mergedPrecomputedEntries &&
+          s.mergedPrecomputedEntries.length > 0 &&
+          serverMod.setPrecomputedEntries
+        ) {
+          serverMod.setPrecomputedEntries(s.mergedPrecomputedEntries);
+        }
+        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);
+          }
+        }
+      };
+
       server.middlewares.use("/__rsc_prerender", async (req: any, res: any) => {
         if (s.discoveryDone) await s.discoveryDone;
 
@@ -396,12 +407,24 @@ export function createRouterDiscoveryPlugin(
         }
 
         const wantIntercept = url.searchParams.get("intercept") === "1";
+        const wantRouteName = url.searchParams.get("routeName");
+        const wantPassthrough = url.searchParams.get("passthrough") === "1";
 
         for (const [, routerInstance] of registry) {
           if (!routerInstance.matchForPrerender) continue;
           try {
-            const result = await routerInstance.matchForPrerender(pathname, {});
+            const result = await routerInstance.matchForPrerender(
+              pathname,
+              {},
+              undefined,
+              wantPassthrough,
+            );
             if (!result) continue;
+            if (result.passthrough) continue;
+            // When routeName is specified, only accept a match for that route.
+            // This prevents returning the wrong entry when multiple routers
+            // have prerenderable routes sharing the same pathname.
+            if (wantRouteName && result.routeName !== wantRouteName) continue;
             res.setHeader("content-type", "application/json");
             let payload: Record<string, unknown>;
             if (wantIntercept && result.interceptSegments?.length) {
@@ -449,6 +472,13 @@ export function createRouterDiscoveryPlugin(
         ): boolean => {
           if (!isGeneratedRouteFile(filePath)) return false;
           if (consumeSelfGenWrite(s, filePath)) return true;
+          // In Cloudflare dev (no module runner), perRouterManifests is never
+          // refreshed after HMR so regenerateGeneratedRouteFiles() would use
+          // stale data and revert user edits. Source files own route state;
+          // gen files are derived output. Skip regeneration and let the next
+          // source-file change rebuild them from the static parser.
+          const hasRunner = !!(server.environments as any)?.rsc?.runner;
+          if (!hasRunner) return true;
           regenerateGeneratedRouteFiles();
           return true;
         };
@@ -459,6 +489,26 @@ export function createRouterDiscoveryPlugin(
         // only the expensive regeneration is debounced.
         let routeChangeTimer: ReturnType<typeof setTimeout> | undefined;
 
+        // Re-run runtime discovery so factory-generated routes that the
+        // static parser cannot see are refreshed after source changes.
+        let runtimeRediscoveryInProgress = false;
+        const refreshRuntimeDiscovery = async () => {
+          const rscEnv = (server.environments as any)?.rsc;
+          if (!rscEnv?.runner || runtimeRediscoveryInProgress) return;
+          runtimeRediscoveryInProgress = true;
+          try {
+            await discoverRouters(s, rscEnv);
+            writeRouteTypesFiles(s);
+            await propagateDiscoveryState(rscEnv);
+          } catch (err: any) {
+            console.warn(
+              `[rsc-router] Runtime re-discovery failed: ${err.message}`,
+            );
+          } finally {
+            runtimeRediscoveryInProgress = false;
+          }
+        };
+
         const scheduleRouteRegeneration = () => {
           clearTimeout(routeChangeTimer);
           routeChangeTimer = setTimeout(() => {
@@ -473,6 +523,15 @@ export function createRouterDiscoveryPlugin(
                 `[rsc-router] Route regeneration error: ${err.message}`,
               );
             }
+            // Async: re-run runtime discovery to refresh factory-generated
+            // routes that the static parser cannot resolve.
+            if (s.perRouterManifests.length > 0) {
+              refreshRuntimeDiscovery().catch((err: any) => {
+                console.warn(
+                  `[rsc-router] Runtime re-discovery error: ${err.message}`,
+                );
+              });
+            }
           }, 100);
         };
 
@@ -515,8 +574,12 @@ export function createRouterDiscoveryPlugin(
         server.watcher.on("change", handleRouteFileChange);
 
         // Regenerate gen files when they are deleted (e.g. manual cleanup).
+        // Same no-runner guard as change/add: stale perRouterManifests would
+        // reintroduce reverted content.
         server.watcher.on("unlink", (filePath) => {
           if (!isGeneratedRouteFile(filePath)) return;
+          const hasRunner = !!(server.environments as any)?.rsc?.runner;
+          if (!hasRunner) return;
           regenerateGeneratedRouteFiles();
         });
       }

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

@@ -17,6 +17,27 @@ export function encodePathParam(value: unknown): string {
     .join("/");
 }
 
+/**
+ * Substitute route params into a pattern, stripping constraint and optional
+ * syntax (:param(a|b)? -> value). Also handles wildcard params (*key).
+ */
+export function substituteRouteParams(
+  pattern: string,
+  params: Record<string, string>,
+  encode: (value: string) => string = encodeURIComponent,
+): string {
+  let result = pattern;
+  for (const [key, value] of Object.entries(params)) {
+    const escaped = escapeRegExp(key);
+    result = result.replace(
+      new RegExp(`:${escaped}(\\([^)]*\\))?\\??`),
+      encode(value),
+    );
+    result = result.replace(`*${key}`, encode(value));
+  }
+  return result;
+}
+
 /**
  * Run an async function over items with bounded concurrency.
  * Errors propagate immediately and abort remaining work.

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

@@ -89,9 +89,11 @@ export function createVirtualEntriesPlugin(
         }
         // Lazy RSC entry: routerPath may have been set by a config() hook
         if (virtualId === VIRTUAL_IDS.rsc && routerPathRef?.path) {
-          const absoluteRouterPath = routerPathRef.path.startsWith(".")
+          const raw = routerPathRef.path.startsWith(".")
             ? "/" + routerPathRef.path.slice(2) // ./src/router.tsx -> /src/router.tsx
             : routerPathRef.path;
+          // Normalize backslashes for Windows (path.join/slice preserve native separators)
+          const absoluteRouterPath = raw.replaceAll("\\", "/");
           return getVirtualEntryRSC(absoluteRouterPath);
         }
       }

package/src/browser/request-controller.ts

@@ -1,164 +0,0 @@
-import type { RequestController, DisposableAbortController } from "./types.js";
-
-// Polyfill Symbol.dispose for Safari and older browsers
-if (typeof Symbol.dispose === "undefined") {
-  (Symbol as any).dispose = Symbol("Symbol.dispose");
-}
-
-/**
- * Create a request controller for managing concurrent abort controllers
- *
- * This utility helps manage concurrent navigation requests by providing
- * a way to abort all pending requests when a new navigation starts.
- *
- * @returns RequestController instance
- *
- * @example
- * ```typescript
- * const controller = createRequestController();
- *
- * // Start a new request
- * const abortController = controller.create();
- * fetch(url, { signal: abortController.signal });
- *
- * // Abort all pending requests (e.g., when starting new navigation)
- * controller.abortAll();
- *
- * // Clean up completed request
- * controller.remove(abortController);
- * ```
- */
-export function createRequestController(): RequestController {
-  // Navigation controllers - aborted on new navigation
-  // Using WeakRef to allow GC if controller is no longer referenced elsewhere
-  const controllers: WeakRef<AbortController>[] = [];
-  // Action controllers - NOT aborted by navigation, only by errors
-  const actionControllers: WeakRef<AbortController>[] = [];
-
-  /**
-   * Remove stale (garbage collected) refs from an array
-   */
-  function pruneStaleRefs(refs: WeakRef<AbortController>[]): void {
-    for (let i = refs.length - 1; i >= 0; i--) {
-      if (!refs[i].deref()) {
-        refs.splice(i, 1);
-      }
-    }
-  }
-
-  return {
-    /**
-     * Create a new abort controller and track it for navigation
-     *
-     * @returns A new AbortController
-     */
-    create(): AbortController {
-      const controller = new AbortController();
-      controllers.push(new WeakRef(controller));
-      console.log(
-        `[Browser] Created abort controller, total: ${controllers.length}`,
-      );
-      return controller;
-    },
-
-    /**
-     * Create a disposable abort controller for navigation use with `using` keyword
-     *
-     * The controller will be automatically removed from tracking when
-     * it goes out of scope, regardless of how the scope is exited.
-     *
-     * @returns A DisposableAbortController
-     *
-     * @example
-     * ```typescript
-     * async function handleNavigation() {
-     *   requestController.abortAll();
-     *   using { controller } = requestController.createDisposable();
-     *   // ... use controller.signal ...
-     *   // controller is automatically removed on scope exit
-     * }
-     * ```
-     */
-    createDisposable(): DisposableAbortController {
-      const controller = this.create();
-      return {
-        controller,
-        [Symbol.dispose]: () => {
-          this.remove(controller);
-        },
-      };
-    },
-
-    /**
-     * Create a disposable abort controller for actions
-     *
-     * Action controllers are NOT aborted by navigation - they complete
-     * independently. Only aborted by abortAllActions() on error.
-     *
-     * @returns A DisposableAbortController
-     */
-    createActionDisposable(): DisposableAbortController {
-      const controller = new AbortController();
-      const ref = new WeakRef(controller);
-      actionControllers.push(ref);
-      console.log(
-        `[Browser] Created action controller, total: ${actionControllers.length}`,
-      );
-      return {
-        controller,
-        [Symbol.dispose]: () => {
-          const index = actionControllers.indexOf(ref);
-          if (index !== -1) {
-            actionControllers.splice(index, 1);
-            console.log(
-              `[Browser] Removed action controller, remaining: ${actionControllers.length}`,
-            );
-          }
-        },
-      };
-    },
-
-    /**
-     * Abort all navigation controllers (NOT actions)
-     *
-     * Called when starting new navigation. Actions continue
-     * to complete in the background.
-     */
-    abortAll(): void {
-      controllers.forEach((ref) => ref.deref()?.abort());
-      controllers.length = 0;
-      console.log(`[Browser] Aborted all navigation controllers`);
-    },
-
-    /**
-     * Abort all action controllers
-     *
-     * Called when an action error occurs - prevents other actions
-     * from completing and overwriting the error UI.
-     */
-    abortAllActions(): void {
-      actionControllers.forEach((ref) => ref.deref()?.abort());
-      actionControllers.length = 0;
-      console.log(`[Browser] Aborted all action controllers`);
-    },
-
-    /**
-     * Remove a specific controller from tracking
-     *
-     * Call this when a request completes successfully.
-     *
-     * @param controller - The controller to remove
-     */
-    remove(controller: AbortController): void {
-      // Prune any stale refs while searching
-      pruneStaleRefs(controllers);
-      const index = controllers.findIndex((ref) => ref.deref() === controller);
-      if (index !== -1) {
-        controllers.splice(index, 1);
-        console.log(
-          `[Browser] Removed abort controller, remaining: ${controllers.length}`,
-        );
-      }
-    },
-  };
-}

package/src/href-context.ts

@@ -1,33 +0,0 @@
-"use client";
-
-/**
- * Href Context for route name resolution
- *
- * This module is marked "use client" so it can be imported by both:
- * - Server (segment-system): Gets a client reference for createElement
- * - Client (useHref): Uses the actual context for useContext
- *
- * The context stores:
- * - routeMap: Map of route names to URL patterns
- * - routeName: Current matched route name (for local name resolution)
- */
-import { createContext, type Context } from "react";
-
-/**
- * Context value for href resolution
- */
-export interface HrefContextValue {
-  /** Route map: route name -> URL pattern */
-  routeMap: Record<string, string>;
-  /** Current matched route name (includes name prefix from include()) */
-  routeName?: string;
-}
-
-/**
- * Context for href resolution (route map and current route name)
- *
- * On the server: Populated by renderSegments() via HrefContext.Provider
- * On the client: Populated by NavigationProvider from RSC metadata
- */
-export const HrefContext: Context<HrefContextValue | null> =
-  createContext<HrefContextValue | null>(null);

package/src/router.gen.ts

@@ -1,6 +0,0 @@
-// Auto-generated by @rangojs/router - do not edit
-export const routes = {
-  about: "/about",
-  home: "/",
-} as const;
-export type routes = typeof routes;

package/src/static-handler.gen.ts

@@ -1,5 +0,0 @@
-// Auto-generated by @rangojs/router - do not edit
-export const routes = {
-  "doc.gs": "/getting-started",
-} as const;
-export type routes = typeof routes;

package/src/urls.gen.ts

@@ -1,8 +0,0 @@
-// Auto-generated by @rangojs/router - do not edit
-export const routes = {
-  health: "/health",
-  home: "/",
-  index: "/",
-  post: "/:slug",
-} as const;
-export type routes = typeof routes;