@rangojs/router 0.0.0-experimental.19 → 0.0.0-experimental.1b930379

package/dist/vite/index.js

@@ -1,6 +1,6 @@
 // src/vite/rango.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 
 // src/vite/plugins/expose-action-id.ts
 import MagicString from "magic-string";
@@ -1585,6 +1585,53 @@ function warnOnNearMissDirectives(ast, fileId, warn) {
   }
 }
 
+// src/vite/plugins/client-ref-dedup.ts
+var CLIENT_IN_SERVER_PROXY_PREFIX = "virtual:vite-rsc/client-in-server-package-proxy/";
+function extractPackageName(absolutePath) {
+  const marker = "/node_modules/";
+  const idx = absolutePath.lastIndexOf(marker);
+  if (idx === -1) return null;
+  const afterModules = absolutePath.slice(idx + marker.length);
+  if (afterModules.startsWith("@")) {
+    const parts = afterModules.split("/");
+    if (parts.length < 2 || !parts[1]) return null;
+    return `${parts[0]}/${parts[1]}`;
+  }
+  const name = afterModules.split("/")[0];
+  return name || null;
+}
+function clientRefDedup() {
+  let clientExclude = [];
+  return {
+    name: "@rangojs/router:client-ref-dedup",
+    enforce: "pre",
+    apply: "serve",
+    configResolved(config) {
+      const clientEnv = config.environments?.["client"];
+      clientExclude = clientEnv?.optimizeDeps?.exclude ?? config.optimizeDeps?.exclude ?? [];
+    },
+    resolveId(source, importer, options) {
+      if (this.environment?.name !== "client") return;
+      if (!importer?.includes(CLIENT_IN_SERVER_PROXY_PREFIX)) return;
+      if (!source.includes("/node_modules/")) return;
+      if (!importer) return;
+      const packageName = extractPackageName(source);
+      if (!packageName) return;
+      if (clientExclude.includes(packageName)) return;
+      return `\0rango:dedup/${packageName}`;
+    },
+    load(id) {
+      if (!id.startsWith("\0rango:dedup/")) return;
+      const packageName = id.slice("\0rango:dedup/".length);
+      return [
+        `export * from ${JSON.stringify(packageName)};`,
+        `import * as __all__ from ${JSON.stringify(packageName)};`,
+        `export default __all__.default;`
+      ].join("\n");
+    }
+  };
+}
+
 // src/vite/plugins/virtual-entries.ts
 var VIRTUAL_ENTRY_BROWSER = `
 import {
@@ -1698,7 +1745,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.19",
+  version: "0.0.0-experimental.1b930379",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -1729,7 +1776,7 @@ var package_default = {
     "!src/**/*.test.tsx",
     "dist",
     "skills",
-    "CLAUDE.md",
+    "AGENTS.md",
     "README.md"
   ],
   type: "module",
@@ -2049,7 +2096,6 @@ declare global {
 
 // src/build/route-types/scan-filter.ts
 import { join, relative } from "node:path";
-import { readdirSync } from "node:fs";
 import picomatch from "picomatch";
 var DEFAULT_EXCLUDE_PATTERNS = [
   "**/__tests__/**",
@@ -2074,29 +2120,6 @@ function createScanFilter(root, opts) {
     return true;
   };
 }
-function findTsFiles(dir, filter) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch (err) {
-    console.warn(
-      `[rsc-router] Failed to scan directory ${dir}: ${err.message}`
-    );
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
-      results.push(...findTsFiles(fullPath, filter));
-    } else if ((entry.name.endsWith(".ts") || entry.name.endsWith(".tsx") || entry.name.endsWith(".js") || entry.name.endsWith(".jsx")) && !entry.name.includes(".gen.")) {
-      if (filter && !filter(fullPath)) continue;
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
 
 // src/build/route-types/per-module-writer.ts
 import ts4 from "typescript";
@@ -2355,8 +2378,20 @@ function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagno
 }
 
 // src/build/route-types/router-processing.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3, unlinkSync } from "node:fs";
-import { join as join2, dirname as dirname2, resolve as resolve3, basename as pathBasename } from "node:path";
+import {
+  readFileSync as readFileSync2,
+  writeFileSync,
+  existsSync as existsSync3,
+  unlinkSync,
+  readdirSync
+} from "node:fs";
+import {
+  join as join2,
+  dirname as dirname2,
+  resolve as resolve3,
+  sep,
+  basename as pathBasename
+} from "node:path";
 import ts5 from "typescript";
 function countPublicRouteEntries(source) {
   const matches = source.matchAll(/^\s+(?:"([^"]+)"|([a-zA-Z_$][^:]*)):\s*["{]/gm) ?? [];
@@ -2369,6 +2404,77 @@ function countPublicRouteEntries(source) {
   }
   return count;
 }
+var ROUTER_CALL_PATTERN = /\bcreateRouter\s*[<(]/;
+function isRoutableSourceFile(name) {
+  return (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js") || name.endsWith(".jsx")) && !name.includes(".gen.");
+}
+function findRouterFilesRecursive(dir, filter, results) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    console.warn(
+      `[rsc-router] Failed to scan directory ${dir}: ${err.message}`
+    );
+    return;
+  }
+  const childDirs = [];
+  const routerFilesInDir = [];
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      childDirs.push(fullPath);
+      continue;
+    }
+    if (!isRoutableSourceFile(entry.name)) continue;
+    if (filter && !filter(fullPath)) continue;
+    try {
+      const source = readFileSync2(fullPath, "utf-8");
+      if (ROUTER_CALL_PATTERN.test(source)) {
+        routerFilesInDir.push(fullPath);
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (routerFilesInDir.length > 0) {
+    results.push(...routerFilesInDir);
+    return;
+  }
+  for (const childDir of childDirs) {
+    findRouterFilesRecursive(childDir, filter, results);
+  }
+}
+function findNestedRouterConflict(routerFiles) {
+  const routerDirs = [
+    ...new Set(routerFiles.map((filePath) => dirname2(resolve3(filePath))))
+  ].sort((a, b) => a.length - b.length);
+  for (let i = 0; i < routerDirs.length; i++) {
+    const ancestorDir = routerDirs[i];
+    const prefix = ancestorDir.endsWith(sep) ? ancestorDir : `${ancestorDir}${sep}`;
+    for (let j = i + 1; j < routerDirs.length; j++) {
+      const nestedDir = routerDirs[j];
+      if (!nestedDir.startsWith(prefix)) continue;
+      const ancestorFile = routerFiles.find(
+        (filePath) => dirname2(resolve3(filePath)) === ancestorDir
+      );
+      const nestedFile = routerFiles.find(
+        (filePath) => dirname2(resolve3(filePath)) === nestedDir
+      );
+      if (ancestorFile && nestedFile) {
+        return { ancestor: ancestorFile, nested: nestedFile };
+      }
+    }
+  }
+  return null;
+}
+function formatNestedRouterConflictError(conflict, prefix = "[rsc-router]") {
+  return `${prefix} Nested router roots are not supported.
+Router root: ${conflict.ancestor}
+Nested router: ${conflict.nested}
+Move the nested router into a sibling directory or configure it as a separate app root.`;
+}
 function extractUrlsVariableFromRouter(code) {
   const sourceFile = ts5.createSourceFile(
     "router.tsx",
@@ -2435,19 +2541,8 @@ function buildCombinedRouteMapForRouterFile(routerFilePath) {
   return buildCombinedRouteMapWithSearch(routerFilePath, urlsVarName);
 }
 function findRouterFiles(root, filter) {
-  const files = findTsFiles(root, filter);
   const result = [];
-  for (const filePath of files) {
-    if (filePath.includes(".gen.")) continue;
-    try {
-      const source = readFileSync2(filePath, "utf-8");
-      if (/\bcreateRouter\s*[<(]/.test(source)) {
-        result.push(filePath);
-      }
-    } catch {
-      continue;
-    }
-  }
+  findRouterFilesRecursive(root, filter, result);
   return result;
 }
 function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
@@ -2463,6 +2558,10 @@ function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
   }
   const routerFilePaths = knownRouterFiles ?? findRouterFiles(root);
   if (routerFilePaths.length === 0) return;
+  const nestedRouterConflict = findNestedRouterConflict(routerFilePaths);
+  if (nestedRouterConflict) {
+    throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
+  }
   for (const routerFilePath of routerFilePaths) {
     let routerSource;
     try {
@@ -2925,6 +3024,7 @@ function createCjsToEsmPlugin() {
 
 // src/vite/router-discovery.ts
 import { createServer as createViteServer } from "vite";
+import { resolve as resolve8 } from "node:path";
 import { readFileSync as readFileSync6 } from "node:fs";
 
 // src/vite/plugins/virtual-stub-plugin.ts
@@ -3107,8 +3207,8 @@ function createDiscoveryState(entryPath, opts) {
     perRouterTrieMap: /* @__PURE__ */ new Map(),
     perRouterPrecomputedMap: /* @__PURE__ */ new Map(),
     perRouterManifestDataMap: /* @__PURE__ */ new Map(),
-    prerenderCollectedData: null,
-    staticCollectedData: null,
+    prerenderManifestEntries: null,
+    staticManifestEntries: null,
     handlerChunkInfo: null,
     staticHandlerChunkInfo: null,
     rscEntryFileName: null,
@@ -3208,6 +3308,16 @@ function contextSet(variables, keyOrVar, value) {
 }
 
 // src/vite/utils/prerender-utils.ts
+import { createHash as createHash4 } from "node:crypto";
+import {
+  copyFileSync,
+  existsSync as existsSync4,
+  mkdirSync,
+  rmSync,
+  statSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { resolve as resolve5 } from "node:path";
 function escapeRegExp2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -3286,6 +3396,37 @@ function notifyOnError(registry, error, phase, routeKey, pathname, skipped) {
     break;
   }
 }
+function getStagedAssetDir(projectRoot) {
+  return resolve5(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
+}
+function resetStagedBuildAssets(projectRoot) {
+  rmSync(getStagedAssetDir(projectRoot), { recursive: true, force: true });
+}
+function stageBuildAssetModule(projectRoot, prefix, exportValue) {
+  const stagedDir = getStagedAssetDir(projectRoot);
+  mkdirSync(stagedDir, { recursive: true });
+  const contentHash = createHash4("sha256").update(exportValue).digest("hex").slice(0, 8);
+  const fileName = `${prefix}-${contentHash}.js`;
+  const filePath = resolve5(stagedDir, fileName);
+  if (!existsSync4(filePath)) {
+    writeFileSync2(filePath, `export default ${exportValue};
+`);
+  }
+  return fileName;
+}
+function copyStagedBuildAssets(projectRoot, fileNames) {
+  const stagedDir = getStagedAssetDir(projectRoot);
+  const distAssetsDir = resolve5(projectRoot, "dist/rsc/assets");
+  mkdirSync(distAssetsDir, { recursive: true });
+  let totalBytes = 0;
+  for (const fileName of new Set(fileNames)) {
+    const stagedPath = resolve5(stagedDir, fileName);
+    const distPath = resolve5(distAssetsDir, fileName);
+    copyFileSync(stagedPath, distPath);
+    totalBytes += statSync(stagedPath).size;
+  }
+  return totalBytes;
+}
 
 // src/vite/discovery/prerender-collection.ts
 async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
@@ -3387,7 +3528,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
     `[rsc-router] Pre-rendering ${entries.length} URL(s)${concurrencyNote}...`
   );
   const { hashParams } = await rscEnv.runner.import("@rangojs/router/build");
-  const collectedData = {};
+  const manifestEntries = {};
   let doneCount = 0;
   let skipCount = 0;
   const startTotal = performance.now();
@@ -3417,18 +3558,30 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
               break;
             }
             const paramHash = hashParams(result.params || {});
-            collectedData[`${result.routeName}/${paramHash}`] = {
+            const mainKey = `${result.routeName}/${paramHash}`;
+            const mainValue = JSON.stringify({
               segments: result.segments,
               handles: result.handles
-            };
+            });
+            manifestEntries[mainKey] = stageBuildAssetModule(
+              state.projectRoot,
+              "__pr",
+              mainValue
+            );
             if (result.interceptSegments?.length) {
-              collectedData[`${result.routeName}/${paramHash}/i`] = {
+              const interceptKey = `${result.routeName}/${paramHash}/i`;
+              const interceptValue = JSON.stringify({
                 segments: [...result.segments, ...result.interceptSegments],
                 handles: {
                   ...result.handles,
                   ...result.interceptHandles || {}
                 }
-              };
+              });
+              manifestEntries[interceptKey] = stageBuildAssetModule(
+                state.projectRoot,
+                "__pr",
+                interceptValue
+              );
             }
             const elapsed = (performance.now() - startUrl).toFixed(0);
             console.log(
@@ -3472,7 +3625,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
   }
   const totalElapsed = (performance.now() - startTotal).toFixed(0);
   if (doneCount > 0) {
-    state.prerenderCollectedData = collectedData;
+    state.prerenderManifestEntries = manifestEntries;
   }
   const parts = [`${doneCount} done`];
   if (skipCount > 0) parts.push(`${skipCount} skipped`);
@@ -3483,7 +3636,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
 async function renderStaticHandlers(state, rscEnv, registry) {
   if (!state.opts?.enableBuildPrerender || !state.isBuildMode || !state.resolvedStaticModules?.size)
     return;
-  const collected = {};
+  const manifestEntries = {};
   let staticDone = 0;
   let staticSkip = 0;
   let totalStaticCount = 0;
@@ -3520,7 +3673,13 @@ async function renderStaticHandlers(state, rscEnv, registry) {
             def.$$routePrefix
           );
           if (result) {
-            collected[def.$$id] = result;
+            const hasHandles = Object.keys(result.handles).length > 0;
+            const exportValue = hasHandles ? JSON.stringify(result) : JSON.stringify(result.encoded);
+            manifestEntries[def.$$id] = stageBuildAssetModule(
+              state.projectRoot,
+              "__st",
+              exportValue
+            );
             const elapsed = (performance.now() - startHandler).toFixed(0);
             console.log(
               `[rsc-router]   OK   ${name.padEnd(40)} (${elapsed}ms)`
@@ -3557,7 +3716,7 @@ async function renderStaticHandlers(state, rscEnv, registry) {
   }
   const totalStaticElapsed = (performance.now() - startStatic).toFixed(0);
   if (staticDone > 0) {
-    state.staticCollectedData = collected;
+    state.staticManifestEntries = manifestEntries;
   }
   const staticParts = [`${staticDone} done`];
   if (staticSkip > 0) staticParts.push(`${staticSkip} skipped`);
@@ -3574,8 +3733,7 @@ async function discoverRouters(state, rscEnv) {
   let registry = serverMod.RouterRegistry;
   if (!registry || registry.size === 0) {
     try {
-      const hostMod = await rscEnv.runner.import("@rangojs/router/host");
-      const hostRegistry = hostMod.HostRouterRegistry;
+      const hostRegistry = serverMod.HostRouterRegistry;
       if (hostRegistry && hostRegistry.size > 0) {
         console.log(
           `[rsc-router] Found ${hostRegistry.size} host router(s), resolving lazy handlers...`
@@ -3615,6 +3773,14 @@ async function discoverRouters(state, rscEnv) {
   }
   const buildMod = await rscEnv.runner.import("@rangojs/router/build");
   const generateManifestFull = buildMod.generateManifestFull;
+  const nestedRouterConflict = findNestedRouterConflict(
+    [...registry.values()].map((router) => router.__sourceFile).filter(
+      (sourceFile) => typeof sourceFile === "string"
+    )
+  );
+  if (nestedRouterConflict) {
+    throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
+  }
   const newMergedRouteManifest = {};
   const newMergedPrecomputedEntries = [];
   const newPerRouterManifests = [];
@@ -3771,8 +3937,8 @@ async function discoverRouters(state, rscEnv) {
 }
 
 // src/vite/discovery/route-types-writer.ts
-import { dirname as dirname3, basename, join as join3, resolve as resolve5 } from "node:path";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, unlinkSync as unlinkSync2 } from "node:fs";
+import { dirname as dirname3, basename, join as join3, resolve as resolve6 } from "node:path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, unlinkSync as unlinkSync2 } from "node:fs";
 function filterUserNamedRoutes(manifest) {
   const filtered = {};
   for (const [name, pattern] of Object.entries(manifest)) {
@@ -3806,7 +3972,7 @@ function writeCombinedRouteTypesWithTracking(state, opts) {
       ""
     );
     const outPath = join3(routerDir, `${routerBasename}.named-routes.gen.ts`);
-    if (!existsSync4(outPath)) continue;
+    if (!existsSync5(outPath)) continue;
     try {
       const content = readFileSync4(outPath, "utf-8");
       if (content !== preContent.get(outPath)) {
@@ -3820,10 +3986,10 @@ function writeRouteTypesFiles(state) {
   if (state.perRouterManifests.length === 0) return;
   try {
     const entryDir = dirname3(
-      resolve5(state.projectRoot, state.resolvedEntryPath)
+      resolve6(state.projectRoot, state.resolvedEntryPath)
     );
     const oldCombinedPath = join3(entryDir, "named-routes.gen.ts");
-    if (existsSync4(oldCombinedPath)) {
+    if (existsSync5(oldCombinedPath)) {
       unlinkSync2(oldCombinedPath);
       console.log(
         `[rsc-router] Removed stale combined route types: ${oldCombinedPath}`
@@ -3867,10 +4033,10 @@ Set an explicit \`id\` on createRouter() or check the call site.`
       userRoutes,
       effectiveSearchSchemas && Object.keys(effectiveSearchSchemas).length > 0 ? effectiveSearchSchemas : void 0
     );
-    const existing = existsSync4(outPath) ? readFileSync4(outPath, "utf-8") : null;
+    const existing = existsSync5(outPath) ? readFileSync4(outPath, "utf-8") : null;
     if (existing !== source) {
       markSelfGenWrite(state, outPath, source);
-      writeFileSync2(outPath, source);
+      writeFileSync3(outPath, source);
       console.log(`[rsc-router] Generated route types -> ${outPath}`);
     }
   }
@@ -3917,10 +4083,10 @@ function supplementGenFilesWithRuntimeRoutes(state) {
       mergedRoutes,
       Object.keys(mergedSearchSchemas).length > 0 ? mergedSearchSchemas : void 0
     );
-    const existing = existsSync4(outPath) ? readFileSync4(outPath, "utf-8") : null;
+    const existing = existsSync5(outPath) ? readFileSync4(outPath, "utf-8") : null;
     if (existing !== source) {
       markSelfGenWrite(state, outPath, source);
-      writeFileSync2(outPath, source);
+      writeFileSync3(outPath, source);
     }
   }
 }
@@ -4065,14 +4231,13 @@ function generatePerRouterModule(state, routerId) {
 }
 
 // src/vite/discovery/bundle-postprocess.ts
-import { resolve as resolve6 } from "node:path";
-import { createHash as createHash4 } from "node:crypto";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync } from "node:fs";
+import { resolve as resolve7 } from "node:path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "node:fs";
 function postprocessBundle(state) {
-  const hasPrerenderData = state.prerenderCollectedData && Object.keys(state.prerenderCollectedData).length > 0;
-  const hasStaticData = state.staticCollectedData && Object.keys(state.staticCollectedData).length > 0;
+  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 = resolve6(
+  const rscEntryPath = resolve7(
     state.projectRoot,
     "dist/rsc",
     state.rscEntryFileName ?? "index.js"
@@ -4093,7 +4258,7 @@ function postprocessBundle(state) {
   ];
   for (const target of evictionTargets) {
     if (!target.info) continue;
-    const chunkPath = resolve6(
+    const chunkPath = resolve7(
       state.projectRoot,
       "dist/rsc",
       target.info.fileName
@@ -4107,7 +4272,7 @@ function postprocessBundle(state) {
         target.brand
       );
       if (result) {
-        writeFileSync3(chunkPath, result.code);
+        writeFileSync4(chunkPath, result.code);
         const savedKB = (result.savedBytes / 1024).toFixed(1);
         console.log(
           `[rsc-router] Evicted ${target.label} (${savedKB} KB saved): ${target.info.fileName}`
@@ -4121,44 +4286,38 @@ function postprocessBundle(state) {
   }
   state.handlerChunkInfo = null;
   state.staticHandlerChunkInfo = null;
-  if (hasPrerenderData && existsSync5(rscEntryPath)) {
+  if (hasPrerenderData && existsSync6(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
     if (!rscCode.includes("__prerender-manifest.js")) {
       try {
-        const assetsDir = resolve6(state.projectRoot, "dist/rsc/assets");
-        mkdirSync(assetsDir, { recursive: true });
-        const manifestEntries = [];
-        let totalBytes = 0;
-        for (const [key, entry] of Object.entries(
-          state.prerenderCollectedData
+        let totalBytes = copyStagedBuildAssets(
+          state.projectRoot,
+          Object.values(state.prerenderManifestEntries)
+        );
+        const manifestMap = {};
+        for (const [key, assetFileName] of Object.entries(
+          state.prerenderManifestEntries
         )) {
-          const entryJson = JSON.stringify(entry);
-          const contentHash = createHash4("sha256").update(entryJson).digest("hex").slice(0, 8);
-          const assetFileName = `__pr-${contentHash}.js`;
-          const assetPath = resolve6(assetsDir, assetFileName);
-          const assetCode = `export default ${entryJson};
-`;
-          writeFileSync3(assetPath, assetCode);
-          totalBytes += Buffer.byteLength(assetCode);
-          manifestEntries.push(
-            `${JSON.stringify(key)}:()=>import("./assets/${assetFileName}")`
-          );
+          manifestMap[key] = `./assets/${assetFileName}`;
         }
-        const manifestCode = `const m={${manifestEntries.join(",")}};export default m;
-`;
-        const manifestPath = resolve6(
+        const manifestCode = [
+          `const m=JSON.parse('${JSON.stringify(manifestMap).replace(/'/g, "\\'")}');`,
+          `export function loadPrerenderAsset(s){return import(s)}`,
+          `export default m;`,
+          ""
+        ].join("\n");
+        const manifestPath = resolve7(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js"
         );
-        writeFileSync3(manifestPath, manifestCode);
+        writeFileSync4(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
-        const injection = `import __pm from "./__prerender-manifest.js";
-globalThis.__PRERENDER_MANIFEST = __pm;
+        const injection = `globalThis.__loadPrerenderManifestModule = () => import("./__prerender-manifest.js");
 `;
-        writeFileSync3(rscEntryPath, injection + rscCode);
+        writeFileSync4(rscEntryPath, injection + rscCode);
         const totalKB = (totalBytes / 1024).toFixed(1);
         console.log(
-          `[rsc-router] Wrote prerender assets (${totalKB} KB total, ${Object.keys(state.prerenderCollectedData).length} entries)`
+          `[rsc-router] Wrote prerender assets (${totalKB} KB total, ${Object.keys(state.prerenderManifestEntries).length} entries)`
         );
       } catch (err) {
         throw new Error(
@@ -4167,44 +4326,36 @@ globalThis.__PRERENDER_MANIFEST = __pm;
       }
     }
   }
-  if (hasStaticData && existsSync5(rscEntryPath)) {
+  if (hasStaticData && existsSync6(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
     if (!rscCode.includes("__STATIC_MANIFEST")) {
       try {
-        const assetsDir = resolve6(state.projectRoot, "dist/rsc/assets");
-        mkdirSync(assetsDir, { recursive: true });
         const manifestEntries = [];
-        let totalBytes = 0;
-        for (const [handlerId, { encoded, handles }] of Object.entries(
-          state.staticCollectedData
+        let totalBytes = copyStagedBuildAssets(
+          state.projectRoot,
+          Object.values(state.staticManifestEntries)
+        );
+        for (const [handlerId, assetFileName] of Object.entries(
+          state.staticManifestEntries
         )) {
-          const hasHandles = Object.keys(handles).length > 0;
-          const exportValue = hasHandles ? JSON.stringify({ encoded, handles }) : JSON.stringify(encoded);
-          const contentHash = createHash4("sha256").update(exportValue).digest("hex").slice(0, 8);
-          const assetFileName = `__st-${contentHash}.js`;
-          const assetPath = resolve6(assetsDir, assetFileName);
-          const assetCode = `export default ${exportValue};
-`;
-          writeFileSync3(assetPath, assetCode);
-          totalBytes += Buffer.byteLength(assetCode);
           manifestEntries.push(
             `${JSON.stringify(handlerId)}:()=>import("./assets/${assetFileName}")`
           );
         }
         const manifestCode = `const m={${manifestEntries.join(",")}};globalThis.__STATIC_MANIFEST=m;export default m;
 `;
-        const manifestPath = resolve6(
+        const manifestPath = resolve7(
           state.projectRoot,
           "dist/rsc/__static-manifest.js"
         );
-        writeFileSync3(manifestPath, manifestCode);
+        writeFileSync4(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
         const injection = `import "./__static-manifest.js";
 `;
-        writeFileSync3(rscEntryPath, injection + rscCode);
+        writeFileSync4(rscEntryPath, injection + rscCode);
         const totalKB = (totalBytes / 1024).toFixed(1);
         console.log(
-          `[rsc-router] Wrote static assets (${totalKB} KB total, ${Object.keys(state.staticCollectedData).length} entries)`
+          `[rsc-router] Wrote static assets (${totalKB} KB total, ${Object.keys(state.staticManifestEntries).length} entries)`
         );
       } catch (err) {
         throw new Error(
@@ -4319,8 +4470,8 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
       if (globalThis.__rscRouterDiscoveryActive) return;
       s.devServer = server;
       let resolveDiscovery;
-      const discoveryPromise = new Promise((resolve8) => {
-        resolveDiscovery = resolve8;
+      const discoveryPromise = new Promise((resolve10) => {
+        resolveDiscovery = resolve10;
       });
       const getDevServerOrigin = () => server.resolvedUrls?.local?.[0]?.replace(/\/$/, "") || `http://localhost:${server.config.server.port || 5173}`;
       let prerenderTempServer = null;
@@ -4395,8 +4546,8 @@ ${err.stack}`
           resolveDiscovery();
         }
       };
-      s.discoveryDone = new Promise((resolve8) => {
-        setTimeout(() => discover().then(resolve8, resolve8), 0);
+      s.discoveryDone = new Promise((resolve10) => {
+        setTimeout(() => discover().then(resolve10, resolve10), 0);
       });
       let mainRegistry = null;
       const propagateDiscoveryState = async (rscEnv) => {
@@ -4563,6 +4714,16 @@ ${err.stack}`
             const hasCreateRouter = /\bcreateRouter\s*[<(]/.test(source);
             if (!hasUrls && !hasCreateRouter) return;
             if (hasCreateRouter) {
+              const nestedRouterConflict = findNestedRouterConflict([
+                ...s.cachedRouterFiles ?? [],
+                resolve8(filePath)
+              ]);
+              if (nestedRouterConflict) {
+                server.config.logger.error(
+                  formatNestedRouterConflictError(nestedRouterConflict)
+                );
+                return;
+              }
               s.cachedRouterFiles = void 0;
             }
             scheduleRouteRegeneration();
@@ -4585,6 +4746,9 @@ ${err.stack}`
     async buildStart() {
       if (!s.isBuildMode) return;
       if (s.mergedRouteManifest !== null) return;
+      resetStagedBuildAssets(s.projectRoot);
+      s.prerenderManifestEntries = null;
+      s.staticManifestEntries = null;
       let tempServer = null;
       globalThis.__rscRouterDiscoveryActive = true;
       try {
@@ -4817,6 +4981,7 @@ async function rango(options) {
         serverHandler: false
       })
     );
+    plugins.push(clientRefDedup());
   } else {
     const nodeOptions = resolvedOptions;
     routerRef.path = nodeOptions.router;
@@ -4825,7 +4990,7 @@ async function rango(options) {
         name: "@rangojs/router:auto-discover",
         config(userConfig) {
           if (routerRef.path) return;
-          const root = userConfig.root ? resolve7(process.cwd(), userConfig.root) : process.cwd();
+          const root = userConfig.root ? resolve9(process.cwd(), userConfig.root) : process.cwd();
           const filter = createScanFilter(root, {
             include: resolvedOptions.include,
             exclude: resolvedOptions.exclude
@@ -4965,6 +5130,7 @@ ${list}`
         })
       );
     }
+    plugins.push(clientRefDedup());
   }
   plugins.push({
     name: "@rangojs/router:client-component-hmr",
@@ -5007,6 +5173,42 @@ ${list}`
   );
   return plugins;
 }
+
+// src/vite/plugins/refresh-cmd.ts
+function poke() {
+  return {
+    name: "vite-plugin-poke",
+    apply: "serve",
+    configureServer(server) {
+      const stdin = process.stdin;
+      const previousRawMode = stdin.isTTY ? stdin.isRaw : null;
+      if (stdin.isTTY) {
+        stdin.setRawMode(true);
+      }
+      const onData = (data) => {
+        if (data.length !== 1) return;
+        if (data[0] === 3) {
+          process.emit("SIGINT", "SIGINT");
+          return;
+        }
+        if (data[0] === 18) {
+          server.hot.send({ type: "full-reload", path: "*" });
+          server.config.logger.info("  browser reload (ctrl+r)", {
+            timestamp: true
+          });
+        }
+      };
+      stdin.on("data", onData);
+      server.httpServer?.on("close", () => {
+        stdin.off("data", onData);
+        if (stdin.isTTY && previousRawMode !== null) {
+          stdin.setRawMode(previousRawMode);
+        }
+      });
+    }
+  };
+}
 export {
+  poke,
   rango
 };