vite-plugin-vercel 10.0.0-beta.3 → 10.0.0-beta.5

package/dist/index.js

@@ -1,820 +1,12 @@
-import {
-  entryToPathtoregex,
-  photonEntryDestination,
-  photonEntryDestinationDefault
-} from "./chunk-OCCU6UM5.js";
-import {
-  createAPI,
-  getVercelAPI
-} from "./chunk-CR7Q2T4Q.js";
-import {
-  assert
-} from "./chunk-UTQ72LMT.js";
-
-// 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 { nodeFileTrace } from "@vercel/nft";
-import { build } from "esbuild";
-
-// src/helpers.ts
-import path from "path";
-function joinAbsolute(env_or_p0, p1, ...p) {
-  if (path.isAbsolute(p1)) {
-    return path.join(p1, ...p);
-  }
-  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/utils/edge.ts
-var edgeConditions = ["edge-light", "worker", "browser", "module", "import", "default"];
-
-// src/utils/env.ts
-function isVercelLastBuildStep(env) {
-  const name = typeof env !== "string" ? env.name : env;
-  return name === "vercel_node";
-}
-
-// 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) {
-    build2.onResolve({ filter: /\.wasm/ }, (args) => {
-      return {
-        path: args.path.replace(/\.wasm\?module$/i, ".wasm"),
-        external: true
-      };
-    });
-  }
-};
-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 };
-      }
-    });
-  }
-};
-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);
-    });
-  }
-};
-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
-    }
-  ];
-}
-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);
-`
-    };
-  }
-  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;
-      }
-      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));
-    }
-  }
-}
-
-// 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
-  };
-}
-function cleanOutputDirectory(outdir) {
-  fs.rmSync(outdir, {
-    recursive: true,
-    force: true
-  });
-  fs.mkdirSync(outdir, { recursive: true });
-}
-
-// 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
-    }
-  );
-}
-
-// 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`;
-            }
-          }
-        }
-      },
-      sharedDuringBuild: true
-    },
-    {
-      name: "vite-plugin-vercel:dummy",
-      enforce: "pre",
-      resolveId: {
-        filter: {
-          id: re_DUMMY
-        },
-        handler(id) {
-          return id;
-        }
-      },
-      load: {
-        filter: {
-          id: re_DUMMY
-        },
-        handler() {
-          return "export default {};";
-        }
-      }
-    },
-    ...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 (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
-              }))
-            });
-          }
-        }
-        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};
-`;
-      }
-    })
-  ];
-}
-
-// 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();
-          const defaultEnvIsEdge = this.environment.config.photon.defaultBuildEnv === "vercel_edge";
-          for (const envEntries of defaultEnvIsEdge ? [entriesEdge] : [entriesNode]) {
-            for (const page of envEntries.filter(
-              (p) => p.compositionMode === "isolated" || p.vercel?.isr || p.vercel?.route && p.vercel?.headers !== null && p.vercel?.headers !== void 0
-            )) {
-              entriesToKeep.add(page);
-            }
-          }
-          for (const page of defaultEnvIsEdge ? entriesNode : entriesEdge) {
-            entriesToKeep.add(page);
-          }
-          console.log("entriesToKeep", entriesToKeep);
-          this.environment.config.photon.entries = this.environment.config.photon.entries.filter(
-            (e) => !e.vikeMeta || entriesToKeep.has(e)
-          );
-        }
-      },
-      sharedDuringBuild: true
-    }
-  ];
-}
-
-// src/plugins/setupEnvs.ts
-import {
-  BuildEnvironment,
-  createLogger,
-  createRunnableDevEnvironment,
-  mergeConfig
-} from "vite";
-import path4 from "path";
-
-// src/config.ts
-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"),
-    ...arr.filter((r) => !r.enforce),
-    ...arr.filter((r) => r.enforce === "post")
-  ];
-}
-function getConfig(pluginConfig) {
-  const _rewrites = [...pluginConfig.rewrites ?? []];
-  const { routes, error } = getTransformedRoutes({
-    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 (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 `routes` config to override routes. Prefer using `rewrites` and `redirects`.'
-    );
-  }
-  let userRoutes = [];
-  let buildRoutes = [];
-  if (pluginConfig.config?.routes) {
-    const norm = normalizeRoutes(pluginConfig.config.routes);
-    if (norm.error) {
-      throw norm.error;
-    }
-    userRoutes = norm.routes ?? [];
-  }
-  if (routes) {
-    const norm = normalizeRoutes(routes);
-    if (norm.error) {
-      throw norm.error;
-    }
-    buildRoutes = norm.routes ?? [];
-  }
-  const cleanRoutes = mergeRoutes({
-    userRoutes,
-    builds: [
-      {
-        use: "@vercel/node",
-        entrypoint: "index.mjs",
-        routes: buildRoutes
-      }
-    ]
-  });
-  return vercelOutputConfigSchema.parse({
-    version: 3,
-    ...pluginConfig.config,
-    routes: cleanRoutes,
-    overrides: {
-      ...pluginConfig.config?.overrides
-    }
-  });
-}
-
-// src/plugins/setupEnvs.ts
-import stripAnsi from "strip-ansi";
-
-// src/utils/const.ts
-var virtualEntry = "virtual:vite-plugin-vercel:entry";
-
-// 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
-    }
-  ];
-}
-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 (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);
-    }
-    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 ?? {}
-  );
-}
-function getDummyInput() {
-  return { [DUMMY2]: `${virtualEntry}:${DUMMY2}` };
-}
-function cleanupDummy(bundle2) {
-  const dummy = Object.keys(bundle2).find((key) => key.includes(DUMMY2));
-  if (dummy) {
-    delete bundle2[dummy];
-  }
-}
-
-// src/plugins/wasm.ts
-function wasmPlugin() {
-  return {
-    name: "vite-plugin-vercel:fix-wasm-module",
-    enforce: "pre",
-    resolveId: {
-      order: "pre",
-      async handler(id) {
-        if (!id.endsWith(".wasm?module")) return;
-        if (this.environment.name !== "vercel_edge") return;
-        return {
-          id,
-          external: true
-        };
-      }
-    }
-  };
-}
-
-// src/plugins/index.ts
-function vercel(pluginConfig = {}) {
-  const additionalConfig = {};
-  if (pluginConfig.entries) {
-    additionalConfig.entries = pluginConfig.entries;
-  }
-  if (pluginConfig.server) {
-    additionalConfig.server = pluginConfig.server;
-  }
-  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;
+// src/vite.ts
+import { installPhotonResolver } from "@photonjs/core/vite";
+import plugin from "@photonjs/vercel/vite";
+var vercel = (options) => {
+  const plugins = plugin(options);
+  return [...plugins, ...installPhotonResolver("vite-plugin-vercel")];
+};
+var vite_default = vercel;
 export {
-  plugins_default as default,
+  vite_default as default,
   vercel
 };