@rangojs/router 0.0.0-experimental.9 → 0.0.0-experimental.91

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

@@ -0,0 +1,214 @@
+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",
+]);
+
+// Keep in sync with `STUBS` in cloudflare-protocol-loader-hook.mjs —
+// both paths (Vite transform and Node loader) need to hand out the same
+// classes. Unknown `cloudflare:*` modules fall back to an empty default
+// export so third-party packages (e.g. the Cloudflare Agents SDK) can
+// pull them into the graph without crashing discovery. Discovery only
+// evaluates module top-level code — no handlers run — so missing named
+// exports only fail if something does `class X extends Missing {}` at
+// module scope, which is rare outside the already-stubbed classes.
+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 {};
+`,
+};
+
+// Policy: unknown `cloudflare:*` specifiers resolve permissively (empty
+// default export) rather than throwing. We prioritize dependency-graph
+// resilience over strict validation of user imports because third-party
+// packages can pull `cloudflare:*` modules we haven't curated, and
+// discovery should not fail just because those modules appear in the graph.
+// Tradeoff: unsupported user-authored `cloudflare:*` imports may fail later
+// with a generic JS/module error instead of a tailored rango-branded hint.
+// The test below pins this behavior so dependency compatibility is not
+// regressed accidentally.
+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) 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;
+
+      // Rewrite from last to first so earlier offsets stay valid. `start`/
+      // `end` span the full literal including quotes, so we re-emit the
+      // same quote character around the new specifier.
+      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/{expose-action-id.ts → plugins/expose-action-id.ts}

@@ -2,6 +2,10 @@ import type { Plugin, ResolvedConfig } from "vite";
 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
@@ -34,12 +38,12 @@ function getRscPluginApi(config: ResolvedConfig): RscPluginApi | undefined {
     plugin = config.plugins.find(
       (p) =>
         (p.api as RscPluginApi | undefined)?.manager?.serverReferenceMetaMap !==
-        undefined
+        undefined,
     );
     if (plugin) {
       console.warn(
         `[rsc-router:expose-action-id] RSC plugin found by API structure (name: "${plugin.name}"). ` +
-          `Consider updating the name lookup if the plugin was renamed.`
+          `Consider updating the name lookup if the plugin was renamed.`,
       );
     }
   }
@@ -47,13 +51,6 @@ function getRscPluginApi(config: ResolvedConfig): RscPluginApi | undefined {
   return plugin?.api as RscPluginApi | undefined;
 }
 
-/**
- * Normalize path to forward slashes
- */
-function normalizePath(p: string): string {
-  return p.split(path.sep).join("/");
-}
-
 /**
  * Check if a file is a "use server" module (has the directive at the module level).
  * This distinguishes module-level server action files from files with inline actions.
@@ -88,21 +85,27 @@ function isUseServerModule(filePath: string): boolean {
  * @param sourceId - The source file identifier (for sourcemap)
  * @param hashToFileMap - Optional mapping from hash to file path (for server bundles)
  */
-function transformServerReferences(
+/**
+ * Apply createServerReference wrapping to a MagicString instance.
+ * Returns true if any changes were made.
+ */
+function applyServerReferenceWrapping(
   code: string,
-  sourceId?: string,
-  hashToFileMap?: Map<string, string>
-): { code: string; map: ReturnType<MagicString["generateMap"]> } | null {
+  s: MagicString,
+  hashToFileMap?: Map<string, string>,
+): boolean {
   if (!code.includes("createServerReference(")) {
-    return null;
+    return false;
   }
 
   // Match: createServerReference("hash#actionName", ...) or $$ReactClient.createServerReference(...)
-  // The RSC plugin uses $$ReactClient namespace in transformed code
+  // 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;
 
-  const s = new MagicString(code);
   let hasChanges = false;
   let match: RegExpExecArray | null;
 
@@ -133,7 +136,16 @@ function transformServerReferences(
     s.overwrite(start, end, replacement);
   }
 
-  if (!hasChanges) {
+  return hasChanges;
+}
+
+function transformServerReferences(
+  code: string,
+  sourceId?: string,
+  hashToFileMap?: Map<string, string>,
+): { code: string; map: ReturnType<MagicString["generateMap"]> } | null {
+  const s = new MagicString(code);
+  if (!applyServerReferenceWrapping(code, s, hashToFileMap)) {
     return null;
   }
 
@@ -159,20 +171,27 @@ function transformServerReferences(
  * @param sourceId - The source file identifier (for sourcemap)
  * @param hashToFileMap - Mapping from hash to file path (only module-level "use server" files)
  */
-function transformRegisterServerReference(
+/**
+ * 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,
-  sourceId?: string,
-  hashToFileMap?: Map<string, string>
-): { code: string; map: ReturnType<MagicString["generateMap"]> } | null {
-  if (!hashToFileMap || !code.includes("registerServerReference(")) {
-    return null;
+  s: MagicString,
+  hashToFileMap: Map<string, string>,
+): boolean {
+  if (!code.includes("registerServerReference(")) {
+    return false;
   }
 
   // Match: registerServerReference(fn, "hash", "exportName")
   // The hash is the second argument, exportName is the third
-  const pattern = /registerServerReference\(([^,]+),\s*"([^"]+)",\s*"([^"]+)"\)/g;
+  const pattern =
+    /registerServerReference\(([^,]+),\s*"([^"]+)",\s*"([^"]+)"\)/g;
 
-  const s = new MagicString(code);
   let hasChanges = false;
   let match: RegExpExecArray | null;
 
@@ -196,7 +215,18 @@ function transformRegisterServerReference(
     }
   }
 
-  if (!hasChanges) {
+  return hasChanges;
+}
+
+function transformRegisterServerReference(
+  code: string,
+  sourceId?: string,
+  hashToFileMap?: Map<string, string>,
+): { code: string; map: ReturnType<MagicString["generateMap"]> } | null {
+  if (!hashToFileMap) return null;
+
+  const s = new MagicString(code);
+  if (!applyRegisterReferenceWrapping(code, s, hashToFileMap)) {
     return null;
   }
 
@@ -227,6 +257,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",
@@ -241,6 +273,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
@@ -251,9 +288,7 @@ 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."
+            "@rangojs/router requires the Vite RSC plugin, which is included automatically by rango().",
         );
       }
 
@@ -263,7 +298,7 @@ export function exposeActionId(): Plugin {
       const { serverReferenceMetaMap } = rscPluginApi.manager;
 
       for (const [absolutePath, meta] of Object.entries(
-        serverReferenceMetaMap
+        serverReferenceMetaMap,
       )) {
         // Only include module-level "use server" files
         // Inline actions (defined in RSC components) should keep hashed IDs for client security
@@ -272,7 +307,7 @@ export function exposeActionId(): Plugin {
         }
 
         const relativePath = normalizePath(
-          path.relative(config.root, absolutePath)
+          path.relative(config.root, absolutePath),
         );
 
         // The referenceKey in build mode is the hash
@@ -281,7 +316,6 @@ export function exposeActionId(): Plugin {
       }
     },
 
-
     // Dev mode only: transform hook runs after RSC plugin creates server references
     // In dev mode, IDs already contain file paths, not hashes
     transform(code, id) {
@@ -300,45 +334,54 @@ 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 {
+        // Dev mode: no hash-to-file mapping needed (IDs are already file paths)
+        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;
-
-      // Transform createServerReference calls (client-side)
-      const result = transformServerReferences(
-        code,
-        chunk.fileName,
-        effectiveMap
-      );
-
-      // For RSC bundles, also transform registerServerReference calls
-      // This replaces hashed IDs with file paths so $id contains the actual path
-      if (isRscEnv && hashToFileMap) {
-        const codeToTransform = result ? result.code : code;
-        const registerResult = transformRegisterServerReference(
-          codeToTransform,
-          chunk.fileName,
-          hashToFileMap
-        );
-        if (registerResult) {
-          return { code: registerResult.code, map: registerResult.map };
+      const start = counterRender ? performance.now() : 0;
+      try {
+        // 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,
+              }),
+            };
+          }
+          return null;
         }
-      }
 
-      if (result) {
-        return { code: result.code, map: result.map };
+        // Non-RSC environments: only transform createServerReference calls
+        return transformServerReferences(code, chunk.fileName, effectiveMap);
+      } finally {
+        counterRender?.record(chunk.fileName, performance.now() - start);
       }
-      return null;
     },
   };
 }