vite-plugin-vercel 11.0.0-beta.2 → 11.0.0-beta.20

package/README.md

@@ -1,15 +1,12 @@
 # vite-plugin-vercel
 
 > [!NOTE]
-> You are on the [Vite Environment API](https://vite.dev/guide/api-environment.html#environment-configuration) beta branch (v10). Check out [v9 branch](https://github.com/magne4000/vite-plugin-vercel/tree/v9) for current stable version.
+> You are on the [Vite Environment API](https://vite.dev/guide/api-environment.html#environment-configuration) beta branch (v11). Check out [v9 branch](https://github.com/magne4000/vite-plugin-vercel/tree/v9) for current stable version.
 
 Vercel adapter for [Vite](https://vitejs.dev/).
 
 Bundle your Vite application as supported by [Vercel Output API (v3)](https://vercel.com/docs/build-output-api/v3).
 
-> [!NOTE]
-> This plugin is mostly a re-export of [`@photonjs/vercel`](https://github.com/photon-js/photon/tree/main/packages/adapter-vercel)
-
 ## Install
 
 ```bash
@@ -68,7 +65,7 @@ export default defineConfig({
 ```
 
 > [!NOTE]
-> `@vercel/build` currently forces the building of files in the _/api_ folder, with no way to disable this behavior.
+> `@vercel/build` forces the building of files in the _/api_ folder, with no way to disable this behavior.
 > It's recommended to place your files in a different folder.
 
 ### Configure endpoints
@@ -165,7 +162,7 @@ export default defineConfig({
     trailingSlash: true,
     /**
      * 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
+     * If you are interfacing this plugin with a framework, entries can also be added through the {@link https://github.com/photon-js/universal-deploy | universal-deploy} API
      */
     entries: {
       root: {
@@ -209,7 +206,7 @@ Related documentation: https://vercel.com/docs/edge-network/headers/request-head
 
 ## Migrations
 
-- [Migration from v9 to v10](https://github.com/magne4000/vite-plugin-vercel/blob/main/MIGRATION.md)
+- [Migration from v9 to v11](https://github.com/magne4000/vite-plugin-vercel/blob/main/MIGRATION.md)
 
 ## Demo
 

package/dist/api.js

@@ -1,3 +1,65 @@
-import { n as getVercelAPI, t as createAPI } from "./api-DR2y7JVQ.js";
+import { t as assert } from "./assert-vtiLgQIb.js";
 
+//#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 { createAPI, getVercelAPI };

package/dist/assert-vtiLgQIb.js

@@ -0,0 +1,8 @@
+//#region src/utils/assert.ts
+function assert(condition, errorMessage) {
+	if (condition) return;
+	throw new Error(`[vite-plugin-vercel] ${errorMessage}`);
+}
+
+//#endregion
+export { assert as t };

package/dist/index.d.ts

@@ -1,18 +1,31 @@
 import { EntryMeta } from "@universal-deploy/store";
 
 //#region src/index.d.ts
-
+interface GetVercelEntriesOptions {
+  /**
+   * Map entries to URL patterns
+   * @example
+   *  // When dir: "endpoints/myapi" and destination: "api"
+   *  //  endpoints/myapi/page.ts -> /api/page
+   *  //  endpoints/myapi/name/[name].ts -> /api/name/*
+   */
+  destination?: string;
+  /**
+   * If true, parse entries exports for per-file settings.
+   * Entries can export `edge`, `isr`, `headers` and `streaming`. See README for more details
+   *
+   * @default true
+   */
+  tryParseExports?: boolean;
+}
 /**
  * Scans the filesystem for entry points.
- * @experimental
+ * @beta
  */
 declare function getVercelEntries(dir: string, {
   destination,
   tryParseExports
-}: {
-  destination?: string | undefined;
-  tryParseExports?: boolean | undefined;
-}): Promise<EntryMeta[]>;
+}: GetVercelEntriesOptions): Promise<EntryMeta[]>;
 declare function extractExports(filepath: string): Promise<{
   edge?: boolean | undefined;
   headers?: Record<string, string> | undefined;
@@ -22,4 +35,4 @@ declare function extractExports(filepath: string): Promise<{
   } | undefined;
 } | null>;
 //#endregion
-export { extractExports, getVercelEntries };
+export { GetVercelEntriesOptions, extractExports, getVercelEntries };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as pathRelativeTo } from "./path-B4ThGm96.js";
+import { t as pathRelativeTo } from "./path-DoLvGKnz.js";
 import path from "node:path";
 import { vercelEndpointExports } from "@vite-plugin-vercel/schemas";
 import { fromNextFs } from "convert-route/next-fs";
@@ -10,7 +10,7 @@ import { normalizePath } from "vite";
 //#region src/index.ts
 /**
 * Scans the filesystem for entry points.
-* @experimental
+* @beta
 */
 async function getVercelEntries(dir, { destination = dir, tryParseExports = true }) {
 	const normalizedDir = normalizePath(dir);
@@ -31,7 +31,7 @@ async function getVercelEntries(dir, { destination = dir, tryParseExports = true
 		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);
+		entry.route = entryToRou3(key);
 		if (key.includes("[...")) entry.vercel.enforce = "post";
 		entryPoints.push(entry);
 	}

package/dist/types.d.ts

@@ -12,6 +12,20 @@ type ViteVercelRedirect = Redirect & {
 };
 type PluginContext = ThisParameterType<Extract<Plugin["resolveId"], (...args: never) => any>>;
 interface ViteVercelConfig {
+  /**
+   * @experimental
+   * @default basic
+   */
+  bundleStrategy?: "basic" | "nf3";
+  /**
+   * Override vite build environments
+   * @experimental
+   */
+  viteEnvNames?: {
+    client?: string;
+    edge?: string | false;
+    node?: string;
+  };
   /**
    * How long Functions should be allowed to run for every request, in seconds.
    * If left empty, default value for your plan will be used.

package/dist/vite.js

@@ -1,22 +1,36 @@
-import { t as pathRelativeTo$1 } from "./path-B4ThGm96.js";
-import { r as assert, t as createAPI } from "./api-DR2y7JVQ.js";
+import { t as pathRelativeTo$1 } from "./path-DoLvGKnz.js";
+import { t as assert } from "./assert-vtiLgQIb.js";
+import { createAPI, getVercelAPI } from "./api.js";
+import { builtinModules } from "node:module";
 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 { addEntry, getAllEntries } from "@universal-deploy/store";
+import fs, { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { copyFile, cp, rmdir, unlink } from "node:fs/promises";
+import { findRoot } from "@manypkg/find-root";
+import { nodeFileTrace, resolve } from "@vercel/nft";
+import { transform } from "oxc-transform";
+import { build } from "rolldown";
 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/buildEnvs.ts
+function getBuildEnvNames(pluginConfig) {
+	return {
+		client: pluginConfig.viteEnvNames?.client ?? "vercel_client",
+		edge: pluginConfig.viteEnvNames?.edge ?? "vercel_edge",
+		node: pluginConfig.viteEnvNames?.node ?? "vercel_node"
+	};
+}
+
+//#endregion
 //#region src/utils/dedupeRoutes.ts
 /**
 * When multiple entries point to the same module, we can deploy them as a single function.
@@ -24,20 +38,65 @@ import { getTransformedRoutes, mergeRoutes, normalizeRoutes } from "@vercel/rout
 */
 function dedupeRoutes() {
 	const entriesToKeep = [];
-	const entriesGroupedByModuleId = groupBy(store.entries, (e) => e.id);
+	const entriesGroupedByModuleId = groupBy(getAllEntries(), (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];
+			if (!Array.isArray(entry.route)) entry.route = [entry.route];
 			entriesToKeep.push(entry);
 		} else if (!groupedEntry) {
 			groupedEntry = structuredClone(entry);
-			if (!Array.isArray(groupedEntry.pattern)) groupedEntry.pattern = [groupedEntry.pattern];
+			if (!Array.isArray(groupedEntry.route)) groupedEntry.route = [groupedEntry.route];
 			entriesToKeep.push(groupedEntry);
-		} else groupedEntry.pattern.push(...[entry.pattern].flat());
+		} else groupedEntry.route.push(...[entry.route].flat());
 	}
 	return entriesToKeep;
 }
+/**
+* Sorts routes by specificity.
+*
+* Specificity rules:
+* 1. Segment type priority at each position: Static > Dynamic/Param > Catch-all.
+* 2. Total route length: Longer routes are generally more specific.
+* 3. Prefix match exception: A shorter static route is more specific than a longer route
+*    that only adds a catch-all segment to the same prefix.
+* 4. Alphabetical order: Final tie-breaker for static segments at the same position.
+*
+* @param routes - Array of routes to sort.
+* @returns A new array of routes sorted from most specific to least specific.
+*/
+function sortRoutes(routes) {
+	return [...routes].sort((a, b) => {
+		const lenA = a.pathname.length;
+		const lenB = b.pathname.length;
+		const commonLen = Math.min(lenA, lenB);
+		for (let i = 0; i < commonLen; i++) {
+			const segA = a.pathname[i];
+			const segB = b.pathname[i];
+			if (segA.value && !segB.value) return -1;
+			if (!segA.value && segB.value) return 1;
+			if (segA.value && segB.value) {
+				if (segA.value !== segB.value) {
+					if (lenA !== lenB) return lenB - lenA;
+					return segA.value.localeCompare(segB.value);
+				}
+			}
+			if (!segA.optional && segB.optional) return -1;
+			if (segA.optional && !segB.optional) return 1;
+			if (segA.catchAll && segB.catchAll) {
+				if (!segA.catchAll.greedy && segB.catchAll.greedy) return -1;
+				if (segA.catchAll.greedy && !segB.catchAll.greedy) return 1;
+			}
+			if (segA.catchAll && !segB.catchAll) return 1;
+			if (!segA.catchAll && segB.catchAll) return -1;
+		}
+		if (lenA !== lenB) {
+			if (lenA > lenB) return a.pathname[lenB].catchAll ? 1 : -1;
+			return b.pathname[lenA].catchAll ? -1 : 1;
+		}
+		return 0;
+	});
+}
 function groupBy(list, fn, selector) {
 	return Array.from(list).reduce((acc, curr) => {
 		const key = fn(curr);
@@ -56,8 +115,36 @@ function removeExtension$1(subject) {
 
 //#endregion
 //#region src/utils/destination.ts
+function parseViteId(id) {
+	const [path, query] = id.split("?");
+	return {
+		path: decodeURIComponent(path),
+		query
+	};
+}
+function extractBestPath({ path, query }) {
+	if (!query) return path;
+	return query.split("&").map(decodeURIComponent).find((p) => p.includes("/")) || path;
+}
+function shortenPath(path, maxSegments = 2) {
+	return removeExtension$1(path.split(/[\\/]/).filter(Boolean).slice(-maxSegments).join("_"));
+}
+function mapPath(path, maxSegments = 2) {
+	const nodeModuleMatch = path.match(/node_modules[\\/](.+?)([\\/].*)?$/);
+	if (nodeModuleMatch) return `${nodeModuleMatch[1].split(/[\\/]/)[0]}_${removeExtension$1(nodeModuleMatch[2]?.split(/[\\/]/).pop() || "index")}`;
+	return shortenPath(path, maxSegments);
+}
+function hashString(str, length = 6) {
+	let hash = 5381;
+	for (let i = 0; i < str.length; i++) hash = hash * 33 ^ str.charCodeAt(i);
+	hash = hash >>> 0;
+	return hash.toString(36).slice(0, length);
+}
+function uniqueViteName(id, entry, maxSegments = 2) {
+	return removeExtension$1(`${mapPath(extractBestPath(parseViteId(id)), maxSegments)}_${hashString(JSON.stringify(entry))}`.replace(/[^a-zA-Z0-9\-_[\]/]/g, "-"));
+}
 function entryDestinationDefault(root, entry) {
-	return `${removeExtension$1(pathRelativeTo$1(entry.id, root)).replace(/[^a-zA-Z0-9\-_[\]/]/g, "-")}`;
+	return uniqueViteName(pathRelativeTo$1(entry.id, root), entry);
 }
 function entryDestination(root, entry, postfix) {
 	return `${path.posix.join("functions/", entryDestinationDefault(root, entry))}${postfix}`;
@@ -66,6 +153,7 @@ function entryDestination(root, entry, postfix) {
 //#endregion
 //#region src/plugins/api.ts
 function apiPlugin(pluginConfig) {
+	const envNames = getBuildEnvNames(pluginConfig);
 	const outfiles = [];
 	return {
 		name: "vite-plugin-vercel:api",
@@ -73,12 +161,12 @@ function apiPlugin(pluginConfig) {
 			return createAPI(outfiles, pluginConfig);
 		},
 		applyToEnvironment({ name }) {
-			return name === "vercel_edge" || name === "vercel_node";
+			return name === envNames.edge || name === envNames.node;
 		},
-		writeBundle(_opts, bundle$1) {
+		writeBundle(_opts, bundle) {
 			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({
+			for (const [key, value] of Object.entries(bundle)) if (value.type === "chunk" && entryMapByDestination.has(removeExtension$1(key))) outfiles.push({
 				type: "chunk",
 				root: this.environment.config.root,
 				outdir: this.environment.config.build.outDir,
@@ -96,6 +184,17 @@ function apiPlugin(pluginConfig) {
 	};
 }
 
+//#endregion
+//#region src/utils/edge.ts
+const edgeConditions = [
+	"edge-light",
+	"worker",
+	"browser",
+	"module",
+	"import",
+	"default"
+];
+
 //#endregion
 //#region src/utils/external.ts
 const _external = [
@@ -108,8 +207,193 @@ const _external = [
 const edgeExternal = [..._external, ..._external.map((e) => `node:${e}`)];
 
 //#endregion
-//#region src/plugins/bundle.ts
-function bundlePlugin() {
+//#region src/plugins/bundle/basic.ts
+const builtIns = new Set(builtinModules.flatMap((m) => [m, `node:${m}`]));
+const edgeWasmPlugin = {
+	name: "edge-wasm-vercel",
+	resolveId: {
+		filter: { id: [/\.wasm\?module$/] },
+		handler(id) {
+			return {
+				id: id.replace(/\.wasm\?module$/, ".wasm"),
+				external: true
+			};
+		}
+	}
+};
+const dynamicNativeImportPlugin = {
+	name: "edge-dynamic-import-native",
+	resolveDynamicImport(specifier) {
+		if (typeof specifier === "string" && builtIns.has(specifier)) return {
+			id: specifier,
+			external: true
+		};
+	}
+};
+const reactEdgePlugin$1 = {
+	name: "react-edge-plugin",
+	resolveId: {
+		filter: { id: [/react-dom\/server/] },
+		async handler(_id, importer, options) {
+			return this.resolve("react-dom/server.edge", importer, options);
+		}
+	}
+};
+function basicBundlePlugin(pluginConfig) {
+	const envNames = getBuildEnvNames(pluginConfig);
+	const bundledAssets = /* @__PURE__ */ new Map();
+	const bundledChunks = [];
+	return [{
+		name: "vite-plugin-vercel:bundle",
+		enforce: "post",
+		apply: "build",
+		generateBundle(_opts, bundle) {
+			for (const b of Object.values(bundle)) {
+				const outFile = joinAbsolute(this.environment, this.environment.config.build.outDir, b.fileName);
+				if (b.type === "asset") {
+					const originalFileNames = b.originalFileNames.map((relativePath) => path.resolve(this.environment.config.root, relativePath));
+					const asset = {
+						env: this.environment.name,
+						root: this.environment.config.root,
+						outDir: this.environment.config.build.outDir,
+						outFile,
+						fileName: b.fileName
+					};
+					for (const originalFileName of originalFileNames) bundledAssets.set(originalFileName, asset);
+				} else if (this.environment.name === envNames.edge || this.environment.name === envNames.node) bundledChunks.push(outFile);
+			}
+		},
+		closeBundle: {
+			order: "post",
+			async handler() {
+				if (!isVercelLastBuildStep(this.environment, pluginConfig)) return;
+				this.environment.logger.info("Creating Vercel bundles...");
+				const outfiles = getVercelAPI(this).getOutFiles();
+				const filesToKeepP = [];
+				for (const outfile of outfiles) if (outfile.type === "chunk") filesToKeepP.push(bundle$1(this, bundledAssets, outfile));
+				await cleanup$1((await Promise.all(filesToKeepP)).flat(), bundledChunks);
+			}
+		},
+		sharedDuringBuild: true
+	}];
+}
+function getAbsoluteOutFile(outfile) {
+	const source = joinAbsolutePosix(outfile.root, outfile.outdir, outfile.filepath);
+	return {
+		source,
+		destination: source.replace(outfile.outdir, outfile.outdir)
+	};
+}
+async function bundle$1(pluginContext, bundledAssets, outfile) {
+	const output = [];
+	const { source, destination } = getAbsoluteOutFile(outfile);
+	const isEdge = Boolean(outfile.relatedEntry.vercel?.edge);
+	const { environment } = pluginContext;
+	const buildOptions = {};
+	buildOptions.output = {
+		format: "esm",
+		legalComments: "none",
+		codeSplitting: false
+	};
+	buildOptions.checks = { pluginTimings: false };
+	buildOptions.input = [source];
+	buildOptions.treeshake = true;
+	buildOptions.resolve ??= {};
+	if (isEdge) {
+		buildOptions.platform = "browser";
+		buildOptions.external = edgeExternal;
+		buildOptions.resolve.conditionNames = edgeConditions;
+		buildOptions.transform = { define: { "process.env.NODE_ENV": JSON.stringify("production") } };
+		buildOptions.output.file = destination.replace(/\.mjs$/, ".js");
+		buildOptions.plugins = [
+			edgeWasmPlugin,
+			dynamicNativeImportPlugin,
+			reactEdgePlugin$1
+		];
+	} else {
+		buildOptions.platform = "node";
+		buildOptions.output.file = destination.replace(/\.js$/, ".mjs");
+	}
+	try {
+		await build(buildOptions);
+		output.push(buildOptions.output.file);
+	} catch (e) {
+		throw new Error(`Error while bundling ${destination}`, { cause: e });
+	}
+	let base = environment.config.root;
+	try {
+		base = (await findRoot(environment.config.root)).rootDir;
+	} catch (_e) {}
+	const resolvedEntryP = pluginContext.resolve(outfile.relatedEntry.id);
+	const entryFilePath = existsSync(outfile.relatedEntry.id) ? outfile.relatedEntry.id : (await resolvedEntryP)?.id && existsSync((await resolvedEntryP).id) ? (await resolvedEntryP).id : null;
+	if (entryFilePath === null) return [];
+	const { fileList, reasons } = await nodeFileTrace([entryFilePath], {
+		base,
+		processCwd: environment.config.root,
+		mixedModules: true,
+		ignore: [
+			"**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js",
+			"**/*.d.ts",
+			"**/*.map",
+			"**/node_modules/webpack5/**/*"
+		],
+		async readFile(filepath) {
+			const code = readFileSync(filepath, "utf-8");
+			if (filepath.endsWith(".ts") || filepath.endsWith(".tsx")) return (await transform(filepath, code, { target: "es2022" })).code;
+			return code;
+		}
+	});
+	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 = path.join(base, file);
+		const assetRenamedByVite = bundledAssets.get(absolutePath);
+		const basename = path.basename(assetRenamedByVite ? assetRenamedByVite.fileName : absolutePath);
+		if (assetRenamedByVite) writeFileSync(destination, readFileSync(destination, "utf-8").replaceAll(`/${assetRenamedByVite.fileName}`, `./${path.basename(assetRenamedByVite.fileName)}`));
+		const to = path.join(path.dirname(destination), basename);
+		output.push(to);
+		await copyFile(absolutePath, to);
+	}
+	return output;
+}
+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);
+}
+function isVercelLastBuildStep(env, pluginConfig) {
+	const envNames = getBuildEnvNames(pluginConfig);
+	return (typeof env !== "string" ? env.name : env) === envNames.node;
+}
+async function cleanup$1(filesToKeep, bundledChunks) {
+	const toKeep = new Set(filesToKeep);
+	const removedFiles = [];
+	await Promise.all(bundledChunks.map(async (file) => {
+		if (!toKeep.has(file)) try {
+			await unlink(file);
+			removedFiles.push(file);
+		} catch {}
+	}));
+	const dirsToRemove = /* @__PURE__ */ new Set();
+	for (const file of removedFiles) {
+		let dir = path.dirname(file);
+		while (dir && dir !== "." && dir !== "/" && !toKeep.has(dir)) {
+			dirsToRemove.add(dir);
+			dir = path.dirname(dir);
+		}
+	}
+	const sortedDirs = Array.from(dirsToRemove).sort((a, b) => b.length - a.length);
+	for (const dir of sortedDirs) try {
+		await rmdir(dir);
+	} catch {}
+}
+
+//#endregion
+//#region src/plugins/bundle/nf3.ts
+function nf3BundlePlugin(pluginConfig) {
+	console.warn("[vite-plugin-vercel] bundleStrategy 'nf3' is highly experimental. Use at your own risk; support is not provided for related issues.");
+	const envNames = getBuildEnvNames(pluginConfig);
 	const externalsPlugin = externals({});
 	delete externalsPlugin.buildEnd;
 	let buildOutput;
@@ -125,24 +409,31 @@ function bundlePlugin() {
 			return env.config.consumer !== "client";
 		},
 		async writeBundle(_, output) {
-			const isEdge = this.environment.name === "vercel_edge";
+			const isEdge = this.environment.name === envNames.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 outDir = 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)
+				outPath: path.join(outDir, e[1].fileName)
 			}));
-			assert(entries.length > 0, "No entry files found in build output");
+			if (entries.length === 0) return;
 			const outPaths = entries.map((entry) => entry.outPath);
-			const input = Object.fromEntries(outPaths.map((e) => [removeExtension(pathRelativeTo(e, outDir$1)), e]));
+			const input = Object.fromEntries(outPaths.map((e) => [removeExtension(pathRelativeTo(e, outDir)), e]));
 			const limit = pLimit(Math.max(1, Math.ceil(cpus().length / 2)));
+			const nonVitePlugins = this.environment.config.plugins.filter((p) => {
+				return !p.name.startsWith("vite:") && p.name !== "alias" && p.name !== "commonjs" && p.name !== "nitro:externals";
+			}).map((x) => {
+				const { buildStart, buildEnd, writeBundle, generateBundle, ...rest } = x;
+				return rest;
+			});
 			const localOutput = (await Promise.all(Object.values(input).map((entryPath) => limit(async () => {
-				const outDir$2 = path.dirname(entryPath);
+				const outDir = path.dirname(entryPath);
 				return { output: (await bundle({
+					plugins: nonVitePlugins,
 					isEdge,
 					input: { index: entryPath },
-					outDir: outDir$2,
+					outDir,
 					externals: {
 						conditions: this.environment.config.resolve.conditions,
 						rootDir: this.environment.config.root,
@@ -155,7 +446,7 @@ function bundlePlugin() {
 					}
 				})).output.map((o) => ({
 					...o,
-					fileName: path.join(outDir$2, o.fileName)
+					fileName: path.join(outDir, o.fileName)
 				})) };
 			})))).flatMap((r) => r.output);
 			buildOutput = buildOutput ? [...buildOutput, ...localOutput] : localOutput;
@@ -169,7 +460,7 @@ function bundle(options) {
 		platform: options.isEdge ? "browser" : "node",
 		external: options.isEdge ? edgeExternal : [],
 		write: true,
-		plugins: [externals(options.externals)],
+		plugins: [...options.plugins, externals(options.externals)],
 		input: options.input,
 		resolve: { conditionNames: options.externals.conditions },
 		output: {
@@ -208,12 +499,13 @@ function removeExtension(subject) {
 //#region src/plugins/clean-outdir.ts
 function vercelCleanupPlugin(pluginConfig) {
 	let alreadyRun = false;
+	const envNames = getBuildEnvNames(pluginConfig);
 	return {
 		apply: "build",
 		name: "vite-plugin-vercel:cleanup",
 		enforce: "pre",
 		applyToEnvironment(env) {
-			return env.name === "vercel_client";
+			return env.name === envNames.client;
 		},
 		buildStart: {
 			order: "pre",
@@ -251,10 +543,37 @@ function getVcConfig(pluginConfig, filename, options) {
 	});
 }
 
+//#endregion
+//#region src/utils/request.ts
+function getOriginalRequest(request) {
+	const xNowRouteMatchesHeader = request.headers.get("x-now-route-matches");
+	let newUrl = null;
+	let newRequest = request;
+	if (typeof xNowRouteMatchesHeader === "string") {
+		const originalPathBis = new URLSearchParams(xNowRouteMatchesHeader).get("1");
+		if (originalPathBis) newUrl = new URL(originalPathBis, request.url).toString();
+	}
+	if (newUrl) newRequest = new Request(newUrl, {
+		method: request.method,
+		headers: request.headers,
+		body: request.body,
+		mode: request.mode,
+		credentials: request.credentials,
+		cache: request.cache,
+		redirect: request.redirect,
+		referrer: request.referrer,
+		integrity: request.integrity
+	});
+	return newRequest;
+}
+
 //#endregion
 //#region src/plugins/loader.ts
-const re_DUMMY = /* @__PURE__ */ new RegExp(`__DUMMY__$`);
+const re_DUMMY = new RegExp(`__DUMMY__$`);
+const re_edge = /[?&]vercel_edge\b/;
+const re_node = /[?&]vercel_node\b/;
 function loaderPlugin(pluginConfig) {
+	const envNames = getBuildEnvNames(pluginConfig);
 	let root;
 	return [
 		{
@@ -277,19 +596,57 @@ function loaderPlugin(pluginConfig) {
 			name: "vite-plugin-vercel:load-edge",
 			apply: "build",
 			resolveId: {
-				filter: { id: [/\?edge$/] },
+				filter: { id: re_edge },
+				async handler(id, importer, opts) {
+					const resolved = await this.resolve(id.replace(re_edge, ""), importer, opts);
+					if (!resolved) return null;
+					return `${resolved.id}?vercel_edge`;
+				}
+			},
+			load: {
+				filter: { id: re_edge },
+				async handler(id) {
+					const mod = id.replace(re_edge, "");
+					return `import mod from ${JSON.stringify(mod)};
+
+${getOriginalRequest.toString()}
+
+const fn = (r) => {
+  return mod.fetch(getOriginalRequest(r));
+};
+
+export default fn`;
+				}
+			}
+		},
+		{
+			name: "vite-plugin-vercel:load-node",
+			apply: "build",
+			resolveId: {
+				filter: { id: re_node },
 				async handler(id, importer, opts) {
-					const resolved = await this.resolve(id.replace(/\?edge$/, ""), importer, opts);
+					const resolved = await this.resolve(id.replace(re_node, ""), importer, opts);
 					if (!resolved) return null;
-					return `${resolved.id}?edge`;
+					return `${resolved.id}?vercel_node`;
 				}
 			},
 			load: {
-				filter: { id: [/\?edge$/] },
+				filter: { id: re_node },
 				async handler(id) {
-					const mod = id.replace(/\?edge$/, "");
+					const mod = id.replace(re_node, "");
 					return `import mod from ${JSON.stringify(mod)};
-const def = mod.fetch;
+
+${getOriginalRequest.toString()}
+
+if (mod?.fetch) {
+  const ori = mod.fetch;
+  mod.fetch = (r) => {
+    return ori(getOriginalRequest(r));
+  }
+}
+
+const def = mod?.server?.nodeHandler ?? mod;
+
 export default def;`;
 				}
 			}
@@ -298,7 +655,7 @@ export default def;`;
 			name: "vite-plugin-vercel:build-functions",
 			apply: "build",
 			applyToEnvironment(env) {
-				return env.name === "vercel_node" || env.name === "vercel_edge";
+				return env.name === envNames.node || env.name === envNames.edge;
 			},
 			config: {
 				order: "post",
@@ -309,28 +666,30 @@ export default def;`;
 			configEnvironment: {
 				order: "post",
 				handler(name) {
-					const isEdge = name === "vercel_edge";
-					if (name === "vercel_node" || isEdge) {
+					const isEdge = name === envNames.edge;
+					if (name === envNames.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 }
+							input: Object.fromEntries(entries.map((e) => [entryDestination(root ?? process.cwd(), e, ".func/index"), isEdge ? `${e.id}?vercel_edge` : `${e.id}?vercel_node`])),
+							output: {
+								hoistTransitiveImports: false,
+								entryFileNames: "[name].js"
+							}
 						} } };
 					}
 				}
 			},
 			async buildStart() {
-				const isEdge = this.environment.name === "vercel_edge";
+				const isEdge = this.environment.name === envNames.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", {
+						source: JSON.stringify(getVcConfig(pluginConfig, isEdge ? "index.js" : "index.mjs", {
 							nodeVersion,
-							edge: isEdge$1,
+							edge: isEdge,
 							streaming: entry.vercel?.streaming
 						}), void 0, 2)
 					});
@@ -340,8 +699,8 @@ export default def;`;
 						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));
+					for (const ir of sortRoutes([entry.route].flat().map((p) => fromRou3(p)))) {
+						const source = toPathToRegexpV6(ir);
 						pluginConfig.rewrites.push({
 							enforce: entry.vercel?.enforce,
 							source,
@@ -367,11 +726,12 @@ export default def;`;
 
 //#endregion
 //#region src/plugins/react-edge.ts
-function reactEdgePlugin() {
+function reactEdgePlugin(pluginConfig) {
+	const envNames = getBuildEnvNames(pluginConfig);
 	return {
 		name: "vite-plugin-vercel:react-edge",
 		applyToEnvironment(env) {
-			return env.name === "vercel_edge";
+			return env.name === envNames.edge;
 		},
 		resolveId: {
 			order: "pre",
@@ -397,7 +757,10 @@ function getConfig(pluginConfig) {
 	const { routes, error } = getTransformedRoutes({
 		cleanUrls: pluginConfig.cleanUrls ?? true,
 		trailingSlash: pluginConfig.trailingSlash,
-		rewrites: reorderEnforce(_rewrites),
+		rewrites: reorderEnforce(_rewrites.map((r) => {
+			if (r.source === "/:_1*") r.source = "(.*)";
+			return r;
+		})),
 		redirects: pluginConfig.redirects ? reorderEnforce(pluginConfig.redirects) : void 0,
 		headers: pluginConfig.headers
 	});
@@ -423,6 +786,7 @@ function getConfig(pluginConfig) {
 			routes: buildRoutes
 		}]
 	});
+	for (const route of cleanRoutes) wrapRouteInParentheses(route);
 	return vercelOutputConfigSchema.parse({
 		version: 3,
 		...pluginConfig.config,
@@ -430,74 +794,73 @@ function getConfig(pluginConfig) {
 		overrides: { ...pluginConfig.config?.overrides }
 	});
 }
+function wrapRouteInParentheses(route) {
+	if (!route.src || !route.dest || route.src.match(/^\(.*\)$/) || route.src.match(/^\^\(.*\)\$$/)) return;
+	route.src = `(${route.src})`;
+}
 
 //#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) {
+	const envNames = getBuildEnvNames(pluginConfig);
 	return [
 		{
 			name: "vite-plugin-vercel:setup-envs",
 			buildApp: {
 				order: "post",
 				async handler(builder) {
-					try {
-						await builder.build(builder.environments.vercel_client);
+					if (!builder.environments[envNames.client].isBuilt) try {
+						await builder.build(builder.environments[envNames.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);
+					if (envNames.edge !== false && !builder.environments[envNames.edge].isBuilt) await builder.build(builder.environments[envNames.edge]);
+					if (!builder.environments[envNames.node].isBuilt) await builder.build(builder.environments[envNames.node]);
 				}
 			},
-			config() {
-				if (!injected) {
-					injected = true;
-					if (pluginConfig.entries) store.entries.push(...pluginConfig.entries);
+			config: {
+				order: "post",
+				handler() {
+					if (!injected) {
+						injected = true;
+						if (pluginConfig.entries) pluginConfig.entries.forEach((entry) => {
+							addEntry(entry);
+						});
+					}
+					const outDirOverride = pluginConfig.outDir ? { build: { outDir: pluginConfig.outDir } } : {};
+					const environments = {};
+					if (envNames.client) environments[envNames.client] = {
+						build: {
+							outDir: path.join(pluginConfig.outDir ?? outDir, "static"),
+							copyPublicDir: true,
+							rollupOptions: { input: getDummyInput() }
+						},
+						consumer: "client"
+					};
+					if (envNames.edge) environments[envNames.edge] = createVercelEnvironmentOptions(outDirOverride);
+					if (envNames.node) environments[envNames.node] = createVercelEnvironmentOptions(outDirOverride);
+					return {
+						environments,
+						builder: {}
+					};
 				}
-				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";
+				return env.name === envNames.edge;
 			},
 			configEnvironment(name, config, env) {
-				if (name !== "vercel_edge") return;
+				if (name !== envNames.edge) return;
 				return {
 					resolve: {
 						external: edgeExternal,
@@ -524,8 +887,8 @@ function setupEnvs(pluginConfig) {
 			},
 			generateBundle: {
 				order: "post",
-				async handler(_opts, bundle$1) {
-					cleanupDummy(bundle$1);
+				async handler(_opts, bundle) {
+					cleanupDummy(bundle);
 				}
 			},
 			sharedDuringBuild: true
@@ -533,16 +896,16 @@ function setupEnvs(pluginConfig) {
 		{
 			name: "vite-plugin-vercel:setup-envs:vercel_node",
 			applyToEnvironment(env) {
-				return env.name === "vercel_node";
+				return env.name === envNames.node;
 			},
 			configEnvironment(name, config) {
-				if (name !== "vercel_node") return;
+				if (name !== envNames.node) return;
 				return { optimizeDeps: { ...config.optimizeDeps } };
 			},
 			generateBundle: {
 				order: "post",
-				async handler(_opts, bundle$1) {
-					cleanupDummy(bundle$1);
+				async handler(_opts, bundle) {
+					cleanupDummy(bundle);
 					this.emitFile({
 						type: "asset",
 						fileName: "config.json",
@@ -555,10 +918,10 @@ function setupEnvs(pluginConfig) {
 		{
 			name: "vite-plugin-vercel:setup-envs:vercel_client",
 			applyToEnvironment(env) {
-				return env.name === "vercel_client";
+				return env.name === envNames.client;
 			},
-			generateBundle: { async handler(_opts, bundle$1) {
-				cleanupDummy(bundle$1);
+			generateBundle: { async handler(_opts, bundle) {
+				cleanupDummy(bundle);
 				const topLevelConfig = this.environment.getTopLevelConfig();
 				const clientEnv = topLevelConfig.environments.client;
 				if (clientEnv) try {
@@ -589,7 +952,9 @@ function createVercelEnvironmentOptions(overrides) {
 			rollupOptions: {
 				input: getDummyInput(),
 				output: {
-					sanitizeFileName: false,
+					sanitizeFileName: (filename) => {
+						return filename.replace("\0", "_");
+					},
 					sourcemap: false
 				}
 			},
@@ -604,26 +969,25 @@ function createVercelEnvironmentOptions(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];
+function cleanupDummy(bundle) {
+	const dummy = Object.keys(bundle).find((key) => key.includes("_DUMMY_"));
+	if (dummy) delete bundle[dummy];
 }
 
 //#endregion
 //#region src/plugins/index.ts
 function vercel(pluginConfig = {}) {
 	return [
-		reactEdgePlugin(),
-		vercelCleanupPlugin(),
+		reactEdgePlugin(pluginConfig),
+		vercelCleanupPlugin(pluginConfig),
 		apiPlugin(pluginConfig),
 		...setupEnvs(pluginConfig),
 		...loaderPlugin(pluginConfig),
-		...bundlePlugin(),
+		...pluginConfig?.bundleStrategy === "nf3" ? nf3BundlePlugin(pluginConfig) : basicBundlePlugin(pluginConfig),
 		catchAll(),
 		devServer()
 	];
 }
-var plugins_default = vercel;
 
 //#endregion
-export { plugins_default as default, vercel };
+export { vercel as default, vercel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-vercel",
-  "version": "11.0.0-beta.2",
+  "version": "11.0.0-beta.20",
   "type": "module",
   "files": [
     "dist",
@@ -26,29 +26,30 @@
     "@types/node": "^22.19.3",
     "@universal-middleware/express": "^0.4.22",
     "@vercel/node": "^5.5.15",
-    "tsdown": "^0.18.4",
+    "tsdown": "^0.20.3",
     "typescript": "^5.9.3",
     "vite": "^7.2.4",
     "vitest": "^4.0.16"
   },
   "dependencies": {
     "@manypkg/find-root": "^3.1.0",
-    "@universal-deploy/store": "^0.0.2",
+    "@universal-deploy/store": "^0.1.3",
     "@universal-middleware/core": "^0.4.13",
     "@universal-middleware/vercel": "^0.4.29",
     "@vercel/build-utils": "^13.2.3",
-    "@vercel/nft": "^1.1.1",
+    "@vercel/nft": "^1.2.0",
     "@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",
+    "nf3": "^0.3.4",
+    "oxc-transform": "^0.108.0",
     "p-limit": "^7.2.0",
     "path-to-regexp": "^8.3.0",
-    "rolldown": "^1.0.0-beta.58",
+    "rolldown": "^1.0.0-rc.4",
     "strip-ansi": "^7.1.2",
-    "vite-plugin-wasm": "^3.5.0"
+    "vite-plugin-wasm": "^3.5.0",
+    "@vite-plugin-vercel/schemas": "^1.0.0"
   },
   "scripts": {
     "dev": "tsdown --watch",

package/dist/api-DR2y7JVQ.js

@@ -1,70 +0,0 @@
-//#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 };