@rangojs/router 0.21.0 → 0.22.1

package/dist/vite/index.js

@@ -2463,6 +2463,7 @@ function createDiscoveryState(entryPath, opts) {
     buildData: [],
     handlerChunkInfoMap: /* @__PURE__ */ new Map(),
     staticHandlerChunkInfoMap: /* @__PURE__ */ new Map(),
+    onDemandHandlerIds: /* @__PURE__ */ new Map(),
     rscEntryFileName: null,
     resolvedPrerenderModules: void 0,
     resolvedStaticModules: void 0,
@@ -4457,6 +4458,12 @@ async function initializeApp() {
   // is the default; createRouter({ strictMode: false }) ships the opt-out in the
   // payload metadata. StrictMode emits no DOM, so toggling never changes markup.
   const { strictMode, initialPayload } = await initBrowserApp({ rscStream, deps });
+  // Set only on a document a no-JS useActionState POST rendered: React needs
+  // the server's form state to hydrate the hook without resetting it. A state
+  // Flight could not carry rejects: hydrate without it, as before.
+  const formState = await Promise.resolve(initialPayload.formState).catch(
+    () => undefined
+  );
 
   if (import.meta.hot) {
     const { startDevDiscoveryHandshake } = await import(
@@ -4471,7 +4478,8 @@ async function initializeApp() {
   const app = createElement(Rango);
   hydrateRoot(
     document,
-    strictMode === false ? app : createElement(StrictMode, null, app)
+    strictMode === false ? app : createElement(StrictMode, null, app),
+    formState ? { formState } : undefined
   );
 }
 
@@ -5420,7 +5428,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.21.0",
+  version: "0.22.1",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -5545,6 +5553,16 @@ var package_default = {
       "react-server": "./src/cloudflare/index.ts",
       default: "./src/cloudflare/index.ts"
     },
+    "./prerender": {
+      types: "./dist/types/prerender/index.d.ts",
+      "react-server": "./src/prerender/index.ts",
+      default: "./src/prerender/index.ts"
+    },
+    "./prerender/cloudflare": {
+      types: "./dist/types/prerender/cloudflare.d.ts",
+      "react-server": "./src/prerender/cloudflare.ts",
+      default: "./src/prerender/cloudflare.ts"
+    },
     "./vercel": {
       types: "./dist/types/vercel/index.d.ts",
       "react-server": "./src/vercel/index.ts",
@@ -5618,7 +5636,7 @@ var package_default = {
   },
   dependencies: {
     "@types/debug": "^4.1.12",
-    "@vitejs/plugin-rsc": "^0.5.35",
+    "@vitejs/plugin-rsc": "^0.5.36",
     debug: "^4.4.1",
     "magic-string": "^0.30.17",
     picomatch: "^4.0.4",
@@ -5643,7 +5661,7 @@ var package_default = {
     jiti: "^2.7.0",
     react: "catalog:",
     "react-dom": "catalog:",
-    vitest: "^4.1.9"
+    vitest: "^4.1.11"
   },
   peerDependencies: {
     "@cloudflare/vite-plugin": "^1.42.1",
@@ -7680,6 +7698,11 @@ import React from "react";
 // src/server/context.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 
+// src/cache/cache-key-utils.ts
+function routerKeyPrefix(routerId2) {
+  return `${encodeURIComponent(routerId2)}@`;
+}
+
 // src/rsc/shell-capture-constants.ts
 var SHELL_CAPTURE_MAX_WAIT_MS = 15e3;
 var PPR_LANE_HINT = 'Lane rule: only loader(Def, { ssr: false }) executes at capture and bakes its non-promise data; every other loader is live (masked at capture, fresh per request) and needs loading() or an inline <Suspense> above its reader. See the /ppr skill, "The loader lane rule" (node_modules/@rangojs/router/skills/ppr/SKILL.md).';
@@ -7743,15 +7766,28 @@ function normalizeCaptureTimeout(value) {
 var SHELL_PRELUDE_CHUNK_BYTES = 32 * 1024;
 
 // src/vite/inject-client-debug.ts
-function isRouterInternalDebugId(id) {
-  if (!id.includes("internal-debug")) return false;
+var FLAG_MODULE = /\/(internal-debug|internal-suspense-audit)\.[cm]?[jt]sx?(\?|$)/;
+var FLAG_NAMES = {
+  "internal-debug": "INTERNAL_RANGO_DEBUG",
+  "internal-suspense-audit": "INTERNAL_RANGO_SUSPENSE_AUDIT"
+};
+function routerFlagName(id) {
+  if (!id.includes("internal-")) return void 0;
   const norm = id.replace(/\\/g, "/");
-  return /\/internal-debug\.[cm]?[jt]sx?(\?|$)/.test(norm) && (norm.includes("/@rangojs/router/") || norm.includes("/packages/rangojs-router/"));
+  if (!norm.includes("/@rangojs/router/") && !norm.includes("/packages/rangojs-router/")) {
+    return void 0;
+  }
+  const match = FLAG_MODULE.exec(norm);
+  return match ? FLAG_NAMES[match[1]] : void 0;
+}
+function isRouterInternalDebugId(id) {
+  return routerFlagName(id) !== void 0;
 }
 function injectClientDebugFlag(id) {
-  if (!isRouterInternalDebugId(id)) return null;
+  const name = routerFlagName(id);
+  if (name === void 0) return null;
   return {
-    code: `export const INTERNAL_RANGO_DEBUG = ${!!process.env.INTERNAL_RANGO_DEBUG};
+    code: `export const ${name} = ${!!process.env[name]};
 `,
     map: null
   };
@@ -7964,8 +8000,9 @@ function findMatchingParenInBundle(code, openParenPos) {
   }
   return depth === 0 ? pos : -1;
 }
-function extractHandlerExportsFromChunk(chunkCode, handlerModules, fnName, detectPassthrough) {
+function extractHandlerExportsFromChunk(chunkCode, handlerModules, fnName, detectPassthrough, onDemandHandlerIds) {
   const handlers = [];
+  const scanPassthrough = detectPassthrough && chunkCode.includes("passthrough");
   for (const [, handlerNames] of handlerModules) {
     for (const name of handlerNames) {
       const eName = escapeRegExp(name);
@@ -7975,7 +8012,7 @@ function extractHandlerExportsFromChunk(chunkCode, handlerModules, fnName, detec
       const match = chunkCode.match(idPattern);
       if (!match) continue;
       let isPassthrough = false;
-      if (detectPassthrough) {
+      if (scanPassthrough) {
         const eFnName = escapeRegExp(fnName);
         const callStartRe = new RegExp(
           `(?:const|let|var)\\s+${eName}\\s*=\\s*${eFnName}\\s*(?:<[^>]*>)?\\s*\\(`
@@ -7990,7 +8027,12 @@ function extractHandlerExportsFromChunk(chunkCode, handlerModules, fnName, detec
           }
         }
       }
-      handlers.push({ name, handlerId: match[1], passthrough: isPassthrough });
+      handlers.push({
+        name,
+        handlerId: match[1],
+        passthrough: isPassthrough,
+        onDemand: onDemandHandlerIds?.has(match[1]) ?? false
+      });
     }
   }
   return handlers;
@@ -7999,8 +8041,8 @@ function evictHandlerCode(code, exports, fnName, brand) {
   const originalSize = Buffer.byteLength(code);
   let modified = code;
   const eFnName = escapeRegExp(fnName);
-  for (const { name, handlerId, passthrough } of exports) {
-    if (passthrough) continue;
+  for (const { name, handlerId, passthrough, onDemand } of exports) {
+    if (passthrough || onDemand) continue;
     const eName = escapeRegExp(name);
     const callStartRe = new RegExp(
       `(?:const|let|var)\\s+${eName}\\s*=\\s*${eFnName}\\s*(?:<[^>]*>)?\\s*\\(`
@@ -8121,7 +8163,7 @@ function parsePattern(pattern) {
 }
 
 // src/router/route-trie-builder.ts
-function buildRouteTrie(routeManifest, routeToStaticPrefix, routeTrailingSlash, prerenderRouteNames, passthroughRouteNames, responseTypeRoutes) {
+function buildRouteTrie(routeManifest, routeToStaticPrefix, routeTrailingSlash, prerenderRouteNames, passthroughRouteNames, responseTypeRoutes, onDemandRouteNames) {
   const root = {};
   for (const [routeName, pattern] of Object.entries(routeManifest)) {
     const staticPrefix = routeToStaticPrefix[routeName] || "";
@@ -8136,6 +8178,7 @@ function buildRouteTrie(routeManifest, routeToStaticPrefix, routeTrailingSlash,
       ...trailingSlash ? { ts: trailingSlash } : {},
       ...prerenderRouteNames?.has(routeName) ? { pr: true } : {},
       ...passthroughRouteNames?.has(routeName) ? { pt: true } : {},
+      ...onDemandRouteNames?.has(routeName) ? { od: true } : {},
       ...responseType ? { rt: responseType } : {}
     });
   }
@@ -8328,7 +8371,8 @@ function buildPerRouterTrie(manifest) {
     manifest.routeTrailingSlash,
     manifest.prerenderRoutes ? new Set(manifest.prerenderRoutes) : void 0,
     manifest.passthroughRoutes ? new Set(manifest.passthroughRoutes) : void 0,
-    manifest.responseTypeRoutes
+    manifest.responseTypeRoutes,
+    manifest.onDemandRoutes ? new Set(manifest.onDemandRoutes) : void 0
   );
 }
 
@@ -8482,6 +8526,11 @@ function mergeFullManifests(manifests) {
         manifest.passthroughRoutes,
         overwrittenRoutes
       ),
+      onDemandRoutes: mergeRouteList(
+        merged.onDemandRoutes,
+        manifest.onDemandRoutes,
+        overwrittenRoutes
+      ),
       responseTypeRoutes: mergeRouteRecord(
         merged.responseTypeRoutes,
         manifest.responseTypeRoutes,
@@ -9268,9 +9317,10 @@ function isUnderTestRunner() {
 // src/client.tsx
 import {
   Component as Component3,
-  createElement as createElement3,
+  createElement as createElement4,
+  isValidElement as isValidElement2,
   useContext as useContext17,
-  useMemo as useMemo8,
+  useMemo as useMemo9,
   Suspense as Suspense2
 } from "react";
 
@@ -9281,7 +9331,6 @@ import {
   useEffect,
   useRef,
   useOptimistic,
-  useSyncExternalStore,
   startTransition
 } from "react";
 
@@ -9359,10 +9408,7 @@ function createHandle(collect, __injectedId) {
 import { createContext } from "react";
 var NavigationStoreContext = createContext(null);
 var LocationStateContext = createContext(void 0);
-
-// src/browser/react/subscribe-to-nothing.ts
-var subscribeToNothing = () => () => {
-};
+var HydrationBarrierContext = createContext(0);
 
 // src/handles/meta.ts
 function isUnsetDescriptor(descriptor) {
@@ -9568,17 +9614,31 @@ import { createContext as createContext4 } from "react";
 var OutletContext = createContext4(null);
 
 // src/route-content-wrapper.tsx
-import { Component, Suspense, use } from "react";
+import { Component, Suspense, use, useMemo as useMemo3 } from "react";
+
+// src/outlet-provider.tsx
+import {
+  useContext as useContext4,
+  useMemo
+} from "react";
+
+// src/suspense-audit-react.tsx
+import { useEffect as useEffect3, useLayoutEffect, useRef as useRef2 } from "react";
+
+// src/suspense-audit.ts
+init_internal_debug();
+
+// src/internal-suspense-audit.ts
+var INTERNAL_RANGO_SUSPENSE_AUDIT = typeof process !== "undefined" && Boolean(process.env?.INTERNAL_RANGO_SUSPENSE_AUDIT);
 
 // src/outlet-provider.tsx
-import { useContext as useContext4, useMemo } from "react";
 import { jsx as jsx3 } from "react/jsx-runtime";
 
 // src/decode-loader-results.ts
 import { createElement as createElement2 } from "react";
 
 // src/loader-redirect.tsx
-import { useEffect as useEffect3 } from "react";
+import { useEffect as useEffect4 } from "react";
 
 // src/browser/react/use-router.ts
 import { useContext as useContext6, useMemo as useMemo2 } from "react";
@@ -9608,6 +9668,7 @@ init_redirect_origin();
 
 // src/route-content-wrapper.tsx
 import { jsx as jsx4 } from "react/jsx-runtime";
+import { createElement as createElement3 } from "react";
 
 // src/use-loader.tsx
 import {
@@ -9616,18 +9677,18 @@ import {
   use as use2,
   useCallback,
   useContext as useContext7,
-  useEffect as useEffect4,
-  useMemo as useMemo3,
+  useEffect as useEffect5,
+  useMemo as useMemo4,
   useOptimistic as useOptimistic2,
-  useRef as useRef2,
+  useRef as useRef3,
   useState as useState3
 } from "react";
 
 // src/thenable-status.ts
-function unwrapsSynchronously(stream) {
-  const status = stream.status;
-  return status === "fulfilled" || status === "resolved_model" || status === "resolved_module";
-}
+var SETTLED_THENABLE = Object.assign(
+  Promise.resolve(void 0),
+  { status: "fulfilled", value: void 0, _debugInfo: [] }
+);
 
 // src/loader-store.ts
 var EMPTY_SNAPSHOT = Object.freeze({
@@ -9637,410 +9698,19 @@ var EMPTY_SNAPSHOT = Object.freeze({
   isLoading: false,
   requestId: 0
 });
-function normalizeGroups(group) {
-  if (group === void 0) return [];
-  if (typeof group === "string") return [group];
-  return [...new Set(group)];
-}
-var LoaderStore = class {
-  constructor() {
-    this.entries = /* @__PURE__ */ new Map();
-    /** loader.$$id -> set of bucket keys, so clearFamily() can reach every bucket. */
-    this.families = /* @__PURE__ */ new Map();
-    /** refresh group name -> set of bucket keys, for refreshGroups(). */
-    this.groups = /* @__PURE__ */ new Map();
-    /**
-     * loader.$$id -> per-loader streams a committed navigation is still
-     * receiving. Registered and announced by announcePendingStreams(), which
-     * browser/partial-update.ts calls INSIDE every transition commit, so a
-     * reader whose content is held on screen by that transition pins
-     * `isLoading: true` for the data it is still showing until the transition
-     * lands (use-loader.tsx). Family-keyed on purpose: a persisting layout
-     * reader of the same createLoader the child is re-running is pinned too
-     * (the loader is in flight; not "this segment's copy is being replaced" —
-     * issue #862, working as designed). The new tree's own read of the loader
-     * suspends at the read site and never observes the flag. A Set, not a
-     * flag: overlapping navigations (second click before the first stream
-     * lands) keep the family pending until the LAST stream settles.
-     */
-    this.pendingStreams = /* @__PURE__ */ new Map();
-  }
-  getOrCreate(bucketKey) {
-    let e = this.entries.get(bucketKey);
-    if (!e) {
-      e = {
-        snapshot: EMPTY_SNAPSHOT,
-        listeners: /* @__PURE__ */ new Set(),
-        latestRequestId: 0,
-        loaderId: bucketKey,
-        sticky: false,
-        pendingClear: false,
-        clearWhenSettled: false,
-        groups: /* @__PURE__ */ new Map(),
-        refetch: void 0,
-        streamPendingListeners: /* @__PURE__ */ new Set()
-      };
-      this.entries.set(bucketKey, e);
-    }
-    return e;
-  }
-  registerFamily(loaderId, bucketKey) {
-    let fam = this.families.get(loaderId);
-    if (!fam) {
-      fam = /* @__PURE__ */ new Set();
-      this.families.set(loaderId, fam);
-    }
-    fam.add(bucketKey);
-  }
-  /**
-   * Subscribe to entry changes for `bucketKey`.
-   * Returns an unsubscribe function. A sticky bucket's entry is kept around even
-   * after the last subscriber leaves so that an in-flight `load()` can still
-   * commit if the consumer remounts. An ephemeral bucket is dropped once its
-   * last subscriber leaves (deferred, see maybeScheduleRefcountClear).
-   */
-  subscribe(bucketKey, cb, options) {
-    const e = this.getOrCreate(bucketKey);
-    const loaderId = options?.loaderId ?? bucketKey;
-    e.loaderId = loaderId;
-    this.registerFamily(loaderId, bucketKey);
-    if (options?.ephemeral !== true) e.sticky = true;
-    const groups = normalizeGroups(options?.group);
-    for (const group of groups) {
-      this.addToGroup(group, bucketKey, e, options?.refetch);
-    }
-    e.pendingClear = false;
-    e.clearWhenSettled = false;
-    e.listeners.add(cb);
-    const onStreamPending = options?.onStreamPending;
-    if (onStreamPending) e.streamPendingListeners.add(onStreamPending);
-    return () => {
-      e.listeners.delete(cb);
-      if (onStreamPending) e.streamPendingListeners.delete(onStreamPending);
-      for (const group of groups) this.releaseGroup(group, bucketKey, e);
-      this.maybeScheduleRefcountClear(bucketKey, e);
-    };
-  }
-  addToGroup(group, bucketKey, e, refetch) {
-    e.groups.set(group, (e.groups.get(group) ?? 0) + 1);
-    if (refetch) e.refetch = refetch;
-    let members = this.groups.get(group);
-    if (!members) {
-      members = /* @__PURE__ */ new Set();
-      this.groups.set(group, members);
-    }
-    members.add(bucketKey);
-  }
-  releaseGroup(group, bucketKey, e) {
-    const next = (e.groups.get(group) ?? 0) - 1;
-    if (next > 0) {
-      e.groups.set(group, next);
-      return;
-    }
-    e.groups.delete(group);
-    const members = this.groups.get(group);
-    if (members) {
-      members.delete(bucketKey);
-      if (members.size === 0) this.groups.delete(group);
-    }
-  }
-  /** Remove a bucket from every group it belongs to (used when it is dropped). */
-  removeFromAllGroups(bucketKey, e) {
-    for (const group of e.groups.keys()) {
-      const members = this.groups.get(group);
-      if (members) {
-        members.delete(bucketKey);
-        if (members.size === 0) this.groups.delete(group);
-      }
-    }
-    e.groups.clear();
-  }
-  /**
-   * Refresh every currently-mounted bucket tagged with ANY of the given group
-   * names, with a plain GET (no params/body). Accepts a single name or an array
-   * of names. A bucket that belongs to more than one of the named groups is
-   * refreshed exactly once (members are unioned and deduped by bucket key), as
-   * are multiple reads of one bucket. Resolves when all refreshes settle; rejects
-   * with an `AggregateError` of the failures if any member fails — each failing
-   * member also records its error on its own snapshot.
-   */
-  async refreshGroups(groups) {
-    const names = typeof groups === "string" ? [groups] : groups;
-    const buckets = /* @__PURE__ */ new Set();
-    for (const name of names) {
-      const members = this.groups.get(name);
-      if (!members) continue;
-      for (const bucketKey of members) buckets.add(bucketKey);
-    }
-    if (buckets.size === 0) return;
-    const thunks = [];
-    for (const bucketKey of buckets) {
-      const e = this.entries.get(bucketKey);
-      if (!e || e.listeners.size === 0 || !e.refetch) continue;
-      thunks.push(e.refetch);
-    }
-    if (thunks.length === 0) return;
-    const results = await Promise.allSettled(thunks.map((t) => t()));
-    const reasons = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-    if (reasons.length > 0) {
-      const label = names.map((n) => `"${n}"`).join(", ");
-      throw new AggregateError(
-        reasons,
-        `refreshGroups(${label}) had ${reasons.length} failure(s)`
-      );
-    }
-  }
-  /**
-   * Schedule a deferred drop for an ad-hoc (never-sticky) bucket whose last
-   * subscriber just left. Deferred to a microtask so a StrictMode / transition
-   * remount that resubscribes in the same tick cancels it.
-   */
-  maybeScheduleRefcountClear(bucketKey, e) {
-    if (e.listeners.size > 0) return;
-    if (e.sticky) return;
-    if (e.pendingClear) return;
-    e.pendingClear = true;
-    queueMicrotask(() => {
-      if (!e.pendingClear) return;
-      e.pendingClear = false;
-      if (e.listeners.size > 0) return;
-      if (e.snapshot.isLoading) {
-        e.clearWhenSettled = true;
-        return;
-      }
-      this.dropBucket(bucketKey);
-    });
-  }
-  /** Remove a bucket entry entirely and prune it from its family/group indexes. */
-  dropBucket(bucketKey) {
-    const e = this.entries.get(bucketKey);
-    if (!e) return;
-    this.removeFromAllGroups(bucketKey, e);
-    this.entries.delete(bucketKey);
-    const fam = this.families.get(e.loaderId);
-    if (fam) {
-      fam.delete(bucketKey);
-      if (fam.size === 0) this.families.delete(e.loaderId);
-    }
-  }
-  /** Drop an ephemeral bucket that settled with no subscribers left. */
-  dropIfSettled(bucketKey, e) {
-    if (e.clearWhenSettled && e.listeners.size === 0) {
-      e.clearWhenSettled = false;
-      this.dropBucket(bucketKey);
-    }
-  }
-  /**
-   * Returns the current snapshot for `bucketKey`. Stable reference between
-   * mutations — subscribers rely on this to avoid spurious re-renders.
-   * Returns `EMPTY_SNAPSHOT` (a singleton) when the entry has never been
-   * mutated or has been cleared.
-   */
-  getSnapshot(bucketKey) {
-    return this.entries.get(bucketKey)?.snapshot ?? EMPTY_SNAPSHOT;
-  }
-  /**
-   * Reserve a fresh request id for an upcoming `load()` call. The returned id
-   * is the new "latest"; any older in-flight requests will fail their gating
-   * check on `finishData` / `finishError` / `finishLoading` and be dropped.
-   *
-   * Callers should follow with `beginRequest(id, requestId)` to flip the
-   * loading flag on AND clear any leftover error from a previous attempt
-   * — the latter matters for `throwOnError: false` consumers, which would
-   * otherwise keep showing the stale error throughout the retry.
-   */
-  reserveRequestId(bucketKey) {
-    const e = this.getOrCreate(bucketKey);
-    e.latestRequestId++;
-    return e.latestRequestId;
-  }
-  /**
-   * Mark the request as in-flight: `isLoading = true`, `error = null`.
-   * Combines the two operations so a retry doesn't render the previous
-   * error during the new request. Gated on `requestId === latestRequestId`
-   * for symmetry with the other mutators.
-   */
-  beginRequest(bucketKey, requestId) {
-    const e = this.entries.get(bucketKey);
-    if (!e || requestId !== e.latestRequestId) return;
-    if (e.snapshot.isLoading && e.snapshot.error === null) return;
-    e.snapshot = Object.freeze({
-      value: e.snapshot.value,
-      hasValue: e.snapshot.hasValue,
-      error: null,
-      isLoading: true,
-      requestId
-    });
-    this.notify(e);
-  }
-  /**
-   * Commit a successful result. No-op if `requestId` is not the latest
-   * (a newer `load()` was issued or `clear()` ran). Clearing `error` is
-   * intentional: a successful refetch should hide the previous failure.
-   */
-  finishData(bucketKey, requestId, value) {
-    const e = this.entries.get(bucketKey);
-    if (!e || requestId !== e.latestRequestId) return;
-    e.snapshot = Object.freeze({
-      value,
-      hasValue: true,
-      error: null,
-      isLoading: false,
-      requestId
-    });
-    this.notify(e);
-    this.dropIfSettled(bucketKey, e);
-  }
-  /**
-   * Commit an error. Preserves the last good `value` so consumers can keep
-   * showing previous data while displaying the error if they choose. No-op
-   * if `requestId` is not the latest.
-   */
-  finishError(bucketKey, requestId, error) {
-    const e = this.entries.get(bucketKey);
-    if (!e || requestId !== e.latestRequestId) return;
-    e.snapshot = Object.freeze({
-      value: e.snapshot.value,
-      hasValue: e.snapshot.hasValue,
-      error,
-      isLoading: false,
-      requestId
-    });
-    this.notify(e);
-    this.dropIfSettled(bucketKey, e);
-  }
-  /**
-   * Update loading flag. Gated on `requestId` to fix the race where an old
-   * load() finishes after a new one started — its `setLoading(false)` would
-   * otherwise hide the new request's spinner.
-   */
-  setLoading(bucketKey, requestId, isLoading) {
-    const e = this.entries.get(bucketKey);
-    if (!e || requestId !== e.latestRequestId) return;
-    if (e.snapshot.isLoading === isLoading) return;
-    e.snapshot = Object.freeze({
-      ...e.snapshot,
-      isLoading
-    });
-    this.notify(e);
-  }
-  /**
-   * Reset a single bucket entry. Bumps `latestRequestId` so any in-flight
-   * `load()` whose promise is still pending will fail its gate when it resolves
-   * and be dropped — prevents pre-navigation loads from clobbering the new
-   * route's context. The entry itself is kept (sticky-bucket semantics).
-   */
-  clear(bucketKey) {
-    const e = this.entries.get(bucketKey);
-    if (!e) return;
-    e.latestRequestId++;
-    if (e.snapshot === EMPTY_SNAPSHOT) return;
-    e.snapshot = EMPTY_SNAPSHOT;
-    this.notify(e);
-  }
-  /**
-   * Reset every sticky bucket belonging to `loaderId`. Called on navigation /
-   * route-context change: all route-registered reads of the loader (keyed or
-   * not) drop back to seeding from fresh `loaderData`. Ephemeral buckets are
-   * intentionally left alone — they are governed by subscriber refcount, so a
-   * persistent keyed reader outside the outlet keeps its value across a
-   * navigation rather than blanking out.
-   */
-  clearFamily(loaderId) {
-    const fam = this.families.get(loaderId);
-    if (!fam) return;
-    for (const bucketKey of fam) {
-      const e = this.entries.get(bucketKey);
-      if (!e || !e.sticky) continue;
-      this.clear(bucketKey);
-    }
-  }
-  notify(e) {
-    for (const cb of e.listeners) cb();
-  }
-  /**
-   * Register a still-streaming per-loader result for `loaderId`. No-op for a
-   * settled Flight chunk (unwrapsSynchronously / "rejected"): the forceAwait
-   * and action lanes commit settled chunks, and a { ssr: false } loader is
-   * awaited before flush. Released as the stream settles, either way.
-   */
-  trackPendingStream(loaderId, stream) {
-    if (unwrapsSynchronously(stream) || stream.status === "rejected") {
-      return;
-    }
-    let set = this.pendingStreams.get(loaderId);
-    if (set?.has(stream)) return;
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.pendingStreams.set(loaderId, set);
-    }
-    set.add(stream);
-    const release = () => {
-      const current = this.pendingStreams.get(loaderId);
-      if (!current || !current.delete(stream)) return;
-      if (current.size === 0) this.pendingStreams.delete(loaderId);
-    };
-    stream.then(release, release);
-  }
-  /** True while any navigation stream for `loaderId` is still pending. */
-  isStreamPending(loaderId) {
-    return this.pendingStreams.has(loaderId);
-  }
-  /**
-   * Register the loader segments of a tree being committed whose data is
-   * still a pending promise, then fire `onStreamPending` on every subscriber
-   * of every family with a pending stream. MUST run inside the startTransition
-   * that commits the tree: the hook answers with a useOptimistic update, which
-   * React reverts exactly when that transition commits — so the held reader
-   * reports isLoading:true for as long as its data stays on screen and not a
-   * frame longer. Outside a transition React reverts an optimistic update on
-   * the next render, pinning nothing useful. Registering here rather than in
-   * the tree build keeps register + announce in one call; settled chunks
-   * (cached/reused segments, forceAwait lanes) are skipped by
-   * trackPendingStream.
-   */
-  announcePendingStreams(segments) {
-    for (const segment of segments) {
-      if (segment.type === "loader" && segment.loaderId && segment.loaderData instanceof Promise) {
-        this.trackPendingStream(segment.loaderId, segment.loaderData);
-      }
-    }
-    for (const loaderId of this.pendingStreams.keys()) {
-      const fam = this.families.get(loaderId);
-      if (!fam) continue;
-      for (const bucketKey of fam) {
-        const e = this.entries.get(bucketKey);
-        if (!e) continue;
-        for (const cb of e.streamPendingListeners) cb();
-      }
-    }
-  }
-  /**
-   * Test-only escape hatch. Drops every entry. Production code should never
-   * call this; the store is process-scoped and lives for the tab's lifetime.
-   * @internal
-   */
-  reset() {
-    this.entries.clear();
-    this.families.clear();
-    this.groups.clear();
-    this.pendingStreams.clear();
-  }
-};
-var loaderStore = new LoaderStore();
 
 // src/browser/react/use-navigation.ts
 import {
   useContext as useContext8,
   useState as useState4,
-  useEffect as useEffect5,
+  useEffect as useEffect6,
   useOptimistic as useOptimistic3,
   startTransition as startTransition3,
-  useRef as useRef3
+  useRef as useRef4
 } from "react";
 
 // src/browser/react/use-pathname.ts
-import { useContext as useContext9, useState as useState5, useEffect as useEffect6, useRef as useRef4 } from "react";
+import { useContext as useContext9, useState as useState5, useEffect as useEffect7, useRef as useRef5 } from "react";
 
 // src/client-urls/optimistic-location.ts
 import { createContext as createContext6 } from "react";
@@ -10050,38 +9720,39 @@ var OptimisticLocationContext = createContext6(null);
 import {
   useCallback as useCallback2,
   useContext as useContext10,
-  useEffect as useEffect7,
-  useMemo as useMemo4,
-  useRef as useRef5,
+  useEffect as useEffect8,
+  useMemo as useMemo5,
+  useRef as useRef6,
   useState as useState6
 } from "react";
 
 // src/browser/react/use-params.ts
-import { useContext as useContext11, useState as useState7, useEffect as useEffect8, useRef as useRef6 } from "react";
+import { useContext as useContext11, useState as useState7, useEffect as useEffect9, useRef as useRef7 } from "react";
 var EMPTY_PARAMS = Object.freeze({});
 
 // src/browser/react/use-action.ts
 import {
   useContext as useContext12,
   useState as useState8,
-  useEffect as useEffect9,
-  useRef as useRef7,
+  useEffect as useEffect10,
+  useRef as useRef8,
   useOptimistic as useOptimistic4,
   startTransition as startTransition4
 } from "react";
 
 // src/browser/react/use-segments.ts
-import { useContext as useContext13, useState as useState9, useEffect as useEffect10, useRef as useRef8 } from "react";
+import { useContext as useContext13, useState as useState9, useEffect as useEffect11, useRef as useRef9 } from "react";
 
 // src/browser/react/NavigationProvider.tsx
 import {
   useState as useState12,
-  useEffect as useEffect12,
-  useLayoutEffect,
+  useEffect as useEffect13,
+  useLayoutEffect as useLayoutEffect2,
   useCallback as useCallback4,
-  useMemo as useMemo6,
-  useRef as useRef10,
-  use as use3
+  useMemo as useMemo7,
+  useRef as useRef11,
+  use as use3,
+  startTransition as startTransition5
 } from "react";
 
 // src/root-error-boundary.tsx
@@ -10091,8 +9762,8 @@ import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 // src/theme/ThemeProvider.tsx
 import {
   useCallback as useCallback3,
-  useEffect as useEffect11,
-  useMemo as useMemo5,
+  useEffect as useEffect12,
+  useMemo as useMemo6,
   useState as useState11
 } from "react";
 
@@ -10128,10 +9799,9 @@ import {
   forwardRef,
   useCallback as useCallback5,
   useContext as useContext15,
-  useEffect as useEffect14,
-  useMemo as useMemo7,
-  useRef as useRef12,
-  useSyncExternalStore as useSyncExternalStore2
+  useEffect as useEffect15,
+  useMemo as useMemo8,
+  useRef as useRef13
 } from "react";
 
 // src/browser/react/use-link-status.ts
@@ -10139,10 +9809,10 @@ import {
   createContext as createContext7,
   useContext as useContext14,
   useState as useState13,
-  useEffect as useEffect13,
-  useRef as useRef11,
+  useEffect as useEffect14,
+  useRef as useRef12,
   useOptimistic as useOptimistic5,
-  startTransition as startTransition5
+  startTransition as startTransition6
 } from "react";
 var LinkContext = createContext7(
   null
@@ -10202,24 +9872,18 @@ function subscribeToLocationChange(eventController, listener) {
 }
 
 // src/browser/prefetch/default-strategy.ts
-var hoverNoneQuery = null;
-var defaultStrategy = process.env.NODE_ENV === "production" ? "viewport" : "none";
-function getHoverNoneQuery() {
-  if (typeof window === "undefined") return null;
-  if (!hoverNoneQuery) {
-    hoverNoneQuery = window.matchMedia("(hover: none)");
-  }
-  return hoverNoneQuery;
-}
-function getDefaultPrefetchStrategy() {
-  return defaultStrategy;
+var ENVIRONMENT_DEFAULT_PREFETCH = process.env.NODE_ENV === "production" ? "viewport" : "none";
+function hoverNoneQuery() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function")
+    return null;
+  return window.matchMedia("(hover: none)");
 }
 function resolveAdaptiveStrategy(strategy) {
   if (strategy !== "adaptive") return strategy;
-  return getHoverNoneQuery()?.matches ? "viewport" : "hover";
+  return hoverNoneQuery()?.matches ? "viewport" : "hover";
 }
 function subscribeToAdaptiveStrategyChange(listener) {
-  const query = getHoverNoneQuery();
+  const query = hoverNoneQuery();
   if (!query) return () => {
   };
   if (typeof query.addEventListener === "function") {
@@ -10403,23 +10067,16 @@ var Link = forwardRef(function Link2({
   ...props
 }, ref) {
   const ctx = useContext15(NavigationStoreContext);
-  const storeLocation = ctx?.eventController.getState().location;
-  const origin = storeLocation?.origin ?? (typeof window !== "undefined" ? window.location.origin : void 0);
-  const isExternal = isExternalUrl(to, origin);
-  const resolvedTo = useMemo7(() => {
+  const isExternal = isExternalUrl(to, ctx?.origin);
+  const resolvedTo = useMemo8(() => {
     if (isExternal) return to;
     const bn = ctx?.basename;
     if (!bn || !to.startsWith("/") || to.startsWith(bn + "/") || to === bn)
       return to;
     return to === "/" ? bn : bn + to;
   }, [to, isExternal, ctx?.basename]);
-  const configuredStrategy = prefetch ?? ctx?.defaultPrefetch ?? getDefaultPrefetchStrategy();
-  const resolvedStrategy = useSyncExternalStore2(
-    configuredStrategy === "adaptive" ? subscribeToAdaptiveStrategyChange : subscribeToNothing,
-    () => resolveAdaptiveStrategy(configuredStrategy),
-    () => configuredStrategy === "adaptive" ? "hover" : configuredStrategy
-  );
-  const internalRef = useRef12(null);
+  const configuredStrategy = prefetch ?? ctx?.defaultPrefetch ?? ENVIRONMENT_DEFAULT_PREFETCH;
+  const internalRef = useRef13(null);
   const setRef = useCallback5(
     (node) => {
       internalRef.current = node;
@@ -10431,7 +10088,7 @@ var Link = forwardRef(function Link2({
     },
     [ref]
   );
-  const stateRef = useRef12(state);
+  const stateRef = useRef13(state);
   stateRef.current = state;
   const handleClick = useCallback5(
     (e) => {
@@ -10476,7 +10133,8 @@ var Link = forwardRef(function Link2({
   );
   const handleMouseEnter = useCallback5(() => {
     const element = internalRef.current;
-    if ((resolvedStrategy === "hover" || resolvedStrategy === "viewport") && !isExternal && ctx?.store && (!element || !isHashOnlyNavigation(element) && !isPrefetchScopeDisabled(element))) {
+    const strategy = resolveAdaptiveStrategy(configuredStrategy);
+    if ((strategy === "hover" || strategy === "viewport") && !isExternal && ctx?.store && (!element || !isHashOnlyNavigation(element) && !isPrefetchScopeDisabled(element))) {
       const segmentState = ctx.store.getSegmentState();
       prefetchDirect2(
         resolvedTo,
@@ -10486,13 +10144,18 @@ var Link = forwardRef(function Link2({
         prefetchKey
       );
     }
-  }, [resolvedStrategy, resolvedTo, isExternal, ctx, prefetchKey]);
-  useEffect14(() => {
+  }, [configuredStrategy, resolvedTo, isExternal, ctx, prefetchKey]);
+  useEffect15(() => {
     if (isExternal || !ctx?.store) return;
-    const isViewport = resolvedStrategy === "viewport";
-    const isRender = resolvedStrategy === "render";
-    if (!isViewport && !isRender) return;
+    if (configuredStrategy !== "viewport" && configuredStrategy !== "render" && configuredStrategy !== "adaptive") {
+      return;
+    }
     const armPrefetch = () => {
+      const strategy = resolveAdaptiveStrategy(configuredStrategy);
+      const isViewport = strategy === "viewport";
+      const isRender = strategy === "render";
+      if (!isViewport && !isRender) return () => {
+      };
       const element2 = internalRef.current;
       if (element2 && (isHashOnlyNavigation(element2) || isPrefetchScopeDisabled(element2))) {
         return () => {
@@ -10537,24 +10200,24 @@ var Link = forwardRef(function Link2({
       };
     };
     let disarmPrefetch = armPrefetch();
-    const element = internalRef.current;
-    const unsubscribeScope = element ? subscribeToPrefetchScopeChange(element, () => {
+    const rearm = () => {
       disarmPrefetch();
       disarmPrefetch = armPrefetch();
-    }) : void 0;
+    };
+    const element = internalRef.current;
+    const unsubscribeScope = element ? subscribeToPrefetchScopeChange(element, rearm) : void 0;
     const unsubscribeLocation = subscribeToLocationChange(
       ctx.eventController,
-      () => {
-        disarmPrefetch();
-        disarmPrefetch = armPrefetch();
-      }
+      rearm
     );
+    const unsubscribeAdaptive = configuredStrategy === "adaptive" ? subscribeToAdaptiveStrategyChange(rearm) : void 0;
     return () => {
       unsubscribeScope?.();
       unsubscribeLocation();
+      unsubscribeAdaptive?.();
       disarmPrefetch();
     };
-  }, [resolvedStrategy, resolvedTo, isExternal, ctx, prefetchKey]);
+  }, [configuredStrategy, resolvedTo, isExternal, ctx, prefetchKey]);
   return /* @__PURE__ */ jsx8(
     "a",
     {
@@ -10602,7 +10265,7 @@ var Breadcrumbs = createHandle(
 );
 
 // src/browser/react/location-state.ts
-import { useContext as useContext16, useEffect as useEffect15, useSyncExternalStore as useSyncExternalStore3 } from "react";
+import { useContext as useContext16, useEffect as useEffect16 } from "react";
 
 // src/href-client.ts
 function href(path6, mount) {
@@ -10671,7 +10334,7 @@ import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 init_cookie_name();
 
 // src/router/segment-resolution/mask-nested.ts
-import { cloneElement, isValidElement as isValidElement2 } from "react";
+import { cloneElement, isValidElement as isValidElement3 } from "react";
 
 // src/server/handle-store.ts
 var LOADER_SLOT = Object.freeze({ loader: true });
@@ -10734,6 +10397,7 @@ var THEME_READ = {
 
 // src/cache/invalidation-order.ts
 var order = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:tag-invalidation-order")] ??= { seq: 0, tags: /* @__PURE__ */ new Map(), forgotten: 0 };
+var responseStarts = globalThis[/* @__PURE__ */ Symbol.for("rangojs-router:response-execution-start")] ??= /* @__PURE__ */ new WeakMap();
 
 // src/server/request-context.ts
 var requestContextStorage = new AsyncLocalStorage5();
@@ -10743,17 +10407,17 @@ init_redirect_origin();
 
 // src/client-urls/client-root.tsx
 import {
-  createElement as createElement4,
+  createElement as createElement5,
   Fragment as Fragment4,
   Suspense as Suspense3,
   useDeferredValue,
-  useEffect as useEffect16,
-  useMemo as useMemo9,
+  useEffect as useEffect17,
+  useMemo as useMemo10,
   useState as useState14
 } from "react";
 
 // src/client-urls/navigation.ts
-import { startTransition as startTransition6 } from "react";
+import { startTransition as startTransition7 } from "react";
 
 // src/client-urls/client-root.tsx
 import { jsx as jsx11, jsxs as jsxs4 } from "react/jsx-runtime";
@@ -11285,11 +10949,23 @@ async function discoverRouters(state, rscEnv, ssrEnv) {
     "inner: trie build done (%sms)",
     (performance.now() - trieStart).toFixed(1)
   );
+  const newOnDemandHandlerIds = /* @__PURE__ */ new Map();
+  for (const { manifest } of allManifests) {
+    if (!manifest.onDemandRoutes) continue;
+    const defs = manifest._prerenderDefs || {};
+    for (const routeName of manifest.onDemandRoutes) {
+      const handlerId = defs[routeName]?.$$id;
+      if (typeof handlerId === "string") {
+        newOnDemandHandlerIds.set(handlerId, routeName);
+      }
+    }
+  }
   state.mergedRouteManifest = newMergedRouteManifest;
   state.perRouterManifests = newPerRouterManifests;
   state.perRouterManifestDataMap = newPerRouterManifestDataMap;
   state.perRouterPrecomputedMap = newPerRouterPrecomputedMap;
   state.perRouterTrieMap = newPerRouterTrieMap;
+  state.onDemandHandlerIds = newOnDemandHandlerIds;
   const perRouterSetters = [
     [newPerRouterManifestDataMap, "setRouterManifest"],
     [newPerRouterTrieMap, "setRouterTrie"],
@@ -11310,8 +10986,8 @@ import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as
 import { join as join7, resolve as resolve10 } from "node:path";
 
 // src/prerender/shell-manifest-key.ts
-function buildShellManifestKey(pathname) {
-  return pathname;
+function buildShellManifestKey(routerId2, pathname) {
+  return `${routerKeyPrefix(routerId2)}${pathname}`;
 }
 
 // src/vite/discovery/router-versions-phase.ts
@@ -11801,7 +11477,7 @@ async function runShellPrerenderPhase(s, builder, versionsTable) {
             tags: res.tags
           };
           staged.push({
-            key: buildShellManifestKey(cand.urlPath),
+            key: buildShellManifestKey(routerId2, cand.urlPath),
             value: JSON.stringify(value)
           });
           console.log(
@@ -13012,6 +12688,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
             globalThis.__rscRouterDiscoveryActive ?? false
           );
           s.devServerOrigin = getDevServerOrigin();
+          globalThis.__PRERENDER_DEV_URL = s.devServerOrigin;
           let tempRscEnv;
           let optimizerHashBefore2;
           try {
@@ -14065,7 +13742,13 @@ ${details}`,
             chunk.code,
             s.resolvedPrerenderModules,
             "Prerender",
-            false
+            false,
+            // Mark onDemand exports (retained, not evicted) from the
+            // discovery-derived $$id set — the same evaluated source that sets
+            // the runtime od trie flag, so retention and serve can never
+            // disagree. Populated by discoverRouters (buildStart), which runs
+            // before this generateBundle pass.
+            s.onDemandHandlerIds
           );
           if (handlers.length > 0) {
             const existing = s.handlerChunkInfoMap.get(fileName);