@rangojs/router 0.0.0-experimental.88a3b2f7 → 0.0.0-experimental.89

package/dist/vite/index.js

@@ -18,6 +18,9 @@ function hashId(filePath, exportName) {
   const hash = crypto.createHash("sha256").update(input).digest("hex");
   return `${hash.slice(0, 8)}#${exportName}`;
 }
+function makeStubId(filePath, exportName, isBuild) {
+  return isBuild ? hashId(filePath, exportName) : `${filePath}#${exportName}`;
+}
 function hashInlineId(filePath, lineNumber, index) {
   const input = index !== void 0 && index > 0 ? `${filePath}:${lineNumber}:${index}` : `${filePath}:${lineNumber}`;
   return crypto.createHash("sha256").update(input).digest("hex").slice(0, 8);
@@ -188,7 +191,99 @@ function escapeRegExp(input) {
   return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/vite/debug.ts
+import debugFactory from "debug";
+var NS = {
+  config: "rango:config",
+  discovery: "rango:discovery",
+  routes: "rango:routes",
+  prerender: "rango:prerender",
+  build: "rango:build",
+  dev: "rango:dev",
+  transform: "rango:transform"
+};
+if (process.env.INTERNAL_RANGO_DEBUG) {
+  const existing = debugFactory.disable();
+  debugFactory.enable(existing ? `${existing},rango:*` : "rango:*");
+}
+function createRangoDebugger(namespace) {
+  const primary = debugFactory(namespace);
+  const shadow = debugFactory(`vite:${namespace}`);
+  if (primary.enabled) return primary;
+  if (shadow.enabled) return shadow;
+  return void 0;
+}
+async function timed(debug11, label, fn) {
+  if (!debug11) return await fn();
+  const start = performance.now();
+  try {
+    return await fn();
+  } finally {
+    debug11("%s (%sms)", label, (performance.now() - start).toFixed(1));
+  }
+}
+function timedSync(debug11, label, fn) {
+  if (!debug11) return fn();
+  const start = performance.now();
+  try {
+    return fn();
+  } finally {
+    debug11("%s (%sms)", label, (performance.now() - start).toFixed(1));
+  }
+}
+function createCounter(debug11, label) {
+  if (!debug11) return void 0;
+  let n = 0;
+  let totalMs = 0;
+  let slowestMs = 0;
+  let slowestFile = "";
+  const record = (file, ms) => {
+    n++;
+    totalMs += ms;
+    if (ms > slowestMs) {
+      slowestMs = ms;
+      slowestFile = file;
+    }
+  };
+  return {
+    record,
+    time(file, fn) {
+      const start = performance.now();
+      let out;
+      try {
+        out = fn();
+      } catch (err) {
+        record(file, performance.now() - start);
+        throw err;
+      }
+      if (out && typeof out.then === "function") {
+        return out.finally(
+          () => record(file, performance.now() - start)
+        );
+      }
+      record(file, performance.now() - start);
+      return out;
+    },
+    flush() {
+      if (n === 0) return;
+      debug11(
+        "%s: %d files, %sms total, slowest %sms %s",
+        label,
+        n,
+        totalMs.toFixed(1),
+        slowestMs.toFixed(1),
+        slowestFile
+      );
+      n = 0;
+      totalMs = 0;
+      slowestMs = 0;
+      slowestFile = "";
+    }
+  };
+}
+
 // src/vite/plugins/expose-action-id.ts
+var debug = createRangoDebugger(NS.transform);
 function getRscPluginApi(config) {
   let plugin = config.plugins.find((p) => p.name === "rsc:minimal");
   if (!plugin) {
@@ -277,6 +372,8 @@ function exposeActionId() {
   let isBuild = false;
   let hashToFileMap;
   let rscPluginApi;
+  const counterTransform = createCounter(debug, "expose-action-id transform");
+  const counterRender = createCounter(debug, "expose-action-id renderChunk");
   return {
     name: "@rangojs/router:expose-action-id",
     // Run after all other plugins (including RSC plugin's transforms)
@@ -286,6 +383,10 @@ function exposeActionId() {
       isBuild = config.command === "build";
       rscPluginApi = getRscPluginApi(config);
     },
+    buildEnd() {
+      counterTransform?.flush();
+      counterRender?.flush();
+    },
     buildStart() {
       if (!rscPluginApi) {
         rscPluginApi = getRscPluginApi(config);
@@ -322,28 +423,42 @@ function exposeActionId() {
       if (id.includes("/node_modules/")) {
         return;
       }
-      return transformServerReferences(code, id);
+      const start = counterTransform ? performance.now() : 0;
+      try {
+        return transformServerReferences(code, id);
+      } finally {
+        counterTransform?.record(id, performance.now() - start);
+      }
     },
     // Build mode: renderChunk runs after all transforms and bundling complete
     renderChunk(code, chunk) {
-      const isRscEnv = this.environment?.name === "rsc";
-      const effectiveMap = isRscEnv ? hashToFileMap : void 0;
-      if (isRscEnv && hashToFileMap) {
-        const s = new MagicString(code);
-        const changed1 = applyServerReferenceWrapping(code, s, effectiveMap);
-        const changed2 = applyRegisterReferenceWrapping(code, s, hashToFileMap);
-        if (changed1 || changed2) {
-          return {
-            code: s.toString(),
-            map: s.generateMap({
-              source: chunk.fileName,
-              includeContent: true
-            })
-          };
+      const start = counterRender ? performance.now() : 0;
+      try {
+        const isRscEnv = this.environment?.name === "rsc";
+        const effectiveMap = isRscEnv ? hashToFileMap : void 0;
+        if (isRscEnv && hashToFileMap) {
+          const s = new MagicString(code);
+          const changed1 = applyServerReferenceWrapping(code, s, effectiveMap);
+          const changed2 = applyRegisterReferenceWrapping(
+            code,
+            s,
+            hashToFileMap
+          );
+          if (changed1 || changed2) {
+            return {
+              code: s.toString(),
+              map: s.generateMap({
+                source: chunk.fileName,
+                includeContent: true
+              })
+            };
+          }
+          return null;
         }
-        return null;
+        return transformServerReferences(code, chunk.fileName, effectiveMap);
+      } finally {
+        counterRender?.record(chunk.fileName, performance.now() - start);
       }
-      return transformServerReferences(code, chunk.fileName, effectiveMap);
     }
   };
 }
@@ -910,9 +1025,7 @@ function generateWholeFileStubs(cfg, bindings, code, filePath, isBuild) {
   });
   return { code: stubs.join("\n") + "\n", map: null };
 }
-function generateExprStubs(cfg, bindings, code, filePath, sourceId, isBuild) {
-  if (bindings.length === 0) return null;
-  const s = new MagicString2(code);
+function stubHandlerExprs(cfg, bindings, s, filePath, isBuild) {
   let hasChanges = false;
   for (const binding of bindings) {
     const exportName = binding.exportNames[0];
@@ -924,15 +1037,7 @@ function generateExprStubs(cfg, bindings, code, filePath, sourceId, isBuild) {
     );
     hasChanges = true;
   }
-  if (!hasChanges) return null;
-  return {
-    code: s.toString(),
-    map: s.generateMap({
-      source: sourceId,
-      includeContent: true,
-      hires: "boundary"
-    })
-  };
+  return hasChanges;
 }
 function transformHandlerIds(cfg, bindings, s, filePath, isBuild) {
   let hasChanges = false;
@@ -960,6 +1065,7 @@ ${binding.localName}.$$id = "${handlerId}";`;
 import MagicString3 from "magic-string";
 import path3 from "node:path";
 import { createHash } from "node:crypto";
+var debug2 = createRangoDebugger(NS.transform);
 function transformRouter(code, filePath, routerFnNames, absolutePath) {
   const pat = new RegExp(
     `\\b(?:${routerFnNames.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\s*(?:<[^>]*>)?\\s*\\(`,
@@ -1002,11 +1108,15 @@ function transformRouter(code, filePath, routerFnNames, absolutePath) {
 }
 function exposeRouterId() {
   let projectRoot = "";
+  const counter = createCounter(debug2, "expose-router-id");
   return {
     name: "@rangojs/router:expose-router-id",
     configResolved(config) {
       projectRoot = config.root;
     },
+    buildEnd() {
+      counter?.flush();
+    },
     transform(code, id) {
       if (!code.includes("createRouter")) return null;
       if (!/import\s*\{[^}]*\bcreateRouter\b[^}]*\}\s*from\s*["']@rangojs\/router(?:\/server)?["']/.test(
@@ -1015,14 +1125,25 @@ function exposeRouterId() {
         return null;
       }
       if (id.includes("node_modules")) return null;
-      const filePath = normalizePath(path3.relative(projectRoot, id));
-      const routerFnNames = getImportedFnNames(code, "createRouter");
-      return transformRouter(code, filePath, routerFnNames, normalizePath(id));
+      const start = counter ? performance.now() : 0;
+      try {
+        const filePath = normalizePath(path3.relative(projectRoot, id));
+        const routerFnNames = getImportedFnNames(code, "createRouter");
+        return transformRouter(
+          code,
+          filePath,
+          routerFnNames,
+          normalizePath(id)
+        );
+      } finally {
+        counter?.record(id, performance.now() - start);
+      }
     }
   };
 }
 
 // src/vite/plugins/expose-internal-ids.ts
+var debug3 = createRangoDebugger(NS.transform);
 var VIRTUAL_LOADER_MANIFEST = "virtual:rsc-router/loader-manifest";
 var RESOLVED_VIRTUAL_LOADER_MANIFEST = "\0" + VIRTUAL_LOADER_MANIFEST;
 var VIRTUAL_HANDLER_PREFIX = "virtual:handler-extract:";
@@ -1035,9 +1156,13 @@ function exposeInternalIds(options) {
   const staticHandlerModules = /* @__PURE__ */ new Map();
   const virtualHandlers = /* @__PURE__ */ new Map();
   const unsupportedShapeWarnings = /* @__PURE__ */ new Set();
+  const counter = createCounter(debug3, "expose-internal-ids");
   return {
     name: "@rangojs/router:expose-internal-ids",
     enforce: "post",
+    buildEnd() {
+      counter?.flush();
+    },
     api: {
       prerenderHandlerModules,
       staticHandlerModules
@@ -1151,11 +1276,13 @@ ${lazyImports.join(",\n")}
     // --------------- Unified transform ---------------
     transform(code, id) {
       if (id.includes("/node_modules/")) return;
-      const filePath = normalizePath(path4.relative(projectRoot, id));
-      const isRscEnv = this.environment?.name === "rsc";
-      if (id.includes(".named-routes.gen.") && !isRscEnv && this.environment?.name === "client") {
-        this.warn(
-          `
+      const __t0 = counter ? performance.now() : 0;
+      try {
+        const filePath = normalizePath(path4.relative(projectRoot, id));
+        const isRscEnv = this.environment?.name === "rsc";
+        if (id.includes(".named-routes.gen.") && !isRscEnv && this.environment?.name === "client") {
+          this.warn(
+            `
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 !!                                                              !!
 !!  WARNING: NamedRoutes imported in a CLIENT component!        !!
@@ -1175,228 +1302,373 @@ ${lazyImports.join(",\n")}
 !!                                                              !!
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 `
-        );
-      }
-      if (!code.includes("@rangojs/router")) return;
-      const has = detectImports(code);
-      const hasLoaderCode = has.loader && code.includes("createLoader");
-      const hasHandleCode = has.handle && code.includes("createHandle");
-      const hasLocationStateCode = has.locationState && code.includes("createLocationState");
-      const hasPrerenderHandlerCode = has.prerenderHandler && code.includes("Prerender");
-      const hasStaticHandlerCode = has.staticHandler && code.includes("Static");
-      if (!hasLoaderCode && !hasHandleCode && !hasLocationStateCode && !hasPrerenderHandlerCode && !hasStaticHandlerCode) {
-        return;
-      }
-      const _fnNamesCache = /* @__PURE__ */ new Map();
-      const _bindingsCache = /* @__PURE__ */ new Map();
-      let _cachedAst;
-      let _astParseFailed = false;
-      let _astCodeRef = code;
-      const getFnNames = (canonicalName) => {
-        let result = _fnNamesCache.get(canonicalName);
-        if (!result) {
-          result = getImportedFnNames(code, canonicalName);
-          _fnNamesCache.set(canonicalName, result);
+          );
         }
-        return result;
-      };
-      const lazyAst = () => {
-        if (code !== _astCodeRef) {
-          _cachedAst = void 0;
-          _astParseFailed = false;
-          _astCodeRef = code;
+        if (!code.includes("@rangojs/router")) return;
+        const has = detectImports(code);
+        const hasLoaderCode = has.loader && code.includes("createLoader");
+        const hasHandleCode = has.handle && code.includes("createHandle");
+        const hasLocationStateCode = has.locationState && code.includes("createLocationState");
+        const hasPrerenderHandlerCode = has.prerenderHandler && code.includes("Prerender");
+        const hasStaticHandlerCode = has.staticHandler && code.includes("Static");
+        if (!hasLoaderCode && !hasHandleCode && !hasLocationStateCode && !hasPrerenderHandlerCode && !hasStaticHandlerCode) {
+          return;
         }
-        if (_cachedAst !== void 0 || _astParseFailed) return _cachedAst;
-        try {
-          _cachedAst = parseAst2(code, { jsx: true });
-        } catch {
-          _astParseFailed = true;
+        const _fnNamesCache = /* @__PURE__ */ new Map();
+        const _bindingsCache = /* @__PURE__ */ new Map();
+        let _cachedAst;
+        let _astParseFailed = false;
+        let _astCodeRef = code;
+        const getFnNames = (canonicalName) => {
+          let result = _fnNamesCache.get(canonicalName);
+          if (!result) {
+            result = getImportedFnNames(code, canonicalName);
+            _fnNamesCache.set(canonicalName, result);
+          }
+          return result;
+        };
+        const lazyAst = () => {
+          if (code !== _astCodeRef) {
+            _cachedAst = void 0;
+            _astParseFailed = false;
+            _astCodeRef = code;
+          }
+          if (_cachedAst !== void 0 || _astParseFailed) return _cachedAst;
+          try {
+            _cachedAst = parseAst2(code, { jsx: true });
+          } catch {
+            _astParseFailed = true;
+          }
+          return _cachedAst;
+        };
+        const getBindings = (currentCode, fnNames) => {
+          const key = fnNames.join("\0");
+          let result = _bindingsCache.get(key);
+          if (!result) {
+            result = collectCreateExportBindings(
+              currentCode,
+              fnNames,
+              lazyAst()
+            );
+            _bindingsCache.set(key, result);
+          }
+          return result;
+        };
+        for (const cfg of STRICT_CREATE_CONFIGS) {
+          const hasCode = cfg.fnName === "createLoader" ? hasLoaderCode : cfg.fnName === "createHandle" ? hasHandleCode : hasLocationStateCode;
+          if (!hasCode) continue;
+          const fnNames = getFnNames(cfg.fnName);
+          const totalCalls = countCreateCallsForNames(code, fnNames);
+          const supportedBindings = getBindings(code, fnNames).length;
+          if (totalCalls <= supportedBindings) continue;
+          const warnKey = `${id}::${cfg.fnName}`;
+          if (unsupportedShapeWarnings.has(warnKey)) continue;
+          unsupportedShapeWarnings.add(warnKey);
+          this.warn(buildUnsupportedShapeWarning(filePath, cfg.fnName));
         }
-        return _cachedAst;
-      };
-      const getBindings = (currentCode, fnNames) => {
-        const key = fnNames.join("\0");
-        let result = _bindingsCache.get(key);
-        if (!result) {
-          result = collectCreateExportBindings(currentCode, fnNames, lazyAst());
-          _bindingsCache.set(key, result);
+        if (hasLoaderCode && isRscEnv) {
+          const fnNames = getFnNames("createLoader");
+          const bindings = getBindings(code, fnNames);
+          for (const binding of bindings) {
+            const exportName = binding.exportNames[0];
+            const hashedId = hashId(filePath, exportName);
+            loaderRegistry.set(hashedId, {
+              filePath,
+              exportName
+            });
+          }
         }
-        return result;
-      };
-      for (const cfg of STRICT_CREATE_CONFIGS) {
-        const hasCode = cfg.fnName === "createLoader" ? hasLoaderCode : cfg.fnName === "createHandle" ? hasHandleCode : hasLocationStateCode;
-        if (!hasCode) continue;
-        const fnNames = getFnNames(cfg.fnName);
-        const totalCalls = countCreateCallsForNames(code, fnNames);
-        const supportedBindings = getBindings(code, fnNames).length;
-        if (totalCalls <= supportedBindings) continue;
-        const warnKey = `${id}::${cfg.fnName}`;
-        if (unsupportedShapeWarnings.has(warnKey)) continue;
-        unsupportedShapeWarnings.add(warnKey);
-        this.warn(buildUnsupportedShapeWarning(filePath, cfg.fnName));
-      }
-      if (hasLoaderCode && isRscEnv) {
-        const fnNames = getFnNames("createLoader");
-        const bindings = getBindings(code, fnNames);
-        for (const binding of bindings) {
-          const exportName = binding.exportNames[0];
-          const hashedId = hashId(filePath, exportName);
-          loaderRegistry.set(hashedId, {
+        if (hasLoaderCode && !isRscEnv) {
+          const fnNames = getFnNames("createLoader");
+          const bindings = getBindings(code, fnNames);
+          const stubResult = generateClientLoaderStubs(
+            bindings,
+            code,
             filePath,
-            exportName
-          });
+            isBuild
+          );
+          if (stubResult) return stubResult;
         }
-      }
-      if (hasLoaderCode && !isRscEnv) {
-        const fnNames = getFnNames("createLoader");
-        const bindings = getBindings(code, fnNames);
-        const stubResult = generateClientLoaderStubs(
-          bindings,
-          code,
-          filePath,
-          isBuild
-        );
-        if (stubResult) return stubResult;
-      }
-      if (hasPrerenderHandlerCode && !isRscEnv) {
-        const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
-        const bindings = getBindings(code, fnNames);
-        const wholeFile = generateWholeFileStubs(
-          PRERENDER_CONFIG,
-          bindings,
-          code,
-          filePath,
-          isBuild
-        );
-        if (wholeFile) return wholeFile;
-        const exprStubs = generateExprStubs(
-          PRERENDER_CONFIG,
-          bindings,
-          code,
-          filePath,
-          id,
-          isBuild
-        );
-        if (exprStubs) return exprStubs;
-      }
-      if (hasPrerenderHandlerCode && isRscEnv && isBuild) {
-        const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
-        const exportNames = getBindings(code, fnNames).map(
-          (b) => b.exportNames[0]
-        );
-        if (exportNames.length > 0) {
-          prerenderHandlerModules.set(id, exportNames);
+        if (hasPrerenderHandlerCode && !isRscEnv) {
+          const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
+          const bindings = getBindings(code, fnNames);
+          const wholeFile = generateWholeFileStubs(
+            PRERENDER_CONFIG,
+            bindings,
+            code,
+            filePath,
+            isBuild
+          );
+          if (wholeFile) return wholeFile;
         }
-      }
-      let changed = false;
-      const handlerConfigs = [
-        hasStaticHandlerCode && STATIC_CONFIG,
-        hasPrerenderHandlerCode && PRERENDER_CONFIG
-      ].filter((c) => !!c).map((cfg) => {
-        const fnNames = getFnNames(cfg.fnName);
-        return { cfg, fnNames };
-      });
-      for (const { cfg, fnNames } of handlerConfigs) {
-        const totalCalls = countCreateCallsForNames(code, fnNames);
-        const supportedBindings = getBindings(code, fnNames).length;
-        if (totalCalls > supportedBindings) {
-          const iterS = new MagicString4(code);
-          const result = transformInlineHandlers(
-            cfg.fnName,
-            VIRTUAL_HANDLER_PREFIX,
-            iterS,
+        if (hasPrerenderHandlerCode && isRscEnv && isBuild) {
+          const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
+          const exportNames = getBindings(code, fnNames).map(
+            (b) => b.exportNames[0]
+          );
+          if (exportNames.length > 0) {
+            prerenderHandlerModules.set(id, exportNames);
+          }
+        }
+        let changed = false;
+        const handlerConfigs = [
+          hasStaticHandlerCode && STATIC_CONFIG,
+          hasPrerenderHandlerCode && PRERENDER_CONFIG
+        ].filter((c) => !!c).map((cfg) => {
+          const fnNames = getFnNames(cfg.fnName);
+          return { cfg, fnNames };
+        });
+        for (const { cfg, fnNames } of handlerConfigs) {
+          const totalCalls = countCreateCallsForNames(code, fnNames);
+          const supportedBindings = getBindings(code, fnNames).length;
+          if (totalCalls > supportedBindings) {
+            const iterS = new MagicString4(code);
+            const result = transformInlineHandlers(
+              cfg.fnName,
+              VIRTUAL_HANDLER_PREFIX,
+              iterS,
+              code,
+              filePath,
+              virtualHandlers,
+              id,
+              parseAst2
+            );
+            if (result) {
+              changed = true;
+              code = iterS.toString();
+              _bindingsCache.clear();
+            }
+          }
+        }
+        if (hasStaticHandlerCode && !isRscEnv) {
+          const fnNames = getFnNames(STATIC_CONFIG.fnName);
+          const bindings = getBindings(code, fnNames);
+          const wholeFile = generateWholeFileStubs(
+            STATIC_CONFIG,
+            bindings,
             code,
             filePath,
-            virtualHandlers,
-            id,
-            parseAst2
+            isBuild
           );
-          if (result) {
-            changed = true;
-            code = iterS.toString();
-            _bindingsCache.clear();
+          if (wholeFile) return wholeFile;
+        }
+        if (!isRscEnv && (hasPrerenderHandlerCode || hasStaticHandlerCode)) {
+          const prerenderFnNames = hasPrerenderHandlerCode ? getFnNames(PRERENDER_CONFIG.fnName) : [];
+          const staticFnNames = hasStaticHandlerCode ? getFnNames(STATIC_CONFIG.fnName) : [];
+          const loaderFnNames = hasLoaderCode ? getFnNames("createLoader") : [];
+          const handleFnNames = hasHandleCode ? getFnNames("createHandle") : [];
+          const lsFnNames = hasLocationStateCode ? getFnNames("createLocationState") : [];
+          const allBindings = [];
+          for (const fnNames of [
+            prerenderFnNames,
+            staticFnNames,
+            loaderFnNames,
+            handleFnNames,
+            lsFnNames
+          ]) {
+            if (fnNames.length > 0) {
+              allBindings.push(...getBindings(code, fnNames));
+            }
+          }
+          let canStubWholeFile = allBindings.length > 0 && isExportOnlyFile(code, allBindings);
+          if (canStubWholeFile && (handleFnNames.length > 0 || lsFnNames.length > 0)) {
+            const exportedLocals = new Set(allBindings.map((b) => b.localName));
+            const strippedBindings = [];
+            const localDeclPattern = /(?:^|;|\n)\s*(?:const|let|var|function)\s+(\w+)/g;
+            let declMatch;
+            while ((declMatch = localDeclPattern.exec(code)) !== null) {
+              const name = declMatch[1];
+              if (!exportedLocals.has(name) && !/^_c\d*$/.test(name)) {
+                strippedBindings.push(name);
+              }
+            }
+            const importPattern = /import\s*\{([^}]*)\}\s*from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+            let importMatch;
+            while ((importMatch = importPattern.exec(code)) !== null) {
+              for (const spec of importMatch[1].split(",")) {
+                const m = spec.trim().match(/^[A-Za-z_$][\w$]*(?:\s+as\s+([A-Za-z_$][\w$]*))?$/);
+                if (m)
+                  strippedBindings.push(m[1] || m[0].trim().split(/\s/)[0]);
+              }
+            }
+            const defaultImportPattern = /import\s+([A-Za-z_$][\w$]*)\s+from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+            while ((importMatch = defaultImportPattern.exec(code)) !== null) {
+              strippedBindings.push(importMatch[1]);
+            }
+            const nsImportPattern = /import\s+\*\s+as\s+([A-Za-z_$][\w$]*)\s+from\s*["'](?!@rangojs\/router)[^"']*["']/g;
+            while ((importMatch = nsImportPattern.exec(code)) !== null) {
+              strippedBindings.push(importMatch[1]);
+            }
+            if (strippedBindings.length > 0) {
+              const preservedBindings = allBindings.filter((b) => {
+                const fc = code.slice(b.callExprStart, b.callOpenParenPos + 1);
+                return handleFnNames.some((n) => fc.includes(n)) || lsFnNames.some((n) => fc.includes(n));
+              });
+              const strippedRe = new RegExp(
+                `\\b(?:${strippedBindings.join("|")})\\b`
+              );
+              canStubWholeFile = !preservedBindings.some((b) => {
+                const expr = code.slice(
+                  b.callExprStart,
+                  b.callCloseParenPos + 1
+                );
+                return strippedRe.test(expr);
+              });
+            }
+          }
+          if (canStubWholeFile) {
+            const lines = [];
+            const neededImports = [];
+            if (handleFnNames.length > 0) neededImports.push("createHandle");
+            if (lsFnNames.length > 0) neededImports.push("createLocationState");
+            if (neededImports.length > 0) {
+              lines.push(
+                `import { ${neededImports.join(", ")} } from "@rangojs/router";`
+              );
+            }
+            for (const binding of allBindings) {
+              const fnCall = code.slice(
+                binding.callExprStart,
+                binding.callOpenParenPos + 1
+              );
+              const isHandle = handleFnNames.some((n) => fnCall.includes(n));
+              const isLocationState = lsFnNames.some((n) => fnCall.includes(n));
+              const primaryName = binding.exportNames[0];
+              const stubId = makeStubId(filePath, primaryName, isBuild);
+              if (isHandle || isLocationState) {
+                const rawArgs = code.slice(
+                  binding.callOpenParenPos + 1,
+                  binding.callCloseParenPos
+                ).replace(/\b_c\d*\s*=\s*/g, "");
+                const canonicalName = isHandle ? "createHandle" : "createLocationState";
+                const activeFnNames = isHandle ? handleFnNames : lsFnNames;
+                let rawCallee = code.slice(
+                  binding.callExprStart,
+                  binding.callOpenParenPos
+                );
+                for (const alias of activeFnNames) {
+                  if (alias !== canonicalName && rawCallee.startsWith(alias)) {
+                    rawCallee = canonicalName + rawCallee.slice(alias.length);
+                    break;
+                  }
+                }
+                if (isHandle) {
+                  const idParam = binding.argCount === 0 ? `undefined, "${stubId}"` : `, "${stubId}"`;
+                  lines.push(
+                    `export const ${primaryName} = ${rawCallee}(${rawArgs}${idParam});`
+                  );
+                  lines.push(`${primaryName}.$$id = "${stubId}";`);
+                } else {
+                  lines.push(
+                    `export const ${primaryName} = ${rawCallee}(${rawArgs});`
+                  );
+                  lines.push(
+                    `${primaryName}.__rsc_ls_key = "__rsc_ls_${stubId}";`
+                  );
+                }
+                for (const name of binding.exportNames.slice(1)) {
+                  lines.push(`export const ${name} = ${primaryName};`);
+                }
+              } else {
+                let brand = "loader";
+                if (prerenderFnNames.some((n) => fnCall.includes(n))) {
+                  brand = PRERENDER_CONFIG.brand;
+                } else if (staticFnNames.some((n) => fnCall.includes(n))) {
+                  brand = STATIC_CONFIG.brand;
+                }
+                lines.push(
+                  `export const ${primaryName} = { __brand: "${brand}", $$id: "${stubId}" };`
+                );
+                for (const name of binding.exportNames.slice(1)) {
+                  lines.push(`export const ${name} = ${primaryName};`);
+                }
+              }
+            }
+            return { code: lines.join("\n") + "\n", map: null };
           }
         }
-      }
-      if (hasStaticHandlerCode && !isRscEnv) {
-        const fnNames = getFnNames(STATIC_CONFIG.fnName);
-        const bindings = getBindings(code, fnNames);
-        const wholeFile = generateWholeFileStubs(
-          STATIC_CONFIG,
-          bindings,
-          code,
-          filePath,
-          isBuild
-        );
-        if (wholeFile) return wholeFile;
-        const exprStubs = generateExprStubs(
-          STATIC_CONFIG,
-          bindings,
-          code,
-          filePath,
-          id,
-          isBuild
-        );
-        if (exprStubs) return exprStubs;
-      }
-      if (hasStaticHandlerCode && isRscEnv && isBuild) {
-        const fnNames = getFnNames(STATIC_CONFIG.fnName);
-        const exportNames = getBindings(code, fnNames).map(
-          (b) => b.exportNames[0]
-        );
-        if (exportNames.length > 0) {
-          staticHandlerModules.set(id, exportNames);
+        if (hasStaticHandlerCode && isRscEnv && isBuild) {
+          const fnNames = getFnNames(STATIC_CONFIG.fnName);
+          const exportNames = getBindings(code, fnNames).map(
+            (b) => b.exportNames[0]
+          );
+          if (exportNames.length > 0) {
+            staticHandlerModules.set(id, exportNames);
+          }
         }
+        const s = new MagicString4(code);
+        if (hasLoaderCode) {
+          const fnNames = getFnNames("createLoader");
+          changed = transformLoaders(
+            getBindings(code, fnNames),
+            s,
+            filePath,
+            isBuild
+          ) || changed;
+        }
+        if (hasHandleCode) {
+          const fnNames = getFnNames("createHandle");
+          changed = transformHandles(
+            getBindings(code, fnNames),
+            s,
+            code,
+            filePath,
+            isBuild
+          ) || changed;
+        }
+        if (hasLocationStateCode) {
+          const fnNames = getFnNames("createLocationState");
+          changed = transformLocationState(
+            getBindings(code, fnNames),
+            s,
+            filePath,
+            isBuild
+          ) || changed;
+        }
+        if (hasPrerenderHandlerCode) {
+          const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
+          const bindings = getBindings(code, fnNames);
+          if (isRscEnv) {
+            changed = transformHandlerIds(
+              PRERENDER_CONFIG,
+              bindings,
+              s,
+              filePath,
+              isBuild
+            ) || changed;
+          } else {
+            changed = stubHandlerExprs(
+              PRERENDER_CONFIG,
+              bindings,
+              s,
+              filePath,
+              isBuild
+            ) || changed;
+          }
+        }
+        if (hasStaticHandlerCode) {
+          const fnNames = getFnNames(STATIC_CONFIG.fnName);
+          const bindings = getBindings(code, fnNames);
+          if (isRscEnv) {
+            changed = transformHandlerIds(
+              STATIC_CONFIG,
+              bindings,
+              s,
+              filePath,
+              isBuild
+            ) || changed;
+          } else {
+            changed = stubHandlerExprs(STATIC_CONFIG, bindings, s, filePath, isBuild) || changed;
+          }
+        }
+        if (!changed) return;
+        return {
+          code: s.toString(),
+          map: s.generateMap({ source: id, includeContent: true })
+        };
+      } finally {
+        counter?.record(id, performance.now() - __t0);
       }
-      const s = new MagicString4(code);
-      if (hasLoaderCode) {
-        const fnNames = getFnNames("createLoader");
-        changed = transformLoaders(getBindings(code, fnNames), s, filePath, isBuild) || changed;
-      }
-      if (hasHandleCode) {
-        const fnNames = getFnNames("createHandle");
-        changed = transformHandles(
-          getBindings(code, fnNames),
-          s,
-          code,
-          filePath,
-          isBuild
-        ) || changed;
-      }
-      if (hasLocationStateCode) {
-        const fnNames = getFnNames("createLocationState");
-        changed = transformLocationState(
-          getBindings(code, fnNames),
-          s,
-          filePath,
-          isBuild
-        ) || changed;
-      }
-      if (hasPrerenderHandlerCode && isRscEnv) {
-        const fnNames = getFnNames(PRERENDER_CONFIG.fnName);
-        changed = transformHandlerIds(
-          PRERENDER_CONFIG,
-          getBindings(code, fnNames),
-          s,
-          filePath,
-          isBuild
-        ) || changed;
-      }
-      if (hasStaticHandlerCode && isRscEnv) {
-        const fnNames = getFnNames(STATIC_CONFIG.fnName);
-        changed = transformHandlerIds(
-          STATIC_CONFIG,
-          getBindings(code, fnNames),
-          s,
-          filePath,
-          isBuild
-        ) || changed;
-      }
-      if (!changed) return;
-      return {
-        code: s.toString(),
-        map: s.generateMap({ source: id, includeContent: true })
-      };
     }
   };
 }
@@ -1404,12 +1676,14 @@ ${lazyImports.join(",\n")}
 // src/vite/plugins/use-cache-transform.ts
 import path5 from "node:path";
 import MagicString5 from "magic-string";
+var debug4 = createRangoDebugger(NS.transform);
 var CACHE_RUNTIME_IMPORT = "@rangojs/router/cache-runtime";
 var LAYOUT_TEMPLATE_PATTERN = /\/(layout|template)\.(tsx?|jsx?)$/;
 function useCacheTransform() {
   let projectRoot = "";
   let isBuild = false;
   let rscTransforms = null;
+  const counter = createCounter(debug4, "use-cache");
   return {
     name: "@rangojs/router:use-cache",
     enforce: "post",
@@ -1417,53 +1691,61 @@ function useCacheTransform() {
       projectRoot = config.root;
       isBuild = config.command === "build";
     },
+    buildEnd() {
+      counter?.flush();
+    },
     async transform(code, id) {
       if (this.environment?.name !== "rsc") return;
       if (!code.includes("use cache")) return;
       if (id.includes("/node_modules/") || id.startsWith("\0")) return;
       if (!/\.(tsx?|jsx?|mjs)$/.test(id)) return;
-      if (!rscTransforms) {
+      const start = counter ? performance.now() : 0;
+      try {
+        if (!rscTransforms) {
+          try {
+            rscTransforms = await import("@vitejs/plugin-rsc/transforms");
+          } catch {
+            return;
+          }
+        }
+        const {
+          hasDirective,
+          transformWrapExport,
+          transformHoistInlineDirective
+        } = rscTransforms;
+        let ast;
         try {
-          rscTransforms = await import("@vitejs/plugin-rsc/transforms");
+          const { parseAst: parseAst4 } = await import("vite");
+          ast = parseAst4(code);
         } catch {
           return;
         }
-      }
-      const {
-        hasDirective,
-        transformWrapExport,
-        transformHoistInlineDirective
-      } = rscTransforms;
-      let ast;
-      try {
-        const { parseAst: parseAst4 } = await import("vite");
-        ast = parseAst4(code);
-      } catch {
-        return;
-      }
-      const filePath = normalizePath(path5.relative(projectRoot, id));
-      const isLayoutOrTemplate = LAYOUT_TEMPLATE_PATTERN.test(id);
-      if (hasDirective(ast.body, "use cache")) {
-        return transformFileLevelUseCache(
+        const filePath = normalizePath(path5.relative(projectRoot, id));
+        const isLayoutOrTemplate = LAYOUT_TEMPLATE_PATTERN.test(id);
+        if (hasDirective(ast.body, "use cache")) {
+          return transformFileLevelUseCache(
+            code,
+            ast,
+            filePath,
+            id,
+            isBuild,
+            isLayoutOrTemplate,
+            transformWrapExport
+          );
+        }
+        const functionResult = transformFunctionLevelUseCache(
           code,
           ast,
           filePath,
           id,
           isBuild,
-          isLayoutOrTemplate,
-          transformWrapExport
+          transformHoistInlineDirective
         );
+        warnOnNearMissDirectives(ast, id, this.warn.bind(this));
+        if (functionResult) return functionResult;
+      } finally {
+        counter?.record(id, performance.now() - start);
       }
-      const functionResult = transformFunctionLevelUseCache(
-        code,
-        ast,
-        filePath,
-        id,
-        isBuild,
-        transformHoistInlineDirective
-      );
-      warnOnNearMissDirectives(ast, id, this.warn.bind(this));
-      if (functionResult) return functionResult;
     }
   };
 }
@@ -1586,6 +1868,7 @@ function warnOnNearMissDirectives(ast, fileId, warn) {
 }
 
 // src/vite/plugins/client-ref-dedup.ts
+var debug5 = createRangoDebugger(NS.transform);
 var CLIENT_IN_SERVER_PROXY_PREFIX = "virtual:vite-rsc/client-in-server-package-proxy/";
 function extractPackageName(absolutePath) {
   const marker = "/node_modules/";
@@ -1602,6 +1885,7 @@ function extractPackageName(absolutePath) {
 }
 function clientRefDedup() {
   let clientExclude = [];
+  const dedupedPackages = /* @__PURE__ */ new Set();
   return {
     name: "@rangojs/router:client-ref-dedup",
     enforce: "pre",
@@ -1610,6 +1894,15 @@ function clientRefDedup() {
       const clientEnv = config.environments?.["client"];
       clientExclude = clientEnv?.optimizeDeps?.exclude ?? config.optimizeDeps?.exclude ?? [];
     },
+    buildEnd() {
+      if (debug5 && dedupedPackages.size > 0) {
+        debug5(
+          "client-ref-dedup: redirected %d package(s) (%s)",
+          dedupedPackages.size,
+          [...dedupedPackages].join(",")
+        );
+      }
+    },
     resolveId(source, importer, options) {
       if (this.environment?.name !== "client") return;
       if (!importer?.includes(CLIENT_IN_SERVER_PROXY_PREFIX)) return;
@@ -1618,6 +1911,7 @@ function clientRefDedup() {
       const packageName = extractPackageName(source);
       if (!packageName) return;
       if (clientExclude.includes(packageName)) return;
+      if (debug5) dedupedPackages.add(packageName);
       return `\0rango:dedup/${packageName}`;
     },
     load(id) {
@@ -1740,12 +2034,13 @@ function getVirtualVersionContent(version) {
 
 // src/vite/utils/package-resolution.ts
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { resolve } from "node:path";
 
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.88a3b2f7",
+  version: "0.0.0-experimental.89",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -1878,22 +2173,24 @@ var package_default = {
     tag: "experimental"
   },
   scripts: {
-    build: "pnpm dlx esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && pnpm dlx esbuild src/bin/rango.ts --bundle --format=esm --outfile=dist/bin/rango.js --platform=node --packages=external --banner:js='#!/usr/bin/env node' && chmod +x dist/bin/rango.js",
+    build: "pnpm dlx esbuild src/vite/index.ts --bundle --format=esm --outfile=dist/vite/index.js --platform=node --packages=external && mkdir -p dist/vite/plugins && cp src/vite/plugins/cloudflare-protocol-loader-hook.mjs dist/vite/plugins/cloudflare-protocol-loader-hook.mjs && pnpm dlx esbuild src/bin/rango.ts --bundle --format=esm --outfile=dist/bin/rango.js --platform=node --packages=external --banner:js='#!/usr/bin/env node' && chmod +x dist/bin/rango.js",
     prepublishOnly: "pnpm build",
-    typecheck: "tsc --noEmit",
+    typecheck: "tsc --noEmit && tsc -p tsconfig.strict-check.json --noEmit",
     test: "playwright test",
     "test:ui": "playwright test --ui",
     "test:unit": "vitest run",
     "test:unit:watch": "vitest"
   },
   dependencies: {
-    "@vitejs/plugin-rsc": "^0.5.19",
+    "@vitejs/plugin-rsc": "^0.5.23",
+    debug: "^4.4.1",
     "magic-string": "^0.30.17",
     picomatch: "^4.0.3",
     "rsc-html-stream": "^0.0.7"
   },
   devDependencies: {
     "@playwright/test": "^1.49.1",
+    "@types/debug": "^4.1.12",
     "@types/node": "^24.10.1",
     "@types/react": "catalog:",
     "@types/react-dom": "catalog:",
@@ -1907,7 +2204,7 @@ var package_default = {
   },
   peerDependencies: {
     "@cloudflare/vite-plugin": "^1.25.0",
-    "@vitejs/plugin-rsc": "^0.5.14",
+    "@vitejs/plugin-rsc": "^0.5.23",
     react: "^18.0.0 || ^19.0.0",
     vite: "^7.3.0"
   },
@@ -1922,6 +2219,7 @@ var package_default = {
 };
 
 // src/vite/utils/package-resolution.ts
+var require2 = createRequire(import.meta.url);
 var VIRTUAL_PACKAGE_NAME = "@rangojs/router";
 function getPublishedPackageName() {
   return package_default.name;
@@ -1962,6 +2260,20 @@ function getPackageAliases() {
   }
   return aliases;
 }
+function getVendorAliases() {
+  const specs = [
+    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge",
+    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+  ];
+  const aliases = {};
+  for (const spec of specs) {
+    try {
+      aliases[spec] = require2.resolve(spec);
+    } catch {
+    }
+  }
+  return aliases;
+}
 
 // src/build/route-types/param-extraction.ts
 function extractParamsFromPattern(pattern) {
@@ -2859,6 +3171,7 @@ import * as Vite from "vite";
 
 // src/vite/plugins/performance-tracks.ts
 import { readFile } from "node:fs/promises";
+var debug6 = createRangoDebugger(NS.transform);
 var RSDW_PATCH_RE = /((?:var|let|const)\s+\w+\s*=\s*root\._children\s*,\s*(\w+)\s*=\s*root\._debugInfo\s*[;,])/;
 function buildPatchReplacement(match, debugInfoVar) {
   return `${match}
@@ -2900,19 +3213,23 @@ function performanceTracksOptimizeDepsPlugin() {
   };
 }
 function performanceTracksPlugin() {
+  const counter = createCounter(debug6, "performance-tracks");
   return {
     name: "@rangojs/router:performance-tracks",
+    buildEnd() {
+      counter?.flush();
+    },
     transform(code, id) {
       if (!id.includes("react-server-dom") || !id.includes("client")) return;
-      const patched = patchRsdwClientDebugInfoRecovery(code);
-      if (!patched.debugInfoVar) return;
-      if (process.env.INTERNAL_RANGO_DEBUG)
-        console.log(
-          "[perf-tracks] patched RSDW client (var:",
-          patched.debugInfoVar,
-          ")"
-        );
-      return patched.code;
+      const start = counter ? performance.now() : 0;
+      try {
+        const patched = patchRsdwClientDebugInfoRecovery(code);
+        if (!patched.debugInfoVar) return;
+        debug6?.("patched RSDW client (var: %s)", patched.debugInfoVar);
+        return patched.code;
+      } finally {
+        counter?.record(id, performance.now() - start);
+      }
     }
   };
 }
@@ -3083,6 +3400,7 @@ function createVersionInjectorPlugin(rscEntryPath) {
 }
 
 // src/vite/plugins/cjs-to-esm.ts
+var debug7 = createRangoDebugger(NS.transform);
 function createCjsToEsmPlugin() {
   return {
     name: "@rangojs/router:cjs-to-esm",
@@ -3092,6 +3410,7 @@ function createCjsToEsmPlugin() {
       if (cleanId.includes("vendor/react-server-dom/client.browser.js") || cleanId.includes("vendor\\react-server-dom\\client.browser.js")) {
         const isProd = process.env.NODE_ENV === "production";
         const cjsFile = isProd ? "./cjs/react-server-dom-webpack-client.browser.production.js" : "./cjs/react-server-dom-webpack-client.browser.development.js";
+        debug7?.("cjs-to-esm entry redirect %s", id);
         return {
           code: `export * from "${cjsFile}";`,
           map: null
@@ -3127,6 +3446,7 @@ function createCjsToEsmPlugin() {
           "export const $1 ="
         );
         transformed = license + "\n" + transformed;
+        debug7?.("cjs-to-esm body rewrite %s", id);
         return {
           code: transformed,
           map: null
@@ -3141,7 +3461,7 @@ function createCjsToEsmPlugin() {
 import { createServer as createViteServer } from "vite";
 import { resolve as resolve8 } from "node:path";
 import { readFileSync as readFileSync6 } from "node:fs";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2, register } from "node:module";
 import { pathToFileURL } from "node:url";
 
 // src/vite/plugins/virtual-stub-plugin.ts
@@ -3168,9 +3488,117 @@ function createVirtualStubPlugin() {
   };
 }
 
+// src/vite/plugins/cloudflare-protocol-stub.ts
+var VIRTUAL_PREFIX = "virtual:rango-cloudflare-stub-";
+var NULL_PREFIX = "\0" + VIRTUAL_PREFIX;
+var CF_PREFIX = "cloudflare:";
+var BUILD_ENV_GLOBAL_KEY = "__rango_build_env__";
+var SOURCE_EXT_RE = /\.[mc]?[jt]sx?$/;
+var IMPORT_NODE_TYPES = /* @__PURE__ */ new Set([
+  "ImportDeclaration",
+  "ImportExpression",
+  "ExportNamedDeclaration",
+  "ExportAllDeclaration"
+]);
+var STUBS = {
+  "cloudflare:workers": `
+export class DurableObject { constructor(_ctx, _env) {} }
+export class WorkerEntrypoint { constructor(_ctx, _env) {} }
+export class WorkflowEntrypoint { constructor(_ctx, _env) {} }
+export class RpcTarget {}
+export const env = globalThis[${JSON.stringify(BUILD_ENV_GLOBAL_KEY)}] ?? {};
+export default {};
+`,
+  "cloudflare:email": `
+export class EmailMessage { constructor(_from, _to, _raw) {} }
+export default {};
+`,
+  "cloudflare:sockets": `
+export function connect() { return {}; }
+export default {};
+`,
+  "cloudflare:workflows": `
+export class NonRetryableError extends Error {
+  constructor(message, name) { super(message); this.name = name ?? "NonRetryableError"; }
+}
+export default {};
+`
+};
+var FALLBACK_STUB = `export default {};
+`;
+function createCloudflareProtocolStubPlugin() {
+  return {
+    name: "@rangojs/router:cloudflare-protocol-stub",
+    transform(code, id) {
+      const cleanId = id.split("?")[0] ?? id;
+      if (!SOURCE_EXT_RE.test(cleanId)) return null;
+      if (!code.includes(CF_PREFIX)) return null;
+      let ast;
+      try {
+        ast = this.parse(code);
+      } catch {
+        return null;
+      }
+      const hits = [];
+      walk(ast, (node) => {
+        if (!IMPORT_NODE_TYPES.has(node.type)) return;
+        const source = node.source;
+        if (!source || source.type !== "Literal") return;
+        if (typeof source.value !== "string") return;
+        if (!source.value.startsWith(CF_PREFIX)) return;
+        if (typeof source.start !== "number" || typeof source.end !== "number")
+          return;
+        hits.push({
+          start: source.start,
+          end: source.end,
+          value: source.value
+        });
+      });
+      if (hits.length === 0) return null;
+      hits.sort((a, b) => b.start - a.start);
+      let out = code;
+      for (const hit of hits) {
+        const submodule = hit.value.slice(CF_PREFIX.length);
+        const quote = code[hit.start] === "'" ? "'" : '"';
+        out = out.slice(0, hit.start) + quote + VIRTUAL_PREFIX + submodule + quote + out.slice(hit.end);
+      }
+      return { code: out, map: null };
+    },
+    resolveId(id) {
+      if (id.startsWith(VIRTUAL_PREFIX)) {
+        return "\0" + id;
+      }
+      return null;
+    },
+    load(id) {
+      if (!id.startsWith(NULL_PREFIX)) return null;
+      const submodule = id.slice(NULL_PREFIX.length);
+      const specifier = CF_PREFIX + submodule;
+      return STUBS[specifier] ?? FALLBACK_STUB;
+    }
+  };
+}
+function walk(node, visit) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, visit);
+    return;
+  }
+  const n = node;
+  if (typeof n.type !== "string") return;
+  visit(n);
+  for (const key in n) {
+    if (key === "loc" || key === "start" || key === "end" || key === "range") {
+      continue;
+    }
+    walk(n[key], visit);
+  }
+}
+
 // src/vite/plugins/client-ref-hashing.ts
 import { relative } from "node:path";
 import { createHash as createHash2 } from "node:crypto";
+var debug8 = createRangoDebugger(NS.transform);
 var CLIENT_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-package-proxy/";
 var CLIENT_IN_SERVER_PKG_PROXY_PREFIX = "/@id/__x00__virtual:vite-rsc/client-in-server-package-proxy/";
 var FS_PREFIX = "/@fs/";
@@ -3209,6 +3637,7 @@ function transformClientRefs(code, projectRoot) {
   return hasReplacement ? result : null;
 }
 function hashClientRefs(projectRoot) {
+  const counter = createCounter(debug8, "hash-client-refs");
   return {
     name: "@rangojs/router:hash-client-refs",
     // Run after the RSC plugin's transform (default enforce is normal)
@@ -3216,10 +3645,18 @@ function hashClientRefs(projectRoot) {
     applyToEnvironment(env) {
       return env.name === "rsc";
     },
-    transform(code, _id) {
-      const result = transformClientRefs(code, projectRoot);
-      if (result === null) return;
-      return { code: result, map: null };
+    buildEnd() {
+      counter?.flush();
+    },
+    transform(code, id) {
+      const start = counter ? performance.now() : 0;
+      try {
+        const result = transformClientRefs(code, projectRoot);
+        if (result === null) return;
+        return { code: result, map: null };
+      } finally {
+        counter?.record(id, performance.now() - start);
+      }
     }
   };
 }
@@ -3461,11 +3898,19 @@ function substituteRouteParams(pattern, params, encode = encodeURIComponent) {
   let hadOmittedOptional = false;
   for (const [key, value] of Object.entries(params)) {
     const escaped = escapeRegExp2(key);
-    result = result.replace(
-      new RegExp(`:${escaped}(\\([^)]*\\))?\\??`),
-      encode(value)
-    );
-    result = result.replace(`*${key}`, encode(value));
+    if (value === "") {
+      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));
+    }
   }
   result = result.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)(\([^)]*\))?\?/g, () => {
     hadOmittedOptional = true;
@@ -3571,8 +4016,14 @@ function copyStagedBuildAssets(projectRoot, fileNames) {
 }
 
 // src/vite/discovery/prerender-collection.ts
+var debug9 = createRangoDebugger(NS.prerender);
 async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
   if (!state.opts?.enableBuildPrerender || !state.isBuildMode) return;
+  const overallStart = debug9 ? performance.now() : 0;
+  debug9?.(
+    "expandPrerenderRoutes: start (%d router manifest(s))",
+    allManifests.length
+  );
   const entries = [];
   const allRoutes = {};
   for (const { manifest: m } of allManifests) {
@@ -3584,100 +4035,151 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
     if (!params) return pattern;
     return substituteRouteParams(pattern, params);
   };
+  let resolvedRoutes = 0;
+  let totalDynamic = 0;
   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 = passthroughSet.has(routeName);
-      const hasDynamic = pattern.includes(":") || pattern.includes("*");
-      if (!hasDynamic) {
-        entries.push({
-          urlPath: pattern.replace(/\/$/, "") || "/",
-          routeName,
-          concurrency: 1,
-          isPassthroughRoute
-        });
-      } else {
-        if (def?.getParams) {
-          try {
-            const buildVars = {};
-            const buildEnv = state.resolvedBuildEnv;
-            const getParamsCtx = {
-              build: true,
-              dev: !state.isBuildMode,
-              set: ((keyOrVar, value) => {
-                contextSet(buildVars, keyOrVar, value);
-              }),
-              reverse: getParamsReverse,
-              get env() {
-                if (buildEnv !== void 0) 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;
-            const hasBuildVars = Object.keys(buildVars).length > 0 || Object.getOwnPropertySymbols(buildVars).length > 0;
-            for (const params of paramsList) {
-              let url = substituteRouteParams(
-                pattern,
-                params,
-                encodePathParam
-              );
-              if (url.includes("*")) {
-                const wildcardValue = params["*"] ?? params.splat;
-                if (wildcardValue !== void 0) {
-                  url = url.replace(/\*[^/]*$/, encodePathParam(wildcardValue));
+      if (pattern && (pattern.includes(":") || pattern.includes("*"))) {
+        totalDynamic++;
+      }
+    }
+  }
+  const paramsStart = performance.now();
+  const progressInterval = totalDynamic > 0 ? setInterval(() => {
+    const elapsed = ((performance.now() - paramsStart) / 1e3).toFixed(1);
+    console.log(
+      `[rsc-router] Resolving prerender params... ${resolvedRoutes}/${totalDynamic} routes (${elapsed}s)`
+    );
+  }, 5e3) : void 0;
+  try {
+    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 = passthroughSet.has(routeName);
+        const hasDynamic = pattern.includes(":") || pattern.includes("*");
+        if (!hasDynamic) {
+          entries.push({
+            urlPath: pattern.replace(/\/$/, "") || "/",
+            routeName,
+            concurrency: 1,
+            isPassthroughRoute
+          });
+        } else {
+          if (def?.getParams) {
+            const getParamsStart = debug9 ? performance.now() : 0;
+            try {
+              const buildVars = {};
+              const buildEnv = state.resolvedBuildEnv;
+              const getParamsCtx = {
+                build: true,
+                dev: !state.isBuildMode,
+                set: ((keyOrVar, value) => {
+                  contextSet(buildVars, keyOrVar, value);
+                }),
+                reverse: getParamsReverse,
+                get env() {
+                  if (buildEnv !== void 0) 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."
+                  );
                 }
-              }
-              entries.push({
-                urlPath: url.replace(/\/$/, "") || "/",
+              };
+              const paramsList = await def.getParams(getParamsCtx);
+              debug9?.(
+                "getParams %s -> %d params (%sms)",
                 routeName,
-                concurrency,
-                ...hasBuildVars ? { buildVars } : {},
-                isPassthroughRoute
-              });
-            }
-          } catch (err) {
-            if (err.name === "Skip") {
-              console.log(
-                `[rsc-router]   SKIP route "${routeName}" - ${err.message}`
+                paramsList.length,
+                (performance.now() - getParamsStart).toFixed(1)
               );
-              notifyOnError(
-                registry,
-                err,
-                "prerender",
-                routeName,
-                void 0,
-                true
+              const concurrency = def.options?.concurrency ?? 1;
+              const hasBuildVars = Object.keys(buildVars).length > 0 || Object.getOwnPropertySymbols(buildVars).length > 0;
+              for (const params of paramsList) {
+                let url = substituteRouteParams(
+                  pattern,
+                  params,
+                  encodePathParam
+                );
+                if (url.includes("*")) {
+                  const wildcardValue = params["*"] ?? params.splat;
+                  if (wildcardValue !== void 0) {
+                    url = url.replace(
+                      /\*[^/]*$/,
+                      encodePathParam(wildcardValue)
+                    );
+                  }
+                }
+                entries.push({
+                  urlPath: url.replace(/\/$/, "") || "/",
+                  routeName,
+                  concurrency,
+                  ...hasBuildVars ? { buildVars } : {},
+                  isPassthroughRoute
+                });
+              }
+              resolvedRoutes++;
+            } catch (err) {
+              resolvedRoutes++;
+              if (err.name === "Skip") {
+                console.log(
+                  `[rsc-router]   SKIP route "${routeName}" - ${err.message}`
+                );
+                notifyOnError(
+                  registry,
+                  err,
+                  "prerender",
+                  routeName,
+                  void 0,
+                  true
+                );
+                continue;
+              }
+              console.error(
+                `[rsc-router] Failed to get params for prerender route "${routeName}": ${err.message}`
               );
-              continue;
+              notifyOnError(registry, err, "prerender", routeName);
+              throw err;
             }
-            console.error(
-              `[rsc-router] Failed to get params for prerender route "${routeName}": ${err.message}`
+          } else {
+            console.warn(
+              `[rsc-router] Dynamic prerender route "${routeName}" has no getParams(), skipping`
             );
-            notifyOnError(registry, err, "prerender", routeName);
-            throw err;
           }
-        } else {
-          console.warn(
-            `[rsc-router] Dynamic prerender route "${routeName}" has no getParams(), skipping`
-          );
         }
       }
     }
+  } finally {
+    if (progressInterval) {
+      clearInterval(progressInterval);
+      const elapsed = ((performance.now() - paramsStart) / 1e3).toFixed(1);
+      console.log(
+        `[rsc-router] Resolved prerender params: ${resolvedRoutes}/${totalDynamic} routes (${elapsed}s)`
+      );
+    }
+  }
+  if (entries.length === 0) {
+    debug9?.(
+      "no prerender entries (done in %sms)",
+      (performance.now() - overallStart).toFixed(1)
+    );
+    return;
   }
-  if (entries.length === 0) return;
   const maxConcurrency = Math.max(...entries.map((e) => e.concurrency));
   const concurrencyNote = maxConcurrency > 1 ? ` (concurrency: ${maxConcurrency})` : "";
   console.log(
     `[rsc-router] Pre-rendering ${entries.length} URL(s)${concurrencyNote}...`
   );
+  debug9?.(
+    "prerender loop: %d entries, max concurrency %d",
+    entries.length,
+    maxConcurrency
+  );
   const { hashParams } = await rscEnv.runner.import("@rangojs/router/build");
   const manifestEntries = {};
   let doneCount = 0;
@@ -3784,10 +4286,22 @@ async function expandPrerenderRoutes(state, rscEnv, registry, allManifests) {
   console.log(
     `[rsc-router] Pre-render complete: ${parts.join(", ")} (${totalElapsed}ms total)`
   );
+  debug9?.(
+    "expandPrerenderRoutes done: %d done, %d skipped, %sms (overall %sms)",
+    doneCount,
+    skipCount,
+    totalElapsed,
+    (performance.now() - overallStart).toFixed(1)
+  );
 }
 async function renderStaticHandlers(state, rscEnv, registry) {
   if (!state.opts?.enableBuildPrerender || !state.isBuildMode || !state.resolvedStaticModules?.size)
     return;
+  const overallStart = debug9 ? performance.now() : 0;
+  debug9?.(
+    "renderStaticHandlers: start (%d static module(s))",
+    state.resolvedStaticModules.size
+  );
   const manifestEntries = {};
   let staticDone = 0;
   let staticSkip = 0;
@@ -3877,13 +4391,29 @@ async function renderStaticHandlers(state, rscEnv, registry) {
   console.log(
     `[rsc-router] Static render complete: ${staticParts.join(", ")} (${totalStaticElapsed}ms total)`
   );
+  debug9?.(
+    "renderStaticHandlers done: %d done, %d skipped, %sms (overall %sms)",
+    staticDone,
+    staticSkip,
+    totalStaticElapsed,
+    (performance.now() - overallStart).toFixed(1)
+  );
 }
 
 // src/vite/discovery/discover-routers.ts
+var debug10 = createRangoDebugger(NS.discovery);
 async function discoverRouters(state, rscEnv) {
   if (!state.resolvedEntryPath) return;
-  await rscEnv.runner.import(state.resolvedEntryPath);
-  const serverMod = await rscEnv.runner.import("@rangojs/router/server");
+  await timed(
+    debug10,
+    "inner: import entry",
+    () => rscEnv.runner.import(state.resolvedEntryPath)
+  );
+  const serverMod = await timed(
+    debug10,
+    "inner: import @rangojs/router/server",
+    () => rscEnv.runner.import("@rangojs/router/server")
+  );
   let registry = serverMod.RouterRegistry;
   if (!registry || registry.size === 0) {
     try {
@@ -3925,8 +4455,13 @@ async function discoverRouters(state, rscEnv) {
       );
     }
   }
-  const buildMod = await rscEnv.runner.import("@rangojs/router/build");
+  const buildMod = await timed(
+    debug10,
+    "inner: import @rangojs/router/build",
+    () => rscEnv.runner.import("@rangojs/router/build")
+  );
   const generateManifestFull = buildMod.generateManifestFull;
+  debug10?.("inner: found %d router(s) in registry", registry.size);
   const nestedRouterConflict = findNestedRouterConflict(
     [...registry.values()].map((router) => router.__sourceFile).filter(
       (sourceFile) => typeof sourceFile === "string"
@@ -3945,6 +4480,7 @@ async function discoverRouters(state, rscEnv) {
   let mergedRouteTrailingSlash = {};
   let routerMountIndex = 0;
   const allManifests = [];
+  const manifestGenStart = debug10 ? performance.now() : 0;
   for (const [id, router] of registry) {
     if (!router.urlpatterns || !generateManifestFull) {
       continue;
@@ -4019,7 +4555,13 @@ async function discoverRouters(state, rscEnv) {
       );
     }
   }
+  debug10?.(
+    "inner: generated manifests for %d router(s) (%sms)",
+    allManifests.length,
+    (performance.now() - manifestGenStart).toFixed(1)
+  );
   let newMergedRouteTrie = null;
+  const trieStart = debug10 ? performance.now() : 0;
   if (Object.keys(newMergedRouteManifest).length > 0) {
     const buildRouteTrie = buildMod.buildRouteTrie;
     if (buildRouteTrie && mergedRouteAncestry) {
@@ -4082,6 +4624,10 @@ async function discoverRouters(state, rscEnv) {
       }
     }
   }
+  debug10?.(
+    "inner: trie build done (%sms)",
+    (performance.now() - trieStart).toFixed(1)
+  );
   state.mergedRouteManifest = newMergedRouteManifest;
   state.mergedPrecomputedEntries = newMergedPrecomputedEntries;
   state.perRouterManifests = newPerRouterManifests;
@@ -4522,7 +5068,26 @@ function postprocessBundle(state) {
 }
 
 // src/vite/router-discovery.ts
+var debugDiscovery = createRangoDebugger(NS.discovery);
+var debugRoutes = createRangoDebugger(NS.routes);
+var debugBuild = createRangoDebugger(NS.build);
+var debugDev = createRangoDebugger(NS.dev);
+var loaderHookRegistered = false;
+function ensureCloudflareProtocolLoaderRegistered() {
+  if (loaderHookRegistered) return;
+  loaderHookRegistered = true;
+  try {
+    register(
+      new URL("./plugins/cloudflare-protocol-loader-hook.mjs", import.meta.url)
+    );
+  } catch (err) {
+    console.warn(
+      `[rsc-router] Could not register Node ESM loader hook for cloudflare:* imports (${err?.message ?? err}). Falling back to Vite transform only.`
+    );
+  }
+}
 async function createTempRscServer(state, options = {}) {
+  ensureCloudflareProtocolLoaderRegistered();
   const { default: rsc } = await import("@vitejs/plugin-rsc");
   return createViteServer({
     root: state.projectRoot,
@@ -4545,6 +5110,7 @@ async function createTempRscServer(state, options = {}) {
       ...options.forceBuild ? [hashClientRefs(state.projectRoot)] : [],
       createVersionPlugin(),
       createVirtualStubPlugin(),
+      createCloudflareProtocolStubPlugin(),
       // Dev prerender must use dev-mode IDs (path-based) to match the workerd
       // runtime. forceBuild produces hashed IDs for production bundle consistency.
       exposeInternalIds(options.forceBuild ? { forceBuild: true } : void 0),
@@ -4561,7 +5127,7 @@ async function resolveBuildEnv(option, factoryCtx) {
       );
     }
     try {
-      const userRequire = createRequire(
+      const userRequire = createRequire2(
         resolve8(factoryCtx.root, "package.json")
       );
       const wranglerPath = userRequire.resolve("wrangler");
@@ -4596,6 +5162,7 @@ async function acquireBuildEnv(s, command, mode) {
   if (!result) return false;
   s.resolvedBuildEnv = result.env;
   s.buildEnvDispose = result.dispose ?? null;
+  globalThis[BUILD_ENV_GLOBAL_KEY] = result.env;
   return true;
 }
 async function releaseBuildEnv(s) {
@@ -4608,6 +5175,7 @@ async function releaseBuildEnv(s) {
     s.buildEnvDispose = null;
   }
   s.resolvedBuildEnv = void 0;
+  delete globalThis[BUILD_ENV_GLOBAL_KEY];
 }
 function createRouterDiscoveryPlugin(entryPath, opts) {
   const s = createDiscoveryState(entryPath, opts);
@@ -4700,15 +5268,33 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
         return null;
       }
       const discover = async () => {
+        const discoverStart = performance.now();
         const rscEnv = server.environments?.rsc;
         if (!rscEnv?.runner) {
+          debugDiscovery?.("dev: no rsc runner (cloudflare path)");
           s.devServerOrigin = getDevServerOrigin();
           try {
-            await acquireBuildEnv(s, viteCommand, viteMode);
-            const tempRscEnv = await getOrCreateTempServer();
+            await timed(
+              debugDiscovery,
+              "acquireBuildEnv",
+              () => acquireBuildEnv(s, viteCommand, viteMode)
+            );
+            const tempRscEnv = await timed(
+              debugDiscovery,
+              "getOrCreateTempServer",
+              () => getOrCreateTempServer()
+            );
             if (tempRscEnv) {
-              await discoverRouters(s, tempRscEnv);
-              writeRouteTypesFiles(s);
+              await timed(
+                debugDiscovery,
+                "discoverRouters (cloudflare)",
+                () => discoverRouters(s, tempRscEnv)
+              );
+              timedSync(
+                debugDiscovery,
+                "writeRouteTypesFiles",
+                () => writeRouteTypesFiles(s)
+              );
             }
           } catch (err) {
             console.warn(
@@ -4716,27 +5302,54 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
 ${err.stack}`
             );
           }
+          debugDiscovery?.(
+            "dev discovery done (%sms)",
+            (performance.now() - discoverStart).toFixed(1)
+          );
           resolveDiscovery();
           return;
         }
         try {
-          await acquireBuildEnv(s, viteCommand, viteMode);
-          const serverMod = await rscEnv.runner.import(
-            "@rangojs/router/server"
+          debugDiscovery?.("dev: node path start");
+          await timed(
+            debugDiscovery,
+            "acquireBuildEnv",
+            () => acquireBuildEnv(s, viteCommand, viteMode)
+          );
+          const serverMod = await timed(
+            debugDiscovery,
+            "import @rangojs/router/server",
+            () => rscEnv.runner.import("@rangojs/router/server")
           );
           if (serverMod?.setManifestReadyPromise) {
             serverMod.setManifestReadyPromise(discoveryPromise);
           }
-          await discoverRouters(s, rscEnv);
+          await timed(
+            debugDiscovery,
+            "discoverRouters",
+            () => discoverRouters(s, rscEnv)
+          );
           s.devServerOrigin = getDevServerOrigin();
-          writeRouteTypesFiles(s);
-          await propagateDiscoveryState(rscEnv);
+          timedSync(
+            debugDiscovery,
+            "writeRouteTypesFiles",
+            () => writeRouteTypesFiles(s)
+          );
+          await timed(
+            debugDiscovery,
+            "propagateDiscoveryState",
+            () => propagateDiscoveryState(rscEnv)
+          );
         } catch (err) {
           console.warn(
             `[rsc-router] Router discovery failed: ${err.message}
 ${err.stack}`
           );
         } finally {
+          debugDiscovery?.(
+            "dev discovery done (%sms)",
+            (performance.now() - discoverStart).toFixed(1)
+          );
           resolveDiscovery();
         }
       };
@@ -4777,15 +5390,46 @@ ${err.stack}`
         }
       };
       server.middlewares.use("/__rsc_prerender", async (req, res) => {
+        const reqStart = debugDev ? performance.now() : 0;
+        const logResult = (status, note) => {
+          debugDev?.(
+            "/__rsc_prerender %s -> %d %s (%sms)",
+            req.url,
+            status,
+            note,
+            (performance.now() - reqStart).toFixed(1)
+          );
+        };
         if (s.discoveryDone) await s.discoveryDone;
         const url = new URL(req.url || "/", "http://localhost");
         const pathname = url.searchParams.get("pathname");
         if (!pathname) {
           res.statusCode = 400;
           res.end("Missing pathname");
+          logResult(400, "missing pathname");
           return;
         }
-        let registry = mainRegistry;
+        const rscEnv = server.environments?.rsc;
+        let registry = null;
+        if (rscEnv?.runner && s.resolvedEntryPath) {
+          try {
+            await rscEnv.runner.import(s.resolvedEntryPath);
+            const serverMod = await rscEnv.runner.import(
+              "@rangojs/router/server"
+            );
+            registry = serverMod.RouterRegistry ?? null;
+          } catch (err) {
+            console.warn(
+              `[rsc-router] Dev prerender module refresh failed: ${err.message}`
+            );
+            res.statusCode = 500;
+            res.end(`Prerender handler error: ${err.message}`);
+            logResult(500, "module refresh failed");
+            return;
+          }
+        } else {
+          registry = mainRegistry;
+        }
         if (!registry) {
           if (!prerenderNodeRegistry) {
             await getOrCreateTempServer();
@@ -4795,6 +5439,7 @@ ${err.stack}`
         if (!registry || registry.size === 0) {
           res.statusCode = 503;
           res.end("Prerender runner not available");
+          logResult(503, "no registry");
           return;
         }
         const wantIntercept = url.searchParams.get("intercept") === "1";
@@ -4829,6 +5474,7 @@ ${err.stack}`
               payload = { segments: result.segments, handles: result.handles };
             }
             res.end(JSON.stringify(payload));
+            logResult(200, `match ${result.routeName}`);
             return;
           } catch (err) {
             console.warn(
@@ -4838,6 +5484,7 @@ ${err.stack}`
         }
         res.statusCode = 404;
         res.end("No prerender match");
+        logResult(404, "no match");
       });
       if (opts?.staticRouteTypesGeneration !== false) {
         const isGeneratedRouteFile = (filePath) => filePath.endsWith(".gen.ts") && (filePath.includes("named-routes.gen.ts") || filePath.includes("urls.gen.ts"));
@@ -4862,15 +5509,32 @@ ${err.stack}`
           const rscEnv = server.environments?.rsc;
           if (!rscEnv?.runner || runtimeRediscoveryInProgress) return;
           runtimeRediscoveryInProgress = true;
+          const hmrStart = performance.now();
           try {
-            await discoverRouters(s, rscEnv);
-            writeRouteTypesFiles(s);
-            await propagateDiscoveryState(rscEnv);
+            await timed(
+              debugDiscovery,
+              "hmr discoverRouters",
+              () => discoverRouters(s, rscEnv)
+            );
+            timedSync(
+              debugDiscovery,
+              "hmr writeRouteTypesFiles",
+              () => writeRouteTypesFiles(s)
+            );
+            await timed(
+              debugDiscovery,
+              "hmr propagateDiscoveryState",
+              () => propagateDiscoveryState(rscEnv)
+            );
           } catch (err) {
             console.warn(
               `[rsc-router] Runtime re-discovery failed: ${err.message}`
             );
           } finally {
+            debugDiscovery?.(
+              "hmr re-discovery done (%sms)",
+              (performance.now() - hmrStart).toFixed(1)
+            );
             runtimeRediscoveryInProgress = false;
           }
         };
@@ -4878,6 +5542,7 @@ ${err.stack}`
           clearTimeout(routeChangeTimer);
           routeChangeTimer = setTimeout(() => {
             routeChangeTimer = void 0;
+            const regenStart = debugDiscovery ? performance.now() : 0;
             try {
               writeCombinedRouteTypesWithTracking(s);
               if (s.perRouterManifests.length > 0) {
@@ -4888,6 +5553,10 @@ ${err.stack}`
                 `[rsc-router] Route regeneration error: ${err.message}`
               );
             }
+            debugDiscovery?.(
+              "watcher: regenerated gen files (%sms)",
+              (performance.now() - regenStart).toFixed(1)
+            );
             if (s.perRouterManifests.length > 0) {
               refreshRuntimeDiscovery().catch((err) => {
                 console.warn(
@@ -4910,6 +5579,12 @@ ${err.stack}`
             const hasUrls = source.includes("urls(");
             const hasCreateRouter = /\bcreateRouter\s*[<(]/.test(source);
             if (!hasUrls && !hasCreateRouter) return;
+            debugDiscovery?.(
+              "watcher: %s matches (urls=%s, router=%s)",
+              filePath,
+              hasUrls,
+              hasCreateRouter
+            );
             if (hasCreateRouter) {
               const nestedRouterConflict = findNestedRouterConflict([
                 ...s.cachedRouterFiles ?? [],
@@ -4942,15 +5617,31 @@ ${err.stack}`
     // The manifest data is stored for the virtual module's load hook.
     async buildStart() {
       if (!s.isBuildMode) return;
-      if (s.mergedRouteManifest !== null) return;
+      if (s.mergedRouteManifest !== null) {
+        debugDiscovery?.(
+          "build: skip (already discovered, env=%s)",
+          this.environment?.name ?? "?"
+        );
+        return;
+      }
+      const buildStartTime = performance.now();
+      debugDiscovery?.("build: start (env=%s)", this.environment?.name ?? "?");
       resetStagedBuildAssets(s.projectRoot);
       s.prerenderManifestEntries = null;
       s.staticManifestEntries = null;
-      await acquireBuildEnv(s, viteCommand, viteMode);
+      await timed(
+        debugDiscovery,
+        "build acquireBuildEnv",
+        () => acquireBuildEnv(s, viteCommand, viteMode)
+      );
       let tempServer = null;
       globalThis.__rscRouterDiscoveryActive = true;
       try {
-        tempServer = await createTempRscServer(s, { forceBuild: true });
+        tempServer = await timed(
+          debugDiscovery,
+          "build createTempRscServer",
+          () => createTempRscServer(s, { forceBuild: true })
+        );
         const rscEnv = tempServer.environments?.rsc;
         if (!rscEnv?.runner) {
           console.warn(
@@ -4964,8 +5655,16 @@ ${err.stack}`
         if (tempIdsPlugin?.api?.staticHandlerModules) {
           s.resolvedStaticModules = tempIdsPlugin.api.staticHandlerModules;
         }
-        await discoverRouters(s, rscEnv);
-        writeRouteTypesFiles(s);
+        await timed(
+          debugDiscovery,
+          "build discoverRouters",
+          () => discoverRouters(s, rscEnv)
+        );
+        timedSync(
+          debugDiscovery,
+          "build writeRouteTypesFiles",
+          () => writeRouteTypesFiles(s)
+        );
       } catch (err) {
         const sourceFile = err.stack?.split("\n").find(
           (line) => line.includes(s.projectRoot) && !line.includes("node_modules")
@@ -4984,9 +5683,17 @@ ${details}`
       } finally {
         delete globalThis.__rscRouterDiscoveryActive;
         if (tempServer) {
-          await tempServer.close();
+          await timed(
+            debugDiscovery,
+            "build tempServer.close",
+            () => tempServer.close()
+          );
         }
         await releaseBuildEnv(s);
+        debugDiscovery?.(
+          "build discovery done (%sms)",
+          (performance.now() - buildStartTime).toFixed(1)
+        );
       }
     },
     // Virtual module: provides the pre-generated route manifest as a JS module
@@ -5003,17 +5710,36 @@ ${details}`
     async load(id) {
       if (id === "\0" + VIRTUAL_ROUTES_MANIFEST_ID) {
         if (s.discoveryDone) {
-          await s.discoveryDone;
+          await timed(
+            debugRoutes,
+            "await discoveryDone (manifest)",
+            () => s.discoveryDone
+          );
         }
-        return generateRoutesManifestModule(s);
+        const code = await timed(
+          debugRoutes,
+          "generateRoutesManifestModule",
+          () => generateRoutesManifestModule(s)
+        );
+        debugRoutes?.("manifest module emitted (%d bytes)", code?.length ?? 0);
+        return code;
       }
       const perRouterPrefix = "\0" + VIRTUAL_ROUTES_MANIFEST_ID + "/";
       if (id.startsWith(perRouterPrefix)) {
         if (s.discoveryDone) {
-          await s.discoveryDone;
+          await timed(
+            debugRoutes,
+            "await discoveryDone (per-router)",
+            () => s.discoveryDone
+          );
         }
         const routerId = id.slice(perRouterPrefix.length);
-        return generatePerRouterModule(s, routerId);
+        const code = await timed(
+          debugRoutes,
+          `generatePerRouterModule ${routerId}`,
+          () => generatePerRouterModule(s, routerId)
+        );
+        return code;
       }
       return null;
     },
@@ -5021,14 +5747,20 @@ ${details}`
     // Used by closeBundle for handler code eviction and prerender data injection.
     generateBundle(_options, bundle) {
       if (this.environment?.name !== "rsc") return;
+      const genStart = debugBuild ? performance.now() : 0;
       for (const [fileName, chunk] of Object.entries(bundle)) {
         if (chunk.type === "chunk" && chunk.isEntry) {
           s.rscEntryFileName = fileName;
           break;
         }
       }
-      if (!s.resolvedPrerenderModules?.size && !s.resolvedStaticModules?.size)
+      if (!s.resolvedPrerenderModules?.size && !s.resolvedStaticModules?.size) {
+        debugBuild?.(
+          "generateBundle (rsc): no handlers to scan (%sms)",
+          (performance.now() - genStart).toFixed(1)
+        );
         return;
+      }
       s.handlerChunkInfoMap.clear();
       s.staticHandlerChunkInfoMap.clear();
       for (const [fileName, chunk] of Object.entries(bundle)) {
@@ -5072,6 +5804,13 @@ ${details}`
           }
         }
       }
+      debugBuild?.(
+        "generateBundle (rsc): scanned %d chunks, %d prerender chunk(s), %d static chunk(s) (%sms)",
+        Object.keys(bundle).length,
+        s.handlerChunkInfoMap.size,
+        s.staticHandlerChunkInfoMap.size,
+        (performance.now() - genStart).toFixed(1)
+      );
     },
     // Build-time pre-rendering: evict handler code and inject collected prerender data.
     // Collection now happens in-process during discoverRouters() via RSC runner.
@@ -5082,29 +5821,41 @@ ${details}`
       async handler() {
         if (!s.isBuildMode) return;
         if (this.environment && this.environment.name !== "rsc") return;
-        postprocessBundle(s);
+        timedSync(
+          debugBuild,
+          "closeBundle postprocessBundle",
+          () => postprocessBundle(s)
+        );
       }
     }
   };
 }
 
 // src/vite/rango.ts
+var debugConfig = createRangoDebugger(NS.config);
 async function rango(options) {
+  const rangoStart = performance.now();
   const resolvedOptions = options ?? { preset: "node" };
   const preset = resolvedOptions.preset ?? "node";
   const showBanner = resolvedOptions.banner ?? true;
+  debugConfig?.("rango(%s) setup start", preset);
   const plugins = [];
-  const rangoAliases = getPackageAliases();
+  const rangoAliases = { ...getPackageAliases(), ...getVendorAliases() };
   const excludeDeps = [
     ...getExcludeDeps(),
-    // The public browser entry re-exports the RSDW browser client.
-    // Excluding both keeps Vite from freezing the unpatched bundle into
-    // .vite/deps before our source transforms run.
+    // plugin-rsc itself injects these into the client env's
+    // optimizeDeps.include, which overrides exclude for the dep's own
+    // pre-bundle entry. What exclude still controls is how *other*
+    // pre-bundled deps treat imports of these specs (external vs inlined)
+    // via esbuildCjsExternalPlugin. The cjs-to-esm transform in
+    // plugins/cjs-to-esm.ts is the fallback for strict-pnpm consumers,
+    // where client.browser's bare include fails to resolve and Vite ends up
+    // serving the raw CJS file at dev-serve time.
     "@vitejs/plugin-rsc/browser",
-    // Keep the browser RSDW client out of Vite's dep optimizer so our
-    // cjs-to-esm transform can patch the real file.
     "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser"
   ];
+  const pkg = getPublishedPackageName();
+  const nested = (spec) => `${pkg} > ${spec}`;
   const routerRef = { path: void 0 };
   const prerenderEnabled = true;
   if (preset === "cloudflare") {
@@ -5142,7 +5893,7 @@ async function rango(options) {
               // Pre-bundle rsc-html-stream to prevent discovery during first request
               // Exclude rsc-router modules to ensure same Context instance
               optimizeDeps: {
-                include: ["rsc-html-stream/client"],
+                include: [nested("rsc-html-stream/client")],
                 exclude: excludeDeps,
                 esbuildOptions: sharedEsbuildOptions
               }
@@ -5167,8 +5918,10 @@ async function rango(options) {
                   "react-dom/static.edge",
                   "react/jsx-runtime",
                   "react/jsx-dev-runtime",
-                  "rsc-html-stream/server",
-                  "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+                  nested("rsc-html-stream/server"),
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+                  )
                 ],
                 exclude: excludeDeps,
                 esbuildOptions: sharedEsbuildOptions
@@ -5183,7 +5936,9 @@ async function rango(options) {
                   "react",
                   "react/jsx-runtime",
                   "react/jsx-dev-runtime",
-                  "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+                  )
                 ],
                 exclude: excludeDeps,
                 esbuildOptions: sharedEsbuildOptions
@@ -5264,7 +6019,7 @@ ${list}`);
                   "react-dom",
                   "react/jsx-runtime",
                   "react/jsx-dev-runtime",
-                  "rsc-html-stream/client"
+                  nested("rsc-html-stream/client")
                 ],
                 exclude: excludeDeps,
                 esbuildOptions: sharedEsbuildOptions,
@@ -5281,7 +6036,9 @@ ${list}`);
                   "react-dom/static.edge",
                   "react/jsx-runtime",
                   "react/jsx-dev-runtime",
-                  "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/client.edge"
+                  )
                 ],
                 exclude: excludeDeps,
                 esbuildOptions: sharedEsbuildOptions
@@ -5294,7 +6051,9 @@ ${list}`);
                   "react",
                   "react/jsx-runtime",
                   "react/jsx-dev-runtime",
-                  "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+                  nested(
+                    "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge"
+                  )
                 ],
                 esbuildOptions: sharedEsbuildOptions
               }
@@ -5364,6 +6123,12 @@ ${list}`);
       preset
     })
   );
+  debugConfig?.(
+    "rango(%s) setup done: %d plugin(s) (%sms)",
+    preset,
+    plugins.length,
+    (performance.now() - rangoStart).toFixed(1)
+  );
   return plugins;
 }
 
@@ -5374,7 +6139,7 @@ function poke() {
     apply: "serve",
     configureServer(server) {
       const stdin = process.stdin;
-      const debug = process.env.RANGO_POKE_DEBUG === "1";
+      const debug11 = process.env.RANGO_POKE_DEBUG === "1";
       const triggerReload = (source) => {
         server.hot.send({ type: "full-reload", path: "*" });
         server.config.logger.info(`  browser reload (${source})`, {
@@ -5407,7 +6172,7 @@ function poke() {
         lines.pop();
         return lines;
       };
-      if (debug) {
+      if (debug11) {
         server.config.logger.info(
           `  poke debug enabled (isTTY=${stdin.isTTY ? "yes" : "no"}, isRaw=${stdin.isTTY ? stdin.isRaw ? "yes" : "no" : "n/a"})`,
           { timestamp: true }
@@ -5420,7 +6185,7 @@ function poke() {
         );
       }
       const onData = (data) => {
-        if (debug) {
+        if (debug11) {
           server.config.logger.info(`  poke stdin ${formatChunk(data)}`, {
             timestamp: true
           });