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

package/src/use-loader.tsx

@@ -1,9 +1,70 @@
 "use client";
 
-import { useCallback, useContext, useEffect, useRef, useState } from "react";
+import {
+  isValidElement,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react";
 import { OutletContext, type OutletContextValue } from "./outlet-context.js";
 import type { LoaderDefinition, LoadOptions } from "./types.js";
 
+/**
+ * Extract a specific loader's data from a content ReactNode.
+ *
+ * When a route registers loaders via loader(), the resolved data lives in
+ * the route's OutletProvider (rendered as <Outlet /> content). Parallel
+ * slots are siblings of <Outlet />, so they can't find it by walking
+ * the parent context chain. This helper traverses wrapper elements
+ * (MountContextProvider, ViewTransition, etc.) to reach the OutletProvider
+ * and extract the loader data directly.
+ */
+const NOT_FOUND = Symbol("not-found");
+
+function extractContentLoaderData(
+  node: ReactNode,
+  loaderId: string,
+): unknown | typeof NOT_FOUND {
+  if (!isValidElement(node)) return NOT_FOUND;
+  const props = node.props as Record<string, any> | undefined;
+  if (!props) return NOT_FOUND;
+
+  // Direct OutletProvider with loaderData
+  if (props.loaderData && loaderId in props.loaderData) {
+    return props.loaderData[loaderId];
+  }
+
+  // LoaderBoundary: loaderIds + loaderDataPromise (already resolved array).
+  // When the segment has loading(), loaderData is resolved inside
+  // LoaderBoundary via use(). If the promise was pre-awaited (forceAwait
+  // or isAction), the prop is a raw array we can index into.
+  if (
+    props.loaderIds &&
+    Array.isArray(props.loaderIds) &&
+    props.loaderDataPromise &&
+    !(props.loaderDataPromise instanceof Promise)
+  ) {
+    const idx = (props.loaderIds as string[]).indexOf(loaderId);
+    if (idx !== -1) {
+      const data = (props.loaderDataPromise as any[])[idx];
+      // loaderDataPromise entries may be { ok, data } result objects
+      if (data && typeof data === "object" && "ok" in data) {
+        return data.ok ? data.data : NOT_FOUND;
+      }
+      return data;
+    }
+  }
+
+  // Traverse into wrapper elements (MountContextProvider, ViewTransition,
+  // Suspense wrappers, etc.)
+  if (props.children) return extractContentLoaderData(props.children, loaderId);
+  return NOT_FOUND;
+}
+
 /**
  * Payload returned by loader RSC requests
  */
@@ -71,19 +132,27 @@ function useLoaderInternal<T>(
   const context = useContext(OutletContext);
 
   // Get data from context (SSR/navigation)
-  const getContextData = useCallback((): T | undefined => {
+  const contextData = useMemo((): T | undefined => {
     let current: OutletContextValue | null | undefined = context;
     while (current) {
       if (current.loaderData && loader.$$id in current.loaderData) {
         return current.loaderData[loader.$$id] as T;
       }
+      // Check content element — the route's OutletProvider is rendered as
+      // <Outlet /> content (a child), so its loaderData isn't in the parent
+      // chain. Parallel slots need to reach into it to find route-level loaders.
+      const contentData = extractContentLoaderData(
+        current.content,
+        loader.$$id,
+      );
+      if (contentData !== NOT_FOUND) {
+        return contentData as T;
+      }
       current = current.parent;
     }
     return undefined;
   }, [context, loader.$$id]);
 
-  const contextData = getContextData();
-
   // Local state for fetched data (from load() calls)
   const [fetchedData, setFetchedData] = useState<T | undefined>(undefined);
   const [isLoading, setIsLoading] = useState(false);

package/src/vite/discovery/bundle-postprocess.ts

@@ -6,9 +6,9 @@
  */
 
 import { resolve } from "node:path";
-import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { evictHandlerCode } from "../utils/bundle-analysis.js";
+import { copyStagedBuildAssets } from "../utils/prerender-utils.js";
 import type { DiscoveryState } from "./state.js";
 
 /**
@@ -17,11 +17,11 @@ import type { DiscoveryState } from "./state.js";
  */
 export function postprocessBundle(state: DiscoveryState): void {
   const hasPrerenderData =
-    state.prerenderCollectedData &&
-    Object.keys(state.prerenderCollectedData).length > 0;
+    state.prerenderManifestEntries &&
+    Object.keys(state.prerenderManifestEntries).length > 0;
   const hasStaticData =
-    state.staticCollectedData &&
-    Object.keys(state.staticCollectedData).length > 0;
+    state.staticManifestEntries &&
+    Object.keys(state.staticManifestEntries).length > 0;
   if (!hasPrerenderData && !hasStaticData) return;
 
   // Find RSC entry (recorded in generateBundle, fallback to dist/rsc/index.js)
@@ -31,25 +31,25 @@ export function postprocessBundle(state: DiscoveryState): void {
     state.rscEntryFileName ?? "index.js",
   );
 
-  // 1. Evict handler code from __prerender-handlers and __static-handlers chunks.
-  // handlerChunkInfo/staticHandlerChunkInfo are populated by generateBundle
+  // 1. Evict handler code from whichever chunks contain handler exports.
+  // handlerChunkInfoMap/staticHandlerChunkInfoMap are populated by generateBundle
   // after the production RSC build. In Vite 6 multi-environment builds, the
-  // RSC build runs twice (analysis + production). Chunk info is only available
-  // after the production pass, so we run eviction whenever it becomes available.
+  // RSC build runs twice (analysis + production). The maps are cleared at the
+  // start of each generateBundle pass so only production data is used here.
   const evictionTargets: Array<{
-    info: typeof state.handlerChunkInfo;
+    infos: Iterable<import("./state.js").ChunkInfo>;
     fnName: string;
     brand: string;
     label: string;
   }> = [
     {
-      info: state.handlerChunkInfo,
+      infos: state.handlerChunkInfoMap.values(),
       fnName: "Prerender",
       brand: "prerenderHandler",
       label: "handler code from RSC bundle",
     },
     {
-      info: state.staticHandlerChunkInfo,
+      infos: state.staticHandlerChunkInfoMap.values(),
       fnName: "Static",
       brand: "staticHandler",
       label: "static handler code",
@@ -57,70 +57,58 @@ export function postprocessBundle(state: DiscoveryState): void {
   ];
 
   for (const target of evictionTargets) {
-    if (!target.info) continue;
-    const chunkPath = resolve(
-      state.projectRoot,
-      "dist/rsc",
-      target.info.fileName,
-    );
-    try {
-      const code = readFileSync(chunkPath, "utf-8");
-      const result = evictHandlerCode(
-        code,
-        target.info.exports,
-        target.fnName,
-        target.brand,
-      );
-      if (result) {
-        writeFileSync(chunkPath, result.code);
-        const savedKB = (result.savedBytes / 1024).toFixed(1);
-        console.log(
-          `[rsc-router] Evicted ${target.label} (${savedKB} KB saved): ${target.info.fileName}`,
+    for (const info of target.infos) {
+      const chunkPath = resolve(state.projectRoot, "dist/rsc", info.fileName);
+      try {
+        const code = readFileSync(chunkPath, "utf-8");
+        const result = evictHandlerCode(
+          code,
+          info.exports,
+          target.fnName,
+          target.brand,
+        );
+        if (result) {
+          writeFileSync(chunkPath, result.code);
+          const savedKB = (result.savedBytes / 1024).toFixed(1);
+          console.log(
+            `[rsc-router] Evicted ${target.label} (${savedKB} KB saved): ${info.fileName}`,
+          );
+        }
+      } catch (replaceErr: any) {
+        console.warn(
+          `[rsc-router] Failed to evict ${target.label}: ${replaceErr.message}`,
         );
       }
-    } catch (replaceErr: any) {
-      console.warn(
-        `[rsc-router] Failed to evict ${target.label}: ${replaceErr.message}`,
-      );
     }
   }
-  state.handlerChunkInfo = null;
-  state.staticHandlerChunkInfo = null;
+  state.handlerChunkInfoMap.clear();
+  state.staticHandlerChunkInfoMap.clear();
 
   // 2. Write prerender data as separate importable asset modules
-  // and inject a manifest import into the RSC entry.
+  // and inject a lazy manifest loader into the RSC entry.
   if (hasPrerenderData && existsSync(rscEntryPath)) {
     const rscCode = readFileSync(rscEntryPath, "utf-8");
-    // Check for the specific injection marker, not just the variable name.
-    // The runtime code (prerender store) also references __PRERENDER_MANIFEST,
-    // so a broad string check would false-positive and skip injection.
+    // Check for the specific injection marker to avoid double-injection.
     if (!rscCode.includes("__prerender-manifest.js")) {
       try {
-        const assetsDir = resolve(state.projectRoot, "dist/rsc/assets");
-        mkdirSync(assetsDir, { recursive: true });
-
-        const manifestEntries: string[] = [];
-        let totalBytes = 0;
+        let totalBytes = copyStagedBuildAssets(
+          state.projectRoot,
+          Object.values(state.prerenderManifestEntries!),
+        );
 
-        for (const [key, entry] of Object.entries(
-          state.prerenderCollectedData!,
+        const manifestMap: Record<string, string> = {};
+        for (const [key, assetFileName] of Object.entries(
+          state.prerenderManifestEntries!,
         )) {
-          const entryJson = JSON.stringify(entry);
-          const contentHash = createHash("sha256")
-            .update(entryJson)
-            .digest("hex")
-            .slice(0, 8);
-          const assetFileName = `__pr-${contentHash}.js`;
-          const assetPath = resolve(assetsDir, assetFileName);
-          const assetCode = `export default ${entryJson};\n`;
-          writeFileSync(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;\n`;
+        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 = resolve(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js",
@@ -128,12 +116,12 @@ export function postprocessBundle(state: DiscoveryState): void {
         writeFileSync(manifestPath, manifestCode);
         totalBytes += Buffer.byteLength(manifestCode);
 
-        const injection = `import __pm from "./__prerender-manifest.js";\nglobalThis.__PRERENDER_MANIFEST = __pm;\n`;
+        const injection = `globalThis.__loadPrerenderManifestModule = () => import("./__prerender-manifest.js");\n`;
         writeFileSync(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: any) {
         throw new Error(
@@ -147,33 +135,17 @@ export function postprocessBundle(state: DiscoveryState): void {
   // and inject a __STATIC_MANIFEST import into the RSC entry.
   if (hasStaticData && existsSync(rscEntryPath)) {
     const rscCode = readFileSync(rscEntryPath, "utf-8");
-    if (!rscCode.includes("__STATIC_MANIFEST")) {
+    if (!rscCode.includes("__static-manifest.js")) {
       try {
-        const assetsDir = resolve(state.projectRoot, "dist/rsc/assets");
-        mkdirSync(assetsDir, { recursive: true });
-
         const manifestEntries: string[] = [];
-        let totalBytes = 0;
+        let totalBytes = copyStagedBuildAssets(
+          state.projectRoot,
+          Object.values(state.staticManifestEntries!),
+        );
 
-        for (const [handlerId, { encoded, handles }] of Object.entries(
-          state.staticCollectedData!,
+        for (const [handlerId, assetFileName] of Object.entries(
+          state.staticManifestEntries!,
         )) {
-          // Store both the Flight payload and handle data
-          const hasHandles = Object.keys(handles).length > 0;
-          const exportValue = hasHandles
-            ? JSON.stringify({ encoded, handles })
-            : JSON.stringify(encoded);
-          // Hash the full payload that is written so distinct handle
-          // snapshots produce distinct asset filenames.
-          const contentHash = createHash("sha256")
-            .update(exportValue)
-            .digest("hex")
-            .slice(0, 8);
-          const assetFileName = `__st-${contentHash}.js`;
-          const assetPath = resolve(assetsDir, assetFileName);
-          const assetCode = `export default ${exportValue};\n`;
-          writeFileSync(assetPath, assetCode);
-          totalBytes += Buffer.byteLength(assetCode);
           manifestEntries.push(
             `${JSON.stringify(handlerId)}:()=>import("./assets/${assetFileName}")`,
           );
@@ -197,7 +169,7 @@ export function postprocessBundle(state: DiscoveryState): void {
 
         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: any) {
         throw new Error(

package/src/vite/discovery/discover-routers.ts

@@ -6,7 +6,11 @@
  * router, and builds route tries for O(path_length) matching.
  */
 
-import { buildCombinedRouteMapForRouterFile } from "../../build/generate-route-types.js";
+import {
+  buildCombinedRouteMapForRouterFile,
+  formatNestedRouterConflictError,
+  findNestedRouterConflict,
+} from "../../build/generate-route-types.js";
 import {
   flattenLeafEntries,
   buildRouteToStaticPrefix,
@@ -44,9 +48,8 @@ export async function discoverRouters(
     // No RSC routers found directly. Check for host routers with lazy handlers
     // that need to be resolved to trigger sub-app createRouter() calls.
     try {
-      const hostMod = await rscEnv.runner.import("@rangojs/router/host");
       const hostRegistry: Map<string, any> | undefined =
-        hostMod.HostRouterRegistry;
+        serverMod.HostRouterRegistry;
 
       if (hostRegistry && hostRegistry.size > 0) {
         console.log(
@@ -85,7 +88,7 @@ export async function discoverRouters(
         }
       }
     } catch {
-      // @rangojs/router/host not available or import failed, skip
+      // Host-router discovery is best-effort; skip if unavailable
     }
 
     // If still no routers after host router resolution, fail
@@ -100,6 +103,17 @@ export async function discoverRouters(
   const buildMod = await rscEnv.runner.import("@rangojs/router/build");
   const generateManifestFull = buildMod.generateManifestFull;
 
+  const nestedRouterConflict = findNestedRouterConflict(
+    [...registry.values()]
+      .map((router) => router.__sourceFile)
+      .filter(
+        (sourceFile): sourceFile is string => typeof sourceFile === "string",
+      ),
+  );
+  if (nestedRouterConflict) {
+    throw new Error(formatNestedRouterConflictError(nestedRouterConflict));
+  }
+
   // Build into local variables first. Only commit to state after the
   // full pass succeeds, so a failed re-discovery preserves the last
   // known-good state instead of leaving it partially wiped.
@@ -121,7 +135,11 @@ export async function discoverRouters(
       continue;
     }
 
-    const manifest = generateManifestFull(router.urlpatterns, routerMountIndex);
+    const manifest = generateManifestFull(
+      router.urlpatterns,
+      routerMountIndex,
+      router.__basename ? { urlPrefix: router.__basename } : undefined,
+    );
     routerMountIndex++;
     allManifests.push({ id, manifest });
     const routeCount = Object.keys(manifest.routeManifest).length;

package/src/vite/discovery/prerender-collection.ts

@@ -13,12 +13,14 @@ import {
   runWithConcurrency,
   groupByConcurrency,
   notifyOnError,
+  stageBuildAssetModule,
 } from "../utils/prerender-utils.js";
 import type { DiscoveryState } from "./state.js";
 
 /**
  * Expand prerender routes into concrete URLs and render them via the
- * RSC runner. Stores collected data in state.prerenderCollectedData.
+ * RSC runner. Stages asset modules and stores key-to-file entries in
+ * state.prerenderManifestEntries.
  */
 export async function expandPrerenderRoutes(
   state: DiscoveryState,
@@ -52,11 +54,12 @@ export async function expandPrerenderRoutes(
   for (const { manifest } of allManifests) {
     if (!manifest.prerenderRoutes) continue;
     const defs = manifest._prerenderDefs || {};
+    const passthroughSet = new Set(manifest.passthroughRoutes || []);
     for (const routeName of manifest.prerenderRoutes) {
       const pattern = manifest.routeManifest[routeName];
       if (!pattern) continue;
       const def = defs[routeName];
-      const isPassthroughRoute = !!def?.options?.passthrough;
+      const isPassthroughRoute = passthroughSet.has(routeName);
       const hasDynamic = pattern.includes(":") || pattern.includes("*");
       if (!hasDynamic) {
         // Static route: use pattern directly (strip trailing slash for URL)
@@ -71,12 +74,21 @@ export async function expandPrerenderRoutes(
         if (def?.getParams) {
           try {
             const buildVars: Record<string, any> = {};
+            const buildEnv = state.resolvedBuildEnv;
             const getParamsCtx = {
               build: true as const,
+              dev: !state.isBuildMode,
               set: ((keyOrVar: any, value: any) => {
                 contextSet(buildVars, keyOrVar, value);
               }) as any,
               reverse: getParamsReverse,
+              get env() {
+                if (buildEnv !== undefined) return buildEnv;
+                throw new Error(
+                  "[rsc-router] ctx.env is not available during build-time getParams(). " +
+                    "Configure buildEnv in your rango() plugin options to enable build-time env access.",
+                );
+              },
             };
             const paramsList = await def.getParams(getParamsCtx);
             const concurrency = def.options?.concurrency ?? 1;
@@ -150,7 +162,7 @@ export async function expandPrerenderRoutes(
 
   const { hashParams } = await rscEnv.runner.import("@rangojs/router/build");
 
-  const collectedData: Record<string, any> = {};
+  const manifestEntries: Record<string, string> = {};
   let doneCount = 0;
   let skipCount = 0;
   const startTotal = performance.now();
@@ -173,6 +185,7 @@ export async function expandPrerenderRoutes(
               {},
               entry.buildVars,
               entry.isPassthroughRoute,
+              state.resolvedBuildEnv,
             );
             if (!result) continue;
 
@@ -187,18 +200,30 @@ export async function expandPrerenderRoutes(
             }
 
             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(
@@ -244,7 +269,7 @@ export async function expandPrerenderRoutes(
 
   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`);
@@ -256,7 +281,8 @@ export async function expandPrerenderRoutes(
 /**
  * Render Static handlers at build time. Each Static handler is called
  * with a synthetic BuildContext and its output is RSC-serialized.
- * Stores collected data in state.staticCollectedData.
+ * Stages asset modules and stores handlerId-to-file entries in
+ * state.staticManifestEntries.
  */
 export async function renderStaticHandlers(
   state: DiscoveryState,
@@ -270,10 +296,7 @@ export async function renderStaticHandlers(
   )
     return;
 
-  const collected: Record<
-    string,
-    { encoded: string; handles: Record<string, unknown[]> }
-  > = {};
+  const manifestEntries: Record<string, string> = {};
   let staticDone = 0;
   let staticSkip = 0;
   let totalStaticCount = 0;
@@ -314,9 +337,19 @@ export async function renderStaticHandlers(
             def.handler,
             def.$$id,
             (def as any).$$routePrefix,
+            state.resolvedBuildEnv,
+            !state.isBuildMode,
           );
           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)`,
@@ -355,7 +388,7 @@ export async function renderStaticHandlers(
 
   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`);

package/src/vite/discovery/state.ts

@@ -13,11 +13,13 @@ export const VIRTUAL_ROUTES_MANIFEST_ID = "virtual:rsc-router/routes-manifest";
 export interface PluginOptions {
   enableBuildPrerender?: boolean;
   staticRouteTypesGeneration?: boolean;
-  include?: string[];
-  exclude?: string[];
   // Mutable ref for deferred auto-discovery (node preset).
   // The auto-discover config() hook populates this before configResolved.
   routerPathRef?: { path?: string };
+  /** Build-time env option from rango() config. */
+  buildEnv?: import("../plugin-types.js").BuildEnvOption;
+  /** Deployment preset (needed for buildEnv "auto" resolution). */
+  preset?: "node" | "cloudflare";
 }
 
 export interface PrecomputedEntry {
@@ -56,13 +58,10 @@ export interface DiscoveryState {
   perRouterPrecomputedMap: Map<string, PrecomputedEntry[]>;
   perRouterManifestDataMap: Map<string, Record<string, string>>;
 
-  prerenderCollectedData: Record<string, any> | null;
-  staticCollectedData: Record<
-    string,
-    { encoded: string; handles: Record<string, unknown[]> }
-  > | null;
-  handlerChunkInfo: ChunkInfo | null;
-  staticHandlerChunkInfo: ChunkInfo | null;
+  prerenderManifestEntries: Record<string, string> | null;
+  staticManifestEntries: Record<string, string> | null;
+  handlerChunkInfoMap: Map<string, ChunkInfo>;
+  staticHandlerChunkInfoMap: Map<string, ChunkInfo>;
   rscEntryFileName: string | null;
   resolvedPrerenderModules: Map<string, string[]> | undefined;
   resolvedStaticModules: Map<string, string[]> | undefined;
@@ -72,6 +71,11 @@ export interface DiscoveryState {
   devServer: any;
   selfWrittenGenFiles: Map<string, { at: number; hash: string }>;
   SELF_WRITE_WINDOW_MS: number;
+
+  /** Resolved build-time env bindings (set during buildStart/configureServer). */
+  resolvedBuildEnv?: Record<string, unknown>;
+  /** Cleanup function for build-time env resources (e.g., miniflare). */
+  buildEnvDispose?: (() => Promise<void> | void) | null;
 }
 
 export function createDiscoveryState(
@@ -96,10 +100,10 @@ export function createDiscoveryState(
     perRouterPrecomputedMap: new Map(),
     perRouterManifestDataMap: new Map(),
 
-    prerenderCollectedData: null,
-    staticCollectedData: null,
-    handlerChunkInfo: null,
-    staticHandlerChunkInfo: null,
+    prerenderManifestEntries: null,
+    staticManifestEntries: null,
+    handlerChunkInfoMap: new Map(),
+    staticHandlerChunkInfoMap: new Map(),
     rscEntryFileName: null,
     resolvedPrerenderModules: undefined,
     resolvedStaticModules: undefined,

package/src/vite/index.ts

@@ -1,15 +1,20 @@
 /**
  * Public API for @rangojs/router/vite
  *
- * Only the rango() plugin factory and its option types are part of the
- * public API. All other utilities are internal implementation details
- * consumed via direct imports within the package.
+ * Exports: rango() plugin factory, poke() dev utility plugin,
+ * and related option types. All other utilities are internal implementation
+ * details consumed via direct imports within the package.
  */
 
 export { rango } from "./rango.js";
+export { poke } from "./plugins/refresh-cmd.js";
 
 export type {
   RangoNodeOptions,
   RangoCloudflareOptions,
   RangoOptions,
+  BuildEnvOption,
+  BuildEnvFactory,
+  BuildEnvFactoryContext,
+  BuildEnvResult,
 } from "./plugin-types.js";