@rangojs/router 0.0.0-experimental.d7eeaa75 → 0.0.0-experimental.d98a8e9d

package/src/vite/utils/ast-handler-extract.ts

@@ -48,7 +48,7 @@ function findImportInsertionPos(
 ): number {
   let program: ProgramNode;
   try {
-    program = parseAst(code, { jsx: true });
+    program = parseAst(code, { lang: "tsx" });
   } catch {
     return 0;
   }
@@ -127,7 +127,7 @@ export function findHandlerCalls(
 ): HandlerCallSite[] {
   let program: ProgramNode;
   try {
-    program = parseAst(code, { jsx: true });
+    program = parseAst(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -239,7 +239,7 @@ export function getImportedLocalNames(
   parseAst: (code: string, options?: any) => ProgramNode,
 ): Set<string> {
   try {
-    const program = parseAst(code, { jsx: true });
+    const program = parseAst(code, { lang: "tsx" });
     return getImportedLocalNamesFromProgram(program, importedName);
   } catch {
     return new Set<string>();
@@ -256,7 +256,7 @@ export function extractImportDeclarations(
 ): string[] {
   let program: ProgramNode;
   try {
-    program = parseAst(code, { jsx: true });
+    program = parseAst(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -380,7 +380,7 @@ export function extractModuleLevelDeclarations(
 ): string[] {
   let program: ProgramNode;
   try {
-    program = parseAst(code, { jsx: true });
+    program = parseAst(code, { lang: "tsx" });
   } catch {
     return [];
   }
@@ -468,19 +468,19 @@ export function transformInlineHandlers(
     handlerNames,
   );
 
-  // Track line occurrences for same-line collision handling
-  const lineCounts = new Map<number, number>();
-
   // Collect all import statements to prepend
   const importStatements: string[] = [];
 
-  for (const site of inlineSites) {
-    const lineCount = lineCounts.get(site.lineNumber) ?? 0;
-    lineCounts.set(site.lineNumber, lineCount + 1);
-
-    const hash = hashInlineId(filePath, site.lineNumber, lineCount);
+  for (const [siteIndex, site] of inlineSites.entries()) {
+    // Key the extracted handler on its source-order index (per fnName), NOT its
+    // line number. The id flows into BOTH the export name and the virtual module
+    // path (which hashId hashes for the runtime $$id), and line numbers shift
+    // between the prerender and production build contexts. The index is invariant
+    // to those shifts, keeping the prerender manifest key == the runtime id.
+    const hash = hashInlineId(filePath, fnName, siteIndex);
     const exportName = `__sh_${hash}`;
-    const virtualId = `\0${virtualPrefix}${filePath}:${site.lineNumber}${lineCount > 0 ? `:${lineCount}` : ""}`;
+    const idSuffix = `${filePath}:${fnName}:${siteIndex}`;
+    const virtualId = `\0${virtualPrefix}${idSuffix}`;
 
     // Extract the full handler call expression text
     const handlerCode = code.slice(site.callStart, site.callEnd);
@@ -498,7 +498,7 @@ export function transformInlineHandlers(
     s.overwrite(site.callStart, site.callEnd, exportName);
 
     // Build the import specifier for this virtual module
-    const importId = `${virtualPrefix}${filePath}:${site.lineNumber}${lineCount > 0 ? `:${lineCount}` : ""}`;
+    const importId = `${virtualPrefix}${idSuffix}`;
     importStatements.push(`import { ${exportName} } from "${importId}";`);
   }
 

package/src/vite/utils/banner.ts

@@ -1,4 +1,4 @@
-import packageJson from "../../../package.json" with { type: "json" };
+import packageJson from "../../../package.json";
 
 export const rangoVersion: string = packageJson.version;
 

package/src/vite/utils/bundle-analysis.ts

@@ -59,7 +59,7 @@ export function extractHandlerExportsFromChunk(
       if (detectPassthrough) {
         const eFnName = escapeRegExp(fnName);
         const callStartRe = new RegExp(
-          `const\\s+${eName}\\s*=\\s*${eFnName}\\s*(?:<[^>]*>)?\\s*\\(`,
+          `(?:const|let|var)\\s+${eName}\\s*=\\s*${eFnName}\\s*(?:<[^>]*>)?\\s*\\(`,
         );
         const callStart = callStartRe.exec(chunkCode);
         if (callStart) {
@@ -98,8 +98,10 @@ export function evictHandlerCode(
     if (passthrough) continue;
 
     const eName = escapeRegExp(name);
+    // Match const/let/var: Rolldown (Vite 8) emits top-level bindings in the
+    // non-minified RSC bundle as `var`, whereas Rollup used `const`.
     const callStartRe = new RegExp(
-      `const\\s+${eName}\\s*=\\s*${eFnName}\\s*(?:<[^>]*>)?\\s*\\(`,
+      `(?:const|let|var)\\s+${eName}\\s*=\\s*${eFnName}\\s*(?:<[^>]*>)?\\s*\\(`,
     );
     const startMatch = callStartRe.exec(modified);
     if (!startMatch) continue;

package/src/vite/utils/client-chunks.ts

@@ -0,0 +1,190 @@
+// Resolution of the public `clientChunks` option into the callback shape that
+// @vitejs/plugin-rsc expects. See plugin-types.ts (ClientChunks) and
+// docs/client-chunking.md for the contract. The mechanism: a distinct returned
+// name yields a distinct, dynamically-imported client chunk, independent of how
+// the RSC/server build chunked the importing modules.
+
+import type { ClientChunkMeta, ClientChunks } from "../plugin-types.js";
+import { createRangoDebugger, NS } from "../debug.js";
+import { hashRefKey } from "../plugins/client-ref-hashing.js";
+
+/** The callback shape @vitejs/plugin-rsc's `clientChunks` option accepts. */
+export type RscClientChunksFn = (meta: ClientChunkMeta) => string | undefined;
+
+/**
+ * Build-time context the discovery pass populates and the built-in strategy
+ * reads. It refines how the catch-all (no route-root marker) modules are grouped
+ * without touching marker splits or the shared runtime:
+ *
+ * - `fallbackRefs`: production hashes of the `"use client"` modules a consumer
+ *   registered as `errorBoundary`/`notFoundBoundary` fallbacks. Pulled into a
+ *   dedicated `app-fallback` chunk so the error UI is not co-bundled with the
+ *   very route code it exists to catch failures for (resilience), and so the
+ *   chunk it would otherwise sit in gets named after a real module rather than
+ *   the boundary. Populated by reading each fallback element's client-reference
+ *   `$$id` during discovery (see discover-routers).
+ */
+export interface ClientChunkContext {
+  fallbackRefs: Set<string>;
+}
+
+/**
+ * Opt-in observability for the built-in strategy. The route-root marker list is
+ * intentionally finite (see {@link ROUTE_ROOT_DIRS}); a consumer whose layout
+ * has no recognized marker (e.g. `src/parts/<feature>/…`) silently inherits the
+ * default grouping (no per-route split). That silence is the only real downside
+ * of a convention-based default, so we make the decision observable: run a build
+ * with `DEBUG=rango:chunks` to see, per client module, which route group it was
+ * assigned to or why it fell back to the shared grouping. Zero cost when off
+ * (the debugger is `undefined` unless the namespace is enabled). For full control
+ * over any layout, pass a `clientChunks` function instead of relying on the
+ * convention — that is the supported configurability path, not widening the list.
+ */
+const debugChunks = createRangoDebugger(NS.chunks);
+
+/**
+ * Modules that must stay on the default (shared) grouping regardless of strategy:
+ * React, the router client runtime, and anything in node_modules. Splitting these
+ * out per route would fragment the shared baseline and regress cache reuse — they
+ * are loaded on every route, so they belong in shared chunks.
+ *
+ * The Rango runtime is matched by package root only: `@rangojs/router` (the
+ * installed/aliased name) and the workspace `packages/(rangojs-router|rsc-router)/(src|dist)/`.
+ * The `(src|dist)` anchor matches the package's own source/build output but NOT
+ * consumer apps that merely live under a `packages/rangojs-router/` ancestor (the
+ * in-repo e2e apps), so their app components remain splittable. We deliberately do
+ * NOT match a bare `/src/browser/`: that is a consumer-owned path (a consumer's own
+ * `src/browser/Foo.tsx` must still split).
+ *
+ * We test BOTH `meta.id` (absolute) and `meta.normalizedId`. `normalizedId` is the
+ * project-root-relative form plugin-rsc derives (e.g. `../../src/browser/react/Link.tsx`
+ * for the in-repo runtime), which the package-root patterns miss; the absolute `id`
+ * always contains the package's real location, so it reliably catches the runtime.
+ */
+function isSharedRuntime(meta: ClientChunkMeta): boolean {
+  return [meta.id, meta.normalizedId].some(
+    (path) =>
+      path.includes("/node_modules/") ||
+      /\/@rangojs\/router\//.test(path) ||
+      /\/packages\/(rangojs-router|rsc-router)\/(src|dist)\//.test(path),
+  );
+}
+
+/** Sanitize a raw group name into a filesystem/Rollup-safe chunk name fragment. */
+function sanitizeGroup(name: string): string {
+  return name.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "app";
+}
+
+/**
+ * Directory names that conventionally hold one sub-directory per route/feature.
+ * When a `"use client"` module lives under one of these, the built-in strategy
+ * keys the chunk on the segment IMMEDIATELY AFTER the marker (the route id),
+ * rather than the module's immediate parent directory. This is what keeps
+ * `routes/foo/components/Button.tsx` and `routes/bar/components/Button.tsx` in
+ * `app-foo` / `app-bar` instead of colliding in a single `app-components`.
+ *
+ * Route identity lives in the path PREFIX; the immediate parent (a suffix) is
+ * only a reliable proxy for the un-nested `routes/<route>/Widget.tsx` layout.
+ */
+const ROUTE_ROOT_DIRS = new Set([
+  "routes",
+  "route",
+  "pages",
+  "page",
+  "app",
+  "features",
+  "feature",
+  "views",
+  "view",
+  "handlers",
+  "urls",
+  "modules",
+  "screens",
+  "sections",
+]);
+
+/**
+ * Built-in strategy used when `clientChunks: true` (also the default). Splits app
+ * client components by route/feature identity ONLY where it can recognize a route
+ * structure; everywhere else it inherits the default grouping (returns undefined).
+ * This conservatism is what makes it safe as a default:
+ *
+ * - A recognized route structure (`routes/<id>/…`, `app/<id>/…`, `handlers/<id>/…`
+ *   etc.) splits into a per-route chunk `app-<id>`, at any nesting depth.
+ * - A flat `src/components/Button.tsx`, or host sub-apps already split by a dynamic
+ *   `import()` boundary (each app's `serverChunk` differs), get `undefined` and so
+ *   keep `@vitejs/plugin-rsc`'s default `serverChunk` grouping — i.e. NO change
+ *   versus not enabling the option. Returning a parent-dir name here would instead
+ *   merge unrelated modules (e.g. every host app's `components/Layout.tsx` into one
+ *   `app-components`), re-introducing cross-app leakage.
+ *
+ * Resolution order:
+ * 1. Shared runtime (React / router / node_modules) -> `undefined` (never split).
+ * 2. A registered error/notFound fallback (`ctx.fallbackRefs`) -> `app-fallback`,
+ *    regardless of location, so the error UI is decoupled from the happy path.
+ * 3. A {@link ROUTE_ROOT_DIRS} marker with a directory after it -> key on that
+ *    next segment (the route id), robust to any nesting depth.
+ * 4. Otherwise `undefined` (inherit the default `serverChunk` grouping).
+ */
+export function directoryClientChunks(
+  meta: ClientChunkMeta,
+  ctx?: ClientChunkContext,
+): string | undefined {
+  if (isSharedRuntime(meta)) {
+    // React / router runtime / node_modules: always shared, expected, uninteresting.
+    return undefined;
+  }
+  // Registered error/notFound fallbacks -> a dedicated chunk. The error UI must
+  // not co-bundle with the code it catches failures for, and removing it lets the
+  // chunk it would otherwise anchor be named after a real module, not the boundary.
+  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; // exclude the filename
+  if (dirCount >= 1) {
+    // Route-root marker -> the segment after it is the route id. First marker
+    // wins, so a top-level route owns its whole subtree. The `< dirCount - 1`
+    // bound guarantees the segment after the marker is a directory, not the file.
+    for (let i = 0; i < dirCount - 1; i++) {
+      if (ROUTE_ROOT_DIRS.has(segments[i].toLowerCase())) {
+        const group = `app-${sanitizeGroup(segments[i + 1])}`;
+        debugChunks?.("split %s -> %s", meta.normalizedId, group);
+        return group;
+      }
+    }
+  }
+  // No recognized route structure -> inherit the default serverChunk grouping.
+  // This is the actionable "silent" case: app code that did NOT split by route.
+  // Surface it (under DEBUG=rango:chunks) so a consumer can see their layout
+  // missed the convention and either colocate under a marker dir or pass a fn.
+  debugChunks?.(
+    "shared %s (no route-root marker; inherits default grouping)",
+    meta.normalizedId,
+  );
+  return undefined;
+}
+
+/**
+ * Resolve a Rango `clientChunks` option into a @vitejs/plugin-rsc `clientChunks`
+ * callback, or `undefined` to leave plugin-rsc on its default (serverChunk)
+ * grouping.
+ *
+ * - `false` / `undefined` -> `undefined` (no override).
+ * - `true`               -> the built-in {@link directoryClientChunks} strategy,
+ *   bound to the discovery-populated {@link ClientChunkContext} (fallback chunk).
+ * - function             -> the user's function, used verbatim (full control; the
+ *   fallback refinement does not apply — the consumer owns the grouping).
+ */
+export function resolveClientChunks(
+  option: ClientChunks | undefined,
+  ctx?: ClientChunkContext,
+): RscClientChunksFn | undefined {
+  if (!option) return undefined;
+  if (option === true) return (meta) => directoryClientChunks(meta, ctx);
+  return option;
+}

package/src/vite/utils/forward-user-plugins.ts

@@ -0,0 +1,193 @@
+/**
+ * Discovery Runner Config Parity
+ *
+ * The discovery temp server (createTempRscServer) runs the user's handler
+ * graph through a throwaway Node Vite server built with `configFile: false`.
+ * Without help, that server only sees a fixed Rango-owned plugin set, so any
+ * user resolution is absent during discovery, prerender, and static handler
+ * rendering — even though it applies at request time. Two flavors of user
+ * resolution must be carried across:
+ *
+ * - Third-party resolveId plugins (e.g. vite-tsconfig-paths) — forwarded as
+ *   plugin instances, see selectForwardableResolvePlugins.
+ * - Native config-driven resolution, including Vite 8's built-in
+ *   `resolve.tsconfigPaths` (which supersedes vite-tsconfig-paths) — forwarded
+ *   as the data slice, see pickForwardedRunnerConfig.
+ *
+ * These helpers extract the resolution-relevant slice of the user's resolved
+ * config (resolve.*, define, oxc) and forward the user's resolution plugins
+ * into the temp server so discovery resolves modules the same way the real
+ * environment does.
+ */
+
+import type { Plugin, ResolvedConfig, UserConfig } from "vite";
+
+/**
+ * Whether a user plugin must NOT be forwarded into the discovery temp server.
+ *
+ * Framework-owned plugins are matched precisely -- by exact name or a
+ * namespaced prefix -- rather than by a loose substring/word prefix, so an
+ * unrelated user resolver named e.g. `rsc-paths` or `cloudflare-kv-alias` is
+ * still forwarded (it would otherwise reproduce issue #500).
+ *
+ * - `vite:*`               Vite core + official plugins (incl.
+ *                          @vitejs/plugin-react's `vite:react-*`). The temp
+ *                          server already provides its own core; forwarding
+ *                          these would duplicate or conflict with it.
+ * - `rsc` / `rsc:*`        @vitejs/plugin-rsc. createTempRscServer instantiates
+ *                          its own rsc() plugin; forwarding would duplicate it.
+ *                          Matched exactly (`rsc`) or by the `rsc:` namespace --
+ *                          NOT every `rsc`-prefixed name.
+ * - `@rangojs/router*`     Our own plugins. The discovery plugin spawns the
+ *                          temp server, so forwarding would recurse infinitely.
+ * - `@cloudflare/vite-plugin*` / @cloudflare/vite-plugin (emits the scoped
+ *   `vite-plugin-cloudflare*`  `@cloudflare/vite-plugin` and unscoped
+ *                          `vite-plugin-cloudflare` / `vite-plugin-cloudflare:*`).
+ *                          Forwarding re-inits workerd, defeating the Node temp
+ *                          server. Matched specifically so a scoped user resolver
+ *                          like `@cloudflare/kv-alias` is still forwarded.
+ */
+function isDenied(name: string): boolean {
+  return (
+    name.startsWith("vite:") ||
+    name === "rsc" ||
+    name.startsWith("rsc:") ||
+    name.startsWith("@rangojs/router") ||
+    name.startsWith("@cloudflare/vite-plugin") ||
+    name.startsWith("vite-plugin-cloudflare")
+  );
+}
+
+/**
+ * A plugin participates in resolution if it exposes `resolveId` or `load`.
+ * Plugins that only transform, configure the server, or hook into the build
+ * lifecycle do not affect how bare specifiers resolve, so we skip them to keep
+ * the forwarded surface minimal.
+ */
+function hasResolutionHooks(p: Plugin): boolean {
+  return Boolean((p as any).resolveId || (p as any).load);
+}
+
+/**
+ * Strip a resolved plugin instance down to its resolution hooks plus the
+ * gating fields that decide whether/where it runs.
+ *
+ * We reuse the SAME instance objects captured from `config.plugins`. By the
+ * time `configResolved` fires on the discovery plugin, every plugin's own
+ * `config`/`configResolved` has already run on the main server, so any state
+ * a `resolveId` hook depends on (e.g. vite-tsconfig-paths' compiled path
+ * matcher, held in closure) is already populated. Forwarding only the
+ * resolution hooks therefore preserves correct resolution while avoiding a
+ * second `buildStart`/`configureServer`/`config` lifecycle in the temp server.
+ *
+ * `enforce` and `applyToEnvironment` are preserved so ordering and per-environment
+ * gating match the real pipeline.
+ *
+ * `apply` is intentionally dropped. Vite filters plugins by `apply` against the
+ * command during config resolution, so the `config.plugins` we read here is
+ * already command-filtered by the main server (build: `apply: "build"` +
+ * unconditional; dev: `apply: "serve"` + unconditional). The discovery temp
+ * server is always created with `createServer` (`command === "serve"`), so a
+ * forwarded `apply: "build"` plugin would be filtered straight back out -- even
+ * during a production build, where build-only resolvers are exactly what
+ * static/prerender rendering needs. Since the source list is already correct for
+ * the current command, the forwarded copy must carry no `apply` gate.
+ */
+function stripToResolutionHooks(p: Plugin): Plugin {
+  const stripped: Plugin = { name: p.name };
+  if ((p as any).enforce) (stripped as any).enforce = (p as any).enforce;
+  if ((p as any).applyToEnvironment)
+    (stripped as any).applyToEnvironment = (p as any).applyToEnvironment;
+  if ((p as any).resolveId) (stripped as any).resolveId = (p as any).resolveId;
+  if ((p as any).load) (stripped as any).load = (p as any).load;
+  return stripped;
+}
+
+/**
+ * Pick the user's resolution plugins from the resolved plugin list, denylist
+ * framework-owned plugins, keep only those with resolution hooks, and strip
+ * each to its resolution surface. Returns plugin objects safe to drop into the
+ * discovery temp server's `plugins` array.
+ */
+export function selectForwardableResolvePlugins(
+  plugins: readonly Plugin[] | undefined,
+): Plugin[] {
+  if (!plugins) return [];
+  const forwarded: Plugin[] = [];
+  for (const p of plugins) {
+    const name = p?.name;
+    if (!name || isDenied(name)) continue;
+    if (!hasResolutionHooks(p)) continue;
+    forwarded.push(stripToResolutionHooks(p));
+  }
+  return forwarded;
+}
+
+/**
+ * The resolution-relevant slice of the user's resolved config that is plain
+ * data (no plugin re-execution): everything under `resolve` that influences
+ * how specifiers map to files, plus `define` and `oxc` so transforms and
+ * compile-time constants match request time.
+ */
+export interface ForwardedRunnerConfig {
+  resolve: UserConfig["resolve"];
+  define: UserConfig["define"];
+  oxc: UserConfig["oxc"];
+}
+
+/**
+ * Extract the data-only config slice to mirror into the discovery temp server.
+ * `alias` is included here so callers no longer need to thread it separately.
+ *
+ * `tsconfigPaths` is forwarded so Vite 8's native tsconfig `paths` resolution
+ * (a top-level `resolve` flag, off by default) reaches the temp server. The
+ * server is created with `configFile: false` and an explicit, allowlisted
+ * resolve slice, so a flag that is not copied here is simply absent during
+ * discovery — which would make path-aliased imports fail at prerender/static
+ * time the same way unforwarded resolveId plugins did (issue #500).
+ *
+ * `oxc` keeps the user's options but always pins the RSC-required JSX runtime
+ * (automatic, react), since the temp server compiles the handler graph as
+ * React server components regardless of the user's app-level JSX config. Vite 8
+ * replaced the deprecated `esbuild` transform option with `oxc`, so we read and
+ * forward `oxc` exclusively — no `esbuild` field is touched.
+ */
+export function pickForwardedRunnerConfig(
+  config: ResolvedConfig,
+): ForwardedRunnerConfig {
+  const r = config.resolve ?? ({} as ResolvedConfig["resolve"]);
+  const resolve: NonNullable<UserConfig["resolve"]> = {};
+  if (r.alias !== undefined) resolve.alias = r.alias as any;
+  if (r.dedupe !== undefined) resolve.dedupe = r.dedupe;
+  if (r.conditions !== undefined) resolve.conditions = r.conditions;
+  if (r.mainFields !== undefined) resolve.mainFields = r.mainFields;
+  if (r.extensions !== undefined) resolve.extensions = r.extensions;
+  if (r.preserveSymlinks !== undefined)
+    resolve.preserveSymlinks = r.preserveSymlinks;
+  if (r.tsconfigPaths !== undefined) resolve.tsconfigPaths = r.tsconfigPaths;
+
+  // Pin the RSC JSX runtime on top of the user's oxc options. The user's
+  // jsx sub-options (e.g. `development`) are preserved when present; only
+  // `runtime`/`importSource` are forced to the values the RSC compile needs.
+  const userOxc = config.oxc;
+  const userJsx =
+    userOxc &&
+    typeof userOxc === "object" &&
+    typeof userOxc.jsx === "object" &&
+    userOxc.jsx !== null
+      ? userOxc.jsx
+      : {};
+  const oxc: UserConfig["oxc"] =
+    userOxc && typeof userOxc === "object"
+      ? {
+          ...userOxc,
+          jsx: { ...userJsx, runtime: "automatic", importSource: "react" },
+        }
+      : { jsx: { runtime: "automatic", importSource: "react" } };
+
+  return {
+    resolve,
+    define: config.define,
+    oxc,
+  };
+}

package/src/vite/utils/manifest-utils.ts

@@ -1,62 +1,11 @@
-/**
- * Flatten prefix tree leaf nodes into precomputed route entries.
- * Leaf nodes have no children (no nested includes), so their routes can be
- * used directly by evaluateLazyEntry() without running the handler.
- * Non-leaf nodes are skipped because they have nested lazy includes that
- * require the handler to run for discovery.
- */
-export function flattenLeafEntries(
-  prefixTree: Record<string, any>,
-  routeManifest: Record<string, string>,
-  result: Array<{ staticPrefix: string; routes: Record<string, string> }>,
-): void {
-  function visit(node: any): void {
-    const children = node.children || {};
-    if (
-      Object.keys(children).length === 0 &&
-      node.routes &&
-      node.routes.length > 0
-    ) {
-      // Leaf node: collect its routes from the manifest
-      const routes: Record<string, string> = {};
-      for (const name of node.routes) {
-        if (name in routeManifest) {
-          routes[name] = routeManifest[name];
-        }
-      }
-      result.push({ staticPrefix: node.staticPrefix, routes });
-    } else {
-      // Non-leaf: recurse into children
-      for (const child of Object.values(children)) {
-        visit(child);
-      }
-    }
-  }
-  for (const node of Object.values(prefixTree)) {
-    visit(node);
-  }
-}
-
-/**
- * Walk prefix tree to map each route name to its scope's staticPrefix.
- */
-export function buildRouteToStaticPrefix(
-  prefixTree: Record<string, any>,
-  result: Record<string, string>,
-): void {
-  function visit(node: any): void {
-    const sp = node.staticPrefix || "";
-    for (const name of node.routes || []) {
-      result[name] = sp;
-    }
-    for (const child of Object.values(node.children || {})) {
-      visit(child);
-    }
-  }
-  for (const node of Object.values(prefixTree)) {
-    visit(node);
-  }
-}
+// Pure prefix-tree walks live in the build layer so runtime code can consume
+// them without importing from vite/. Re-exported here for the vite-side
+// callers (discover-routers, virtual-module-codegen) that already import them
+// from this module.
+export {
+  flattenLeafEntries,
+  buildRouteToStaticPrefix,
+} from "../../build/prefix-tree-utils.js";
 
 /**
  * Wrap a value as `JSON.parse('...')` instead of a JS object literal.

package/src/vite/utils/package-resolution.ts

@@ -6,8 +6,11 @@
  */
 
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { resolve } from "node:path";
-import packageJson from "../../../package.json" with { type: "json" };
+import packageJson from "../../../package.json";
+
+const require = createRequire(import.meta.url);
 
 /**
  * The canonical name used in virtual entries (without scope)
@@ -119,3 +122,40 @@ export function getPackageAliases(): Record<string, string> {
 
   return aliases;
 }
+
+/**
+ * Plugin-rsc pushes bare specs like
+ * `@vitejs/plugin-rsc/vendor/react-server-dom/client.edge` into
+ * `optimizeDeps.include` for the ssr and rsc environments. In strict pnpm
+ * consumer apps, `@vitejs/plugin-rsc` is only reachable from @rangojs/router's
+ * node_modules, so Vite's optimizer — which resolves from the project root —
+ * can't find them and emits "Failed to resolve dependency" warnings.
+ *
+ * We resolve those specs from this plugin's location (where plugin-rsc is
+ * guaranteed to be installed as our dep) and expose them as `resolve.alias`
+ * entries. The optimizer's resolver honors aliases, so the bare specs map to
+ * absolute paths and resolve cleanly.
+ */
+export function getVendorAliases(): Record<string, string> {
+  // client.browser is intentionally NOT aliased. plugin-rsc injects it into
+  // the client env's optimizeDeps.include; Vite's manual-include path resolves
+  // and pre-bundles regardless of optimizeDeps.exclude, so aliasing would
+  // trigger esbuild pre-bundling of the CJS vendor file and bypass the
+  // cjs-to-esm transform that patches `require('react'|'react-dom')` into
+  // real ESM imports. The consumer may still see a single "Failed to resolve"
+  // warning for client.browser; runtime resolution from plugin-rsc's own
+  // importer works because Vite resolves relative to the importer (not root).
+  const specs = [
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge",
+  ];
+  const aliases: Record<string, string> = {};
+  for (const spec of specs) {
+    try {
+      aliases[spec] = require.resolve(spec);
+    } catch {
+      // Spec unresolvable (unexpected but non-fatal — Vite will warn as before).
+    }
+  }
+  return aliases;
+}

package/src/vite/utils/prerender-utils.ts

@@ -41,14 +41,29 @@ export function substituteRouteParams(
   let result = pattern;
   let hadOmittedOptional = false;
 
-  // First pass: substitute provided params
+  // First pass: substitute provided params.
+  // Empty string on an optional placeholder is treated as omitted —
+  // caller-supplied params or `getParams()` shapes may pass `""` for an
+  // absent optional, so letting the second pass strip them keeps slash
+  // cleanup consistent. Empty string on required `:key` or wildcard
+  // `*key` still substitutes, matching prior behaviour.
   for (const [key, value] of Object.entries(params)) {
     const escaped = escapeRegExp(key);
-    result = result.replace(
-      new RegExp(`:${escaped}(\\([^)]*\\))?\\??`),
-      encode(value),
-    );
-    result = result.replace(`*${key}`, encode(value));
+    if (value === "") {
+      // Only replace required placeholders (negative lookahead for `?`);
+      // leave `:key?` for the second pass.
+      result = result.replace(
+        new RegExp(`:${escaped}(\\([^)]*\\))?(?!\\?)`),
+        "",
+      );
+      result = result.replace(`*${key}`, "");
+    } else {
+      result = result.replace(
+        new RegExp(`:${escaped}(\\([^)]*\\))?\\??`),
+        encode(value),
+      );
+      result = result.replace(`*${key}`, encode(value));
+    }
   }
 
   // Second pass: strip remaining optional param placeholders not in params