@vercel/backends 0.0.26 → 0.0.28

package/dist/introspection/express.mjs

@@ -1,7 +1,7 @@
 import { pathToRegexp } from "path-to-regexp";
 import { debug } from "@vercel/build-utils";
 
-//#region src/introspection/util.ts
+//#region src/rolldown/util.ts
 const BEGIN_INTROSPECTION_RESULT = "\n__VERCEL_INTROSPECTION_BEGIN__\n";
 const END_INTROSPECTION_RESULT = "\n__VERCEL_INTROSPECTION_END__\n";
 const setupCloseHandlers = (cb) => {
@@ -33,7 +33,6 @@ const handle = (expressModule) => {
 setupCloseHandlers(() => {
 	const { routes, additionalFolders, additionalDeps } = extractRoutes();
 	if (routes.length > 0) return {
-		frameworkSlug: "express",
 		routes,
 		additionalFolders,
 		additionalDeps

package/dist/introspection/hono.mjs

@@ -1,7 +1,7 @@
 import { pathToRegexp } from "path-to-regexp";
 import { debug } from "@vercel/build-utils";
 
-//#region src/introspection/util.ts
+//#region src/rolldown/util.ts
 const BEGIN_INTROSPECTION_RESULT = "\n__VERCEL_INTROSPECTION_BEGIN__\n";
 const END_INTROSPECTION_RESULT = "\n__VERCEL_INTROSPECTION_END__\n";
 const setupCloseHandlers = (cb) => {
@@ -28,10 +28,7 @@ const handle = (honoModule) => {
 };
 setupCloseHandlers(() => {
 	const routes = extractRoutes();
-	if (routes.length > 0) return {
-		frameworkSlug: "hono",
-		routes
-	};
+	if (routes.length > 0) return { routes };
 });
 function extractRoutes() {
 	const app = apps.sort((a, b) => b.routes.length - a.routes.length)[0];

package/dist/introspection/loaders/cjs.cjs

@@ -26,7 +26,7 @@ module$1 = __toESM(module$1);
 let path_to_regexp = require("path-to-regexp");
 let __vercel_build_utils = require("@vercel/build-utils");
 
-//#region src/introspection/util.ts
+//#region src/rolldown/util.ts
 const BEGIN_INTROSPECTION_RESULT = "\n__VERCEL_INTROSPECTION_BEGIN__\n";
 const END_INTROSPECTION_RESULT = "\n__VERCEL_INTROSPECTION_END__\n";
 const setupCloseHandlers = (cb) => {
@@ -53,10 +53,7 @@ const handle = (honoModule) => {
 };
 setupCloseHandlers(() => {
 	const routes = extractRoutes$1();
-	if (routes.length > 0) return {
-		frameworkSlug: "hono",
-		routes
-	};
+	if (routes.length > 0) return { routes };
 });
 function extractRoutes$1() {
 	const app$1 = apps.sort((a, b) => b.routes.length - a.routes.length)[0];
@@ -99,7 +96,6 @@ const handle$1 = (expressModule) => {
 setupCloseHandlers(() => {
 	const { routes, additionalFolders, additionalDeps } = extractRoutes();
 	if (routes.length > 0) return {
-		frameworkSlug: "express",
 		routes,
 		additionalFolders,
 		additionalDeps

package/dist/rolldown/cjs-hooks.cjs

@@ -0,0 +1,208 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_module = require("node:module");
+node_module = __toESM(node_module);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_fs = require("node:fs");
+let path_to_regexp = require("path-to-regexp");
+let __vercel_build_utils = require("@vercel/build-utils");
+
+//#region src/rolldown/util.ts
+const BEGIN_INTROSPECTION_RESULT = "\n__VERCEL_INTROSPECTION_BEGIN__\n";
+const END_INTROSPECTION_RESULT = "\n__VERCEL_INTROSPECTION_END__\n";
+const setupCloseHandlers = (cb) => {
+	const callCallback = () => {
+		const result = cb();
+		if (result) console.log(`${BEGIN_INTROSPECTION_RESULT}${JSON.stringify(result)}${END_INTROSPECTION_RESULT}`);
+	};
+	process.on("SIGINT", callCallback);
+	process.on("SIGTERM", callCallback);
+	process.on("exit", callCallback);
+};
+
+//#endregion
+//#region src/introspection/hono.ts
+const apps = [];
+const handle = (honoModule) => {
+	const TrackedHono = class extends honoModule.Hono {
+		constructor(...args) {
+			super(...args);
+			apps.push(this);
+		}
+	};
+	return TrackedHono;
+};
+setupCloseHandlers(() => {
+	const routes = extractRoutes$1();
+	if (routes.length > 0) return { routes };
+});
+function extractRoutes$1() {
+	const app$1 = apps.sort((a, b) => b.routes.length - a.routes.length)[0];
+	if (!app$1 || !app$1.routes) return [];
+	const routes = [];
+	for (const route of app$1.routes) {
+		const routePath = route.path;
+		const method = route.method.toUpperCase();
+		try {
+			const { regexp } = (0, path_to_regexp.pathToRegexp)(routePath);
+			if (routePath === "/") continue;
+			routes.push({
+				src: regexp.source,
+				dest: routePath,
+				methods: [method]
+			});
+		} catch (e) {
+			(0, __vercel_build_utils.debug)(`Error extracting routes for ${routePath}: ${e instanceof Error ? e.message : "Unknown error"}`);
+		}
+	}
+	return routes;
+}
+
+//#endregion
+//#region src/introspection/express.ts
+let app = null;
+const handle$1 = (expressModule) => {
+	if (typeof expressModule === "function") {
+		const originalCreateApp = expressModule;
+		const createApp = (...args) => {
+			app = originalCreateApp(...args);
+			return app;
+		};
+		Object.setPrototypeOf(createApp, originalCreateApp);
+		Object.assign(createApp, originalCreateApp);
+		return createApp;
+	}
+	return expressModule;
+};
+setupCloseHandlers(() => {
+	const { routes, additionalFolders, additionalDeps } = extractRoutes();
+	if (routes.length > 0) return {
+		routes,
+		additionalFolders,
+		additionalDeps
+	};
+});
+const extractRoutes = () => {
+	if (!app) return {
+		routes: [],
+		additionalFolders: [],
+		additionalDeps: []
+	};
+	const additionalFolders = [];
+	const additionalDeps = [];
+	const routes = [];
+	const methods = [
+		"all",
+		"get",
+		"post",
+		"put",
+		"delete",
+		"patch",
+		"options",
+		"head"
+	];
+	const router = app._router || app.router;
+	if ("settings" in app) {
+		if ("views" in app.settings && typeof app.settings.views === "string") additionalFolders.push(app.settings.views);
+		if ("view engine" in app.settings && typeof app.settings["view engine"] === "string") additionalDeps.push(app.settings["view engine"]);
+	}
+	for (const route of router.stack) if (route.route) {
+		const m = [];
+		for (const method of methods) if (route.route.methods[method]) m.push(method.toUpperCase());
+		try {
+			const { regexp } = (0, path_to_regexp.pathToRegexp)(route.route.path);
+			if (route.route.path === "/") continue;
+			routes.push({
+				src: regexp.source,
+				dest: route.route.path,
+				methods: m
+			});
+		} catch (e) {
+			const message = e instanceof Error ? e.message : "Unknown error";
+			(0, __vercel_build_utils.debug)(`Error extracting routes for ${route.route.path}: ${message}`);
+		}
+	}
+	return {
+		routes,
+		additionalFolders,
+		additionalDeps
+	};
+};
+
+//#endregion
+//#region src/rolldown/cjs-hooks.ts
+/**
+* CJS preload script that intercepts require() calls.
+* - Check tmpDir first for files
+* - Map bare specifiers from tmpDir to repoRootPath
+* - Wrap hono/express modules with instrumentation
+*/
+const repoRootPath = process.env.VERCEL_INTROSPECTION_REPO_ROOT_PATH;
+const tmpDirEnv = process.env.VERCEL_INTROSPECTION_TMP_DIR;
+if (!repoRootPath || !tmpDirEnv) throw new Error("VERCEL_INTROSPECTION_REPO_ROOT_PATH and VERCEL_INTROSPECTION_TMP_DIR must be set");
+const tmpDir = (0, node_fs.realpathSync)(tmpDirEnv);
+const wrappedModules = /* @__PURE__ */ new Map();
+const originalResolveFilename = node_module.default._resolveFilename;
+node_module.default._resolveFilename = function(request, parent, isMain, options) {
+	if (request.startsWith(".") && parent?.filename) {
+		const parentDir = node_path.default.dirname(parent.filename);
+		const resolvedPath = node_path.default.resolve(parentDir, request);
+		if ((0, node_fs.existsSync)(resolvedPath) && (0, node_fs.statSync)(resolvedPath).isFile()) return resolvedPath;
+	}
+	if (!request.startsWith(".") && !request.startsWith("/") && parent?.filename?.startsWith(tmpDir)) {
+		const relativeToTmp = node_path.default.relative(tmpDir, parent.filename);
+		const mappedParentPath = node_path.default.join(repoRootPath, relativeToTmp);
+		const fakeParent = {
+			...parent,
+			filename: mappedParentPath,
+			paths: node_module.default._nodeModulePaths(node_path.default.dirname(mappedParentPath))
+		};
+		return originalResolveFilename.call(this, request, fakeParent, isMain, options);
+	}
+	return originalResolveFilename.call(this, request, parent, isMain, options);
+};
+const originalLoad = node_module.default._load;
+node_module.default._load = function(request, parent, isMain) {
+	const result = originalLoad.call(this, request, parent, isMain);
+	if (request === "hono") {
+		if (wrappedModules.has("hono")) return wrappedModules.get("hono");
+		const TrackedHono = handle(result);
+		const wrapped = {
+			...result,
+			Hono: TrackedHono
+		};
+		wrappedModules.set("hono", wrapped);
+		return wrapped;
+	}
+	if (request === "express") {
+		if (wrappedModules.has("express")) return wrappedModules.get("express");
+		const wrapped = handle$1(result);
+		wrappedModules.set("express", wrapped);
+		return wrapped;
+	}
+	return result;
+};
+
+//#endregion

package/dist/rolldown/cjs-hooks.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/rolldown/esm.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/rolldown/esm.mjs

@@ -0,0 +1,7 @@
+import { register } from "node:module";
+
+//#region src/rolldown/esm.ts
+register(new URL("./hooks.mjs", import.meta.url), import.meta.url);
+
+//#endregion
+export {  };

package/dist/rolldown/hooks.d.mts

@@ -0,0 +1,27 @@
+/// <reference types="node" resolution-mode="require"/>
+//#region src/rolldown/hooks.d.ts
+interface ResolveContext {
+  parentURL?: string;
+  conditions?: string[];
+  importAttributes?: Record<string, string>;
+}
+interface ResolveResult {
+  url: string;
+  shortCircuit?: boolean;
+  format?: string;
+}
+interface LoadContext {
+  format?: string;
+  importAttributes?: Record<string, string>;
+}
+interface LoadResult {
+  format: string;
+  source?: string | Buffer;
+  shortCircuit?: boolean;
+}
+type NextResolve = (specifier: string, context: ResolveContext) => Promise<ResolveResult>;
+type NextLoad = (url: string, context: LoadContext) => Promise<LoadResult>;
+declare function resolve(specifier: string, context: ResolveContext, nextResolve: NextResolve): Promise<ResolveResult>;
+declare function load(url: string, context: LoadContext, nextLoad: NextLoad): Promise<LoadResult>;
+//#endregion
+export { load, resolve };

package/dist/rolldown/hooks.mjs

@@ -0,0 +1,84 @@
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, join, relative } from "node:path";
+import { existsSync, realpathSync, statSync } from "node:fs";
+
+//#region src/rolldown/hooks.ts
+const getRequiredEnv = (key) => {
+	const value = process.env[key];
+	if (!value) throw new Error(`${key} is not set`);
+	return value;
+};
+const repoRootPath = getRequiredEnv("VERCEL_INTROSPECTION_REPO_ROOT_PATH");
+const handlerPath = getRequiredEnv("VERCEL_INTROSPECTION_HANDLER");
+const handlerBuilt = getRequiredEnv("VERCEL_INTROSPECTION_HANDLER_BUILT");
+const tmpDir = realpathSync(getRequiredEnv("VERCEL_INTROSPECTION_TMP_DIR"));
+let honoUrl = null;
+let expressUrl = null;
+async function resolve(specifier, context, nextResolve) {
+	let specifierAsPath = null;
+	try {
+		specifierAsPath = fileURLToPath(specifier);
+	} catch {}
+	if (specifierAsPath === handlerPath) return {
+		url: pathToFileURL(join(tmpDir, handlerBuilt)).href,
+		shortCircuit: true
+	};
+	if (specifier.startsWith(".") && context.parentURL) {
+		const resolvedPath = join(dirname(fileURLToPath(context.parentURL)), specifier);
+		if (existsSync(resolvedPath) && statSync(resolvedPath).isFile()) return {
+			url: pathToFileURL(resolvedPath).href,
+			shortCircuit: true
+		};
+	}
+	if (!specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("file:") && context.parentURL) {
+		const parentPath = fileURLToPath(context.parentURL);
+		if (parentPath.startsWith(tmpDir)) {
+			const mappedParent = join(repoRootPath, relative(tmpDir, parentPath));
+			const result = await nextResolve(specifier, {
+				...context,
+				parentURL: pathToFileURL(mappedParent).href
+			});
+			if (specifier === "hono") honoUrl = result.url;
+			else if (specifier === "express") expressUrl = result.url;
+			return result;
+		}
+	}
+	return nextResolve(specifier, context);
+}
+async function load(url, context, nextLoad) {
+	if (honoUrl === url) {
+		const pathToHonoExtract = new URL("../introspection/hono.mjs", import.meta.url);
+		return {
+			format: "module",
+			source: `
+import { handle } from ${JSON.stringify(pathToHonoExtract.toString())};
+import * as originalHono from ${JSON.stringify(url + "?original")};
+
+export * from ${JSON.stringify(url + "?original")};
+export const Hono = handle(originalHono);
+`,
+			shortCircuit: true
+		};
+	}
+	if (expressUrl === url) {
+		const pathToExpressExtract = new URL("../introspection/express.mjs", import.meta.url);
+		return {
+			format: "module",
+			source: `
+import { handle } from ${JSON.stringify(pathToExpressExtract.toString())};
+import originalExpress from ${JSON.stringify(url + "?original")};
+
+const extendedExpress = handle(originalExpress);
+
+export * from ${JSON.stringify(url + "?original")};
+export default extendedExpress;
+`,
+			shortCircuit: true
+		};
+	}
+	if (url.endsWith("?original")) return nextLoad(url, context);
+	return nextLoad(url, context);
+}
+
+//#endregion
+export { load, resolve };

package/dist/rolldown/index.d.mts

@@ -0,0 +1,16 @@
+import { BuildOptions, Files, Span } from "@vercel/build-utils";
+
+//#region src/rolldown/index.d.ts
+declare const rolldown: (args: Pick<BuildOptions, 'entrypoint' | 'workPath' | 'repoRootPath'> & {
+  span?: Span;
+}) => Promise<{
+  files: Files;
+  handler: string;
+  framework: {
+    slug: string;
+    version: string;
+  };
+  localBuildFiles: Set<string>;
+}>;
+//#endregion
+export { rolldown };