@catmint/adapter-vercel 0.0.0-prealpha.1

package/dist/function-gen.js

@@ -0,0 +1,504 @@
+// @catmint/adapter-vercel — Serverless function wrapper generator
+/**
+ * Build the tag-to-routes mapping from the manifest for cache invalidation.
+ */
+function buildTagToRoutes(manifest) {
+    const tagToRoutes = {};
+    for (const route of manifest.routes) {
+        if (route.cache?.tags) {
+            for (const tag of route.cache.tags) {
+                if (!tagToRoutes[tag]) {
+                    tagToRoutes[tag] = [];
+                }
+                tagToRoutes[tag].push(route.path);
+            }
+        }
+    }
+    return tagToRoutes;
+}
+/**
+ * Generate the platform cache adapter setup code.
+ *
+ * This code is injected at the top of the generated serverless function
+ * to register the Vercel cache adapter before any request handling.
+ *
+ * Returns an empty string if no cached routes or bypass token are present.
+ */
+function generateCacheAdapterSetup(manifest) {
+    const bypassToken = manifest.cache?.invalidation?.bypassToken;
+    const hasCachedRoutes = manifest.routes.some((r) => r.cache);
+    if (!bypassToken || !hasCachedRoutes) {
+        return "";
+    }
+    const tagToRoutes = buildTagToRoutes(manifest);
+    const tagToRoutesJson = JSON.stringify(tagToRoutes, null, 2);
+    return `
+// ── Vercel Platform Cache Adapter ──────────────────────────────────
+// Registers a cache adapter that delegates invalidateCache() calls to
+// Vercel's on-demand ISR revalidation API (x-prerender-revalidate header).
+const __BYPASS_TOKEN = ${JSON.stringify(bypassToken)};
+const __TAG_TO_ROUTES = ${tagToRoutesJson};
+
+const __catmintBaseUrl = typeof process !== "undefined" && process.env.VERCEL_URL
+  ? \`https://\${process.env.VERCEL_URL}\`
+  : null;
+
+const __catmintPlatformAdapter = {
+  name: "@catmint/adapter-vercel",
+  async invalidate(options) {
+    if (!__catmintBaseUrl) return;
+    const routesToRevalidate = new Set();
+    if (options.tag && __TAG_TO_ROUTES[options.tag]) {
+      for (const route of __TAG_TO_ROUTES[options.tag]) {
+        routesToRevalidate.add(route);
+      }
+    }
+    if (options.route) {
+      routesToRevalidate.add(options.route);
+    }
+    await Promise.all([...routesToRevalidate].map(async (routePath) => {
+      try {
+        await fetch(\`\${__catmintBaseUrl}\${routePath}\`, {
+          method: "HEAD",
+          headers: { "x-prerender-revalidate": __BYPASS_TOKEN },
+        });
+      } catch (err) {
+        console.warn("[@catmint/adapter-vercel] ISR revalidation error for " + routePath + ":", err);
+      }
+    }));
+  },
+};
+
+// Register the adapter on globalThis so all environments (RSC/SSR) share it
+const __ga = globalThis;
+__ga.__catmintPlatformCacheAdapter = __catmintPlatformAdapter;
+// ────────────────────────────────────────────────────────────────────
+`;
+}
+/**
+ * Generate the .vc-config.json for the serverless function.
+ */
+export function generateVcConfig(runtime, regions) {
+    if (runtime === "edge") {
+        const config = {
+            runtime: "edge",
+            entrypoint: "handler.js",
+        };
+        if (regions?.length) {
+            config.regions = regions;
+        }
+        return config;
+    }
+    const config = {
+        runtime: "nodejs22.x",
+        handler: "handler.js",
+        launcherType: "Nodejs",
+    };
+    if (regions?.length) {
+        config.regions = regions;
+    }
+    return config;
+}
+/**
+ * Generate the serverless function entry point wrapper.
+ *
+ * For Node.js runtime: exports a default handler function compatible with
+ * Vercel's Node.js serverless function signature.
+ *
+ * For Edge runtime: exports a default fetch handler compatible with
+ * Vercel's Edge runtime.
+ *
+ * When the manifest contains cached routes with a bypass token, the generated
+ * function registers a platform cache adapter that delegates invalidation
+ * to Vercel's on-demand ISR revalidation API.
+ */
+export function generateServerlessFunction(manifest, runtime) {
+    if (runtime === "edge") {
+        return generateEdgeFunction(manifest);
+    }
+    return generateNodejsFunction(manifest);
+}
+function generateNodejsFunction(manifest) {
+    const cacheAdapterSetup = generateCacheAdapterSetup(manifest);
+    return `// Auto-generated by @catmint/adapter-vercel (Node.js runtime) — do not edit
+import * as rscEntry from "./rsc/index.js";
+import * as ssrEntry from "./ssr/index.js";
+${cacheAdapterSetup}
+function collectBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+async function pipeWebStreamToResponse(webStream, res) {
+  const reader = webStream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!res.write(value)) {
+        await new Promise((resolve) => res.once("drain", resolve));
+      }
+    }
+  } finally {
+    reader.releaseLock();
+    res.end();
+  }
+}
+
+async function sendStatusPage(res, statusCode, pathname) {
+  var html = null;
+  if (rscEntry.renderStatusPage && ssrEntry.renderToHtml) {
+    try {
+      var rscResult = await rscEntry.renderStatusPage(statusCode, pathname);
+      if (rscResult) {
+        var htmlStream = await ssrEntry.renderToHtml(rscResult.stream, rscResult.headConfig);
+        var reader = htmlStream.getReader();
+        var decoder = new TextDecoder();
+        var result = "";
+        while (true) {
+          var chunk = await reader.read();
+          if (chunk.done) break;
+          result += decoder.decode(chunk.value, { stream: true });
+        }
+        html = result;
+      }
+    } catch (err) {
+      console.error("Failed to render status page for " + statusCode + ":", err);
+    }
+  }
+  if (!html) html = __catmintErrorPage(statusCode);
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "text/html; charset=utf-8");
+  res.end(html);
+}
+
+function __catmintErrorPage(statusCode, detail) {
+  var titles = { 404: "Not Found", 500: "Internal Server Error" };
+  var descs = {
+    404: "The page you are looking for does not exist.",
+    500: "Something went wrong. Please try again later."
+  };
+  var title = titles[statusCode] || "Error";
+  var desc = descs[statusCode] || "An error occurred.";
+  function esc(s) {
+    return String(s).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;");
+  }
+  var detailBlock = detail
+    ? '\\n  <div class="detail">' + esc(detail) + '</div>'
+    : '';
+  return '<!DOCTYPE html>'
+    + '<html lang="en"><head>'
+    + '<meta charset="utf-8">'
+    + '<meta name="viewport" content="width=device-width,initial-scale=1">'
+    + '<title>' + statusCode + ' \\u2014 ' + title + '</title>'
+    + '<style>'
+    + '*{margin:0;padding:0;box-sizing:border-box}'
+    + 'html,body{height:100%}'
+    + 'body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;color:#111;background:#fafafa;display:flex;align-items:center;justify-content:center;text-align:center}'
+    + '.c{max-width:480px;padding:2rem}'
+    + '.code{font-size:4rem;font-weight:700;letter-spacing:-.02em;color:#222;line-height:1}'
+    + '.divider{width:48px;height:2px;background:#e5e5e5;margin:1.25rem auto}'
+    + '.title{font-size:1.125rem;font-weight:500;color:#444;margin-bottom:.5rem}'
+    + '.desc{font-size:.875rem;color:#888;line-height:1.5}'
+    + '.detail{margin-top:1.5rem;padding:1rem;background:#f0f0f0;border-radius:6px;font-family:"SF Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,monospace;font-size:.75rem;color:#666;text-align:left;white-space:pre-wrap;word-break:break-word;max-height:200px;overflow:auto}'
+    + '</style></head><body>'
+    + '<div class="c">'
+    + '<div class="code">' + statusCode + '</div>'
+    + '<div class="divider"></div>'
+    + '<div class="title">' + esc(title) + '</div>'
+    + '<div class="desc">' + esc(desc) + '</div>'
+    + detailBlock
+    + '</div></body></html>';
+}
+
+export default async function handler(req, res) {
+  const url = new URL(req.url || "/", \`https://\${req.headers.host || "localhost"}\`);
+  const pathname = url.pathname;
+  const method = (req.method || "GET").toUpperCase();
+
+  try {
+    // 1. Handle server function RPC calls (/__catmint/fn/*)
+    if (pathname.startsWith("/__catmint/fn/") && ssrEntry.handleServerFn) {
+      const body = await collectBody(req);
+      let parsed;
+      try {
+        parsed = body.length > 0 ? JSON.parse(body.toString("utf-8")) : undefined;
+      } catch {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Invalid JSON body" }));
+        return;
+      }
+      const result = await ssrEntry.handleServerFn(pathname, parsed);
+      if (result) {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify(result.result));
+        return;
+      }
+      res.statusCode = 404;
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({ error: "Server function not found" }));
+      return;
+    }
+
+    // 2. RSC flight stream for client-side navigation (/__catmint/rsc?path=...)
+    if (pathname === "/__catmint/rsc" && method === "GET" && rscEntry.render) {
+      const targetPath = url.searchParams.get("path");
+      if (!targetPath) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing ?path= parameter" }));
+        return;
+      }
+      try {
+        const rscResult = await rscEntry.render(targetPath);
+        if (rscResult) {
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "text/x-component; charset=utf-8");
+          res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+          await pipeWebStreamToResponse(rscResult.stream, res);
+          return;
+        }
+        res.statusCode = 404;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "No matching route" }));
+      } catch (err) {
+        console.error("RSC navigation error:", err);
+        if (!res.headersSent) {
+          res.statusCode = 500;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ error: "RSC navigation error" }));
+        }
+      }
+      return;
+    }
+
+    // 3. API endpoint handling
+    if (ssrEntry.hasEndpoint && ssrEntry.hasEndpoint(pathname)) {
+      const fullUrl = \`https://\${req.headers.host || "localhost"}\${req.url || "/"}\`;
+      const requestInit = {
+        method,
+        headers: Object.fromEntries(
+          Object.entries(req.headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(", ") : v || ""])
+        ),
+      };
+
+      if (method !== "GET" && method !== "HEAD") {
+        const body = await collectBody(req);
+        requestInit.body = new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+      }
+
+      const webRequest = new Request(fullUrl, requestInit);
+      const result = await ssrEntry.handleEndpoint(pathname, method, webRequest);
+
+      if (result) {
+        result.response.headers.forEach((value, key) => {
+          res.setHeader(key, value);
+        });
+        res.statusCode = result.response.status;
+        if (result.response.body) {
+          await pipeWebStreamToResponse(result.response.body, res);
+        } else {
+          res.end();
+        }
+        return;
+      }
+
+      res.statusCode = 405;
+      res.setHeader("Content-Type", "text/plain");
+      res.end(\`Method \${method} not allowed\`);
+      return;
+    }
+
+    // 4. RSC → SSR page rendering pipeline
+    if (method === "GET" && rscEntry.render) {
+      const rscResult = await rscEntry.render(pathname);
+      if (rscResult) {
+        const htmlStream = await ssrEntry.renderToHtml(rscResult.stream, rscResult.headConfig);
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        await pipeWebStreamToResponse(htmlStream, res);
+        return;
+      }
+    }
+
+    // 5. Fallback 404
+    await sendStatusPage(res, 404, pathname);
+  } catch (err) {
+    console.error("Serverless function error:", err);
+    await sendStatusPage(res, 500, pathname);
+  }
+}
+`;
+}
+function generateEdgeFunction(manifest) {
+    const cacheAdapterSetup = generateCacheAdapterSetup(manifest);
+    return `// Auto-generated by @catmint/adapter-vercel (Edge runtime) — do not edit
+import * as rscEntry from "./rsc/index.js";
+import * as ssrEntry from "./ssr/index.js";
+${cacheAdapterSetup}
+async function statusPageResponse(statusCode, pathname) {
+  if (rscEntry.renderStatusPage && ssrEntry.renderToHtml) {
+    try {
+      var rscResult = await rscEntry.renderStatusPage(statusCode, pathname);
+      if (rscResult) {
+        var htmlStream = await ssrEntry.renderToHtml(rscResult.stream, rscResult.headConfig);
+        return new Response(htmlStream, {
+          status: statusCode,
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+      }
+    } catch (err) {
+      console.error("Failed to render status page for " + statusCode + ":", err);
+    }
+  }
+  return new Response(__catmintErrorPage(statusCode), {
+    status: statusCode,
+    headers: { "Content-Type": "text/html; charset=utf-8" },
+  });
+}
+
+function __catmintErrorPage(statusCode, detail) {
+  var titles = { 404: "Not Found", 500: "Internal Server Error" };
+  var descs = {
+    404: "The page you are looking for does not exist.",
+    500: "Something went wrong. Please try again later."
+  };
+  var title = titles[statusCode] || "Error";
+  var desc = descs[statusCode] || "An error occurred.";
+  function esc(s) {
+    return String(s).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;");
+  }
+  var detailBlock = detail
+    ? '\\n  <div class="detail">' + esc(detail) + '</div>'
+    : '';
+  return '<!DOCTYPE html>'
+    + '<html lang="en"><head>'
+    + '<meta charset="utf-8">'
+    + '<meta name="viewport" content="width=device-width,initial-scale=1">'
+    + '<title>' + statusCode + ' \\u2014 ' + title + '</title>'
+    + '<style>'
+    + '*{margin:0;padding:0;box-sizing:border-box}'
+    + 'html,body{height:100%}'
+    + 'body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif;color:#111;background:#fafafa;display:flex;align-items:center;justify-content:center;text-align:center}'
+    + '.c{max-width:480px;padding:2rem}'
+    + '.code{font-size:4rem;font-weight:700;letter-spacing:-.02em;color:#222;line-height:1}'
+    + '.divider{width:48px;height:2px;background:#e5e5e5;margin:1.25rem auto}'
+    + '.title{font-size:1.125rem;font-weight:500;color:#444;margin-bottom:.5rem}'
+    + '.desc{font-size:.875rem;color:#888;line-height:1.5}'
+    + '.detail{margin-top:1.5rem;padding:1rem;background:#f0f0f0;border-radius:6px;font-family:"SF Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,monospace;font-size:.75rem;color:#666;text-align:left;white-space:pre-wrap;word-break:break-word;max-height:200px;overflow:auto}'
+    + '</style></head><body>'
+    + '<div class="c">'
+    + '<div class="code">' + statusCode + '</div>'
+    + '<div class="divider"></div>'
+    + '<div class="title">' + esc(title) + '</div>'
+    + '<div class="desc">' + esc(desc) + '</div>'
+    + detailBlock
+    + '</div></body></html>';
+}
+
+export default async function handler(request) {
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+  const method = request.method.toUpperCase();
+
+  try {
+    // 1. Handle server function RPC calls (/__catmint/fn/*)
+    if (pathname.startsWith("/__catmint/fn/") && ssrEntry.handleServerFn) {
+      const bodyText = await request.text();
+      let parsed;
+      try {
+        parsed = bodyText.length > 0 ? JSON.parse(bodyText) : undefined;
+      } catch {
+        return new Response(
+          JSON.stringify({ error: "Invalid JSON body" }),
+          { status: 400, headers: { "Content-Type": "application/json" } },
+        );
+      }
+      const result = await ssrEntry.handleServerFn(pathname, parsed);
+      if (result) {
+        return new Response(JSON.stringify(result.result), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+      return new Response(
+        JSON.stringify({ error: "Server function not found" }),
+        { status: 404, headers: { "Content-Type": "application/json" } },
+      );
+    }
+
+    // 2. RSC flight stream for client-side navigation (/__catmint/rsc?path=...)
+    if (pathname === "/__catmint/rsc" && method === "GET" && rscEntry.render) {
+      const targetPath = url.searchParams.get("path");
+      if (!targetPath) {
+        return new Response(
+          JSON.stringify({ error: "Missing ?path= parameter" }),
+          { status: 400, headers: { "Content-Type": "application/json" } },
+        );
+      }
+      try {
+        const rscResult = await rscEntry.render(targetPath);
+        if (rscResult) {
+          return new Response(rscResult.stream, {
+            status: 200,
+            headers: {
+              "Content-Type": "text/x-component; charset=utf-8",
+              "Cache-Control": "no-cache, no-store, must-revalidate",
+            },
+          });
+        }
+        return new Response(
+          JSON.stringify({ error: "No matching route" }),
+          { status: 404, headers: { "Content-Type": "application/json" } },
+        );
+      } catch (err) {
+        console.error("RSC navigation error:", err);
+        return new Response(
+          JSON.stringify({ error: "RSC navigation error" }),
+          { status: 500, headers: { "Content-Type": "application/json" } },
+        );
+      }
+    }
+
+    // 3. API endpoint handling
+    if (ssrEntry.hasEndpoint && ssrEntry.hasEndpoint(pathname)) {
+      const result = await ssrEntry.handleEndpoint(pathname, method, request);
+
+      if (result) {
+        return result.response;
+      }
+
+      return new Response(\`Method \${method} not allowed\`, {
+        status: 405,
+        headers: { "Content-Type": "text/plain" },
+      });
+    }
+
+    // 4. RSC → SSR page rendering pipeline
+    if (method === "GET" && rscEntry.render) {
+      const rscResult = await rscEntry.render(pathname);
+      if (rscResult) {
+        const htmlStream = await ssrEntry.renderToHtml(rscResult.stream, rscResult.headConfig);
+        return new Response(htmlStream, {
+          status: 200,
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+      }
+    }
+
+    // 5. Fallback 404
+    return await statusPageResponse(404, pathname);
+  } catch (err) {
+    console.error("Edge function error:", err);
+    return await statusPageResponse(500, pathname);
+  }
+}
+`;
+}
+//# sourceMappingURL=function-gen.js.map

package/dist/function-gen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-gen.js","sourceRoot":"","sources":["../src/function-gen.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import type { CatmintAdapter } from "catmint/config";
+/**
+ * Vercel adapter configuration options.
+ */
+export interface VercelAdapterOptions {
+    /** Runtime for serverless functions: 'nodejs' | 'edge' */
+    runtime?: "nodejs" | "edge";
+    /** Vercel regions to deploy to */
+    regions?: string[];
+}
+/**
+ * Create a Vercel adapter for Catmint.
+ *
+ * Transforms Catmint build output into the Vercel Build Output API v3 format.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'catmint/config'
+ * import vercel from '@catmint/adapter-vercel'
+ *
+ * export default defineConfig({
+ *   adapter: vercel({ runtime: 'edge' }),
+ * })
+ * ```
+ */
+export default function vercelAdapter(options?: VercelAdapterOptions): CatmintAdapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAA+B,MAAM,gBAAgB,CAAC;AAoBlF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,OAAO,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC5B,kCAAkC;IAClC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,CACnC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,cAAc,CA0JhB"}

package/dist/index.js

@@ -0,0 +1,131 @@
+// @catmint/adapter-vercel — Vercel deployment adapter
+import { join } from "node:path";
+import { generateVercelConfig } from "./config-gen.js";
+import { generateServerlessFunction, generateVcConfig, } from "./function-gen.js";
+/**
+ * Create a Vercel adapter for Catmint.
+ *
+ * Transforms Catmint build output into the Vercel Build Output API v3 format.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'catmint/config'
+ * import vercel from '@catmint/adapter-vercel'
+ *
+ * export default defineConfig({
+ *   adapter: vercel({ runtime: 'edge' }),
+ * })
+ * ```
+ */
+export default function vercelAdapter(options) {
+    const runtime = options?.runtime ?? "nodejs";
+    const regions = options?.regions;
+    return {
+        name: "@catmint/adapter-vercel",
+        async adapt(context) {
+            context.log("@catmint/adapter-vercel: Generating Vercel Build Output API v3...");
+            const manifest = context.manifest;
+            // Validate edge runtime compatibility
+            if (runtime === "edge") {
+                validateEdgeCompatibility(manifest, context);
+            }
+            const outputDir = join(context.serverDir, "..", "..", ".vercel", "output");
+            // 1. Generate config.json
+            const configJson = generateVercelConfig(manifest);
+            await context.writeFile(join(outputDir, "config.json"), JSON.stringify(configJson, null, 2));
+            context.log("@catmint/adapter-vercel: Generated .vercel/output/config.json");
+            // 2. Copy client assets to static/
+            const staticOutputDir = join(outputDir, "static");
+            await context.copyDir(context.clientDir, staticOutputDir);
+            context.log("@catmint/adapter-vercel: Copied client assets to static/");
+            // 3. Copy pre-rendered static pages to static/
+            await context.copyDir(context.staticDir, staticOutputDir);
+            context.log("@catmint/adapter-vercel: Copied pre-rendered pages to static/");
+            // 4. Generate serverless function (only if not frontend-only mode)
+            if (manifest.mode !== "frontend") {
+                const funcDir = join(outputDir, "functions", "index.func");
+                // Derive the RSC directory from the server (SSR) directory.
+                // Build output layout: dist/ssr/ (serverDir), dist/rsc/ (RSC entry).
+                const rscDir = join(context.serverDir, "..", "rsc");
+                // Copy SSR bundle into ssr/ subdirectory and RSC bundle into rsc/
+                // subdirectory within the function directory, so the handler can
+                // import both without filename conflicts.
+                await context.copyDir(context.serverDir, join(funcDir, "ssr"));
+                await context.copyDir(rscDir, join(funcDir, "rsc"));
+                // Generate the serverless function entry as handler.js.
+                // This imports from ./ssr/index.js and ./rsc/index.js and wraps
+                // them with the Vercel serverless function handler signature.
+                const functionEntry = generateServerlessFunction(manifest, runtime);
+                await context.writeFile(join(funcDir, "handler.js"), functionEntry);
+                // Add package.json with "type": "module" so Node.js treats .js as ESM.
+                // The function directory is isolated from the project root, so without
+                // this file Node.js defaults to CJS and fails on import statements.
+                await context.writeFile(join(funcDir, "package.json"), JSON.stringify({ type: "module" }, null, 2));
+                // Generate .vc-config.json
+                const vcConfig = generateVcConfig(runtime, regions);
+                await context.writeFile(join(funcDir, ".vc-config.json"), JSON.stringify(vcConfig, null, 2));
+                context.log("@catmint/adapter-vercel: Generated serverless function at functions/index.func/");
+                // 5. Emit Prerender Functions for cached routes
+                const bypassToken = manifest.cache?.invalidation?.bypassToken;
+                const cachedRoutes = manifest.routes.filter((r) => r.cache);
+                if (cachedRoutes.length > 0 && bypassToken) {
+                    for (const route of cachedRoutes) {
+                        // Convert route path to a filesystem-safe function name
+                        // e.g., "/examples/cached-route" → "examples/cached-route"
+                        const routeName = route.path === "/" ? "index" : route.path.replace(/^\//, "");
+                        // Skip the catch-all "index" route (already handled above)
+                        if (routeName === "index")
+                            continue;
+                        // Create the function directory for this route
+                        const routeFuncDir = join(outputDir, "functions", `${routeName}.func`);
+                        // The route function re-uses the same serverless entry and server bundle
+                        await context.copyDir(context.serverDir, join(routeFuncDir, "ssr"));
+                        await context.copyDir(rscDir, join(routeFuncDir, "rsc"));
+                        await context.writeFile(join(routeFuncDir, "handler.js"), functionEntry);
+                        await context.writeFile(join(routeFuncDir, "package.json"), JSON.stringify({ type: "module" }, null, 2));
+                        await context.writeFile(join(routeFuncDir, ".vc-config.json"), JSON.stringify(vcConfig, null, 2));
+                        // Emit the prerender config
+                        const prerenderConfig = {
+                            expiration: route.cache?.revalidate ?? false,
+                            bypassToken,
+                        };
+                        await context.writeFile(join(outputDir, "functions", `${routeName}.prerender-config.json`), JSON.stringify(prerenderConfig, null, 2));
+                        context.log(`@catmint/adapter-vercel: Prerender function for ${route.path} (TTL: ${route.cache?.revalidate ?? "none"}s)`);
+                    }
+                    context.log(`@catmint/adapter-vercel: Emitted ${cachedRoutes.length} Prerender Function(s)`);
+                }
+            }
+            context.log("@catmint/adapter-vercel: Build output ready at .vercel/output/");
+        },
+    };
+}
+/**
+ * Basic validation that edge runtime doesn't use Node.js-specific APIs.
+ * This is a best-effort check based on the manifest.
+ */
+function validateEdgeCompatibility(manifest, context) {
+    // Warn about potential issues with edge runtime
+    if (manifest.serverFunctions.length > 0) {
+        context.log("@catmint/adapter-vercel: Warning — Edge runtime selected with server functions. " +
+            "Ensure server functions do not use Node.js-specific APIs (fs, child_process, etc.).");
+    }
+    const nodeOnlyIndicators = [
+        "node:",
+        "fs",
+        "child_process",
+        "cluster",
+        "dgram",
+        "dns",
+        "net",
+        "tls",
+    ];
+    for (const fn of manifest.serverFunctions) {
+        for (const indicator of nodeOnlyIndicators) {
+            if (fn.source.includes(indicator)) {
+                context.log(`@catmint/adapter-vercel: Warning — Server function "${fn.name}" source path ` +
+                    `contains "${indicator}" which may not be compatible with edge runtime.`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=index.js.map