@rangojs/router 0.0.0-experimental.125 → 0.0.0-experimental.127

package/dist/vite/index.js

@@ -1192,7 +1192,10 @@ function transformRouter(code, filePath, routerFnNames, absolutePath) {
   const basename2 = path3.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
   const routeNamesImport = `./${basename2}.named-routes.gen.js`;
   const routeNamesVar = `__rsc_rn`;
+  const codeOffsets = new Set(codeMatchIndices(code, pat));
+  pat.lastIndex = 0;
   while ((match = pat.exec(code)) !== null) {
+    if (!codeOffsets.has(match.index)) continue;
     const callStart = match.index;
     const parenPos = match.index + match[0].length - 1;
     const closeParen = findMatchingParen(code, parenPos + 1);
@@ -1841,7 +1844,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 +1853,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) {
@@ -2129,7 +2133,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.125",
+  version: "0.0.0-experimental.127",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -2239,6 +2243,11 @@ var package_default = {
       "react-server": "./src/cache/cache-runtime.ts",
       default: "./src/cache/cache-runtime.ts"
     },
+    "./cloudflare": {
+      types: "./src/cloudflare/index.ts",
+      "react-server": "./src/cloudflare/index.ts",
+      default: "./src/cloudflare/index.ts"
+    },
     "./theme": {
       types: "./src/theme/index.ts",
       default: "./src/theme/index.ts"
@@ -2531,16 +2540,44 @@ export const NamedRoutes = {
 ${objectBody}
 } as const;
 
+// Aliased so the augmentation below does not pay a homomorphic mapped-type
+// instantiation per route; \`as const\` already makes the members readonly.
+type NamedRoutesShape = typeof NamedRoutes;
+
 declare global {
   namespace Rango {
-    interface GeneratedRouteMap extends Readonly<typeof NamedRoutes> {}
+    interface GeneratedRouteMap extends NamedRoutesShape {}
   }
 }
 `;
 }
 
 // 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";
@@ -2809,7 +2846,7 @@ import {
   readdirSync
 } from "node:fs";
 import {
-  join,
+  join as join2,
   dirname as dirname2,
   resolve as resolve3,
   sep,
@@ -2845,7 +2882,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;
@@ -3005,7 +3042,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) {
@@ -3071,7 +3108,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(
@@ -3499,7 +3536,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/";
@@ -3516,10 +3553,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 {
@@ -4054,6 +4091,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) {
@@ -4096,6 +4176,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);
@@ -4104,6 +4394,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"
 );
@@ -4240,6 +4533,23 @@ function notifyOnError(registry, error, phase, routeKey, pathname, skipped) {
     break;
   }
 }
+function resolvePrerenderError(registry, error, onError, label, elapsed, phase, routeKey, pathname) {
+  const isSkip = error?.name === "Skip";
+  if (isSkip || onError === "warn") {
+    if (isSkip) {
+      console.log(`[rango]   SKIP ${label} (${elapsed}ms) - ${error.message}`);
+    } else {
+      console.warn(
+        `[rango]   WARN ${label} (${elapsed}ms) - render error, not pre-rendered (prerender.onError: "warn"): ${error.message}`
+      );
+    }
+    notifyOnError(registry, error, phase, routeKey, pathname, true);
+    return;
+  }
+  console.error(`[rango]   FAIL ${label} (${elapsed}ms) - ${error.message}`);
+  notifyOnError(registry, error, phase, routeKey, pathname);
+  throw error;
+}
 function getStagedAssetDir(projectRoot) {
   return resolve5(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
 }
@@ -4356,7 +4666,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,
@@ -4441,6 +4751,7 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
   const manifestEntries = {};
   let doneCount = 0;
   let skipCount = 0;
+  const prerenderOnError = state.opts?.prerenderOnError ?? "fail";
   const startTotal = performance.now();
   const groups = groupByConcurrency(entries);
   for (const group of groups) {
@@ -4500,34 +4811,19 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
             doneCount++;
             break;
           } catch (err) {
-            if (err.name === "Skip") {
-              const elapsed2 = (performance.now() - startUrl).toFixed(0);
-              console.log(
-                `[rango]   SKIP ${entry.urlPath.padEnd(40)} (${elapsed2}ms) - ${err.message}`
-              );
-              skipCount++;
-              notifyOnError(
-                registry,
-                err,
-                "prerender",
-                entry.routeName,
-                entry.urlPath,
-                true
-              );
-              break;
-            }
             const elapsed = (performance.now() - startUrl).toFixed(0);
-            console.error(
-              `[rango]   FAIL ${entry.urlPath.padEnd(40)} (${elapsed}ms) - ${err.message}`
-            );
-            notifyOnError(
+            resolvePrerenderError(
               registry,
               err,
+              prerenderOnError,
+              entry.urlPath.padEnd(40),
+              elapsed,
               "prerender",
               entry.routeName,
               entry.urlPath
             );
-            throw err;
+            skipCount++;
+            break;
           }
         }
       }
@@ -4562,6 +4858,7 @@ async function renderStaticHandlers(state, rscEnv, registry) {
   let staticDone = 0;
   let staticSkip = 0;
   let totalStaticCount = 0;
+  const prerenderOnError = state.opts?.prerenderOnError ?? "fail";
   for (const [, exportNames] of state.resolvedStaticModules) {
     totalStaticCount += exportNames.length;
   }
@@ -4609,22 +4906,18 @@ async function renderStaticHandlers(state, rscEnv, registry) {
             break;
           }
         } catch (err) {
-          if (err.name === "Skip") {
-            const elapsed2 = (performance.now() - startHandler).toFixed(0);
-            console.log(
-              `[rango]   SKIP ${name.padEnd(40)} (${elapsed2}ms) - ${err.message}`
-            );
-            staticSkip++;
-            notifyOnError(registry, err, "static", void 0, void 0, true);
-            handled = true;
-            break;
-          }
           const elapsed = (performance.now() - startHandler).toFixed(0);
-          console.error(
-            `[rango]   FAIL ${name.padEnd(40)} (${elapsed}ms) - ${err.message}`
+          resolvePrerenderError(
+            registry,
+            err,
+            prerenderOnError,
+            name.padEnd(40),
+            elapsed,
+            "static"
           );
-          notifyOnError(registry, err, "static");
-          throw err;
+          staticSkip++;
+          handled = true;
+          break;
         }
       }
       if (!handled) {
@@ -4798,8 +5091,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;
@@ -4889,8 +5182,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)) {
@@ -4927,9 +5219,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);
         }
@@ -4953,7 +5244,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 = {};
@@ -4985,7 +5276,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(
@@ -5067,7 +5358,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) {
@@ -5082,7 +5373,7 @@ function generateRoutesManifestModule(state) {
           /\.(tsx?|jsx?)$/,
           ""
         );
-        const genPath = join3(
+        const genPath = join4(
           routerDir,
           `${routerBasename}.named-routes.gen.js`
         ).replaceAll("\\", "/");
@@ -5167,7 +5458,7 @@ function generatePerRouterModule(state, routerId) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const genPath = join3(
+    const genPath = join4(
       routerDir,
       `${routerBasename}.named-routes.gen.js`
     ).replaceAll("\\", "/");
@@ -5589,6 +5880,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;
@@ -5991,9 +6283,11 @@ ${err.stack}`
             logResult(200, `match ${result.routeName}`);
             return;
           } catch (err) {
-            console.warn(
-              `[rango] Dev prerender failed for ${pathname}: ${err.message}`
-            );
+            if (err?.name !== "Skip") {
+              console.warn(
+                `[rango] Dev prerender error for ${pathname} (serving live instead): ${err.message}`
+              );
+            }
           }
         }
         res.statusCode = 404;
@@ -6783,6 +7077,8 @@ ${list}`);
       enableBuildPrerender: prerenderEnabled,
       buildEnv: options?.buildEnv,
       preset,
+      prerenderOnError: options?.prerender?.onError,
+      discovery: options?.discovery,
       clientChunkCtx
     })
   );
@@ -6798,7 +7094,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;