vite-plugin-vercel 10.0.0-beta.5 → 11.0.0-beta.2

package/README.md

@@ -31,12 +31,12 @@ bun add -D vite-plugin-vercel
 ## Features
 
 - [x] [SSG/Static files](https://vercel.com/docs/build-output-api/v3/primitives#static-files)
-  - see [`prerender` config](/packages/vercel/src/types.ts#L37)
+    - see [`prerender` config](/packages/vercel/src/types.ts#L37)
 - [x] [SSR/Serverless functions](https://vercel.com/docs/build-output-api/v3/primitives#serverless-functions)
-  - `.[jt]s` files under the `<root>/api` folder of your project are automatically bundled as Serverless functions under `.vercel/output/functions/api/*.func`
-  - see [`additionalEndpoints` config](/packages/vercel/src/types.ts#L62)
+    - `.[jt]s` files under the `<root>/api` folder of your project are automatically bundled as Serverless functions under `.vercel/output/functions/api/*.func`
+    - see [`additionalEndpoints` config](/packages/vercel/src/types.ts#L62)
 - [x] [ISR/Prerender functions](https://vercel.com/docs/build-output-api/v3/primitives#prerender-functions)
-  - see [`isr` config](/packages/vercel/src/types.ts#L89). Also see implementation of [vike](/packages/vike-integration/vike.ts) for example
+    - see [`isr` config](/packages/vercel/src/types.ts#L89). Also see implementation of [vike](/packages/vike-integration/vike.ts) for example
 - [x] [Edge functions](https://vercel.com/docs/build-output-api/v3/primitives#edge-functions)
 - [x] [Edge middleware](https://vercel.com/docs/functions/edge-middleware/middleware-api)
 - [ ] [Images optimization](https://vercel.com/docs/build-output-api/v3/configuration#images)
@@ -51,9 +51,9 @@ Install this package as a dev dependency and add it to your Vite config:
 // vite.config.ts
 import { defineConfig } from 'vite';
 import vercel from 'vite-plugin-vercel';
-import { getEntriesFromFs } from "vite-plugin-vercel/utils";
+import { getVercelEntries } from "vite-plugin-vercel";
 
-const entries = await getEntriesFromFs("endpoints/api", {
+const entries = await getVercelEntries("endpoints/api", {
   // Auto mapping examples:
   //   endpoints/api/page.ts -> /api/page
   //   endpoints/api/name/[name].ts -> /api/name/*
@@ -73,7 +73,7 @@ export default defineConfig({
 
 ### Configure endpoints
 
-Endpoints added via `getEntriesFromFs` can be configured by exporting values from the endpoint file:
+Endpoints added via `getVercelEntries` can be configured by exporting values from the endpoint file:
 
 ```ts
 // file: endpoints/api/endpoint.ts
@@ -164,7 +164,7 @@ export default defineConfig({
      */
     trailingSlash: true,
     /**
-     * Use `getEntriesFromFs` for mapping your filesystem routes to entries.
+     * Use `getVercelEntries` for mapping your filesystem routes to entries.
      * If you are interfacing this plugin with a framework, entries can also be added through the Photon API
      */
     entries: {

package/dist/api-DR2y7JVQ.js

@@ -0,0 +1,70 @@
+//#region src/utils/assert.ts
+function assert(condition, errorMessage) {
+	if (condition) return;
+	throw new Error(`[vite-plugin-vercel] ${errorMessage}`);
+}
+
+//#endregion
+//#region src/api.ts
+function createAPI(outfiles, pluginConfig) {
+	return {
+		getOutFiles() {
+			return outfiles;
+		},
+		get config() {
+			pluginConfig.config ??= {};
+			return pluginConfig.config;
+		},
+		get defaultMaxDuration() {
+			return pluginConfig.defaultMaxDuration;
+		},
+		set defaultMaxDuration(value) {
+			pluginConfig.defaultMaxDuration = value;
+		},
+		get expiration() {
+			return pluginConfig.expiration;
+		},
+		set expiration(value) {
+			pluginConfig.expiration = value;
+		},
+		get rewrites() {
+			pluginConfig.rewrites ??= [];
+			return pluginConfig.rewrites;
+		},
+		get headers() {
+			pluginConfig.headers ??= [];
+			return pluginConfig.headers;
+		},
+		get redirects() {
+			pluginConfig.redirects ??= [];
+			return pluginConfig.redirects;
+		},
+		get cleanUrls() {
+			return pluginConfig.cleanUrls;
+		},
+		set cleanUrls(value) {
+			pluginConfig.cleanUrls = value;
+		},
+		get trailingSlash() {
+			return pluginConfig.trailingSlash;
+		},
+		set trailingSlash(value) {
+			pluginConfig.trailingSlash = value;
+		},
+		get defaultSupportsResponseStreaming() {
+			return pluginConfig.defaultSupportsResponseStreaming;
+		},
+		set defaultSupportsResponseStreaming(value) {
+			pluginConfig.defaultSupportsResponseStreaming = value;
+		}
+	};
+}
+function getVercelAPI(pluginContextOrServer) {
+	const vpv = ("environment" in pluginContextOrServer ? pluginContextOrServer.environment.config : pluginContextOrServer.config).plugins.find((p) => p.name === "vite-plugin-vercel:api");
+	assert(vpv, "Could not find vite-plugin-vercel:api plugin");
+	assert(vpv.api, "Missing `api`. Make sure vite-plugin-vercel is up-to-date");
+	return vpv.api("environment" in pluginContextOrServer ? pluginContextOrServer : void 0);
+}
+
+//#endregion
+export { getVercelAPI as n, assert as r, createAPI as t };

package/dist/api.d.ts

@@ -1 +1,53 @@
-export * from '@photonjs/vercel/api';
+import { PluginContext, ViteVercelConfig, ViteVercelRedirect, ViteVercelRewrite } from "./types.js";
+import { VercelOutputConfig } from "@vite-plugin-vercel/schemas";
+import { ViteDevServer } from "vite";
+import { EntryMeta } from "@universal-deploy/store";
+import * as _vercel_routing_utils0 from "@vercel/routing-utils";
+
+//#region src/api.d.ts
+declare function createAPI(outfiles: ViteVercelOutFile[], pluginConfig: ViteVercelConfig): {
+  /**
+   * @internal
+   */
+  getOutFiles(): ViteVercelOutFile[];
+  readonly config: Partial<Omit<VercelOutputConfig, "version">>;
+  defaultMaxDuration: number | undefined;
+  expiration: number | undefined;
+  readonly rewrites: ViteVercelRewrite[];
+  readonly headers: _vercel_routing_utils0.Header[];
+  readonly redirects: ViteVercelRedirect[];
+  cleanUrls: boolean | undefined;
+  trailingSlash: boolean | undefined;
+  defaultSupportsResponseStreaming: boolean | undefined;
+};
+declare function getVercelAPI(pluginContextOrServer: Pick<PluginContext, "environment"> | ViteDevServer): {
+  /**
+   * @internal
+   */
+  getOutFiles(): ViteVercelOutFile[];
+  readonly config: Partial<Omit<VercelOutputConfig, "version">>;
+  defaultMaxDuration: number | undefined;
+  expiration: number | undefined;
+  readonly rewrites: ViteVercelRewrite[];
+  readonly headers: _vercel_routing_utils0.Header[];
+  readonly redirects: ViteVercelRedirect[];
+  cleanUrls: boolean | undefined;
+  trailingSlash: boolean | undefined;
+  defaultSupportsResponseStreaming: boolean | undefined;
+};
+type ViteVercelApi = ReturnType<typeof createAPI>;
+type ViteVercelOutFile = ViteVercelOutFileChunk | ViteVercelOutFileAsset;
+interface ViteVercelOutFileCommon {
+  filepath: string;
+  root: string;
+  outdir: string;
+}
+interface ViteVercelOutFileChunk extends ViteVercelOutFileCommon {
+  type: "chunk";
+  relatedEntry: EntryMeta;
+}
+interface ViteVercelOutFileAsset extends ViteVercelOutFileCommon {
+  type: "asset";
+}
+//#endregion
+export { ViteVercelApi, ViteVercelOutFile, ViteVercelOutFileAsset, ViteVercelOutFileChunk, createAPI, getVercelAPI };

package/dist/api.js

@@ -1,2 +1,3 @@
-// src/api.ts
-export * from "@photonjs/vercel/api";
+import { n as getVercelAPI, t as createAPI } from "./api-DR2y7JVQ.js";
+
+export { createAPI, getVercelAPI };

package/dist/index.d.ts

@@ -1,5 +1,25 @@
-import plugin from '@photonjs/vercel/vite';
+import { EntryMeta } from "@universal-deploy/store";
 
-declare const vercel: typeof plugin;
+//#region src/index.d.ts
 
-export { vercel as default, vercel };
+/**
+ * Scans the filesystem for entry points.
+ * @experimental
+ */
+declare function getVercelEntries(dir: string, {
+  destination,
+  tryParseExports
+}: {
+  destination?: string | undefined;
+  tryParseExports?: boolean | undefined;
+}): Promise<EntryMeta[]>;
+declare function extractExports(filepath: string): Promise<{
+  edge?: boolean | undefined;
+  headers?: Record<string, string> | undefined;
+  streaming?: boolean | undefined;
+  isr?: {
+    expiration: number | false;
+  } | undefined;
+} | null>;
+//#endregion
+export { extractExports, getVercelEntries };

package/dist/index.js

@@ -1,12 +1,70 @@
-// 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 {
-  vite_default as default,
-  vercel
-};
+import { t as pathRelativeTo } from "./path-B4ThGm96.js";
+import path from "node:path";
+import { vercelEndpointExports } from "@vite-plugin-vercel/schemas";
+import { fromNextFs } from "convert-route/next-fs";
+import { toRou3 } from "convert-route/rou3";
+import glob from "fast-glob";
+import { generateCode, loadFile } from "magicast";
+import { normalizePath } from "vite";
+
+//#region src/index.ts
+/**
+* Scans the filesystem for entry points.
+* @experimental
+*/
+async function getVercelEntries(dir, { destination = dir, tryParseExports = true }) {
+	const normalizedDir = normalizePath(dir);
+	destination = normalizePath(destination);
+	const apiEntries = glob.sync(`${path.posix.resolve(normalizedDir)}/**/*.?(m)[jt]s?(x)`).filter((filepath) => !path.basename(filepath).startsWith("_"));
+	const entryPoints = [];
+	for (const filePath of apiEntries) {
+		const outFilePath = pathRelativeTo(filePath, normalizedDir);
+		const parsed = path.posix.parse(outFilePath);
+		let xports;
+		if (tryParseExports) xports = await extractExports(filePath);
+		const key = path.posix.join(destination, parsed.dir, parsed.name);
+		const entry = {
+			id: filePath,
+			vercel: {}
+		};
+		if (xports?.edge) entry.vercel.edge = xports.edge;
+		if (xports?.isr) entry.vercel.isr = xports.isr;
+		if (xports?.headers) entry.vercel.headers = xports.headers;
+		if (xports?.streaming) entry.vercel.streaming = xports.streaming;
+		entry.pattern = entryToRou3(key);
+		if (key.includes("[...")) entry.vercel.enforce = "post";
+		entryPoints.push(entry);
+	}
+	return entryPoints;
+}
+function entryToRou3(key) {
+	return toRou3(fromNextFs(path.posix.resolve("/", key)))[0].replace(/\/index$/, "/");
+}
+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);
+		return null;
+	}
+}
+function isPrimitive(test) {
+	return test !== Object(test);
+}
+function _eval(code) {
+	return new Function(`{ return function(){ return ${code} } };`).call(null).call(null);
+}
+function evalExport(exp) {
+	if (!exp) return;
+	return _eval(isPrimitive(exp) ? exp : generateCode(exp).code);
+}
+
+//#endregion
+export { extractExports, getVercelEntries };

package/dist/path-B4ThGm96.js

@@ -0,0 +1,10 @@
+import path from "node:path";
+import { normalizePath } from "vite";
+
+//#region src/utils/path.ts
+function pathRelativeTo(filePath, rel) {
+	return normalizePath(path.relative(normalizePath(path.resolve(rel)), path.resolve(filePath)));
+}
+
+//#endregion
+export { pathRelativeTo as t };

package/dist/types.d.ts

@@ -1 +1,103 @@
-export * from '@photonjs/vercel/types';
+import { VercelOutputConfig, VercelOutputPrerenderConfig } from "@vite-plugin-vercel/schemas";
+import { Plugin } from "vite";
+import { EntryMeta } from "@universal-deploy/store";
+import { Header, Redirect, Rewrite } from "@vercel/routing-utils";
+
+//#region src/types.d.ts
+type ViteVercelRewrite = Rewrite & {
+  enforce?: "pre" | "post";
+};
+type ViteVercelRedirect = Redirect & {
+  enforce?: "pre" | "post";
+};
+type PluginContext = ThisParameterType<Extract<Plugin["resolveId"], (...args: never) => any>>;
+interface ViteVercelConfig {
+  /**
+   * How long Functions should be allowed to run for every request, in seconds.
+   * If left empty, default value for your plan will be used.
+   */
+  defaultMaxDuration?: number;
+  /**
+   * Default expiration time (in seconds) for prerender functions.
+   * Defaults to 86400 seconds (24h).
+   * @see {@link https://vercel.com/docs/concepts/next.js/incremental-static-regeneration}
+   * @see {@link https://vercel.com/docs/build-output-api/v3#vercel-primitives/prerender-functions/configuration}
+   */
+  expiration?: number;
+  /**
+   * @see {@link https://vercel.com/docs/projects/project-configuration#rewrites}
+   */
+  rewrites?: ViteVercelRewrite[];
+  /**
+   * @see {@link https://vercel.com/docs/projects/project-configuration#headers}
+   * @beta
+   */
+  headers?: Header[];
+  /**
+   * @see {@link https://vercel.com/docs/projects/project-configuration#redirects}
+   */
+  redirects?: ViteVercelRedirect[];
+  /**
+   * @see {@link https://vercel.com/docs/projects/project-configuration#cleanurls}
+   */
+  cleanUrls?: boolean;
+  /**
+   * @see {@link https://vercel.com/docs/projects/project-configuration#trailingslash}
+   */
+  trailingSlash?: boolean;
+  /**
+   * When true, the Serverless Function will stream the response to the client.
+   * @see {@link https://vercel.com/docs/build-output-api/v3/primitives#serverless-function-configuration}
+   * @default true
+   */
+  defaultSupportsResponseStreaming?: boolean;
+  /**
+   * Use `getVercelEntries` for mapping your filesystem routes to entries.
+   */
+  entries?: EntryMeta[];
+  /**
+   * Advanced configuration to override .vercel/output/config.json
+   * @see {@link https://vercel.com/docs/build-output-api/v3/configuration#configuration}
+   * @protected
+   */
+  config?: Partial<Omit<VercelOutputConfig, "version">>;
+  /**
+   * Defaults to `.vercel/output`. Mostly useful for testing purpose
+   * @protected
+   */
+  outDir?: string;
+}
+/**
+ * Keys are path relative to .vercel/output/static directory
+ */
+type ViteVercelRouteOverrides = VercelOutputConfig["overrides"];
+interface VercelEntryOptions {
+  /**
+   * If `true`, guesses route for the function, and adds it to config.json (mimics defaults Vercel behavior).
+   * If a string is provided, it will be equivalent to a `rewrites` rule.
+   * Set to `false` to disable
+   */
+  route?: string | boolean;
+  /**
+   * Ensures that the route is added before or after others
+   */
+  enforce?: "post" | "pre";
+  /**
+   * Set to `true` to mark this function as an Edge Function
+   */
+  edge?: boolean;
+  /**
+   * Additional headers
+   */
+  headers?: Record<string, string> | null;
+  /**
+   * ISR config
+   */
+  isr?: VercelOutputPrerenderConfig;
+  /**
+   * When true, the Serverless Function will stream the response to the client
+   */
+  streaming?: boolean;
+}
+//#endregion
+export { PluginContext, VercelEntryOptions, ViteVercelConfig, ViteVercelRedirect, ViteVercelRewrite, ViteVercelRouteOverrides };

package/dist/types.js

@@ -1,2 +1 @@
-// src/types.ts
-export * from "@photonjs/vercel/types";
+export {  };

package/dist/vite.d.ts

@@ -0,0 +1,9 @@
+import { ViteVercelConfig } from "./types.js";
+
+//#region src/plugins/index.d.ts
+type PluginInterop = Record<string, unknown> & {
+  name: string;
+};
+declare function vercel(pluginConfig?: ViteVercelConfig): PluginInterop[];
+//#endregion
+export { vercel as default, vercel };

package/dist/vite.js

@@ -0,0 +1,629 @@
+import { t as pathRelativeTo$1 } from "./path-B4ThGm96.js";
+import { r as assert, t as createAPI } from "./api-DR2y7JVQ.js";
+import path from "node:path";
+import { vercelOutputConfigSchema, vercelOutputPrerenderConfigSchema, vercelOutputVcConfigSchema } from "@vite-plugin-vercel/schemas";
+import { fromRou3 } from "convert-route/rou3";
+import { BuildEnvironment, createRunnableDevEnvironment, mergeConfig, normalizePath } from "vite";
+import { catchAll, devServer } from "@universal-deploy/store/vite";
+import { store } from "@universal-deploy/store";
+import fs from "node:fs";
+import { cpus } from "node:os";
+import { resolve } from "@vercel/nft";
+import { externals } from "nf3/plugin";
+import pLimit from "p-limit";
+import { build } from "rolldown";
+import { getNodeVersion } from "@vercel/build-utils";
+import { toPathToRegexpV6 } from "convert-route/path-to-regexp-v6";
+import { cp } from "node:fs/promises";
+import { getTransformedRoutes, mergeRoutes, normalizeRoutes } from "@vercel/routing-utils";
+
+//#region src/utils/dedupeRoutes.ts
+/**
+* When multiple entries point to the same module, we can deploy them as a single function.
+* Create a separate function only when specific configuration is provided (`isr`, `headers`, `edge` or `streaming`).
+*/
+function dedupeRoutes() {
+	const entriesToKeep = [];
+	const entriesGroupedByModuleId = groupBy(store.entries, (e) => e.id);
+	for (const entries of entriesGroupedByModuleId.values()) {
+		let groupedEntry;
+		for (const entry of entries) if (entry.vercel && Object.keys(entry.vercel).length > 0) {
+			if (!Array.isArray(entry.pattern)) entry.pattern = [entry.pattern];
+			entriesToKeep.push(entry);
+		} else if (!groupedEntry) {
+			groupedEntry = structuredClone(entry);
+			if (!Array.isArray(groupedEntry.pattern)) groupedEntry.pattern = [groupedEntry.pattern];
+			entriesToKeep.push(groupedEntry);
+		} else groupedEntry.pattern.push(...[entry.pattern].flat());
+	}
+	return entriesToKeep;
+}
+function groupBy(list, fn, selector) {
+	return Array.from(list).reduce((acc, curr) => {
+		const key = fn(curr);
+		if (!acc.has(key)) acc.set(key, []);
+		if (selector) acc.get(key).push(...selector(curr));
+		else acc.get(key).push(curr);
+		return acc;
+	}, /* @__PURE__ */ new Map());
+}
+
+//#endregion
+//#region src/utils/extension.ts
+function removeExtension$1(subject) {
+	return subject.replace(/\.[^/.]+$/, "");
+}
+
+//#endregion
+//#region src/utils/destination.ts
+function entryDestinationDefault(root, entry) {
+	return `${removeExtension$1(pathRelativeTo$1(entry.id, root)).replace(/[^a-zA-Z0-9\-_[\]/]/g, "-")}`;
+}
+function entryDestination(root, entry, postfix) {
+	return `${path.posix.join("functions/", entryDestinationDefault(root, entry))}${postfix}`;
+}
+
+//#endregion
+//#region src/plugins/api.ts
+function apiPlugin(pluginConfig) {
+	const outfiles = [];
+	return {
+		name: "vite-plugin-vercel:api",
+		api() {
+			return createAPI(outfiles, pluginConfig);
+		},
+		applyToEnvironment({ name }) {
+			return name === "vercel_edge" || name === "vercel_node";
+		},
+		writeBundle(_opts, bundle$1) {
+			const root = this.environment.config.root ?? process.cwd();
+			const entryMapByDestination = new Map(dedupeRoutes().map((e) => [entryDestination(root, e, ".func/index"), e]));
+			for (const [key, value] of Object.entries(bundle$1)) if (value.type === "chunk" && entryMapByDestination.has(removeExtension$1(key))) outfiles.push({
+				type: "chunk",
+				root: this.environment.config.root,
+				outdir: this.environment.config.build.outDir,
+				filepath: key,
+				relatedEntry: entryMapByDestination.get(removeExtension$1(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
+	};
+}
+
+//#endregion
+//#region src/utils/external.ts
+const _external = [
+	"async_hooks",
+	"events",
+	"buffer",
+	"assert",
+	"util"
+];
+const edgeExternal = [..._external, ..._external.map((e) => `node:${e}`)];
+
+//#endregion
+//#region src/plugins/bundle.ts
+function bundlePlugin() {
+	const externalsPlugin = externals({});
+	delete externalsPlugin.buildEnd;
+	let buildOutput;
+	return [{
+		...externalsPlugin,
+		applyToEnvironment(env) {
+			return env.config.consumer !== "client";
+		}
+	}, {
+		name: "vite-plugin-vercel:isolate-functions",
+		apply: "build",
+		applyToEnvironment(env) {
+			return env.config.consumer !== "client";
+		},
+		async writeBundle(_, output) {
+			const isEdge = this.environment.name === "vercel_edge";
+			const config = this.environment.config;
+			const outDir$1 = normalizePath(path.isAbsolute(config.build.outDir) ? config.build.outDir : path.join(config.root, config.build.outDir));
+			const entries = Object.entries(output).filter((e) => "isEntry" in e[1] && e[1].isEntry).map((e) => ({
+				name: e[1].name,
+				fileName: e[1].fileName,
+				outPath: path.join(outDir$1, e[1].fileName)
+			}));
+			assert(entries.length > 0, "No entry files found in build output");
+			const outPaths = entries.map((entry) => entry.outPath);
+			const input = Object.fromEntries(outPaths.map((e) => [removeExtension(pathRelativeTo(e, outDir$1)), e]));
+			const limit = pLimit(Math.max(1, Math.ceil(cpus().length / 2)));
+			const localOutput = (await Promise.all(Object.values(input).map((entryPath) => limit(async () => {
+				const outDir$2 = path.dirname(entryPath);
+				return { output: (await bundle({
+					isEdge,
+					input: { index: entryPath },
+					outDir: outDir$2,
+					externals: {
+						conditions: this.environment.config.resolve.conditions,
+						rootDir: this.environment.config.root,
+						trace: {
+							outDir: path.dirname(entryPath),
+							nft: { async resolve(id, parent, job, cjsResolve) {
+								return resolve(id.replace(/\.wasm\?module$/, ".wasm"), parent, job, cjsResolve);
+							} }
+						}
+					}
+				})).output.map((o) => ({
+					...o,
+					fileName: path.join(outDir$2, o.fileName)
+				})) };
+			})))).flatMap((r) => r.output);
+			buildOutput = buildOutput ? [...buildOutput, ...localOutput] : localOutput;
+			cleanup(output, buildOutput, this.environment.config.build.outDir);
+		}
+	}];
+}
+function bundle(options) {
+	assert(options.input, "No input specified");
+	return build({
+		platform: options.isEdge ? "browser" : "node",
+		external: options.isEdge ? edgeExternal : [],
+		write: true,
+		plugins: [externals(options.externals)],
+		input: options.input,
+		resolve: { conditionNames: options.externals.conditions },
+		output: {
+			entryFileNames: options.isEdge ? "[name].js" : "[name].mjs",
+			sanitizeFileName: false,
+			dir: options.outDir,
+			hoistTransitiveImports: false
+		},
+		checks: { pluginTimings: false }
+	});
+}
+function cleanup(viteOutput, rolldownOutput, outputDir) {
+	const viteFilenames = Object.values(viteOutput).map((o) => path.join(outputDir, o.fileName));
+	const rolldownFilenames = new Set(rolldownOutput.map((o) => o.fileName));
+	const rolldownModuleIds = new Set(rolldownOutput.flatMap((o) => o.type === "chunk" ? o.moduleIds : []));
+	const filesToDelete = viteFilenames.filter((id) => id.startsWith(outputDir) && rolldownModuleIds.has(id) && !rolldownFilenames.has(id));
+	const parentDirs = /* @__PURE__ */ new Set();
+	for (const file of filesToDelete) try {
+		fs.unlinkSync(file);
+		const mapFile = `${file}.map`;
+		if (fs.existsSync(mapFile)) fs.unlinkSync(mapFile);
+		parentDirs.add(path.dirname(file));
+	} catch {}
+	for (const dir of parentDirs) try {
+		if (fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+	} catch {}
+}
+function pathRelativeTo(filePath, rel) {
+	return normalizePath(path.relative(normalizePath(path.resolve(rel)), path.resolve(filePath)));
+}
+function removeExtension(subject) {
+	return subject.replace(/\.[^/.]+$/, "");
+}
+
+//#endregion
+//#region src/plugins/clean-outdir.ts
+function vercelCleanupPlugin(pluginConfig) {
+	let alreadyRun = false;
+	return {
+		apply: "build",
+		name: "vite-plugin-vercel:cleanup",
+		enforce: "pre",
+		applyToEnvironment(env) {
+			return env.name === "vercel_client";
+		},
+		buildStart: {
+			order: "pre",
+			sequential: true,
+			handler() {
+				if (alreadyRun) return;
+				alreadyRun = true;
+				cleanOutputDirectory(pluginConfig?.outDir && path.isAbsolute(pluginConfig.outDir) ? pluginConfig.outDir : path.join(this.environment.config.root, pluginConfig?.outDir ?? ".vercel/output"));
+			}
+		},
+		sharedDuringBuild: true
+	};
+}
+function cleanOutputDirectory(outdir) {
+	fs.rmSync(outdir, {
+		recursive: true,
+		force: true
+	});
+	fs.mkdirSync(outdir, { recursive: true });
+}
+
+//#endregion
+//#region src/build.ts
+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: false,
+		supportsResponseStreaming: options.streaming ?? pluginConfig.defaultSupportsResponseStreaming ?? true
+	});
+}
+
+//#endregion
+//#region src/plugins/loader.ts
+const re_DUMMY = /* @__PURE__ */ new RegExp(`__DUMMY__$`);
+function loaderPlugin(pluginConfig) {
+	let root;
+	return [
+		{
+			name: "vite-plugin-vercel:dummy",
+			enforce: "pre",
+			resolveId: {
+				filter: { id: re_DUMMY },
+				handler(id) {
+					return id;
+				}
+			},
+			load: {
+				filter: { id: re_DUMMY },
+				handler() {
+					return "console.log('');export default {};";
+				}
+			}
+		},
+		{
+			name: "vite-plugin-vercel:load-edge",
+			apply: "build",
+			resolveId: {
+				filter: { id: [/\?edge$/] },
+				async handler(id, importer, opts) {
+					const resolved = await this.resolve(id.replace(/\?edge$/, ""), importer, opts);
+					if (!resolved) return null;
+					return `${resolved.id}?edge`;
+				}
+			},
+			load: {
+				filter: { id: [/\?edge$/] },
+				async handler(id) {
+					const mod = id.replace(/\?edge$/, "");
+					return `import mod from ${JSON.stringify(mod)};
+const def = mod.fetch;
+export default def;`;
+				}
+			}
+		},
+		{
+			name: "vite-plugin-vercel:build-functions",
+			apply: "build",
+			applyToEnvironment(env) {
+				return env.name === "vercel_node" || env.name === "vercel_edge";
+			},
+			config: {
+				order: "post",
+				handler(config) {
+					root = config.root;
+				}
+			},
+			configEnvironment: {
+				order: "post",
+				handler(name) {
+					const isEdge = name === "vercel_edge";
+					if (name === "vercel_node" || isEdge) {
+						const entries = dedupeRoutes().filter((e) => (e.vercel?.edge ?? false) === isEdge);
+						return { build: { rollupOptions: {
+							input: Object.fromEntries(entries.map((e) => [entryDestination(root ?? process.cwd(), e, ".func/index"), isEdge ? `${e.id}?edge` : e.id])),
+							output: { hoistTransitiveImports: false }
+						} } };
+					}
+				}
+			},
+			async buildStart() {
+				const isEdge = this.environment.name === "vercel_edge";
+				const nodeVersion = await getNodeVersion(process.cwd());
+				const entries = dedupeRoutes();
+				for (const entry of entries.filter((e) => (e.vercel?.edge ?? false) === isEdge)) {
+					const isEdge$1 = this.environment.name === "vercel_edge";
+					this.emitFile({
+						type: "asset",
+						fileName: entryDestination(root ?? process.cwd(), entry, ".func/.vc-config.json"),
+						source: JSON.stringify(getVcConfig(pluginConfig, isEdge$1 ? "index.js" : "index.mjs", {
+							nodeVersion,
+							edge: isEdge$1,
+							streaming: entry.vercel?.streaming
+						}), void 0, 2)
+					});
+					if (entry.vercel?.isr) this.emitFile({
+						type: "asset",
+						fileName: entryDestination(root ?? process.cwd(), entry, ".prerender-config.json"),
+						source: JSON.stringify(vercelOutputPrerenderConfigSchema.parse(entry.vercel.isr), void 0, 2)
+					});
+					pluginConfig.rewrites ??= [];
+					for (const pattern of [entry.pattern].flat()) {
+						const source = toPathToRegexpV6(fromRou3(pattern));
+						pluginConfig.rewrites.push({
+							enforce: entry.vercel?.enforce,
+							source,
+							destination: `/${entryDestinationDefault(root ?? process.cwd(), entry)}`
+						});
+						if (entry.vercel?.headers) {
+							pluginConfig.headers ??= [];
+							pluginConfig.headers.push({
+								source,
+								headers: Object.entries(entry.vercel.headers).map(([key, value]) => ({
+									key,
+									value
+								}))
+							});
+						}
+					}
+				}
+			},
+			sharedDuringBuild: true
+		}
+	];
+}
+
+//#endregion
+//#region src/plugins/react-edge.ts
+function reactEdgePlugin() {
+	return {
+		name: "vite-plugin-vercel:react-edge",
+		applyToEnvironment(env) {
+			return env.name === "vercel_edge";
+		},
+		resolveId: {
+			order: "pre",
+			filter: { id: [/^react-dom\/server$/] },
+			handler(_id, importer, opts) {
+				return this.resolve("react-dom/server.edge", importer, opts);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/config.ts
+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 }
+	});
+}
+
+//#endregion
+//#region src/utils/const.ts
+const virtualEntry = "virtual:vite-plugin-vercel:entry";
+
+//#endregion
+//#region src/utils/edge.ts
+const edgeConditions = [
+	"edge-light",
+	"worker",
+	"browser",
+	"module",
+	"import",
+	"default"
+];
+
+//#endregion
+//#region src/plugins/setupEnvs.ts
+const outDir = path.posix.join(process.cwd(), ".vercel/output");
+const DUMMY = "__DUMMY__";
+let injected = false;
+function setupEnvs(pluginConfig) {
+	return [
+		{
+			name: "vite-plugin-vercel:setup-envs",
+			buildApp: {
+				order: "post",
+				async handler(builder) {
+					try {
+						await builder.build(builder.environments.vercel_client);
+					} catch (e) {
+						if (e instanceof Error && e.message.includes(`Could not resolve entry module "index.html"`)) {} else throw e;
+					}
+					await builder.build(builder.environments.vercel_edge);
+					await builder.build(builder.environments.vercel_node);
+				}
+			},
+			config() {
+				if (!injected) {
+					injected = true;
+					if (pluginConfig.entries) store.entries.push(...pluginConfig.entries);
+				}
+				const outDirOverride = pluginConfig.outDir ? { build: { outDir: pluginConfig.outDir } } : {};
+				return {
+					environments: {
+						vercel_edge: createVercelEnvironmentOptions(outDirOverride),
+						vercel_node: createVercelEnvironmentOptions(outDirOverride),
+						vercel_client: {
+							build: {
+								outDir: path.join(pluginConfig.outDir ?? outDir, "static"),
+								copyPublicDir: true,
+								rollupOptions: { input: getDummyInput() }
+							},
+							consumer: "client"
+						}
+					},
+					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;
+				return {
+					resolve: {
+						external: edgeExternal,
+						...!(env.command === "serve") ? { conditions: edgeConditions } : {}
+					},
+					build: {
+						target: "es2022",
+						rollupOptions: {
+							input: {},
+							treeshake: { preset: "smallest" }
+						}
+					},
+					optimizeDeps: {
+						...config.optimizeDeps,
+						...this.meta.rolldownVersion ? { rolldownOptions: {
+							target: "es2022",
+							format: "esm"
+						} } : { esbuildOptions: {
+							target: "es2022",
+							format: "esm"
+						} }
+					}
+				};
+			},
+			generateBundle: {
+				order: "post",
+				async handler(_opts, bundle$1) {
+					cleanupDummy(bundle$1);
+				}
+			},
+			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, bundle$1) {
+					cleanupDummy(bundle$1);
+					this.emitFile({
+						type: "asset",
+						fileName: "config.json",
+						source: JSON.stringify(getConfig(pluginConfig), void 0, 2)
+					});
+				}
+			},
+			sharedDuringBuild: true
+		},
+		{
+			name: "vite-plugin-vercel:setup-envs:vercel_client",
+			applyToEnvironment(env) {
+				return env.name === "vercel_client";
+			},
+			generateBundle: { async handler(_opts, bundle$1) {
+				cleanupDummy(bundle$1);
+				const topLevelConfig = this.environment.getTopLevelConfig();
+				const clientEnv = topLevelConfig.environments.client;
+				if (clientEnv) try {
+					await cp(path.join(topLevelConfig.root, clientEnv.build.outDir), this.environment.config.build.outDir, {
+						recursive: true,
+						force: true,
+						dereference: true
+					});
+				} catch (e) {
+					if (e instanceof Error && e.message.includes("ENOENT")) {} else throw e;
+				}
+			} },
+			sharedDuringBuild: true
+		}
+	];
+}
+function createVercelEnvironmentOptions(overrides) {
+	return mergeConfig({
+		dev: { async createEnvironment(name, config) {
+			return createRunnableDevEnvironment(name, config);
+		} },
+		build: {
+			createEnvironment(name, config) {
+				return new BuildEnvironment(name, config);
+			},
+			outDir,
+			copyPublicDir: false,
+			rollupOptions: {
+				input: getDummyInput(),
+				output: {
+					sanitizeFileName: false,
+					sourcemap: false
+				}
+			},
+			target: "es2022",
+			emptyOutDir: false,
+			emitAssets: true
+		},
+		consumer: "server",
+		keepProcessEnv: true
+	}, overrides ?? {});
+}
+function getDummyInput() {
+	return { [DUMMY]: `${virtualEntry}:${DUMMY}` };
+}
+function cleanupDummy(bundle$1) {
+	const dummy = Object.keys(bundle$1).find((key) => key.includes("_DUMMY_"));
+	if (dummy) delete bundle$1[dummy];
+}
+
+//#endregion
+//#region src/plugins/index.ts
+function vercel(pluginConfig = {}) {
+	return [
+		reactEdgePlugin(),
+		vercelCleanupPlugin(),
+		apiPlugin(pluginConfig),
+		...setupEnvs(pluginConfig),
+		...loaderPlugin(pluginConfig),
+		...bundlePlugin(),
+		catchAll(),
+		devServer()
+	];
+}
+var plugins_default = vercel;
+
+//#endregion
+export { plugins_default as default, vercel };

package/meta.d.ts

@@ -0,0 +1,7 @@
+import type { VercelEntryOptions } from "./src/types";
+
+declare module "@universal-deploy/store" {
+  export interface EntryMeta {
+    vercel?: VercelEntryOptions;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-vercel",
-  "version": "10.0.0-beta.5",
+  "version": "11.0.0-beta.2",
   "type": "module",
   "files": [
     "dist",
@@ -9,9 +9,7 @@
   "module": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js",
-    "./universal-middleware": "./dist/universal-middleware-prod.js",
-    "./universal-middleware/dev": "./dist/universal-middleware-dev.js",
-    "./utils": "./dist/utils.js",
+    "./vite": "./dist/vite.js",
     "./api": "./dist/api.js",
     "./types": {
       "types": "./dist/types.d.ts"
@@ -21,23 +19,41 @@
   "author": "Joël Charles <joel.charles91@gmail.com>",
   "repository": "https://github.com/magne4000/vite-plugin-vercel",
   "license": "MIT",
+  "peerDependencies": {
+    "vite": ">=7.1"
+  },
   "devDependencies": {
-    "tsup": "^8.5.0",
+    "@types/node": "^22.19.3",
+    "@universal-middleware/express": "^0.4.22",
+    "@vercel/node": "^5.5.15",
+    "tsdown": "^0.18.4",
     "typescript": "^5.9.3",
-    "vite": "^7.1.12"
+    "vite": "^7.2.4",
+    "vitest": "^4.0.16"
   },
   "dependencies": {
-    "@photonjs/vercel": "^0.1.5",
-    "@photonjs/core": "^0.1.5",
-    "@photonjs/runtime": "^0.1.4"
-  },
-  "peerDependencies": {
-    "@photonjs/core": "^0.1.5",
-    "@photonjs/runtime": "^0.1.4"
+    "@manypkg/find-root": "^3.1.0",
+    "@universal-deploy/store": "^0.0.2",
+    "@universal-middleware/core": "^0.4.13",
+    "@universal-middleware/vercel": "^0.4.29",
+    "@vercel/build-utils": "^13.2.3",
+    "@vercel/nft": "^1.1.1",
+    "@vercel/routing-utils": "^5.3.1",
+    "@vite-plugin-vercel/schemas": "latest",
+    "convert-route": "^1.0.0",
+    "fast-glob": "^3.3.3",
+    "magicast": "^0.5.1",
+    "nf3": "^0.3.1",
+    "p-limit": "^7.2.0",
+    "path-to-regexp": "^8.3.0",
+    "rolldown": "^1.0.0-beta.58",
+    "strip-ansi": "^7.1.2",
+    "vite-plugin-wasm": "^3.5.0"
   },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:types": "tsc --noEmit"
   }
 }

package/dist/universal-middleware-dev.d.ts

@@ -1,3 +0,0 @@
-import um__default from '@photonjs/vercel/universal-middleware/dev';
-export * from '@photonjs/vercel/universal-middleware/dev';
-export { default } from '@photonjs/vercel/universal-middleware/dev';

package/dist/universal-middleware-dev.js

@@ -1,7 +0,0 @@
-// src/universal-middleware-dev.ts
-import um from "@photonjs/vercel/universal-middleware/dev";
-export * from "@photonjs/vercel/universal-middleware/dev";
-var universal_middleware_dev_default = um;
-export {
-  universal_middleware_dev_default as default
-};

package/dist/universal-middleware-prod.d.ts

@@ -1,3 +0,0 @@
-import um__default from '@photonjs/vercel/universal-middleware';
-export * from '@photonjs/vercel/universal-middleware';
-export { default } from '@photonjs/vercel/universal-middleware';

package/dist/universal-middleware-prod.js

@@ -1,7 +0,0 @@
-// src/universal-middleware-prod.ts
-import um from "@photonjs/vercel/universal-middleware";
-export * from "@photonjs/vercel/universal-middleware";
-var universal_middleware_prod_default = um;
-export {
-  universal_middleware_prod_default as default
-};

package/dist/utils.d.ts

@@ -1,3 +0,0 @@
-export * from '@photonjs/vercel/utils';
-import '@photonjs/vercel/api';
-import '@photonjs/vercel/types';

package/dist/utils.js

@@ -1,2 +0,0 @@
-// src/utils.ts
-export * from "@photonjs/vercel/utils";