@rangojs/router 0.11.0 → 0.12.1

package/src/vite/plugins/use-cache-transform.ts

@@ -17,6 +17,7 @@
  */
 
 import type { Plugin } from "vite";
+import type { ModuleExportMeta } from "@vitejs/plugin-rsc/transforms";
 import path from "node:path";
 import MagicString from "magic-string";
 import { normalizePath, hashId } from "./expose-id-utils.js";
@@ -89,6 +90,13 @@ export function useCacheTransform(): Plugin {
           return;
         }
 
+        // plugin-rsc 0.5.34 `matchDirective` does `stmt.directive.match(...)`
+        // after `"directive" in node`. Vite/oxc parseAst now emits
+        // `directive: null` on ordinary ExpressionStatements, so a file that
+        // mixes a `"use cache"` function with a sibling handler whose first
+        // statement is an expression throws and the wrap is dropped.
+        stripNullDirectiveFields(ast);
+
         const filePath = normalizePath(path.relative(projectRoot, id));
         const isLayoutOrTemplate = LAYOUT_TEMPLATE_PATTERN.test(id);
 
@@ -101,6 +109,7 @@ export function useCacheTransform(): Plugin {
             isBuild,
             isLayoutOrTemplate,
             transformWrapExport,
+            hasDirective,
           );
         }
 
@@ -131,6 +140,7 @@ function transformFileLevelUseCache(
   isBuild: boolean,
   isLayoutOrTemplate: boolean,
   transformWrapExport: (typeof import("@vitejs/plugin-rsc/transforms"))["transformWrapExport"],
+  hasDirective: (typeof import("@vitejs/plugin-rsc/transforms"))["hasDirective"],
 ) {
   const unconfirmedExports: string[] = [];
 
@@ -140,8 +150,18 @@ function transformFileLevelUseCache(
       return `__rango_registerCachedFunction(${value}, ${JSON.stringify(funcId)}, "default")`;
     },
     rejectNonAsyncFunction: false,
-    filter: (name: string, meta: { isFunction?: boolean }) => {
+    filter: (name: string, meta: ModuleExportMeta) => {
       if (name === "default" && isLayoutOrTemplate) return false;
+      // plugin-rsc 0.5.34 hoists mixed inline `"use server"` out of a
+      // file-level `"use cache"` module as `$$hoist_*` exports and rebinds the
+      // original name to `registerServerReference($$hoist_*, ...)`. Both are
+      // server references, not cached functions. The directive check covers
+      // the pre-hoist shape (this plugin seeing the source first).
+      if (name.startsWith("$$hoist_")) return false;
+      if (isHoistedServerReferenceRebind(meta.valueNode)) return false;
+      if (functionHasUseServerDirective(meta.valueNode, hasDirective)) {
+        return false;
+      }
       // isFunction is boolean | undefined: true = confirmed function, false =
       // confirmed non-function, undefined = cannot tell statically (e.g. a
       // factory/HOF initializer `const x = makeCached(fn)`). Deliberate policy:
@@ -250,6 +270,50 @@ function transformFunctionLevelUseCache(
   }
 }
 
+function stripNullDirectiveFields(node: unknown): void {
+  if (!node || typeof node !== "object") return;
+  const rec = node as Record<string, unknown>;
+  if (rec.type === "ExpressionStatement" && typeof rec.directive !== "string") {
+    delete rec.directive;
+  }
+  for (const value of Object.values(rec)) {
+    if (Array.isArray(value)) {
+      for (const item of value) stripNullDirectiveFields(item);
+    } else if (value && typeof value === "object" && "type" in value) {
+      stripNullDirectiveFields(value);
+    }
+  }
+}
+
+function isHoistedServerReferenceRebind(
+  valueNode: ModuleExportMeta["valueNode"],
+): boolean {
+  if (!valueNode || valueNode.type !== "CallExpression") return false;
+  const first = valueNode.arguments[0];
+  return (
+    first !== undefined &&
+    first.type === "Identifier" &&
+    first.name.startsWith("$$hoist_")
+  );
+}
+
+function functionHasUseServerDirective(
+  valueNode: ModuleExportMeta["valueNode"],
+  hasDirective: (typeof import("@vitejs/plugin-rsc/transforms"))["hasDirective"],
+): boolean {
+  if (!valueNode || !("body" in valueNode)) return false;
+  const { body } = valueNode;
+  if (!body || Array.isArray(body) || body.type !== "BlockStatement") {
+    return false;
+  }
+  // plugin-rsc types valueNode with plain estree nodes but hasDirective with
+  // its oxc-flavored AST; the flavors differ only in position/extra fields.
+  return hasDirective(
+    body.body as Parameters<typeof hasDirective>[0],
+    "use server",
+  );
+}
+
 function findFileLevelDirective(
   ast: any,
 ): { start: number; end: number } | null {

package/src/vite/plugins/vercel-output.ts

@@ -28,9 +28,11 @@
  *      type:module in scope the deployed (isolated) function loads them as
  *      CommonJS and fails on the first `import`.
  *
- * The launcher is bundled with srvx (the Web->Node streaming bridge, a
- * @rangojs/router dependency) and @vercel/functions (resolved from the app)
- * inlined, keeping the RSC bundle a runtime-relative external.
+ * The launcher is bundled with rolldown (Vite 8's bundler — a production
+ * dependency of `vite`, resolved through the app's vite install) so a
+ * standalone consumer does not need `esbuild`. srvx (the Web->Node streaming
+ * bridge, a @rangojs/router dependency) and @vercel/functions (resolved from
+ * the app) are inlined; the RSC bundle stays a runtime-relative external.
  *
  * Timing: this runs in the `buildApp` hook (order "post"), which fires once
  * after every environment has built, so dist/{client,rsc,ssr} all exist.
@@ -52,19 +54,30 @@ import type {
   VercelPresetOptions,
 } from "../plugin-types.js";
 
-// Minimal structural types for the esbuild API we use, resolved dynamically from
-// the app so @rangojs/router does not depend on esbuild's type package.
-interface EsbuildPluginBuild {
-  onResolve(
-    options: { filter: RegExp },
-    callback: () => { path: string; external: boolean },
-  ): void;
+// Minimal structural types for the rolldown API we use. Resolved dynamically
+// from the app's vite install so @rangojs/router does not depend on rolldown's
+// type package (same stance the previous esbuild path took).
+interface RolldownResolveResult {
+  id: string;
+  external?: boolean;
 }
-type EsbuildBuild = (options: Record<string, unknown>) => Promise<unknown>;
-interface EsbuildModule {
-  build?: EsbuildBuild;
-  default?: { build?: EsbuildBuild };
+interface RolldownBundle {
+  write: (output: {
+    file: string;
+    format: string;
+    exports: string;
+    codeSplitting?: boolean;
+  }) => Promise<unknown>;
+  close: () => Promise<void>;
 }
+interface RolldownModule {
+  rolldown?: (options: Record<string, unknown>) => Promise<RolldownBundle>;
+  default?: {
+    rolldown?: (options: Record<string, unknown>) => Promise<RolldownBundle>;
+  };
+}
+
+const VIRTUAL_LAUNCHER_ID = "\0rango-vercel-launcher";
 
 const LAUNCHER_SOURCE = `import { toNodeHandler } from "srvx/node";
 import { waitUntil } from "@vercel/functions";
@@ -86,6 +99,122 @@ const fetchHandler = (request) =>
 export default toNodeHandler(fetchHandler);
 `;
 
+/**
+ * Resolve rolldown through the app's vite install (rolldown is a production
+ * dependency of Vite 8, unlike esbuild which is only an optional peer). Fall
+ * back to the app root, then the plugin's own vite, so a hoisted or
+ * workspace copy still works. Issue #785: the previous "esbuild ships with
+ * Vite" path broke standalone consumers on Vite 8.
+ */
+export function resolveRolldownPath(root: string): string {
+  const appRequire = createRequire(join(root, "package.json"));
+  const rangoRequire = createRequire(import.meta.url);
+  const attempts: Array<() => string> = [
+    () => createRequire(appRequire.resolve("vite")).resolve("rolldown"),
+    () => appRequire.resolve("rolldown"),
+    () => createRequire(rangoRequire.resolve("vite")).resolve("rolldown"),
+    () => rangoRequire.resolve("rolldown"),
+  ];
+  for (const attempt of attempts) {
+    try {
+      return attempt();
+    } catch {
+      // Intentionally empty: try the next resolver.
+    }
+  }
+  throw new Error(
+    '[rango] preset "vercel" requires "rolldown" to bundle the function launcher. Vite 8 depends on it; reinstall dependencies.',
+  );
+}
+
+/**
+ * Bundle the Node launcher into `funcDir/index.mjs`: srvx + @vercel/functions
+ * inlined, `./rsc/index.js` left as a runtime-relative external.
+ */
+export async function bundleVercelLauncher(opts: {
+  root: string;
+  funcDir: string;
+  srvxNodePath: string;
+}): Promise<void> {
+  const { root, funcDir, srvxNodePath } = opts;
+  const appRequire = createRequire(join(root, "package.json"));
+  let vercelFunctionsPath: string;
+  try {
+    vercelFunctionsPath = appRequire.resolve("@vercel/functions");
+  } catch {
+    throw new Error(
+      '[rango] preset "vercel": could not resolve "@vercel/functions". Add it to your app dependencies (it also backs VercelCacheStore).',
+    );
+  }
+  let rolldownModule: RolldownModule;
+  try {
+    rolldownModule = (await import(
+      pathToFileURL(resolveRolldownPath(root)).href
+    )) as RolldownModule;
+  } catch {
+    throw new Error(
+      '[rango] preset "vercel" requires "rolldown" to bundle the function launcher. Vite 8 depends on it; reinstall dependencies.',
+    );
+  }
+  const rolldownFn =
+    rolldownModule.rolldown ?? rolldownModule.default?.rolldown;
+  if (typeof rolldownFn !== "function") {
+    throw new Error('[rango] preset "vercel": could not load rolldown().');
+  }
+
+  let bundle: RolldownBundle | undefined;
+  try {
+    bundle = await rolldownFn({
+      input: VIRTUAL_LAUNCHER_ID,
+      cwd: root,
+      platform: "node",
+      logLevel: "silent",
+      resolve: {
+        alias: {
+          "srvx/node": srvxNodePath,
+          "@vercel/functions": vercelFunctionsPath,
+        },
+      },
+      plugins: [
+        {
+          name: "rango-vercel-launcher",
+          resolveId(id: string): string | RolldownResolveResult | null {
+            if (id === VIRTUAL_LAUNCHER_ID) return VIRTUAL_LAUNCHER_ID;
+            if (id === "./rsc/index.js") {
+              return { id: "./rsc/index.js", external: true };
+            }
+            return null;
+          },
+          load(id: string): string | null {
+            if (id === VIRTUAL_LAUNCHER_ID) return LAUNCHER_SOURCE;
+            return null;
+          },
+        },
+      ],
+    });
+    await bundle.write({
+      file: join(funcDir, "index.mjs"),
+      format: "esm",
+      exports: "default",
+      // @vercel/functions (and srvx) may contain dynamic import(); the
+      // launcher must stay a single index.mjs — Vercel's handler field
+      // points at that one file.
+      codeSplitting: false,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/@vercel\/functions/.test(message)) {
+      throw new Error(
+        '[rango] preset "vercel": could not resolve "@vercel/functions". Add it to your app dependencies (it also backs VercelCacheStore).\n' +
+          message,
+      );
+    }
+    throw error;
+  } finally {
+    await bundle?.close();
+  }
+}
+
 /**
  * Reject a non-Node runtime for the vercel preset. The preset only emits a Node
  * serverless function (launcherType "Nodejs", bundled Node APIs, response
@@ -237,7 +366,8 @@ async function assemble(
 
   // 3. Bundle the Node launcher. srvx (a @rangojs/router dependency) is aliased
   //    to its resolved path; @vercel/functions resolves from the app; the RSC
-  //    server bundle stays a runtime-relative external.
+  //    server bundle stays a runtime-relative external. Rolldown (Vite 8's
+  //    bundler) is resolved through the app's vite install — #785.
   const rangoRequire = createRequire(import.meta.url);
   let srvxNodePath: string;
   try {
@@ -247,79 +377,7 @@ async function assemble(
       '[rango] preset "vercel" requires "srvx" (a dependency of @rangojs/router). Reinstall dependencies.',
     );
   }
-
-  // esbuild ships with Vite, so we never add it as a @rangojs/router dependency.
-  // It is a DIRECT dependency of Vite but only a TRANSITIVE one from the app's
-  // view, so under strict pnpm it is NOT resolvable from the app root. Resolve it
-  // through Vite's module location (Vite is a direct app dependency, and esbuild
-  // is a direct dependency of Vite). Minimal structural types avoid coupling to
-  // esbuild's type package at compile time.
-  const appRequire = createRequire(join(root, "package.json"));
-  const resolveEsbuildPath = (): string => {
-    try {
-      const viteRequire = createRequire(appRequire.resolve("vite"));
-      return viteRequire.resolve("esbuild");
-    } catch {
-      // Intentionally empty: fall through to the app/rango fallbacks below.
-    }
-    try {
-      return appRequire.resolve("esbuild");
-    } catch {
-      // Intentionally empty: last resort is @rangojs/router's own resolver.
-    }
-    return rangoRequire.resolve("esbuild");
-  };
-  let esbuildModule: EsbuildModule;
-  try {
-    esbuildModule = (await import(
-      pathToFileURL(resolveEsbuildPath()).href
-    )) as EsbuildModule;
-  } catch {
-    throw new Error(
-      '[rango] preset "vercel" requires "esbuild" to bundle the function launcher. It ships with Vite; reinstall dependencies (or add esbuild to your app dependencies).',
-    );
-  }
-  const esbuildBuild = esbuildModule.build ?? esbuildModule.default?.build;
-  if (typeof esbuildBuild !== "function") {
-    throw new Error('[rango] preset "vercel": could not load esbuild.build.');
-  }
-
-  try {
-    await esbuildBuild({
-      stdin: {
-        contents: LAUNCHER_SOURCE,
-        resolveDir: root,
-        sourcefile: "func-entry.mjs",
-        loader: "js",
-      },
-      outfile: join(funcDir, "index.mjs"),
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      target: "node18",
-      alias: { "srvx/node": srvxNodePath },
-      plugins: [
-        {
-          name: "external-rsc-entry",
-          setup(b: EsbuildPluginBuild) {
-            b.onResolve({ filter: /^\.\/rsc\/index\.js$/ }, () => ({
-              path: "./rsc/index.js",
-              external: true,
-            }));
-          },
-        },
-      ],
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (/@vercel\/functions/.test(message)) {
-      throw new Error(
-        '[rango] preset "vercel": could not resolve "@vercel/functions". Add it to your app dependencies (it also backs VercelCacheStore).\n' +
-          message,
-      );
-    }
-    throw error;
-  }
+  await bundleVercelLauncher({ root, funcDir, srvxNodePath });
 
   // 3b. Mark the function as ESM. The rsc/ssr bundles are .js ESM files with no
   //     package.json in scope on the deployed function (it is isolated at

package/src/vite/plugins/virtual-entries.ts

@@ -63,18 +63,20 @@ function emitProgressiveChunkSize(value: number): string {
 /**
  * Generate the virtual SSR entry. `headScripts` mirrors the rango() plugin
  * option: "preinit" (default) installs the client-reference preinit hook and
- * lets the SSR handlers convert the bootstrap to `bootstrapModules`;
- * "preload" omits the hook and pins the handlers to the hint-only strategy.
+ * threads `getClientEntryUrl` so Fizz emits `bootstrapModules`;
+ * "preload" omits the hook and uses the deprecated inline
+ * `loadBootstrapScriptContent` bootstrap.
  */
 export function getVirtualEntrySSR(
   headScripts: HeadScriptsOption = "preinit",
   progressiveChunkSize?: number,
 ): string {
   const preinit = headScripts !== "preload";
-  // The preload variant drops exactly three preinit-only lines, all built
-  // here so the template below stays a single unconditional shape.
+  // The preload variant drops the preinit-only imports/install and swaps the
+  // bootstrap dep, all built here so the template below stays a single
+  // unconditional shape.
   const depsImportNames = preinit
-    ? "createFromReadableStream,\n  setOnClientReference,"
+    ? "createFromReadableStream,\n  setOnClientReference,\n  getClientEntryUrl,"
     : "createFromReadableStream,";
   const ssrImportNames = preinit ? "\n  installClientReferencePreinit," : "";
   const install = preinit
@@ -85,6 +87,10 @@ export function getVirtualEntrySSR(
 installClientReferencePreinit(setOnClientReference);
 `
     : "";
+  const bootstrapDep = preinit
+    ? "getClientEntryUrl,"
+    : `loadBootstrapScriptContent: () =>
+    import.meta.viteRsc.loadBootstrapScriptContent("index"),`;
   const hs = JSON.stringify(headScripts);
   // Emitted into all three handlers: live SSR and shell capture consume it
   // directly; the resume handler receives it for dep-shape uniformity (resume()
@@ -114,8 +120,7 @@ export const renderHTML = createSSRHandler({
   renderToReadableStream,
   injectRSCPayload,
   headScripts: ${hs},${pcs}
-  loadBootstrapScriptContent: () =>
-    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+  ${bootstrapDep}
 });
 
 export const captureShellHTML = createShellCaptureHandler({
@@ -125,8 +130,7 @@ export const captureShellHTML = createShellCaptureHandler({
   prerender,
   resume,
   headScripts: ${hs},${pcs}
-  loadBootstrapScriptContent: () =>
-    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+  ${bootstrapDep}
 });
 
 export const resumeShellHTML = createShellResumeHandler({
@@ -136,8 +140,7 @@ export const resumeShellHTML = createShellResumeHandler({
   prerender,
   resume,
   headScripts: ${hs},${pcs}
-  loadBootstrapScriptContent: () =>
-    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+  ${bootstrapDep}
 });
 `.trim();
 }