@rangojs/router 0.0.0-experimental.20 → 0.0.0-experimental.22

package/README.md

@@ -45,6 +45,30 @@ For Cloudflare Workers:
 npm install @cloudflare/vite-plugin
 ```
 
+## Import Paths
+
+Use these import paths consistently:
+
+- `@rangojs/router` — server/RSC router APIs, route DSL, `createRouter`, `urls`, `redirect`, `Prerender`, `Static`, shared types
+- `@rangojs/router/client` — hooks and components such as `Link`, `Outlet`, `href`, `useNavigation`, `useLoader`, `useAction`, `useLocationState`
+- `@rangojs/router/cache` — public cache APIs such as `CFCacheStore`, `MemorySegmentCacheStore`, `createDocumentCacheMiddleware`
+- `@rangojs/router/host`, `@rangojs/router/theme`, `@rangojs/router/vite` — specialized public subpaths
+- `@rangojs/router/rsc`, `@rangojs/router/ssr` — advanced server-only integration subpaths for custom request/HTML pipelines
+
+Use only subpaths that are explicitly exported from the package. Avoid deep imports such as `@rangojs/router/cache/cf`.
+
+`@rangojs/router` is conditionally resolved. Server-only root APIs such as
+`createRouter()`, `urls()`, `redirect()`, `Prerender()`, and `cookies()` rely on
+the `react-server` export condition and are meant to run in router definitions,
+handlers, and other RSC/server modules. Outside that environment the root entry
+falls back to stub implementations that throw guidance errors.
+
+If you hit a root-entrypoint stub error:
+
+- hooks and components like `Link`, `Outlet`, `useLoader`, `useNavigation`, and `MetaTags` belong in `@rangojs/router/client`
+- cache APIs like `CFCacheStore` and `createDocumentCacheMiddleware` belong in `@rangojs/router/cache`
+- host-router APIs belong in `@rangojs/router/host`
+
 ## Quick Start
 
 ### Vite Config
@@ -62,6 +86,9 @@ export default defineConfig({
 
 ### Router
 
+This file is a server/RSC module and should import router construction APIs from
+`@rangojs/router`.
+
 ```tsx
 // src/router.tsx
 import { createRouter, urls } from "@rangojs/router";
@@ -842,16 +869,22 @@ module, use `scopedReverse<typeof localPatterns>(ctx.reverse)` or
 
 ## Subpath Exports
 
-| Export                   | Description                                                                       |
-| ------------------------ | --------------------------------------------------------------------------------- |
-| `@rangojs/router`        | Core: `createRouter`, `urls`, `createLoader`, `Handler`, `Prerender`, `Meta`      |
-| `@rangojs/router/client` | Client: `Link`, `Outlet`, `href`, `useNavigation`, `useLoader`, `MetaTags`        |
-| `@rangojs/router/cache`  | Cache: `CFCacheStore`, `MemorySegmentCacheStore`, `createDocumentCacheMiddleware` |
-| `@rangojs/router/theme`  | Theme: `useTheme`, `ThemeProvider`, `ThemeScript`                                 |
-| `@rangojs/router/host`   | Host routing: `createHostRouter`, `defineHosts`                                   |
-| `@rangojs/router/vite`   | Vite plugin: `rango()`                                                            |
-| `@rangojs/router/server` | Server utilities                                                                  |
-| `@rangojs/router/build`  | Build utilities                                                                   |
+| Export                   | Description                                                                                              |
+| ------------------------ | -------------------------------------------------------------------------------------------------------- |
+| `@rangojs/router`        | Server/RSC core and shared types: `createRouter`, `urls`, `createLoader`, `Handler`, `Prerender`, `Meta` |
+| `@rangojs/router/client` | Client: `Link`, `Outlet`, `href`, `useNavigation`, `useLoader`, `MetaTags`                               |
+| `@rangojs/router/cache`  | Cache: `CFCacheStore`, `MemorySegmentCacheStore`, `createDocumentCacheMiddleware`                        |
+| `@rangojs/router/theme`  | Theme: `useTheme`, `ThemeProvider`, `ThemeScript`                                                        |
+| `@rangojs/router/host`   | Host routing: `createHostRouter`, `defineHosts`                                                          |
+| `@rangojs/router/vite`   | Vite plugin: `rango()`                                                                                   |
+| `@rangojs/router/rsc`    | Advanced server pipeline APIs: `createRSCHandler`, request-context access                                |
+| `@rangojs/router/ssr`    | Advanced SSR bridge APIs: `createSSRHandler`                                                             |
+| `@rangojs/router/server` | Internal build/runtime utilities for advanced integrations                                               |
+| `@rangojs/router/build`  | Build utilities                                                                                          |
+
+The root entrypoint is not a generic client/runtime barrel. If you need hooks
+or components, import from `@rangojs/router/client`; if you need cache or host
+APIs, use their dedicated subpaths.
 
 ## Examples
 

package/dist/vite/index.js

@@ -1,6 +1,6 @@
 // src/vite/rango.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 
 // src/vite/plugins/expose-action-id.ts
 import MagicString from "magic-string";
@@ -1745,7 +1745,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.20",
+  version: "0.0.0-experimental.22",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -3024,7 +3024,7 @@ function createCjsToEsmPlugin() {
 
 // src/vite/router-discovery.ts
 import { createServer as createViteServer } from "vite";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve8 } from "node:path";
 import { readFileSync as readFileSync6 } from "node:fs";
 
 // src/vite/plugins/virtual-stub-plugin.ts
@@ -3207,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,
@@ -3308,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, "\\$&");
 }
@@ -3386,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) {
@@ -3487,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();
@@ -3517,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(
@@ -3572,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`);
@@ -3583,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;
@@ -3620,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)`
@@ -3657,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`);
@@ -3674,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...`
@@ -3879,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)) {
@@ -3914,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)) {
@@ -3928,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}`
@@ -3975,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}`);
     }
   }
@@ -4025,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);
     }
   }
 }
@@ -4173,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"
@@ -4201,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
@@ -4215,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}`
@@ -4229,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(
@@ -4275,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(
@@ -4427,8 +4470,8 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
       if (globalThis.__rscRouterDiscoveryActive) return;
       s.devServer = server;
       let resolveDiscovery;
-      const discoveryPromise = new Promise((resolve9) => {
-        resolveDiscovery = resolve9;
+      const discoveryPromise = new Promise((resolve10) => {
+        resolveDiscovery = resolve10;
       });
       const getDevServerOrigin = () => server.resolvedUrls?.local?.[0]?.replace(/\/$/, "") || `http://localhost:${server.config.server.port || 5173}`;
       let prerenderTempServer = null;
@@ -4503,8 +4546,8 @@ ${err.stack}`
           resolveDiscovery();
         }
       };
-      s.discoveryDone = new Promise((resolve9) => {
-        setTimeout(() => discover().then(resolve9, resolve9), 0);
+      s.discoveryDone = new Promise((resolve10) => {
+        setTimeout(() => discover().then(resolve10, resolve10), 0);
       });
       let mainRegistry = null;
       const propagateDiscoveryState = async (rscEnv) => {
@@ -4673,7 +4716,7 @@ ${err.stack}`
             if (hasCreateRouter) {
               const nestedRouterConflict = findNestedRouterConflict([
                 ...s.cachedRouterFiles ?? [],
-                resolve7(filePath)
+                resolve8(filePath)
               ]);
               if (nestedRouterConflict) {
                 server.config.logger.error(
@@ -4703,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 {
@@ -4944,7 +4990,7 @@ async function rango(options) {
         name: "@rangojs/router:auto-discover",
         config(userConfig) {
           if (routerRef.path) return;
-          const root = userConfig.root ? resolve8(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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.0.0-experimental.20",
+  "version": "0.0.0-experimental.22",
   "description": "Django-inspired RSC router with composable URL patterns",
   "keywords": [
     "react",

package/skills/caching/SKILL.md

@@ -89,7 +89,7 @@ Configure a cache store in the router:
 
 ```typescript
 import { createRouter } from "@rangojs/router";
-import { MemorySegmentCacheStore } from "@rangojs/router/rsc";
+import { MemorySegmentCacheStore } from "@rangojs/router/cache";
 
 const store = new MemorySegmentCacheStore({
   defaults: { ttl: 60, swr: 300 },
@@ -112,7 +112,7 @@ const router = createRouter({
 For single-instance deployments:
 
 ```typescript
-import { MemorySegmentCacheStore } from "@rangojs/router/rsc";
+import { MemorySegmentCacheStore } from "@rangojs/router/cache";
 
 const store = new MemorySegmentCacheStore({
   defaults: { ttl: 60, swr: 300 },
@@ -125,7 +125,7 @@ const store = new MemorySegmentCacheStore({
 For distributed caching on Cloudflare Workers:
 
 ```typescript
-import { CFCacheStore } from "@rangojs/router/cache/cf";
+import { CFCacheStore } from "@rangojs/router/cache";
 
 const router = createRouter<AppBindings>({
   document: Document,
@@ -175,7 +175,7 @@ cache({ store: checkoutCache }, () => [
 
 ```typescript
 import { urls } from "@rangojs/router";
-import { MemorySegmentCacheStore } from "@rangojs/router/rsc";
+import { MemorySegmentCacheStore } from "@rangojs/router/cache";
 
 // Custom store for checkout (short TTL)
 const checkoutCache = new MemorySegmentCacheStore({

package/skills/document-cache/SKILL.md

@@ -14,7 +14,7 @@ Configure document cache in router:
 
 ```typescript
 import { createRouter } from "@rangojs/router";
-import { CFCacheStore } from "@rangojs/router/cache/cf";
+import { CFCacheStore } from "@rangojs/router/cache";
 import { urlpatterns } from "./urls";
 
 const router = createRouter<AppBindings>({
@@ -134,7 +134,7 @@ Segment hash ensures different cached responses for navigations from different s
 ```typescript
 // router.tsx
 import { createRouter } from "@rangojs/router";
-import { CFCacheStore } from "@rangojs/router/cache/cf";
+import { CFCacheStore } from "@rangojs/router/cache";
 import { urlpatterns } from "./urls";
 
 const router = createRouter<AppBindings>({