@rangojs/router 0.0.0-experimental.124 → 0.0.0-experimental.126

package/dist/vite/index.js

@@ -431,7 +431,6 @@ function exposeActionId() {
         counterTransform?.record(id, performance.now() - start);
       }
     },
-    // Build mode: renderChunk runs after all transforms and bundling complete
     renderChunk(code, chunk) {
       const start = counterRender ? performance.now() : 0;
       try {
@@ -1345,6 +1344,7 @@ ${lazyImports.join(",\n")}
     // --------------- Loader pre-scan (build mode) ---------------
     async buildStart() {
       if (!isBuild) return;
+      if (this.environment && this.environment.name !== "rsc") return;
       const fs2 = await import("node:fs/promises");
       const SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage"]);
       async function scanDir(dir) {
@@ -1841,7 +1841,7 @@ function useCacheTransform() {
   };
 }
 function transformFileLevelUseCache(code, ast, filePath, sourceId, isBuild, isLayoutOrTemplate, transformWrapExport) {
-  const nonFunctionExports = [];
+  const unconfirmedExports = [];
   const { exportNames, output } = transformWrapExport(code, ast, {
     runtime: (value, name) => {
       const funcId = isBuild ? hashId(filePath, name) : `${filePath}#${name}`;
@@ -1850,16 +1850,17 @@ function transformFileLevelUseCache(code, ast, filePath, sourceId, isBuild, isLa
     rejectNonAsyncFunction: false,
     filter: (name, meta) => {
       if (name === "default" && isLayoutOrTemplate) return false;
-      if (meta.isFunction === false) {
-        nonFunctionExports.push(name);
+      if (meta.isFunction !== true) {
+        unconfirmedExports.push(name);
         return false;
       }
       return true;
     }
   });
-  if (nonFunctionExports.length > 0) {
+  if (unconfirmedExports.length > 0) {
+    const plural = unconfirmedExports.length > 1;
     throw new Error(
-      `[rango:use-cache] File-level "use cache" in ${sourceId} cannot wrap non-function export${nonFunctionExports.length > 1 ? "s" : ""}: ${nonFunctionExports.map((n) => `"${n}"`).join(", ")}. Only function exports can be cached. Either remove "use cache" from the file level and add it inside individual functions, or move the non-function exports to a separate module.`
+      `[rango:use-cache] File-level "use cache" in ${sourceId} only wraps exports that are statically-confirmed functions. ${plural ? "These exports are" : "This export is"} not: ${unconfirmedExports.map((n) => `"${n}"`).join(", ")}. Declare them directly (export async function foo() {} or export const foo = async () => {}). A factory or otherwise statically-indeterminate initializer (export const foo = makeCached(fn)) is rejected even if it returns a function at runtime -- rewrite it as a direct async function, or move non-function exports to a separate module.`
     );
   }
   if (exportNames.length === 0) {
@@ -1997,7 +1998,6 @@ function clientRefDedup() {
       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;
@@ -2130,7 +2130,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.124",
+  version: "0.0.0-experimental.126",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -2422,10 +2422,10 @@ function extractParamsFromPattern(pattern) {
 function formatRouteEntry(key, pattern, _params, search) {
   const hasSearch = search && Object.keys(search).length > 0;
   if (!hasSearch) {
-    return `  ${key}: "${pattern}",`;
+    return `  ${key}: ${JSON.stringify(pattern)},`;
   }
-  const searchBody = Object.entries(search).map(([k, v]) => `${k}: "${v}"`).join(", ");
-  return `  ${key}: { path: "${pattern}", search: { ${searchBody} } },`;
+  const searchBody = Object.entries(search).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join(", ");
+  return `  ${key}: { path: ${JSON.stringify(pattern)}, search: { ${searchBody} } },`;
 }
 
 // src/build/route-types/ast-route-extraction.ts
@@ -2541,7 +2541,31 @@ declare global {
 }
 
 // src/build/route-types/scan-filter.ts
+import { join, relative } from "node:path";
 import picomatch from "picomatch";
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "**/__tests__/**",
+  "**/__mocks__/**",
+  "**/dist/**",
+  "**/coverage/**",
+  "**/*.test.{ts,tsx,js,jsx}",
+  "**/*.spec.{ts,tsx,js,jsx}"
+];
+function createScanFilter(root, opts) {
+  const { include, exclude } = opts;
+  const hasInclude = include && include.length > 0;
+  const hasCustomExclude = exclude !== void 0;
+  if (!hasInclude && !hasCustomExclude) return void 0;
+  const effectiveExclude = exclude ?? DEFAULT_EXCLUDE_PATTERNS;
+  const includeMatcher = hasInclude ? picomatch(include) : null;
+  const excludeMatcher = effectiveExclude.length > 0 ? picomatch(effectiveExclude) : null;
+  return (absolutePath) => {
+    const rel = relative(root, absolutePath);
+    if (excludeMatcher && excludeMatcher(rel)) return false;
+    if (includeMatcher) return includeMatcher(rel);
+    return true;
+  };
+}
 
 // src/build/route-types/per-module-writer.ts
 import ts4 from "typescript";
@@ -2810,7 +2834,7 @@ import {
   readdirSync
 } from "node:fs";
 import {
-  join,
+  join as join2,
   dirname as dirname2,
   resolve as resolve3,
   sep,
@@ -2846,7 +2870,7 @@ function findRouterFilesRecursive(dir, filter, results) {
   const childDirs = [];
   const routerFilesInDir = [];
   for (const entry of entries) {
-    const fullPath = join(dir, entry.name);
+    const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "coverage" || entry.name === "__tests__" || entry.name === "__mocks__" || entry.name.startsWith("."))
         continue;
@@ -3006,7 +3030,7 @@ function applyBasenameToRoutes(result, basename2) {
 }
 function genFileTsPath(sourceFile) {
   const base = pathBasename(sourceFile).replace(/\.(tsx?|jsx?)$/, "");
-  return join(dirname2(sourceFile), `${base}.named-routes.gen.ts`);
+  return join2(dirname2(sourceFile), `${base}.named-routes.gen.ts`);
 }
 function resolveSearchSchemas(publicRouteNames, runtimeSchemas, sourceFile) {
   if (runtimeSchemas && Object.keys(runtimeSchemas).length > 0) {
@@ -3072,7 +3096,7 @@ function findRouterFiles(root, filter) {
 }
 function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
   try {
-    const oldCombinedPath = join(root, "src", "named-routes.gen.ts");
+    const oldCombinedPath = join2(root, "src", "named-routes.gen.ts");
     if (existsSync3(oldCombinedPath)) {
       unlinkSync(oldCombinedPath);
       console.log(
@@ -3282,7 +3306,6 @@ function createVersionPlugin() {
       }
       return null;
     },
-    // Track RSC module changes and update version
     async hotUpdate(ctx) {
       if (!isDev) return;
       const isRscModule = this.environment?.name === "rsc";
@@ -3359,9 +3382,6 @@ function performanceTracksOptimizeDepsPlugin() {
   const RSDW_CLIENT_RE = /react-server-dom-webpack-client\.browser\.(development|production)\.js$/;
   return {
     name: "@rangojs/router:performance-tracks-optimize-deps",
-    // Vite 8 optimizes deps with Rolldown (Rollup-style plugin pipeline), so the
-    // pre-bundled RSDW client is patched via load() rather than esbuild's onLoad.
-    // Returning code overrides Rolldown's default filesystem read for the module.
     async load(id) {
       const cleanId = id.split("?")[0] ?? id;
       if (!RSDW_CLIENT_RE.test(cleanId)) return null;
@@ -3504,7 +3524,7 @@ function getManualChunks(id) {
 }
 
 // src/vite/plugins/client-ref-hashing.ts
-import { relative } from "node:path";
+import { relative as relative2 } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
 var debug7 = createRangoDebugger(NS.transform);
 var CLIENT_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-package-proxy/";
@@ -3521,10 +3541,10 @@ function computeProductionHash(projectRoot, refKey) {
     const absPath = decodeURIComponent(
       refKey.slice(CLIENT_IN_SERVER_PKG_PROXY_PREFIX.length)
     );
-    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
+    toHash = relative2(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith(FS_PREFIX)) {
     const absPath = refKey.slice(FS_PREFIX.length - 1);
-    toHash = relative(projectRoot, absPath).replaceAll("\\", "/");
+    toHash = relative2(projectRoot, absPath).replaceAll("\\", "/");
   } else if (refKey.startsWith("/")) {
     toHash = refKey.slice(1);
   } else {
@@ -3551,7 +3571,6 @@ function hashClientRefs(projectRoot) {
   const counter = createCounter(debug7, "hash-client-refs");
   return {
     name: "@rangojs/router:hash-client-refs",
-    // Run after the RSC plugin's transform (default enforce is normal)
     enforce: "post",
     applyToEnvironment(env) {
       return env.name === "rsc";
@@ -4060,6 +4079,49 @@ function checkSelfGenWrite(state, filePath, consume) {
   }
 }
 
+// src/router/logging.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/internal-debug.ts
+var INTERNAL_RANGO_DEBUG = typeof __RANGO_DEBUG__ !== "undefined" ? __RANGO_DEBUG__ : typeof process !== "undefined" && Boolean(process.env?.INTERNAL_RANGO_DEBUG);
+
+// src/router/logging.ts
+var routerLogContext = new AsyncLocalStorage();
+
+// src/router/pattern-matching.ts
+function parsePattern(pattern) {
+  const segments = [];
+  const segmentRegex = /\/(:([a-zA-Z_][a-zA-Z0-9_]*)(\(([^)]+)\))?(\?)?([^/]*)|(\*)|([^/]+))/g;
+  let match;
+  while ((match = segmentRegex.exec(pattern)) !== null) {
+    const [
+      ,
+      ,
+      paramName,
+      ,
+      constraint,
+      optional,
+      suffix,
+      wildcard,
+      staticText
+    ] = match;
+    if (wildcard) {
+      segments.push({ type: "wildcard", value: "*", optional: false });
+    } else if (paramName) {
+      segments.push({
+        type: "param",
+        value: paramName,
+        optional: optional === "?",
+        constraint: constraint ? constraint.split("|") : void 0,
+        suffix: suffix || void 0
+      });
+    } else if (staticText) {
+      segments.push({ type: "static", value: staticText, optional: false });
+    }
+  }
+  return segments;
+}
+
 // src/build/prefix-tree-utils.ts
 function flattenLeafEntries(prefixTree, routeManifest, result) {
   function visit(node, ancestorStaticPrefixes) {
@@ -4102,6 +4164,216 @@ function buildRouteToStaticPrefix(prefixTree, result) {
   }
 }
 
+// src/build/route-trie.ts
+function buildRouteTrie(routeManifest, routeAncestry, routeToStaticPrefix, routeTrailingSlash, prerenderRouteNames, passthroughRouteNames, responseTypeRoutes) {
+  const root = {};
+  for (const [routeName, pattern] of Object.entries(routeManifest)) {
+    const ancestry = routeAncestry[routeName] || [];
+    const staticPrefix = routeToStaticPrefix[routeName] || "";
+    const trailingSlash = routeTrailingSlash?.[routeName];
+    const responseType = responseTypeRoutes?.[routeName];
+    const hasTrailingSlash = pattern.length > 1 && pattern.endsWith("/");
+    const normalizedPattern = hasTrailingSlash ? pattern.slice(0, -1) : pattern;
+    const segments = parsePattern(normalizedPattern);
+    insertRoute(root, segments, 0, {
+      n: routeName,
+      sp: staticPrefix,
+      a: ancestry,
+      ...trailingSlash ? { ts: trailingSlash } : {},
+      ...prerenderRouteNames?.has(routeName) ? { pr: true } : {},
+      ...passthroughRouteNames?.has(routeName) ? { pt: true } : {},
+      ...responseType ? { rt: responseType } : {}
+    });
+  }
+  sortSuffixParams(root);
+  return root;
+}
+function sortSuffixParams(node) {
+  if (node.xp) {
+    const sorted = {};
+    for (const suffix of Object.keys(node.xp).sort(
+      (a, b) => b.length - a.length
+    )) {
+      sorted[suffix] = node.xp[suffix];
+    }
+    node.xp = sorted;
+  }
+  if (node.s) {
+    for (const child of Object.values(node.s)) {
+      sortSuffixParams(child);
+    }
+  }
+  if (node.p) {
+    sortSuffixParams(node.p.c);
+  }
+  if (node.xp) {
+    for (const child of Object.values(node.xp)) {
+      sortSuffixParams(child.c);
+    }
+  }
+}
+function buildPerRouterTrie(manifest) {
+  const ancestry = manifest._routeAncestry;
+  if (!ancestry || Object.keys(ancestry).length === 0) {
+    return null;
+  }
+  const routeToStaticPrefix = {};
+  for (const name of Object.keys(manifest.routeManifest)) {
+    routeToStaticPrefix[name] = "";
+  }
+  if (manifest.prefixTree) {
+    buildRouteToStaticPrefix(manifest.prefixTree, routeToStaticPrefix);
+  }
+  return buildRouteTrie(
+    manifest.routeManifest,
+    ancestry,
+    routeToStaticPrefix,
+    manifest.routeTrailingSlash,
+    manifest.prerenderRoutes ? new Set(manifest.prerenderRoutes) : void 0,
+    manifest.passthroughRoutes ? new Set(manifest.passthroughRoutes) : void 0,
+    manifest.responseTypeRoutes
+  );
+}
+function insertRoute(node, segments, index, leaf) {
+  const constraints = {};
+  for (const seg of segments) {
+    if (seg.type === "param") {
+      if (seg.constraint) {
+        constraints[seg.value] = seg.constraint;
+      }
+    }
+  }
+  const leafBase = {
+    ...leaf,
+    ...Object.keys(constraints).length > 0 ? { cv: constraints } : {}
+  };
+  insertSegments(node, segments, index, leafBase, []);
+}
+function mergeLeaves(existing, leaf) {
+  if (!existing) return leaf;
+  if (existing.rt && leaf.rt) {
+    const merged = leaf;
+    merged.nv = existing.nv || [];
+    merged.nv.push({ routeKey: existing.n, responseType: existing.rt });
+    return merged;
+  }
+  if (leaf.rt && !existing.rt) {
+    if (!existing.nv) {
+      existing.nv = [];
+      existing.rf = true;
+    }
+    existing.nv.push({ routeKey: leaf.n, responseType: leaf.rt });
+    return existing;
+  }
+  if (!leaf.rt && existing.rt) {
+    if (!leaf.nv) leaf.nv = [];
+    if (existing.nv) leaf.nv.push(...existing.nv);
+    leaf.nv.push({ routeKey: existing.n, responseType: existing.rt });
+    return leaf;
+  }
+  return leaf;
+}
+function mergeLeaf(node, leaf) {
+  node.r = mergeLeaves(node.r, leaf);
+}
+function buildLeaf(leafBase, paramNames) {
+  return paramNames.length > 0 ? { ...leafBase, pa: [...paramNames] } : { ...leafBase };
+}
+function insertSegments(node, segments, index, leafBase, paramNames) {
+  if (index >= segments.length) {
+    mergeLeaf(node, buildLeaf(leafBase, paramNames));
+    return;
+  }
+  const segment = segments[index];
+  if (segment.type === "static") {
+    if (!node.s) node.s = {};
+    if (!node.s[segment.value]) node.s[segment.value] = {};
+    insertSegments(
+      node.s[segment.value],
+      segments,
+      index + 1,
+      leafBase,
+      paramNames
+    );
+  } else if (segment.type === "param") {
+    if (segment.optional) {
+      insertSegments(node, segments, index + 1, leafBase, paramNames);
+    }
+    if (segment.suffix) {
+      if (!node.xp) node.xp = {};
+      if (!node.xp[segment.suffix]) {
+        node.xp[segment.suffix] = { n: segment.value, c: {} };
+      }
+      insertSegments(node.xp[segment.suffix].c, segments, index + 1, leafBase, [
+        ...paramNames,
+        segment.value
+      ]);
+    } else {
+      if (!node.p) {
+        node.p = { n: segment.value, c: {} };
+      }
+      insertSegments(node.p.c, segments, index + 1, leafBase, [
+        ...paramNames,
+        segment.value
+      ]);
+    }
+  } else if (segment.type === "wildcard") {
+    const wildLeaf = {
+      ...buildLeaf(leafBase, paramNames),
+      pn: "*"
+    };
+    const existing = node.w ? { ...node.w } : void 0;
+    const merged = mergeLeaves(existing, wildLeaf);
+    node.w = merged;
+  }
+}
+
+// src/build/collect-fallback-refs.ts
+var CLIENT_REF = /* @__PURE__ */ Symbol.for("react.client.reference");
+var MAX_DEPTH = 40;
+var SYNTHETIC_PROPS = {
+  error: new Error("rango: build-time fallback-chunk discovery"),
+  reset: () => {
+  },
+  pathname: "/",
+  info: { componentStack: "" }
+};
+function isReactNodeLike(v) {
+  return Array.isArray(v) || typeof v === "object" && v !== null && "$$typeof" in v;
+}
+function walkElementTree(node, report, depth) {
+  if (node == null || depth > MAX_DEPTH) return;
+  if (Array.isArray(node)) {
+    for (const child of node) walkElementTree(child, report, depth + 1);
+    return;
+  }
+  if (typeof node !== "object") return;
+  const el = node;
+  const type = el.type;
+  if (type?.$$typeof === CLIENT_REF && typeof type.$$id === "string") {
+    report(type.$$id.split("#")[0]);
+  }
+  const props = el.props;
+  if (props && typeof props === "object") {
+    walkElementTree(props.children, report, depth + 1);
+    for (const key in props) {
+      if (key === "children") continue;
+      const value = props[key];
+      if (isReactNodeLike(value)) walkElementTree(value, report, depth + 1);
+    }
+  }
+}
+function collectFallbackClientRefs(boundary, report) {
+  try {
+    let node = boundary;
+    if (typeof node === "function") {
+      node = node(SYNTHETIC_PROPS);
+    }
+    walkElementTree(node, report, 0);
+  } catch {
+  }
+}
+
 // src/vite/utils/manifest-utils.ts
 function jsonParseExpression(value) {
   const json = JSON.stringify(value);
@@ -4110,6 +4382,9 @@ function jsonParseExpression(value) {
 }
 
 // src/context-var.ts
+function hasContextVars(variables) {
+  return Object.keys(variables).length > 0 || Object.getOwnPropertySymbols(variables).length > 0;
+}
 var NON_CACHEABLE_KEYS = /* @__PURE__ */ Symbol.for(
   "rango:non-cacheable-keys"
 );
@@ -4362,7 +4637,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
                 (performance.now() - getParamsStart).toFixed(1)
               );
               const concurrency = def.options?.concurrency ?? 1;
-              const hasBuildVars = Object.keys(buildVars).length > 0 || Object.getOwnPropertySymbols(buildVars).length > 0;
+              const hasBuildVars = hasContextVars(buildVars);
               for (const params of paramsList) {
                 let url = substituteRouteParams(
                   pattern,
@@ -4804,8 +5079,8 @@ async function discoverRouters(state, rscEnv) {
     computeProductionHash(state.projectRoot, refKey)
   ) : void 0;
   const collectFromBoundaryNode = (node) => {
-    if (collectClientFallbackRef && buildMod.collectFallbackClientRefs) {
-      buildMod.collectFallbackClientRefs(node, collectClientFallbackRef);
+    if (collectClientFallbackRef) {
+      collectFallbackClientRefs(node, collectClientFallbackRef);
     }
   };
   const manifestGenStart = debug10 ? performance.now() : 0;
@@ -4864,18 +5139,14 @@ async function discoverRouters(state, rscEnv) {
     if (manifest.routeTrailingSlash) {
       Object.assign(mergedRouteTrailingSlash, manifest.routeTrailingSlash);
     }
-    flattenLeafEntries(
-      manifest.prefixTree,
-      manifest.routeManifest,
-      newMergedPrecomputedEntries
-    );
-    newPerRouterManifestDataMap.set(id, manifest.routeManifest);
     const routerPrecomputed = [];
     flattenLeafEntries(
       manifest.prefixTree,
       manifest.routeManifest,
       routerPrecomputed
     );
+    newMergedPrecomputedEntries.push(...routerPrecomputed);
+    newPerRouterManifestDataMap.set(id, manifest.routeManifest);
     newPerRouterPrecomputedMap.set(id, routerPrecomputed);
     console.log(
       `[rango] Router "${id}" -> ${routeCount} routes (${staticRoutes} static, ${dynamicRoutes} dynamic)`
@@ -4899,8 +5170,7 @@ async function discoverRouters(state, rscEnv) {
   let newMergedRouteTrie = null;
   const trieStart = debug10 ? performance.now() : 0;
   if (Object.keys(newMergedRouteManifest).length > 0) {
-    const buildRouteTrie = buildMod.buildRouteTrie;
-    if (buildRouteTrie && mergedRouteAncestry) {
+    if (mergedRouteAncestry) {
       const routeToStaticPrefix = {};
       for (const { manifest } of allManifests) {
         for (const name of Object.keys(manifest.routeManifest)) {
@@ -4937,9 +5207,8 @@ async function discoverRouters(state, rscEnv) {
         passthroughRouteNames,
         mergedResponseTypeRoutes
       );
-      const buildPerRouterTrie = buildMod.buildPerRouterTrie;
       for (const { id, manifest } of allManifests) {
-        const perRouterTrie = buildPerRouterTrie ? buildPerRouterTrie(manifest) : null;
+        const perRouterTrie = buildPerRouterTrie(manifest);
         if (perRouterTrie) {
           newPerRouterTrieMap.set(id, perRouterTrie);
         }
@@ -4963,7 +5232,7 @@ async function discoverRouters(state, rscEnv) {
 }
 
 // src/vite/discovery/route-types-writer.ts
-import { dirname as dirname3, join as join2, resolve as resolve6 } from "node:path";
+import { dirname as dirname3, 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 = {};
@@ -4995,7 +5264,7 @@ function writeRouteTypesFiles(state) {
     const entryDir = dirname3(
       resolve6(state.projectRoot, state.resolvedEntryPath)
     );
-    const oldCombinedPath = join2(entryDir, "named-routes.gen.ts");
+    const oldCombinedPath = join3(entryDir, "named-routes.gen.ts");
     if (existsSync5(oldCombinedPath)) {
       unlinkSync2(oldCombinedPath);
       console.log(
@@ -5077,7 +5346,7 @@ function supplementGenFilesWithRuntimeRoutes(state) {
 }
 
 // src/vite/discovery/virtual-module-codegen.ts
-import { dirname as dirname4, basename, join as join3 } from "node:path";
+import { dirname as dirname4, basename, join as join4 } from "node:path";
 function generateRoutesManifestModule(state) {
   const hasManifest = state.mergedRouteManifest && Object.keys(state.mergedRouteManifest).length > 0;
   if (hasManifest) {
@@ -5092,7 +5361,7 @@ function generateRoutesManifestModule(state) {
           /\.(tsx?|jsx?)$/,
           ""
         );
-        const genPath = join3(
+        const genPath = join4(
           routerDir,
           `${routerBasename}.named-routes.gen.js`
         ).replaceAll("\\", "/");
@@ -5177,7 +5446,7 @@ function generatePerRouterModule(state, routerId) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const genPath = join3(
+    const genPath = join4(
       routerDir,
       `${routerBasename}.named-routes.gen.js`
     ).replaceAll("\\", "/");
@@ -5200,7 +5469,7 @@ function generatePerRouterModule(state, routerId) {
       `export const precomputedEntries = ${jsonParseExpression(entries)};`
     );
   }
-  return lines.join("\n") || "// empty router manifest";
+  return lines.join("\n") || "";
 }
 
 // src/vite/discovery/bundle-postprocess.ts
@@ -5271,7 +5540,7 @@ function postprocessBundle(state) {
           manifestMap[key] = `./assets/${assetFileName}`;
         }
         const manifestCode = [
-          `const m=JSON.parse('${JSON.stringify(manifestMap).replace(/'/g, "\\'")}');`,
+          `const m=${jsonParseExpression(manifestMap)};`,
           `export function loadPrerenderAsset(s){return import(s)}`,
           `export default m;`,
           ""
@@ -5599,6 +5868,7 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
     },
     configResolved(config) {
       s.projectRoot = config.root;
+      s.scanFilter = opts?.discovery ? createScanFilter(s.projectRoot, opts.discovery) : void 0;
       s.isBuildMode = config.command === "build";
       viteCommand = config.command;
       viteMode = config.mode;
@@ -6535,8 +6805,6 @@ async function rango(options) {
       enforce: "pre",
       config() {
         return {
-          // Exclude rsc-router modules from optimization to prevent module duplication
-          // This ensures the same Context instance is used by both browser entry and RSC proxy modules
           optimizeDeps: {
             exclude: excludeDeps,
             rolldownOptions: sharedRolldownOptions
@@ -6559,21 +6827,12 @@ async function rango(options) {
             client: {
               build: {
                 rollupOptions: {
-                  // FILE_NAME_CONFLICT (and any other client-build warning) is
-                  // emitted by the CLIENT environment build, which consults THIS
-                  // env's onwarn -- Vite 8's environment builds do NOT propagate
-                  // the top-level build.rollupOptions.onwarn into the client env.
-                  // Wire it here so the suppression runs where the conflicts
-                  // originate (the top-level handler is invoked 0x for these; the
-                  // client-env handler is invoked for all of them).
                   onwarn,
                   output: {
                     manualChunks: getManualChunks
                   }
                 }
               },
-              // Pre-bundle rsc-html-stream to prevent discovery during first request
-              // Exclude rsc-router modules to ensure same Context instance
               optimizeDeps: {
                 include: [nested("rsc-html-stream/client")],
                 exclude: excludeDeps,
@@ -6581,12 +6840,9 @@ async function rango(options) {
               }
             },
             ssr: {
-              // Build SSR inside RSC directory so wrangler can deploy self-contained dist/rsc
               build: {
                 outDir: "./dist/rsc/ssr"
               },
-              // Pre-bundle SSR entry and React for proper module linking with childEnvironments
-              // All deps must be listed to avoid late discovery triggering ERR_OUTDATED_OPTIMIZED_DEP
               optimizeDeps: {
                 entries: [finalEntries.ssr],
                 include: [
@@ -6606,10 +6862,7 @@ async function rango(options) {
               }
             },
             rsc: {
-              // RSC environment needs exclude list and esbuild options
-              // Exclude rsc-router modules to prevent createContext in RSC environment
               optimizeDeps: {
-                // Pre-bundle all RSC deps to prevent late discovery triggering ERR_OUTDATED_OPTIMIZED_DEP
                 include: [
                   "react",
                   "react/jsx-runtime",
@@ -6695,13 +6948,6 @@ ${list}`);
             client: {
               build: {
                 rollupOptions: {
-                  // FILE_NAME_CONFLICT (and any other client-build warning) is
-                  // emitted by the CLIENT environment build, which consults THIS
-                  // env's onwarn -- Vite 8's environment builds do NOT propagate
-                  // the top-level build.rollupOptions.onwarn into the client env.
-                  // Wire it here so the suppression runs where the conflicts
-                  // originate (the top-level handler is invoked 0x for these; the
-                  // client-env handler is invoked for all of them).
                   onwarn,
                   output: {
                     manualChunks: getManualChunks
@@ -6817,6 +7063,7 @@ ${list}`);
       enableBuildPrerender: prerenderEnabled,
       buildEnv: options?.buildEnv,
       preset,
+      discovery: options?.discovery,
       clientChunkCtx
     })
   );
@@ -6832,7 +7079,7 @@ ${list}`);
 // src/vite/plugins/refresh-cmd.ts
 function poke() {
   return {
-    name: "vite-plugin-poke",
+    name: "@rangojs/router:poke",
     apply: "serve",
     configureServer(server) {
       const stdin = process.stdin;