vite-plugin-vercel 9.0.6 → 10.0.0-beta.0

package/dist/index.js

@@ -1,136 +1,104 @@
-// src/index.ts
-import fs5 from "node:fs/promises";
-import path6 from "node:path";
+import {
+  entryToPathtoregex,
+  photonEntryDestination,
+  photonEntryDestinationDefault
+} from "./chunk-OCCU6UM5.js";
+import {
+  createAPI,
+  getVercelAPI
+} from "./chunk-CR7Q2T4Q.js";
+import {
+  assert
+} from "./chunk-UTQ72LMT.js";
 
-// src/build.ts
-import fs, { copyFile } from "node:fs/promises";
-import { builtinModules } from "node:module";
-import path2, { basename } from "node:path";
+// src/plugins/index.ts
+import { installPhoton } from "@photonjs/runtime/vite";
+
+// src/plugins/api.ts
+function apiPlugin(pluginConfig) {
+  const outfiles = [];
+  return {
+    name: "vite-plugin-vercel:api",
+    api() {
+      return createAPI(outfiles, pluginConfig);
+    },
+    // Compute outfiles for the API
+    writeBundle(_opts, bundle2) {
+      if (this.environment.name !== "vercel_edge" && this.environment.name !== "vercel_node") return;
+      const entries = this.environment.config.photon.entries;
+      const server = this.environment.config.photon.server;
+      const entryMapByDestination = new Map(
+        [server, ...Object.values(entries)].map((e) => [photonEntryDestination(e, ".func/index"), e])
+      );
+      for (const entry of this.environment.config.photon.entries.filter((e) => e.type === "server-config")) {
+        entryMapByDestination.set(photonEntryDestination(entry, ".func/index"), entry);
+      }
+      for (const [key, value] of Object.entries(bundle2)) {
+        if (value.type === "chunk" && value.isEntry && entryMapByDestination.has(removeExtension(key))) {
+          outfiles.push({
+            type: "chunk",
+            root: this.environment.config.root,
+            outdir: this.environment.config.build.outDir,
+            filepath: key,
+            // biome-ignore lint/style/noNonNullAssertion: guarded by entryMap.has(...)
+            relatedEntry: entryMapByDestination.get(removeExtension(key))
+          });
+        } else if (value.type === "asset" && key.startsWith("functions/") || key === "config.json") {
+          outfiles.push({
+            type: "asset",
+            root: this.environment.config.root,
+            outdir: this.environment.config.build.outDir,
+            filepath: key
+          });
+        }
+      }
+    },
+    sharedDuringBuild: true
+  };
+}
+function removeExtension(subject) {
+  return subject.replace(/\.[^/.]+$/, "");
+}
+
+// src/plugins/bundle.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { copyFile, mkdir, rm } from "fs/promises";
+import { builtinModules } from "module";
+import path2 from "path";
 import { findRoot } from "@manypkg/find-root";
-import { getNodeVersion } from "@vercel/build-utils";
 import { nodeFileTrace } from "@vercel/nft";
 import { build } from "esbuild";
-import glob from "fast-glob";
-import { generateCode, loadFile } from "magicast";
 
-// src/assert.ts
-import { newError } from "@brillout/libassert";
-var libName = "vite-plugin-vercel";
-function assert(condition, errorMessage) {
-  if (condition) {
-    return;
+// src/helpers.ts
+import path from "path";
+function joinAbsolute(env_or_p0, p1, ...p) {
+  if (path.isAbsolute(p1)) {
+    return path.join(p1, ...p);
   }
-  const err = newError(`[${libName}][Wrong Usage] ${errorMessage}`, 2);
-  throw err;
+  return path.join(typeof env_or_p0 === "string" ? env_or_p0 : env_or_p0.config.root, p1, ...p);
+}
+function joinAbsolutePosix(env_or_p0, p1, ...p) {
+  if (path.isAbsolute(p1)) {
+    return path.posix.join(p1, ...p);
+  }
+  return path.posix.join(typeof env_or_p0 === "string" ? env_or_p0 : env_or_p0.config.root, p1, ...p);
 }
 
-// src/schemas/config/vc-config.ts
-import { z } from "zod";
-var vercelOutputEdgeVcConfigSchema = z.object({
-  runtime: z.literal("edge"),
-  entrypoint: z.string(),
-  envVarsInUse: z.array(z.string()).optional()
-}).strict();
-var vercelOutputServerlessVcConfigSchema = z.object({
-  runtime: z.string(),
-  handler: z.string(),
-  memory: z.number().int().min(128).max(3008).optional(),
-  maxDuration: z.number().int().positive().optional(),
-  environment: z.record(z.string()).optional(),
-  regions: z.array(z.string()).optional(),
-  supportsWrapper: z.boolean().optional(),
-  supportsResponseStreaming: z.boolean().optional()
-}).strict();
-var vercelOutputServerlessNodeVcConfigSchema = vercelOutputServerlessVcConfigSchema.extend({
-  launcherType: z.literal("Nodejs"),
-  shouldAddHelpers: z.boolean().optional(),
-  shouldAddSourcemapSupport: z.boolean().optional(),
-  awsLambdaHandler: z.string().optional()
-}).strict();
-var vercelOutputVcConfigSchema = z.union([
-  vercelOutputEdgeVcConfigSchema,
-  vercelOutputServerlessVcConfigSchema,
-  vercelOutputServerlessNodeVcConfigSchema
-]);
-
-// src/schemas/exports.ts
-import { z as z2 } from "zod";
-var vercelEndpointExports = z2.object({
-  edge: z2.boolean().optional(),
-  headers: z2.record(z2.string()).optional(),
-  streaming: z2.boolean().optional(),
-  isr: z2.object({
-    expiration: z2.number().or(z2.literal(false))
-  }).optional()
-});
+// src/utils/edge.ts
+var edgeConditions = ["edge-light", "worker", "browser", "module", "import", "default"];
 
-// src/utils.ts
-import { normalizePath } from "vite";
-import path from "node:path";
-function getRoot(config) {
-  return normalizePath(config.root || process.cwd());
-}
-function getOutput(config, suffix) {
-  return path.join(
-    config.vercel?.outDir ? "" : getRoot(config),
-    config.vercel?.outDir ?? ".vercel/output",
-    suffix ?? ""
-  );
-}
-function getPublic(config) {
-  return path.join(getRoot(config), config.publicDir || "public");
-}
-function pathRelativeTo(filePath, config, rel) {
-  const root = getRoot(config);
-  return normalizePath(path.relative(normalizePath(path.join(root, rel)), filePath));
+// src/utils/env.ts
+function isVercelLastBuildStep(env) {
+  const name = typeof env !== "string" ? env.name : env;
+  return name === "vercel_node";
 }
 
-// src/build.ts
-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,
-    route: e.route ?? true,
-    // path.resolve removes the trailing slash if any
-    destination: `${path2.posix.resolve("/", e.destination)}.func`
-  }));
-}
-async function getEntries(resolvedConfig) {
-  const apiEntries = glob.sync(`${getRoot(resolvedConfig)}/api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !path2.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 = glob.sync(`${getRoot(resolvedConfig)}/_api/**/*.*([a-zA-Z0-9])`).filter((filepath) => !path2.basename(filepath).startsWith("_"));
-  return [...apiEntries, ...otherApiEntries].reduce(
-    (entryPoints, filePath) => {
-      const outFilePath = pathRelativeTo(filePath, resolvedConfig, filePath.includes("/_api/") ? "_api" : "api");
-      const parsed = path2.posix.parse(outFilePath);
-      entryPoints.push({
-        source: filePath,
-        destination: `api/${path2.posix.join(parsed.dir, parsed.name)}.func`,
-        route: true
-      });
-      return entryPoints;
-    },
-    await getAdditionalEndpoints(resolvedConfig)
-  );
-}
+// src/utils/external.ts
+var _external = ["async_hooks", "events", "buffer", "assert", "util"];
+var edgeExternal = [..._external, ..._external.map((e) => `node:${e}`)];
+
+// src/plugins/bundle.ts
+var builtIns = new Set(builtinModules.flatMap((m) => [m, `node:${m}`]));
 var edgeWasmPlugin = {
   name: "edge-wasm-vercel",
   setup(build2) {
@@ -142,366 +110,411 @@ var edgeWasmPlugin = {
     });
   }
 };
-var vercelOgPlugin = (ctx) => {
-  return {
-    name: "vercel-og",
-    setup(build2) {
-      build2.onResolve({ filter: /@vercel\/og/ }, () => {
-        ctx.found = true;
-        return void 0;
-      });
-      build2.onLoad({ filter: /@vercel\/og/ }, (args) => {
-        ctx.index = args.path;
-        return void 0;
-      });
-    }
-  };
-};
-var standardBuildOptions = {
-  bundle: true,
-  target: "es2022",
-  format: "esm",
-  platform: "node",
-  logLevel: "info",
-  logOverride: {
-    "ignored-bare-import": "verbose",
-    "require-resolve-not-external": "verbose"
-  },
-  minify: false,
-  plugins: [],
-  define: {
-    "process.env.NODE_ENV": '"production"',
-    "import.meta.env.NODE_ENV": '"production"'
+var dynamicNativeImportPlugin = {
+  name: "edge-dynamic-import-native",
+  setup(build2) {
+    build2.onResolve({ filter: /.*/ }, (args) => {
+      if (args.kind === "dynamic-import" && builtIns.has(args.path)) {
+        return { path: args.path, external: true };
+      }
+    });
   }
 };
-async function buildFn(resolvedConfig, entry, buildOptions) {
-  assert(
-    entry.destination.length > 0,
-    `Endpoint ${typeof entry.source === "string" ? entry.source : "-"} does not have build destination`
-  );
-  const options = Object.assign({}, standardBuildOptions);
-  if (buildOptions) {
-    Object.assign(options, buildOptions);
+var reactEdgePlugin = {
+  name: "react-edge-plugin",
+  setup(build2) {
+    build2.onResolve({ filter: /^react-dom\/server$/ }, (args) => {
+      const { path: _, ...rest } = args;
+      return build2.resolve("react-dom/server.edge", rest);
+    });
   }
-  const filename = entry.edge || options.format === "cjs" ? "index.js" : "index.mjs";
-  const outfile = path2.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");
-      options.stdin = entry.source;
+};
+function bundlePlugin(pluginConfig) {
+  const bundledAssets = /* @__PURE__ */ new Map();
+  return [
+    {
+      name: "vite-plugin-vercel:bundle",
+      enforce: "post",
+      apply: "build",
+      generateBundle(_opts, bundle2) {
+        for (const b of Object.values(bundle2)) {
+          if (b.type === "asset") {
+            const originalFileNames = b.originalFileNames.map(
+              (relativePath) => path2.resolve(this.environment.config.root, relativePath)
+            );
+            const asset = {
+              env: this.environment.name,
+              root: this.environment.config.root,
+              outDir: this.environment.config.build.outDir,
+              outFile: joinAbsolute(this.environment, this.environment.config.build.outDir, b.fileName),
+              fileName: b.fileName
+            };
+            for (const originalFileName of originalFileNames) {
+              bundledAssets.set(originalFileName, asset);
+            }
+          }
+        }
+      },
+      closeBundle: {
+        order: "post",
+        async handler() {
+          if (!isVercelLastBuildStep(this.environment)) return;
+          this.environment.logger.info("Creating Vercel bundles...");
+          const api = getVercelAPI(this);
+          const outfiles = api.getOutFiles();
+          for (const outfile of outfiles) {
+            if (outfile.type === "asset") {
+              const { source, destination } = getAbsoluteOutFileWithout_tmp(outfile);
+              await mkdir(path2.dirname(destination), { recursive: true });
+              await copyFile(source, destination);
+            } else {
+              await bundle(this.environment, bundledAssets, outfile);
+            }
+          }
+          const tmpDir = pluginConfig.outDir ? path2.posix.join(pluginConfig.outDir, "_tmp") : ".vercel/output/_tmp";
+          await rm(tmpDir, { recursive: true });
+        }
+      },
+      sharedDuringBuild: true
     }
-  }
-  if (entry.edge) {
-    options.platform = void 0;
-    options.external = [...builtinModules, ...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") {
-    options.banner = {
-      js: `import { createRequire as VPV_createRequire } from "node:module";
-import { fileURLToPath as VPV_fileURLToPath } from "node:url";
-import { dirname as VPV_dirname } from "node:path";
-const require = VPV_createRequire(import.meta.url);
-const __filename = VPV_fileURLToPath(import.meta.url);
-const __dirname = VPV_dirname(__filename);
+  ];
+}
+function getAbsoluteOutFileWithout_tmp(outfile) {
+  const source = joinAbsolutePosix(outfile.root, outfile.outdir, outfile.filepath);
+  const destination = source.replace(outfile.outdir, outfile.outdir.replace(/_tmp(\/|\\|$)/, ""));
+  return {
+    source,
+    destination
+  };
+}
+async function bundle(environment, bundledAssets, outfile) {
+  const { source, destination } = getAbsoluteOutFileWithout_tmp(outfile);
+  const isEdge = Boolean(outfile.relatedEntry.vercel?.edge);
+  const buildOptions = {
+    format: "esm",
+    target: "es2022",
+    legalComments: "none",
+    bundle: true,
+    entryPoints: [source],
+    treeShaking: true,
+    logOverride: { "ignored-bare-import": "silent" }
+  };
+  if (isEdge) {
+    buildOptions.platform = "browser";
+    buildOptions.external = edgeExternal;
+    buildOptions.conditions = edgeConditions;
+    buildOptions.define = {
+      "process.env.NODE_ENV": JSON.stringify("production")
+    };
+    buildOptions.outExtension = { ".js": ".mjs" };
+    buildOptions.outfile = destination.replace(/\.mjs$/, ".js");
+    buildOptions.plugins = [edgeWasmPlugin, dynamicNativeImportPlugin, reactEdgePlugin];
+  } else {
+    buildOptions.platform = "node";
+    buildOptions.outfile = destination.replace(/\.js$/, ".mjs");
+    buildOptions.banner = {
+      js: `import { createRequire as topLevelCreateRequire } from 'module';
+import { dirname as topLevelDirname } from 'path';
+import { fileURLToPath as topLevelFileURLToPath } from 'url';
+const require = topLevelCreateRequire(import.meta.url);
+const __filename = topLevelFileURLToPath(import.meta.url);
+const __dirname = topLevelDirname(__filename);
 `
     };
   }
-  const ctx = { found: false, index: "" };
-  options.plugins?.push(vercelOgPlugin(ctx));
-  const output = await build(options);
-  if (typeof entry.source === "string") {
-    let base = resolvedConfig.root;
-    try {
-      const dir = await findRoot(resolvedConfig.root);
-      base = dir.rootDir;
-    } catch (e) {
-    }
-    const { fileList, reasons } = await nodeFileTrace([entry.source], {
-      base,
-      processCwd: resolvedConfig.root,
-      mixedModules: true,
-      ignore: [
-        "**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js",
-        "**/*.d.ts",
-        "**/*.map",
-        "**/node_modules/webpack5/**/*"
-      ],
-      async readFile(filepath) {
-        if (filepath.endsWith(".ts") || filepath.endsWith(".tsx")) {
-          const result = await build({
-            ...standardBuildOptions,
-            entryPoints: [entry.source],
-            bundle: false,
-            write: false
-          });
-          return result.outputFiles[0].text;
-        }
-        return fs.readFile(filepath, "utf-8");
+  try {
+    await build(buildOptions);
+  } catch (e) {
+    throw new Error(`Error while bundling ${destination}`, { cause: e });
+  }
+  let base = environment.config.root;
+  try {
+    const dir = await findRoot(environment.config.root);
+    base = dir.rootDir;
+  } catch (_e) {
+  }
+  const entryFilePath = existsSync(outfile.relatedEntry.id) ? outfile.relatedEntry.id : outfile.relatedEntry.resolvedId && existsSync(outfile.relatedEntry.resolvedId) ? outfile.relatedEntry.resolvedId : null;
+  if (entryFilePath === null) {
+    return;
+  }
+  const { fileList, reasons } = await nodeFileTrace([entryFilePath], {
+    base,
+    processCwd: environment.config.root,
+    mixedModules: true,
+    // https://github.com/vercel/next.js/blob/7c8e2b4e50449ce2d2c83de0b5638c61b7de2362/packages/next/src/build/collect-build-traces.ts#L201
+    ignore: [
+      "**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js",
+      "**/*.d.ts",
+      "**/*.map",
+      "**/node_modules/webpack5/**/*"
+    ],
+    async readFile(filepath) {
+      if (filepath.endsWith(".ts") || filepath.endsWith(".tsx")) {
+        const result = await build({
+          target: "es2022",
+          format: "esm",
+          platform: "node",
+          logLevel: "info",
+          logOverride: {
+            "ignored-bare-import": "verbose",
+            "require-resolve-not-external": "verbose"
+          },
+          minify: false,
+          plugins: [],
+          define: {
+            "process.env.NODE_ENV": '"production"',
+            "import.meta.env.NODE_ENV": '"production"'
+          },
+          entryPoints: [entryFilePath],
+          bundle: false,
+          write: false
+        });
+        return result.outputFiles[0].text;
       }
-    });
-    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 copyFile(
-          path2.join(base, file),
-          path2.join(getOutput(resolvedConfig, "functions"), entry.destination, basename(file))
+      return readFileSync(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")) {
+      const absolutePath = path2.join(base, file);
+      const assetRenamedByVite = bundledAssets.get(absolutePath);
+      const basename = path2.basename(assetRenamedByVite ? assetRenamedByVite.fileName : absolutePath);
+      if (assetRenamedByVite) {
+        writeFileSync(
+          destination,
+          readFileSync(destination, "utf-8").replaceAll(
+            `/${assetRenamedByVite.fileName}`,
+            `./${path2.basename(assetRenamedByVite.fileName)}`
+          )
         );
       }
+      await copyFile(absolutePath, path2.join(path2.dirname(destination), basename));
     }
   }
-  await writeVcConfig(resolvedConfig, entry.destination, filename, {
-    edge: Boolean(entry.edge),
-    streaming: entry.streaming
-  });
-  return output;
 }
-async function writeVcConfig(resolvedConfig, destination, filename, options) {
-  const vcConfig = path2.join(getOutput(resolvedConfig, "functions"), destination, ".vc-config.json");
-  const nodeVersion = await getNodeVersion(getOutput(resolvedConfig));
-  await fs.writeFile(
-    vcConfig,
-    JSON.stringify(
-      vercelOutputVcConfigSchema.parse(
-        options.edge ? {
-          runtime: "edge",
-          entrypoint: filename
-        } : {
-          runtime: nodeVersion.runtime,
-          handler: filename,
-          maxDuration: resolvedConfig.vercel?.defaultMaxDuration,
-          launcherType: "Nodejs",
-          shouldAddHelpers: true,
-          supportsResponseStreaming: options.streaming ?? resolvedConfig.vercel?.defaultSupportsResponseStreaming
-        }
-      ),
-      void 0,
-      2
-    ),
-    "utf-8"
-  );
-}
-function getSourceAndDestination(destination) {
-  if (destination.startsWith("api/")) {
-    return path2.posix.resolve("/", destination);
-  }
-  return path2.posix.resolve("/", destination, ":match*");
-}
-var RE_BRACKETS = /^\[([^/]+)\]$/gm;
-function replaceBrackets(source) {
-  return source.split("/").map((segment) => segment.replace(RE_BRACKETS, ":$1")).join("/");
-}
-function isPrimitive(test) {
-  return test !== Object(test);
-}
-function _eval(code) {
-  const func = new Function(`{ return function(){ return ${code} } };`);
-  return func.call(null).call(null);
-}
-function evalExport(exp) {
-  if (!exp) return;
-  const code = isPrimitive(exp) ? exp : generateCode(exp).code;
-  return _eval(code);
+
+// src/plugins/clean-outdir.ts
+import fs from "fs";
+import path3 from "path";
+function vercelCleanupPlugin(pluginConfig) {
+  let alreadyRun = false;
+  return {
+    apply: "build",
+    name: "vite-plugin-vercel:cleanup",
+    enforce: "pre",
+    applyToEnvironment(env) {
+      return env.name === "client";
+    },
+    buildStart: {
+      order: "pre",
+      sequential: true,
+      handler() {
+        if (alreadyRun) return;
+        alreadyRun = true;
+        const absoluteOutdir = pluginConfig?.outDir && path3.isAbsolute(pluginConfig.outDir) ? pluginConfig.outDir : path3.join(this.environment.config.root, pluginConfig?.outDir ?? ".vercel/output");
+        cleanOutputDirectory(absoluteOutdir);
+      }
+    },
+    sharedDuringBuild: true
+  };
 }
-async function extractExports(filepath) {
-  try {
-    const mod = await loadFile(filepath);
-    const subject = {
-      edge: evalExport(mod.exports.edge),
-      headers: evalExport(mod.exports.headers),
-      streaming: evalExport(mod.exports.streaming),
-      isr: evalExport(mod.exports.isr)
-    };
-    return vercelEndpointExports.parse(subject);
-  } catch (e) {
-    console.warn(`Warning: failed to read exports of '${filepath}'`, e);
-  }
+function cleanOutputDirectory(outdir) {
+  fs.rmSync(outdir, {
+    recursive: true,
+    force: true
+  });
+  fs.mkdirSync(outdir, { recursive: true });
 }
-async function extractHeaders(resolvedConfig) {
-  let headers = [];
-  if (typeof resolvedConfig.vercel?.headers === "function") {
-    headers = await resolvedConfig.vercel.headers();
-  } else if (Array.isArray(resolvedConfig.vercel?.headers)) {
-    headers = resolvedConfig.vercel.headers;
-  }
-  return headers;
+
+// src/plugins/loader.ts
+import { targetLoader } from "@photonjs/core/vite";
+import { getNodeVersion } from "@vercel/build-utils";
+import { vercelOutputPrerenderConfigSchema } from "@vite-plugin-vercel/schemas";
+import { toPathToRegexpV6 } from "convert-route/path-to-regexp-v6";
+import { fromRou3 } from "convert-route/rou3";
+
+// src/build.ts
+import { vercelOutputVcConfigSchema } from "@vite-plugin-vercel/schemas";
+function getVcConfig(pluginConfig, filename, options) {
+  return vercelOutputVcConfigSchema.parse(
+    options.edge ? {
+      runtime: "edge",
+      entrypoint: filename
+    } : {
+      runtime: options.nodeVersion.runtime,
+      handler: filename,
+      maxDuration: pluginConfig.defaultMaxDuration,
+      launcherType: "Nodejs",
+      shouldAddHelpers: true,
+      supportsResponseStreaming: options.streaming ?? pluginConfig.defaultSupportsResponseStreaming
+    }
+  );
 }
-async function buildEndpoints(resolvedConfig) {
-  const entries = await getEntries(resolvedConfig);
-  const headers = await extractHeaders(resolvedConfig);
-  for (const entry of entries) {
-    if (typeof entry.source === "string") {
-      const exports = await extractExports(entry.source);
-      if (exports) {
-        if (entry.headers || exports.headers) {
-          entry.headers = {
-            ...exports.headers,
-            ...entry.headers
-          };
-        }
-        if (entry.edge !== void 0 && exports.edge !== void 0) {
-          throw new Error(
-            `edge configuration should be defined either in the endpoint itself or through Vite config, not both ('${entry.source}')`
-          );
+
+// src/plugins/loader.ts
+var DUMMY = "__DUMMY__";
+var re_DUMMY = new RegExp(`${DUMMY}$`);
+var nonEdgeServers = ["express", "fastify"];
+function loaderPlugin(pluginConfig) {
+  let nodeVersion;
+  return [
+    {
+      name: "vite-plugin-vercel:update-entries",
+      apply: "build",
+      buildStart: {
+        order: "post",
+        handler() {
+          for (const entry of [this.environment.config.photon.server, ...this.environment.config.photon.entries]) {
+            if (!entry.env) {
+              entry.env = entry.vercel?.edge ? "vercel_edge" : "vercel_node";
+            }
+            if (entry.env === "vercel_edge" || entry.env === "vercel_node") {
+              entry.target = `${photonEntryDestination(entry, ".func/index")}.js`;
+            }
+          }
         }
-        if (exports.edge !== void 0) {
-          entry.edge = exports.edge;
+      },
+      sharedDuringBuild: true
+    },
+    {
+      name: "vite-plugin-vercel:dummy",
+      enforce: "pre",
+      resolveId: {
+        filter: {
+          id: re_DUMMY
+        },
+        handler(id) {
+          return id;
         }
-        if (entry.isr !== void 0 && exports.isr !== void 0) {
-          throw new Error(
-            `isr configuration should be defined either in the endpoint itself or through Vite config, not both ('${entry.source}')`
-          );
+      },
+      load: {
+        filter: {
+          id: re_DUMMY
+        },
+        handler() {
+          return "export default {};";
         }
-        if ((entry.isr !== void 0 || exports.isr !== void 0) && (entry.edge !== void 0 || exports.edge !== void 0)) {
-          throw new Error(`isr cannot be enabled for edge functions ('${entry.source}')`);
+      }
+    },
+    ...targetLoader("vercel", {
+      async buildStart() {
+        nodeVersion = await getNodeVersion(process.cwd());
+      },
+      applyToEnvironment(env) {
+        return env.name === "vercel_node" || env.name === "vercel_edge" || env.name === "vercel_client";
+      },
+      async load(_id, { meta }) {
+        const entry = meta;
+        const isEdge = Boolean(entry.vercel?.edge);
+        this.emitFile({
+          type: "asset",
+          fileName: photonEntryDestination(entry, ".func/.vc-config.json"),
+          source: JSON.stringify(
+            // Unpredictable things happen when the extension is .mjs on edge
+            getVcConfig(pluginConfig, isEdge ? "index.js" : "index.mjs", {
+              nodeVersion,
+              edge: isEdge,
+              streaming: entry.vercel?.streaming
+            }),
+            void 0,
+            2
+          )
+        });
+        if (entry.vercel?.isr) {
+          this.emitFile({
+            type: "asset",
+            fileName: photonEntryDestination(entry, ".prerender-config.json"),
+            source: JSON.stringify(vercelOutputPrerenderConfigSchema.parse(entry.vercel.isr), void 0, 2)
+          });
         }
-        if (exports.isr) {
-          entry.isr = exports.isr;
+        if (entry.route || entry.vercel?.route) {
+          pluginConfig.rewrites ??= [];
+          const source = typeof entry.vercel?.route === "string" ? `(${entry.vercel.route})` : typeof entry.route === "string" ? toPathToRegexpV6(fromRou3(entry.route)) : entryToPathtoregex(entry);
+          pluginConfig.rewrites.push({
+            enforce: entry.vercel?.enforce,
+            source,
+            destination: typeof entry.vercel?.route === "string" ? `/${photonEntryDestinationDefault(entry)}?__original_path=$1` : `/${photonEntryDestinationDefault(entry)}`
+          });
+          if (entry.vercel?.headers) {
+            pluginConfig.headers ??= [];
+            pluginConfig.headers.push({
+              source,
+              headers: Object.entries(entry.vercel.headers).map(([key, value]) => ({
+                key,
+                value
+              }))
+            });
+          }
         }
-        if (typeof exports.streaming === "boolean") {
-          entry.streaming = exports.streaming;
+        const fn = isEdge ? "createEdgeHandler" : "createNodeHandler";
+        const isServerEntry = entry.type === "server";
+        if (isServerEntry) {
+          assert(entry.server, `Could not determine server for entry ${entry.id}`);
+          if (isEdge) {
+            assert(
+              !nonEdgeServers.includes(entry.server),
+              `${entry.server} is not compatible with Vercel Edge target. Either use another server like Hono or change target to Node`
+            );
+          }
         }
+        const importFrom = isServerEntry ? `@universal-middleware/vercel/${entry.server}` : "@universal-middleware/vercel";
+        const exportDefault = isServerEntry ? `export default ${fn}(handlerOrApp)` : `export default ${fn}(() => handlerOrApp)()`;
+        return `
+import { ${fn} } from "photon:resolve-from-photon:${importFrom}";
+import handlerOrApp from "${entry.resolvedId ?? entry.id}";
+
+${exportDefault};
+`;
       }
-    }
-    await buildFn(resolvedConfig, entry, entry.buildOptions);
-  }
-  const isrEntries = entries.filter((e) => e.isr).map((e) => [e.destination.replace(/\.func$/, ""), { expiration: e.isr?.expiration }]);
-  return {
-    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]) => ({
-          key,
-          value
-        }))
-      })),
-      ...headers
-    ]
-  };
+    })
+  ];
 }
 
-// src/config.ts
-import path3 from "node:path";
+// src/plugins/routes.ts
+function routesPlugins() {
+  return [
+    {
+      name: "vite-plugin-vercel:routes-dedupe",
+      apply: "build",
+      applyToEnvironment(env) {
+        return env.name === "ssr";
+      },
+      buildStart: {
+        // Ensure that this hook is executed close to last, ensuring that all plugins had time to inject their Photon entries
+        order: "post",
+        handler() {
+          const entriesEdge = this.environment.config.photon.entries.filter((e) => e.vercel?.edge);
+          const entriesNode = this.environment.config.photon.entries.filter((e) => !e.vercel?.edge);
+          const entriesToKeep = /* @__PURE__ */ new Set();
+          for (const envEntries of [entriesEdge, entriesNode]) {
+            for (const page of envEntries.filter(
+              (p) => p.vercel?.isr || p.vercel?.route && p.vercel?.headers !== null && p.vercel?.headers !== void 0
+            )) {
+              entriesToKeep.add(page);
+            }
+          }
+          this.environment.config.photon.entries = this.environment.config.photon.entries.filter(
+            (e) => !e.vikeMeta || entriesToKeep.has(e)
+          );
+        }
+      },
+      sharedDuringBuild: true
+    }
+  ];
+}
 
-// src/schemas/config/config.ts
-import { z as z3 } from "zod";
-var HasOrMissing = z3.array(
-  z3.union([
-    z3.object({
-      type: z3.literal("host"),
-      value: z3.string()
-    }).strict(),
-    z3.object({
-      type: z3.literal("header"),
-      key: z3.string(),
-      value: z3.string().optional()
-    }).strict(),
-    z3.object({
-      type: z3.literal("cookie"),
-      key: z3.string(),
-      value: z3.string().optional()
-    }).strict(),
-    z3.object({
-      type: z3.literal("query"),
-      key: z3.string(),
-      value: z3.string().optional()
-    }).strict()
-  ])
-).optional();
-var vercelOutputConfigSchema = z3.object({
-  version: z3.literal(3),
-  routes: z3.array(
-    z3.union([
-      z3.object({
-        src: z3.string(),
-        dest: z3.string().optional(),
-        headers: z3.record(z3.string()).optional(),
-        methods: z3.array(z3.string()).optional(),
-        status: z3.number().int().positive().optional(),
-        continue: z3.boolean().optional(),
-        check: z3.boolean().optional(),
-        missing: HasOrMissing,
-        has: HasOrMissing,
-        locale: z3.object({
-          redirect: z3.record(z3.string()).optional(),
-          cookie: z3.string().optional()
-        }).strict().optional(),
-        middlewarePath: z3.string().optional()
-      }).strict(),
-      z3.object({
-        handle: z3.union([
-          z3.literal("rewrite"),
-          z3.literal("filesystem"),
-          z3.literal("resource"),
-          z3.literal("miss"),
-          z3.literal("hit"),
-          z3.literal("error")
-        ]),
-        src: z3.string().optional(),
-        dest: z3.string().optional(),
-        status: z3.number().optional()
-      }).strict()
-    ])
-  ).optional(),
-  images: z3.object({
-    sizes: z3.tuple([z3.number().int().positive(), z3.number().int().positive()]),
-    domains: z3.array(z3.string()).nonempty().optional(),
-    minimumCacheTTL: z3.number().int().positive().optional(),
-    formats: z3.union([z3.literal("image/avif"), z3.literal("image/webp")]).array().nonempty().optional(),
-    dangerouslyAllowSVG: z3.boolean().optional(),
-    contentSecurityPolicy: z3.string().optional()
-  }).strict().optional(),
-  wildcard: z3.array(
-    z3.object({
-      domain: z3.string(),
-      value: z3.string()
-    }).strict()
-  ).optional(),
-  overrides: z3.record(
-    z3.object({
-      path: z3.string().optional(),
-      contentType: z3.string().optional()
-    }).strict()
-  ).optional(),
-  cache: z3.array(z3.string()).optional()
-}).strict();
+// src/plugins/setupEnvs.ts
+import {
+  BuildEnvironment,
+  createLogger,
+  createRunnableDevEnvironment,
+  mergeConfig
+} from "vite";
+import path4 from "path";
 
 // src/config.ts
-import fs2 from "node:fs/promises";
-import {
-  getTransformedRoutes,
-  mergeRoutes,
-  normalizeRoutes
-} from "@vercel/routing-utils";
+import { getTransformedRoutes, mergeRoutes, normalizeRoutes } from "@vercel/routing-utils";
+import { vercelOutputConfigSchema } from "@vite-plugin-vercel/schemas";
 function reorderEnforce(arr) {
   return [
     ...arr.filter((r) => r.enforce === "pre"),
@@ -509,36 +522,27 @@ function reorderEnforce(arr) {
     ...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 _enforcedRewrites = reorderEnforce(_rewrites).map((r) => {
-    r.source = r.source.replaceAll(/:\[(\.\.\.)(.*)\]/g, ":$2*");
-    r.source = r.source.replaceAll(/:(\.\.\.)(.*)/g, ":$2+");
-    return r;
-  });
+function getConfig(pluginConfig) {
+  const _rewrites = [...pluginConfig.rewrites ?? []];
   const { routes, error } = getTransformedRoutes({
-    cleanUrls: resolvedConfig.vercel?.cleanUrls ?? true,
-    trailingSlash: resolvedConfig.vercel?.trailingSlash,
-    rewrites: _enforcedRewrites,
-    redirects: resolvedConfig.vercel?.redirects ? reorderEnforce(resolvedConfig.vercel?.redirects) : void 0,
-    headers
+    cleanUrls: pluginConfig.cleanUrls ?? true,
+    trailingSlash: pluginConfig.trailingSlash,
+    rewrites: reorderEnforce(_rewrites),
+    redirects: pluginConfig.redirects ? reorderEnforce(pluginConfig.redirects) : void 0,
+    headers: pluginConfig.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)) {
+  if (pluginConfig.config?.routes && pluginConfig.config.routes.length > 0 && !pluginConfig.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`.'
+      '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 `routes` config to override routes. Prefer using `rewrites` and `redirects`.'
     );
   }
   let userRoutes = [];
   let buildRoutes = [];
-  if (resolvedConfig.vercel?.config?.routes) {
-    const norm = normalizeRoutes(resolvedConfig.vercel.config.routes);
+  if (pluginConfig.config?.routes) {
+    const norm = normalizeRoutes(pluginConfig.config.routes);
     if (norm.error) {
       throw norm.error;
     }
@@ -556,247 +560,256 @@ function getConfig(resolvedConfig, rewrites, overrides, headers) {
     builds: [
       {
         use: "@vercel/node",
-        entrypoint: "index.js",
+        entrypoint: "index.mjs",
         routes: buildRoutes
       }
     ]
   });
   return vercelOutputConfigSchema.parse({
     version: 3,
-    ...resolvedConfig.vercel?.config,
+    ...pluginConfig.config,
     routes: cleanRoutes,
     overrides: {
-      ...resolvedConfig.vercel?.config?.overrides,
-      ...overrides
+      ...pluginConfig.config?.overrides
     }
   });
 }
-function getConfigDestination(resolvedConfig) {
-  return path3.join(getOutput(resolvedConfig), "config.json");
-}
-async function writeConfig(resolvedConfig, rewrites, overrides, headers) {
-  await fs2.writeFile(
-    getConfigDestination(resolvedConfig),
-    JSON.stringify(getConfig(resolvedConfig, rewrites, overrides, headers), void 0, 2),
-    "utf-8"
-  );
-}
 
-// src/helpers.ts
-import fs3 from "node:fs/promises";
-import path4 from "node:path";
-async function copyDir(src, dest) {
-  await fs3.mkdir(dest, { recursive: true });
-  const entries = await fs3.readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path4.join(src, entry.name);
-    const destPath = path4.join(dest, entry.name);
-    entry.isDirectory() ? await copyDir(srcPath, destPath) : await fs3.copyFile(srcPath, destPath);
-  }
-}
-
-// src/prerender.ts
-import path5 from "node:path";
+// src/plugins/setupEnvs.ts
+import stripAnsi from "strip-ansi";
 
-// src/schemas/config/prerender-config.ts
-import { z as z4 } from "zod";
-var vercelOutputPrerenderConfigSchema = z4.object({
-  expiration: z4.union([z4.number().int().positive(), z4.literal(false)]),
-  group: z4.number().int().optional(),
-  bypassToken: z4.string().optional(),
-  fallback: z4.string().optional(),
-  allowQuery: z4.array(z4.string()).optional()
-}).strict();
+// src/utils/const.ts
+var virtualEntry = "virtual:vite-plugin-vercel:entry";
 
-// src/prerender.ts
-import fs4 from "node:fs/promises";
-function execPrerender(resolvedConfig) {
-  const prerender = resolvedConfig.vercel?.prerender;
-  if (prerender === false) {
-    return;
-  }
-  return prerender?.(resolvedConfig);
-}
-var group = 1;
-async function writePrerenderConfig(resolvedConfig, destination, isr) {
-  const parsed = path5.parse(destination);
-  const outfile = path5.join(getOutput(resolvedConfig, "functions"), parsed.dir, `${parsed.name}.prerender-config.json`);
-  await fs4.mkdir(path5.join(getOutput(resolvedConfig, "functions"), parsed.dir), { recursive: true });
-  await fs4.writeFile(
-    outfile,
-    JSON.stringify(
-      vercelOutputPrerenderConfigSchema.parse({
-        group: group++,
-        ...isr
-      }),
-      void 0,
-      2
-    ),
-    "utf-8"
-  );
-}
-function getPrerenderSymlinkInfo(resolvedConfig, destination, target) {
-  const parsed = path5.parse(destination);
-  const targetParsed = path5.parse(target);
-  return {
-    target: path5.join(getOutput(resolvedConfig, "functions"), targetParsed.dir, `${targetParsed.name}.func`),
-    link: path5.join(getOutput(resolvedConfig, "functions"), parsed.dir, `${parsed.name}.func`)
-  };
+// src/plugins/setupEnvs.ts
+var outDir = ".vercel/output";
+var DUMMY2 = "__DUMMY__";
+function setupEnvs(pluginConfig) {
+  return [
+    {
+      name: "vite-plugin-vercel:setup-envs",
+      buildApp: {
+        order: "post",
+        async handler(builder) {
+          await builder.build(builder.environments.vercel_client);
+          await builder.build(builder.environments.vercel_edge);
+          await builder.build(builder.environments.vercel_node);
+        }
+      },
+      config() {
+        const outDirOverride = pluginConfig.outDir ? {
+          build: {
+            outDir: path4.posix.join(pluginConfig.outDir, "_tmp")
+          }
+        } : {};
+        return {
+          environments: {
+            vercel_edge: createVercelEnvironmentOptions(outDirOverride),
+            vercel_node: createVercelEnvironmentOptions(outDirOverride),
+            vercel_client: {
+              build: {
+                outDir: path4.join(pluginConfig.outDir ?? outDir, "static"),
+                copyPublicDir: true
+              },
+              consumer: "client"
+            }
+          },
+          customLogger: createVercelLogger(),
+          // Required for environments to be taken into account
+          builder: {}
+        };
+      },
+      sharedDuringBuild: true
+    },
+    {
+      name: "vite-plugin-vercel:setup-envs:vercel_edge",
+      applyToEnvironment(env) {
+        return env.name === "vercel_edge";
+      },
+      configEnvironment(name, config, env) {
+        if (name !== "vercel_edge") return;
+        const isDev = env.command === "serve";
+        const conditions = !isDev ? {
+          conditions: edgeConditions
+        } : {};
+        return {
+          resolve: {
+            external: edgeExternal,
+            ...conditions
+          },
+          build: {
+            target: "es2022",
+            rollupOptions: {
+              input: {},
+              treeshake: "smallest"
+            }
+          },
+          optimizeDeps: {
+            ...config.optimizeDeps,
+            esbuildOptions: {
+              target: "es2022",
+              format: "esm"
+            }
+          }
+        };
+      },
+      generateBundle: {
+        order: "post",
+        async handler(_opts, bundle2) {
+          cleanupDummy(bundle2);
+        }
+      },
+      sharedDuringBuild: true
+    },
+    {
+      name: "vite-plugin-vercel:setup-envs:vercel_node",
+      applyToEnvironment(env) {
+        return env.name === "vercel_node";
+      },
+      configEnvironment(name, config) {
+        if (name !== "vercel_node") return;
+        return {
+          optimizeDeps: {
+            ...config.optimizeDeps
+          }
+        };
+      },
+      generateBundle: {
+        order: "post",
+        async handler(_opts, bundle2) {
+          cleanupDummy(bundle2);
+          this.emitFile({
+            type: "asset",
+            fileName: "config.json",
+            source: JSON.stringify(getConfig(pluginConfig), void 0, 2)
+          });
+        }
+      },
+      sharedDuringBuild: true
+    }
+  ];
 }
-async function buildPrerenderConfigs(resolvedConfig, extractedIsr) {
-  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);
-      await copyDir(info.target, info.link);
+function createVercelLogger() {
+  const logger = createLogger();
+  const loggerInfo = logger.info;
+  logger.info = (msg, options) => {
+    if (options?.environment && (msg.includes("building for production") || msg.includes("building SSR bundle for production"))) {
+      return loggerInfo(`${msg} ${options.environment}`, options);
     }
-    if (route) {
-      rewrites.push({
-        source: `(${route})`,
-        destination: `${destination}/?__original_path=$1`
-      });
+    if (msg.includes(".vercel/output/_tmp")) {
+      const strippedMsg = stripAnsi(msg);
+      if (strippedMsg.includes(".vercel/output/_tmp/assets") || strippedMsg.includes(".vercel/output/_tmp/chunks") || strippedMsg.includes(".vercel/output/_tmp/entries"))
+        return;
+      if (!strippedMsg.includes(".vercel/output/_tmp/functions/") && !strippedMsg.includes(".vercel/output/_tmp/config.json")) {
+        return;
+      }
+      return loggerInfo(msg.replace(".vercel/output/_tmp/", ".vercel/output/"), options);
     }
-  }
-  return rewrites;
+    loggerInfo(msg, options);
+  };
+  return logger;
+}
+function createVercelEnvironmentOptions(overrides) {
+  return mergeConfig(
+    {
+      // The bundle generated by esbuild takes care of this
+      // resolve: {
+      //   noExternal: true,
+      // },
+      dev: {
+        async createEnvironment(name, config) {
+          return createRunnableDevEnvironment(name, config);
+        }
+      },
+      build: {
+        createEnvironment(name, config) {
+          return new BuildEnvironment(name, config);
+        },
+        outDir: path4.posix.join(outDir, "_tmp"),
+        copyPublicDir: false,
+        rollupOptions: {
+          input: getDummyInput(),
+          output: {
+            sanitizeFileName: false,
+            sourcemap: false
+          }
+        },
+        target: "es2022",
+        emptyOutDir: false,
+        emitAssets: true
+      },
+      consumer: "server",
+      keepProcessEnv: true
+    },
+    overrides ?? {}
+  );
 }
-async function getIsrConfig(resolvedConfig) {
-  const isr = resolvedConfig.vercel?.isr ?? {};
-  if (typeof isr === "function") {
-    return await isr();
+function getDummyInput() {
+  return { [DUMMY2]: `${virtualEntry}:${DUMMY2}` };
+}
+function cleanupDummy(bundle2) {
+  const dummy = Object.keys(bundle2).find((key) => key.includes(DUMMY2));
+  if (dummy) {
+    delete bundle2[dummy];
   }
-  return isr;
 }
 
-// src/index.ts
-function vercelPluginCleanup() {
-  let resolvedConfig;
+// src/plugins/wasm.ts
+function wasmPlugin() {
   return {
-    apply: "build",
-    name: "vite-plugin-vercel:cleanup",
+    name: "vite-plugin-vercel:fix-wasm-module",
     enforce: "pre",
-    configResolved(config) {
-      resolvedConfig = config;
-    },
-    writeBundle: {
+    resolveId: {
       order: "pre",
-      sequential: true,
-      async handler() {
-        if (!resolvedConfig.build?.ssr) {
-          await cleanOutputDirectory(resolvedConfig);
-        }
-      }
-    }
-  };
-}
-function vercelPlugin() {
-  let resolvedConfig;
-  let vikeFound = false;
-  return {
-    apply: "build",
-    name: "vite-plugin-vercel",
-    enforce: "post",
-    configResolved(config) {
-      resolvedConfig = config;
-      vikeFound = resolvedConfig.plugins.some((p) => p.name.match("^vite-plugin-ssr:|^vike:"));
-      if (typeof resolvedConfig.vercel?.distContainsOnlyStatic === "undefined") {
-        resolvedConfig.vercel ??= {};
-        resolvedConfig.vercel.distContainsOnlyStatic = !vikeFound;
-      }
-    },
-    writeBundle: {
-      order: "post",
-      sequential: true,
-      async handler() {
-        if (!resolvedConfig.build?.ssr) {
-          if (vikeFound) {
-            return;
-          }
-        }
-        const overrides = await execPrerender(resolvedConfig);
-        const userOverrides = await computeStaticHtmlOverrides(resolvedConfig);
-        const { rewrites, isr, headers } = await buildEndpoints(resolvedConfig);
-        rewrites.push(...await buildPrerenderConfigs(resolvedConfig, isr));
-        await writeConfig(
-          resolvedConfig,
-          rewrites,
-          {
-            ...userOverrides,
-            ...overrides
-          },
-          headers
-        );
-        await copyDistToStatic(resolvedConfig);
+      async handler(id) {
+        if (!id.endsWith(".wasm?module")) return;
+        if (this.environment.name !== "vercel_edge") return;
+        return {
+          id,
+          external: true
+        };
       }
     }
   };
 }
-async function cleanOutputDirectory(resolvedConfig) {
-  await fs5.rm(getOutput(resolvedConfig), {
-    recursive: true,
-    force: true
-  });
-  await fs5.mkdir(getOutput(resolvedConfig), { recursive: true });
-}
-async function copyDistToStatic(resolvedConfig) {
-  if (resolvedConfig.vercel?.distContainsOnlyStatic) {
-    await copyDir(resolvedConfig.build.outDir, getOutput(resolvedConfig, "static"));
-  }
-}
-async function computeStaticHtmlOverrides(resolvedConfig) {
-  const staticAbsolutePath = getOutput(resolvedConfig, "static");
-  const files = await getStaticHtmlFiles(staticAbsolutePath);
-  const publicDir = getPublic(resolvedConfig);
-  const publicFiles = await getStaticHtmlFiles(publicDir);
-  files.push(...publicFiles.map((f) => f.replace(publicDir, staticAbsolutePath)));
-  return files.reduce(
-    (acc, curr) => {
-      const relPath = path6.relative(staticAbsolutePath, curr);
-      const parsed = path6.parse(relPath);
-      const pathJoined = path6.join(parsed.dir, parsed.name);
-      acc[relPath] = {
-        path: pathJoined
-      };
-      return acc;
-    },
-    {}
-  );
-}
-async function getStaticHtmlFiles(src) {
-  try {
-    await fs5.stat(src);
-  } catch (e) {
-    return [];
+
+// src/plugins/index.ts
+function vercel(pluginConfig = {}) {
+  const additionalConfig = {};
+  if (pluginConfig.entries) {
+    additionalConfig.entries = pluginConfig.entries;
   }
-  const entries = await fs5.readdir(src, { withFileTypes: true });
-  const htmlFiles = [];
-  for (const entry of entries) {
-    const srcPath = path6.join(src, entry.name);
-    entry.isDirectory() ? htmlFiles.push(...await getStaticHtmlFiles(srcPath)) : srcPath.endsWith(".html") ? htmlFiles.push(srcPath) : void 0;
+  if (pluginConfig.server) {
+    additionalConfig.server = pluginConfig.server;
   }
-  return htmlFiles;
-}
-async function tryImportVpvv(options) {
-  try {
-    await import("vike/plugin");
-    const vpvv = await import("@vite-plugin-vercel/vike");
-    return vpvv.default(options);
-  } catch (e) {
-    try {
-      await import("vite-plugin-ssr/plugin");
-      const vpvv = await import("@vite-plugin-vercel/vike");
-      return vpvv.default(options);
-    } catch (e2) {
-      return null;
-    }
-  }
-}
-function allPlugins(options = {}) {
-  const { smart, ...rest } = options;
-  return [vercelPluginCleanup(), vercelPlugin(), smart !== false ? tryImportVpvv(rest) : null];
+  return [
+    ...installPhoton("vite-plugin-vercel", {
+      ...additionalConfig,
+      defaultBuildEnv: "vercel_node",
+      codeSplitting: {
+        target: true
+      },
+      devServer: {
+        env: "vercel_node"
+      },
+      resolveMiddlewares(env) {
+        if (env === "dev") {
+          return "vite-plugin-vercel/universal-middleware/dev";
+        }
+        return "vite-plugin-vercel/universal-middleware";
+      }
+    }),
+    vercelCleanupPlugin(),
+    apiPlugin(pluginConfig),
+    ...setupEnvs(pluginConfig),
+    wasmPlugin(),
+    ...loaderPlugin(pluginConfig),
+    ...routesPlugins(),
+    ...bundlePlugin(pluginConfig)
+  ];
 }
+var plugins_default = vercel;
 export {
-  allPlugins as default
+  plugins_default as default,
+  vercel
 };