@rangojs/router 0.0.0-experimental.b9cb8739 → 0.0.0-experimental.bdaf10aa

package/src/vite/plugins/cloudflare-protocol-loader-hook.mjs

@@ -0,0 +1,76 @@
+// Node ESM loader hook that resolves `cloudflare:*` imports to the same
+// stub ESM the Vite transform produces for rewritten specifiers.
+//
+// Why both? The Vite transform (cloudflare-protocol-stub.ts) catches
+// imports in modules that flow through Vite's plugin pipeline — covers
+// user source and any node_modules package Vite fetches and transforms.
+// But Vite/Rollup externalize certain packages (e.g. `partyserver`,
+// which has `import { DurableObject, env } from "cloudflare:workers"`
+// at its top level, and similar "workerd-native" libraries). Externalized
+// modules bypass the transform: Rollup hands their resolution to Node's
+// native ESM loader, which rejects URL-scheme specifiers. This loader
+// hook registers via `module.register()` from `createTempRscServer` and
+// intercepts `cloudflare:*` at Node's resolve layer — before the default
+// loader throws ERR_UNSUPPORTED_ESM_URL_SCHEME.
+//
+// Lifecycle: the hook runs in a dedicated worker thread (Node ESM loader
+// architecture) with its own globalThis. It cannot see the main thread's
+// `__rango_build_env__` bridge, so the `env` export here is always `{}`.
+// That's fine in practice — externalized libraries don't typically touch
+// `env` at module top level; they read it at request time in workerd
+// where the real module exists. Build-time prerender handlers in user
+// source DO read `env`, but they flow through the Vite transform (which
+// does bridge `env` from `getPlatformProxy()`), not through this loader.
+//
+// Keep STUBS in sync with cloudflare-protocol-stub.ts — both paths need
+// to hand out the same base classes.
+
+const CF_PREFIX = "cloudflare:";
+
+const 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 = {};
+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 {};
+`,
+};
+
+// Policy: unknown `cloudflare:*` specifiers resolve permissively to an
+// empty default export rather than throwing. Same reasoning as
+// cloudflare-protocol-stub.ts's FALLBACK_STUB — we prioritize
+// dependency-graph resilience over strict validation, because third-party
+// packages can pull `cloudflare:*` modules we haven't curated.
+const FALLBACK_STUB = `export default {};\n`;
+
+function dataUrlFor(specifier) {
+  const body = STUBS[specifier] ?? FALLBACK_STUB;
+  return "data:text/javascript;base64," + Buffer.from(body).toString("base64");
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith(CF_PREFIX)) {
+    return {
+      shortCircuit: true,
+      url: dataUrlFor(specifier),
+      format: "module",
+    };
+  }
+  return nextResolve(specifier, context);
+}

package/src/vite/plugins/cloudflare-protocol-stub.ts

@@ -0,0 +1,194 @@
+import type { Plugin } from "vite";
+
+const VIRTUAL_PREFIX = "virtual:rango-cloudflare-stub-";
+const NULL_PREFIX = "\0" + VIRTUAL_PREFIX;
+const CF_PREFIX = "cloudflare:";
+
+/**
+ * `globalThis` key the `cloudflare:workers` stub reads to populate its
+ * `env` export. Router discovery sets this to the resolved `buildEnv`
+ * proxy (from `wrangler.getPlatformProxy()` when `buildEnv: "auto"` is
+ * configured, or a user-supplied object otherwise) before importing the
+ * worker entry, and clears it after discovery disposes the proxy. When
+ * unset, the stub's `env` falls back to `{}`.
+ *
+ * Using `globalThis` is the only cross-module bridge that works here:
+ * the stub's `load` hook returns source text, not a live closure, but
+ * the stub module is evaluated in the same Node process as the
+ * discovery plugin — so reading a global at module-evaluation time
+ * reaches whatever the plugin assigned there. A symbol key would be
+ * cleaner in-process but awkward to name from the stub source.
+ *
+ * @internal
+ */
+export const BUILD_ENV_GLOBAL_KEY = "__rango_build_env__";
+
+const SOURCE_EXT_RE = /\.[mc]?[jt]sx?$/;
+
+const IMPORT_NODE_TYPES = new Set([
+  "ImportDeclaration",
+  "ImportExpression",
+  "ExportNamedDeclaration",
+  "ExportAllDeclaration",
+]);
+
+const STUBS: Record<string, string> = {
+  "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 {};
+`,
+};
+
+const FALLBACK_STUB = `export default {};\n`;
+
+interface AstNode {
+  type: string;
+  start?: number;
+  end?: number;
+  source?: AstNode | null;
+  value?: unknown;
+  [key: string]: unknown;
+}
+
+/**
+ * Stubs `cloudflare:*` imports for the discovery-time Node Vite server.
+ *
+ * Discovery only evaluates user module top-level code — it never invokes
+ * DurableObject / WorkerEntrypoint / Workflow handlers — so empty base
+ * classes are enough for `class X extends DurableObject {}` declarations
+ * to load in Node, where `cloudflare:*` is otherwise unresolvable.
+ *
+ * Interception point: a transform hook parses source with Rollup's
+ * plugin-context parser (`this.parse`) and rewrites only real import
+ * specifier spans (`import ... from "cloudflare:xxx"`,
+ * `import("cloudflare:xxx")`, `export ... from "cloudflare:xxx"`) to a
+ * plain virtual module name (`virtual:rango-cloudflare-stub-xxx`).
+ * This must be done in transform because Vite's module runner routes
+ * URL-scheme specifiers straight to Node's native ESM loader without
+ * consulting plugin `resolveId` hooks. Using the AST (instead of a
+ * text regex or a permissive lexer) guarantees that strings,
+ * comments, and template literals that merely contain import-like
+ * text are never mutated — the walker only looks at the four import
+ * node types.
+ *
+ * The transform runs on user source AND on compiled node_modules
+ * output: real-world CF packages (e.g. the Cloudflare Agents SDK)
+ * ship compiled JS that contains `import ... from "cloudflare:email"`
+ * and similar, so excluding node_modules would leave those imports
+ * unrewritten. Cost is small because the early exit (`code.includes`)
+ * skips files with no cloudflare: mention.
+ *
+ * The plugin intentionally runs at Vite's default ordering (no
+ * `enforce: "pre"`) so TS/JSX has already been compiled to plain JS
+ * by the time `this.parse` runs — acorn doesn't understand
+ * non-standard syntax.
+ *
+ * `cloudflare:workers`, `cloudflare:email`, `cloudflare:sockets`, and
+ * `cloudflare:workflows` each get curated stubs with the well-known
+ * symbols that appear in top-level `extends` positions. Any other
+ * `cloudflare:*` specifier falls back to an empty default export —
+ * discovery never executes the handlers, so an empty module is safe
+ * for anything the graph pulls in transitively.
+ *
+ * Only registered in the discovery temp server, not the user's runtime
+ * config.
+ * @internal
+ */
+export function createCloudflareProtocolStubPlugin(): Plugin {
+  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: AstNode;
+      try {
+        ast = this.parse(code, { lang: "tsx" }) as unknown as AstNode;
+      } catch {
+        // Malformed source — let a downstream plugin surface the parse error.
+        return null;
+      }
+
+      const hits: Array<{ start: number; end: number; value: string }> = [];
+      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: unknown, visit: (n: AstNode) => void): void {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) walk(child, visit);
+    return;
+  }
+  const n = node as AstNode;
+  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);
+  }
+}

package/src/vite/plugins/expose-action-id.ts

@@ -3,10 +3,10 @@ import MagicString from "magic-string";
 import path from "node:path";
 import fs from "node:fs";
 import { normalizePath } from "./expose-id-utils.js";
+import { createRangoDebugger, createCounter, NS } from "../debug.js";
+
+const debug = createRangoDebugger(NS.transform);
 
-/**
- * Type for the RSC plugin's manager API
- */
 interface RscPluginManager {
   serverReferenceMetaMap: Record<
     string,
@@ -23,14 +23,9 @@ interface RscPluginApi {
   manager: RscPluginManager;
 }
 
-/**
- * Get the RSC plugin's API from Vite config
- */
 function getRscPluginApi(config: ResolvedConfig): RscPluginApi | undefined {
-  // Try by name first
   let plugin = config.plugins.find((p) => p.name === "rsc:minimal");
 
-  // Fallback: find by API structure if name lookup fails
   if (!plugin) {
     plugin = config.plugins.find(
       (p) =>
@@ -39,7 +34,7 @@ function getRscPluginApi(config: ResolvedConfig): RscPluginApi | undefined {
     );
     if (plugin) {
       console.warn(
-        `[rsc-router:expose-action-id] RSC plugin found by API structure (name: "${plugin.name}"). ` +
+        `[rango:expose-action-id] RSC plugin found by API structure (name: "${plugin.name}"). ` +
           `Consider updating the name lookup if the plugin was renamed.`,
       );
     }
@@ -59,13 +54,11 @@ function getRscPluginApi(config: ResolvedConfig): RscPluginApi | undefined {
 function isUseServerModule(filePath: string): boolean {
   try {
     const content = fs.readFileSync(filePath, "utf-8");
-    // Remove leading comments and whitespace to find the first meaningful content
     const trimmed = content
-      .replace(/^\s*\/\/[^\n]*\n/gm, "") // Remove single-line comments
-      .replace(/^\s*\/\*[\s\S]*?\*\/\s*/gm, "") // Remove multi-line comments
+      .replace(/^\s*\/\/[^\n]*\n/gm, "")
+      .replace(/^\s*\/\*[\s\S]*?\*\/\s*/gm, "")
       .trimStart();
 
-    // Check if the file starts with "use server" directive
     return (
       trimmed.startsWith('"use server"') || trimmed.startsWith("'use server'")
     );
@@ -74,18 +67,6 @@ function isUseServerModule(filePath: string): boolean {
   }
 }
 
-/**
- * Transform code to expose action IDs on createServerReference calls.
- * Wraps each call with an IIFE that attaches $id to the returned function.
- *
- * @param code - The source code to transform
- * @param sourceId - The source file identifier (for sourcemap)
- * @param hashToFileMap - Optional mapping from hash to file path (for server bundles)
- */
-/**
- * Apply createServerReference wrapping to a MagicString instance.
- * Returns true if any changes were made.
- */
 function applyServerReferenceWrapping(
   code: string,
   s: MagicString,
@@ -95,11 +76,6 @@ function applyServerReferenceWrapping(
     return false;
   }
 
-  // Match: createServerReference("hash#actionName", ...) or $$ReactClient.createServerReference(...)
-  // The RSC plugin uses $$ReactClient namespace in transformed code.
-  // Note: [^)]* cannot handle nested parens in trailing args. This is safe in practice
-  // because the RSC plugin always generates simple variable references (e.g., callServer)
-  // as the second argument, never nested function calls.
   const pattern =
     /((?:\$\$\w+\.)?createServerReference)\(("[^"]+#[^"]+")([^)]*)\)/g;
 
@@ -112,23 +88,19 @@ function applyServerReferenceWrapping(
     const start = match.index;
     const end = start + fullMatch.length;
 
-    // Parse the ID to potentially replace hash with file path
     let finalIdArg = idArg;
     if (hashToFileMap) {
-      // idArg is like '"hash#actionName"', extract the parts
       const idValue = idArg.slice(1, -1); // Remove quotes
       const hashMatch = idValue.match(/^([^#]+)#(.+)$/);
       if (hashMatch) {
         const [, hash, actionName] = hashMatch;
         const filePath = hashToFileMap.get(hash);
         if (filePath) {
-          // Replace hash with file path for server-side
           finalIdArg = `"${filePath}#${actionName}"`;
         }
       }
     }
 
-    // Wrap the createServerReference call to attach $$id to the returned function
     const replacement = `(function(fn) { fn.$$id = ${finalIdArg}; return fn; })(${fnCall}(${idArg}${rest}))`;
     s.overwrite(start, end, replacement);
   }
@@ -152,29 +124,6 @@ function transformServerReferences(
   };
 }
 
-/**
- * Transform registerServerReference calls in server bundles to use file paths instead of hashes.
- * Pattern: registerServerReference(fn, "hash", "exportName")
- * React's registerServerReference sets $$id = hash + "#" + exportName
- * By replacing the hash with file path, $$id will contain the file path for revalidation matching.
- *
- * Only actions from module-level "use server" files are transformed.
- * Inline actions (defined in RSC components with "use server" inside a function) are NOT in
- * hashToFileMap and keep their hashed IDs. This is intentional for client security:
- * - Module-level "use server" files: shared action modules, file path helps revalidation
- * - Inline actions: one-off actions in RSC, hash ID prevents file path exposure to client
- *
- * @param code - The source code to transform
- * @param sourceId - The source file identifier (for sourcemap)
- * @param hashToFileMap - Mapping from hash to file path (only module-level "use server" files)
- */
-/**
- * Apply registerServerReference wrapping to a MagicString instance.
- * Returns true if any changes were made.
- *
- * Only actions from module-level "use server" files are transformed.
- * Inline actions keep their hashed IDs for client security.
- */
 function applyRegisterReferenceWrapping(
   code: string,
   s: MagicString,
@@ -184,8 +133,6 @@ function applyRegisterReferenceWrapping(
     return false;
   }
 
-  // Match: registerServerReference(fn, "hash", "exportName")
-  // The hash is the second argument, exportName is the third
   const pattern =
     /registerServerReference\(([^,]+),\s*"([^"]+)",\s*"([^"]+)"\)/g;
 
@@ -197,15 +144,9 @@ function applyRegisterReferenceWrapping(
     const start = match.index;
     const end = start + fullMatch.length;
 
-    // Look up the file path for this hash
     const filePath = hashToFileMap.get(hash);
     if (filePath) {
       hasChanges = true;
-      // WRAP the call to add $id property with file path
-      // Keep the original hash for React's action registry (so loadServerAction works)
-      // Add $id (single dollar) with file path for revalidation matching
-      // Note: We use $id instead of $$id because React's registerServerReference
-      // sets $$id as a non-writable property
       const filePathId = `${filePath}#${exportName}`;
       const replacement = `(function(fn) { fn.$id = "${filePathId}"; return fn; })(registerServerReference(${fnArg}, "${hash}", "${exportName}"))`;
       s.overwrite(start, end, replacement);
@@ -254,6 +195,8 @@ export function exposeActionId(): Plugin {
   let isBuild = false;
   let hashToFileMap: Map<string, string> | undefined;
   let rscPluginApi: RscPluginApi | undefined;
+  const counterTransform = createCounter(debug, "expose-action-id transform");
+  const counterRender = createCounter(debug, "expose-action-id renderChunk");
 
   return {
     name: "@rangojs/router:expose-action-id",
@@ -268,6 +211,11 @@ export function exposeActionId(): Plugin {
       rscPluginApi = getRscPluginApi(config);
     },
 
+    buildEnd() {
+      counterTransform?.flush();
+      counterRender?.flush();
+    },
+
     buildStart() {
       // Verify RSC plugin is present at build start (after all config hooks have run)
       // This allows rsc-router:rsc-integration to dynamically add the RSC plugin
@@ -277,10 +225,8 @@ export function exposeActionId(): Plugin {
 
       if (!rscPluginApi) {
         throw new Error(
-          "[rsc-router] Could not find @vitejs/plugin-rsc. " +
-            "@rangojs/router requires the Vite RSC plugin.\n" +
-            "The RSC plugin should be included automatically. If you disabled it with\n" +
-            "rango({ rsc: false }), add rsc() before rango() in your config.",
+          "[rango] Could not find @vitejs/plugin-rsc. " +
+            "@rangojs/router requires the Vite RSC plugin, which is included automatically by rango().",
         );
       }
 
@@ -326,40 +272,45 @@ export function exposeActionId(): Plugin {
         return;
       }
 
-      // Dev mode: no hash-to-file mapping needed (IDs are already file paths)
-      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) {
-      // Only RSC bundle should get file paths for revalidation matching
-      // SSR bundle must NOT use file paths because client components run there
-      // and need to match the client bundle during hydration (otherwise: error #418)
-      const isRscEnv = this.environment?.name === "rsc";
-
-      // Only use file path mapping for RSC environment
-      const effectiveMap = isRscEnv ? hashToFileMap : undefined;
-
-      // For RSC bundles, both createServerReference and registerServerReference
-      // may need transforming. Use a single MagicString for correct sourcemaps.
-      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 : undefined;
+
+        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;
-      }
 
-      // Non-RSC environments: only transform createServerReference calls
-      return transformServerReferences(code, chunk.fileName, effectiveMap);
+        return transformServerReferences(code, chunk.fileName, effectiveMap);
+      } finally {
+        counterRender?.record(chunk.fileName, performance.now() - start);
+      }
     },
   };
 }