@rangojs/router 0.26.3 → 0.26.4

package/dist/bin/rango.js

@@ -1644,7 +1644,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@rangojs/router",
-      version: "0.26.3",
+      version: "0.26.4",
       description: "Django-inspired RSC router with composable URL patterns",
       keywords: [
         "react",

package/dist/types/router/dev-reload-handoff.d.ts

@@ -13,6 +13,18 @@ export declare function watchRunnerReloads(events: RunnerReloadEvents | undefine
  * @internal
  */
 export declare function droppedByRunnerReload(): boolean;
+type Serve = () => Promise<Response>;
+/**
+ * Serves a request on this router copy, or on the router a runner full reload
+ * re-created when the reload dropped this copy before the request or while it
+ * ran. What a request imports after the clear is the fresh copy, so one the
+ * reload lands inside fails or answers the wrong route: its outcome is
+ * discarded. Only GET and HEAD re-run, since a re-run repeats side effects and
+ * cannot re-read a body. A reload after the response is returned still splits
+ * its stream.
+ * @internal
+ */
+export declare function serveAcrossRunnerReload(request: Request, serve: Serve, recreated: () => Promise<Serve | undefined>): Promise<Response>;
 /**
  * The router the reload re-created for `routerId`, or undefined when none
  * registered within DEV_RECREATED_ROUTER_WAIT_MS. Importing `sourceFile`

package/dist/vite/index.js

@@ -7078,7 +7078,7 @@ function resolveVersionsFrom(table, routerId2) {
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.26.3",
+  version: "0.26.4",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.26.3",
+  "version": "0.26.4",
   "description": "Django-inspired RSC router with composable URL patterns",
   "keywords": [
     "react",

package/src/router/dev-reload-handoff.ts

@@ -45,6 +45,43 @@ export function droppedByRunnerReload(): boolean {
   return runnerReloaded;
 }
 
+type Serve = () => Promise<Response>;
+
+/**
+ * Serves a request on this router copy, or on the router a runner full reload
+ * re-created when the reload dropped this copy before the request or while it
+ * ran. What a request imports after the clear is the fresh copy, so one the
+ * reload lands inside fails or answers the wrong route: its outcome is
+ * discarded. Only GET and HEAD re-run, since a re-run repeats side effects and
+ * cannot re-read a body. A reload after the response is returned still splits
+ * its stream.
+ * @internal
+ */
+export async function serveAcrossRunnerReload(
+  request: Request,
+  serve: Serve,
+  recreated: () => Promise<Serve | undefined>,
+): Promise<Response> {
+  if (runnerReloaded) {
+    const rerun = await recreated();
+    return (rerun ?? serve)();
+  }
+  if (request.method !== "GET" && request.method !== "HEAD") return serve();
+  const settled = await serve().then(
+    (response) => ({ response }),
+    (error: unknown) => ({ error }),
+  );
+  const rerun = runnerReloaded ? await recreated() : undefined;
+  if (rerun) {
+    if ("response" in settled) {
+      void settled.response.body?.cancel().catch(() => {});
+    }
+    return rerun();
+  }
+  if ("error" in settled) throw settled.error;
+  return settled.response;
+}
+
 /**
  * The router the reload re-created for `routerId`, or undefined when none
  * registered within DEV_RECREATED_ROUTER_WAIT_MS. Importing `sourceFile`

package/src/router.ts

@@ -134,8 +134,8 @@ import {
   resolvePrefetchConcurrency,
 } from "./router/prefetch-limits.js";
 import {
-  droppedByRunnerReload,
   routerAfterRunnerReload,
+  serveAcrossRunnerReload,
 } from "./router/dev-reload-handoff.js";
 
 // Re-export public types and values from extracted modules
@@ -1293,18 +1293,30 @@ export function createRouter<TEnv = any>(
           });
         }
 
-        // Dev: a runner full reload dropped this router's module copy
-        // (router/dev-reload-handoff.ts, #1186).
-        if (process.env.NODE_ENV !== "production" && droppedByRunnerReload()) {
-          const reloaded = await routerAfterRunnerReload(
-            routerId,
-            __sourceFile,
+        // Dev: a runner full reload can drop this router's module copy before
+        // or during the request (router/dev-reload-handoff.ts, #1186).
+        if (process.env.NODE_ENV !== "production") {
+          return serveAcrossRunnerReload(
+            request,
+            () => serve(request, input),
+            async () => {
+              const reloaded = await routerAfterRunnerReload(
+                routerId,
+                __sourceFile,
+              );
+              return reloaded && reloaded !== router
+                ? () => reloaded.fetch(request, input)
+                : undefined;
+            },
           );
-          if (reloaded && reloaded !== router) {
-            return reloaded.fetch(request, input);
-          }
         }
+        return serve(request, input);
+      };
 
+      async function serve(
+        request: Request,
+        input: RouterRequestInput<TEnv>,
+      ): Promise<Response> {
         // Trigger lazy import of per-router manifest data before route matching.
         // No-op if data is already loaded or no loader is registered.
         await ensureRouterManifest(routerId);
@@ -1325,7 +1337,7 @@ export function createRouter<TEnv = any>(
           ) => Promise<Response>;
         }
         return handler!(request, input);
-      };
+      }
     })(),
 
     // Low-level route matching for request classification