@rangojs/router 0.20.0 → 0.22.0

package/dist/vite/index.js

@@ -22,26 +22,26 @@ function createRangoDebugger(namespace) {
   if (shadow.enabled) return shadow;
   return void 0;
 }
-async function timed(debug13, label, fn) {
-  if (!debug13) return await fn();
+async function timed(debug14, label, fn) {
+  if (!debug14) return await fn();
   const start = performance.now();
   try {
     return await fn();
   } finally {
-    debug13("%s (%sms)", label, (performance.now() - start).toFixed(1));
+    debug14("%s (%sms)", label, (performance.now() - start).toFixed(1));
   }
 }
-function timedSync(debug13, label, fn) {
-  if (!debug13) return fn();
+function timedSync(debug14, label, fn) {
+  if (!debug14) return fn();
   const start = performance.now();
   try {
     return fn();
   } finally {
-    debug13("%s (%sms)", label, (performance.now() - start).toFixed(1));
+    debug14("%s (%sms)", label, (performance.now() - start).toFixed(1));
   }
 }
-function createCounter(debug13, label) {
-  if (!debug13) return void 0;
+function createCounter(debug14, label) {
+  if (!debug14) return void 0;
   let n = 0;
   let totalMs = 0;
   let slowestMs = 0;
@@ -75,7 +75,7 @@ function createCounter(debug13, label) {
     },
     flush() {
       if (n === 0) return;
-      debug13(
+      debug14(
         "%s: %d files, %sms total, slowest %sms %s",
         label,
         n,
@@ -119,7 +119,7 @@ __export(client_ref_hashing_exports, {
   hashRefKey: () => hashRefKey,
   transformClientRefs: () => transformClientRefs
 });
-import { relative as relative3 } from "node:path";
+import { relative as relative2 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 function hashRefKey(relativeId) {
   return createHash2("sha256").update(relativeId).digest("hex").slice(0, 12);
@@ -132,10 +132,10 @@ function computeProductionHash(projectRoot, refKey) {
     const absPath = decodeURIComponent(
       refKey.slice(CLIENT_IN_SERVER_PKG_PROXY_PREFIX.length)
     );
-    toHash = relative3(projectRoot, absPath).replaceAll("\\", "/");
+    toHash = relative2(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith(FS_PREFIX)) {
     const absPath = refKey.slice(FS_PREFIX.length - 1);
-    toHash = relative3(projectRoot, absPath).replaceAll("\\", "/");
+    toHash = relative2(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith("/")) {
     toHash = refKey.slice(1);
   } else {
@@ -158,7 +158,7 @@ function transformClientRefs(code, projectRoot) {
   return hasReplacement ? result : null;
 }
 function hashClientRefs(projectRoot) {
-  const counter = createCounter(debug6, "hash-client-refs");
+  const counter = createCounter(debug5, "hash-client-refs");
   return {
     name: "@rangojs/router:hash-client-refs",
     enforce: "post",
@@ -180,12 +180,12 @@ function hashClientRefs(projectRoot) {
     }
   };
 }
-var debug6, CLIENT_PKG_PROXY_PREFIX, CLIENT_IN_SERVER_PKG_PROXY_PREFIX, FS_PREFIX, REGISTER_CLIENT_REF_RE;
+var debug5, CLIENT_PKG_PROXY_PREFIX, CLIENT_IN_SERVER_PKG_PROXY_PREFIX, FS_PREFIX, REGISTER_CLIENT_REF_RE;
 var init_client_ref_hashing = __esm({
   "src/vite/plugins/client-ref-hashing.ts"() {
     "use strict";
     init_debug();
-    debug6 = createRangoDebugger(NS.transform);
+    debug5 = createRangoDebugger(NS.transform);
     CLIENT_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-package-proxy/";
     CLIENT_IN_SERVER_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-in-server-package-proxy/";
     FS_PREFIX = "/@fs/";
@@ -492,12 +492,12 @@ function waitForViewportImages() {
     return rect.bottom > 0 && rect.right > 0 && rect.top < window.innerHeight && rect.left < window.innerWidth;
   });
   if (pending.length === 0) return Promise.resolve();
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     const settled = /* @__PURE__ */ new Set();
     const settle = (img) => {
       if (settled.has(img)) return;
       settled.add(img);
-      if (settled.size >= pending.length) resolve14();
+      if (settled.size >= pending.length) resolve15();
     };
     for (const img of pending) {
       img.addEventListener("load", () => settle(img), { once: true });
@@ -507,16 +507,16 @@ function waitForViewportImages() {
   });
 }
 function wait(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 function waitForIdle(timeout = 200) {
   if (typeof window !== "undefined" && "requestIdleCallback" in window) {
-    return new Promise((resolve14) => {
-      window.requestIdleCallback(() => resolve14(), { timeout });
+    return new Promise((resolve15) => {
+      window.requestIdleCallback(() => resolve15(), { timeout });
     });
   }
-  return new Promise((resolve14) => {
-    setTimeout(resolve14, 0);
+  return new Promise((resolve15) => {
+    setTimeout(resolve15, 0);
   });
 }
 var init_resource_ready = __esm({
@@ -766,7 +766,7 @@ function isSamePage(url) {
     return false;
   }
 }
-function buildPrefetchUrl(url, segmentIds, version, routerId) {
+function buildPrefetchUrl(url, segmentIds, version, routerId2) {
   let targetUrl;
   try {
     targetUrl = new URL(url, window.location.origin);
@@ -783,8 +783,8 @@ function buildPrefetchUrl(url, segmentIds, version, routerId) {
   if (version) {
     targetUrl.searchParams.set("_rsc_v", version);
   }
-  if (routerId) {
-    targetUrl.searchParams.set("_rsc_rid", routerId);
+  if (routerId2) {
+    targetUrl.searchParams.set("_rsc_rid", routerId2);
   }
   return targetUrl;
 }
@@ -843,8 +843,8 @@ function executePrefetchFetch(wildcardKey, sourceKey, fetchUrl, forceSourceScope
     const storageKey = scope === "source" ? sourceKey : wildcardKey;
     let resolveStreamComplete;
     let endedCleanly = false;
-    const streamComplete = new Promise((resolve14) => {
-      resolveStreamComplete = resolve14;
+    const streamComplete = new Promise((resolve15) => {
+      resolveStreamComplete = resolve15;
     });
     const tracked = teeWithCompletion(
       response,
@@ -908,9 +908,9 @@ function executePrefetchFetch(wildcardKey, sourceKey, fetchUrl, forceSourceScope
 function hasPrefetchHit(forceSourceScope, wildcardKey, sourceKey) {
   return forceSourceScope ? hasPrefetch(sourceKey) : hasPrefetch(wildcardKey) || hasPrefetch(sourceKey);
 }
-function prefetchDirect(url, segmentIds, version, routerId, prefetchKey) {
+function prefetchDirect(url, segmentIds, version, routerId2, prefetchKey) {
   if (!shouldPrefetch()) return;
-  const targetUrl = buildPrefetchUrl(url, segmentIds, version, routerId);
+  const targetUrl = buildPrefetchUrl(url, segmentIds, version, routerId2);
   if (!targetUrl) return;
   const forceSourceScope = prefetchKey === ":source";
   if (!forceSourceScope && isSamePage(url)) {
@@ -946,12 +946,12 @@ function prefetchDirect(url, segmentIds, version, routerId, prefetchKey) {
     targetUrl.toString(),
     forceSourceScope,
     rangoState,
-    routerId
+    routerId2
   );
 }
-function prefetchQueued(url, segmentIds, version, routerId, prefetchKey) {
+function prefetchQueued(url, segmentIds, version, routerId2, prefetchKey) {
   if (!shouldPrefetch()) return "";
-  const targetUrl = buildPrefetchUrl(url, segmentIds, version, routerId);
+  const targetUrl = buildPrefetchUrl(url, segmentIds, version, routerId2);
   if (!targetUrl) return "";
   const forceSourceScope = prefetchKey === ":source";
   if (!forceSourceScope && isSamePage(url)) {
@@ -987,7 +987,7 @@ function prefetchQueued(url, segmentIds, version, routerId, prefetchKey) {
       fetchUrlStr,
       forceSourceScope,
       rangoState,
-      routerId,
+      routerId2,
       signal
     ).then(() => {
     });
@@ -1061,14 +1061,14 @@ function withRuntime(run) {
   }).catch(() => {
   });
 }
-function prefetchDirect2(url, segmentIds, version, routerId, prefetchKey) {
+function prefetchDirect2(url, segmentIds, version, routerId2, prefetchKey) {
   withRuntime(
-    (loaded) => loaded.prefetchDirect(url, segmentIds, version, routerId, prefetchKey)
+    (loaded) => loaded.prefetchDirect(url, segmentIds, version, routerId2, prefetchKey)
   );
 }
-function prefetchQueued2(url, segmentIds, version, routerId, prefetchKey) {
+function prefetchQueued2(url, segmentIds, version, routerId2, prefetchKey) {
   withRuntime(
-    (loaded) => loaded.prefetchQueued(url, segmentIds, version, routerId, prefetchKey)
+    (loaded) => loaded.prefetchQueued(url, segmentIds, version, routerId2, prefetchKey)
   );
 }
 function schedulePrefetchWhenRouterIdle(eventController, callback) {
@@ -1098,8 +1098,8 @@ var init_loader = __esm({
 });
 
 // src/vite/rango.ts
-import { readFileSync as readFileSync10, existsSync as existsSync11 } from "node:fs";
-import { resolve as resolve13 } from "node:path";
+import { readFileSync as readFileSync12, existsSync as existsSync13 } from "node:fs";
+import { resolve as resolve14 } from "node:path";
 
 // src/vite/plugins/expose-action-id.ts
 import { getPluginApi } from "@vitejs/plugin-rsc";
@@ -1569,10 +1569,56 @@ function exposeActionId() {
 
 // src/vite/encryption-key.ts
 import { randomBytes } from "node:crypto";
-var cachedKey;
+var AES_KEY_BYTES = /* @__PURE__ */ new Set([16, 24, 32]);
+var EXPECTED = "a base64-encoded AES key of 16, 24 or 32 bytes (openssl rand -base64 32)";
+var resolvedKey;
+function assertValidEncryptionKey(value, source) {
+  if (typeof value !== "string") {
+    throw new Error(
+      `[rango] ${source} must be a string, received ${typeof value}. Expected ${EXPECTED}.`
+    );
+  }
+  if (value === "") {
+    throw new Error(
+      `[rango] ${source} is an empty string. Unset it to generate a key per build, or set it to ${EXPECTED}.`
+    );
+  }
+  const bytes = /^[A-Za-z0-9+/]+={0,2}$/.test(value) ? Buffer.from(value, "base64") : void 0;
+  if (!bytes || bytes.toString("base64").replace(/=+$/, "") !== value.replace(/=+$/, "")) {
+    throw new Error(
+      `[rango] ${source} is not valid base64. Expected ${EXPECTED}.`
+    );
+  }
+  if (!AES_KEY_BYTES.has(bytes.length)) {
+    throw new Error(
+      `[rango] ${source} decodes to ${bytes.length} bytes. Expected ${EXPECTED}.`
+    );
+  }
+}
+function configureEncryptionKey(option) {
+  if (option !== void 0) {
+    assertValidEncryptionKey(option, "rango({ encryptionKey })");
+    resolvedKey = { key: option, stable: true };
+    return;
+  }
+  const fromEnv = process.env.RANGO_ENCRYPTION_KEY;
+  if (fromEnv !== void 0) {
+    assertValidEncryptionKey(fromEnv, "RANGO_ENCRYPTION_KEY");
+    resolvedKey = { key: fromEnv, stable: true };
+    return;
+  }
+  if (resolvedKey && !resolvedKey.stable) return;
+  resolvedKey = { key: randomBytes(32).toString("base64"), stable: false };
+}
+function resolved() {
+  if (!resolvedKey) configureEncryptionKey(void 0);
+  return resolvedKey;
+}
 function buildEncryptionKey() {
-  cachedKey ??= process.env.RANGO_ENCRYPTION_KEY ?? randomBytes(32).toString("base64");
-  return cachedKey;
+  return resolved().key;
+}
+function isEncryptionKeyStable() {
+  return resolved().stable;
 }
 function defineEncryptionKeyExpr() {
   return JSON.stringify(buildEncryptionKey());
@@ -1587,10 +1633,10 @@ import path4 from "node:path";
 function isDirectivePrologueStatement(node) {
   return node?.type === "ExpressionStatement" && typeof node.directive === "string";
 }
-function findImportInsertionPos(code, parseAst7) {
+function findImportInsertionPos(code, parseAst8) {
   let program;
   try {
-    program = parseAst7(code, { lang: "tsx" });
+    program = parseAst8(code, { lang: "tsx" });
   } catch {
     return 0;
   }
@@ -1627,10 +1673,10 @@ function walkNode(node, parent, ancestors, enter) {
   }
   ancestors.pop();
 }
-function findHandlerCalls(code, fnName, parseAst7) {
+function findHandlerCalls(code, fnName, parseAst8) {
   let program;
   try {
-    program = parseAst7(code, { lang: "tsx" });
+    program = parseAst8(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -1702,18 +1748,18 @@ function getImportedLocalNamesFromProgram(program, importedName) {
   }
   return localNames;
 }
-function getImportedLocalNames(code, importedName, parseAst7) {
+function getImportedLocalNames(code, importedName, parseAst8) {
   try {
-    const program = parseAst7(code, { lang: "tsx" });
+    const program = parseAst8(code, { lang: "tsx" });
     return getImportedLocalNamesFromProgram(program, importedName);
   } catch {
     return /* @__PURE__ */ new Set();
   }
 }
-function extractImportDeclarations(code, parseAst7) {
+function extractImportDeclarations(code, parseAst8) {
   let program;
   try {
-    program = parseAst7(code, { lang: "tsx" });
+    program = parseAst8(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -1770,10 +1816,10 @@ function isSafeVariableDeclaration(node, handlerNames) {
     (d) => isSafeDeclaratorInit(d.init) && !(d.init?.type === "CallExpression" && d.init.callee?.type === "Identifier" && handlerNames.has(d.init.callee.name))
   );
 }
-function extractModuleLevelDeclarations(code, parseAst7, handlerNames) {
+function extractModuleLevelDeclarations(code, parseAst8, handlerNames) {
   let program;
   try {
-    program = parseAst7(code, { lang: "tsx" });
+    program = parseAst8(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -1804,17 +1850,17 @@ function extractModuleLevelDeclarations(code, parseAst7, handlerNames) {
   }
   return declarations;
 }
-function transformInlineHandlers(fnName, virtualPrefix, s, code, filePath, virtualRegistry, moduleId, parseAst7) {
-  const sites = findHandlerCalls(code, fnName, parseAst7);
+function transformInlineHandlers(fnName, virtualPrefix, s, code, filePath, virtualRegistry, moduleId, parseAst8) {
+  const sites = findHandlerCalls(code, fnName, parseAst8);
   const inlineSites = sites.filter((site) => site.exportInfo === null);
   if (inlineSites.length === 0) return false;
-  const imports = extractImportDeclarations(code, parseAst7);
-  const staticNames = getImportedLocalNames(code, "Static", parseAst7);
-  const prerenderNames = getImportedLocalNames(code, "Prerender", parseAst7);
+  const imports = extractImportDeclarations(code, parseAst8);
+  const staticNames = getImportedLocalNames(code, "Static", parseAst8);
+  const prerenderNames = getImportedLocalNames(code, "Prerender", parseAst8);
   const handlerNames = /* @__PURE__ */ new Set([...staticNames, ...prerenderNames]);
   const declarations = extractModuleLevelDeclarations(
     code,
-    parseAst7,
+    parseAst8,
     handlerNames
   );
   const importStatements = [];
@@ -1837,7 +1883,7 @@ function transformInlineHandlers(fnName, virtualPrefix, s, code, filePath, virtu
   }
   if (importStatements.length > 0) {
     const importBlock = importStatements.join("\n") + "\n";
-    const insertionPos = findImportInsertionPos(code, parseAst7);
+    const insertionPos = findImportInsertionPos(code, parseAst8);
     if (insertionPos === 0) {
       s.prepend(importBlock);
     } else {
@@ -2379,6 +2425,58 @@ ${binding.localName}.$$id = "${handlerId}";`;
 // src/vite/plugins/expose-internal-ids.ts
 init_debug();
 
+// src/vite/utils/compare-strings.ts
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/vite/discovery/state.ts
+var VIRTUAL_ROUTES_MANIFEST_ID = "virtual:rsc-router/routes-manifest";
+var VIRTUAL_LOADER_MANIFEST_ID = "virtual:rsc-router/loader-manifest";
+function createDiscoveryState(entryPath, opts) {
+  return {
+    resolvedEntryPath: entryPath,
+    projectRoot: "",
+    isBuildMode: false,
+    userResolveAlias: void 0,
+    userRunnerConfig: void 0,
+    userResolvePlugins: [],
+    scanFilter: void 0,
+    cachedRouterFiles: void 0,
+    opts,
+    mergedRouteManifest: null,
+    perRouterManifests: [],
+    perRouterTrieMap: /* @__PURE__ */ new Map(),
+    perRouterPrecomputedMap: /* @__PURE__ */ new Map(),
+    perRouterManifestDataMap: /* @__PURE__ */ new Map(),
+    clientUrlSourceByReferenceId: /* @__PURE__ */ new Map(),
+    clientUrlProjectionMap: /* @__PURE__ */ new Map(),
+    prerenderManifestEntries: null,
+    staticManifestEntries: null,
+    shellCandidates: null,
+    prerenderPayloadValues: null,
+    shellPhaseTempServer: null,
+    serverBuildGraph: null,
+    clientBuildGraph: null,
+    ssrBundle: null,
+    versionModuleFiles: /* @__PURE__ */ new Map(),
+    buildData: [],
+    handlerChunkInfoMap: /* @__PURE__ */ new Map(),
+    staticHandlerChunkInfoMap: /* @__PURE__ */ new Map(),
+    onDemandHandlerIds: /* @__PURE__ */ new Map(),
+    rscEntryFileName: null,
+    resolvedPrerenderModules: void 0,
+    resolvedStaticModules: void 0,
+    discoveryDone: null,
+    devDiscoveryEpoch: opts?.preset === "cloudflare" ? Date.now() : void 0,
+    devServerOrigin: null,
+    devServer: null,
+    selfWrittenGenFiles: /* @__PURE__ */ new Map(),
+    SELF_WRITE_WINDOW_MS: 5e3,
+    lastDiscoveryError: null
+  };
+}
+
 // src/vite/plugins/expose-ids/router-transform.ts
 import MagicString2 from "magic-string";
 import path3 from "node:path";
@@ -2401,15 +2499,16 @@ function skipLeadingTrivia(code, start, end) {
   }
   return i;
 }
+function routerId(filePath, callIndex) {
+  return createHash("sha256").update(`${filePath}#${callIndex}`).digest("hex").slice(0, 8);
+}
 function transformRouter(code, filePath, routerFnNames, absolutePath, warn) {
-  const pat = new RegExp(
-    `\\b(?:${routerFnNames.map(escapeRegExp).join("|")})\\b`,
-    "g"
-  );
+  const pat = createCallPattern(routerFnNames);
   let match;
   const s = new MagicString2(code);
   let changed = false;
   const unsupportedSites = [];
+  let callIndex = -1;
   const basename2 = path3.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
   const routeNamesImport = `./${basename2}.named-routes.gen.js`;
   const routeNamesVar = `__rsc_rn`;
@@ -2421,13 +2520,12 @@ function transformRouter(code, filePath, routerFnNames, absolutePath, warn) {
     const calleeEnd = match.index + match[0].length;
     const parenPos = findCallParenAfterGenerics(code, calleeEnd);
     if (parenPos === -1) continue;
+    callIndex++;
     const closeParen = findMatchingParen(code, parenPos + 1);
     const callArgs = code.slice(parenPos + 1, closeParen);
     if (callArgs.includes(`$$routeNames: ${routeNamesVar}`)) continue;
     const sourceFilePath = absolutePath ?? filePath;
-    const lineNumber = code.slice(0, callStart).split("\n").length;
-    const hash = createHash("sha256").update(`${filePath}:${lineNumber}`).digest("hex").slice(0, 8);
-    const injected = ` $$id: "${hash}", $$sourceFile: "${sourceFilePath}", $$routeNames: ${routeNamesVar},`;
+    const injected = ` $$id: "${routerId(filePath, callIndex)}", $$sourceFile: "${sourceFilePath}", $$routeNames: ${routeNamesVar},`;
     const argsContentStart = skipLeadingTrivia(code, parenPos + 1, closeParen);
     const firstArgChar = code[argsContentStart];
     if (firstArgChar === "{") {
@@ -2437,9 +2535,7 @@ function transformRouter(code, filePath, routerFnNames, absolutePath, warn) {
       changed = true;
       s.appendRight(parenPos + 1, `{${injected} }`);
     } else {
-      const lastNl = code.lastIndexOf("\n", callStart - 1);
-      const column = callStart - (lastNl + 1) + 1;
-      unsupportedSites.push({ line: lineNumber, column });
+      unsupportedSites.push(offsetToLineColumn(code, callStart));
     }
   }
   if (unsupportedSites.length > 0 && warn) {
@@ -2459,11 +2555,13 @@ function transformRouter(code, filePath, routerFnNames, absolutePath, warn) {
 }
 function exposeRouterId() {
   let projectRoot = "";
+  let rootRelativeSourceFile = false;
   const counter = createCounter(debug2, "expose-router-id");
   return {
     name: "@rangojs/router:expose-router-id",
     configResolved(config) {
       projectRoot = config.root;
+      rootRelativeSourceFile = config.command === "build";
     },
     buildEnd() {
       counter?.flush();
@@ -2485,7 +2583,7 @@ function exposeRouterId() {
           code,
           filePath,
           routerFnNames,
-          normalizePath(id),
+          rootRelativeSourceFile ? void 0 : normalizePath(id),
           warn
         );
       } finally {
@@ -2497,7 +2595,7 @@ function exposeRouterId() {
 
 // src/vite/plugins/expose-internal-ids.ts
 var debug3 = createRangoDebugger(NS.transform);
-var VIRTUAL_LOADER_MANIFEST = "virtual:rsc-router/loader-manifest";
+var VIRTUAL_LOADER_MANIFEST = VIRTUAL_LOADER_MANIFEST_ID;
 var RESOLVED_VIRTUAL_LOADER_MANIFEST = "\0" + VIRTUAL_LOADER_MANIFEST;
 var VIRTUAL_HANDLER_PREFIX = "virtual:handler-extract:";
 function createLoaderScanStubPlugin() {
@@ -2568,8 +2666,8 @@ function exposeInternalIds(options) {
       prerenderHandlerModules,
       staticHandlerModules
     },
-    configResolved(resolved) {
-      config = resolved;
+    configResolved(resolved2) {
+      config = resolved2;
       isBuild = options?.forceBuild || config.command === "build";
       projectRoot = config.root;
     },
@@ -2607,7 +2705,10 @@ setLoaderImports({});
 `;
       }
       const lazyImports = [];
-      for (const [hashedId, { filePath, exportName }] of loaderRegistry) {
+      const sortedLoaders = [...loaderRegistry].sort(
+        ([a], [b]) => compareStrings(a, b)
+      );
+      for (const [hashedId, { filePath, exportName }] of sortedLoaders) {
         lazyImports.push(
           `  "${hashedId}": () => import("/${filePath}").then(m => m.${exportName})`
         );
@@ -3103,8 +3204,8 @@ async function transformUseCache(code, id, options) {
   const { hasDirective: hasDirective2, transformWrapExport, transformHoistInlineDirective } = rscTransforms;
   let ast;
   try {
-    const { parseAst: parseAst7 } = await import("vite");
-    ast = parseAst7(code, { lang: "tsx" });
+    const { parseAst: parseAst8 } = await import("vite");
+    ast = parseAst8(code, { lang: "tsx" });
   } catch {
     return;
   }
@@ -3395,37 +3496,37 @@ function analyzeScopes(program) {
     if (!pattern) return;
     switch (pattern.type) {
       case "Identifier":
-        if (pattern.typeAnnotation) walk2(pattern.typeAnnotation, scope, true);
+        if (pattern.typeAnnotation) walk3(pattern.typeAnnotation, scope, true);
         return;
       case "ObjectPattern":
         for (const prop of pattern.properties) {
           if (prop.type === "RestElement") {
             walkPattern(prop.argument, scope, typeOnly);
           } else {
-            if (prop.computed) walk2(prop.key, scope, typeOnly);
+            if (prop.computed) walk3(prop.key, scope, typeOnly);
             walkPattern(prop.value, scope, typeOnly);
           }
         }
-        if (pattern.typeAnnotation) walk2(pattern.typeAnnotation, scope, true);
+        if (pattern.typeAnnotation) walk3(pattern.typeAnnotation, scope, true);
         return;
       case "ArrayPattern":
         for (const element of pattern.elements) {
           walkPattern(element, scope, typeOnly);
         }
-        if (pattern.typeAnnotation) walk2(pattern.typeAnnotation, scope, true);
+        if (pattern.typeAnnotation) walk3(pattern.typeAnnotation, scope, true);
         return;
       case "RestElement":
         walkPattern(pattern.argument, scope, typeOnly);
         return;
       case "AssignmentPattern":
         walkPattern(pattern.left, scope, typeOnly);
-        walk2(pattern.right, scope, typeOnly);
+        walk3(pattern.right, scope, typeOnly);
         return;
       case "TSParameterProperty":
         walkPattern(pattern.parameter, scope, typeOnly);
         return;
       default:
-        walk2(pattern, scope, typeOnly);
+        walk3(pattern, scope, typeOnly);
     }
   };
   const hoistDeclarations = (statements, scope) => {
@@ -3459,44 +3560,44 @@ function analyzeScopes(program) {
       }
     }
   };
-  const walk2 = (node, scope, typeOnly) => {
+  const walk3 = (node, scope, typeOnly) => {
     if (!node || typeof node !== "object") return;
     if (Array.isArray(node)) {
-      for (const item of node) walk2(item, scope, typeOnly);
+      for (const item of node) walk3(item, scope, typeOnly);
       return;
     }
     if (typeof node.type !== "string") return;
     switch (node.type) {
       case "Identifier":
         references.push({ node, scope, typeOnly });
-        if (node.typeAnnotation) walk2(node.typeAnnotation, scope, true);
+        if (node.typeAnnotation) walk3(node.typeAnnotation, scope, true);
         return;
       case "ImportDeclaration":
       case "ExportAllDeclaration":
         return;
       case "ExportNamedDeclaration":
-        if (node.declaration) walk2(node.declaration, scope, typeOnly);
+        if (node.declaration) walk3(node.declaration, scope, typeOnly);
         else if (!node.source) {
           for (const spec of node.specifiers) {
-            walk2(spec.local, scope, typeOnly || node.exportKind === "type");
+            walk3(spec.local, scope, typeOnly || node.exportKind === "type");
           }
         }
         return;
       case "MemberExpression":
-        walk2(node.object, scope, typeOnly);
-        if (node.computed) walk2(node.property, scope, typeOnly);
+        walk3(node.object, scope, typeOnly);
+        if (node.computed) walk3(node.property, scope, typeOnly);
         return;
       case "Property":
       case "MethodDefinition":
       case "PropertyDefinition":
       case "TSPropertySignature":
       case "TSMethodSignature":
-        if (node.computed) walk2(node.key, scope, typeOnly);
-        walk2(node.value, scope, typeOnly);
-        if (node.typeAnnotation) walk2(node.typeAnnotation, scope, true);
+        if (node.computed) walk3(node.key, scope, typeOnly);
+        walk3(node.value, scope, typeOnly);
+        if (node.typeAnnotation) walk3(node.typeAnnotation, scope, true);
         return;
       case "LabeledStatement":
-        walk2(node.body, scope, typeOnly);
+        walk3(node.body, scope, typeOnly);
         return;
       case "BreakStatement":
       case "ContinueStatement":
@@ -3506,25 +3607,25 @@ function analyzeScopes(program) {
       case "JSXClosingElement": {
         const ref = jsxNameReference(node.name);
         if (ref) references.push({ node: ref, scope, typeOnly });
-        walk2(node.typeArguments, scope, true);
-        walk2(node.attributes, scope, typeOnly);
+        walk3(node.typeArguments, scope, true);
+        walk3(node.attributes, scope, typeOnly);
         return;
       }
       case "TSQualifiedName":
-        walk2(node.left, scope, typeOnly);
+        walk3(node.left, scope, typeOnly);
         return;
       case "TSEnumMember":
-        walk2(node.initializer, scope, typeOnly);
+        walk3(node.initializer, scope, typeOnly);
         return;
       case "TSTypeAliasDeclaration":
       case "TSInterfaceDeclaration":
-        walk2(node.typeParameters, scope, true);
-        walk2(node.typeAnnotation ?? node.body, scope, true);
-        walk2(node.extends, scope, true);
+        walk3(node.typeParameters, scope, true);
+        walk3(node.typeAnnotation ?? node.body, scope, true);
+        walk3(node.extends, scope, true);
         return;
       case "VariableDeclarator":
         walkPattern(node.id, scope, typeOnly);
-        walk2(node.init, scope, typeOnly);
+        walk3(node.init, scope, typeOnly);
         return;
       case "FunctionDeclaration":
       case "FunctionExpression":
@@ -3535,14 +3636,14 @@ function analyzeScopes(program) {
           fnScope.declarations.add(node.id.name);
         }
         for (const param of node.params) declarePattern(param, fnScope);
-        walk2(node.typeParameters, fnScope, true);
+        walk3(node.typeParameters, fnScope, true);
         for (const param of node.params) walkPattern(param, fnScope, typeOnly);
-        walk2(node.returnType, fnScope, true);
+        walk3(node.returnType, fnScope, true);
         if (node.body?.type === "BlockStatement") {
           hoistDeclarations(node.body.body, fnScope);
-          walk2(node.body.body, fnScope, typeOnly);
+          walk3(node.body.body, fnScope, typeOnly);
         } else {
-          walk2(node.body, fnScope, typeOnly);
+          walk3(node.body, fnScope, typeOnly);
         }
         return;
       }
@@ -3554,11 +3655,11 @@ function analyzeScopes(program) {
           classScope.declarations.add(node.id.name);
           scopeOf.set(node, classScope);
         }
-        walk2(node.superClass, classScope, typeOnly);
-        walk2(node.superTypeArguments, classScope, true);
-        walk2(node.typeParameters, classScope, true);
-        walk2(node.implements, classScope, true);
-        walk2(node.body, classScope, typeOnly);
+        walk3(node.superClass, classScope, typeOnly);
+        walk3(node.superTypeArguments, classScope, true);
+        walk3(node.typeParameters, classScope, true);
+        walk3(node.implements, classScope, true);
+        walk3(node.body, classScope, typeOnly);
         return;
       }
       case "BlockStatement":
@@ -3566,7 +3667,7 @@ function analyzeScopes(program) {
         const blockScope = new Scope(scope, false, node);
         scopeOf.set(node, blockScope);
         hoistDeclarations(node.body, blockScope);
-        walk2(node.body, blockScope, typeOnly);
+        walk3(node.body, blockScope, typeOnly);
         return;
       }
       case "ForStatement":
@@ -3579,12 +3680,12 @@ function analyzeScopes(program) {
           hoistDeclarations([head], loopScope);
         }
         for (const key of ["init", "left", "right", "test", "update", "body"]) {
-          walk2(node[key], loopScope, typeOnly);
+          walk3(node[key], loopScope, typeOnly);
         }
         return;
       }
       case "SwitchStatement": {
-        walk2(node.discriminant, scope, typeOnly);
+        walk3(node.discriminant, scope, typeOnly);
         const switchScope = new Scope(scope, false, node);
         scopeOf.set(node, switchScope);
         hoistDeclarations(
@@ -3592,8 +3693,8 @@ function analyzeScopes(program) {
           switchScope
         );
         for (const c of node.cases) {
-          walk2(c.test, switchScope, typeOnly);
-          walk2(c.consequent, switchScope, typeOnly);
+          walk3(c.test, switchScope, typeOnly);
+          walk3(c.consequent, switchScope, typeOnly);
         }
         return;
       }
@@ -3604,17 +3705,17 @@ function analyzeScopes(program) {
           declarePattern(node.param, catchScope);
           walkPattern(node.param, catchScope, typeOnly);
         }
-        walk2(node.body, catchScope, typeOnly);
+        walk3(node.body, catchScope, typeOnly);
         return;
       }
     }
     for (const key of Object.keys(node)) {
       if (key === "type" || key === "start" || key === "end") continue;
-      walk2(node[key], scope, typeOnly || TYPE_KEYS.has(key));
+      walk3(node[key], scope, typeOnly || TYPE_KEYS.has(key));
     }
   };
   hoistDeclarations(program.body, moduleScope);
-  walk2(program.body, moduleScope, false);
+  walk3(program.body, moduleScope, false);
   return { moduleScope, references, scopeOf };
 }
 function collectImports(program) {
@@ -4044,9 +4145,9 @@ function transitionWhenHoistPlugin() {
       emitted.delete(file);
       const result = await hoistTransitionWhens(code, id, {
         isServerOnlyImport: async (source) => {
-          const resolved = await this.resolve(source, id);
-          if (!resolved || resolved.external) return false;
-          const target = resolved.id.split("?", 1)[0];
+          const resolved2 = await this.resolve(source, id);
+          if (!resolved2 || resolved2.external) return false;
+          const target = resolved2.id.split("?", 1)[0];
           if (target.includes("/node_modules/") || target.startsWith("\0")) {
             return false;
           }
@@ -4207,9 +4308,9 @@ async function resolvePublicSpecifier(source, metadata, installedSpecifier, reso
       source
     )) {
       try {
-        const resolved = await resolvePackage(candidate, importer);
-        if (!resolved) continue;
-        const resolvedId = stripQueryAndHash(resolved);
+        const resolved2 = await resolvePackage(candidate, importer);
+        if (!resolved2) continue;
+        const resolvedId = stripQueryAndHash(resolved2);
         if (normalize(resolvedId) === normalize(source) && belongsToPackage(resolvedId, metadata.root)) {
           return candidate;
         }
@@ -4309,6 +4410,26 @@ function clientRefDedup() {
   };
 }
 
+// src/vite/plugins/stable-rsc-output.ts
+import { parseAst as parseAst4 } from "vite";
+
+// src/vite/discovery/build-versions.ts
+import { createHash as createHash3 } from "node:crypto";
+import { isBuiltin } from "node:module";
+import { posix, relative as relative3 } from "node:path";
+
+// src/router-versions.ts
+var DEFAULT_ROUTER_VERSIONS_KEY = "*";
+function uniformVersions(version) {
+  return { data: version, document: version };
+}
+function resolveVersionsFrom(table, routerId2, override) {
+  if (override !== void 0) return uniformVersions(override);
+  if (!table) return void 0;
+  const pair = (routerId2 !== void 0 && Object.hasOwn(table, routerId2) ? table[routerId2] : void 0) ?? table[DEFAULT_ROUTER_VERSIONS_KEY];
+  return pair ? { data: pair[0], document: pair[1] } : void 0;
+}
+
 // src/vite/plugins/virtual-entries.ts
 var VIRTUAL_ENTRY_BROWSER = `
 import {
@@ -4337,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(
@@ -4351,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
   );
 }
 
@@ -4457,12 +4585,11 @@ import {
 // consults them at router-module evaluation. Router-first would silently push
 // every clientUrls() app onto the deferred-subscription path and change mount
 // registration order with no error. The custom-entry injector keeps the same
-// guarantee by PREPENDING this list at file top (version-injector.ts).
+// guarantee by PREPENDING this list at file top (entry-bootstrap-injector.ts).
 ${bootstrapImports}
 
 import { router } from "${routerPath}";
 import { createRSCHandler } from "@rangojs/router/internal/rsc-handler";
-import { VERSION } from "@rangojs/router:version";
 
 // Lazily create the handler on first request so that ESM live bindings
 // have resolved by the time we read \`router\`. During HMR the module may
@@ -4472,7 +4599,6 @@ export default function handler(request, env) {
   if (!_handler) {
     _handler = createRSCHandler({
       router,
-      version: VERSION,
       // Forward the router's CSP nonce provider. createRSCHandler reads the
       // provider only from options.nonce; without this, createRouter({ nonce })
       // is silently dropped on the Node preset (the Cloudflare path wires it via
@@ -4572,7 +4698,726 @@ var VIRTUAL_IDS = {
   version: "@rangojs/router:version"
 };
 function getVirtualVersionContent(version) {
-  return `export const VERSION = ${JSON.stringify(version)};`;
+  return [
+    `export const VERSION = ${JSON.stringify(version)};`,
+    `export const ROUTER_VERSIONS = undefined;`
+  ].join("\n");
+}
+var ROUTER_VERSIONS_PLACEHOLDER = "__RANGO_ROUTER_VERSIONS__";
+function getVirtualBuildVersionContent() {
+  return [
+    `export const ROUTER_VERSIONS = ${ROUTER_VERSIONS_PLACEHOLDER};`,
+    `export const VERSION = ROUTER_VERSIONS[${JSON.stringify(DEFAULT_ROUTER_VERSIONS_KEY)}][1];`
+  ].join("\n");
+}
+
+// src/vite/utils/client-chunks.ts
+init_debug();
+init_client_ref_hashing();
+import { gzipSync } from "node:zlib";
+var debugChunks = createRangoDebugger(NS.chunks);
+function isSharedRuntime(meta) {
+  return [meta.id, meta.normalizedId].some(
+    (path6) => path6.includes("/node_modules/") || /\/@rangojs\/router\//.test(path6) || /\/packages\/(rangojs-router|rsc-router)\/(src|dist)\//.test(path6)
+  );
+}
+function sanitizeGroup(name) {
+  return name.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "app";
+}
+var ROUTE_ROOT_DIRS = /* @__PURE__ */ new Set([
+  "routes",
+  "route",
+  "pages",
+  "page",
+  "app",
+  "features",
+  "feature",
+  "views",
+  "view",
+  "handlers",
+  "urls",
+  "modules",
+  "screens",
+  "sections"
+]);
+var SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set(["app"]);
+function directoryClientChunks(meta, ctx) {
+  if (isSharedRuntime(meta)) {
+    return void 0;
+  }
+  if (ctx?.fallbackRefs.size && ctx.fallbackRefs.has(hashRefKey(meta.normalizedId))) {
+    debugChunks?.("fallback %s -> app-fallback", meta.normalizedId);
+    return "app-fallback";
+  }
+  const segments = meta.normalizedId.split("/").filter(Boolean);
+  const dirCount = segments.length - 1;
+  const isMarkerAt = (i) => i < dirCount - 1 && ROUTE_ROOT_DIRS.has(segments[i].toLowerCase());
+  for (let i = 0; i < dirCount - 1; i++) {
+    if (!isMarkerAt(i)) continue;
+    const marker = SOURCE_ROOT_DIRS.has(segments[i].toLowerCase()) && isMarkerAt(i + 1) ? i + 1 : i;
+    const group = `app-${sanitizeGroup(segments[marker + 1])}`;
+    debugChunks?.("split %s -> %s", meta.normalizedId, group);
+    return group;
+  }
+  debugChunks?.(
+    "shared %s (no route-root marker; inherits default grouping)",
+    meta.normalizedId
+  );
+  return void 0;
+}
+function resolveClientChunks(option, ctx) {
+  if (!option) return void 0;
+  if (option === true) return (meta) => directoryClientChunks(meta, ctx);
+  return option;
+}
+var CLIENT_REFERENCES_MODULE_ID = "\0virtual:vite-rsc/client-references";
+var CLIENT_GROUP_PREFIX = `${CLIENT_REFERENCES_MODULE_ID}/group/`;
+function clientChunksReport(log = debugChunks) {
+  if (!log) return void 0;
+  return {
+    name: "@rangojs/router:client-chunks-report",
+    apply: "build",
+    applyToEnvironment: (env) => env.name === "client",
+    generateBundle(_options, bundle) {
+      for (const chunk of Object.values(bundle)) {
+        if (chunk.type !== "chunk") continue;
+        const facade = chunk.facadeModuleId;
+        if (!facade?.startsWith(CLIENT_GROUP_PREFIX)) continue;
+        log(
+          "group %s: %d client reference(s), %d B (%d B gzip) -> %s",
+          facade.slice(CLIENT_GROUP_PREFIX.length).replaceAll("\0", "\\0"),
+          this.getModuleInfo(facade)?.importedIds.length ?? 0,
+          Buffer.byteLength(chunk.code),
+          gzipSync(chunk.code).length,
+          chunk.fileName
+        );
+      }
+    }
+  };
+}
+
+// src/vite/discovery/build-versions.ts
+function identifier(name) {
+  return new RegExp(`(?<![\\w$.])${escapeRegExp(name)}(?![\\w$])`, "g");
+}
+var ENCRYPTION_RUNTIME_ID = "/utils/encryption-runtime";
+var ENCRYPTION_RUNTIME_IMPORT = /import\s*\*\s*as\s+([A-Za-z_$][\w$]*)\s+from\s*["'][^"'\n]*\/utils\/encryption-runtime[^"'\n]*["']/;
+function usesEncryptionRuntime(code) {
+  if (code == null) return true;
+  const local = code.match(ENCRYPTION_RUNTIME_IMPORT)?.[1];
+  if (local === void 0) return true;
+  let occurrences = 0;
+  for (const _ of code.matchAll(identifier(local))) {
+    if (++occurrences > 1) return true;
+  }
+  return false;
+}
+function recordModuleEdges(context) {
+  const modules = /* @__PURE__ */ new Map();
+  for (const id of context.getModuleIds()) {
+    const info = context.getModuleInfo(id);
+    const imports = info?.importedIds ?? [];
+    const encryptsBoundArgs = imports.some((imported) => imported.includes(ENCRYPTION_RUNTIME_ID)) && usesEncryptionRuntime(info?.code);
+    modules.set(id, {
+      imports,
+      dynamicImports: info?.dynamicallyImportedIds ?? [],
+      ...encryptsBoundArgs ? { encryptsBoundArgs } : void 0
+    });
+  }
+  return modules;
+}
+function recordBundleFiles(bundle) {
+  const chunks = [];
+  const assets = [];
+  for (const file of Object.values(bundle)) {
+    if (file.type === "chunk") {
+      chunks.push({
+        fileName: file.fileName,
+        name: file.name ?? file.fileName,
+        moduleIds: file.moduleIds ?? [],
+        externalImports: [
+          ...file.imports ?? [],
+          ...file.dynamicImports ?? []
+        ].filter((specifier) => !Object.hasOwn(bundle, specifier))
+      });
+    } else {
+      assets.push({
+        fileName: file.fileName,
+        name: file.names?.[0] ?? file.fileName
+      });
+    }
+  }
+  return { chunks, assets };
+}
+function recordServerGraph(context, bundle) {
+  return { modules: recordModuleEdges(context), ...recordBundleFiles(bundle) };
+}
+function recordClientGraph(context, bundle) {
+  return {
+    modules: recordModuleEdges(context),
+    fileNames: Object.values(bundle).map((file) => file.fileName)
+  };
+}
+var SERVER_REFERENCES_MODULE_ID = "\0virtual:vite-rsc/server-references";
+var LOADER_REGISTRY = "\0" + VIRTUAL_LOADER_MANIFEST_ID;
+var ROUTES_REGISTRY = "\0" + VIRTUAL_ROUTES_MANIFEST_ID;
+var VERSION_MODULE = "\0" + VIRTUAL_IDS.version;
+var ENCRYPTION_KEY_FILE = "__vite_rsc_encryption_key.js";
+function isRegistryModule(id) {
+  return id === SERVER_REFERENCES_MODULE_ID || id === LOADER_REGISTRY || id === ROUTES_REGISTRY || id.startsWith(ROUTES_REGISTRY + "/") || id === CLIENT_REFERENCES_MODULE_ID || id.startsWith(CLIENT_REFERENCES_MODULE_ID + "/");
+}
+function routeManifestModuleId(routerId2) {
+  return `${ROUTES_REGISTRY}/${routerId2}`;
+}
+function walk(modules, roots, reached) {
+  const stack = [...roots];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (reached.has(id)) continue;
+    reached.add(id);
+    if (isRegistryModule(id)) continue;
+    const edges = modules.get(id);
+    if (!edges) continue;
+    for (const next of edges.imports) {
+      if (!reached.has(next)) stack.push(next);
+    }
+    for (const next of edges.dynamicImports) {
+      if (!reached.has(next)) stack.push(next);
+    }
+  }
+}
+function registryTargets(server) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const id of [SERVER_REFERENCES_MODULE_ID, LOADER_REGISTRY]) {
+    for (const target of server.modules.get(id)?.dynamicImports ?? []) {
+      targets.add(target);
+    }
+  }
+  return targets;
+}
+function ownersOf(subjects, reachOf) {
+  const owners = /* @__PURE__ */ new Set();
+  for (const [routerId2, reached] of reachOf) {
+    if (subjects.some((id) => reached.has(id))) owners.add(routerId2);
+  }
+  return owners.size > 0 ? owners : void 0;
+}
+function extendReach(server, client, targets, reach, roots) {
+  walk(server.modules, roots, reach.server);
+  if (!client || targets.size === 0) return;
+  for (; ; ) {
+    const seeds = [];
+    for (const id of reach.server) {
+      if (!reach.client.has(id) && client.modules.has(id)) seeds.push(id);
+    }
+    if (seeds.length === 0) return;
+    walk(client.modules, seeds, reach.client);
+    const found = [];
+    for (const target of targets) {
+      if (reach.client.has(target) && !reach.server.has(target)) {
+        found.push(target);
+      }
+    }
+    if (found.length === 0) return;
+    walk(server.modules, found, reach.server);
+  }
+}
+function findModuleId(modules, path6) {
+  if (modules.has(path6)) return path6;
+  for (const id of modules.keys()) {
+    const query = id.indexOf("?");
+    if (query !== -1 && id.slice(0, query) === path6) return id;
+  }
+  return void 0;
+}
+function staticImporters(modules) {
+  const importers = /* @__PURE__ */ new Map();
+  for (const [id, edges] of modules) {
+    if (isRegistryModule(id)) continue;
+    for (const imported of edges.imports) {
+      const list = importers.get(imported);
+      if (list) list.push(id);
+      else importers.set(imported, [id]);
+    }
+  }
+  return importers;
+}
+function resolveRouterMembers(server, client, routers) {
+  const targets = registryTargets(server);
+  const importers = staticImporters(server.modules);
+  const reachByRouter = /* @__PURE__ */ new Map();
+  for (const router of routers) {
+    const moduleId = router.moduleId !== void 0 ? findModuleId(server.modules, router.moduleId) : void 0;
+    if (moduleId === void 0) continue;
+    const climbed = /* @__PURE__ */ new Set();
+    const stack = [moduleId];
+    while (stack.length > 0) {
+      const id = stack.pop();
+      if (climbed.has(id)) continue;
+      climbed.add(id);
+      for (const importer of importers.get(id) ?? []) stack.push(importer);
+    }
+    const reach = { server: /* @__PURE__ */ new Set(), client: /* @__PURE__ */ new Set() };
+    extendReach(server, client, targets, reach, climbed);
+    reachByRouter.set(router.id, reach);
+  }
+  const serverReach = new Map(
+    [...reachByRouter].map(([routerId2, reach]) => [routerId2, reach.server])
+  );
+  const unattributed = [...targets].filter(
+    (target) => ownersOf([target], serverReach) === void 0
+  );
+  if (unattributed.length > 0) {
+    for (const reach of reachByRouter.values()) {
+      extendReach(server, client, targets, reach, unattributed);
+    }
+  }
+  const chunkOfModule = /* @__PURE__ */ new Map();
+  for (const chunk of server.chunks) {
+    for (const id of chunk.moduleIds) chunkOfModule.set(id, chunk.fileName);
+  }
+  const members = /* @__PURE__ */ new Map();
+  for (const [routerId2, { server: modules }] of reachByRouter) {
+    const chunkFiles = /* @__PURE__ */ new Set();
+    for (const id of modules) {
+      const fileName = chunkOfModule.get(id);
+      if (fileName !== void 0) chunkFiles.add(fileName);
+    }
+    const manifestChunk = chunkOfModule.get(routeManifestModuleId(routerId2));
+    if (manifestChunk !== void 0) chunkFiles.add(manifestChunk);
+    members.set(routerId2, { modules, chunkFiles });
+  }
+  return members;
+}
+function sha256(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+var baseName = posix.basename;
+function isAbsolutePath(path6) {
+  return path6.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path6);
+}
+var PNPM_PEER_SUFFIX = /(\/\.pnpm\/[^/]+?@[^/_]+)_[^/]+(?=\/)/g;
+function withoutWorkingDirectory(id) {
+  const kind = /(?:facade|shared):/.exec(id);
+  const virtual = id.indexOf("\0");
+  if (!kind || virtual === -1) return id;
+  const facade = kind.index + kind[0].length;
+  return virtual < facade ? id : id.slice(0, facade) + id.slice(virtual);
+}
+function portableModuleId(id, projectRoot) {
+  const path6 = id.startsWith("\0") ? id.slice(1) : id;
+  const nodeModules = path6.indexOf("/node_modules/");
+  if (nodeModules !== -1) {
+    return path6.slice(nodeModules + 1).replace(PNPM_PEER_SUFFIX, "$1");
+  }
+  if (isAbsolutePath(path6)) {
+    return relative3(projectRoot, path6).replaceAll("\\", "/");
+  }
+  return withoutWorkingDirectory(path6).replace(
+    /([?&][^=&]+=)([^&]+)/g,
+    (whole, name, value) => {
+      let decoded;
+      try {
+        decoded = decodeURIComponent(value);
+      } catch {
+        return whole;
+      }
+      return isAbsolutePath(decoded) ? name + portableModuleId(decoded, projectRoot) : whole;
+    }
+  );
+}
+var SERVER_CSS_MODULE = /^virtual:vite-rsc\/css\?type=rsc&id=([^&]+)/;
+function isSourceMap(fileName) {
+  return fileName.endsWith(".map");
+}
+var SERVER_REFERENCES_REGION_START = `//#region \\0${SERVER_REFERENCES_MODULE_ID.slice(1)}
+`;
+var REGION_END = "//#endregion";
+function stripServerReferenceMap(source) {
+  const start = source.indexOf(SERVER_REFERENCES_REGION_START);
+  if (start === -1) return source;
+  const bodyStart = start + SERVER_REFERENCES_REGION_START.length;
+  const end = source.indexOf(REGION_END, bodyStart);
+  if (end === -1) return source;
+  return source.slice(0, bodyStart) + source.slice(end);
+}
+var REGION_LINE = /^\/\/#region .*$/gm;
+function stripRegionPaths(source) {
+  return source.replace(REGION_LINE, "//#region");
+}
+var FILE_REFERENCE = "\0";
+var FOREIGN_FILE = "~";
+function digestBundle(bundle, projectRoot, read, label) {
+  const named = [];
+  for (const chunk of bundle.chunks) {
+    const ids = chunk.moduleIds.map((id) => portableModuleId(id, projectRoot)).sort();
+    const ext = posix.extname(chunk.fileName);
+    named.push({
+      fileName: chunk.fileName,
+      identity: `${chunk.name}~${sha256(ids.join("\n")).slice(0, 8)}${ext}`,
+      hashedName: baseName(chunk.fileName) !== chunk.name + ext,
+      chunk
+    });
+  }
+  for (const asset of bundle.assets) {
+    if (isSourceMap(asset.fileName)) continue;
+    named.push({
+      fileName: asset.fileName,
+      identity: asset.name,
+      hashedName: baseName(asset.fileName) !== baseName(asset.name)
+    });
+  }
+  const fileOfBaseName = /* @__PURE__ */ new Map();
+  for (const file of named) {
+    if (file.hashedName) {
+      fileOfBaseName.set(baseName(file.fileName), file.fileName);
+    }
+  }
+  const reference = fileOfBaseName.size > 0 ? new RegExp(
+    [...fileOfBaseName.keys()].sort((a, b) => b.length - a.length).map(escapeRegExp).join("|"),
+    "g"
+  ) : void 0;
+  const decoder3 = new TextDecoder();
+  return named.map(({ fileName, identity, chunk }) => {
+    const bytes = read(fileName);
+    if (bytes === void 0) {
+      throw new Error(
+        `the ${label} bundle lists ${fileName}, which is not in its output directory`
+      );
+    }
+    if (!chunk) {
+      return {
+        fileName,
+        identity,
+        base: sha256(bytes),
+        references: [],
+        externalImports: []
+      };
+    }
+    const references = [];
+    const text = stripRegionPaths(
+      stripServerReferenceMap(decoder3.decode(bytes))
+    );
+    const blanked = reference ? text.replace(reference, (name) => {
+      references.push(fileOfBaseName.get(name));
+      return FILE_REFERENCE;
+    }) : text;
+    return {
+      fileName,
+      identity,
+      base: sha256(blanked),
+      references,
+      externalImports: chunk.externalImports ?? []
+    };
+  });
+}
+function digestAsOwned(file, identityOf, owned) {
+  if (file.references.length === 0) return file.base;
+  return sha256(
+    JSON.stringify([
+      file.base,
+      ...file.references.map(
+        (name) => owned.has(name) ? identityOf.get(name) : FOREIGN_FILE
+      )
+    ])
+  );
+}
+var RUNTIME_SCHEME = /^(?:node|cloudflare|workerd|bun):/;
+var REPLACED_MARKER = /^(?:__CLOUDFLARE_MODULE__.*__CLOUDFLARE_MODULE__|virtual:vite-rsc\/assets-manifest)$/;
+var PACKAGE_NAME = /^(?:@[\w.~-]+\/)?[A-Za-z0-9~-][\w.~-]*$/;
+function classifyExternal(specifier) {
+  if (/^[./\\]/.test(specifier) || isAbsolutePath(specifier)) {
+    return { kind: "file" };
+  }
+  if (RUNTIME_SCHEME.test(specifier) || specifier.startsWith("data:") || isBuiltin(specifier) || REPLACED_MARKER.test(specifier)) {
+    return { kind: "provided" };
+  }
+  if (specifier.includes(":")) return { kind: "unknown" };
+  const parts = specifier.split("/");
+  const name = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  return PACKAGE_NAME.test(name) ? { kind: "package", name } : { kind: "unknown" };
+}
+function externalInputs(file, context) {
+  const { externals, undetermined } = context;
+  const inputs = [];
+  const add = (name, value) => {
+    if (value === void 0) undetermined.add(name);
+    inputs.push([
+      `external ${name}`,
+      sha256(value ?? `undetermined ${externals.buildId}`)
+    ]);
+  };
+  for (const specifier of file.externalImports) {
+    const external = classifyExternal(specifier);
+    if (external.kind === "package") {
+      add(external.name, externals.describePackage(external.name));
+    } else if (external.kind === "file") {
+      if (isAbsolutePath(specifier)) {
+        const inProject = portableModuleId(specifier, context.projectRoot);
+        add(
+          inProject.startsWith("..") ? specifier : inProject,
+          externals.readFile(specifier)
+        );
+      } else {
+        const fileName = posix.join(
+          posix.dirname(file.fileName),
+          specifier.replaceAll("\\", "/")
+        );
+        add(fileName, context.read(fileName));
+      }
+    } else if (external.kind === "unknown") {
+      add(specifier, void 0);
+    }
+  }
+  return inputs;
+}
+var VERSION_HEX_LENGTH = 16;
+function byName(a, b) {
+  return compareStrings(a[0], b[0]) || compareStrings(a[1], b[1]);
+}
+function distinct(inputs) {
+  const sorted = [...inputs].sort(byName);
+  return sorted.filter(
+    (item, index) => index === 0 || byName(item, sorted[index - 1]) !== 0
+  );
+}
+function hashInputs(label, inputs) {
+  return sha256(`${label}
+${JSON.stringify(inputs)}`).slice(
+    0,
+    VERSION_HEX_LENGTH
+  );
+}
+function serverCssRecords(server, projectRoot, serverResources) {
+  if (serverResources.size === 0) return [];
+  const moduleOf = /* @__PURE__ */ new Map();
+  for (const id of server.modules.keys()) {
+    const key = portableModuleId(id, projectRoot).match(SERVER_CSS_MODULE)?.[1];
+    if (key !== void 0) moduleOf.set(key, id);
+  }
+  return [...serverResources].map(([key, entry]) => ({
+    kind: "server-css",
+    key,
+    digest: sha256(entry),
+    moduleId: moduleOf.get(key)
+  }));
+}
+function computeRouterVersions(input) {
+  const { server, projectRoot } = input;
+  const undetermined = /* @__PURE__ */ new Set();
+  const files = digestBundle(server, projectRoot, input.readServerFile, "RSC");
+  const identityOf = new Map(
+    files.map((file) => [file.fileName, file.identity])
+  );
+  const assetFiles = new Set(server.assets.map((asset) => asset.fileName));
+  const externalContext = {
+    projectRoot,
+    externals: input.externals,
+    read: input.readServerFile,
+    undetermined
+  };
+  const externalsOf = new Map(
+    files.map((file) => [file.fileName, externalInputs(file, externalContext)])
+  );
+  const members = resolveRouterMembers(server, input.client, input.routers);
+  const reachOf = new Map(
+    [...members].map(([routerId2, member]) => [routerId2, member.modules])
+  );
+  const owned = [
+    ...input.buildData,
+    ...serverCssRecords(
+      server,
+      projectRoot,
+      input.serverResources ?? /* @__PURE__ */ new Map()
+    )
+  ].map(
+    (record) => ({
+      input: [`${record.kind} ${record.key}`, record.digest],
+      version: record.kind === "prerender" ? "document" : "data",
+      owners: record.routerId !== void 0 ? /* @__PURE__ */ new Set([record.routerId]) : ownersOf(
+        record.moduleId === void 0 ? [] : [record.moduleId],
+        reachOf
+      )
+    })
+  );
+  const encrypting = [...server.modules].filter(([, edges]) => edges.encryptsBoundArgs).map(([id]) => id);
+  const keyFile = input.readServerFile(ENCRYPTION_KEY_FILE);
+  if (keyFile !== void 0) {
+    owned.push({
+      input: ["encryption-key", sha256(keyFile)],
+      version: "data",
+      owners: ownersOf(encrypting, reachOf)
+    });
+  } else if (encrypting.length > 0) {
+    throw new Error(
+      `${encrypting.length} server module(s) encrypt action arguments (${portableModuleId(encrypting[0], projectRoot)}), but ${ENCRYPTION_KEY_FILE} is not in the RSC output directory, so the key cannot be made part of their cache version. The installed @vitejs/plugin-rsc keeps the key somewhere @rangojs/router does not know. Report it with the plugin-rsc version.`
+    );
+  }
+  const keyInput = owned.find((item) => item.input[0] === "encryption-key");
+  const ssrFiles = digestBundle(
+    input.ssr,
+    projectRoot,
+    input.readSsrFile,
+    "SSR"
+  );
+  const ssrIdentityOf = new Map(
+    ssrFiles.map((file) => [file.fileName, file.identity])
+  );
+  const everySsrFile = new Set(ssrFiles.map((file) => file.fileName));
+  const ssrAndClient = {
+    base: input.base,
+    ssr: distinct(
+      ssrFiles.map((file) => [
+        file.identity,
+        digestAsOwned(file, ssrIdentityOf, everySsrFile)
+      ])
+    ),
+    externals: distinct(
+      ssrFiles.flatMap(
+        (file) => externalInputs(file, { ...externalContext, read: input.readSsrFile })
+      )
+    ),
+    client: [...input.client.fileNames].sort()
+  };
+  const documentDigest = sha256(JSON.stringify(ssrAndClient));
+  const table = {};
+  const details = [];
+  const ownedByARouter = /* @__PURE__ */ new Set();
+  const add = (routerId2, chunkFiles) => {
+    const whole = chunkFiles === void 0;
+    const ownedFiles = new Set(
+      chunkFiles ?? files.map((file) => file.fileName)
+    );
+    for (const file of files) {
+      if (!ownedFiles.has(file.fileName)) continue;
+      for (const name of file.references) {
+        if (assetFiles.has(name)) ownedFiles.add(name);
+      }
+    }
+    const inputs = {
+      data: [],
+      document: [["ssr-and-client", documentDigest]]
+    };
+    for (const file of files) {
+      if (!ownedFiles.has(file.fileName)) continue;
+      if (!whole) ownedByARouter.add(file.fileName);
+      inputs.data.push(
+        [`file ${file.identity}`, digestAsOwned(file, identityOf, ownedFiles)],
+        ...externalsOf.get(file.fileName)
+      );
+    }
+    for (const item of owned) {
+      if (whole || item.owners === void 0 || item.owners.has(routerId2)) {
+        inputs[item.version].push(item.input);
+      }
+    }
+    const dataInputs = distinct(inputs.data);
+    const documentInputs = distinct(inputs.document);
+    const data = hashInputs("rango-data-version", dataInputs);
+    const document2 = hashInputs(
+      `rango-document-version
+${data}`,
+      documentInputs
+    );
+    table[routerId2] = [data, document2];
+    details.push({
+      routerId: routerId2,
+      data,
+      document: document2,
+      dataInputs,
+      documentInputs,
+      usesEncryptionKey: keyInput !== void 0 && (whole || keyInput.owners === void 0 || keyInput.owners.has(routerId2))
+    });
+  };
+  for (const router of input.routers) {
+    const member = members.get(router.id);
+    if (member) add(router.id, member.chunkFiles);
+  }
+  add(DEFAULT_ROUTER_VERSIONS_KEY);
+  return {
+    table,
+    details,
+    ssrAndClient,
+    unownedFiles: files.filter((file) => !ownedByARouter.has(file.fileName)).map((file) => file.identity).sort(),
+    undetermined: [...undetermined].sort()
+  };
+}
+function recordVersionModuleFiles(bundle) {
+  return Object.values(bundle).filter(
+    (file) => file.type === "chunk" && file.moduleIds?.includes(VERSION_MODULE)
+  ).map((file) => file.fileName);
+}
+function fillRouterVersions(source, table) {
+  if (!source.includes(ROUTER_VERSIONS_PLACEHOLDER)) return void 0;
+  const json = JSON.stringify(table);
+  return source.replaceAll(ROUTER_VERSIONS_PLACEHOLDER, () => json);
+}
+
+// src/vite/plugins/stable-rsc-output.ts
+function literalProperties(object) {
+  if (object?.type !== "ObjectExpression") return void 0;
+  const properties = [];
+  for (const property of object.properties ?? []) {
+    const key = property?.type === "Property" && !property.computed ? property.key?.value ?? property.key?.name : void 0;
+    if (typeof key !== "string") return void 0;
+    properties.push({
+      key,
+      start: property.start,
+      end: property.end,
+      value: property.value
+    });
+  }
+  return properties;
+}
+function defaultExportProperties(code) {
+  let program;
+  try {
+    program = parseAst4(code);
+  } catch {
+    return void 0;
+  }
+  return literalProperties(
+    (program.body ?? []).find(
+      (node) => node?.type === "ExportDefaultDeclaration"
+    )?.declaration
+  );
+}
+function sortDefaultExportProperties(code) {
+  const properties = defaultExportProperties(code);
+  if (!properties || properties.length < 2) return void 0;
+  const sorted = [...properties].sort((a, b) => compareStrings(a.key, b.key));
+  if (sorted.every((property, index) => property === properties[index])) {
+    return void 0;
+  }
+  return code.slice(0, properties[0].start) + sorted.map((property) => code.slice(property.start, property.end)).join(",\n") + code.slice(properties[properties.length - 1].end);
+}
+var ASSETS_MANIFEST_ID = "virtual:vite-rsc/assets-manifest";
+var ASSETS_MANIFEST_IMPORT = /import\s+([A-Za-z_$][\w$]*)\s+from\s*["']virtual:vite-rsc\/assets-manifest["']/;
+var ASSETS_MANIFEST_BINDING = "assetsManifest";
+var GENERATED_BINDINGS = /* @__PURE__ */ new Set([
+  "__vite_rsc_assets_manifest__",
+  "__vite_rsc_assets_manifest"
+]);
+function identifier2(name) {
+  return new RegExp(`(?<![\\w$.])${escapeRegExp(name)}(?![\\w$])`, "g");
+}
+function canonicalAssetsManifestBinding(code) {
+  const local = code.match(ASSETS_MANIFEST_IMPORT)?.[1];
+  if (local === void 0 || !GENERATED_BINDINGS.has(local)) return void 0;
+  if (identifier2(ASSETS_MANIFEST_BINDING).test(code)) return void 0;
+  return code.replace(identifier2(local), ASSETS_MANIFEST_BINDING);
+}
+function stableRscOutput() {
+  return {
+    name: "@rangojs/router:stable-rsc-output",
+    apply: "build",
+    // After plugin-rsc's transforms, which add the manifest import.
+    enforce: "post",
+    transform(code, id) {
+      const stable = id === SERVER_REFERENCES_MODULE_ID ? sortDefaultExportProperties(code) : code.includes(ASSETS_MANIFEST_ID) ? canonicalAssetsManifestBinding(code) : void 0;
+      return stable === void 0 ? null : { code: stable, map: null };
+    }
+  };
 }
 
 // src/vite/utils/package-resolution.ts
@@ -4583,7 +5428,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.20.0",
+  version: "0.22.0",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -4708,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",
@@ -4806,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",
@@ -4814,7 +5669,6 @@ var package_default = {
     "@playwright/test": "^1.49.1",
     "@testing-library/react": ">=16",
     "@vercel/functions": "^3.0.0",
-    "@vitejs/plugin-rsc": "^0.5.35",
     react: ">=19.2.8 <20",
     "react-dom": ">=19.2.8 <20",
     vite: "^8.0.16",
@@ -4894,7 +5748,8 @@ function getVendorAliases() {
   const specs = [
     "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser",
     "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
-    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/static.edge"
   ];
   const aliases = {};
   for (const spec of specs) {
@@ -5033,7 +5888,7 @@ declare global {
 }
 
 // src/build/route-types/scan-filter.ts
-import { join as join2, relative as relative2 } from "node:path";
+import { join as join2, relative as relative4 } from "node:path";
 import { readdirSync } from "node:fs";
 import picomatch from "picomatch";
 var DEFAULT_EXCLUDE_PATTERNS = [
@@ -5053,7 +5908,7 @@ function createScanFilter(root, opts) {
   const includeMatcher = hasInclude ? picomatch(include) : null;
   const excludeMatcher = effectiveExclude.length > 0 ? picomatch(effectiveExclude) : null;
   return (absolutePath) => {
-    const rel = relative2(root, absolutePath);
+    const rel = relative4(root, absolutePath);
     if (excludeMatcher && excludeMatcher(rel)) return false;
     if (includeMatcher) return includeMatcher(rel);
     return true;
@@ -5232,7 +6087,7 @@ function extractIncludesWithDiagnostics(code, sourceFileArg) {
     true,
     ts3.ScriptKind.TSX
   );
-  const resolved = [];
+  const resolved2 = [];
   const unresolvable = [];
   function visit(node) {
     if (ts3.isCallExpression(node)) {
@@ -5251,13 +6106,13 @@ function extractIncludesWithDiagnostics(code, sourceFileArg) {
         const namePrefix = extractNamePrefixFromInclude(node);
         const dynamicImportSpec = extractDynamicImportSpecifier(secondArg);
         if (ts3.isIdentifier(secondArg)) {
-          resolved.push({
+          resolved2.push({
             pathPrefix,
             variableName: secondArg.text,
             namePrefix
           });
         } else if (dynamicImportSpec !== null) {
-          resolved.push({
+          resolved2.push({
             pathPrefix,
             moduleSpecifier: dynamicImportSpec,
             namePrefix
@@ -5283,7 +6138,7 @@ function extractIncludesWithDiagnostics(code, sourceFileArg) {
     ts3.forEachChild(node, visit);
   }
   visit(sourceFile);
-  return { resolved, unresolvable };
+  return { resolved: resolved2, unresolvable };
 }
 function resolveImportedVariable(code, localName) {
   const defaultImportRegex = /import\s+([\w$]+)\s*(?:,\s*\{[^}]*\})?\s+from\s*["']([^"']+)["']/g;
@@ -5424,7 +6279,7 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
         );
       } else {
         const variableName = def.variableName;
-        const resolved = resolveIncludedVariable({
+        const resolved2 = resolveIncludedVariable({
           variableName,
           resolutionFile: targetFile,
           resolutionSource: targetSource,
@@ -5437,12 +6292,12 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
           fileNotFoundDetail: (specifier) => `import("${inc.moduleSpecifier}") default re-exports "${variableName}" from "${specifier}", which resolved to no file`,
           notFoundDetail: () => `import("${inc.moduleSpecifier}") default "${variableName}" not found in its imports or same-file scope`
         });
-        if (!resolved) continue;
-        childResult = resolved;
+        if (!resolved2) continue;
+        childResult = resolved2;
       }
     } else if (inc.variableName) {
       const variableName = inc.variableName;
-      const resolved = resolveIncludedVariable({
+      const resolved2 = resolveIncludedVariable({
         variableName,
         resolutionFile: filePath,
         resolutionSource: fullSource,
@@ -5455,8 +6310,8 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
         fileNotFoundDetail: (specifier) => `import "${specifier}" resolved to no file`,
         notFoundDetail: () => `variable "${variableName}" not found in imports or same-file scope`
       });
-      if (!resolved) continue;
-      childResult = resolved;
+      if (!resolved2) continue;
+      childResult = resolved2;
     } else {
       continue;
     }
@@ -6041,14 +6896,14 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
 }
 
 // src/vite/plugins/version-plugin.ts
-import { parseAst as parseAst5 } from "vite";
+import { parseAst as parseAst6 } from "vite";
 
 // src/vite/utils/directive-prologue.ts
-import { parseAst as parseAst4 } from "vite";
+import { parseAst as parseAst5 } from "vite";
 function hasUseClientDirective2(source) {
   let program;
   try {
-    program = parseAst4(source, { lang: "tsx" });
+    program = parseAst5(source, { lang: "tsx" });
   } catch {
     return false;
   }
@@ -6073,7 +6928,7 @@ function getClientModuleSignature(source) {
   if (!hasUseClientDirective2(source)) return void 0;
   let program;
   try {
-    program = parseAst5(source, { lang: "tsx" });
+    program = parseAst6(source, { lang: "tsx" });
   } catch {
     return void 0;
   }
@@ -6141,8 +6996,7 @@ function getClientModuleSignature(source) {
   };
 }
 function createVersionPlugin() {
-  const buildVersion = Date.now().toString(16);
-  let currentVersion3 = buildVersion;
+  let currentVersion3 = Date.now().toString(16);
   let isDev = false;
   let server = null;
   let resolvedCacheDir;
@@ -6162,13 +7016,6 @@ function createVersionPlugin() {
   return {
     name: "@rangojs/router:version",
     enforce: "pre",
-    // The build-time shell capture phase (producer B, #699) stamps entries
-    // with THIS instance's version — the value folded into the shipped worker
-    // — never the discovery temp server's own version-plugin value (a
-    // different Date.now() stamp that would fail the serve-side gate).
-    api: {
-      getBuildVersion: () => currentVersion3
-    },
     configResolved(config) {
       isDev = config.command === "serve";
       resolvedCacheDir = config.cacheDir ? String(config.cacheDir).replace(/\\/g, "/") : void 0;
@@ -6190,7 +7037,7 @@ function createVersionPlugin() {
     },
     load(id) {
       if (id === "\0" + VIRTUAL_IDS.version) {
-        return getVirtualVersionContent(currentVersion3);
+        return isDev ? getVirtualVersionContent(currentVersion3) : getVirtualBuildVersionContent();
       }
       return null;
     },
@@ -6261,7 +7108,7 @@ import { isAbsolute as isAbsolute2, resolve as resolve4 } from "node:path";
 // src/vite/plugins/performance-tracks.ts
 init_debug();
 import { readFile as readFile2 } from "node:fs/promises";
-var debug5 = createRangoDebugger(NS.transform);
+var debug6 = createRangoDebugger(NS.transform);
 var RSDW_PATCH_RE = /((?:var|let|const)\s+\w+\s*=\s*root\._children\s*,\s*(\w+)\s*=\s*root\._debugInfo\s*[;,])/;
 function buildPatchReplacement(match, debugInfoVar) {
   return `${match}
@@ -6296,7 +7143,7 @@ function performanceTracksOptimizeDepsPlugin() {
   };
 }
 function performanceTracksPlugin() {
-  const counter = createCounter(debug5, "performance-tracks");
+  const counter = createCounter(debug6, "performance-tracks");
   return {
     name: "@rangojs/router:performance-tracks",
     buildEnd() {
@@ -6308,7 +7155,7 @@ function performanceTracksPlugin() {
       try {
         const patched = patchRsdwClientDebugInfoRecovery(code);
         if (!patched.debugInfoVar) return;
-        debug5?.("patched RSDW client (var: %s)", patched.debugInfoVar);
+        debug6?.("patched RSDW client (var: %s)", patched.debugInfoVar);
         return patched.code;
       } finally {
         counter?.record(id, performance.now() - start);
@@ -6445,90 +7292,6 @@ function getManualChunks(id) {
   return void 0;
 }
 
-// src/vite/utils/client-chunks.ts
-init_debug();
-init_client_ref_hashing();
-import { gzipSync } from "node:zlib";
-var debugChunks = createRangoDebugger(NS.chunks);
-function isSharedRuntime(meta) {
-  return [meta.id, meta.normalizedId].some(
-    (path6) => path6.includes("/node_modules/") || /\/@rangojs\/router\//.test(path6) || /\/packages\/(rangojs-router|rsc-router)\/(src|dist)\//.test(path6)
-  );
-}
-function sanitizeGroup(name) {
-  return name.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "app";
-}
-var ROUTE_ROOT_DIRS = /* @__PURE__ */ new Set([
-  "routes",
-  "route",
-  "pages",
-  "page",
-  "app",
-  "features",
-  "feature",
-  "views",
-  "view",
-  "handlers",
-  "urls",
-  "modules",
-  "screens",
-  "sections"
-]);
-var SOURCE_ROOT_DIRS = /* @__PURE__ */ new Set(["app"]);
-function directoryClientChunks(meta, ctx) {
-  if (isSharedRuntime(meta)) {
-    return void 0;
-  }
-  if (ctx?.fallbackRefs.size && ctx.fallbackRefs.has(hashRefKey(meta.normalizedId))) {
-    debugChunks?.("fallback %s -> app-fallback", meta.normalizedId);
-    return "app-fallback";
-  }
-  const segments = meta.normalizedId.split("/").filter(Boolean);
-  const dirCount = segments.length - 1;
-  const isMarkerAt = (i) => i < dirCount - 1 && ROUTE_ROOT_DIRS.has(segments[i].toLowerCase());
-  for (let i = 0; i < dirCount - 1; i++) {
-    if (!isMarkerAt(i)) continue;
-    const marker = SOURCE_ROOT_DIRS.has(segments[i].toLowerCase()) && isMarkerAt(i + 1) ? i + 1 : i;
-    const group = `app-${sanitizeGroup(segments[marker + 1])}`;
-    debugChunks?.("split %s -> %s", meta.normalizedId, group);
-    return group;
-  }
-  debugChunks?.(
-    "shared %s (no route-root marker; inherits default grouping)",
-    meta.normalizedId
-  );
-  return void 0;
-}
-function resolveClientChunks(option, ctx) {
-  if (!option) return void 0;
-  if (option === true) return (meta) => directoryClientChunks(meta, ctx);
-  return option;
-}
-var CLIENT_GROUP_PREFIX = "\0virtual:vite-rsc/client-references/group/";
-function clientChunksReport(log = debugChunks) {
-  if (!log) return void 0;
-  return {
-    name: "@rangojs/router:client-chunks-report",
-    apply: "build",
-    applyToEnvironment: (env) => env.name === "client",
-    generateBundle(_options, bundle) {
-      for (const chunk of Object.values(bundle)) {
-        if (chunk.type !== "chunk") continue;
-        const facade = chunk.facadeModuleId;
-        if (!facade?.startsWith(CLIENT_GROUP_PREFIX)) continue;
-        log(
-          "group %s: %d client reference(s), %d B (%d B gzip) -> %s",
-          facade.slice(CLIENT_GROUP_PREFIX.length).replaceAll("\0", "\\0"),
-          this.getModuleInfo(facade)?.importedIds.length ?? 0,
-          Buffer.byteLength(chunk.code),
-          gzipSync(chunk.code).length,
-          chunk.fileName
-        );
-      }
-    }
-  };
-}
-
 // src/vite/plugins/vercel-output.ts
 import { rm, mkdir, cp, writeFile } from "node:fs/promises";
 import { existsSync as existsSync5 } from "node:fs";
@@ -6805,13 +7568,13 @@ ${dim}   ${reset}${bold}\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550$
   console.log(banner);
 }
 
-// src/vite/plugins/version-injector.ts
+// src/vite/plugins/entry-bootstrap-injector.ts
 import { resolve as resolve6 } from "node:path";
 import * as Vite2 from "vite";
-function createVersionInjectorPlugin(rscEntryPath) {
+function createEntryBootstrapInjectorPlugin(rscEntryPath) {
   let resolvedEntryPath = "";
   return {
-    name: "@rangojs/router:version-injector",
+    name: "@rangojs/router:entry-bootstrap-injector",
     enforce: "pre",
     configResolved(config) {
       let entryPath = rscEntryPath;
@@ -6829,17 +7592,8 @@ function createVersionInjectorPlugin(rscEntryPath) {
       }
       const prepend = RSC_ENTRY_BOOTSTRAP_IMPORTS.map(
         (id2) => `import "${id2}";`
-      );
-      let newCode = code;
-      const needsVersion = code.includes("createRSCHandler") && !code.includes("@rangojs/router:version") && /createRSCHandler\s*\(\s*\{/.test(code);
-      if (needsVersion) {
-        prepend.push(`import { VERSION } from "@rangojs/router:version";`);
-        newCode = newCode.replace(
-          /createRSCHandler\s*\(\s*\{/,
-          "createRSCHandler({\n  version: VERSION,"
-        );
-      }
-      const lines = newCode.split("\n");
+      );
+      const lines = code.split("\n");
       let insertAt = 0;
       while (insertAt < lines.length) {
         const trimmed = lines[insertAt].trim();
@@ -6849,7 +7603,7 @@ function createVersionInjectorPlugin(rscEntryPath) {
           break;
         }
       }
-      newCode = [
+      const newCode = [
         ...lines.slice(0, insertAt),
         ...prepend,
         ...lines.slice(insertAt)
@@ -6927,8 +7681,8 @@ function createCjsToEsmPlugin() {
 
 // src/vite/router-discovery.ts
 import { createServer as createViteServer } from "vite";
-import { resolve as resolve12 } from "node:path";
-import { readFileSync as readFileSync9 } from "node:fs";
+import { dirname as dirname7, join as join10, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "node:fs";
 import { createRequire as createRequire3, register } from "node:module";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 
@@ -6944,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).';
@@ -7007,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
   };
@@ -7111,7 +7883,7 @@ function createCloudflareProtocolStubPlugin() {
         return null;
       }
       const hits = [];
-      walk(ast, (node) => {
+      walk2(ast, (node) => {
         if (!IMPORT_NODE_TYPES.has(node.type)) return;
         const source = node.source;
         if (!source || source.type !== "Literal") return;
@@ -7149,10 +7921,10 @@ function createCloudflareProtocolStubPlugin() {
     }
   };
 }
-function walk(node, visit) {
+function walk2(node, visit) {
   if (!node || typeof node !== "object") return;
   if (Array.isArray(node)) {
-    for (const child of node) walk(child, visit);
+    for (const child of node) walk2(child, visit);
     return;
   }
   const n = node;
@@ -7162,7 +7934,7 @@ function walk(node, visit) {
     if (key === "loc" || key === "start" || key === "end" || key === "range") {
       continue;
     }
-    walk(n[key], visit);
+    walk2(n[key], visit);
   }
 }
 
@@ -7228,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);
@@ -7239,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*\\(`
@@ -7254,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;
@@ -7263,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*\\(`
@@ -7294,51 +8072,11 @@ function evictHandlerCode(code, exports, fnName, brand) {
   };
 }
 
-// src/vite/discovery/state.ts
-var VIRTUAL_ROUTES_MANIFEST_ID = "virtual:rsc-router/routes-manifest";
-function createDiscoveryState(entryPath, opts) {
-  return {
-    resolvedEntryPath: entryPath,
-    projectRoot: "",
-    isBuildMode: false,
-    userResolveAlias: void 0,
-    userRunnerConfig: void 0,
-    userResolvePlugins: [],
-    scanFilter: void 0,
-    cachedRouterFiles: void 0,
-    opts,
-    mergedRouteManifest: null,
-    perRouterManifests: [],
-    perRouterTrieMap: /* @__PURE__ */ new Map(),
-    perRouterPrecomputedMap: /* @__PURE__ */ new Map(),
-    perRouterManifestDataMap: /* @__PURE__ */ new Map(),
-    clientUrlSourceByReferenceId: /* @__PURE__ */ new Map(),
-    clientUrlProjectionMap: /* @__PURE__ */ new Map(),
-    prerenderManifestEntries: null,
-    staticManifestEntries: null,
-    shellCandidates: null,
-    prerenderPayloadValues: null,
-    shellPhaseTempServer: null,
-    handlerChunkInfoMap: /* @__PURE__ */ new Map(),
-    staticHandlerChunkInfoMap: /* @__PURE__ */ new Map(),
-    rscEntryFileName: null,
-    resolvedPrerenderModules: void 0,
-    resolvedStaticModules: void 0,
-    discoveryDone: null,
-    devDiscoveryEpoch: opts?.preset === "cloudflare" ? Date.now() : void 0,
-    devServerOrigin: null,
-    devServer: null,
-    selfWrittenGenFiles: /* @__PURE__ */ new Map(),
-    SELF_WRITE_WINDOW_MS: 5e3,
-    lastDiscoveryError: null
-  };
-}
-
 // src/vite/discovery/self-gen-tracking.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { readFileSync as readFileSync4 } from "node:fs";
 function markSelfGenWrite(state, filePath, content) {
-  const hash = createHash3("sha256").update(content).digest("hex");
+  const hash = createHash4("sha256").update(content).digest("hex");
   state.selfWrittenGenFiles.set(filePath, { at: Date.now(), hash });
 }
 function consumeSelfGenWrite(state, filePath) {
@@ -7356,7 +8094,7 @@ function checkSelfGenWrite(state, filePath, consume) {
   }
   try {
     const current = readFileSync4(filePath, "utf-8");
-    const currentHash = createHash3("sha256").update(current).digest("hex");
+    const currentHash = createHash4("sha256").update(current).digest("hex");
     if (currentHash === info.hash) {
       if (consume) state.selfWrittenGenFiles.delete(filePath);
       return true;
@@ -7425,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] || "";
@@ -7440,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 } : {}
     });
   }
@@ -7632,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
   );
 }
 
@@ -7786,6 +8526,11 @@ function mergeFullManifests(manifests) {
         manifest.passthroughRoutes,
         overwrittenRoutes
       ),
+      onDemandRoutes: mergeRouteList(
+        merged.onDemandRoutes,
+        manifest.onDemandRoutes,
+        overwrittenRoutes
+      ),
       responseTypeRoutes: mergeRouteRecord(
         merged.responseTypeRoutes,
         manifest.responseTypeRoutes,
@@ -7850,7 +8595,7 @@ function contextSet(variables, keyOrVar, value, options) {
 }
 
 // src/vite/utils/prerender-utils.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import {
   copyFileSync,
   existsSync as existsSync6,
@@ -8014,15 +8759,16 @@ function resolvePrerenderError(registry, error, onError, label, elapsed, phase,
   notifyOnError(registry, error, phase, routeKey, pathname);
   throw error;
 }
+var RANGO_BUILD_DIR = "node_modules/.rangojs-router-build";
 function getStagedAssetDir(projectRoot) {
-  return resolve7(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
+  return resolve7(projectRoot, RANGO_BUILD_DIR, "rsc-assets");
 }
 function resetStagedBuildAssets(projectRoot) {
   rmSync(getStagedAssetDir(projectRoot), { recursive: true, force: true });
 }
 function writeBuildAssetModule(dir, prefix, exportValue) {
   mkdirSync(dir, { recursive: true });
-  const contentHash = createHash4("sha256").update(exportValue).digest("hex").slice(0, 8);
+  const contentHash = createHash5("sha256").update(exportValue).digest("hex").slice(0, 8);
   const fileName = `${prefix}-${contentHash}.js`;
   const filePath = resolve7(dir, fileName);
   if (!existsSync6(filePath)) {
@@ -8055,6 +8801,14 @@ function copyStagedBuildAssets(projectRoot, fileNames) {
 // src/vite/discovery/prerender-collection.ts
 init_debug();
 var debug9 = createRangoDebugger(NS.prerender);
+function recordBuildData(state, kind, key, value, owner) {
+  state.buildData.push({
+    kind,
+    key,
+    digest: sha256(value),
+    ...owner
+  });
+}
 async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
   if (!state.opts?.enableBuildPrerender || !state.isBuildMode) return;
   const overallStart = debug9 ? performance.now() : 0;
@@ -8231,7 +8985,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
       group.concurrency,
       async (entry) => {
         const startUrl = performance.now();
-        for (const [, routerInstance] of registry) {
+        for (const [routerId2, routerInstance] of registry) {
           if (!routerInstance.matchForPrerender) continue;
           try {
             const result = await routerInstance.matchForPrerender(
@@ -8261,6 +9015,9 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
               "__pr",
               mainValue
             );
+            recordBuildData(state, "prerender", mainKey, mainValue, {
+              routerId: routerId2
+            });
             if (result.ppr !== void 0 && result.ppr !== false) {
               (state.shellCandidates ??= []).push({
                 urlPath: entry.urlPath,
@@ -8286,6 +9043,15 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
                 "__pr",
                 interceptValue
               );
+              recordBuildData(
+                state,
+                "prerender",
+                interceptKey,
+                interceptValue,
+                {
+                  routerId: routerId2
+                }
+              );
             }
             const elapsed = (performance.now() - startUrl).toFixed(0);
             console.log(
@@ -8388,6 +9154,9 @@ async function renderStaticHandlers(state, rscEnv, registry) {
               "__st",
               exportValue
             );
+            recordBuildData(state, "static", def.$$id, exportValue, {
+              moduleId
+            });
             const elapsed = (performance.now() - startHandler).toFixed(0);
             console.log(`[rango]   OK   ${name.padEnd(40)} (${elapsed}ms)`);
             staticDone++;
@@ -8534,8 +9303,8 @@ init_client_ref_hashing();
 
 // src/vite/discovery/client-urls-projection.ts
 import { existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
-import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve8 } from "node:path";
-import { normalizePath as normalizePath5, parseAst as parseAst6 } from "vite";
+import { isAbsolute as isAbsolute3, relative as relative5, resolve as resolve8 } from "node:path";
+import { normalizePath as normalizePath5, parseAst as parseAst7 } from "vite";
 
 // src/client-urls/server-projection.ts
 import * as React5 from "react";
@@ -8548,9 +9317,10 @@ function isUnderTestRunner() {
 // src/client.tsx
 import {
   Component as Component3,
-  createElement as createElement3,
-  useContext as useContext16,
-  useMemo as useMemo8,
+  createElement as createElement4,
+  isValidElement as isValidElement2,
+  useContext as useContext17,
+  useMemo as useMemo9,
   Suspense as Suspense2
 } from "react";
 
@@ -8637,6 +9407,8 @@ function createHandle(collect, __injectedId) {
 // src/browser/react/context.ts
 import { createContext } from "react";
 var NavigationStoreContext = createContext(null);
+var LocationStateContext = createContext(void 0);
+var HydrationBarrierContext = createContext(0);
 
 // src/handles/meta.ts
 function isUnsetDescriptor(descriptor) {
@@ -8842,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";
@@ -8882,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 {
@@ -8890,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({
@@ -8911,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";
@@ -9324,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
@@ -9365,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";
 
@@ -9402,10 +9799,9 @@ import {
   forwardRef,
   useCallback as useCallback5,
   useContext as useContext15,
-  useEffect as useEffect14,
-  useMemo as useMemo7,
-  useRef as useRef12,
-  useSyncExternalStore
+  useEffect as useEffect15,
+  useMemo as useMemo8,
+  useRef as useRef13
 } from "react";
 
 // src/browser/react/use-link-status.ts
@@ -9413,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
@@ -9476,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") {
@@ -9647,8 +10037,6 @@ function isPrefetchScopeDisabled(element) {
 // src/browser/react/Link.tsx
 init_loader();
 import { jsx as jsx8 } from "react/jsx-runtime";
-var IGNORE_STRATEGY_CHANGES = (_listener) => () => {
-};
 function isExternalUrl(href2, origin) {
   if (href2.startsWith("//")) return true;
   if (href2.startsWith("http://") || href2.startsWith("https://")) {
@@ -9679,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 = useSyncExternalStore(
-    configuredStrategy === "adaptive" ? subscribeToAdaptiveStrategyChange : IGNORE_STRATEGY_CHANGES,
-    () => 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;
@@ -9707,7 +10088,7 @@ var Link = forwardRef(function Link2({
     },
     [ref]
   );
-  const stateRef = useRef12(state);
+  const stateRef = useRef13(state);
   stateRef.current = state;
   const handleClick = useCallback5(
     (e) => {
@@ -9752,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,
@@ -9762,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 () => {
@@ -9813,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",
     {
@@ -9878,7 +10265,7 @@ var Breadcrumbs = createHandle(
 );
 
 // src/browser/react/location-state.ts
-import { useState as useState14, useEffect as useEffect15, useRef as useRef13 } from "react";
+import { useContext as useContext16, useEffect as useEffect16 } from "react";
 
 // src/href-client.ts
 function href(path6, mount) {
@@ -9947,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 });
@@ -10010,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();
@@ -10019,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,
-  useState as useState15
+  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";
@@ -10211,7 +10599,7 @@ var debug10 = createRangoDebugger(NS.discovery);
 function hasDefaultExport(code) {
   let program;
   try {
-    program = parseAst6(code, { lang: "tsx" });
+    program = parseAst7(code, { lang: "tsx" });
   } catch {
     return false;
   }
@@ -10239,7 +10627,7 @@ function recordClientUrlsModule(state, code, id) {
   }
   const source = normalizeSource(state, id);
   const projectRoot = normalizePath5(resolve8(state.projectRoot));
-  const relativeId = normalizePath5(relative4(projectRoot, source));
+  const relativeId = normalizePath5(relative5(projectRoot, source));
   const outsideProject = relativeId === ".." || relativeId.startsWith("../") || isAbsolute3(relativeId);
   const devReferenceKey = outsideProject ? `/@fs${source}` : `/${relativeId}`;
   const sourceByReferenceId = state.clientUrlSourceByReferenceId ??= /* @__PURE__ */ new Map();
@@ -10561,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"],
@@ -10574,7 +10974,7 @@ async function discoverRouters(state, rscEnv, ssrEnv) {
   for (const [map2, fn] of perRouterSetters) {
     const setter = serverMod[fn];
     if (typeof setter !== "function") continue;
-    for (const [routerId, value] of map2) setter(routerId, value);
+    for (const [routerId2, value] of map2) setter(routerId2, value);
   }
   await expandPrerenderRoutes(state, rscEnv, registry, allManifests);
   await renderStaticHandlers(state, rscEnv, registry);
@@ -10582,20 +10982,337 @@ async function discoverRouters(state, rscEnv, ssrEnv) {
 }
 
 // src/vite/discovery/shell-prerender-phase.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join5, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
+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
+import { randomUUID } from "node:crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname4, join as join6, resolve as resolve9 } from "node:path";
+init_debug();
+
+// src/vite/discovery/installed-packages.ts
+import { createHash as createHash6 } from "node:crypto";
+import {
+  existsSync as existsSync8,
+  readdirSync as readdirSync3,
+  readFileSync as readFileSync6,
+  realpathSync,
+  statSync as statSync2
+} from "node:fs";
+import { dirname as dirname3, join as join5, sep as sep2 } from "node:path";
+function linkTarget(path6) {
+  try {
+    return statSync2(path6);
+  } catch {
+    return void 0;
+  }
+}
+function digestDirectory(dir) {
+  const hash = createHash6("sha256");
+  const entered = /* @__PURE__ */ new Set();
+  const visit = (current, prefix) => {
+    const real = realpathSync(current);
+    if (entered.has(real)) return;
+    entered.add(real);
+    const entries = readdirSync3(current, { withFileTypes: true }).sort(
+      (a, b) => compareStrings(a.name, b.name)
+    );
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      const path6 = join5(current, entry.name);
+      const name = `${prefix}${entry.name}`;
+      const kind = entry.isSymbolicLink() ? linkTarget(path6) : entry;
+      if (kind?.isDirectory()) {
+        visit(path6, `${name}/`);
+      } else if (kind?.isFile()) {
+        const bytes = readFileSync6(path6);
+        hash.update(`${name}\0${bytes.byteLength}\0`);
+        hash.update(bytes);
+      }
+    }
+  };
+  visit(dir, "");
+  return hash.digest("hex");
+}
+function findPackageDir(name, from) {
+  for (let dir = from; ; ) {
+    const candidate = join5(dir, "node_modules", name);
+    if (existsSync8(join5(candidate, "package.json"))) {
+      return realpathSync(candidate);
+    }
+    const parent = dirname3(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function createInstalledPackageDescriber(projectRoot) {
+  const packages = /* @__PURE__ */ new Map();
+  const read = (dir) => {
+    if (packages.has(dir)) return packages.get(dir);
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync6(join5(dir, "package.json"), "utf-8"));
+    } catch {
+      packages.set(dir, void 0);
+      return void 0;
+    }
+    const linked = !dir.split(sep2).includes("node_modules");
+    const found = {
+      label: `${manifest.name}@${manifest.version}` + (linked ? ` files:${digestDirectory(dir)}` : ""),
+      dependencies: Object.keys({
+        ...manifest.dependencies,
+        ...manifest.optionalDependencies,
+        ...manifest.peerDependencies
+      })
+    };
+    packages.set(dir, found);
+    return found;
+  };
+  const located = /* @__PURE__ */ new Map();
+  const locate = (name, from) => {
+    const key = `${from}\0${name}`;
+    if (!located.has(key)) located.set(key, findPackageDir(name, from));
+    return located.get(key);
+  };
+  const described = /* @__PURE__ */ new Map();
+  return (name) => {
+    if (described.has(name)) return described.get(name);
+    const labels = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    const pending = [[name, projectRoot]];
+    while (pending.length > 0) {
+      const [dependency, from] = pending.pop();
+      const dir = locate(dependency, from);
+      if (dir === void 0 || seen.has(dir)) continue;
+      seen.add(dir);
+      const installed = read(dir);
+      if (!installed) continue;
+      labels.add(installed.label);
+      for (const next of installed.dependencies) pending.push([next, dir]);
+    }
+    const text = labels.size > 0 ? [...labels].sort().join("\n") : void 0;
+    described.set(name, text);
+    return text;
+  };
+}
+
+// src/vite/discovery/router-versions-phase.ts
+var debug12 = createRangoDebugger(NS.build);
+var ASSETS_MANIFEST_FILE = "__vite_rsc_assets_manifest.js";
+var EMPTY_SERVER_RESOURCES = /"serverResources":\s*\{\s*\}/;
+function environmentOutDir(builder, projectRoot, environment) {
+  return resolve9(
+    projectRoot,
+    builder?.environments?.[environment]?.config?.build?.outDir ?? join6("dist", environment)
+  );
+}
+var VERSIONS_REPORT_FILE = `${RANGO_BUILD_DIR}/cache-versions.json`;
+function readIfPresent(path6) {
+  try {
+    return readFileSync7(path6);
+  } catch (err) {
+    if (err?.code === "ENOENT") return void 0;
+    throw err;
+  }
+}
+function readServerResources(manifest) {
+  if (EMPTY_SERVER_RESOURCES.test(manifest)) return /* @__PURE__ */ new Map();
+  const entries = literalProperties(
+    defaultExportProperties(manifest)?.find(
+      (property) => property.key === "serverResources"
+    )?.value
+  );
+  if (!entries) {
+    throw new Error(
+      `${ASSETS_MANIFEST_FILE} has no serverResources object literal: the installed @vitejs/plugin-rsc writes a manifest @rangojs/router cannot read. Report it with the plugin-rsc version.`
+    );
+  }
+  return new Map(
+    entries.map((entry) => [
+      entry.key,
+      manifest.slice(entry.value.start, entry.value.end)
+    ])
+  );
+}
+function clientUrlRecords(s) {
+  const projectionOf = /* @__PURE__ */ new Map();
+  for (const [referenceId2, projection] of s.clientUrlProjectionMap ?? []) {
+    projectionOf.set(
+      s.clientUrlSourceByReferenceId?.get(referenceId2) ?? referenceId2,
+      JSON.stringify(projection)
+    );
+  }
+  return [...projectionOf].map(([source, projection]) => ({
+    kind: "client-urls",
+    key: portableModuleId(source, s.projectRoot),
+    digest: sha256(projection),
+    moduleId: source
+  }));
+}
+function writeVersionsReport(projectRoot, computed, sourceOf) {
+  const routers = {};
+  for (const detail of computed.details) {
+    routers[detail.routerId] = {
+      source: sourceOf.get(detail.routerId) ?? "",
+      data: detail.data,
+      document: detail.document,
+      dataInputs: Object.fromEntries(detail.dataInputs),
+      documentInputs: Object.fromEntries(detail.documentInputs)
+    };
+  }
+  const report = {
+    routers,
+    ssrAndClient: {
+      base: computed.ssrAndClient.base,
+      ssr: Object.fromEntries(computed.ssrAndClient.ssr),
+      externals: Object.fromEntries(computed.ssrAndClient.externals),
+      client: computed.ssrAndClient.client
+    },
+    unownedFiles: computed.unownedFiles
+  };
+  try {
+    const path6 = resolve9(projectRoot, VERSIONS_REPORT_FILE);
+    mkdirSync2(dirname4(path6), { recursive: true });
+    writeFileSync3(path6, JSON.stringify(report, null, 2) + "\n");
+  } catch (err) {
+    debug12?.("could not write %s: %s", VERSIONS_REPORT_FILE, err?.message);
+  }
+}
+function runRouterVersionsPhase(s, builder) {
+  if (!s.isBuildMode) return void 0;
+  const { serverBuildGraph: server, clientBuildGraph: client } = s;
+  const ssr = s.ssrBundle;
+  const rscVersionFiles = s.versionModuleFiles.get("rsc") ?? [];
+  if (!server || !client || !ssr || rscVersionFiles.length === 0) {
+    const missing = [
+      !server && "the RSC bundle",
+      !client && "the client bundle",
+      !ssr && "the SSR bundle",
+      rscVersionFiles.length === 0 && "the RSC chunk that holds the version module"
+    ].filter(Boolean);
+    throw new Error(
+      `[rango] The build did not record ${missing.join(", ")}, so the cache versions cannot be computed. This is a bug in @rangojs/router; please report it.`
+    );
+  }
+  const start = performance.now();
+  const rscOutDir = environmentOutDir(builder, s.projectRoot, "rsc");
+  const ssrOutDir = environmentOutDir(builder, s.projectRoot, "ssr");
+  let computed;
+  try {
+    const assetsManifest = readIfPresent(join6(rscOutDir, ASSETS_MANIFEST_FILE));
+    if (assetsManifest === void 0) {
+      throw new Error(
+        `${ASSETS_MANIFEST_FILE} is not in the RSC output directory, so the stylesheets server components link cannot be read`
+      );
+    }
+    computed = computeRouterVersions({
+      projectRoot: s.projectRoot,
+      server,
+      client,
+      // plugin-rsc writes its manifest next to the SSR bundle, not into it.
+      ssr: {
+        chunks: ssr.chunks,
+        assets: [
+          ...ssr.assets.filter(
+            (asset) => asset.fileName !== ASSETS_MANIFEST_FILE
+          ),
+          { fileName: ASSETS_MANIFEST_FILE, name: ASSETS_MANIFEST_FILE }
+        ]
+      },
+      routers: s.perRouterManifests.map((entry) => ({
+        id: entry.id,
+        moduleId: entry.sourceFile
+      })),
+      buildData: [...s.buildData, ...clientUrlRecords(s)],
+      readServerFile: (fileName) => readIfPresent(join6(rscOutDir, fileName)),
+      readSsrFile: (fileName) => readIfPresent(join6(ssrOutDir, fileName)),
+      base: builder?.config?.base ?? "/",
+      serverResources: readServerResources(assetsManifest.toString("utf-8")),
+      externals: {
+        describePackage: createInstalledPackageDescriber(s.projectRoot),
+        readFile: readIfPresent,
+        buildId: randomUUID()
+      }
+    });
+  } catch (err) {
+    throw new Error(
+      `[rango] Could not compute the cache versions: ${err?.message ?? err}`,
+      { cause: err }
+    );
+  }
+  const { table, details } = computed;
+  for (const [environment, fileNames] of s.versionModuleFiles) {
+    const outDir = environmentOutDir(builder, s.projectRoot, environment);
+    let filled = 0;
+    for (const fileName of fileNames) {
+      const path6 = join6(outDir, fileName);
+      const source = readIfPresent(path6);
+      const next = source === void 0 ? void 0 : fillRouterVersions(source.toString("utf-8"), table);
+      if (next === void 0) continue;
+      writeFileSync3(path6, next);
+      filled++;
+    }
+    if (environment === "rsc" && filled === 0) {
+      throw new Error(
+        `[rango] Could not write the cache versions into the server build: no placeholder in ${fileNames.join(", ")} under ${outDir}. The build would fail to start. This is a bug in @rangojs/router; please report it.`
+      );
+    }
+  }
+  const elapsed = (performance.now() - start).toFixed(1);
+  const sourceOf = new Map(
+    s.perRouterManifests.map((entry) => [
+      entry.id,
+      entry.sourceFile ? portableModuleId(entry.sourceFile, s.projectRoot) : ""
+    ])
+  );
+  const detailOf = new Map(details.map((detail) => [detail.routerId, detail]));
+  const wholeBuild = detailOf.get(DEFAULT_ROUTER_VERSIONS_KEY);
+  let keyed = 0;
+  if (s.perRouterManifests.length > 0) {
+    console.log(
+      `[rango] Cache versions for ${s.perRouterManifests.length} router(s), data / document (${elapsed}ms):`
+    );
+    for (const { id } of s.perRouterManifests) {
+      const own = detailOf.get(id);
+      const detail = own ?? wholeBuild;
+      if (detail.usesEncryptionKey) keyed++;
+      console.log(
+        `[rango]   ${detail.data} / ${detail.document}  ${sourceOf.get(id) || id}${own ? "" : " (whole build)"}`
+      );
+    }
+  }
+  debug12?.(
+    "router versions: %d server file(s), %sms, table=%o",
+    server.chunks.length + server.assets.length,
+    elapsed,
+    table
+  );
+  writeVersionsReport(s.projectRoot, computed, sourceOf);
+  if (computed.undetermined.length > 0) {
+    console.log(
+      `[rango] ${computed.undetermined.length} import(s) the server build leaves external could not be read at build time (${computed.undetermined.join(", ")}): a package that is not installed where the build can find it, a path that does not resolve, or a URL. What they resolve to at run time is unknown, so the routers importing them get a new cache version on every build.`
+    );
+  }
+  if (keyed > 0 && !isEncryptionKeyStable()) {
+    console.log(
+      `[rango] No stable encryption key: ${keyed} router(s) encrypt server-action arguments with a key generated for this build, so their cache version changes on every build and each deploy clears their cache. To keep it, set rango({ encryptionKey: process.env.RANGO_ENCRYPTION_KEY }) with a base64 32-byte key (openssl rand -base64 32).`
+    );
+  }
+  return table;
 }
 
 // src/vite/discovery/shell-prerender-phase.ts
 init_debug();
-var debug12 = createRangoDebugger(NS.prerender);
-async function runShellPrerenderPhase(s, builder) {
+var debug13 = createRangoDebugger(NS.prerender);
+async function runShellPrerenderPhase(s, builder, versionsTable) {
   const tempServer = s.shellPhaseTempServer;
-  if (!s.isBuildMode || !s.shellCandidates?.length || !tempServer) return;
+  if (!versionsTable || !s.shellCandidates?.length || !tempServer) return;
   const candidates = s.shellCandidates;
   const startTotal = performance.now();
   console.log(`[rango] Shell-prerendering ${candidates.length} URL(s)...`);
@@ -10611,16 +11328,6 @@ async function runShellPrerenderPhase(s, builder) {
       );
       return;
     }
-    const versionPlugin = (builder?.config?.plugins ?? []).find(
-      (p) => p?.name === "@rangojs/router:version"
-    );
-    const buildVersion = versionPlugin?.api?.getBuildVersion?.();
-    if (!buildVersion) {
-      console.warn(
-        "[rango] shell prerender: main build version unavailable; skipping \u2014 routes keep runtime shell capture."
-      );
-      return;
-    }
     const payloads = s.prerenderPayloadValues ?? /* @__PURE__ */ new Map();
     const fetchedKeys = /* @__PURE__ */ new Set();
     globalThis.__loadPrerenderManifestModule = async () => ({
@@ -10638,9 +11345,9 @@ async function runShellPrerenderPhase(s, builder) {
     const htmlStream = await ssrRunner.import(
       "@rangojs/router/internal/deps/html-stream-server"
     );
-    const clientOutDir = builder?.environments?.client?.config?.build?.outDir ?? resolve9(s.projectRoot, "dist/client");
-    const clientAssetsDir = join5(clientOutDir, "assets");
-    const entryFile = existsSync8(clientAssetsDir) ? readdirSync3(clientAssetsDir).find((f) => /^index-.*\.js$/.test(f)) : void 0;
+    const clientOutDir = environmentOutDir(builder, s.projectRoot, "client");
+    const clientAssetsDir = join7(clientOutDir, "assets");
+    const entryFile = existsSync9(clientAssetsDir) ? readdirSync4(clientAssetsDir).find((f) => /^index-.*\.js$/.test(f)) : void 0;
     if (!entryFile) {
       console.warn(
         `[rango] shell prerender: built client entry not found under ${clientAssetsDir}; skipping \u2014 routes keep runtime shell capture.`
@@ -10650,7 +11357,7 @@ async function runShellPrerenderPhase(s, builder) {
     const base = builder?.config?.base ?? "/";
     const normalizedBase = base.endsWith("/") ? base : `${base}/`;
     const bootstrapContent = `import("${normalizedBase}assets/${entryFile}")`;
-    debug12?.("shell prerender bootstrap: %s", bootstrapContent);
+    debug13?.("shell prerender bootstrap: %s", bootstrapContent);
     const minimalPlugin = (tempServer.config?.plugins ?? []).find(
       (p) => p?.name === "rsc:minimal"
     );
@@ -10721,8 +11428,13 @@ async function runShellPrerenderPhase(s, builder) {
       const mainKey = `${cand.routeName}/${cand.paramHash}`;
       let handled = false;
       const mismatches = [];
-      for (const [, routerInstance] of registry) {
+      for (const [routerId2, routerInstance] of registry) {
         if (typeof routerInstance.match !== "function") continue;
+        const versions = resolveVersionsFrom(
+          versionsTable,
+          routerId2,
+          routerInstance.version
+        );
         try {
           const res = await captureMod.captureShellForBuild({
             router: routerInstance,
@@ -10735,9 +11447,9 @@ async function runShellPrerenderPhase(s, builder) {
             maxSnapshotBytes: policy.maxSnapshotBytes,
             captureTimeout: policy.captureTimeout,
             buildEnv: s.resolvedBuildEnv,
-            buildVersion,
+            versions,
             captureShellHTML,
-            debug: !!debug12
+            debug: !!debug13
           });
           if (res.outcome === "route-mismatch") {
             mismatches.push(res.matchedRouteName ?? "(no match)");
@@ -10765,7 +11477,7 @@ async function runShellPrerenderPhase(s, builder) {
             tags: res.tags
           };
           staged.push({
-            key: buildShellManifestKey(cand.urlPath),
+            key: buildShellManifestKey(routerId2, cand.urlPath),
             value: JSON.stringify(value)
           });
           console.log(
@@ -10790,8 +11502,11 @@ async function runShellPrerenderPhase(s, builder) {
       }
     }
     if (staged.length > 0) {
-      const rscOutDir = builder?.environments?.rsc?.config?.build?.outDir ?? resolve9(s.projectRoot, "dist/rsc");
-      writeShellManifest(s, rscOutDir, staged);
+      writeShellManifest(
+        s,
+        environmentOutDir(builder, s.projectRoot, "rsc"),
+        staged
+      );
     }
     const totalElapsed = (performance.now() - startTotal).toFixed(0);
     const parts = [`${staged.length} done`];
@@ -10810,14 +11525,14 @@ async function runShellPrerenderPhase(s, builder) {
   }
 }
 function writeShellManifest(s, rscOutDir, staged) {
-  const rscEntryPath = resolve9(rscOutDir, s.rscEntryFileName ?? "index.js");
-  if (!existsSync8(rscEntryPath)) {
+  const rscEntryPath = resolve10(rscOutDir, s.rscEntryFileName ?? "index.js");
+  if (!existsSync9(rscEntryPath)) {
     console.warn(
       `[rango] shell prerender: RSC entry not found at ${rscEntryPath}; entries not persisted \u2014 routes keep runtime capture.`
     );
     return;
   }
-  const assetsDir = resolve9(rscOutDir, "assets");
+  const assetsDir = resolve10(rscOutDir, "assets");
   let totalBytes = 0;
   const manifestMap = {};
   const countedFiles = /* @__PURE__ */ new Set();
@@ -10835,13 +11550,13 @@ function writeShellManifest(s, rscOutDir, staged) {
     `export default m;`,
     ""
   ].join("\n");
-  writeFileSync3(resolve9(rscOutDir, "__shell-manifest.js"), manifestCode);
+  writeFileSync4(resolve10(rscOutDir, "__shell-manifest.js"), manifestCode);
   totalBytes += Buffer.byteLength(manifestCode);
-  const rscCode = readFileSync6(rscEntryPath, "utf-8");
+  const rscCode = readFileSync8(rscEntryPath, "utf-8");
   if (!rscCode.includes("__shell-manifest.js")) {
     const injection = `globalThis.__loadShellManifestModule = () => import("./__shell-manifest.js");
 `;
-    writeFileSync3(rscEntryPath, injection + rscCode);
+    writeFileSync4(rscEntryPath, injection + rscCode);
   }
   const totalKB = (totalBytes / 1024).toFixed(1);
   console.log(
@@ -10887,8 +11602,8 @@ function createDevPrerenderCache(maxEntriesPerRouter = MAX_ENTRIES_PER_ROUTER) {
 }
 
 // src/vite/discovery/route-types-writer.ts
-import { dirname as dirname3, join as join6, resolve as resolve10 } from "node:path";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync9, unlinkSync as unlinkSync2 } from "node:fs";
+import { dirname as dirname5, join as join8, resolve as resolve11 } from "node:path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, existsSync as existsSync10, unlinkSync as unlinkSync2 } from "node:fs";
 function filterUserNamedRoutes(manifest) {
   const filtered = {};
   for (const [name, pattern] of Object.entries(manifest)) {
@@ -10899,10 +11614,10 @@ function filterUserNamedRoutes(manifest) {
   return filtered;
 }
 function writeGenFileIfChanged(state, outPath, source, opts) {
-  const existing = existsSync9(outPath) ? readFileSync7(outPath, "utf-8") : null;
+  const existing = existsSync10(outPath) ? readFileSync9(outPath, "utf-8") : null;
   if (existing === source) return;
   markSelfGenWrite(state, outPath, source);
-  writeFileSync4(outPath, source);
+  writeFileSync5(outPath, source);
   if (opts?.log) console.log(`[rango] Generated route types -> ${outPath}`);
 }
 function writeCombinedRouteTypesWithTracking(state, opts) {
@@ -10916,11 +11631,11 @@ function writeCombinedRouteTypesWithTracking(state, opts) {
 function writeRouteTypesFiles(state) {
   if (state.perRouterManifests.length === 0) return;
   try {
-    const entryDir = dirname3(
-      resolve10(state.projectRoot, state.resolvedEntryPath)
+    const entryDir = dirname5(
+      resolve11(state.projectRoot, state.resolvedEntryPath)
     );
-    const oldCombinedPath = join6(entryDir, "named-routes.gen.ts");
-    if (existsSync9(oldCombinedPath)) {
+    const oldCombinedPath = join8(entryDir, "named-routes.gen.ts");
+    if (existsSync10(oldCombinedPath)) {
       unlinkSync2(oldCombinedPath);
       console.log(
         `[rango] Removed stale combined route types: ${oldCombinedPath}`
@@ -11001,8 +11716,8 @@ function supplementGenFilesWithRuntimeRoutes(state) {
 }
 
 // src/vite/discovery/virtual-module-codegen.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname4, basename, join as join7 } from "node:path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname6, basename, join as join9 } from "node:path";
 var MANIFEST_EXTERNALIZE_THRESHOLD = 512 * 1024;
 var TRANSITION_WHEN_VALIDATION = `enableTransitionWhenValidation();`;
 function devDiscoveryBootstrap(state) {
@@ -11021,12 +11736,12 @@ function generateRoutesManifestModule(state) {
     let varIdx = 0;
     for (const entry of state.perRouterManifests) {
       if (entry.sourceFile) {
-        const routerDir = dirname4(entry.sourceFile);
+        const routerDir = dirname6(entry.sourceFile);
         const routerBasename = basename(entry.sourceFile).replace(
           /\.(tsx?|jsx?)$/,
           ""
         );
-        const genPath = join7(
+        const genPath = join9(
           routerDir,
           `${routerBasename}.named-routes.gen.js`
         ).replaceAll("\\", "/");
@@ -11060,7 +11775,10 @@ function generateRoutesManifestModule(state) {
     ];
     if (hasClientUrlModules) {
       lines2.push(`clearClientUrlProjections();`);
-      for (const [referenceId2, projection] of state.clientUrlProjectionMap ?? []) {
+      const projections = [...state.clientUrlProjectionMap ?? []].sort(
+        ([a], [b]) => compareStrings(a, b)
+      );
+      for (const [referenceId2, projection] of projections) {
         lines2.push(
           `setClientUrlProjection(${JSON.stringify(referenceId2)}, ${jsonParseExpression(projection)});`
         );
@@ -11092,9 +11810,9 @@ function generateRoutesManifestModule(state) {
       );
     }
     if (state.isBuildMode) {
-      for (const routerId of state.perRouterManifestDataMap.keys()) {
+      for (const routerId2 of state.perRouterManifestDataMap.keys()) {
         lines2.push(
-          `registerRouterManifestLoader(${JSON.stringify(routerId)}, () => import(${JSON.stringify(VIRTUAL_ROUTES_MANIFEST_ID + "/" + routerId)}));`
+          `registerRouterManifestLoader(${JSON.stringify(routerId2)}, () => import(${JSON.stringify(VIRTUAL_ROUTES_MANIFEST_ID + "/" + routerId2)}));`
         );
       }
     }
@@ -11131,17 +11849,17 @@ function shortHash(input) {
   }
   return (h >>> 0).toString(36);
 }
-function generatePerRouterModule(state, routerId) {
+function generatePerRouterModule(state, routerId2) {
   const sourceFile = state.perRouterManifests.find(
-    (e) => e.id === routerId
+    (e) => e.id === routerId2
   )?.sourceFile;
-  const trie = state.perRouterTrieMap.get(routerId);
-  const entries = state.perRouterPrecomputedMap.get(routerId);
+  const trie = state.perRouterTrieMap.get(routerId2);
+  const entries = state.perRouterPrecomputedMap.get(routerId2);
   const lines = [];
   if (sourceFile) {
-    const routerDir = dirname4(sourceFile);
+    const routerDir = dirname6(sourceFile);
     const routerBasename = basename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
-    const genPath = join7(
+    const genPath = join9(
       routerDir,
       `${routerBasename}.named-routes.gen.js`
     ).replaceAll("\\", "/");
@@ -11155,11 +11873,11 @@ function generatePerRouterModule(state, routerId) {
   const payloadJson = hasTrie || hasEntries ? JSON.stringify(payload) : "";
   const useTextModule = state.isBuildMode && preset === "cloudflare" && override !== "0" && (hasTrie || hasEntries) && (override === "1" || payloadJson.length >= MANIFEST_EXTERNALIZE_THRESHOLD);
   if (useTextModule) {
-    const dir = join7(state.projectRoot, "node_modules", ".rango");
-    mkdirSync2(dir, { recursive: true });
-    const safeId = `${routerId.replace(/[^a-zA-Z0-9_-]/g, "_")}-${shortHash(routerId)}`;
-    const filePath = join7(dir, `manifest-${safeId}.txt`).replaceAll("\\", "/");
-    writeFileSync5(filePath, payloadJson);
+    const dir = join9(state.projectRoot, "node_modules", ".rango");
+    mkdirSync3(dir, { recursive: true });
+    const safeId = `${routerId2.replace(/[^a-zA-Z0-9_-]/g, "_")}-${shortHash(routerId2)}`;
+    const filePath = join9(dir, `manifest-${safeId}.txt`).replaceAll("\\", "/");
+    writeFileSync6(filePath, payloadJson);
     lines.push(`import __manifestJson from ${JSON.stringify(filePath)};`);
     lines.push(`const __manifestData = JSON.parse(__manifestJson);`);
     emitManifestExports(lines, hasTrie, hasEntries);
@@ -11188,13 +11906,13 @@ function emitManifestExports(lines, hasTrie, hasEntries) {
 }
 
 // src/vite/discovery/bundle-postprocess.ts
-import { resolve as resolve11 } from "node:path";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync10 } from "node:fs";
+import { resolve as resolve12 } from "node:path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync11 } from "node:fs";
 function postprocessBundle(state) {
   const hasPrerenderData = state.prerenderManifestEntries && Object.keys(state.prerenderManifestEntries).length > 0;
   const hasStaticData = state.staticManifestEntries && Object.keys(state.staticManifestEntries).length > 0;
   if (!hasPrerenderData && !hasStaticData) return;
-  const rscEntryPath = resolve11(
+  const rscEntryPath = resolve12(
     state.projectRoot,
     "dist/rsc",
     state.rscEntryFileName ?? "index.js"
@@ -11215,9 +11933,9 @@ function postprocessBundle(state) {
   ];
   for (const target of evictionTargets) {
     for (const info of target.infos) {
-      const chunkPath = resolve11(state.projectRoot, "dist/rsc", info.fileName);
+      const chunkPath = resolve12(state.projectRoot, "dist/rsc", info.fileName);
       try {
-        const code = readFileSync8(chunkPath, "utf-8");
+        const code = readFileSync10(chunkPath, "utf-8");
         const result = evictHandlerCode(
           code,
           info.exports,
@@ -11225,7 +11943,7 @@ function postprocessBundle(state) {
           target.brand
         );
         if (result) {
-          writeFileSync6(chunkPath, result.code);
+          writeFileSync7(chunkPath, result.code);
           const savedKB = (result.savedBytes / 1024).toFixed(1);
           console.log(
             `[rango] Evicted ${target.label} (${savedKB} KB saved): ${info.fileName}`
@@ -11240,8 +11958,8 @@ function postprocessBundle(state) {
   }
   state.handlerChunkInfoMap.clear();
   state.staticHandlerChunkInfoMap.clear();
-  if (hasPrerenderData && existsSync10(rscEntryPath)) {
-    const rscCode = readFileSync8(rscEntryPath, "utf-8");
+  if (hasPrerenderData && existsSync11(rscEntryPath)) {
+    const rscCode = readFileSync10(rscEntryPath, "utf-8");
     if (!rscCode.includes("__prerender-manifest.js")) {
       try {
         let totalBytes = copyStagedBuildAssets(
@@ -11260,15 +11978,15 @@ function postprocessBundle(state) {
           `export default m;`,
           ""
         ].join("\n");
-        const manifestPath = resolve11(
+        const manifestPath = resolve12(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js"
         );
-        writeFileSync6(manifestPath, manifestCode);
+        writeFileSync7(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
         const injection = `globalThis.__loadPrerenderManifestModule = () => import("./__prerender-manifest.js");
 `;
-        writeFileSync6(rscEntryPath, injection + rscCode);
+        writeFileSync7(rscEntryPath, injection + rscCode);
         const totalKB = (totalBytes / 1024).toFixed(1);
         console.log(
           `[rango] Wrote prerender assets (${totalKB} KB total, ${Object.keys(state.prerenderManifestEntries).length} entries)`
@@ -11280,8 +11998,8 @@ function postprocessBundle(state) {
       }
     }
   }
-  if (hasStaticData && existsSync10(rscEntryPath)) {
-    const rscCode = readFileSync8(rscEntryPath, "utf-8");
+  if (hasStaticData && existsSync11(rscEntryPath)) {
+    const rscCode = readFileSync10(rscEntryPath, "utf-8");
     if (!rscCode.includes("__static-manifest.js")) {
       try {
         const manifestEntries = [];
@@ -11298,15 +12016,15 @@ function postprocessBundle(state) {
         }
         const manifestCode = `const m={${manifestEntries.join(",")}};globalThis.__STATIC_MANIFEST=m;export default m;
 `;
-        const manifestPath = resolve11(
+        const manifestPath = resolve12(
           state.projectRoot,
           "dist/rsc/__static-manifest.js"
         );
-        writeFileSync6(manifestPath, manifestCode);
+        writeFileSync7(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
         const injection = `globalThis.__loadStaticManifestModule = () => import("./__static-manifest.js");
 `;
-        writeFileSync6(rscEntryPath, injection + rscCode);
+        writeFileSync7(rscEntryPath, injection + rscCode);
         const totalKB = (totalBytes / 1024).toFixed(1);
         console.log(
           `[rango] Wrote static assets (${totalKB} KB total, ${Object.keys(state.staticManifestEntries).length} entries)`
@@ -11321,7 +12039,7 @@ function postprocessBundle(state) {
 }
 
 // src/vite/discovery/gate-state.ts
-function createDiscoveryGate(s, debug13) {
+function createDiscoveryGate(s, debug14) {
   let gatePending = false;
   let gateResolver = () => {
   };
@@ -11330,15 +12048,15 @@ function createDiscoveryGate(s, debug13) {
   let pendingEvents = false;
   const beginGate = () => {
     if (gatePending) return;
-    s.discoveryDone = new Promise((resolve14) => {
-      gateResolver = resolve14;
+    s.discoveryDone = new Promise((resolve15) => {
+      gateResolver = resolve15;
     });
     gatePending = true;
   };
   const resolveGate = () => {
     if (!gatePending) return;
     if (inProgress || queued2 || pendingEvents) {
-      debug13?.(
+      debug14?.(
         "hmr: resolveGate deferred \u2014 work in flight (inProgress=%s queued=%s pendingEvents=%s)",
         inProgress,
         queued2,
@@ -11347,7 +12065,7 @@ function createDiscoveryGate(s, debug13) {
       return;
     }
     gatePending = false;
-    debug13?.("hmr: discoveryDone resolved");
+    debug14?.("hmr: discoveryDone resolved");
     gateResolver();
   };
   const noteRouteEvent = () => {
@@ -11357,7 +12075,7 @@ function createDiscoveryGate(s, debug13) {
   const runRefreshCycle = async (work) => {
     if (inProgress) {
       queued2 = true;
-      debug13?.("hmr: rediscovery in flight \u2014 queued for a follow-up cycle");
+      debug14?.("hmr: rediscovery in flight \u2014 queued for a follow-up cycle");
       return;
     }
     pendingEvents = false;
@@ -11368,16 +12086,16 @@ function createDiscoveryGate(s, debug13) {
       inProgress = false;
       if (queued2) {
         queued2 = false;
-        debug13?.("hmr: consuming queued rediscovery");
+        debug14?.("hmr: consuming queued rediscovery");
         runRefreshCycle(work).catch((err) => {
-          debug13?.(
+          debug14?.(
             "hmr: queued cycle rejected \u2014 releasing gate (%s)",
             err instanceof Error ? err.message : String(err)
           );
           resolveGate();
         });
       } else if (pendingEvents) {
-        debug13?.(
+        debug14?.(
           "hmr: holding gate for pending events (debounce not yet fired)"
         );
       } else {
@@ -11423,15 +12141,15 @@ function selectForwardableResolvePlugins(plugins) {
 }
 function pickForwardedRunnerConfig(config) {
   const r = config.resolve ?? {};
-  const resolve14 = {};
-  if (r.alias !== void 0) resolve14.alias = r.alias;
-  if (r.dedupe !== void 0) resolve14.dedupe = r.dedupe;
-  if (r.conditions !== void 0) resolve14.conditions = r.conditions;
-  if (r.mainFields !== void 0) resolve14.mainFields = r.mainFields;
-  if (r.extensions !== void 0) resolve14.extensions = r.extensions;
+  const resolve15 = {};
+  if (r.alias !== void 0) resolve15.alias = r.alias;
+  if (r.dedupe !== void 0) resolve15.dedupe = r.dedupe;
+  if (r.conditions !== void 0) resolve15.conditions = r.conditions;
+  if (r.mainFields !== void 0) resolve15.mainFields = r.mainFields;
+  if (r.extensions !== void 0) resolve15.extensions = r.extensions;
   if (r.preserveSymlinks !== void 0)
-    resolve14.preserveSymlinks = r.preserveSymlinks;
-  if (r.tsconfigPaths !== void 0) resolve14.tsconfigPaths = r.tsconfigPaths;
+    resolve15.preserveSymlinks = r.preserveSymlinks;
+  if (r.tsconfigPaths !== void 0) resolve15.tsconfigPaths = r.tsconfigPaths;
   const userOxc = config.oxc;
   const userJsx = userOxc && typeof userOxc === "object" && typeof userOxc.jsx === "object" && userOxc.jsx !== null ? userOxc.jsx : {};
   const oxc = userOxc && typeof userOxc === "object" ? {
@@ -11439,7 +12157,7 @@ function pickForwardedRunnerConfig(config) {
     jsx: { ...userJsx, runtime: "automatic", importSource: "react" }
   } : { jsx: { runtime: "automatic", importSource: "react" } };
   return {
-    resolve: resolve14,
+    resolve: resolve15,
     define: config.define,
     oxc
   };
@@ -11561,6 +12279,26 @@ async function createTempRscServer(state, options = {}) {
     ]
   });
 }
+var WRANGLER_CONFIG_NAMES = [
+  "wrangler.json",
+  "wrangler.jsonc",
+  "wrangler.toml"
+];
+function wranglerProxyOptions(root) {
+  const viteRoot = resolve13(root);
+  for (let dir = viteRoot; ; dir = dirname7(dir)) {
+    for (const name of WRANGLER_CONFIG_NAMES) {
+      const configPath = join10(dir, name);
+      if (existsSync12(configPath)) {
+        return {
+          configPath,
+          persist: { path: join10(viteRoot, ".wrangler", "state", "v3") }
+        };
+      }
+    }
+    if (dirname7(dir) === dir) return void 0;
+  }
+}
 async function resolveBuildEnv(option, factoryCtx) {
   if (!option) return null;
   if (option === "auto") {
@@ -11571,11 +12309,13 @@ async function resolveBuildEnv(option, factoryCtx) {
     }
     try {
       const userRequire = createRequire3(
-        resolve12(factoryCtx.root, "package.json")
+        resolve13(factoryCtx.root, "package.json")
       );
       const wranglerPath = userRequire.resolve("wrangler");
       const { getPlatformProxy } = await import(pathToFileURL2(wranglerPath).href);
-      const proxy = await getPlatformProxy();
+      const proxy = await getPlatformProxy(
+        wranglerProxyOptions(factoryCtx.root)
+      );
       return {
         env: proxy.env,
         dispose: proxy.dispose
@@ -11613,6 +12353,7 @@ function resetPrerenderCollection(s) {
   s.staticManifestEntries = null;
   s.shellCandidates = null;
   s.prerenderPayloadValues = null;
+  s.buildData = [];
 }
 async function releaseBuildEnv(s) {
   if (s.buildEnvDispose) {
@@ -11757,8 +12498,8 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
       }
       server.middlewares.use(internalDebugNoCacheMiddleware());
       let resolveDiscovery;
-      const discoveryPromise = new Promise((resolve14) => {
-        resolveDiscovery = resolve14;
+      const discoveryPromise = new Promise((resolve15) => {
+        resolveDiscovery = resolve15;
       });
       const gate = createDiscoveryGate(s, debugDiscovery);
       const beginDiscoveryGate = gate.beginGate;
@@ -11947,6 +12688,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
             globalThis.__rscRouterDiscoveryActive ?? false
           );
           s.devServerOrigin = getDevServerOrigin();
+          globalThis.__PRERENDER_DEV_URL = s.devServerOrigin;
           let tempRscEnv;
           let optimizerHashBefore2;
           try {
@@ -12057,7 +12799,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
         for (const [map2, fn] of perRouterSetters) {
           const setter = serverMod[fn];
           if (typeof setter !== "function") continue;
-          for (const [routerId, value] of map2) setter(routerId, value);
+          for (const [routerId2, value] of map2) setter(routerId2, value);
         }
       };
       server.middlewares.use("/__rsc_prerender", async (req, res) => {
@@ -12340,7 +13082,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
               maxSnapshotBytes,
               captureTimeout,
               buildEnv: s.resolvedBuildEnv,
-              buildVersion: version,
+              versions: uniformVersions(version),
               captureShellHTML: ssrModule.captureShellHTML,
               debug: !!debugDiscovery
             });
@@ -12525,7 +13267,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
               if (devServerClosed || expectedEpoch !== s.devDiscoveryEpoch) {
                 return;
               }
-              await new Promise((resolve14) => setTimeout(resolve14, 25));
+              await new Promise((resolve15) => setTimeout(resolve15, 25));
               if (devServerClosed || expectedEpoch !== s.devDiscoveryEpoch) {
                 return;
               }
@@ -12643,7 +13385,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
           }
           const inRecoveryMode = !!s.lastDiscoveryError;
           try {
-            const source = readFileSync9(filePath, "utf-8");
+            const source = readFileSync11(filePath, "utf-8");
             const trimmed = source.trimStart();
             const isUseClient = trimmed.startsWith('"use client"') || trimmed.startsWith("'use client'");
             let hasClientUrls = source.includes("clientUrls(");
@@ -12685,11 +13427,11 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
               if (rscGraph?.getModulesByFile) {
                 const routerSourceFiles = /* @__PURE__ */ new Set();
                 if (s.resolvedEntryPath) {
-                  routerSourceFiles.add(resolve12(s.resolvedEntryPath));
+                  routerSourceFiles.add(resolve13(s.resolvedEntryPath));
                 }
                 for (const entry of s.perRouterManifests) {
                   if (entry.sourceFile) {
-                    routerSourceFiles.add(resolve12(entry.sourceFile));
+                    routerSourceFiles.add(resolve13(entry.sourceFile));
                   }
                 }
                 const seen = /* @__PURE__ */ new Set();
@@ -12718,7 +13460,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
             if (hasCreateRouter) {
               const nestedRouterConflict = findNestedRouterConflict([
                 ...s.cachedRouterFiles ?? [],
-                resolve12(filePath)
+                resolve13(filePath)
               ]);
               if (nestedRouterConflict) {
                 server.config.logger.error(
@@ -12841,18 +13583,27 @@ ${details}`,
         );
       }
     },
-    // Post-build PPR shell capture (producer B, #699): runs after EVERY
-    // environment bundle is written — the shell prelude embeds built client
-    // asset URLs (bootstrap entry), which do not exist at buildStart. The
-    // kept temp server and the buildEnv were deferred AS A PAIR in
-    // buildStart's finally; this finally is the pair's success-path owner
-    // (buildEnd below owns the aborted-build path) — the phase itself is a
-    // pure producer and tears down only the globals it installs.
+    // Post-build phases, after EVERY environment bundle is written.
+    //
+    // 1. Cache versions (discovery/router-versions-phase.ts): hashes the
+    //    server output as postprocessBundle left it and writes the per-router
+    //    table into the built version module. First, because phase 2 stamps
+    //    its entries with these versions and reads the same RSC out dir.
+    // 2. PPR shell capture (producer B, #699): the shell prelude embeds built
+    //    client asset URLs (bootstrap entry), which do not exist at
+    //    buildStart. The kept temp server and the buildEnv were deferred AS A
+    //    PAIR in buildStart's finally; this finally is the pair's success-path
+    //    owner (buildEnd below owns the aborted-build path) — the phase itself
+    //    is a pure producer and tears down only the globals it installs.
     buildApp: {
       order: "post",
       async handler(builder) {
         try {
-          await runShellPrerenderPhase(s, builder);
+          await runShellPrerenderPhase(
+            s,
+            builder,
+            runRouterVersionsPhase(s, builder)
+          );
         } finally {
           if (s.isBuildMode) {
             const tempServer = s.shellPhaseTempServer;
@@ -12941,11 +13692,11 @@ ${details}`,
             () => s.discoveryDone
           );
         }
-        const routerId = id.slice(perRouterPrefix.length);
+        const routerId2 = id.slice(perRouterPrefix.length);
         const code = await timed(
           debugRoutes,
-          `generatePerRouterModule ${routerId}`,
-          () => generatePerRouterModule(s, routerId)
+          `generatePerRouterModule ${routerId2}`,
+          () => generatePerRouterModule(s, routerId2)
         );
         return code;
       }
@@ -12954,6 +13705,19 @@ ${details}`,
     // Record handler chunk metadata and RSC entry filename during RSC build.
     // Used by closeBundle for handler code eviction and prerender data injection.
     generateBundle(_options, bundle) {
+      if (s.isBuildMode) {
+        const envName = this.environment?.name;
+        if (envName) {
+          s.versionModuleFiles.set(envName, recordVersionModuleFiles(bundle));
+        }
+        if (envName === "rsc") {
+          s.serverBuildGraph = recordServerGraph(this, bundle);
+        } else if (envName === "client") {
+          s.clientBuildGraph = recordClientGraph(this, bundle);
+        } else if (envName === "ssr") {
+          s.ssrBundle = recordBundleFiles(bundle);
+        }
+      }
       if (this.environment?.name !== "rsc") return;
       const genStart = debugBuild ? performance.now() : 0;
       for (const [fileName, chunk] of Object.entries(bundle)) {
@@ -12978,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);
@@ -13043,10 +13813,12 @@ ${details}`,
 init_debug();
 var debugConfig = createRangoDebugger(NS.config);
 var SERVER_BUILD_TARGET = "esnext";
+var RSC_ENTRY_SIGNATURES = "strict";
 async function rango(options) {
   const rangoStart = performance.now();
   const resolvedOptions = options ?? { preset: "node" };
   const preset = resolvedOptions.preset ?? "node";
+  configureEncryptionKey(resolvedOptions.encryptionKey);
   const showBanner = resolvedOptions.banner ?? true;
   const clientChunksOption = resolvedOptions.clientChunks ?? true;
   const useBuiltInClientChunks = clientChunksOption === true;
@@ -13190,14 +13962,14 @@ async function rango(options) {
       name: "@rangojs/router:auto-discover",
       config(userConfig) {
         if (routerRef.path) return;
-        const root = userConfig.root ? resolve13(process.cwd(), userConfig.root) : process.cwd();
+        const root = userConfig.root ? resolve14(process.cwd(), userConfig.root) : process.cwd();
         const toRootRelative = (abs) => (abs.startsWith(root) ? "./" + abs.slice(root.length + 1) : abs).replaceAll("\\", "/");
         const bulletList = (files) => files.map((f) => "  - " + toRootRelative(f)).join("\n");
         if (explicitHostRouter) {
           routerRef.path = normalizeHostRouterEntry(
             explicitHostRouter,
             root,
-            existsSync11
+            existsSync13
           );
           routerRef.kind = "host";
           return;
@@ -13317,7 +14089,10 @@ If this is a multi-app host router, export a createHostRouter() instance and set
             rsc: {
               ...vercelServerEnv ?? {},
               build: {
-                target: SERVER_BUILD_TARGET
+                target: SERVER_BUILD_TARGET,
+                rollupOptions: {
+                  preserveEntrySignatures: RSC_ENTRY_SIGNATURES
+                }
               },
               optimizeDeps: {
                 entries: [VIRTUAL_IDS.rsc],
@@ -13380,6 +14155,7 @@ If this is a multi-app host router, export a createHostRouter() instance and set
     plugins.push(clientRefDedup());
   }
   plugins.push(clientChunksReport());
+  plugins.push(stableRscOutput());
   plugins.push({
     name: "@rangojs/router:client-component-hmr",
     hotUpdate(ctx) {
@@ -13389,7 +14165,7 @@ If this is a multi-app host router, export a createHostRouter() instance and set
       if (!file.endsWith(".tsx") && !file.endsWith(".ts") && !file.endsWith(".jsx") && !file.endsWith(".js"))
         return;
       try {
-        const source = readFileSync10(file, "utf-8");
+        const source = readFileSync12(file, "utf-8");
         if (hasUseClientDirective2(source)) {
           return [];
         }
@@ -13412,7 +14188,7 @@ If this is a multi-app host router, export a createHostRouter() instance and set
   const discoveryEntryPath = preset !== "cloudflare" ? routerRef.path : void 0;
   const discoveryRouterRef = preset !== "cloudflare" ? routerRef : void 0;
   if (preset === "cloudflare") {
-    plugins.push(createVersionInjectorPlugin(void 0));
+    plugins.push(createEntryBootstrapInjectorPlugin(void 0));
   }
   plugins.push(createCjsToEsmPlugin());
   plugins.push(
@@ -13449,7 +14225,7 @@ function poke() {
     apply: "serve",
     configureServer(server) {
       const stdin = process.stdin;
-      const debug13 = process.env.RANGO_POKE_DEBUG === "1";
+      const debug14 = process.env.RANGO_POKE_DEBUG === "1";
       const triggerReload = (source) => {
         server.hot.send({ type: "full-reload", path: "*" });
         server.config.logger.info(`  browser reload (${source})`, {
@@ -13482,7 +14258,7 @@ function poke() {
         lines.pop();
         return lines;
       };
-      if (debug13) {
+      if (debug14) {
         server.config.logger.info(
           `  poke debug enabled (isTTY=${stdin.isTTY ? "yes" : "no"}, isRaw=${stdin.isTTY ? stdin.isRaw ? "yes" : "no" : "n/a"})`,
           { timestamp: true }
@@ -13495,7 +14271,7 @@ function poke() {
         );
       }
       const onData = (data) => {
-        if (debug13) {
+        if (debug14) {
           server.config.logger.info(`  poke stdin ${formatChunk(data)}`, {
             timestamp: true
           });