vite-plugin-vercel 0.0.2 → 0.0.5

package/dist/index.js

@@ -1,9 +1,7 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -18,309 +16,238 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
-  }
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
   return target;
 };
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
-};
-var __toCommonJS = /* @__PURE__ */ ((cache) => {
-  return (module2, temp) => {
-    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
-  };
-})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  default: () => allPlugins
-});
-var import_promises3 = __toESM(require("fs/promises"));
+import fs5 from "fs/promises";
 
 // src/utils.ts
-var import_vite = require("vite");
-var import_path = __toESM(require("path"));
-var import_promises = __toESM(require("fs/promises"));
+import { normalizePath } from "vite";
+import path from "path";
+import fs from "fs/promises";
 function getRoot(config) {
-  return (0, import_vite.normalizePath)(config.root || process.cwd());
+  return normalizePath(config.root || process.cwd());
 }
 function getOutDir(config, force) {
-  const p = (0, import_vite.normalizePath)(config.build.outDir);
+  const p = normalizePath(config.build.outDir);
   if (!force)
     return p;
-  return import_path.default.join(import_path.default.dirname(p), force);
+  return path.join(path.dirname(p), force);
 }
 function getOutput(config, suffix) {
   var _a, _b;
-  return import_path.default.join(((_a = config.vercel) == null ? void 0 : _a.outDir) ? "" : getRoot(config), ((_b = config.vercel) == null ? void 0 : _b.outDir) ?? ".output", suffix ?? "");
+  return path.join(((_a = config.vercel) == null ? void 0 : _a.outDir) ? "" : getRoot(config), ((_b = config.vercel) == null ? void 0 : _b.outDir) ?? ".vercel/output", suffix ?? "");
 }
 function pathRelativeToApi(filePath, config) {
   const root = getRoot(config);
-  return (0, import_vite.normalizePath)(import_path.default.relative(import_path.default.join(root, "api"), filePath));
+  return normalizePath(path.relative(path.join(root, "api"), filePath));
 }
 async function copyDir(src, dest) {
-  await import_promises.default.mkdir(dest, { recursive: true });
-  const entries = await import_promises.default.readdir(src, { withFileTypes: true });
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = import_path.default.join(src, entry.name);
-    const destPath = import_path.default.join(dest, entry.name);
-    entry.isDirectory() ? await copyDir(srcPath, destPath) : await import_promises.default.copyFile(srcPath, destPath);
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    entry.isDirectory() ? await copyDir(srcPath, destPath) : await fs.copyFile(srcPath, destPath);
   }
 }
 
-// src/manifests.ts
-var import_path2 = __toESM(require("path"));
+// src/config.ts
+import path2 from "path";
+
+// src/schemas/config/config.ts
+import { z } from "zod";
+var HasOrMissing = z.array(z.union([
+  z.object({
+    type: z.literal("host"),
+    value: z.string()
+  }).strict(),
+  z.object({
+    type: z.literal("header"),
+    key: z.string(),
+    value: z.string().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("cookie"),
+    key: z.string(),
+    value: z.string().optional()
+  }).strict(),
+  z.object({
+    type: z.literal("query"),
+    key: z.string(),
+    value: z.string().optional()
+  }).strict()
+])).optional();
+var vercelOutputConfigSchema = z.object({
+  version: z.literal(3),
+  routes: z.array(z.union([
+    z.object({
+      src: z.string(),
+      dest: z.string().optional(),
+      headers: z.record(z.string()).optional(),
+      methods: z.array(z.string()).optional(),
+      status: z.number().int().positive().optional(),
+      continue: z.boolean().optional(),
+      check: z.boolean().optional(),
+      missing: HasOrMissing,
+      has: HasOrMissing,
+      locale: z.object({
+        redirect: z.record(z.string()).optional(),
+        cookie: z.string().optional()
+      }).strict().optional(),
+      middlewarePath: z.string().optional()
+    }).strict(),
+    z.object({
+      handle: z.union([
+        z.literal("rewrite"),
+        z.literal("filesystem"),
+        z.literal("resource"),
+        z.literal("miss"),
+        z.literal("hit"),
+        z.literal("error")
+      ]),
+      src: z.string().optional(),
+      dest: z.string().optional(),
+      status: z.number().optional()
+    }).strict()
+  ])).optional(),
+  images: z.object({
+    sizes: z.tuple([
+      z.number().int().positive(),
+      z.number().int().positive()
+    ]),
+    domains: z.array(z.string()).nonempty().optional(),
+    minimumCacheTTL: z.number().int().positive().optional(),
+    formats: z.union([z.literal("image/avif"), z.literal("image/webp")]).array().nonempty().optional(),
+    dangerouslyAllowSVG: z.boolean().optional(),
+    contentSecurityPolicy: z.string().optional()
+  }).strict().optional(),
+  wildcard: z.array(z.object({
+    domain: z.string(),
+    value: z.string()
+  }).strict()).optional(),
+  overrides: z.record(z.object({
+    path: z.string().optional(),
+    contentType: z.string().optional()
+  }).strict()).optional(),
+  cache: z.array(z.string()).optional()
+}).strict();
+
+// src/config.ts
+import fs2 from "fs/promises";
+import { getTransformedRoutes } from "@vercel/routing-utils";
+function getConfig(resolvedConfig, config) {
+  var _a, _b, _c, _d, _e;
+  const { routes } = getTransformedRoutes({
+    nowConfig: {
+      cleanUrls: true
+    }
+  });
+  return vercelOutputConfigSchema.parse(__spreadProps(__spreadValues({
+    version: 3
+  }, (_a = resolvedConfig.vercel) == null ? void 0 : _a.config), {
+    routes: [
+      ...routes ?? [],
+      ...(config == null ? void 0 : config.routes) ?? [],
+      ...((_c = (_b = resolvedConfig.vercel) == null ? void 0 : _b.config) == null ? void 0 : _c.routes) ?? []
+    ],
+    overrides: __spreadValues(__spreadValues({}, (_e = (_d = resolvedConfig.vercel) == null ? void 0 : _d.config) == null ? void 0 : _e.overrides), config == null ? void 0 : config.overrides)
+  }));
+}
+function getConfigDestination(resolvedConfig) {
+  return path2.join(getOutput(resolvedConfig), "config.json");
+}
+async function writeConfig(resolvedConfig, config) {
+  await fs2.writeFile(getConfigDestination(resolvedConfig), JSON.stringify(getConfig(resolvedConfig, config), void 0, 2), "utf-8");
+}
+
+// src/build.ts
+import glob from "fast-glob";
+import path3 from "path";
+import { build } from "esbuild";
 
 // src/assert.ts
-var import_libassert = require("@brillout/libassert");
+import { newError } from "@brillout/libassert";
 var libName = "vite-plugin-vercel";
 function assert(condition, errorMessage) {
   if (condition) {
     return;
   }
-  const err = (0, import_libassert.newError)(`[${libName}][Wrong Usage] ${errorMessage}`, 2);
+  const err = newError(`[${libName}][Wrong Usage] ${errorMessage}`, 2);
   throw err;
 }
 
-// src/schemas/manifests/routes.ts
-var myzod = __toESM(require("myzod"));
-function record(schema) {
-  return myzod.object({
-    [myzod.keySignature]: schema
-  });
-}
-var routesManifestRedirectSchema = myzod.object({
-  source: myzod.string(),
-  destination: myzod.string(),
-  statusCode: myzod.literals(301, 302, 307, 308),
-  regex: myzod.string()
-});
-var routesManifestHeaderSchema = myzod.object({
-  source: myzod.string(),
-  headers: myzod.array(myzod.object({
-    key: myzod.string(),
-    value: myzod.string()
-  })),
-  regex: myzod.string()
-});
-var routesManifestRewriteSchema = myzod.object({
-  source: myzod.string(),
-  has: myzod.array(myzod.object({
-    key: myzod.string(),
-    value: myzod.string(),
-    type: myzod.literals("header", "cookie", "host", "query")
-  })).optional(),
-  destination: myzod.string(),
-  regex: myzod.string()
-});
-var routesManifestDynamicRouteSchema = myzod.object({
-  page: myzod.string(),
-  regex: myzod.string(),
-  routeKeys: record(myzod.string()).optional(),
-  namedRegex: myzod.string().optional()
-});
-var routesManifestSchema = myzod.object({
-  version: myzod.literal(3),
-  basePath: myzod.string().pattern(/^\/.*/),
-  pages404: myzod.boolean(),
-  redirects: myzod.array(routesManifestRedirectSchema).optional(),
-  headers: myzod.array(routesManifestHeaderSchema).optional(),
-  rewrites: myzod.array(routesManifestRewriteSchema).optional(),
-  dynamicRoutes: myzod.array(routesManifestDynamicRouteSchema).optional()
-});
-
-// src/schemas/manifests/functions.ts
-var myzod2 = __toESM(require("myzod"));
-function record2(schema) {
-  return myzod2.object({
-    [myzod2.keySignature]: schema
-  });
-}
-var functionsManifestSchemaPage = myzod2.object({
-  runtime: myzod2.string().optional(),
-  handler: myzod2.string().optional(),
-  regions: myzod2.array(myzod2.string()).optional(),
-  maxDuration: myzod2.number().min(1).max(900).optional(),
-  memory: myzod2.number().min(128).max(3008).optional()
-});
-var functionsManifestSchemaPageWeb = myzod2.omit(functionsManifestSchemaPage, ["runtime"]).and(myzod2.object({
-  runtime: myzod2.literal("web"),
-  env: myzod2.array(myzod2.string()),
-  files: myzod2.array(myzod2.string()),
-  name: myzod2.string(),
-  page: myzod2.string(),
-  regexp: myzod2.string(),
-  sortingIndex: myzod2.number()
-}));
-var functionsManifestSchema = myzod2.object({
-  version: myzod2.literal(1),
-  pages: myzod2.object({
-    "_middleware.js": functionsManifestSchemaPageWeb.optional()
-  }).and(record2(myzod2.intersection(myzod2.partial(myzod2.omit(functionsManifestSchemaPageWeb, ["runtime"])), functionsManifestSchemaPage)))
-});
-
-// src/schemas/manifests/prerender.ts
-var myzod3 = __toESM(require("myzod"));
-function record3(schema) {
-  return myzod3.object({
-    [myzod3.keySignature]: schema
-  });
-}
-var prerenderManifestSchemaRoute = myzod3.object({
-  initialRevalidateSeconds: myzod3.number(),
-  srcRoute: myzod3.string(),
-  dataRoute: myzod3.string()
-});
-var prerenderManifestSchemaDynamicRoute = myzod3.object({
-  routeRegex: myzod3.string(),
-  fallback: myzod3.string().or(myzod3.null()),
-  dataRoute: myzod3.string(),
-  dataRouteRegex: myzod3.string()
-});
-var prerenderManifestSchema = myzod3.object({
-  version: myzod3.literal(3),
-  routes: record3(prerenderManifestSchemaRoute),
-  dynamicRoutes: record3(prerenderManifestSchemaDynamicRoute),
-  preview: myzod3.object({
-    previewModeId: myzod3.string().or(myzod3.null())
-  })
-});
-
-// src/manifests.ts
-function getPrerenderManifest(resolvedConfig, isrPages) {
-  var _a, _b;
-  const prerenderManifestDefault = (_a = resolvedConfig.vercel) == null ? void 0 : _a.prerenderManifest;
-  const routes = Object.entries((isrPages == null ? void 0 : isrPages.routes) ?? {}).reduce((acc, [key, val]) => {
-    var _a2, _b2, _c, _d, _e, _f, _g;
-    const srcRoute = (val == null ? void 0 : val.srcRoute) ?? ((_b2 = (_a2 = prerenderManifestDefault == null ? void 0 : prerenderManifestDefault.routes) == null ? void 0 : _a2[key]) == null ? void 0 : _b2.srcRoute);
-    assert(typeof srcRoute === "string", `\`[prerender-manifest] { srcRoute }\` is required for route ${key}`);
-    acc[key === "/" ? "/index" : key] = {
-      initialRevalidateSeconds: (val == null ? void 0 : val.initialRevalidateSeconds) ?? ((_d = (_c = prerenderManifestDefault == null ? void 0 : prerenderManifestDefault.routes) == null ? void 0 : _c[key]) == null ? void 0 : _d.initialRevalidateSeconds) ?? ((_e = resolvedConfig.vercel) == null ? void 0 : _e.initialRevalidateSeconds) ?? 86400,
-      srcRoute,
-      dataRoute: (val == null ? void 0 : val.dataRoute) ?? ((_g = (_f = prerenderManifestDefault == null ? void 0 : prerenderManifestDefault.routes) == null ? void 0 : _f[key]) == null ? void 0 : _g.dataRoute) ?? ""
-    };
-    return acc;
-  }, {});
-  const uniqueRoutes = Array.from(new Set(Object.values(routes).map((r) => r.srcRoute)));
-  const dynamicRoutes = uniqueRoutes.reduce((acc, cur) => {
-    var _a2, _b2, _c, _d, _e, _f;
-    acc[cur] = {
-      routeRegex: "^" + cur + "$",
-      dataRoute: ((_b2 = (_a2 = prerenderManifestDefault == null ? void 0 : prerenderManifestDefault.dynamicRoutes) == null ? void 0 : _a2[cur]) == null ? void 0 : _b2.dataRoute) ?? "",
-      fallback: ((_d = (_c = prerenderManifestDefault == null ? void 0 : prerenderManifestDefault.dynamicRoutes) == null ? void 0 : _c[cur]) == null ? void 0 : _d.fallback) ?? null,
-      dataRouteRegex: ((_f = (_e = prerenderManifestDefault == null ? void 0 : prerenderManifestDefault.dynamicRoutes) == null ? void 0 : _e[cur]) == null ? void 0 : _f.dataRouteRegex) ?? ""
-    };
-    return acc;
-  }, {});
-  return prerenderManifestSchema.parse({
-    version: 3,
-    routes,
-    dynamicRoutes,
-    preview: {
-      previewModeId: ((_b = prerenderManifestDefault == null ? void 0 : prerenderManifestDefault.preview) == null ? void 0 : _b.previewModeId) ?? null
-    }
-  }, {
-    collectErrors: true
-  });
-}
-function getPrerenderManifestDestination(resolvedConfig) {
-  return import_path2.default.join(getOutput(resolvedConfig), "prerender-manifest.json");
-}
-function getRoutesManifest(resolvedConfig, ssr) {
-  var _a;
-  const routesManifest = (_a = resolvedConfig.vercel) == null ? void 0 : _a.routesManifest;
-  const allRewrites = [
-    ...(ssr == null ? void 0 : ssr.rewrites) ?? [],
-    ...(routesManifest == null ? void 0 : routesManifest.rewrites) ?? []
-  ];
-  const allDynamicRoutes = [
-    ...(ssr == null ? void 0 : ssr.dynamicRoutes) ?? [],
-    ...(routesManifest == null ? void 0 : routesManifest.dynamicRoutes) ?? []
-  ];
-  return routesManifestSchema.parse({
-    version: 3,
-    basePath: (routesManifest == null ? void 0 : routesManifest.basePath) ?? "/",
-    pages404: (routesManifest == null ? void 0 : routesManifest.pages404) ?? true,
-    dynamicRoutes: allDynamicRoutes.length > 0 ? allDynamicRoutes : void 0,
-    rewrites: allRewrites.length > 0 ? allRewrites : void 0,
-    redirects: routesManifest == null ? void 0 : routesManifest.redirects,
-    headers: routesManifest == null ? void 0 : routesManifest.headers
-  }, {
-    collectErrors: true
-  });
-}
-function getRoutesManifestDestination(resolvedConfig) {
-  return import_path2.default.join(getOutput(resolvedConfig), "routes-manifest.json");
-}
-function getFunctionsManifest(pages) {
-  return functionsManifestSchema.parse({
-    version: 1,
-    pages
-  }, {
-    collectErrors: true
-  });
-}
-function getFunctionsManifestDestination(resolvedConfig) {
-  return import_path2.default.join(getOutput(resolvedConfig), "functions-manifest.json");
-}
+// src/schemas/config/vc-config.ts
+import { z as z2 } from "zod";
+var vercelOutputEdgeVcConfigSchema = z2.object({
+  runtime: z2.literal("edge"),
+  entrypoint: z2.string(),
+  envVarsInUse: z2.array(z2.string()).optional()
+}).strict();
+var vercelOutputServerlessVcConfigSchema = z2.object({
+  runtime: z2.string(),
+  handler: z2.string(),
+  memory: z2.number().int().min(128).max(3008).optional(),
+  maxDuration: z2.number().int().positive().optional(),
+  environment: z2.record(z2.string()).optional(),
+  regions: z2.array(z2.string()).optional()
+}).strict();
+var vercelOutputServerlessNodeVcConfigSchema = vercelOutputServerlessVcConfigSchema.extend({
+  launcherType: z2.literal("Nodejs"),
+  shouldAddHelpers: z2.boolean().optional(),
+  shouldAddSourcemapSupport: z2.boolean().optional(),
+  awsLambdaHandler: z2.string().optional()
+}).strict();
+var vercelOutputVcConfigSchema = z2.union([
+  vercelOutputEdgeVcConfigSchema,
+  vercelOutputServerlessVcConfigSchema,
+  vercelOutputServerlessNodeVcConfigSchema
+]);
 
 // src/build.ts
-var import_fast_glob = __toESM(require("fast-glob"));
-var import_path3 = __toESM(require("path"));
-var import_esbuild = require("esbuild");
-var import_promises2 = __toESM(require("fs/promises"));
-function getPagesEndpoints(resolvedConfig) {
+import fs3 from "fs/promises";
+function getAdditionalEndpoints(resolvedConfig) {
   var _a;
-  const apiEndpoints = (((_a = resolvedConfig.vercel) == null ? void 0 : _a.pagesEndpoints) ?? []).map((p) => import_path3.default.isAbsolute(p) ? p : import_path3.default.resolve(getRoot(resolvedConfig), p));
-  return new Set(apiEndpoints);
+  return (((_a = resolvedConfig.vercel) == null ? void 0 : _a.additionalEndpoints) ?? []).map((e) => __spreadProps(__spreadValues({}, e), {
+    destination: e.destination + ".func"
+  }));
 }
-function getApiEntries(resolvedConfig) {
-  var _a;
-  const pagesEndpoints = getPagesEndpoints(resolvedConfig);
-  const apiEntries = import_fast_glob.default.sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !import_path3.default.basename(filepath).startsWith("_"));
+function getEntries(resolvedConfig) {
+  const apiEntries = glob.sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !path3.basename(filepath).startsWith("_"));
   return apiEntries.reduce((entryPoints, filePath) => {
     const outFilePath = pathRelativeToApi(filePath, resolvedConfig);
-    const parsed = import_path3.default.parse(outFilePath);
-    const alsoPage = pagesEndpoints.has(filePath);
+    const parsed = path3.parse(outFilePath);
     const entry = {
       source: filePath,
-      destination: [`api/${import_path3.default.join(parsed.dir, parsed.name)}`]
+      destination: `api/${path3.join(parsed.dir, parsed.name)}.func`
     };
-    if (alsoPage) {
-      entry.destination.push(`${import_path3.default.join(parsed.dir, parsed.name)}`);
-    }
     entryPoints.push(entry);
     return entryPoints;
-  }, ((_a = resolvedConfig.vercel) == null ? void 0 : _a.additionalEndpoints) ?? []);
+  }, getAdditionalEndpoints(resolvedConfig));
 }
 var standardBuildOptions = {
   bundle: true,
   target: "es2020",
-  format: "cjs",
+  format: "esm",
   platform: "node",
   logLevel: "info",
   minify: true
 };
 async function buildFn(resolvedConfig, entry, buildOptions) {
-  var _a, _b, _c, _d;
-  if (!Array.isArray(entry.destination)) {
-    entry.destination = [entry.destination];
-  }
   assert(entry.destination.length > 0, `Endpoint ${typeof entry.source === "string" ? entry.source : "-"} does not have build destination`);
-  const [firstDestination, ...remainingDestinations] = entry.destination;
-  const pages = ((_b = (_a = resolvedConfig.vercel) == null ? void 0 : _a.functionsManifest) == null ? void 0 : _b.pages) ?? {};
-  const fnManifests = {};
-  const outfile = import_path3.default.join(getOutput(resolvedConfig, "server/pages"), firstDestination + ".js");
+  const outfile = path3.join(getOutput(resolvedConfig, "functions"), entry.destination, "index.js");
   const options = Object.assign({}, standardBuildOptions, { outfile });
   if (buildOptions) {
     Object.assign(options, buildOptions);
@@ -334,31 +261,42 @@ async function buildFn(resolvedConfig, entry, buildOptions) {
       options.stdin = entry.source;
     }
   }
-  await (0, import_esbuild.build)(options);
-  fnManifests[firstDestination + ".js"] = __spreadValues({
-    maxDuration: (_c = resolvedConfig.vercel) == null ? void 0 : _c.defaultMaxDuration
-  }, pages[firstDestination + ".js"]);
-  for (const dest of remainingDestinations) {
-    await import_promises2.default.mkdir(import_path3.default.join(getOutput(resolvedConfig, "server/pages"), import_path3.default.dirname(dest)), {
-      recursive: true
-    });
-    await import_promises2.default.copyFile(outfile, import_path3.default.join(getOutput(resolvedConfig, "server/pages"), dest + ".js"));
-    fnManifests[dest + ".js"] = __spreadValues({
-      maxDuration: (_d = resolvedConfig.vercel) == null ? void 0 : _d.defaultMaxDuration
-    }, pages[dest + ".js"] ?? pages[firstDestination + ".js"]);
-  }
-  return fnManifests;
+  await build(options);
+  await writeVcConfig(resolvedConfig, entry.destination);
+}
+async function writeVcConfig(resolvedConfig, destination) {
+  var _a;
+  const vcConfig = path3.join(getOutput(resolvedConfig, "functions"), destination, ".vc-config.json");
+  await fs3.writeFile(vcConfig, JSON.stringify(vercelOutputVcConfigSchema.parse({
+    runtime: "nodejs16.x",
+    handler: "index.js",
+    maxDuration: (_a = resolvedConfig.vercel) == null ? void 0 : _a.defaultMaxDuration,
+    launcherType: "Nodejs",
+    shouldAddHelpers: true
+  }), void 0, 2), "utf-8");
 }
-async function buildApiEndpoints(resolvedConfig) {
-  const entries = getApiEntries(resolvedConfig);
-  const fnManifests = {};
+async function buildEndpoints(resolvedConfig) {
+  const entries = getEntries(resolvedConfig);
   for (const entry of entries) {
-    Object.assign(fnManifests, await buildFn(resolvedConfig, entry));
+    await buildFn(resolvedConfig, entry);
   }
-  return fnManifests;
 }
 
 // src/prerender.ts
+import path4 from "path";
+
+// src/schemas/config/prerender-config.ts
+import { z as z3 } from "zod";
+var vercelOutputPrerenderConfigSchema = z3.object({
+  expiration: z3.union([z3.number().int().positive(), z3.literal(false)]),
+  group: z3.number().int().optional(),
+  bypassToken: z3.string().optional(),
+  fallback: z3.string().optional(),
+  allowQuery: z3.array(z3.string()).optional()
+}).strict();
+
+// src/prerender.ts
+import fs4 from "fs/promises";
 function execPrerender(resolvedConfig) {
   var _a;
   const prerender = (_a = resolvedConfig.vercel) == null ? void 0 : _a.prerender;
@@ -367,6 +305,51 @@ function execPrerender(resolvedConfig) {
   }
   return prerender == null ? void 0 : prerender(resolvedConfig);
 }
+var group = 1;
+async function writePrerenderConfig(resolvedConfig, destination, isr) {
+  const parsed = path4.parse(destination);
+  const outfile = path4.join(getOutput(resolvedConfig, "functions"), parsed.dir, parsed.name + ".prerender-config.json");
+  await fs4.mkdir(path4.join(getOutput(resolvedConfig, "functions"), parsed.dir), { recursive: true });
+  await fs4.writeFile(outfile, JSON.stringify(vercelOutputPrerenderConfigSchema.parse(__spreadValues({
+    group: group++
+  }, isr)), void 0, 2), "utf-8");
+}
+function getPrerenderSymlinkInfo(resolvedConfig, destination, target) {
+  const parsed = path4.parse(destination);
+  const targetParsed = path4.parse(target);
+  return {
+    target: path4.join(getOutput(resolvedConfig, "functions"), targetParsed.dir, targetParsed.name + ".func"),
+    link: path4.join(getOutput(resolvedConfig, "functions"), parsed.dir, parsed.name + ".func")
+  };
+}
+async function buildPrerenderConfigs(resolvedConfig) {
+  const isr = await getIsrConfig(resolvedConfig);
+  const entries = Object.entries(isr);
+  const rewrites = [];
+  for (const _a of entries) {
+    const [destination, _b] = _a, _c = _b, { symlink, route } = _c, isr2 = __objRest(_c, ["symlink", "route"]);
+    await writePrerenderConfig(resolvedConfig, destination, isr2);
+    if (symlink) {
+      const info = getPrerenderSymlinkInfo(resolvedConfig, destination, symlink);
+      await copyDir(info.target, info.link);
+    }
+    if (route) {
+      rewrites.push({
+        src: `(${route})`,
+        dest: `${destination}/?__original_path=$1`
+      });
+    }
+  }
+  return rewrites;
+}
+async function getIsrConfig(resolvedConfig) {
+  var _a;
+  const isr = ((_a = resolvedConfig.vercel) == null ? void 0 : _a.isr) ?? {};
+  if (typeof isr === "function") {
+    return await isr();
+  }
+  return isr;
+}
 
 // src/index.ts
 function vercelPlugin() {
@@ -374,49 +357,46 @@ function vercelPlugin() {
   return {
     apply: "build",
     name: "vite-plugin-vercel",
+    enforce: "post",
     configResolved(config) {
       resolvedConfig = config;
     },
     async buildStart() {
-      if (resolvedConfig.build.ssr)
-        return;
-      await cleanOutputDirectory(resolvedConfig);
+      if (process.env.VERCEL_ENV === "production" && !process.env.ENABLE_FILE_SYSTEM_API) {
+        throw new Error("Missing ENABLE_FILE_SYSTEM_API=1 to your environment variables in your project settings");
+      }
+      if (!resolvedConfig.build.ssr) {
+        await cleanOutputDirectory(resolvedConfig);
+      } else {
+        await copyDistClientToOutputStatic(resolvedConfig);
+      }
     },
     async writeBundle() {
       var _a;
-      if (!((_a = resolvedConfig.build) == null ? void 0 : _a.ssr)) {
-        await copyDistClientToOutputStatic(resolvedConfig);
+      if (!((_a = resolvedConfig.build) == null ? void 0 : _a.ssr))
         return;
-      }
-      const isrPages = await execPrerender(resolvedConfig);
-      const fnManifests = await buildApiEndpoints(resolvedConfig);
-      await generateFunctionsManifest(resolvedConfig, fnManifests);
-      await generateRoutesManifest(resolvedConfig, isrPages == null ? void 0 : isrPages.ssr);
-      await generatePrerenderManifest(resolvedConfig, isrPages == null ? void 0 : isrPages.isr);
+      const overrides = await execPrerender(resolvedConfig);
+      await buildEndpoints(resolvedConfig);
+      const rewrites = await buildPrerenderConfigs(resolvedConfig);
+      await writeConfig(resolvedConfig, {
+        routes: [{ handle: "filesystem" }, ...rewrites],
+        overrides
+      });
     }
   };
 }
 async function copyDistClientToOutputStatic(resolvedConfig) {
-  await copyDir(getOutDir(resolvedConfig), getOutput(resolvedConfig, "static"));
+  await copyDir(getOutDir(resolvedConfig, "client"), getOutput(resolvedConfig, "static"));
 }
 async function cleanOutputDirectory(resolvedConfig) {
-  await import_promises3.default.rm(getOutput(resolvedConfig), {
+  await fs5.rm(getOutput(resolvedConfig), {
     recursive: true,
     force: true
   });
 }
-async function generatePrerenderManifest(resolvedConfig, isrPages) {
-  await import_promises3.default.writeFile(getPrerenderManifestDestination(resolvedConfig), JSON.stringify(getPrerenderManifest(resolvedConfig, isrPages), void 0, 2));
-}
-async function generateRoutesManifest(resolvedConfig, ssr) {
-  await import_promises3.default.writeFile(getRoutesManifestDestination(resolvedConfig), JSON.stringify(getRoutesManifest(resolvedConfig, ssr), void 0, 2));
-}
-async function generateFunctionsManifest(resolvedConfig, fnManifests) {
-  await import_promises3.default.writeFile(getFunctionsManifestDestination(resolvedConfig), JSON.stringify(getFunctionsManifest(fnManifests), void 0, 2));
-}
 function allPlugins() {
   return [vercelPlugin()];
 }
-module.exports = __toCommonJS(src_exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+export {
+  allPlugins as default
+};