@vercel/backends 0.1.0-canary.20260211174907.cdd2da6 → 0.1.1

package/dist/index.d.mts

@@ -97,9 +97,12 @@ declare const introspectApp: (args: {
   additionalDeps: string[];
 }>;
 //#endregion
+//#region src/diagnostics.d.ts
+declare const diagnostics: _vercel_build_utils0.Diagnostics;
+//#endregion
 //#region src/index.d.ts
 declare const version = 2;
 declare const build: BuildV2;
 declare const prepareCache: PrepareCache;
 //#endregion
-export { type CervelBuildOptions, type CervelServeOptions, type PathOptions, build, build$1 as cervelBuild, serve as cervelServe, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };
+export { type CervelBuildOptions, type CervelServeOptions, type PathOptions, build, build$1 as cervelBuild, serve as cervelServe, diagnostics, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };

package/dist/index.mjs

@@ -1,20 +1,20 @@
 import { builtinModules, createRequire } from "node:module";
-import { delimiter, dirname, extname, join } from "path";
-import { FileBlob, FileFsRef, NodejsLambda, Span, debug, defaultCachePathGlob, download, execCommand, getEnvForPackageManager, getNodeBinPaths, getNodeVersion, glob, isBackendFramework, isBunVersion, isExperimentalBackendsWithoutIntrospectionEnabled, runNpmInstall, runPackageJsonScript, scanParentDirs } from "@vercel/build-utils";
+import path, { delimiter, dirname, join } from "path";
+import { FileBlob, FileFsRef, MANIFEST_VERSION, NodejsLambda, Span, createDiagnostics, debug, defaultCachePathGlob, download, execCommand, getEnvForPackageManager, getLambdaOptionsFromFunction, getNodeBinPaths, getNodeVersion, glob, isBackendFramework, isBunVersion, isExperimentalBackendsWithoutIntrospectionEnabled, runNpmInstall, runPackageJsonScript, scanParentDirs, writeProjectManifest } from "@vercel/build-utils";
+import fs from "fs";
+import yaml from "js-yaml";
+import { parseSyml } from "@yarnpkg/parsers";
 import { createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { lstat, readFile, rm, stat } from "node:fs/promises";
-import { dirname as dirname$1, extname as extname$1, isAbsolute, join as join$1, relative } from "node:path";
+import { basename, dirname as dirname$1, extname, isAbsolute, join as join$1, relative, resolve, sep } from "node:path";
 import { build as build$2 } from "rolldown";
 import { exports } from "resolve.exports";
 import { isNativeError } from "node:util/types";
-import { nodeFileTrace as nodeFileTrace$1, resolve } from "@vercel/nft";
+import { nodeFileTrace as nodeFileTrace$1, resolve as resolve$1 } from "@vercel/nft";
 import { transform } from "oxc-transform";
-import { createRequire as createRequire$1 } from "module";
-import { spawn } from "child_process";
-import { existsSync as existsSync$1 } from "fs";
 import execa from "execa";
 import { readFile as readFile$1, writeFile } from "fs/promises";
-import { spawn as spawn$1 } from "node:child_process";
+import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
 import { z } from "zod";
 
@@ -23,7 +23,7 @@ async function downloadInstallAndBundle(args) {
 	const { entrypoint, files, workPath, meta, config, repoRootPath } = args;
 	await download(files, workPath, meta);
 	const entrypointFsDirname = join(workPath, dirname(entrypoint));
-	const { cliType, lockfileVersion, packageJsonPackageManager, turboSupportsCorepackHome } = await scanParentDirs(entrypointFsDirname, true, repoRootPath);
+	const { cliType, lockfilePath, lockfileVersion, packageJsonPackageManager, turboSupportsCorepackHome } = await scanParentDirs(entrypointFsDirname, true, repoRootPath);
 	const spawnEnv = getEnvForPackageManager({
 		cliType,
 		lockfileVersion,
@@ -43,10 +43,13 @@ async function downloadInstallAndBundle(args) {
 	else await runNpmInstall(entrypointFsDirname, [], { env: spawnEnv }, meta, config.projectSettings?.createdAt);
 	return {
 		entrypointFsDirname,
-		spawnEnv
+		spawnEnv,
+		cliType,
+		lockfilePath,
+		lockfileVersion
 	};
 }
-async function maybeExecBuildCommand(args, { spawnEnv, entrypointFsDirname }) {
+async function maybeExecBuildCommand(args, { spawnEnv }) {
 	const projectBuildCommand = args.config.projectSettings?.buildCommand;
 	if (projectBuildCommand) {
 		const nodeBinPath = getNodeBinPaths({
@@ -61,8 +64,351 @@ async function maybeExecBuildCommand(args, { spawnEnv, entrypointFsDirname }) {
 			cwd: args.workPath
 		});
 	}
-	return runPackageJsonScript(entrypointFsDirname, ["build"], { env: spawnEnv }, args.config.projectSettings?.createdAt);
+	return runPackageJsonScript(args.workPath, ["build"], { env: spawnEnv }, args.config.projectSettings?.createdAt);
+}
+
+//#endregion
+//#region src/diagnostics.ts
+function classifySource(resolvedUrl) {
+	if (!resolvedUrl) return {};
+	if (resolvedUrl.startsWith("file:")) return {
+		source: "file",
+		sourceUrl: resolvedUrl.slice(5)
+	};
+	if (resolvedUrl.startsWith("git+") || resolvedUrl.startsWith("git://")) return {
+		source: "git",
+		sourceUrl: resolvedUrl.replace(/^git\+/, "")
+	};
+	try {
+		return {
+			source: "registry",
+			sourceUrl: new URL(resolvedUrl).origin
+		};
+	} catch {
+		return {};
+	}
+}
+function npmEntryScopes(entry) {
+	const scopes = [];
+	if (entry.dev) scopes.push("dev");
+	if (entry.peer) scopes.push("peer");
+	if (entry.optional) scopes.push("optional");
+	if (scopes.length === 0) scopes.push("prod");
+	return scopes;
+}
+function parseNpmLock(content, lockfileVersion) {
+	const lockMap = /* @__PURE__ */ new Map();
+	const parsed = JSON.parse(content);
+	if ((lockfileVersion ?? parsed.lockfileVersion ?? 1) >= 2) {
+		const packages = parsed.packages;
+		if (!packages) return lockMap;
+		for (const [key, entry] of Object.entries(packages)) {
+			if (key === "") continue;
+			if (!key.startsWith("node_modules/")) continue;
+			if (entry.link === true) continue;
+			const rest = key.slice(13);
+			const isScoped = rest.startsWith("@");
+			const slashCount = (rest.match(/\//g) ?? []).length;
+			if (isScoped ? slashCount !== 1 : slashCount !== 0) continue;
+			const resolved = entry.resolved;
+			if (resolved?.startsWith("file:")) continue;
+			const version$1 = entry.version ?? "";
+			const existing = lockMap.get(rest);
+			if (existing && !isHigherVersion(version$1, existing.resolved)) continue;
+			const { source, sourceUrl } = classifySource(resolved);
+			const lockEntry = {
+				resolved: version$1,
+				scopes: npmEntryScopes(entry)
+			};
+			if (source) lockEntry.source = source;
+			if (sourceUrl) lockEntry.sourceUrl = sourceUrl;
+			lockMap.set(rest, lockEntry);
+		}
+	} else {
+		const dependencies = parsed.dependencies;
+		if (!dependencies) return lockMap;
+		const walk = (deps) => {
+			for (const [name, entry] of Object.entries(deps)) {
+				const resolved = entry.resolved;
+				if (!resolved?.startsWith("file:")) {
+					const version$1 = entry.version ?? "";
+					const existing = lockMap.get(name);
+					if (!existing || isHigherVersion(version$1, existing.resolved)) {
+						const { source, sourceUrl } = classifySource(resolved);
+						const lockEntry = {
+							resolved: version$1,
+							scopes: npmEntryScopes(entry)
+						};
+						if (source) lockEntry.source = source;
+						if (sourceUrl) lockEntry.sourceUrl = sourceUrl;
+						lockMap.set(name, lockEntry);
+					}
+				}
+				const nested = entry.dependencies;
+				if (nested) walk(nested);
+			}
+		};
+		walk(dependencies);
+	}
+	return lockMap;
+}
+function isHigherVersion(a, b) {
+	const seg = (v) => v.split(/[.\-+]/).map((s) => parseInt(s, 10) || 0);
+	const pa = seg(a);
+	const pb = seg(b);
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		if ((pa[i] ?? 0) > (pb[i] ?? 0)) return true;
+		if ((pa[i] ?? 0) < (pb[i] ?? 0)) return false;
+	}
+	return false;
+}
+function extractPackageName(spec) {
+	const s = spec.replace(/\(.*\)$/, "");
+	if (s.startsWith("@")) {
+		const i$1 = s.indexOf("@", 1);
+		return i$1 === -1 ? null : s.slice(0, i$1);
+	}
+	const i = s.lastIndexOf("@");
+	return i <= 0 ? null : s.slice(0, i);
+}
+function parsePnpmV9Key(key) {
+	const name = extractPackageName(key);
+	if (!name) return null;
+	return {
+		name,
+		version: key.replace(/\(.*\)$/, "").slice(name.length + 1)
+	};
+}
+function parsePnpmV5Key(key) {
+	if (!key.startsWith("/")) return null;
+	const rest = key.slice(1);
+	if (rest.startsWith("@")) {
+		const firstSlash = rest.indexOf("/");
+		if (firstSlash === -1) return null;
+		const secondSlash = rest.indexOf("/", firstSlash + 1);
+		if (secondSlash === -1) return null;
+		return {
+			name: rest.slice(0, secondSlash),
+			version: rest.slice(secondSlash + 1).split("_")[0]
+		};
+	}
+	const slashIndex = rest.indexOf("/");
+	if (slashIndex === -1) return null;
+	return {
+		name: rest.slice(0, slashIndex),
+		version: rest.slice(slashIndex + 1).split("_")[0]
+	};
+}
+function parsePnpmV6Key(key) {
+	if (!key.startsWith("/")) return null;
+	const rest = key.slice(1);
+	let atIdx;
+	if (rest.startsWith("@")) atIdx = rest.indexOf("@", 1);
+	else atIdx = rest.indexOf("@");
+	if (atIdx === -1) return null;
+	return {
+		name: rest.slice(0, atIdx),
+		version: rest.slice(atIdx + 1).split("_")[0].replace(/\(.*\)$/, "")
+	};
+}
+function classifyPnpmResolution(resolution) {
+	if (!resolution) return {};
+	if (resolution.type === "directory" || resolution.directory) return { local: true };
+	if (typeof resolution.tarball === "string") return classifySource(resolution.tarball);
+	if (resolution.type === "git" || typeof resolution.repo === "string") return {
+		source: "git",
+		sourceUrl: resolution.repo ?? void 0
+	};
+	return {};
+}
+function parsePnpmLock(content, lockfileVersion) {
+	const lockMap = /* @__PURE__ */ new Map();
+	const docs = [];
+	yaml.safeLoadAll(content, (doc) => docs.push(doc));
+	const parsedYaml = docs[0];
+	if (!parsedYaml) return lockMap;
+	const lv = lockfileVersion ?? Number(parsedYaml.lockfileVersion ?? "0");
+	const packages = parsedYaml.packages;
+	if (!packages) return lockMap;
+	const parseKey = lv >= 9 ? parsePnpmV9Key : lv >= 6 ? parsePnpmV6Key : parsePnpmV5Key;
+	for (const [key, entry] of Object.entries(packages)) {
+		const keyParsed = parseKey(key);
+		if (!keyParsed) continue;
+		const { name, version: version$1 } = keyParsed;
+		const resolution = entry.resolution;
+		const { local, source, sourceUrl } = classifyPnpmResolution(resolution);
+		if (local) continue;
+		const existing = lockMap.get(name);
+		if (existing && !isHigherVersion(version$1, existing.resolved)) continue;
+		const lockEntry = {
+			resolved: version$1,
+			scopes: ["prod"]
+		};
+		if (source) lockEntry.source = source;
+		if (sourceUrl) lockEntry.sourceUrl = sourceUrl;
+		lockMap.set(name, lockEntry);
+	}
+	return lockMap;
+}
+function parseYarnLock(content, lockfileVersion) {
+	const lockMap = /* @__PURE__ */ new Map();
+	const isBerry = (lockfileVersion ?? 1) >= 2;
+	const parsed = parseSyml(content);
+	for (const [key, entry] of Object.entries(parsed)) {
+		if (key === "__metadata" || !entry) continue;
+		if (isBerry && entry.linkType === "soft") continue;
+		const version$1 = entry.version;
+		if (!version$1) continue;
+		let source;
+		let sourceUrl;
+		if (!isBerry && entry.resolved) {
+			if (entry.resolved.startsWith("file:")) continue;
+			const classified = classifySource(entry.resolved);
+			source = classified.source;
+			sourceUrl = classified.sourceUrl;
+		}
+		const specifiers = key.split(",").map((s) => s.trim().replace(/^"|"$/g, ""));
+		let name = null;
+		for (const spec of specifiers) {
+			name = extractPackageName(spec);
+			if (name) break;
+		}
+		if (!name) continue;
+		const existing = lockMap.get(name);
+		if (existing && !isHigherVersion(version$1, existing.resolved)) continue;
+		const lockEntry = {
+			resolved: version$1,
+			scopes: ["prod"]
+		};
+		if (source) lockEntry.source = source;
+		if (sourceUrl) lockEntry.sourceUrl = sourceUrl;
+		lockMap.set(name, lockEntry);
+	}
+	return lockMap;
+}
+function parseBunLock(content) {
+	const lockMap = /* @__PURE__ */ new Map();
+	const json = content.replace(/,(\s*[}\]])/g, "$1");
+	const packages = JSON.parse(json).packages;
+	if (!packages) return lockMap;
+	for (const [name, value] of Object.entries(packages)) {
+		if (!Array.isArray(value)) continue;
+		const ref = value[0];
+		if (!ref || typeof ref !== "string") continue;
+		const pkgName = extractPackageName(ref);
+		if (!pkgName) continue;
+		const version$1 = ref.slice(pkgName.length + 1);
+		if (!version$1) continue;
+		if (version$1.startsWith("file:") || version$1.startsWith("workspace:")) continue;
+		const existingBun = lockMap.get(name);
+		if (existingBun && !isHigherVersion(version$1, existingBun.resolved)) continue;
+		lockMap.set(name, {
+			resolved: version$1,
+			scopes: ["prod"]
+		});
+	}
+	return lockMap;
+}
+async function parseLockfile(cliType, lockfilePath, lockfileVersion) {
+	if (cliType === "bun" && lockfileVersion === 0) return /* @__PURE__ */ new Map();
+	if (cliType === "vlt") return /* @__PURE__ */ new Map();
+	const content = await fs.promises.readFile(lockfilePath, "utf-8");
+	switch (cliType) {
+		case "npm": return parseNpmLock(content, lockfileVersion);
+		case "pnpm": return parsePnpmLock(content, lockfileVersion);
+		case "yarn": return parseYarnLock(content, lockfileVersion);
+		case "bun": return parseBunLock(content);
+		default: return /* @__PURE__ */ new Map();
+	}
+}
+async function readPackageJson(startDir) {
+	let current = startDir;
+	for (;;) try {
+		const content = await fs.promises.readFile(path.join(current, "package.json"), "utf-8");
+		return JSON.parse(content);
+	} catch {
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
 }
+function buildDirectMaps(pkgJson) {
+	const directScopes = /* @__PURE__ */ new Map();
+	const directRequested = /* @__PURE__ */ new Map();
+	const add = (deps, scope) => {
+		if (!deps || typeof deps !== "object") return;
+		for (const [name, specifier] of Object.entries(deps)) {
+			if (!directScopes.has(name)) directScopes.set(name, /* @__PURE__ */ new Set());
+			directScopes.get(name).add(scope);
+			if (!directRequested.has(name)) directRequested.set(name, specifier);
+		}
+	};
+	add(pkgJson.dependencies, "prod");
+	add(pkgJson.devDependencies, "dev");
+	add(pkgJson.peerDependencies, "peer");
+	add(pkgJson.optionalDependencies, "optional");
+	return {
+		directScopes,
+		directRequested
+	};
+}
+async function generateProjectManifest({ workPath, nodeVersion, cliType, lockfilePath, lockfileVersion }) {
+	try {
+		const pkgJson = await readPackageJson(workPath);
+		if (!pkgJson) return;
+		const { directScopes, directRequested } = buildDirectMaps(pkgJson);
+		const lockMap = lockfilePath ? await parseLockfile(cliType, lockfilePath, lockfileVersion) : /* @__PURE__ */ new Map();
+		const directDeps = [];
+		const transitiveDeps = [];
+		for (const [name, scopes] of directScopes) {
+			const lock = lockMap.get(name);
+			const dep = {
+				name,
+				type: "direct",
+				scopes: [...scopes].sort(),
+				requested: directRequested.get(name),
+				resolved: lock?.resolved ?? ""
+			};
+			if (lock?.source) dep.source = lock.source;
+			if (lock?.sourceUrl) dep.sourceUrl = lock.sourceUrl;
+			directDeps.push(dep);
+		}
+		for (const [name, lock] of lockMap) {
+			if (directScopes.has(name)) continue;
+			const dep = {
+				name,
+				type: "transitive",
+				scopes: lock.scopes,
+				resolved: lock.resolved
+			};
+			if (lock.source) dep.source = lock.source;
+			if (lock.sourceUrl) dep.sourceUrl = lock.sourceUrl;
+			transitiveDeps.push(dep);
+		}
+		const runtimeVersion = { resolved: String(nodeVersion.major) };
+		const enginesNode = pkgJson.engines?.node;
+		if (enginesNode) {
+			runtimeVersion.requested = enginesNode;
+			runtimeVersion.requestedSource = "package.json";
+		} else for (const filename of [".node-version", ".nvmrc"]) try {
+			const trimmed = (await fs.promises.readFile(path.join(workPath, filename), "utf-8")).trim();
+			if (trimmed) {
+				runtimeVersion.requested = trimmed;
+				runtimeVersion.requestedSource = filename;
+				break;
+			}
+		} catch {}
+		await writeProjectManifest({
+			version: MANIFEST_VERSION,
+			runtime: "node",
+			runtimeVersion,
+			dependencies: [...directDeps.sort((a, b) => a.name.localeCompare(b.name)), ...transitiveDeps.sort((a, b) => a.name.localeCompare(b.name))]
+		}, workPath, "node");
+	} catch (err) {
+		debug(`generateProjectManifest: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+const diagnostics = createDiagnostics("node");
 
 //#endregion
 //#region src/cervel/plugin.ts
@@ -93,7 +439,7 @@ const plugin = (args) => {
 	* Determine if a resolved module is CommonJS based on package.json exports
 	*/
 	const isCommonJS = async (bareImport, resolvedPath, resolvedInfo) => {
-		const ext = extname$1(resolvedPath);
+		const ext = extname(resolvedPath);
 		if (ext === ".cjs") return true;
 		if (ext === ".mjs") return false;
 		if (ext === ".js" || ext === ".ts") {
@@ -231,7 +577,7 @@ const nodeFileTrace = async (args) => {
 		ts: true,
 		mixedModules: true,
 		async resolve(id, parent, job, cjsResolve) {
-			return resolve(id, parent, job, cjsResolve);
+			return resolve$1(id, parent, job, cjsResolve);
 		},
 		async readFile(fsPath) {
 			try {
@@ -276,7 +622,7 @@ var __dirname = typeof __dirname !== 'undefined' ? __dirname : __dirname_(__file
 const rolldown$1 = async (args) => {
 	const entrypointPath = join$1(args.workPath, args.entrypoint);
 	const outputDir = join$1(args.workPath, args.out);
-	const extension = extname$1(args.entrypoint);
+	const extension = extname(args.entrypoint);
 	const extensionMap = {
 		".ts": {
 			format: "auto",
@@ -407,9 +753,24 @@ const Colors = {
 };
 
 //#endregion
-//#region src/cervel/typescript.ts
-const require_$1 = createRequire$1(import.meta.url);
-const typescript$1 = (args) => {
+//#region src/typescript.ts
+/**
+* Typecheck via the TypeScript compiler API (`createProgram`, `getPreEmitDiagnostics`),
+* not by spawning the `tsc` binary.
+*
+* We only want to validate the deployment entrypoint and its import graph, not every
+* file matched by `tsconfig` `include`. The CLI cannot combine `--project` with explicit
+* root files (TS5042), so expressing 'project options + entry-only roots' in one `tsc`
+* call requires a generated tsconfig on disk. Writing beside the user's config is
+* invasive; a temp config elsewhere often breaks `node_modules` / `@types` resolution
+* relative to the real project. The API lets us reuse `parseJsonConfigFileContent` (same
+* options as `-p`) with explicit `rootNames`, no files written, and a compiler host whose
+* current directory stays `workPath`.
+*
+* The `typescript` package is resolved with `require` from the user's app (peer dependency), not bundled.
+*/
+const require_ = createRequire(import.meta.url);
+const typescript = (args) => {
 	const { span } = args;
 	return span.child("vc.builder.backends.tsCompile").trace(async () => {
 		const extension = extname(args.entrypoint);
@@ -418,79 +779,76 @@ const typescript$1 = (args) => {
 			".mts",
 			".cts"
 		].includes(extension)) return;
-		const tscPath = resolveTscPath$1(args);
-		if (!tscPath) {
+		const ts = resolveTypeScriptModule(args.workPath);
+		if (!ts) {
 			console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Typecheck skipped ${Colors.gray("(TypeScript not found)")}`));
 			return null;
 		}
-		return doTypeCheck$1(args, tscPath);
+		return doTypeCheck(args, ts);
 	});
 };
-async function doTypeCheck$1(args, tscPath) {
-	let stdout = "";
-	let stderr = "";
-	/**
-	* This might be subject to change.
-	* - if no tscPath, skip typecheck
-	* - if tsconfig, provide the tsconfig path
-	* - else provide the entrypoint path
-	*/
-	const tscArgs = [
-		tscPath,
-		"--noEmit",
-		"--pretty",
-		"--allowJs",
-		"--esModuleInterop",
-		"--skipLibCheck"
-	];
-	const tsconfig = await findNearestTsconfig$1(args.workPath);
-	if (tsconfig) tscArgs.push("--project", tsconfig);
-	else tscArgs.push(args.entrypoint);
-	const child = spawn(process.execPath, tscArgs, {
-		cwd: args.workPath,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	child.stdout?.on("data", (data) => {
-		stdout += data.toString();
-	});
-	child.stderr?.on("data", (data) => {
-		stderr += data.toString();
-	});
-	await new Promise((resolve$1, reject) => {
-		child.on("close", (code) => {
-			if (code === 0) {
-				console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Typecheck complete`));
-				resolve$1();
-			} else {
-				const output = stdout || stderr;
-				if (output) {
-					console.error("\nTypeScript type check failed:\n");
-					console.error(output);
-				}
-				reject(/* @__PURE__ */ new Error("TypeScript type check failed"));
-			}
-		});
-		child.on("error", (err) => {
-			reject(err);
-		});
-	});
+async function doTypeCheck(args, ts) {
+	const entryAbsolute = resolve(args.workPath, args.entrypoint);
+	const tsconfig = await findNearestTsconfig(args.workPath);
+	const formatDiagnostics = process.stdout.isTTY ? ts.formatDiagnosticsWithColorAndContext : ts.formatDiagnostics;
+	const diagnosticHost = {
+		getNewLine: () => ts.sys.newLine,
+		getCanonicalFileName: (fileName) => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+		getCurrentDirectory: () => args.workPath
+	};
+	let options;
+	let parseDiagnostics = [];
+	if (tsconfig) {
+		const configRead = ts.readConfigFile(tsconfig, ts.sys.readFile);
+		if (configRead.error) {
+			const message = formatDiagnostics([configRead.error], diagnosticHost);
+			console.error("\nTypeScript type check failed:\n");
+			console.error(message);
+			throw new Error("TypeScript type check failed");
+		}
+		const parsed = ts.parseJsonConfigFileContent(configRead.config, ts.sys, dirname$1(tsconfig), void 0, tsconfig);
+		parseDiagnostics = parsed.errors;
+		options = {
+			...parsed.options,
+			noEmit: true,
+			skipLibCheck: true,
+			allowJs: true,
+			esModuleInterop: true
+		};
+	} else options = {
+		noEmit: true,
+		skipLibCheck: true,
+		allowJs: true,
+		esModuleInterop: true,
+		target: ts.ScriptTarget.ES2022,
+		module: ts.ModuleKind.NodeNext,
+		moduleResolution: ts.ModuleResolutionKind.NodeNext
+	};
+	const compilerHost = ts.createCompilerHost(options);
+	compilerHost.getCurrentDirectory = () => args.workPath;
+	const program = ts.createProgram([entryAbsolute], options, compilerHost);
+	const errors = [...parseDiagnostics, ...ts.getPreEmitDiagnostics(program)].filter((d) => d.category === ts.DiagnosticCategory.Error);
+	if (errors.length === 0) {
+		console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Typecheck complete`));
+		return;
+	}
+	const output = formatDiagnostics(errors, diagnosticHost);
+	console.error("\nTypeScript type check failed:\n");
+	console.error(output);
+	throw new Error("TypeScript type check failed");
 }
-const resolveTscPath$1 = (args) => {
+function resolveTypeScriptModule(workPath) {
 	try {
-		return require_$1.resolve("typescript/bin/tsc", { paths: [args.workPath] });
-	} catch (e) {
+		return require_(require_.resolve("typescript", { paths: [workPath] }));
+	} catch (_e) {
 		return null;
 	}
-};
-const findNearestTsconfig$1 = async (workPath) => {
-	const tsconfigPath = join(workPath, "tsconfig.json");
-	if (existsSync$1(tsconfigPath)) return tsconfigPath;
+}
+const findNearestTsconfig = async (workPath) => {
+	const tsconfigPath = join$1(workPath, "tsconfig.json");
+	if (existsSync(tsconfigPath)) return tsconfigPath;
 	if (workPath === "/") return;
-	return findNearestTsconfig$1(join(workPath, ".."));
+	return findNearestTsconfig(join$1(workPath, ".."));
 };
 
 //#endregion
@@ -524,12 +882,24 @@ const entrypointExtensions = [
 const entrypoints = entrypointFilenames.flatMap((filename) => entrypointExtensions.map((extension) => `${filename}.${extension}`));
 const createFrameworkRegex = (framework) => new RegExp(`(?:from|require|import)\\s*(?:\\(\\s*)?["']${framework}["']\\s*(?:\\))?`, "g");
 const findEntrypoint = async (cwd) => {
-	let framework;
+	let packageJsonObject = null;
 	try {
 		const packageJson = await readFile(join$1(cwd, "package.json"), "utf-8");
-		const packageJsonObject = JSON.parse(packageJson);
-		framework = frameworks.find((framework$1) => packageJsonObject.dependencies?.[framework$1]);
+		packageJsonObject = JSON.parse(packageJson);
 	} catch (_) {}
+	if (packageJsonObject) {
+		const main = typeof packageJsonObject.main === "string" ? packageJsonObject.main.trim() : "";
+		if (main) {
+			const abs = resolve(cwd, main);
+			const rel = relative(cwd, abs);
+			if (!rel.startsWith("..") && rel !== "") try {
+				await readFile(abs, "utf-8");
+				return rel.split(sep).join("/");
+			} catch {}
+		}
+	}
+	let framework;
+	if (packageJsonObject) framework = frameworks.find((framework$1) => packageJsonObject.dependencies?.[framework$1]);
 	if (!framework) for (const entrypoint of entrypoints) {
 		const entrypointPath = join$1(cwd, entrypoint);
 		try {
@@ -550,7 +920,7 @@ const findEntrypoint = async (cwd) => {
 };
 const findEntrypointOrThrow = async (cwd) => {
 	const entrypoint = await findEntrypoint(cwd);
-	if (!entrypoint) throw new Error(`No entrypoint found in "${cwd}". Expected one of: ${entrypoints.join(", ")}`);
+	if (!entrypoint) throw new Error(`No entrypoint found in "${cwd}". Set package.json "main" to a server file, or add one of: ${entrypoints.join(", ")}`);
 	return entrypoint;
 };
 
@@ -564,7 +934,7 @@ const getBuildSummary = async (outputDir) => {
 const build$1 = async (args) => {
 	const entrypoint = args.entrypoint || await findEntrypointOrThrow(args.workPath);
 	const span = args.span ?? new Span({ name: "cervel-build" });
-	const [, rolldownResult] = await Promise.all([typescript$1({
+	const [, rolldownResult] = await Promise.all([typescript({
 		entrypoint,
 		workPath: args.workPath,
 		span
@@ -576,7 +946,7 @@ const build$1 = async (args) => {
 		span
 	})]);
 	await writeFile(join$1(args.workPath, args.out, ".cervel.json"), JSON.stringify({ handler: rolldownResult.result.handler }, null, 2));
-	console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Build complete`));
+	console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Build complete — Using ${Colors.bold(entrypoint)} as the root entrypoint.`));
 	return { rolldownResult: rolldownResult.result };
 };
 const serve = async (args) => {
@@ -625,7 +995,7 @@ const srvxOptions = {
 //#endregion
 //#region src/rolldown/resolve-format.ts
 const resolveEntrypointAndFormat = async (args) => {
-	const extension = extname$1(args.entrypoint);
+	const extension = extname(args.entrypoint);
 	const extensionMap = {
 		".ts": {
 			format: "auto",
@@ -673,13 +1043,174 @@ const resolveEntrypointAndFormat = async (args) => {
 	};
 };
 
+//#endregion
+//#region src/service-vc-init.ts
+async function applyServiceVcInit(args) {
+	const { format, extension } = await resolveShimFormat(args);
+	const handlerDir = dirname$1(args.handler);
+	const vcInitName = `${basename(args.handler, extname(args.handler))}.__vc_service_vc_init${extension}`;
+	const vcInitHandler = handlerDir === "." ? vcInitName : join$1(handlerDir, vcInitName);
+	const handlerImportPath = `./${basename(args.handler)}`;
+	const vcInitSource = format === "esm" ? createEsmServiceVcInit(handlerImportPath) : createCjsServiceVcInit(handlerImportPath);
+	return {
+		handler: vcInitHandler,
+		files: {
+			...args.files,
+			[vcInitHandler]: new FileBlob({
+				data: vcInitSource,
+				mode: 420
+			})
+		}
+	};
+}
+async function resolveShimFormat(args) {
+	const { format } = await resolveEntrypointAndFormat({
+		entrypoint: args.handler,
+		workPath: args.workPath
+	});
+	return {
+		format,
+		extension: extname(args.handler) || (format === "esm" ? ".mjs" : ".cjs")
+	};
+}
+const sharedShimPrelude = String.raw`
+const PATCH_SYMBOL = Symbol.for('vc.service.route-prefix-strip.patch')
+
+function normalizeServiceRoutePrefix(rawPrefix) {
+  if (!rawPrefix) {
+    return ''
+  }
+
+  let prefix = String(rawPrefix).trim()
+  if (!prefix) {
+    return ''
+  }
+
+  if (!prefix.startsWith('/')) {
+    prefix = '/' + prefix
+  }
+
+  if (prefix !== '/') {
+    prefix = prefix.replace(/\/+$/, '')
+  }
+
+  return prefix === '/' ? '' : prefix
+}
+
+function getServiceRoutePrefix() {
+  const enabled = String(
+    process.env.VERCEL_SERVICE_ROUTE_PREFIX_STRIP || ''
+  ).toLowerCase()
+  if (enabled !== '1' && enabled !== 'true') {
+    return ''
+  }
+
+  return normalizeServiceRoutePrefix(process.env.VERCEL_SERVICE_ROUTE_PREFIX || '')
+}
+
+function stripServiceRoutePrefix(requestUrl, prefix) {
+  if (typeof requestUrl !== 'string' || requestUrl === '*') {
+    return requestUrl
+  }
+
+  const queryIndex = requestUrl.indexOf('?')
+  const rawPath =
+    queryIndex === -1 ? requestUrl : requestUrl.slice(0, queryIndex)
+  const query = queryIndex === -1 ? '' : requestUrl.slice(queryIndex)
+
+  let path = rawPath || '/'
+  if (!path.startsWith('/')) {
+    path = '/' + path
+  }
+
+  if (!prefix) {
+    return path + query
+  }
+
+  if (path === prefix) {
+    return '/' + query
+  }
+
+  if (path.startsWith(prefix + '/')) {
+    return path.slice(prefix.length) + query
+  }
+
+  return path + query
+}
+
+function patchServerRequestUrl(ServerCtor) {
+  const prefix = getServiceRoutePrefix()
+  if (!prefix || globalThis[PATCH_SYMBOL]) {
+    return
+  }
+
+  globalThis[PATCH_SYMBOL] = true
+
+  const originalEmit = ServerCtor.prototype.emit
+  ServerCtor.prototype.emit = function patchedEmit(event, request, ...args) {
+    if (event === 'request' && request && typeof request.url === 'string') {
+      request.url = stripServiceRoutePrefix(request.url, prefix)
+    }
+
+    return originalEmit.call(this, event, request, ...args)
+  }
+}
+`;
+function createEsmServiceVcInit(handlerImportPath) {
+	return `
+import { Server } from 'node:http'
+
+${sharedShimPrelude}
+
+// Patch the HTTP server before loading user code so apps that attach request
+// listeners during module evaluation see the stripped service-relative URL.
+patchServerRequestUrl(Server)
+
+const originalModule = await import(${JSON.stringify(handlerImportPath)})
+
+/**
+ * Match the Node serverless loader behavior: TS/CJS/ESM interop can leave us
+ * with nested \`.default\` wrappers, so peel off a few layers to recover the
+ * actual user entrypoint shape.
+ */
+function unwrapDefaultExport(value) {
+  let current = value
+  for (let i = 0; i < 5; i++) {
+    if (current && typeof current === 'object' && 'default' in current && current.default) {
+      current = current.default
+    } else {
+      break
+    }
+  }
+  return current
+}
+
+const entrypoint = unwrapDefaultExport(originalModule)
+
+// Re-export the resolved entrypoint so the surrounding runtime still sees the
+// same handler shape after this service bootstrap runs.
+export default typeof entrypoint === 'undefined' ? originalModule : entrypoint
+`.trimStart();
+}
+function createCjsServiceVcInit(handlerImportPath) {
+	return `
+const { Server } = require('node:http')
+
+${sharedShimPrelude}
+
+patchServerRequestUrl(Server)
+
+module.exports = require(${JSON.stringify(handlerImportPath)})
+`.trimStart();
+}
+
 //#endregion
 //#region src/rolldown/nft.ts
 const nft = async (args) => {
 	const nftSpan = args.span.child("vc.builder.backends.nft");
 	const runNft = async () => {
 		const ignorePatterns = [...args.ignoreNodeModules ? ["**/node_modules/**"] : [], ...args.ignore ? Array.isArray(args.ignore) ? args.ignore : [args.ignore] : []];
-		const nftResult = await nodeFileTrace$1(Array.from(args.localBuildFiles), {
+		const nftResult = await nodeFileTrace$1(Array.from(args.localBuildFiles).filter((p) => existsSync(p)), {
 			base: args.repoRootPath,
 			processCwd: args.workPath,
 			ts: true,
@@ -699,7 +1230,13 @@ const nft = async (args) => {
 		});
 		for (const file of nftResult.fileList) {
 			const absolutePath = join$1(args.repoRootPath, file);
-			const stats = await lstat(absolutePath);
+			let stats;
+			try {
+				stats = await lstat(absolutePath);
+			} catch (error) {
+				if (isNativeError(error) && "code" in error && error.code === "ENOENT") continue;
+				throw error;
+			}
 			const outputPath = file;
 			if (args.localBuildFiles.has(join$1(args.repoRootPath, outputPath))) continue;
 			if (stats.isSymbolicLink() || stats.isFile()) if (args.ignoreNodeModules) {
@@ -719,6 +1256,7 @@ const nft = async (args) => {
 	await nftSpan.trace(runNft);
 };
 const isTypeScriptFile = (fsPath) => {
+	if (fsPath.endsWith(".d.ts") || fsPath.endsWith(".d.mts") || fsPath.endsWith(".d.cts")) return false;
 	return fsPath.endsWith(".ts") || fsPath.endsWith(".tsx") || fsPath.endsWith(".mts") || fsPath.endsWith(".cts");
 };
 
@@ -750,7 +1288,7 @@ const rolldown = async (args) => {
 		}
 	};
 	const isCommonJS = async (bareImport, resolvedPath, resolvedInfo) => {
-		const ext = extname$1(resolvedPath);
+		const ext = extname(resolvedPath);
 		if (ext === ".cjs") return true;
 		if (ext === ".mjs") return false;
 		if (ext === ".js" || ext === ".ts") {
@@ -812,8 +1350,12 @@ const rolldown = async (args) => {
 						id,
 						external: true
 					};
-					if (resolved?.id && isLocalImport(resolved.id)) localBuildFiles.add(resolved.id);
-					else if (!resolved) localBuildFiles.add(join$1(args.workPath, id));
+					if (resolved?.id && isLocalImport(resolved.id)) {
+						if (existsSync(resolved.id)) localBuildFiles.add(resolved.id);
+					} else if (!resolved && !(isBareImport(id) && importer)) {
+						const candidate = join$1(args.workPath, id);
+						if (existsSync(candidate)) localBuildFiles.add(candidate);
+					}
 					if (importer?.startsWith(CJS_SHIM_PREFIX) && isBareImport(id)) return {
 						id,
 						external: true
@@ -915,7 +1457,7 @@ module.exports = requireFromContext('${pkgName}');
 		ignore: args.config.excludeFiles
 	});
 	if (!handler) throw new Error(`Unable to resolve build handler for entrypoint: ${args.entrypoint}`);
-	console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Build complete`));
+	console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Build complete — Using ${Colors.bold(args.entrypoint)} as the root entrypoint.`));
 	return {
 		files,
 		handler,
@@ -962,6 +1504,7 @@ const introspection = async (args) => {
 			writeFileSync(filePath, value.data);
 		}
 		let introspectionData;
+		let introspectionError;
 		await new Promise((resolvePromise) => {
 			try {
 				debug("Spawning introspection process");
@@ -969,7 +1512,7 @@ const introspection = async (args) => {
 				const tempFilePath = join$1(outputTempDir, "output.txt");
 				const writeStream = createWriteStream(tempFilePath);
 				let streamClosed = false;
-				const child = spawn$1("node", [
+				const child = spawn("node", [
 					"-r",
 					rolldownCjsLoaderPath,
 					"--import",
@@ -1004,11 +1547,11 @@ const introspection = async (args) => {
 				const timeout = setTimeout(() => {
 					debug("Introspection timeout, killing process with SIGTERM");
 					child.kill("SIGTERM");
-				}, 8e3);
+				}, 5e3);
 				const timeout2 = setTimeout(() => {
 					debug("Introspection timeout, killing process with SIGKILL");
 					child.kill("SIGKILL");
-				}, 9e3);
+				}, 6e3);
 				const cleanup = () => {
 					clearTimeout(timeout);
 					clearTimeout(timeout2);
@@ -1023,7 +1566,8 @@ const introspection = async (args) => {
 				};
 				child.on("error", (err) => {
 					cleanup();
-					debug(`Loader error: ${err.message}`);
+					introspectionError = `Loader error: ${err.message}`;
+					debug(introspectionError);
 					if (!streamClosed) writeStream.end(() => {
 						streamClosed = true;
 						try {
@@ -1054,8 +1598,12 @@ const introspection = async (args) => {
 									introspectionData = introspectionSchema.parse(JSON.parse(introspectionString));
 									debug("Introspection data parsed successfully");
 								}
-							} else debug(`Introspection markers not found.\nstdout:\n${stdoutBuffer}\nstderr:\n${stderrBuffer}`);
+							} else {
+								introspectionError = `Introspection markers not found. stderr: ${stderrBuffer}`;
+								debug(`Introspection markers not found.\nstdout:\n${stdoutBuffer}\nstderr:\n${stderrBuffer}`);
+							}
 						} catch (error) {
+							introspectionError = `Error parsing introspection data: ${error}. stderr: ${stderrBuffer}`;
 							debug(`Error parsing introspection data: ${error}\nstdout:\n${stdoutBuffer}\nstderr:\n${stderrBuffer}`);
 						} finally {
 							try {
@@ -1072,6 +1620,7 @@ const introspection = async (args) => {
 					else resolvePromise();
 				});
 			} catch (error) {
+				introspectionError = `Introspection error: ${error}`;
 				debug("Introspection error", error);
 				resolvePromise();
 			}
@@ -1079,7 +1628,8 @@ const introspection = async (args) => {
 		if (!introspectionData) {
 			introspectionSpan.setAttributes({
 				"introspection.success": "false",
-				"introspection.routes": "0"
+				"introspection.routes": "0",
+				...introspectionError && { "introspection.error": introspectionError.slice(0, 1024) }
 			});
 			return defaultResult$1;
 		}
@@ -1102,6 +1652,20 @@ const introspection = async (args) => {
 
 //#endregion
 //#region src/build.ts
+/**
+* `outputDirectory` is usually the same project setting the static builder uses
+* (Vite/Webpack/etc. client output). We only reuse it for the Node lambda when we
+* find a known server entry file under that folder; otherwise we bundle from
+* source with rolldown. Errors here are swallowed so static-only output trees do
+* not fail the build.
+*/
+async function findEntrypointInOutputDir(dir) {
+	try {
+		return await findEntrypoint(dir);
+	} catch {
+		return;
+	}
+}
 const maybeDoBuildCommand = async (args, downloadResult) => {
 	const buildCommandResult = await maybeExecBuildCommand(args, downloadResult);
 	const outputSetting = args.config.outputDirectory;
@@ -1109,7 +1673,7 @@ const maybeDoBuildCommand = async (args, downloadResult) => {
 	let entrypoint;
 	if (buildCommandResult && outputSetting) if (outputSetting) {
 		const _outputDir = join$1(args.workPath, outputSetting);
-		const _entrypoint = await findEntrypoint(_outputDir);
+		const _entrypoint = await findEntrypointInOutputDir(_outputDir);
 		if (_entrypoint) {
 			outputDir = _outputDir;
 			entrypoint = _entrypoint;
@@ -1121,7 +1685,7 @@ const maybeDoBuildCommand = async (args, downloadResult) => {
 	]) {
 		const _outputDir = join$1(args.workPath, outputDirectory);
 		if (existsSync(_outputDir)) {
-			const _entrypoint = await findEntrypoint(_outputDir);
+			const _entrypoint = await findEntrypointInOutputDir(_outputDir);
 			if (_entrypoint) {
 				outputDir = _outputDir;
 				entrypoint = _entrypoint;
@@ -1143,93 +1707,6 @@ const maybeDoBuildCommand = async (args, downloadResult) => {
 	};
 };
 
-//#endregion
-//#region src/typescript.ts
-const require_ = createRequire(import.meta.url);
-const typescript = (args) => {
-	const { span } = args;
-	return span.child("vc.builder.backends.tsCompile").trace(async () => {
-		const extension = extname$1(args.entrypoint);
-		if (![
-			".ts",
-			".mts",
-			".cts"
-		].includes(extension)) return;
-		const tscPath = resolveTscPath(args);
-		if (!tscPath) {
-			console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Typecheck skipped ${Colors.gray("(TypeScript not found)")}`));
-			return null;
-		}
-		return doTypeCheck(args, tscPath);
-	});
-};
-async function doTypeCheck(args, tscPath) {
-	let stdout = "";
-	let stderr = "";
-	/**
-	* This might be subject to change.
-	* - if no tscPath, skip typecheck
-	* - if tsconfig, provide the tsconfig path
-	* - else provide the entrypoint path
-	*/
-	const tscArgs = [
-		tscPath,
-		"--noEmit",
-		"--pretty",
-		"--allowJs",
-		"--esModuleInterop",
-		"--skipLibCheck"
-	];
-	const tsconfig = await findNearestTsconfig(args.workPath);
-	if (tsconfig) tscArgs.push("--project", tsconfig);
-	else tscArgs.push(args.entrypoint);
-	const child = spawn$1(process.execPath, tscArgs, {
-		cwd: args.workPath,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	child.stdout?.on("data", (data) => {
-		stdout += data.toString();
-	});
-	child.stderr?.on("data", (data) => {
-		stderr += data.toString();
-	});
-	await new Promise((resolve$1, reject) => {
-		child.on("close", (code) => {
-			if (code === 0) {
-				console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Typecheck complete`));
-				resolve$1();
-			} else {
-				const output = stdout || stderr;
-				if (output) {
-					console.error("\nTypeScript type check failed:\n");
-					console.error(output);
-				}
-				reject(/* @__PURE__ */ new Error("TypeScript type check failed"));
-			}
-		});
-		child.on("error", (err) => {
-			reject(err);
-		});
-	});
-}
-const resolveTscPath = (args) => {
-	try {
-		return require_.resolve("typescript/bin/tsc", { paths: [args.workPath] });
-	} catch (e) {
-		return null;
-	}
-};
-const findNearestTsconfig = async (workPath) => {
-	const tsconfigPath = join$1(workPath, "tsconfig.json");
-	if (existsSync(tsconfigPath)) return tsconfigPath;
-	if (workPath === "/") return;
-	return findNearestTsconfig(join$1(workPath, ".."));
-};
-
 //#endregion
 //#region src/introspection/index.ts
 const require = createRequire(import.meta.url);
@@ -1259,7 +1736,7 @@ const introspectApp = async (args) => {
 	await new Promise((resolvePromise) => {
 		try {
 			debug("Spawning introspection process");
-			const child = spawn$1("node", [
+			const child = spawn("node", [
 				"-r",
 				cjsLoaderPath,
 				"--import",
@@ -1419,6 +1896,11 @@ const getFramework = (args) => {
 //#endregion
 //#region src/index.ts
 const version = 2;
+/** Non-empty Build Command from project settings / vercel.json (not the default `build` script). */
+function hasExplicitBuildCommand(config) {
+	const cmd = config.buildCommand ?? config.projectSettings?.buildCommand;
+	return typeof cmd === "string" && cmd.trim().length > 0;
+}
 const build = async (args) => {
 	const downloadResult = await downloadInstallAndBundle(args);
 	const nodeVersion = await getNodeVersion(args.workPath, void 0, args.config, args.meta);
@@ -1441,13 +1923,21 @@ const build = async (args) => {
 			...args,
 			span: buildSpan
 		});
-		const introspectionPromise = introspection({
+		const introspectionPromise = rolldownResult.framework.slug === "hono" ? introspection({
 			...args,
 			span: buildSpan,
 			files: rolldownResult.files,
 			handler: rolldownResult.handler
+		}) : Promise.resolve({
+			routes: [],
+			additionalFolders: [],
+			additionalDeps: []
 		});
-		const typescriptPromise = typescript({
+		let typescriptPromise;
+		if (hasExplicitBuildCommand(args.config)) {
+			console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Typecheck skipped ${Colors.gray("(Build Command is configured)")}`));
+			typescriptPromise = Promise.resolve();
+		} else typescriptPromise = typescript({
 			entrypoint,
 			workPath: args.workPath,
 			span: buildSpan
@@ -1466,33 +1956,79 @@ const build = async (args) => {
 			conditions: isBun ? ["bun"] : void 0,
 			span: buildSpan
 		});
+		try {
+			await generateProjectManifest({
+				workPath: args.workPath,
+				nodeVersion,
+				cliType: downloadResult.cliType,
+				lockfilePath: downloadResult.lockfilePath,
+				lockfileVersion: downloadResult.lockfileVersion
+			});
+		} catch (err) {
+			debug(`Failed to write node manifest: ${err instanceof Error ? err.message : String(err)}`);
+		}
 		const baseDir = args.repoRootPath || args.workPath;
 		const includeResults = await Promise.all(normalizeArray(args.config.includeFiles).map((pattern) => glob(pattern, baseDir)));
 		for (const matched of includeResults) for (const [relPath, entry] of Object.entries(matched)) files[relPath] = entry;
 		const introspectionResult = await introspectionPromise;
 		await typescriptPromise;
+		const functionConfigOverrides = await getLambdaOptionsFromFunction({
+			sourceFile: entrypoint,
+			config: args.config
+		});
+		const serviceRoutePrefix = normalizeServiceRoutePrefix(args.config?.routePrefix ?? args.service?.routePrefix);
+		const shouldStripServiceRoutePrefix = !!serviceRoutePrefix && (typeof args.config?.serviceName === "string" || !!args.service);
+		let lambdaFiles = files;
+		let lambdaHandler = handler;
+		if (shouldStripServiceRoutePrefix) {
+			const shimmedLambda = await applyServiceVcInit({
+				files,
+				handler,
+				workPath: nftWorkPath
+			});
+			lambdaFiles = shimmedLambda.files;
+			lambdaHandler = shimmedLambda.handler;
+		}
 		const lambda = new NodejsLambda({
 			runtime: nodeVersion.runtime,
-			handler,
-			files,
+			handler: lambdaHandler,
+			files: lambdaFiles,
 			framework: rolldownResult.framework,
 			shouldAddHelpers: false,
 			shouldAddSourcemapSupport: true,
 			awsLambdaHandler: "",
+			...functionConfigOverrides,
 			shouldDisableAutomaticFetchInstrumentation: process.env.VERCEL_TRACING_DISABLE_AUTOMATIC_FETCH_INSTRUMENTATION === "1"
 		});
+		if (shouldStripServiceRoutePrefix && serviceRoutePrefix) lambda.environment = {
+			...lambda.environment,
+			VERCEL_SERVICE_ROUTE_PREFIX: serviceRoutePrefix,
+			VERCEL_SERVICE_ROUTE_PREFIX_STRIP: "1"
+		};
+		const serviceName = typeof args.config?.serviceName === "string" && args.config.serviceName !== "" ? args.config.serviceName : void 0;
+		const internalServiceFunctionPath = typeof serviceName === "string" && serviceName !== "" ? `/_svc/${serviceName}/index` : void 0;
+		const internalServiceOutputPath = internalServiceFunctionPath?.slice(1);
+		const remapRouteDestination = (route) => {
+			const prefixedRoute = maybePrefixServiceRouteSource(route, serviceRoutePrefix);
+			if (!internalServiceFunctionPath || !route.dest) return prefixedRoute;
+			return {
+				...prefixedRoute,
+				dest: internalServiceFunctionPath
+			};
+		};
 		const routes = [
 			{ handle: "filesystem" },
-			...introspectionResult.routes,
+			...introspectionResult.routes.map(remapRouteDestination),
 			{
-				src: "/(.*)",
-				dest: "/"
+				src: getServiceCatchallSource(serviceRoutePrefix),
+				dest: internalServiceFunctionPath ?? "/"
 			}
 		];
-		const output = { index: lambda };
+		const output = internalServiceOutputPath ? { [internalServiceOutputPath]: lambda } : { index: lambda };
 		for (const route of routes) if (route.dest) {
 			if (route.dest === "/") continue;
-			output[route.dest] = lambda;
+			const outputPath = route.dest === internalServiceFunctionPath && internalServiceOutputPath ? internalServiceOutputPath : route.dest;
+			output[outputPath] = lambda;
 		}
 		return {
 			routes,
@@ -1504,6 +2040,33 @@ const prepareCache = ({ repoRootPath, workPath }) => {
 	return glob(defaultCachePathGlob, repoRootPath || workPath);
 };
 const normalizeArray = (value) => Array.isArray(value) ? value : value ? [value] : [];
+const normalizeServiceRoutePrefix = (routePrefix) => {
+	if (typeof routePrefix !== "string" || routePrefix === "" || routePrefix === ".") return;
+	let normalized = routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`;
+	if (normalized !== "/" && normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+	return normalized === "/" ? void 0 : normalized;
+};
+const maybePrefixServiceRouteSource = (route, routePrefix) => {
+	if (!routePrefix || typeof route.dest !== "string" || !route.dest.startsWith("/")) return route;
+	return {
+		...route,
+		src: getPrefixedRouteSource(route.src, route.dest, routePrefix)
+	};
+};
+const getPrefixedRouteSource = (routeSource, routePath, routePrefix) => {
+	if (!routeSource) return routeSource;
+	if (routePath === routePrefix || routePath.startsWith(`${routePrefix}/`)) return routeSource;
+	const escapedRoutePrefix = toRegexSource(routePrefix);
+	if (routeSource.startsWith("^(?:")) return `^(?:${escapedRoutePrefix}${routeSource.slice(4)}`;
+	if (routeSource.startsWith("^")) return `^${escapedRoutePrefix}${routeSource.slice(1)}`;
+	return `${escapedRoutePrefix}${routeSource}`;
+};
+const getServiceCatchallSource = (routePrefix) => {
+	if (!routePrefix) return "/(.*)";
+	return `^${escapeForRegex(routePrefix)}(?:/(.*))?$`;
+};
+const escapeForRegex = (value) => value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+const toRegexSource = (value) => escapeForRegex(value).replaceAll("/", "\\/");
 
 //#endregion
-export { build, build$1 as cervelBuild, serve as cervelServe, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };
+export { build, build$1 as cervelBuild, serve as cervelServe, diagnostics, findEntrypoint, findEntrypointOrThrow, getBuildSummary, introspectApp, nodeFileTrace, prepareCache, srvxOptions, version };

package/dist/rolldown/index.mjs

@@ -94,7 +94,7 @@ const nft = async (args) => {
 	const nftSpan = args.span.child("vc.builder.backends.nft");
 	const runNft = async () => {
 		const ignorePatterns = [...args.ignoreNodeModules ? ["**/node_modules/**"] : [], ...args.ignore ? Array.isArray(args.ignore) ? args.ignore : [args.ignore] : []];
-		const nftResult = await nodeFileTrace(Array.from(args.localBuildFiles), {
+		const nftResult = await nodeFileTrace(Array.from(args.localBuildFiles).filter((p) => existsSync(p)), {
 			base: args.repoRootPath,
 			processCwd: args.workPath,
 			ts: true,
@@ -114,7 +114,13 @@ const nft = async (args) => {
 		});
 		for (const file of nftResult.fileList) {
 			const absolutePath = join(args.repoRootPath, file);
-			const stats = await lstat(absolutePath);
+			let stats;
+			try {
+				stats = await lstat(absolutePath);
+			} catch (error) {
+				if (isNativeError(error) && "code" in error && error.code === "ENOENT") continue;
+				throw error;
+			}
 			const outputPath = file;
 			if (args.localBuildFiles.has(join(args.repoRootPath, outputPath))) continue;
 			if (stats.isSymbolicLink() || stats.isFile()) if (args.ignoreNodeModules) {
@@ -134,6 +140,7 @@ const nft = async (args) => {
 	await nftSpan.trace(runNft);
 };
 const isTypeScriptFile = (fsPath) => {
+	if (fsPath.endsWith(".d.ts") || fsPath.endsWith(".d.mts") || fsPath.endsWith(".d.cts")) return false;
 	return fsPath.endsWith(".ts") || fsPath.endsWith(".tsx") || fsPath.endsWith(".mts") || fsPath.endsWith(".cts");
 };
 
@@ -227,8 +234,12 @@ const rolldown = async (args) => {
 						id,
 						external: true
 					};
-					if (resolved?.id && isLocalImport(resolved.id)) localBuildFiles.add(resolved.id);
-					else if (!resolved) localBuildFiles.add(join(args.workPath, id));
+					if (resolved?.id && isLocalImport(resolved.id)) {
+						if (existsSync(resolved.id)) localBuildFiles.add(resolved.id);
+					} else if (!resolved && !(isBareImport(id) && importer)) {
+						const candidate = join(args.workPath, id);
+						if (existsSync(candidate)) localBuildFiles.add(candidate);
+					}
 					if (importer?.startsWith(CJS_SHIM_PREFIX) && isBareImport(id)) return {
 						id,
 						external: true
@@ -330,7 +341,7 @@ module.exports = requireFromContext('${pkgName}');
 		ignore: args.config.excludeFiles
 	});
 	if (!handler) throw new Error(`Unable to resolve build handler for entrypoint: ${args.entrypoint}`);
-	console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Build complete`));
+	console.log(Colors.gray(`${Colors.bold(Colors.cyan("✓"))} Build complete — Using ${Colors.bold(args.entrypoint)} as the root entrypoint.`));
 	return {
 		files,
 		handler,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/backends",
-  "version": "0.1.0-canary.20260211174907.cdd2da6",
+  "version": "0.1.1",
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",
   "homepage": "https://vercel.com/docs",
@@ -24,7 +24,9 @@
     "dist"
   ],
   "dependencies": {
-    "@vercel/nft": "1.3.0",
+    "@yarnpkg/parsers": "^3.0.0",
+    "js-yaml": "^3.13.1",
+    "@vercel/nft": "1.5.0",
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
     "oxc-transform": "0.111.0",
@@ -34,13 +36,14 @@
     "srvx": "0.8.9",
     "tsx": "4.21.0",
     "zod": "3.22.4",
-    "@vercel/build-utils": "13.4.0-canary.20260211174907.cdd2da6"
+    "@vercel/build-utils": "13.19.0"
   },
   "peerDependencies": {
     "typescript": "^4.0.0 || ^5.0.0"
   },
   "devDependencies": {
     "@types/express": "5.0.3",
+    "@types/js-yaml": "3.12.1",
     "@types/fs-extra": "11",
     "@types/jest": "27.5.1",
     "@types/node": "20.11.0",