@rangojs/router 0.0.0-experimental.137 → 0.0.0-experimental.139

package/dist/vite/index.js

@@ -1,6 +1,6 @@
 // src/vite/rango.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
+import { readFileSync as readFileSync7, existsSync as existsSync8 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
 
 // src/vite/plugins/expose-action-id.ts
 import MagicString from "magic-string";
@@ -2279,6 +2279,77 @@ export default function handler(request, env) {
 }
 `.trim();
 }
+function getVirtualEntryRSCHost(hostEntryPath) {
+  return `
+import * as __hostEntry from "${hostEntryPath}";
+import { isNoRouteMatchError } from "@rangojs/router/host";
+
+// Register every sub-app's fetchable loaders + route manifests at startup, same
+// as the single-router entry. Discovery's host fallback populates these for all
+// mounted sub-apps, so the aggregate manifests cover the whole host tree.
+import "virtual:rsc-router/loader-manifest";
+import "virtual:rsc-router/routes-manifest";
+
+// The host entry module must export the HostRouter instance (createHostRouter()),
+// as a default export or a named \`hostRouter\`/\`router\` export. A Cloudflare-style
+// \`export default { fetch }\` object is not a HostRouter and is rejected (on first
+// request; see the lazy resolution below).
+// We require BOTH .match() and .host(): a regular createRouter() also exposes
+// .match(), so matching on .match() alone would accept an ordinary router and then
+// return its MatchResult (not a Response) at runtime. .host() is unique to a
+// HostRouter, so it disambiguates a mistaken \`hostRouter\` path.
+// Exports are read dynamically (m[name]) so Rollup does not emit IMPORT_IS_UNDEFINED
+// warnings for the named exports a default-only host module legitimately omits.
+const __resolveHostRouter = (m) => {
+  for (const name of ["default", "hostRouter", "router"]) {
+    const candidate = m[name];
+    if (
+      candidate &&
+      typeof candidate.match === "function" &&
+      typeof candidate.host === "function"
+    )
+      return candidate;
+  }
+  return undefined;
+};
+
+// Resolve + validate the HostRouter lazily on first request, mirroring the
+// single-router entry's \`_handler\`. During HMR the host module can re-evaluate
+// before its createHostRouter() export has resolved; validating at module-
+// evaluation time would then throw a spurious "must export a HostRouter" error
+// overlay for a perfectly valid app. Resolving on first request lets the live
+// binding settle first.
+let _hostRouter;
+
+// input = { env, ctx } from the launcher / node server. The host router threads
+// it unchanged to each matched sub-app's handler and cache factory.
+// On node/vercel rango owns this entry, so there is no user worker to translate
+// an unmatched host into a response: catch NoRouteMatchError and return 404
+// (parity with the documented Cloudflare catch). Other errors propagate.
+export default async function handler(request, input) {
+  if (!_hostRouter) {
+    _hostRouter = __resolveHostRouter(__hostEntry);
+    if (!_hostRouter) {
+      throw new Error(
+        "[rango] The host entry (${hostEntryPath}) must export a HostRouter instance (createHostRouter()) for the node/vercel preset: a default export, or a named 'hostRouter'/'router' export. An ordinary createRouter() is not a host router (it has no .host()), and a Cloudflare-style 'export default { fetch }' object is not supported on this preset."
+      );
+    }
+  }
+  try {
+    return await _hostRouter.match(request, input);
+  } catch (err) {
+    // isNoRouteMatchError also matches by name: a workspace with a duplicated
+    // @rangojs/router copy can throw a NoRouteMatchError whose prototype differs
+    // from this module's import, so a bare instanceof would turn an
+    // unmatched-host 404 into a 500.
+    if (isNoRouteMatchError(err)) {
+      return new Response("Not Found", { status: 404 });
+    }
+    throw err;
+  }
+}
+`.trim();
+}
 var VIRTUAL_IDS = {
   browser: "virtual:rsc-router/entry.browser.js",
   ssr: "virtual:rsc-router/entry.ssr.js",
@@ -2297,7 +2368,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.137",
+  version: "0.0.0-experimental.139",
   description: "Django-inspired RSC router with composable URL patterns",
   keywords: [
     "react",
@@ -2412,6 +2483,11 @@ var package_default = {
       "react-server": "./src/cloudflare/index.ts",
       default: "./src/cloudflare/index.ts"
     },
+    "./vercel": {
+      types: "./src/vercel/index.ts",
+      "react-server": "./src/vercel/index.ts",
+      default: "./src/vercel/index.ts"
+    },
     "./theme": {
       types: "./src/theme/index.ts",
       default: "./src/theme/index.ts"
@@ -2477,9 +2553,11 @@ var package_default = {
     "magic-string": "^0.30.17",
     picomatch: "^4.0.4",
     "rsc-html-stream": "^0.0.7",
+    srvx: "^0.11.15",
     tinyexec: "^0.3.2"
   },
   devDependencies: {
+    "@opentelemetry/api": "^1.9.0",
     "@playwright/test": "^1.49.1",
     "@shared/e2e": "workspace:*",
     "@testing-library/dom": "^10.4.1",
@@ -2497,8 +2575,10 @@ var package_default = {
   },
   peerDependencies: {
     "@cloudflare/vite-plugin": "^1.42.1",
+    "@opentelemetry/api": "^1.9.0",
     "@playwright/test": "^1.49.1",
     "@testing-library/react": ">=16",
+    "@vercel/functions": "^3.0.0",
     "@vitejs/plugin-rsc": "^0.5.27",
     react: ">=19.2.6 <20",
     "react-dom": ">=19.2.6 <20",
@@ -2509,12 +2589,18 @@ var package_default = {
     "@cloudflare/vite-plugin": {
       optional: true
     },
+    "@opentelemetry/api": {
+      optional: true
+    },
     "@playwright/test": {
       optional: true
     },
     "@testing-library/react": {
       optional: true
     },
+    "@vercel/functions": {
+      optional: true
+    },
     vite: {
       optional: true
     },
@@ -2795,6 +2881,96 @@ function extractNamePrefixFromInclude(node) {
   }
   return null;
 }
+function thenSelectsNonDefaultMember(expr) {
+  const findThenCall = (e) => {
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression) && e.expression.name.text === "then") {
+      return e;
+    }
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression)) {
+      return findThenCall(e.expression.expression);
+    }
+    if (ts3.isPropertyAccessExpression(e)) return findThenCall(e.expression);
+    if (ts3.isParenthesizedExpression(e)) return findThenCall(e.expression);
+    if (ts3.isAwaitExpression(e)) return findThenCall(e.expression);
+    return null;
+  };
+  const thenCall = findThenCall(expr);
+  if (!thenCall || thenCall.arguments.length === 0) return false;
+  const cb = thenCall.arguments[0];
+  if (!ts3.isArrowFunction(cb) && !ts3.isFunctionExpression(cb)) return false;
+  let ret;
+  if (ts3.isBlock(cb.body)) {
+    for (const stmt of cb.body.statements) {
+      if (ts3.isReturnStatement(stmt) && stmt.expression) {
+        ret = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    ret = cb.body;
+  }
+  if (!ret) return false;
+  if (ts3.isPropertyAccessExpression(ret)) {
+    return ret.name.text !== "default";
+  }
+  return false;
+}
+function extractDynamicImportSpecifier(node) {
+  let body;
+  if (ts3.isArrowFunction(node) || ts3.isFunctionExpression(node)) {
+    body = node.body;
+  }
+  if (!body) return null;
+  let expr;
+  if (ts3.isBlock(body)) {
+    for (const stmt of body.statements) {
+      if (ts3.isReturnStatement(stmt) && stmt.expression) {
+        expr = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    expr = body;
+  }
+  if (!expr) return null;
+  const findImportCall = (e) => {
+    if (ts3.isCallExpression(e) && e.expression.kind === ts3.SyntaxKind.ImportKeyword) {
+      return e;
+    }
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression)) {
+      return findImportCall(e.expression.expression);
+    }
+    if (ts3.isPropertyAccessExpression(e)) return findImportCall(e.expression);
+    if (ts3.isParenthesizedExpression(e)) return findImportCall(e.expression);
+    if (ts3.isAwaitExpression(e)) return findImportCall(e.expression);
+    return null;
+  };
+  const importCall = findImportCall(expr);
+  if (!importCall || importCall.arguments.length === 0) return null;
+  if (thenSelectsNonDefaultMember(expr)) return null;
+  return getStringValue(importCall.arguments[0]);
+}
+function resolveDefaultExportTarget(code, sourceFile) {
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (ts3.isExportAssignment(node) && !node.isExportEquals) {
+      const expr = node.expression;
+      if (ts3.isIdentifier(expr)) {
+        result = { variableName: expr.text };
+      } else if (ts3.isCallExpression(expr)) {
+        const callee = expr.expression;
+        if (ts3.isIdentifier(callee) && callee.text === "urls") {
+          result = { inlineBlock: expr.getText(sourceFile) };
+        }
+      }
+      return;
+    }
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
 function extractIncludesWithDiagnostics(code, sourceFileArg) {
   const sourceFile = sourceFileArg ?? ts3.createSourceFile(
     "input.tsx",
@@ -2820,12 +2996,19 @@ function extractIncludesWithDiagnostics(code, sourceFileArg) {
         }
         const secondArg = node.arguments[1];
         const namePrefix = extractNamePrefixFromInclude(node);
+        const dynamicImportSpec = extractDynamicImportSpecifier(secondArg);
         if (ts3.isIdentifier(secondArg)) {
           resolved.push({
             pathPrefix,
             variableName: secondArg.text,
             namePrefix
           });
+        } else if (dynamicImportSpec !== null) {
+          resolved.push({
+            pathPrefix,
+            moduleSpecifier: dynamicImportSpec,
+            namePrefix
+          });
         } else if (ts3.isCallExpression(secondArg)) {
           const callText = secondArg.expression.getText(sourceFile);
           unresolvable.push({
@@ -2929,57 +3112,94 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
       diagnosticsOut.push({ ...entry, sourceFile: filePath });
     }
   }
-  for (const { pathPrefix, variableName, namePrefix } of includes) {
+  for (const inc of includes) {
+    const { pathPrefix, namePrefix } = inc;
     let childResult;
-    const imported = resolveImportedVariable(fullSource, variableName);
-    if (imported) {
-      const targetFile = resolveImportPath(imported.specifier, filePath);
+    if (inc.moduleSpecifier) {
+      const targetFile = resolveImportPath(inc.moduleSpecifier, filePath);
       if (!targetFile) {
-        if (diagnosticsOut) {
-          diagnosticsOut.push({
-            pathPrefix,
-            namePrefix,
-            reason: "file-not-found",
-            sourceFile: filePath,
-            detail: `import "${imported.specifier}" resolved to no file`
-          });
-        }
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to no file`
+        });
         continue;
       }
-      childResult = buildCombinedRouteMapWithSearch(
-        targetFile,
-        imported.exportedName,
-        visited,
-        diagnosticsOut,
-        void 0,
-        memo
-      );
-    } else {
-      const sameFileBlock = extractUrlsBlockForVariable(
-        fullSource,
-        variableName,
-        parseBlock(memo, fullSource)
+      let targetSource;
+      try {
+        targetSource = readSourceMemoized(memo, resolve2(targetFile));
+      } catch (err) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to "${targetFile}" but reading it failed: ${err?.message ?? String(err)}`
+        });
+        continue;
+      }
+      const def = resolveDefaultExportTarget(
+        targetSource,
+        parseBlock(memo, targetSource)
       );
-      if (!sameFileBlock) {
-        if (diagnosticsOut) {
-          diagnosticsOut.push({
-            pathPrefix,
-            namePrefix,
-            reason: "unresolvable-import",
-            sourceFile: filePath,
-            detail: `variable "${variableName}" not found in imports or same-file scope`
-          });
-        }
+      if (!def) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "unresolvable-import",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") has no resolvable \`export default urls(...)\``
+        });
         continue;
       }
-      childResult = buildCombinedRouteMapWithSearch(
-        filePath,
+      if (def.inlineBlock) {
+        childResult = buildCombinedRouteMapWithSearch(
+          targetFile,
+          void 0,
+          visited,
+          diagnosticsOut,
+          def.inlineBlock,
+          memo
+        );
+      } else {
+        const variableName = def.variableName;
+        const resolved = resolveIncludedVariable({
+          variableName,
+          resolutionFile: targetFile,
+          resolutionSource: targetSource,
+          reportFile: filePath,
+          memo,
+          visited,
+          diagnosticsOut,
+          pathPrefix,
+          namePrefix,
+          fileNotFoundDetail: (specifier) => `import("${inc.moduleSpecifier}") default re-exports "${variableName}" from "${specifier}", which resolved to no file`,
+          notFoundDetail: () => `import("${inc.moduleSpecifier}") default "${variableName}" not found in its imports or same-file scope`
+        });
+        if (!resolved) continue;
+        childResult = resolved;
+      }
+    } else if (inc.variableName) {
+      const variableName = inc.variableName;
+      const resolved = resolveIncludedVariable({
         variableName,
+        resolutionFile: filePath,
+        resolutionSource: fullSource,
+        reportFile: filePath,
+        memo,
         visited,
         diagnosticsOut,
-        void 0,
-        memo
-      );
+        pathPrefix,
+        namePrefix,
+        fileNotFoundDetail: (specifier) => `import "${specifier}" resolved to no file`,
+        notFoundDetail: () => `variable "${variableName}" not found in imports or same-file scope`
+      });
+      if (!resolved) continue;
+      childResult = resolved;
+    } else {
+      continue;
     }
     if (namePrefix === null) {
       continue;
@@ -3002,6 +3222,64 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
   }
   return routeMap;
 }
+function resolveIncludedVariable(opts) {
+  const {
+    variableName,
+    resolutionFile,
+    resolutionSource,
+    reportFile,
+    memo,
+    visited,
+    diagnosticsOut,
+    pathPrefix,
+    namePrefix
+  } = opts;
+  const imported = resolveImportedVariable(resolutionSource, variableName);
+  if (imported) {
+    const targetFile = resolveImportPath(imported.specifier, resolutionFile);
+    if (!targetFile) {
+      diagnosticsOut?.push({
+        pathPrefix,
+        namePrefix,
+        reason: "file-not-found",
+        sourceFile: reportFile,
+        detail: opts.fileNotFoundDetail(imported.specifier)
+      });
+      return null;
+    }
+    return buildCombinedRouteMapWithSearch(
+      targetFile,
+      imported.exportedName,
+      visited,
+      diagnosticsOut,
+      void 0,
+      memo
+    );
+  }
+  const sameFileBlock = extractUrlsBlockForVariable(
+    resolutionSource,
+    variableName,
+    parseBlock(memo, resolutionSource)
+  );
+  if (!sameFileBlock) {
+    diagnosticsOut?.push({
+      pathPrefix,
+      namePrefix,
+      reason: "unresolvable-import",
+      sourceFile: reportFile,
+      detail: opts.notFoundDetail()
+    });
+    return null;
+  }
+  return buildCombinedRouteMapWithSearch(
+    resolutionFile,
+    variableName,
+    visited,
+    diagnosticsOut,
+    void 0,
+    memo
+  );
+}
 function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut, inlineBlock, memo) {
   visited = visited ?? /* @__PURE__ */ new Set();
   memo = memo ?? createScanMemo();
@@ -3078,7 +3356,10 @@ var ROUTER_CALL_PATTERN_G = /\bcreateRouter\s*[<(]/g;
 function isRoutableSourceFile(name) {
   return (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js") || name.endsWith(".jsx")) && !name.includes(".gen.") && !name.includes(".test.") && !name.includes(".spec.");
 }
-function findRouterFilesRecursive(dir, filter, results) {
+function isExcludedScanDir(name) {
+  return name === "node_modules" || name === "dist" || name === "coverage" || name === "__tests__" || name === "__mocks__" || name.startsWith(".");
+}
+function findCallSiteFilesRecursive(dir, pattern, patternG, stopAtMatchDir, filter, results) {
   let entries;
   try {
     entries = readdirSync(dir, { withFileTypes: true });
@@ -3089,32 +3370,36 @@ function findRouterFilesRecursive(dir, filter, results) {
     return;
   }
   const childDirs = [];
-  const routerFilesInDir = [];
+  const matchesInDir = [];
   for (const entry of entries) {
     const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "coverage" || entry.name === "__tests__" || entry.name === "__mocks__" || entry.name.startsWith("."))
-        continue;
-      childDirs.push(fullPath);
+      if (!isExcludedScanDir(entry.name)) childDirs.push(fullPath);
       continue;
     }
     if (!isRoutableSourceFile(entry.name)) continue;
     if (filter && !filter(fullPath)) continue;
     try {
       const source = readFileSync2(fullPath, "utf-8");
-      if (ROUTER_CALL_PATTERN.test(source) && firstCodeMatchIndex(source, ROUTER_CALL_PATTERN_G) >= 0) {
-        routerFilesInDir.push(fullPath);
+      if (pattern.test(source) && firstCodeMatchIndex(source, patternG) >= 0) {
+        matchesInDir.push(fullPath);
       }
     } catch {
       continue;
     }
   }
-  if (routerFilesInDir.length > 0) {
-    results.push(...routerFilesInDir);
-    return;
-  }
-  for (const childDir of childDirs) {
-    findRouterFilesRecursive(childDir, filter, results);
+  results.push(...matchesInDir);
+  if (!stopAtMatchDir || matchesInDir.length === 0) {
+    for (const childDir of childDirs) {
+      findCallSiteFilesRecursive(
+        childDir,
+        pattern,
+        patternG,
+        stopAtMatchDir,
+        filter,
+        results
+      );
+    }
   }
 }
 function findNestedRouterConflict(routerFiles) {
@@ -3312,7 +3597,28 @@ function buildCombinedRouteMapForRouterFile(routerFilePath) {
 }
 function findRouterFiles(root, filter) {
   const result = [];
-  findRouterFilesRecursive(root, filter, result);
+  findCallSiteFilesRecursive(
+    root,
+    ROUTER_CALL_PATTERN,
+    ROUTER_CALL_PATTERN_G,
+    true,
+    filter,
+    result
+  );
+  return result;
+}
+var HOST_ROUTER_CALL_PATTERN = /\bcreateHostRouter\s*[<(]/;
+var HOST_ROUTER_CALL_PATTERN_G = /\bcreateHostRouter\s*[<(]/g;
+function findHostRouterFiles(root, filter) {
+  const result = [];
+  findCallSiteFilesRecursive(
+    root,
+    HOST_ROUTER_CALL_PATTERN,
+    HOST_ROUTER_CALL_PATTERN_G,
+    false,
+    filter,
+    result
+  );
   return result;
 }
 function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
@@ -3586,6 +3892,7 @@ function isViteDepCachePath(filePath, cacheDir) {
 
 // src/vite/utils/shared-utils.ts
 import * as Vite from "vite";
+import { isAbsolute, resolve as resolve4 } from "node:path";
 
 // src/vite/plugins/performance-tracks.ts
 import { readFile } from "node:fs/promises";
@@ -3668,6 +3975,21 @@ var versionRolldownPlugin = {
 var sharedRolldownOptions = {
   plugins: [versionRolldownPlugin, performanceTracksOptimizeDepsPlugin()]
 };
+function normalizeHostRouterEntry(rawInput, root, exists) {
+  const raw = rawInput.replaceAll("\\", "/");
+  const isRelative = raw.startsWith("./") || raw.startsWith("../");
+  const isRooted = raw.startsWith("/") || isAbsolute(rawInput);
+  if (isRooted) return raw;
+  if (isRelative) {
+    if (!exists(resolve4(root, raw))) {
+      throw new Error(
+        `[rango] hostRouter entry not found: "${rawInput}" (resolved under ${root}). Point it at your createHostRouter() module, e.g. rango({ hostRouter: "./src/worker.rsc.tsx" }).`
+      );
+    }
+    return raw;
+  }
+  return exists(resolve4(root, raw)) ? "./" + raw : raw;
+}
 function createVirtualEntriesPlugin(entries, routerPathRef) {
   const virtualModules = {};
   if (entries.client === VIRTUAL_IDS.browser) {
@@ -3701,7 +4023,7 @@ function createVirtualEntriesPlugin(entries, routerPathRef) {
         if (virtualId === VIRTUAL_IDS.rsc && routerPathRef?.path) {
           const raw = routerPathRef.path.startsWith(".") ? "/" + routerPathRef.path.slice(2) : routerPathRef.path;
           const absoluteRouterPath = raw.replaceAll("\\", "/");
-          return getVirtualEntryRSC(absoluteRouterPath);
+          return routerPathRef.kind === "host" ? getVirtualEntryRSCHost(absoluteRouterPath) : getVirtualEntryRSC(absoluteRouterPath);
         }
       }
       return null;
@@ -3880,6 +4202,221 @@ function resolveClientChunks(option, ctx) {
   return option;
 }
 
+// src/vite/plugins/vercel-output.ts
+import { rm, mkdir, cp, writeFile } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { resolve as resolve5, join as join3 } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import { pathToFileURL } from "node:url";
+var LAUNCHER_SOURCE = `import { toNodeHandler } from "srvx/node";
+import { waitUntil } from "@vercel/functions";
+import rscHandler from "./rsc/index.js";
+
+// The Vercel Node launcher invokes a Node (req, res) handler, not a Web fetch
+// handler. srvx's toNodeHandler bridges the Rango Web fetch handler and pipes
+// the streamed Response to the Node response (set supportsResponseStreaming).
+const onVercel = Boolean(process.env.VERCEL);
+
+const fetchHandler = (request) =>
+  rscHandler(request, {
+    env: process.env,
+    // Forward Vercel's waitUntil so cache writes / revalidation run off the
+    // response path. Omitted off-platform so those writes settle inline.
+    ctx: onVercel ? { waitUntil } : undefined,
+  });
+
+export default toNodeHandler(fetchHandler);
+`;
+function assertVercelNodeRuntime(runtime) {
+  if (runtime != null && !runtime.startsWith("nodejs")) {
+    throw new Error(
+      `[rango] preset "vercel": runtime "${runtime}" is not supported. This preset emits a Node serverless function; use a "nodejs*" runtime (default "nodejs22.x"). The Edge runtime is not supported.`
+    );
+  }
+}
+function assertValidVercelFunctionName(functionName) {
+  if (!/^[A-Za-z0-9._-]+$/.test(functionName)) {
+    throw new Error(
+      `[rango] preset "vercel": invalid functionName ${JSON.stringify(
+        functionName
+      )}. Use letters, digits, ".", "_" or "-" only (it becomes the .func directory and the routing dest).`
+    );
+  }
+}
+function buildVercelVcConfig(vercel) {
+  const vcConfig = {
+    runtime: vercel.runtime ?? "nodejs22.x",
+    handler: "index.mjs",
+    launcherType: "Nodejs",
+    shouldAddHelpers: false,
+    supportsResponseStreaming: true,
+    maxDuration: vercel.maxDuration ?? 30
+  };
+  if (vercel.memory != null) vcConfig.memory = vercel.memory;
+  if (vercel.regions != null) vcConfig.regions = vercel.regions;
+  return vcConfig;
+}
+function buildVercelOutputConfig(functionName, assetsDir) {
+  const assetsPrefix = assetsDir.replace(/^\/+|\/+$/g, "");
+  const assetHeaderRoute = assetsPrefix ? [
+    {
+      src: `/${escapeRegExp(assetsPrefix)}/(.*)`,
+      headers: { "cache-control": "public, max-age=31536000, immutable" },
+      continue: true
+    }
+  ] : [];
+  return {
+    version: 3,
+    routes: [
+      ...assetHeaderRoute,
+      { handle: "filesystem" },
+      { src: "/(.*)", dest: `/${functionName}` }
+    ]
+  };
+}
+async function assemble(root, options, assetsDir, publicDir) {
+  const vercel = options.vercel ?? {};
+  assertVercelNodeRuntime(vercel.runtime);
+  const assetsPrefix = assetsDir.replace(/^\/+|\/+$/g, "");
+  if (publicDir && assetsPrefix && existsSync4(join3(publicDir, assetsPrefix))) {
+    console.warn(
+      `[rango] preset "vercel": ${join3(publicDir, assetsPrefix)} exists. Files under public/${assetsPrefix}/ share the /${assetsPrefix}/ URL prefix with hashed build assets and will be served with a one-year immutable cache-control header. Move un-hashed public files out of "${assetsPrefix}/".`
+    );
+  }
+  const dist = join3(root, "dist");
+  for (const dir of ["client", "rsc", "ssr"]) {
+    if (!existsSync4(join3(dist, dir))) {
+      throw new Error(
+        `[rango] preset "vercel": missing dist/${dir}. Run the production build first.`
+      );
+    }
+  }
+  const functionName = vercel.functionName ?? "index";
+  assertValidVercelFunctionName(functionName);
+  const out = join3(root, ".vercel", "output");
+  const funcDir = join3(out, "functions", `${functionName}.func`);
+  await rm(out, { recursive: true, force: true });
+  await mkdir(funcDir, { recursive: true });
+  await cp(join3(dist, "client"), join3(out, "static"), { recursive: true });
+  await cp(join3(dist, "rsc"), join3(funcDir, "rsc"), { recursive: true });
+  await cp(join3(dist, "ssr"), join3(funcDir, "ssr"), { recursive: true });
+  if (existsSync4(join3(dist, "static"))) {
+    await cp(join3(dist, "static"), join3(funcDir, "static"), {
+      recursive: true
+    });
+  }
+  const rangoRequire = createRequire2(import.meta.url);
+  let srvxNodePath;
+  try {
+    srvxNodePath = rangoRequire.resolve("srvx/node");
+  } catch {
+    throw new Error(
+      '[rango] preset "vercel" requires "srvx" (a dependency of @rangojs/router). Reinstall dependencies.'
+    );
+  }
+  const appRequire = createRequire2(join3(root, "package.json"));
+  const resolveEsbuildPath = () => {
+    try {
+      const viteRequire = createRequire2(appRequire.resolve("vite"));
+      return viteRequire.resolve("esbuild");
+    } catch {
+    }
+    try {
+      return appRequire.resolve("esbuild");
+    } catch {
+    }
+    return rangoRequire.resolve("esbuild");
+  };
+  let esbuildModule;
+  try {
+    esbuildModule = await import(pathToFileURL(resolveEsbuildPath()).href);
+  } 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: join3(funcDir, "index.mjs"),
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node18",
+      alias: { "srvx/node": srvxNodePath },
+      plugins: [
+        {
+          name: "external-rsc-entry",
+          setup(b) {
+            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 writeFile(
+    join3(funcDir, "package.json"),
+    JSON.stringify({ type: "module" }, null, 2) + "\n"
+  );
+  await writeFile(
+    join3(funcDir, ".vc-config.json"),
+    JSON.stringify(buildVercelVcConfig(vercel), null, 2) + "\n"
+  );
+  await writeFile(
+    join3(out, "config.json"),
+    JSON.stringify(buildVercelOutputConfig(functionName, assetsDir), null, 2) + "\n"
+  );
+  console.log(
+    `[rango] assembled .vercel/output (function: ${functionName}.func)`
+  );
+}
+function createVercelOutputPlugin(options) {
+  let root = process.cwd();
+  let isBuild = false;
+  let assetsDir = "assets";
+  let publicDir = "";
+  return {
+    name: "@rangojs/router:vercel-output",
+    configResolved(config) {
+      root = resolve5(config.root);
+      isBuild = config.command === "build";
+      assetsDir = config.environments?.client?.build?.assetsDir ?? config.build?.assetsDir ?? "assets";
+      publicDir = config.publicDir || "";
+    },
+    // buildApp runs once after the whole multi-environment build (rsc, client,
+    // ssr), so dist/ is complete here. closeBundle is unusable for this: it
+    // fires per environment, and twice for ssr (the server-reference scan and
+    // the real build), so it would run before dist/client exists.
+    buildApp: {
+      order: "post",
+      async handler() {
+        if (!isBuild) return;
+        await assemble(root, options, assetsDir, publicDir);
+      }
+    }
+  };
+}
+
 // src/vite/utils/banner.ts
 var rangoVersion = package_default.version;
 var _bannerPrinted = false;
@@ -3907,7 +4444,7 @@ ${dim}   ${reset}${bold}\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550$
 }
 
 // src/vite/plugins/version-injector.ts
-import { resolve as resolve4 } from "node:path";
+import { resolve as resolve6 } from "node:path";
 import * as Vite2 from "vite";
 function createVersionInjectorPlugin(rscEntryPath) {
   let resolvedEntryPath = "";
@@ -3918,7 +4455,7 @@ function createVersionInjectorPlugin(rscEntryPath) {
       let entryPath = rscEntryPath;
       if (!entryPath) entryPath = resolveRscEntryFromConfig(config);
       if (entryPath) {
-        resolvedEntryPath = resolve4(config.root, entryPath);
+        resolvedEntryPath = resolve6(config.root, entryPath);
       }
     },
     transform(code, id) {
@@ -4027,10 +4564,10 @@ function createCjsToEsmPlugin() {
 
 // src/vite/router-discovery.ts
 import { createServer as createViteServer } from "vite";
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 import { readFileSync as readFileSync6 } from "node:fs";
-import { createRequire as createRequire2, register } from "node:module";
-import { pathToFileURL } from "node:url";
+import { createRequire as createRequire3, register } from "node:module";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // src/vite/inject-client-debug.ts
 function injectClientDebugFlag(id) {
@@ -4668,13 +5205,13 @@ function contextSet(variables, keyOrVar, value, options) {
 import { createHash as createHash4 } from "node:crypto";
 import {
   copyFileSync,
-  existsSync as existsSync4,
+  existsSync as existsSync5,
   mkdirSync,
   rmSync,
   statSync,
   writeFileSync as writeFileSync2
 } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { resolve as resolve7 } from "node:path";
 function encodePathParam(value) {
   return String(value).split("/").map((segment) => encodeURIComponent(segment)).join("/");
 }
@@ -4797,7 +5334,7 @@ function resolvePrerenderError(registry, error, onError, label, elapsed, phase,
   throw error;
 }
 function getStagedAssetDir(projectRoot) {
-  return resolve5(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
+  return resolve7(projectRoot, "node_modules/.rangojs-router-build/rsc-assets");
 }
 function resetStagedBuildAssets(projectRoot) {
   rmSync(getStagedAssetDir(projectRoot), { recursive: true, force: true });
@@ -4807,8 +5344,8 @@ function stageBuildAssetModule(projectRoot, prefix, exportValue) {
   mkdirSync(stagedDir, { recursive: true });
   const contentHash = createHash4("sha256").update(exportValue).digest("hex").slice(0, 8);
   const fileName = `${prefix}-${contentHash}.js`;
-  const filePath = resolve5(stagedDir, fileName);
-  if (!existsSync4(filePath)) {
+  const filePath = resolve7(stagedDir, fileName);
+  if (!existsSync5(filePath)) {
     writeFileSync2(filePath, `export default ${exportValue};
 `);
   }
@@ -4816,12 +5353,12 @@ function stageBuildAssetModule(projectRoot, prefix, exportValue) {
 }
 function copyStagedBuildAssets(projectRoot, fileNames) {
   const stagedDir = getStagedAssetDir(projectRoot);
-  const distAssetsDir = resolve5(projectRoot, "dist/rsc/assets");
+  const distAssetsDir = resolve7(projectRoot, "dist/rsc/assets");
   mkdirSync(distAssetsDir, { recursive: true });
   let totalBytes = 0;
   for (const fileName of new Set(fileNames)) {
-    const stagedPath = resolve5(stagedDir, fileName);
-    const distPath = resolve5(distAssetsDir, fileName);
+    const stagedPath = resolve7(stagedDir, fileName);
+    const distPath = resolve7(distAssetsDir, fileName);
     copyFileSync(stagedPath, distPath);
     totalBytes += statSync(stagedPath).size;
   }
@@ -5346,7 +5883,7 @@ async function discoverRouters(state, rscEnv) {
     if (!router.urlpatterns || !generateManifestFull) {
       continue;
     }
-    const manifest = generateManifestFull(
+    const manifest = await generateManifestFull(
       router.urlpatterns,
       routerMountIndex,
       {
@@ -5490,8 +6027,8 @@ async function discoverRouters(state, rscEnv) {
 }
 
 // src/vite/discovery/route-types-writer.ts
-import { dirname as dirname3, join as join3, resolve as resolve6 } from "node:path";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, unlinkSync as unlinkSync2 } from "node:fs";
+import { dirname as dirname3, join as join4, resolve as resolve8 } from "node:path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync6, unlinkSync as unlinkSync2 } from "node:fs";
 function filterUserNamedRoutes(manifest) {
   const filtered = {};
   for (const [name, pattern] of Object.entries(manifest)) {
@@ -5502,7 +6039,7 @@ function filterUserNamedRoutes(manifest) {
   return filtered;
 }
 function writeGenFileIfChanged(state, outPath, source, opts) {
-  const existing = existsSync5(outPath) ? readFileSync4(outPath, "utf-8") : null;
+  const existing = existsSync6(outPath) ? readFileSync4(outPath, "utf-8") : null;
   if (existing === source) return;
   markSelfGenWrite(state, outPath, source);
   writeFileSync3(outPath, source);
@@ -5520,10 +6057,10 @@ function writeRouteTypesFiles(state) {
   if (state.perRouterManifests.length === 0) return;
   try {
     const entryDir = dirname3(
-      resolve6(state.projectRoot, state.resolvedEntryPath)
+      resolve8(state.projectRoot, state.resolvedEntryPath)
     );
-    const oldCombinedPath = join3(entryDir, "named-routes.gen.ts");
-    if (existsSync5(oldCombinedPath)) {
+    const oldCombinedPath = join4(entryDir, "named-routes.gen.ts");
+    if (existsSync6(oldCombinedPath)) {
       unlinkSync2(oldCombinedPath);
       console.log(
         `[rango] Removed stale combined route types: ${oldCombinedPath}`
@@ -5604,7 +6141,7 @@ function supplementGenFilesWithRuntimeRoutes(state) {
 }
 
 // src/vite/discovery/virtual-module-codegen.ts
-import { dirname as dirname4, basename, join as join4 } from "node:path";
+import { dirname as dirname4, basename, join as join5 } from "node:path";
 function generateRoutesManifestModule(state) {
   const hasManifest = state.mergedRouteManifest && Object.keys(state.mergedRouteManifest).length > 0;
   if (hasManifest) {
@@ -5619,7 +6156,7 @@ function generateRoutesManifestModule(state) {
           /\.(tsx?|jsx?)$/,
           ""
         );
-        const genPath = join4(
+        const genPath = join5(
           routerDir,
           `${routerBasename}.named-routes.gen.js`
         ).replaceAll("\\", "/");
@@ -5704,7 +6241,7 @@ function generatePerRouterModule(state, routerId) {
       /\.(tsx?|jsx?)$/,
       ""
     );
-    const genPath = join4(
+    const genPath = join5(
       routerDir,
       `${routerBasename}.named-routes.gen.js`
     ).replaceAll("\\", "/");
@@ -5731,13 +6268,13 @@ function generatePerRouterModule(state, routerId) {
 }
 
 // src/vite/discovery/bundle-postprocess.ts
-import { resolve as resolve7 } from "node:path";
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve9 } from "node:path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "node:fs";
 function postprocessBundle(state) {
   const hasPrerenderData = state.prerenderManifestEntries && Object.keys(state.prerenderManifestEntries).length > 0;
   const hasStaticData = state.staticManifestEntries && Object.keys(state.staticManifestEntries).length > 0;
   if (!hasPrerenderData && !hasStaticData) return;
-  const rscEntryPath = resolve7(
+  const rscEntryPath = resolve9(
     state.projectRoot,
     "dist/rsc",
     state.rscEntryFileName ?? "index.js"
@@ -5758,7 +6295,7 @@ function postprocessBundle(state) {
   ];
   for (const target of evictionTargets) {
     for (const info of target.infos) {
-      const chunkPath = resolve7(state.projectRoot, "dist/rsc", info.fileName);
+      const chunkPath = resolve9(state.projectRoot, "dist/rsc", info.fileName);
       try {
         const code = readFileSync5(chunkPath, "utf-8");
         const result = evictHandlerCode(
@@ -5783,7 +6320,7 @@ function postprocessBundle(state) {
   }
   state.handlerChunkInfoMap.clear();
   state.staticHandlerChunkInfoMap.clear();
-  if (hasPrerenderData && existsSync6(rscEntryPath)) {
+  if (hasPrerenderData && existsSync7(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
     if (!rscCode.includes("__prerender-manifest.js")) {
       try {
@@ -5803,7 +6340,7 @@ function postprocessBundle(state) {
           `export default m;`,
           ""
         ].join("\n");
-        const manifestPath = resolve7(
+        const manifestPath = resolve9(
           state.projectRoot,
           "dist/rsc/__prerender-manifest.js"
         );
@@ -5823,7 +6360,7 @@ function postprocessBundle(state) {
       }
     }
   }
-  if (hasStaticData && existsSync6(rscEntryPath)) {
+  if (hasStaticData && existsSync7(rscEntryPath)) {
     const rscCode = readFileSync5(rscEntryPath, "utf-8");
     if (!rscCode.includes("__static-manifest.js")) {
       try {
@@ -5841,7 +6378,7 @@ function postprocessBundle(state) {
         }
         const manifestCode = `const m={${manifestEntries.join(",")}};globalThis.__STATIC_MANIFEST=m;export default m;
 `;
-        const manifestPath = resolve7(
+        const manifestPath = resolve9(
           state.projectRoot,
           "dist/rsc/__static-manifest.js"
         );
@@ -5873,8 +6410,8 @@ function createDiscoveryGate(s, debug11) {
   let pendingEvents = false;
   const beginGate = () => {
     if (gatePending) return;
-    s.discoveryDone = new Promise((resolve10) => {
-      gateResolver = resolve10;
+    s.discoveryDone = new Promise((resolve12) => {
+      gateResolver = resolve12;
     });
     gatePending = true;
   };
@@ -5966,15 +6503,15 @@ function selectForwardableResolvePlugins(plugins) {
 }
 function pickForwardedRunnerConfig(config) {
   const r = config.resolve ?? {};
-  const resolve10 = {};
-  if (r.alias !== void 0) resolve10.alias = r.alias;
-  if (r.dedupe !== void 0) resolve10.dedupe = r.dedupe;
-  if (r.conditions !== void 0) resolve10.conditions = r.conditions;
-  if (r.mainFields !== void 0) resolve10.mainFields = r.mainFields;
-  if (r.extensions !== void 0) resolve10.extensions = r.extensions;
+  const resolve12 = {};
+  if (r.alias !== void 0) resolve12.alias = r.alias;
+  if (r.dedupe !== void 0) resolve12.dedupe = r.dedupe;
+  if (r.conditions !== void 0) resolve12.conditions = r.conditions;
+  if (r.mainFields !== void 0) resolve12.mainFields = r.mainFields;
+  if (r.extensions !== void 0) resolve12.extensions = r.extensions;
   if (r.preserveSymlinks !== void 0)
-    resolve10.preserveSymlinks = r.preserveSymlinks;
-  if (r.tsconfigPaths !== void 0) resolve10.tsconfigPaths = r.tsconfigPaths;
+    resolve12.preserveSymlinks = r.preserveSymlinks;
+  if (r.tsconfigPaths !== void 0) resolve12.tsconfigPaths = r.tsconfigPaths;
   const userOxc = config.oxc;
   const userJsx = userOxc && typeof userOxc === "object" && typeof userOxc.jsx === "object" && userOxc.jsx !== null ? userOxc.jsx : {};
   const oxc = userOxc && typeof userOxc === "object" ? {
@@ -5982,7 +6519,7 @@ function pickForwardedRunnerConfig(config) {
     jsx: { ...userJsx, runtime: "automatic", importSource: "react" }
   } : { jsx: { runtime: "automatic", importSource: "react" } };
   return {
-    resolve: resolve10,
+    resolve: resolve12,
     define: config.define,
     oxc
   };
@@ -6060,11 +6597,11 @@ async function resolveBuildEnv(option, factoryCtx) {
       );
     }
     try {
-      const userRequire = createRequire2(
-        resolve8(factoryCtx.root, "package.json")
+      const userRequire = createRequire3(
+        resolve10(factoryCtx.root, "package.json")
       );
       const wranglerPath = userRequire.resolve("wrangler");
-      const { getPlatformProxy } = await import(pathToFileURL(wranglerPath).href);
+      const { getPlatformProxy } = await import(pathToFileURL2(wranglerPath).href);
       const proxy = await getPlatformProxy();
       return {
         env: proxy.env,
@@ -6161,8 +6698,8 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
       if (globalThis.__rscRouterDiscoveryActive) return;
       s.devServer = server;
       let resolveDiscovery;
-      const discoveryPromise = new Promise((resolve10) => {
-        resolveDiscovery = resolve10;
+      const discoveryPromise = new Promise((resolve12) => {
+        resolveDiscovery = resolve12;
       });
       const gate = createDiscoveryGate(s, debugDiscovery);
       const beginDiscoveryGate = gate.beginGate;
@@ -6269,6 +6806,10 @@ function createRouterDiscoveryPlugin(entryPath, opts) {
           );
           console.warn(`[rango] Failed to create temp runner: ${err.message}`);
         }
+        await prerenderTempServer?.close().catch(() => {
+        });
+        prerenderTempServer = null;
+        prerenderNodeRegistry = null;
         return null;
       }
       async function clearTempRegistries(tempRscEnv) {
@@ -6740,7 +7281,7 @@ ${err.stack}`
             if (hasCreateRouter) {
               const nestedRouterConflict = findNestedRouterConflict([
                 ...s.cachedRouterFiles ?? [],
-                resolve8(filePath)
+                resolve10(filePath)
               ]);
               if (nestedRouterConflict) {
                 server.config.logger.error(
@@ -7052,7 +7593,11 @@ async function rango(options) {
   ];
   const pkg = getPublishedPackageName();
   const nested = (spec) => `${pkg} > ${spec}`;
-  const routerRef = { path: void 0 };
+  const routerRef = {
+    path: void 0,
+    kind: "router"
+  };
+  const explicitHostRouter = preset !== "cloudflare" ? resolvedOptions.hostRouter : void 0;
   const prerenderEnabled = true;
   if (preset === "cloudflare") {
     const { default: rsc } = await import("@vitejs/plugin-rsc");
@@ -7160,17 +7705,49 @@ async function rango(options) {
       name: "@rangojs/router:auto-discover",
       config(userConfig) {
         if (routerRef.path) return;
-        const root = userConfig.root ? resolve9(process.cwd(), userConfig.root) : process.cwd();
+        const root = userConfig.root ? resolve11(process.cwd(), userConfig.root) : process.cwd();
+        const toRootRelative = (abs) => (abs.startsWith(root) ? "./" + abs.slice(root.length + 1) : abs).replaceAll("\\", "/");
+        const bulletList = (files) => files.map((f) => "  - " + toRootRelative(f)).join("\n");
+        if (explicitHostRouter) {
+          routerRef.path = normalizeHostRouterEntry(
+            explicitHostRouter,
+            root,
+            existsSync8
+          );
+          routerRef.kind = "host";
+          return;
+        }
+        const hostCandidates = findHostRouterFiles(root);
+        if (hostCandidates.length === 1) {
+          const hostPath = toRootRelative(hostCandidates[0]);
+          console.info(
+            `[rango] Serving host router entry ${hostPath} (auto-detected). Set the \`hostRouter\` option to override.`
+          );
+          routerRef.path = hostPath;
+          routerRef.kind = "host";
+          return;
+        }
+        if (hostCandidates.length > 1) {
+          throw new Error(
+            `[rango] Multiple host routers found:
+${bulletList(hostCandidates)}
+
+Set the \`hostRouter\` option to the entry to serve, e.g. rango({ preset: "${preset}", hostRouter: "./src/worker.rsc.tsx" }).`
+          );
+        }
         const candidates = findRouterFiles(root);
         if (candidates.length === 1) {
-          const abs = candidates[0];
-          routerRef.path = (abs.startsWith(root) ? "./" + abs.slice(root.length + 1) : abs).replaceAll("\\", "/");
-        } else if (candidates.length > 1) {
-          const list = candidates.map(
-            (f) => "  - " + (f.startsWith(root) ? f.slice(root.length + 1) : f)
-          ).join("\n");
-          throw new Error(`[rango] Multiple routers found:
-${list}`);
+          routerRef.path = toRootRelative(candidates[0]);
+          routerRef.kind = "router";
+          return;
+        }
+        if (candidates.length > 1) {
+          throw new Error(
+            `[rango] Multiple routers found:
+${bulletList(candidates)}
+
+If this is a multi-app host router, export a createHostRouter() instance and set the \`hostRouter\` option (e.g. rango({ preset: "${preset}", hostRouter: "./src/worker.rsc.tsx" })), or use preset: "cloudflare" where you own the worker entry.`
+          );
         }
       }
     });
@@ -7184,8 +7761,11 @@ ${list}`);
     plugins.push({
       name: "@rangojs/router:rsc-integration",
       enforce: "pre",
-      config() {
+      config(_userConfig, configEnv) {
+        const vercelDefine = preset === "vercel" && configEnv.command === "build" ? { "process.env.NODE_ENV": JSON.stringify("production") } : void 0;
+        const vercelServerEnv = preset === "vercel" && configEnv.command === "build" ? { resolve: { noExternal: true } } : void 0;
         return {
+          ...vercelDefine ? { define: vercelDefine } : {},
           optimizeDeps: {
             exclude: excludeDeps,
             rolldownOptions: sharedRolldownOptions
@@ -7228,6 +7808,7 @@ ${list}`);
               }
             },
             ssr: {
+              ...vercelServerEnv ?? {},
               optimizeDeps: {
                 entries: [VIRTUAL_IDS.ssr],
                 include: [
@@ -7246,6 +7827,7 @@ ${list}`);
               }
             },
             rsc: {
+              ...vercelServerEnv ?? {},
               optimizeDeps: {
                 entries: [VIRTUAL_IDS.rsc],
                 include: [
@@ -7271,7 +7853,11 @@ ${list}`);
       configResolved(config) {
         if (showBanner) {
           const mode = config.command === "serve" ? process.argv.includes("preview") ? "preview" : "dev" : "build";
-          printBanner(mode, "node", rangoVersion);
+          printBanner(
+            mode,
+            preset === "vercel" ? "vercel" : "node",
+            rangoVersion
+          );
         }
         const rscMinimalCount = config.plugins.filter(
           (p) => p.name === "rsc:minimal"
@@ -7333,6 +7919,11 @@ ${list}`);
       clientChunkCtx
     })
   );
+  if (preset === "vercel") {
+    plugins.push(
+      createVercelOutputPlugin(resolvedOptions)
+    );
+  }
   debugConfig?.(
     "rango(%s) setup done: %d plugin(s) (%sms)",
     preset,