vite-plugin-vercel 8.0.0 → 9.0.0

package/dist/index.cjs

@@ -34,207 +34,18 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_promises5 = __toESM(require("fs/promises"), 1);
-
-// src/utils.ts
-var import_vite = require("vite");
-var import_path = __toESM(require("path"), 1);
-function getRoot(config) {
-  return (0, import_vite.normalizePath)(config.root || process.cwd());
-}
-function getOutput(config, suffix) {
-  return import_path.default.join(
-    config.vercel?.outDir ? "" : getRoot(config),
-    config.vercel?.outDir ?? ".vercel/output",
-    suffix ?? ""
-  );
-}
-function getPublic(config) {
-  return import_path.default.join(getRoot(config), config.publicDir || "public");
-}
-function pathRelativeTo(filePath, config, rel) {
-  const root = getRoot(config);
-  return (0, import_vite.normalizePath)(
-    import_path.default.relative((0, import_vite.normalizePath)(import_path.default.join(root, rel)), filePath)
-  );
-}
-
-// src/config.ts
-var import_path2 = __toESM(require("path"), 1);
-
-// src/schemas/config/config.ts
-var import_zod = require("zod");
-var HasOrMissing = import_zod.z.array(
-  import_zod.z.union([
-    import_zod.z.object({
-      type: import_zod.z.literal("host"),
-      value: import_zod.z.string()
-    }).strict(),
-    import_zod.z.object({
-      type: import_zod.z.literal("header"),
-      key: import_zod.z.string(),
-      value: import_zod.z.string().optional()
-    }).strict(),
-    import_zod.z.object({
-      type: import_zod.z.literal("cookie"),
-      key: import_zod.z.string(),
-      value: import_zod.z.string().optional()
-    }).strict(),
-    import_zod.z.object({
-      type: import_zod.z.literal("query"),
-      key: import_zod.z.string(),
-      value: import_zod.z.string().optional()
-    }).strict()
-  ])
-).optional();
-var vercelOutputConfigSchema = import_zod.z.object({
-  version: import_zod.z.literal(3),
-  routes: import_zod.z.array(
-    import_zod.z.union([
-      import_zod.z.object({
-        src: import_zod.z.string(),
-        dest: import_zod.z.string().optional(),
-        headers: import_zod.z.record(import_zod.z.string()).optional(),
-        methods: import_zod.z.array(import_zod.z.string()).optional(),
-        status: import_zod.z.number().int().positive().optional(),
-        continue: import_zod.z.boolean().optional(),
-        check: import_zod.z.boolean().optional(),
-        missing: HasOrMissing,
-        has: HasOrMissing,
-        locale: import_zod.z.object({
-          redirect: import_zod.z.record(import_zod.z.string()).optional(),
-          cookie: import_zod.z.string().optional()
-        }).strict().optional(),
-        middlewarePath: import_zod.z.string().optional()
-      }).strict(),
-      import_zod.z.object({
-        handle: import_zod.z.union([
-          import_zod.z.literal("rewrite"),
-          import_zod.z.literal("filesystem"),
-          import_zod.z.literal("resource"),
-          import_zod.z.literal("miss"),
-          import_zod.z.literal("hit"),
-          import_zod.z.literal("error")
-        ]),
-        src: import_zod.z.string().optional(),
-        dest: import_zod.z.string().optional(),
-        status: import_zod.z.number().optional()
-      }).strict()
-    ])
-  ).optional(),
-  images: import_zod.z.object({
-    sizes: import_zod.z.tuple([
-      import_zod.z.number().int().positive(),
-      import_zod.z.number().int().positive()
-    ]),
-    domains: import_zod.z.array(import_zod.z.string()).nonempty().optional(),
-    minimumCacheTTL: import_zod.z.number().int().positive().optional(),
-    formats: import_zod.z.union([import_zod.z.literal("image/avif"), import_zod.z.literal("image/webp")]).array().nonempty().optional(),
-    dangerouslyAllowSVG: import_zod.z.boolean().optional(),
-    contentSecurityPolicy: import_zod.z.string().optional()
-  }).strict().optional(),
-  wildcard: import_zod.z.array(
-    import_zod.z.object({
-      domain: import_zod.z.string(),
-      value: import_zod.z.string()
-    }).strict()
-  ).optional(),
-  overrides: import_zod.z.record(
-    import_zod.z.object({
-      path: import_zod.z.string().optional(),
-      contentType: import_zod.z.string().optional()
-    }).strict()
-  ).optional(),
-  cache: import_zod.z.array(import_zod.z.string()).optional()
-}).strict();
-
-// src/config.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_routing_utils = require("@vercel/routing-utils");
-function reorderEnforce(arr) {
-  return [
-    ...arr.filter((r) => r.enforce === "pre"),
-    ...arr.filter((r) => !r.enforce),
-    ...arr.filter((r) => r.enforce === "post")
-  ];
-}
-function getConfig(resolvedConfig, rewrites, overrides, headers) {
-  const _rewrites = [
-    // User provided config always comes first
-    ...resolvedConfig.vercel?.rewrites ?? [],
-    ...rewrites ?? []
-  ];
-  const { routes, error } = (0, import_routing_utils.getTransformedRoutes)({
-    cleanUrls: resolvedConfig.vercel?.cleanUrls ?? true,
-    trailingSlash: resolvedConfig.vercel?.trailingSlash,
-    rewrites: reorderEnforce(_rewrites),
-    redirects: resolvedConfig.vercel?.redirects ? reorderEnforce(resolvedConfig.vercel?.redirects) : void 0,
-    headers
-  });
-  if (error) {
-    throw error;
-  }
-  if (resolvedConfig.vercel?.config?.routes && resolvedConfig.vercel.config.routes.length > 0 && !resolvedConfig.vercel.config.routes.every(
-    (r) => "continue" in r && r.continue
-  )) {
-    console.warn(
-      'Did you forget to add `"continue": true` to your routes? See https://vercel.com/docs/build-output-api/v3/configuration#source-route\nIf not, it is discouraged to use `vercel.config.routes` to override routes. Prefer using `vercel.rewrites` and `vercel.redirects`.'
-    );
-  }
-  let userRoutes = [];
-  let buildRoutes = [];
-  if (resolvedConfig.vercel?.config?.routes) {
-    const norm = (0, import_routing_utils.normalizeRoutes)(resolvedConfig.vercel.config.routes);
-    if (norm.error) {
-      throw norm.error;
-    }
-    userRoutes = norm.routes ?? [];
-  }
-  if (routes) {
-    const norm = (0, import_routing_utils.normalizeRoutes)(routes);
-    if (norm.error) {
-      throw norm.error;
-    }
-    buildRoutes = norm.routes ?? [];
-  }
-  const cleanRoutes = (0, import_routing_utils.mergeRoutes)({
-    userRoutes,
-    builds: [
-      {
-        use: "@vercel/node",
-        entrypoint: "index.js",
-        routes: buildRoutes
-      }
-    ]
-  });
-  return vercelOutputConfigSchema.parse({
-    version: 3,
-    ...resolvedConfig.vercel?.config,
-    routes: cleanRoutes,
-    overrides: {
-      ...resolvedConfig.vercel?.config?.overrides,
-      ...overrides
-    }
-  });
-}
-function getConfigDestination(resolvedConfig) {
-  return import_path2.default.join(getOutput(resolvedConfig), "config.json");
-}
-async function writeConfig(resolvedConfig, rewrites, overrides, headers) {
-  await import_promises.default.writeFile(
-    getConfigDestination(resolvedConfig),
-    JSON.stringify(
-      getConfig(resolvedConfig, rewrites, overrides, headers),
-      void 0,
-      2
-    ),
-    "utf-8"
-  );
-}
+var import_node_path6 = __toESM(require("path"), 1);
 
 // src/build.ts
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_path3 = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_module = require("module");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_find_root = require("@manypkg/find-root");
+var import_build_utils = require("@vercel/build-utils");
+var import_nft = require("@vercel/nft");
 var import_esbuild = require("esbuild");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_magicast = require("magicast");
 
 // src/assert.ts
 var import_libassert = require("@brillout/libassert");
@@ -248,83 +59,111 @@ function assert(condition, errorMessage) {
 }
 
 // src/schemas/config/vc-config.ts
-var import_zod2 = require("zod");
-var vercelOutputEdgeVcConfigSchema = import_zod2.z.object({
-  runtime: import_zod2.z.literal("edge"),
-  entrypoint: import_zod2.z.string(),
-  envVarsInUse: import_zod2.z.array(import_zod2.z.string()).optional()
+var import_zod = require("zod");
+var vercelOutputEdgeVcConfigSchema = import_zod.z.object({
+  runtime: import_zod.z.literal("edge"),
+  entrypoint: import_zod.z.string(),
+  envVarsInUse: import_zod.z.array(import_zod.z.string()).optional()
 }).strict();
-var vercelOutputServerlessVcConfigSchema = import_zod2.z.object({
-  runtime: import_zod2.z.string(),
-  handler: import_zod2.z.string(),
-  memory: import_zod2.z.number().int().min(128).max(3008).optional(),
-  maxDuration: import_zod2.z.number().int().positive().optional(),
-  environment: import_zod2.z.record(import_zod2.z.string()).optional(),
-  regions: import_zod2.z.array(import_zod2.z.string()).optional(),
-  supportsWrapper: import_zod2.z.boolean().optional(),
-  supportsResponseStreaming: import_zod2.z.boolean().optional()
+var vercelOutputServerlessVcConfigSchema = import_zod.z.object({
+  runtime: import_zod.z.string(),
+  handler: import_zod.z.string(),
+  memory: import_zod.z.number().int().min(128).max(3008).optional(),
+  maxDuration: import_zod.z.number().int().positive().optional(),
+  environment: import_zod.z.record(import_zod.z.string()).optional(),
+  regions: import_zod.z.array(import_zod.z.string()).optional(),
+  supportsWrapper: import_zod.z.boolean().optional(),
+  supportsResponseStreaming: import_zod.z.boolean().optional()
 }).strict();
 var vercelOutputServerlessNodeVcConfigSchema = vercelOutputServerlessVcConfigSchema.extend({
-  launcherType: import_zod2.z.literal("Nodejs"),
-  shouldAddHelpers: import_zod2.z.boolean().optional(),
-  shouldAddSourcemapSupport: import_zod2.z.boolean().optional(),
-  awsLambdaHandler: import_zod2.z.string().optional()
+  launcherType: import_zod.z.literal("Nodejs"),
+  shouldAddHelpers: import_zod.z.boolean().optional(),
+  shouldAddSourcemapSupport: import_zod.z.boolean().optional(),
+  awsLambdaHandler: import_zod.z.string().optional()
 }).strict();
-var vercelOutputVcConfigSchema = import_zod2.z.union([
+var vercelOutputVcConfigSchema = import_zod.z.union([
   vercelOutputEdgeVcConfigSchema,
   vercelOutputServerlessVcConfigSchema,
   vercelOutputServerlessNodeVcConfigSchema
 ]);
 
-// src/build.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-
 // src/schemas/exports.ts
-var import_zod3 = require("zod");
-var vercelEndpointExports = import_zod3.z.object({
-  edge: import_zod3.z.boolean().optional(),
-  headers: import_zod3.z.record(import_zod3.z.string()).optional(),
-  streaming: import_zod3.z.boolean().optional(),
-  isr: import_zod3.z.object({
-    expiration: import_zod3.z.number().or(import_zod3.z.literal(false))
+var import_zod2 = require("zod");
+var vercelEndpointExports = import_zod2.z.object({
+  edge: import_zod2.z.boolean().optional(),
+  headers: import_zod2.z.record(import_zod2.z.string()).optional(),
+  streaming: import_zod2.z.boolean().optional(),
+  isr: import_zod2.z.object({
+    expiration: import_zod2.z.number().or(import_zod2.z.literal(false))
   }).optional()
 });
 
+// src/utils.ts
+var import_vite = require("vite");
+var import_node_path = __toESM(require("path"), 1);
+function getRoot(config) {
+  return (0, import_vite.normalizePath)(config.root || process.cwd());
+}
+function getOutput(config, suffix) {
+  return import_node_path.default.join(
+    config.vercel?.outDir ? "" : getRoot(config),
+    config.vercel?.outDir ?? ".vercel/output",
+    suffix ?? ""
+  );
+}
+function getPublic(config) {
+  return import_node_path.default.join(getRoot(config), config.publicDir || "public");
+}
+function pathRelativeTo(filePath, config, rel) {
+  const root = getRoot(config);
+  return (0, import_vite.normalizePath)(import_node_path.default.relative((0, import_vite.normalizePath)(import_node_path.default.join(root, rel)), filePath));
+}
+
 // src/build.ts
-var import_magicast = require("magicast");
-var import_build_utils = require("@vercel/build-utils");
-var import_nft = require("@vercel/nft");
-var import_find_root = require("@manypkg/find-root");
-function getAdditionalEndpoints(resolvedConfig) {
-  return (resolvedConfig.vercel?.additionalEndpoints ?? []).map((e) => ({
+async function getAdditionalEndpoints(resolvedConfig) {
+  const userEndpoints = [];
+  if (Array.isArray(resolvedConfig.vercel?.additionalEndpoints)) {
+    for (const endpoint of resolvedConfig.vercel.additionalEndpoints) {
+      if (typeof endpoint === "function") {
+        const res = await endpoint();
+        if (Array.isArray(res)) {
+          userEndpoints.push(...res);
+        } else {
+          userEndpoints.push(res);
+        }
+      } else {
+        userEndpoints.push(endpoint);
+      }
+    }
+  }
+  return userEndpoints.map((e) => ({
     ...e,
-    addRoute: e.addRoute ?? true,
+    route: e.route ?? true,
     // path.resolve removes the trailing slash if any
-    destination: import_path3.default.posix.resolve("/", e.destination) + ".func"
+    destination: `${import_node_path2.default.posix.resolve("/", e.destination)}.func`
   }));
 }
-function getEntries(resolvedConfig) {
-  const apiEntries = import_fast_glob.default.sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !import_path3.default.basename(filepath).startsWith("_"));
+async function getEntries(resolvedConfig) {
+  const apiEntries = import_fast_glob.default.sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !import_node_path2.default.basename(filepath).startsWith("_"));
   if (apiEntries.length > 0) {
     console.warn(
       "@vercel/build is currently force building /api files itself, with no way to disable it. In order to avoid double compilation, you should temporarily rename /api to /_api while using this plugin. /_api functions are compiled under .vercel/output/functions/api/*.func as if they were in /api."
     );
   }
-  const otherApiEntries = import_fast_glob.default.sync(`${getRoot(resolvedConfig)}/_api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !import_path3.default.basename(filepath).startsWith("_"));
-  return [...apiEntries, ...otherApiEntries].reduce((entryPoints, filePath) => {
-    const outFilePath = pathRelativeTo(
-      filePath,
-      resolvedConfig,
-      filePath.includes("/_api/") ? "_api" : "api"
-    );
-    const parsed = import_path3.default.posix.parse(outFilePath);
-    entryPoints.push({
-      source: filePath,
-      destination: `api/${import_path3.default.posix.join(parsed.dir, parsed.name)}.func`,
-      addRoute: true
-    });
-    return entryPoints;
-  }, getAdditionalEndpoints(resolvedConfig));
+  const otherApiEntries = import_fast_glob.default.sync(`${getRoot(resolvedConfig)}/_api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !import_node_path2.default.basename(filepath).startsWith("_"));
+  return [...apiEntries, ...otherApiEntries].reduce(
+    (entryPoints, filePath) => {
+      const outFilePath = pathRelativeTo(filePath, resolvedConfig, filePath.includes("/_api/") ? "_api" : "api");
+      const parsed = import_node_path2.default.posix.parse(outFilePath);
+      entryPoints.push({
+        source: filePath,
+        destination: `api/${import_node_path2.default.posix.join(parsed.dir, parsed.name)}.func`,
+        route: true
+      });
+      return entryPoints;
+    },
+    await getAdditionalEndpoints(resolvedConfig)
+  );
 }
 var edgeWasmPlugin = {
   name: "edge-wasm-vercel",
@@ -379,35 +218,21 @@ async function buildFn(resolvedConfig, entry, buildOptions) {
     Object.assign(options, buildOptions);
   }
   const filename = entry.edge || options.format === "cjs" ? "index.js" : "index.mjs";
-  const outfile = import_path3.default.join(
-    getOutput(resolvedConfig, "functions"),
-    entry.destination,
-    filename
-  );
+  const outfile = import_node_path2.default.join(getOutput(resolvedConfig, "functions"), entry.destination, filename);
   Object.assign(options, { outfile });
   if (!options.stdin) {
     if (typeof entry.source === "string") {
       options.entryPoints = [entry.source];
     } else {
-      assert(
-        typeof entry.source === "object",
-        `\`{ source }\` must be a string or an object`
-      );
-      assert(
-        typeof entry.source.contents === "string",
-        `\`{ contents }\` must be a string`
-      );
+      assert(typeof entry.source === "object", "`{ source }` must be a string or an object");
+      assert(typeof entry.source.contents === "string", "`{ contents }` must be a string");
       options.stdin = entry.source;
     }
   }
   if (entry.edge) {
-    options.conditions = [
-      "edge-light",
-      "browser",
-      "module",
-      "import",
-      "require"
-    ];
+    options.platform = void 0;
+    options.external = [...import_node_module.builtinModules, ...import_node_module.builtinModules.map((m) => `node:${m}`)];
+    options.conditions = ["edge-light", "worker", "browser", "module", "import", "require"];
     options.plugins?.push(edgeWasmPlugin);
     options.format = "esm";
   } else if (options.format === "esm") {
@@ -422,9 +247,9 @@ const __dirname = VPV_dirname(__filename);
     };
   }
   const ctx = { found: false, index: "" };
-  options.plugins.push(vercelOgPlugin(ctx));
+  options.plugins?.push(vercelOgPlugin(ctx));
   const output = await (0, import_esbuild.build)(options);
-  if (typeof entry.source == "string") {
+  if (typeof entry.source === "string") {
     let base = resolvedConfig.root;
     try {
       const dir = await (0, import_find_root.findRoot)(resolvedConfig.root);
@@ -451,18 +276,14 @@ const __dirname = VPV_dirname(__filename);
           });
           return result.outputFiles[0].text;
         }
-        return import_promises2.default.readFile(filepath, "utf-8");
+        return import_promises.default.readFile(filepath, "utf-8");
       }
     });
     for (const file of fileList) {
-      if (reasons.has(file) && reasons.get(file).type.includes("asset") && !file.endsWith(".js") && !file.endsWith(".cjs") && !file.endsWith(".mjs") && !file.endsWith("package.json")) {
-        await (0, import_promises2.copyFile)(
-          import_path3.default.join(base, file),
-          import_path3.default.join(
-            getOutput(resolvedConfig, "functions"),
-            entry.destination,
-            (0, import_path3.basename)(file)
-          )
+      if (reasons.has(file) && reasons.get(file)?.type.includes("asset") && !file.endsWith(".js") && !file.endsWith(".cjs") && !file.endsWith(".mjs") && !file.endsWith("package.json")) {
+        await (0, import_promises.copyFile)(
+          import_node_path2.default.join(base, file),
+          import_node_path2.default.join(getOutput(resolvedConfig, "functions"), entry.destination, (0, import_node_path2.basename)(file))
         );
       }
     }
@@ -474,13 +295,9 @@ const __dirname = VPV_dirname(__filename);
   return output;
 }
 async function writeVcConfig(resolvedConfig, destination, filename, options) {
-  const vcConfig = import_path3.default.join(
-    getOutput(resolvedConfig, "functions"),
-    destination,
-    ".vc-config.json"
-  );
+  const vcConfig = import_node_path2.default.join(getOutput(resolvedConfig, "functions"), destination, ".vc-config.json");
   const nodeVersion = await (0, import_build_utils.getNodeVersion)(getOutput(resolvedConfig));
-  await import_promises2.default.writeFile(
+  await import_promises.default.writeFile(
     vcConfig,
     JSON.stringify(
       vercelOutputVcConfigSchema.parse(
@@ -504,9 +321,9 @@ async function writeVcConfig(resolvedConfig, destination, filename, options) {
 }
 function getSourceAndDestination(destination) {
   if (destination.startsWith("api/")) {
-    return import_path3.default.posix.resolve("/", destination);
+    return import_node_path2.default.posix.resolve("/", destination);
   }
-  return import_path3.default.posix.resolve("/", destination, ":match*");
+  return import_node_path2.default.posix.resolve("/", destination, ":match*");
 }
 var RE_BRACKETS = /^\[([^/]+)\]$/gm;
 function replaceBrackets(source) {
@@ -539,7 +356,7 @@ async function extractExports(filepath) {
   }
 }
 async function buildEndpoints(resolvedConfig) {
-  const entries = getEntries(resolvedConfig);
+  const entries = await getEntries(resolvedConfig);
   for (const entry of entries) {
     if (typeof entry.source === "string") {
       const exports2 = await extractExports(entry.source);
@@ -563,6 +380,9 @@ async function buildEndpoints(resolvedConfig) {
             `isr configuration should be defined either in the endpoint itself or through Vite config, not both ('${entry.source}')`
           );
         }
+        if ((entry.isr !== void 0 || exports2.isr !== void 0) && (entry.edge !== void 0 || exports2.edge !== void 0)) {
+          throw new Error(`isr cannot be enabled for edge functions ('${entry.source}')`);
+        }
         if (exports2.isr) {
           entry.isr = exports2.isr;
         }
@@ -573,21 +393,36 @@ async function buildEndpoints(resolvedConfig) {
     }
     await buildFn(resolvedConfig, entry);
   }
-  const isrEntries = entries.filter((e) => e.isr).map(
-    (e) => [
-      e.destination.replace(/\.func$/, ""),
-      { expiration: e.isr.expiration }
-    ]
-  );
+  const isrEntries = entries.filter((e) => e.isr).map((e) => [e.destination.replace(/\.func$/, ""), { expiration: e.isr?.expiration }]);
   return {
-    rewrites: entries.filter((e) => e.addRoute !== false).map((e) => e.destination.replace(/\.func$/, "")).map((destination) => ({
-      source: replaceBrackets(getSourceAndDestination(destination)),
-      destination: getSourceAndDestination(destination)
-    })),
+    rewrites: entries.filter((e) => {
+      if (e.addRoute === void 0 && e.route !== void 0) {
+        return e.route !== false;
+      }
+      if (e.addRoute !== void 0 && e.route === void 0) {
+        return e.addRoute !== false;
+      }
+      if (e.addRoute !== void 0 && e.route !== void 0) {
+        throw new Error("Cannot use both `route` and `addRoute` in `additionalEndpoints`");
+      }
+      return true;
+    }).map((e) => {
+      const destination = e.destination.replace(/\.func$/, "");
+      if (typeof e.route === "string") {
+        return {
+          source: `(${e.route})`,
+          destination: `${destination}/?__original_path=$1`
+        };
+      }
+      return {
+        source: replaceBrackets(getSourceAndDestination(destination)),
+        destination: getSourceAndDestination(destination)
+      };
+    }),
     isr: Object.fromEntries(isrEntries),
     headers: entries.filter((e) => e.headers).map((e) => ({
-      source: "/" + e.destination.replace(/\.func$/, ""),
-      headers: Object.entries(e.headers).map(([key, value]) => ({
+      source: `/${e.destination.replace(/\.func$/, "")}`,
+      headers: Object.entries(e.headers ?? {}).map(([key, value]) => ({
         key,
         value
       }))
@@ -595,36 +430,198 @@ async function buildEndpoints(resolvedConfig) {
   };
 }
 
-// src/prerender.ts
-var import_path5 = __toESM(require("path"), 1);
+// src/config.ts
+var import_node_path3 = __toESM(require("path"), 1);
 
-// src/schemas/config/prerender-config.ts
-var import_zod4 = require("zod");
-var vercelOutputPrerenderConfigSchema = import_zod4.z.object({
-  expiration: import_zod4.z.union([import_zod4.z.number().int().positive(), import_zod4.z.literal(false)]),
-  group: import_zod4.z.number().int().optional(),
-  bypassToken: import_zod4.z.string().optional(),
-  fallback: import_zod4.z.string().optional(),
-  allowQuery: import_zod4.z.array(import_zod4.z.string()).optional()
+// src/schemas/config/config.ts
+var import_zod3 = require("zod");
+var HasOrMissing = import_zod3.z.array(
+  import_zod3.z.union([
+    import_zod3.z.object({
+      type: import_zod3.z.literal("host"),
+      value: import_zod3.z.string()
+    }).strict(),
+    import_zod3.z.object({
+      type: import_zod3.z.literal("header"),
+      key: import_zod3.z.string(),
+      value: import_zod3.z.string().optional()
+    }).strict(),
+    import_zod3.z.object({
+      type: import_zod3.z.literal("cookie"),
+      key: import_zod3.z.string(),
+      value: import_zod3.z.string().optional()
+    }).strict(),
+    import_zod3.z.object({
+      type: import_zod3.z.literal("query"),
+      key: import_zod3.z.string(),
+      value: import_zod3.z.string().optional()
+    }).strict()
+  ])
+).optional();
+var vercelOutputConfigSchema = import_zod3.z.object({
+  version: import_zod3.z.literal(3),
+  routes: import_zod3.z.array(
+    import_zod3.z.union([
+      import_zod3.z.object({
+        src: import_zod3.z.string(),
+        dest: import_zod3.z.string().optional(),
+        headers: import_zod3.z.record(import_zod3.z.string()).optional(),
+        methods: import_zod3.z.array(import_zod3.z.string()).optional(),
+        status: import_zod3.z.number().int().positive().optional(),
+        continue: import_zod3.z.boolean().optional(),
+        check: import_zod3.z.boolean().optional(),
+        missing: HasOrMissing,
+        has: HasOrMissing,
+        locale: import_zod3.z.object({
+          redirect: import_zod3.z.record(import_zod3.z.string()).optional(),
+          cookie: import_zod3.z.string().optional()
+        }).strict().optional(),
+        middlewarePath: import_zod3.z.string().optional()
+      }).strict(),
+      import_zod3.z.object({
+        handle: import_zod3.z.union([
+          import_zod3.z.literal("rewrite"),
+          import_zod3.z.literal("filesystem"),
+          import_zod3.z.literal("resource"),
+          import_zod3.z.literal("miss"),
+          import_zod3.z.literal("hit"),
+          import_zod3.z.literal("error")
+        ]),
+        src: import_zod3.z.string().optional(),
+        dest: import_zod3.z.string().optional(),
+        status: import_zod3.z.number().optional()
+      }).strict()
+    ])
+  ).optional(),
+  images: import_zod3.z.object({
+    sizes: import_zod3.z.tuple([import_zod3.z.number().int().positive(), import_zod3.z.number().int().positive()]),
+    domains: import_zod3.z.array(import_zod3.z.string()).nonempty().optional(),
+    minimumCacheTTL: import_zod3.z.number().int().positive().optional(),
+    formats: import_zod3.z.union([import_zod3.z.literal("image/avif"), import_zod3.z.literal("image/webp")]).array().nonempty().optional(),
+    dangerouslyAllowSVG: import_zod3.z.boolean().optional(),
+    contentSecurityPolicy: import_zod3.z.string().optional()
+  }).strict().optional(),
+  wildcard: import_zod3.z.array(
+    import_zod3.z.object({
+      domain: import_zod3.z.string(),
+      value: import_zod3.z.string()
+    }).strict()
+  ).optional(),
+  overrides: import_zod3.z.record(
+    import_zod3.z.object({
+      path: import_zod3.z.string().optional(),
+      contentType: import_zod3.z.string().optional()
+    }).strict()
+  ).optional(),
+  cache: import_zod3.z.array(import_zod3.z.string()).optional()
 }).strict();
 
-// src/prerender.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
+// src/config.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_routing_utils = require("@vercel/routing-utils");
+function reorderEnforce(arr) {
+  return [
+    ...arr.filter((r) => r.enforce === "pre"),
+    ...arr.filter((r) => !r.enforce),
+    ...arr.filter((r) => r.enforce === "post")
+  ];
+}
+function getConfig(resolvedConfig, rewrites, overrides, headers) {
+  const _rewrites = [
+    // User provided config always comes first
+    ...resolvedConfig.vercel?.rewrites ?? [],
+    ...rewrites ?? []
+  ];
+  const { routes, error } = (0, import_routing_utils.getTransformedRoutes)({
+    cleanUrls: resolvedConfig.vercel?.cleanUrls ?? true,
+    trailingSlash: resolvedConfig.vercel?.trailingSlash,
+    rewrites: reorderEnforce(_rewrites),
+    redirects: resolvedConfig.vercel?.redirects ? reorderEnforce(resolvedConfig.vercel?.redirects) : void 0,
+    headers
+  });
+  if (error) {
+    throw error;
+  }
+  if (resolvedConfig.vercel?.config?.routes && resolvedConfig.vercel.config.routes.length > 0 && !resolvedConfig.vercel.config.routes.every((r) => "continue" in r && r.continue)) {
+    console.warn(
+      'Did you forget to add `"continue": true` to your routes? See https://vercel.com/docs/build-output-api/v3/configuration#source-route\nIf not, it is discouraged to use `vercel.config.routes` to override routes. Prefer using `vercel.rewrites` and `vercel.redirects`.'
+    );
+  }
+  let userRoutes = [];
+  let buildRoutes = [];
+  if (resolvedConfig.vercel?.config?.routes) {
+    const norm = (0, import_routing_utils.normalizeRoutes)(resolvedConfig.vercel.config.routes);
+    if (norm.error) {
+      throw norm.error;
+    }
+    userRoutes = norm.routes ?? [];
+  }
+  if (routes) {
+    const norm = (0, import_routing_utils.normalizeRoutes)(routes);
+    if (norm.error) {
+      throw norm.error;
+    }
+    buildRoutes = norm.routes ?? [];
+  }
+  const cleanRoutes = (0, import_routing_utils.mergeRoutes)({
+    userRoutes,
+    builds: [
+      {
+        use: "@vercel/node",
+        entrypoint: "index.js",
+        routes: buildRoutes
+      }
+    ]
+  });
+  return vercelOutputConfigSchema.parse({
+    version: 3,
+    ...resolvedConfig.vercel?.config,
+    routes: cleanRoutes,
+    overrides: {
+      ...resolvedConfig.vercel?.config?.overrides,
+      ...overrides
+    }
+  });
+}
+function getConfigDestination(resolvedConfig) {
+  return import_node_path3.default.join(getOutput(resolvedConfig), "config.json");
+}
+async function writeConfig(resolvedConfig, rewrites, overrides, headers) {
+  await import_promises2.default.writeFile(
+    getConfigDestination(resolvedConfig),
+    JSON.stringify(getConfig(resolvedConfig, rewrites, overrides, headers), void 0, 2),
+    "utf-8"
+  );
+}
 
 // src/helpers.ts
 var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_path4 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 async function copyDir(src, dest) {
   await import_promises3.default.mkdir(dest, { recursive: true });
   const entries = await import_promises3.default.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = import_path4.default.join(src, entry.name);
-    const destPath = import_path4.default.join(dest, entry.name);
+    const srcPath = import_node_path4.default.join(src, entry.name);
+    const destPath = import_node_path4.default.join(dest, entry.name);
     entry.isDirectory() ? await copyDir(srcPath, destPath) : await import_promises3.default.copyFile(srcPath, destPath);
   }
 }
 
 // src/prerender.ts
+var import_node_path5 = __toESM(require("path"), 1);
+
+// src/schemas/config/prerender-config.ts
+var import_zod4 = require("zod");
+var vercelOutputPrerenderConfigSchema = import_zod4.z.object({
+  expiration: import_zod4.z.union([import_zod4.z.number().int().positive(), import_zod4.z.literal(false)]),
+  group: import_zod4.z.number().int().optional(),
+  bypassToken: import_zod4.z.string().optional(),
+  fallback: import_zod4.z.string().optional(),
+  allowQuery: import_zod4.z.array(import_zod4.z.string()).optional()
+}).strict();
+
+// src/prerender.ts
+var import_promises4 = __toESM(require("fs/promises"), 1);
 function execPrerender(resolvedConfig) {
   const prerender = resolvedConfig.vercel?.prerender;
   if (prerender === false) {
@@ -634,16 +631,9 @@ function execPrerender(resolvedConfig) {
 }
 var group = 1;
 async function writePrerenderConfig(resolvedConfig, destination, isr) {
-  const parsed = import_path5.default.parse(destination);
-  const outfile = import_path5.default.join(
-    getOutput(resolvedConfig, "functions"),
-    parsed.dir,
-    parsed.name + ".prerender-config.json"
-  );
-  await import_promises4.default.mkdir(
-    import_path5.default.join(getOutput(resolvedConfig, "functions"), parsed.dir),
-    { recursive: true }
-  );
+  const parsed = import_node_path5.default.parse(destination);
+  const outfile = import_node_path5.default.join(getOutput(resolvedConfig, "functions"), parsed.dir, `${parsed.name}.prerender-config.json`);
+  await import_promises4.default.mkdir(import_node_path5.default.join(getOutput(resolvedConfig, "functions"), parsed.dir), { recursive: true });
   await import_promises4.default.writeFile(
     outfile,
     JSON.stringify(
@@ -658,37 +648,21 @@ async function writePrerenderConfig(resolvedConfig, destination, isr) {
   );
 }
 function getPrerenderSymlinkInfo(resolvedConfig, destination, target) {
-  const parsed = import_path5.default.parse(destination);
-  const targetParsed = import_path5.default.parse(target);
+  const parsed = import_node_path5.default.parse(destination);
+  const targetParsed = import_node_path5.default.parse(target);
   return {
-    target: import_path5.default.join(
-      getOutput(resolvedConfig, "functions"),
-      targetParsed.dir,
-      targetParsed.name + ".func"
-    ),
-    link: import_path5.default.join(
-      getOutput(resolvedConfig, "functions"),
-      parsed.dir,
-      parsed.name + ".func"
-    )
+    target: import_node_path5.default.join(getOutput(resolvedConfig, "functions"), targetParsed.dir, `${targetParsed.name}.func`),
+    link: import_node_path5.default.join(getOutput(resolvedConfig, "functions"), parsed.dir, `${parsed.name}.func`)
   };
 }
 async function buildPrerenderConfigs(resolvedConfig, extractedIsr) {
-  const isr = Object.assign(
-    {},
-    extractedIsr,
-    await getIsrConfig(resolvedConfig)
-  );
+  const isr = Object.assign({}, extractedIsr, await getIsrConfig(resolvedConfig));
   const entries = Object.entries(isr);
   const rewrites = [];
   for (const [destination, { symlink, route, ...isr2 }] of entries) {
     await writePrerenderConfig(resolvedConfig, destination, isr2);
     if (symlink) {
-      const info = getPrerenderSymlinkInfo(
-        resolvedConfig,
-        destination,
-        symlink
-      );
+      const info = getPrerenderSymlinkInfo(resolvedConfig, destination, symlink);
       await copyDir(info.target, info.link);
     }
     if (route) {
@@ -709,7 +683,6 @@ async function getIsrConfig(resolvedConfig) {
 }
 
 // src/index.ts
-var import_path6 = __toESM(require("path"), 1);
 function vercelPluginCleanup() {
   let resolvedConfig;
   return {
@@ -739,9 +712,7 @@ function vercelPlugin() {
     enforce: "post",
     configResolved(config) {
       resolvedConfig = config;
-      vikeFound = resolvedConfig.plugins.some(
-        (p) => p.name.match("^vite-plugin-ssr:|^vike:")
-      );
+      vikeFound = resolvedConfig.plugins.some((p) => p.name.match("^vite-plugin-ssr:|^vike:"));
       if (typeof resolvedConfig.vercel?.distContainsOnlyStatic === "undefined") {
         resolvedConfig.vercel ??= {};
         resolvedConfig.vercel.distContainsOnlyStatic = !vikeFound;
@@ -783,10 +754,7 @@ async function cleanOutputDirectory(resolvedConfig) {
 }
 async function copyDistToStatic(resolvedConfig) {
   if (resolvedConfig.vercel?.distContainsOnlyStatic) {
-    await copyDir(
-      resolvedConfig.build.outDir,
-      getOutput(resolvedConfig, "static")
-    );
+    await copyDir(resolvedConfig.build.outDir, getOutput(resolvedConfig, "static"));
   }
 }
 async function computeStaticHtmlOverrides(resolvedConfig) {
@@ -794,18 +762,19 @@ async function computeStaticHtmlOverrides(resolvedConfig) {
   const files = await getStaticHtmlFiles(staticAbsolutePath);
   const publicDir = getPublic(resolvedConfig);
   const publicFiles = await getStaticHtmlFiles(publicDir);
-  files.push(
-    ...publicFiles.map((f) => f.replace(publicDir, staticAbsolutePath))
+  files.push(...publicFiles.map((f) => f.replace(publicDir, staticAbsolutePath)));
+  return files.reduce(
+    (acc, curr) => {
+      const relPath = import_node_path6.default.relative(staticAbsolutePath, curr);
+      const parsed = import_node_path6.default.parse(relPath);
+      const pathJoined = import_node_path6.default.join(parsed.dir, parsed.name);
+      acc[relPath] = {
+        path: pathJoined
+      };
+      return acc;
+    },
+    {}
   );
-  return files.reduce((acc, curr) => {
-    const relPath = import_path6.default.relative(staticAbsolutePath, curr);
-    const parsed = import_path6.default.parse(relPath);
-    const pathJoined = import_path6.default.join(parsed.dir, parsed.name);
-    acc[relPath] = {
-      path: pathJoined
-    };
-    return acc;
-  }, {});
 }
 async function getStaticHtmlFiles(src) {
   try {
@@ -816,7 +785,7 @@ async function getStaticHtmlFiles(src) {
   const entries = await import_promises5.default.readdir(src, { withFileTypes: true });
   const htmlFiles = [];
   for (const entry of entries) {
-    const srcPath = import_path6.default.join(src, entry.name);
+    const srcPath = import_node_path6.default.join(src, entry.name);
     entry.isDirectory() ? htmlFiles.push(...await getStaticHtmlFiles(srcPath)) : srcPath.endsWith(".html") ? htmlFiles.push(srcPath) : void 0;
   }
   return htmlFiles;
@@ -838,9 +807,5 @@ async function tryImportVpvv(options) {
 }
 function allPlugins(options = {}) {
   const { smart, ...rest } = options;
-  return [
-    vercelPluginCleanup(),
-    vercelPlugin(),
-    smart !== false ? tryImportVpvv(rest) : null
-  ];
+  return [vercelPluginCleanup(), vercelPlugin(), smart !== false ? tryImportVpvv(rest) : null];
 }