@vercel/backends 0.7.1 → 0.8.0

package/dist/index.mjs

@@ -1,9 +1,10 @@
 import { builtinModules, createRequire } from "node:module";
-import { createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { delimiter as delimiter$1, dirname as dirname$1, join as join$1 } from "path";
 import { FileBlob, FileFsRef, NodejsLambda, Span, createDiagnostics, debug, defaultCachePathGlob, download, execCommand, generateProjectManifest, getEnvForPackageManager, getInternalServiceCronPath, getLambdaOptionsFromFunction, getNodeBinPaths, getNodeVersion, getReportedServiceType, glob, isBackendFramework, isBunVersion, isExperimentalBackendsWithoutIntrospectionEnabled, isScheduleTriggeredService, runNpmInstall, runPackageJsonScript, scanParentDirs } from "@vercel/build-utils";
+import { createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { lstat, readFile, rm, stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 import { build as build$2 } from "rolldown";
 import { exports } from "resolve.exports";
 import { isNativeError } from "node:util/types";
@@ -11,7 +12,6 @@ import { nodeFileTrace as nodeFileTrace$1, resolve as resolve$1 } from "@vercel/
 import { transform } from "oxc-transform";
 import execa from "execa";
 import { readFile as readFile$1, writeFile } from "fs/promises";
-import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
 import { z } from "zod";
@@ -70,222 +70,104 @@ async function maybeExecBuildCommand(args, { spawnEnv }) {
 const diagnostics = createDiagnostics("node");
 
 //#endregion
-//#region src/cervel/plugin.ts
-const CJS_SHIM_PREFIX$1 = "\0cjs-shim:";
-const plugin = (args) => {
-	const packageJsonCache = /* @__PURE__ */ new Map();
-	const shimMeta = /* @__PURE__ */ new Map();
-	const { tracedPaths } = args.context;
-	const isBareImport = (id) => {
-		return !id.startsWith(".") && !id.startsWith("/") && !/^[a-z][a-z0-9+.-]*:/i.test(id);
-	};
-	/**
-	* Read and cache package.json contents
-	*/
-	const getPackageJson = async (pkgPath) => {
-		if (packageJsonCache.has(pkgPath)) return packageJsonCache.get(pkgPath);
-		try {
-			const contents = await readFile(pkgPath, "utf-8");
-			const parsed = JSON.parse(contents);
-			packageJsonCache.set(pkgPath, parsed);
-			return parsed;
-		} catch {
-			packageJsonCache.set(pkgPath, null);
-			return null;
+//#region src/find-entrypoint.ts
+const frameworks = [
+	"express",
+	"hono",
+	"elysia",
+	"fastify",
+	"@nestjs/core",
+	"h3"
+];
+const entrypointFilenames = [
+	"app",
+	"index",
+	"server",
+	"main",
+	"src/app",
+	"src/index",
+	"src/server",
+	"src/main"
+];
+const entrypointExtensions = [
+	"js",
+	"cjs",
+	"mjs",
+	"ts",
+	"cts",
+	"mts"
+];
+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 packageJsonObject = null;
+	try {
+		const packageJson = await readFile(join(cwd, "package.json"), "utf-8");
+		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 {}
 		}
-	};
-	/**
-	* Determine if a resolved module is CommonJS based on package.json exports
-	*/
-	const isCommonJS = async (bareImport, resolvedPath, resolvedInfo) => {
-		const ext = extname(resolvedPath);
-		if (ext === ".cjs") return true;
-		if (ext === ".mjs") return false;
-		if (ext === ".js" || ext === ".ts") {
-			const pkgJsonPath = resolvedInfo.packageJsonPath;
-			if (!pkgJsonPath) return true;
-			const pkgJson = await getPackageJson(pkgJsonPath);
-			if (!pkgJson) return true;
-			const pkgDir = dirname(pkgJsonPath);
-			const relativePath = resolvedPath.startsWith(pkgDir) ? resolvedPath.slice(pkgDir.length + 1).replace(/\\/g, "/") : null;
-			if (!relativePath) return pkgJson.type !== "module";
-			const pkgName = pkgJson.name || "";
-			const subpath = bareImport.startsWith(pkgName) ? `.${bareImport.slice(pkgName.length)}` || "." : ".";
-			try {
-				if (exports(pkgJson, subpath, {
-					require: false,
-					conditions: ["node", "import"]
-				})?.some((p) => p === relativePath || p === `./${relativePath}`)) return false;
-				if (exports(pkgJson, subpath, {
-					require: true,
-					conditions: ["node", "require"]
-				})?.some((p) => p === relativePath || p === `./${relativePath}`)) return true;
-			} catch (err) {
-				console.warn("Export resolution failed::", err);
+	}
+	let framework;
+	if (packageJsonObject) framework = frameworks.find((framework$1) => packageJsonObject.dependencies?.[framework$1]);
+	if (!framework) for (const entrypoint of entrypoints) {
+		const entrypointPath = join(cwd, entrypoint);
+		try {
+			await readFile(entrypointPath, "utf-8");
+			return entrypoint;
+		} catch (_) {}
+	}
+	const regex = framework ? createFrameworkRegex(framework) : void 0;
+	for (const entrypoint of entrypoints) {
+		const entrypointPath = join(cwd, entrypoint);
+		try {
+			const content = await readFile(entrypointPath, "utf-8");
+			if (regex) {
+				if (regex.test(content)) return entrypoint;
 			}
-			if (pkgJson.module) return false;
-			return pkgJson.type !== "module";
-		}
-		return true;
-	};
-	const isLocalImport = (id) => {
-		if (id.startsWith("node:")) return false;
-		if (id.includes("node_modules")) return false;
-		return true;
-	};
+		} catch (_) {}
+	}
+};
+const findEntrypointOrThrow = async (cwd) => {
+	const entrypoint = await findEntrypoint(cwd);
+	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;
+};
+const findEntrypointWithHintOrThrow = async (workPath, configured) => {
+	const explicit = configured && configured !== "package.json" ? configured : null;
+	if (explicit && existsSync(join(workPath, explicit))) return explicit;
+	return findEntrypointOrThrow(workPath);
+};
+/**
+* Normalized entrypoint detector for Node services. Wraps {@link findEntrypoint}
+* and returns the result in the shared {@link DetectedEntrypoint} shape consumed
+* by services auto-detection.
+*/
+const detectEntrypoint = async ({ workPath }) => {
+	const file = await findEntrypoint(workPath);
+	if (!file) return null;
 	return {
-		name: "cervel",
-		resolveId: {
-			order: "pre",
-			async handler(id, importer, rOpts) {
-				if (id.startsWith(CJS_SHIM_PREFIX$1)) return {
-					id,
-					external: false
-				};
-				const resolved = await this.resolve(id, importer, rOpts);
-				if (builtinModules.includes(id)) return {
-					id: `node:${id}`,
-					external: true
-				};
-				if (resolved?.id && isLocalImport(resolved.id)) tracedPaths.add(resolved.id);
-				if (importer?.startsWith(CJS_SHIM_PREFIX$1) && isBareImport(id)) return {
-					id,
-					external: true
-				};
-				if (importer && isBareImport(id) && resolved?.id?.includes("node_modules")) {
-					if (args.shimBareImports) {
-						if (await isCommonJS(id, resolved.id, resolved)) {
-							const importerPkgJsonPath = (await this.resolve(importer))?.packageJsonPath;
-							if (importerPkgJsonPath) {
-								const importerPkgDir = relative(args.repoRootPath, dirname(importerPkgJsonPath));
-								const shimId$1 = `${CJS_SHIM_PREFIX$1}${importerPkgDir.replace(/\//g, "_")}_${id.replace(/\//g, "_")}`;
-								shimMeta.set(shimId$1, {
-									pkgDir: importerPkgDir,
-									pkgName: id
-								});
-								return {
-									id: shimId$1,
-									external: false
-								};
-							}
-							const shimId = `${CJS_SHIM_PREFIX$1}${id.replace(/\//g, "_")}`;
-							shimMeta.set(shimId, {
-								pkgDir: "",
-								pkgName: id
-							});
-							return {
-								id: shimId,
-								external: false
-							};
-						}
-					}
-					return {
-						external: true,
-						id
-					};
-				}
-				if (importer && isBareImport(id)) return resolved;
-				return {
-					external: true,
-					...resolved,
-					id: resolved?.id || id
-				};
-			}
-		},
-		load: { async handler(id) {
-			if (id.startsWith(CJS_SHIM_PREFIX$1)) {
-				const meta = shimMeta.get(id);
-				if (!meta) return { code: `module.exports = require('${id.slice(10)}');` };
-				const { pkgDir, pkgName } = meta;
-				if (pkgDir) return { code: `
-import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const requireFromContext = createRequire(join(dirname(fileURLToPath(import.meta.url)), '${join("..", pkgDir, "package.json")}'));
-module.exports = requireFromContext('${pkgName}');
-`.trim() };
-				return { code: `module.exports = require('${pkgName}');` };
-			}
-			return null;
-		} }
+		kind: "file",
+		entrypoint: file
 	};
 };
 
 //#endregion
-//#region src/cervel/node-file-trace.ts
-const nodeFileTrace = async (args) => {
-	const { span } = args;
-	const files = {};
-	const { tracedPaths } = args;
-	const compiledSourceFiles = await glob("**/*", {
-		cwd: args.outDir,
-		follow: true,
-		includeDirectories: true
-	});
-	for (const file of Object.keys(compiledSourceFiles)) files[file] = compiledSourceFiles[file];
-	/**
-	* While we're not using NFT to process source code, we are using it
-	* to tree shake node deps, and include any fs reads for files that are
-	* not part of the traced paths or compiled source files.
-	* Most of this is identical to the `@vercel/node` implementation
-	*/
-	const runNft = () => nodeFileTrace$1(Array.from(tracedPaths), {
-		base: args.repoRootPath,
-		processCwd: args.workPath,
-		ts: true,
-		mixedModules: true,
-		async resolve(id, parent, job, cjsResolve) {
-			return resolve$1(id, parent, job, cjsResolve);
-		},
-		async readFile(fsPath) {
-			try {
-				let source = await readFile(fsPath);
-				if (fsPath.endsWith(".ts") && !fsPath.endsWith(".d.ts") || fsPath.endsWith(".tsx") || fsPath.endsWith(".mts") || fsPath.endsWith(".cts")) source = (await transform(fsPath, source.toString())).code;
-				return source;
-			} catch (error) {
-				if (isNativeError(error) && "code" in error && (error.code === "ENOENT" || error.code === "EISDIR")) return null;
-				throw error;
-			}
-		}
-	});
-	const result = await span.child("vc.builder.backends.nft").trace(runNft);
-	if (!args.keepTracedPaths) for (const file of tracedPaths) {
-		const relativeFile = relative(args.repoRootPath, file);
-		result.fileList.delete(relativeFile);
-	}
-	debug("NFT traced files count:", result.fileList.size);
-	for (const file of result.fileList) {
-		const absolutePath = join(args.repoRootPath, file);
-		const stats = await lstat(absolutePath);
-		const outputPath = file;
-		if (stats.isSymbolicLink() || stats.isFile()) files[outputPath] = new FileFsRef({
-			fsPath: absolutePath,
-			mode: stats.mode
-		});
-	}
-	debug("Total files in context:", Object.keys(files).length);
-	return files;
-};
-
-//#endregion
-//#region src/cervel/rolldown.ts
-const __dirname__filenameShim = `
-import { createRequire as __createRequire } from 'node:module';
-import { fileURLToPath as __fileURLToPath } from 'node:url';
-import { dirname as __dirname_ } from 'node:path';
-var require = typeof require !== 'undefined' ? require : __createRequire(import.meta.url);
-var __filename = typeof __filename !== 'undefined' ? __filename : __fileURLToPath(import.meta.url);
-var __dirname = typeof __dirname !== 'undefined' ? __dirname : __dirname_(__filename);
-`.trim();
-const rolldown$1 = async (args) => {
-	const entrypointPath = join(args.workPath, args.entrypoint);
-	const outputDir = join(args.workPath, args.out);
-	const extension = extname(args.entrypoint);
-	const extensionMap = {
-		".ts": {
-			format: "auto",
-			extension: "js"
+//#region src/rolldown/resolve-format.ts
+const resolveEntrypointAndFormat = async (args) => {
+	const extension = extname(args.entrypoint);
+	const extensionMap = {
+		".ts": {
+			format: "auto",
+			extension: "js"
 		},
 		".mts": {
 			format: "esm",
@@ -309,9 +191,8 @@ const rolldown$1 = async (args) => {
 		}
 	};
 	const extensionInfo = extensionMap[extension] || extensionMap[".js"];
-	let resolvedFormat = extensionInfo.format === "auto" ? void 0 : extensionInfo.format;
+	let resolvedFormat = extensionInfo.format === "auto" ? args.defaultFormat : extensionInfo.format;
 	const packageJsonPath = join(args.workPath, "package.json");
-	const external = [];
 	let pkg = {};
 	if (existsSync(packageJsonPath)) {
 		const source = await readFile(packageJsonPath, "utf8");
@@ -322,431 +203,46 @@ const rolldown$1 = async (args) => {
 		}
 		if (extensionInfo.format === "auto") if (pkg.type === "module") resolvedFormat = "esm";
 		else resolvedFormat = "cjs";
-		for (const dependency of Object.keys(pkg.dependencies || {})) external.push(dependency);
-		for (const dependency of Object.keys(pkg.devDependencies || {})) external.push(dependency);
-		for (const dependency of Object.keys(pkg.peerDependencies || {})) external.push(dependency);
-		for (const dependency of Object.keys(pkg.optionalDependencies || {})) external.push(dependency);
-	}
-	const resolvedExtension = resolvedFormat === "esm" ? "mjs" : "cjs";
-	const context = { tracedPaths: /* @__PURE__ */ new Set() };
-	const runRolldown = () => build$2({
-		input: entrypointPath,
-		cwd: args.workPath,
-		platform: "node",
-		tsconfig: true,
-		plugins: [plugin({
-			repoRootPath: args.repoRootPath,
-			outDir: outputDir,
-			workPath: args.workPath,
-			shimBareImports: resolvedFormat === "esm",
-			context
-		})],
-		output: {
-			cleanDir: true,
-			dir: outputDir,
-			format: resolvedFormat,
-			entryFileNames: `[name].${resolvedExtension}`,
-			preserveModules: true,
-			preserveModulesRoot: args.repoRootPath,
-			sourcemap: false,
-			banner: resolvedFormat === "esm" ? __dirname__filenameShim : void 0
-		}
-	});
-	const out = await args.span.child("vc.builder.backends.rolldown").trace(runRolldown);
-	let handler = null;
-	for (const entry of out.output) if (entry.type === "chunk") {
-		if (entry.isEntry) handler = entry.fileName;
 	}
-	if (typeof handler !== "string") throw new Error(`Unable to resolve module for ${args.entrypoint}`);
-	const outputFiles = await nodeFileTrace({
-		outDir: outputDir,
-		tracedPaths: Array.from(context.tracedPaths),
-		repoRootPath: args.repoRootPath,
-		workPath: args.workPath,
-		keepTracedPaths: false,
-		span: args.span
-	});
-	const cleanup = async () => {
-		await rm(outputDir, {
-			recursive: true,
-			force: true
-		});
-	};
+	if (!resolvedFormat) throw new Error(`Unable to resolve format for ${args.entrypoint}`);
 	return {
-		result: {
-			handler,
-			outputDir,
-			outputFiles
-		},
-		cleanup
+		format: resolvedFormat,
+		extension: resolvedFormat === "esm" ? "mjs" : "cjs"
 	};
 };
 
 //#endregion
-//#region src/cervel/utils.ts
-const noColor = globalThis.process?.env?.NO_COLOR === "1" || globalThis.process?.env?.TERM === "dumb";
-const resets = {
-	1: 22,
-	31: 39,
-	32: 39,
-	33: 39,
-	34: 39,
-	35: 39,
-	36: 39,
-	90: 39
-};
-const _c = (c) => (text) => {
-	if (noColor) return text;
-	return `\u001B[${c}m${text}\u001B[${resets[c] ?? 0}m`;
-};
-const Colors = {
-	bold: _c(1),
-	red: _c(31),
-	green: _c(32),
-	yellow: _c(33),
-	blue: _c(34),
-	magenta: _c(35),
-	cyan: _c(36),
-	gray: _c(90),
-	url: (title, url) => noColor ? `[${title}](${url})` : `\u001B]8;;${url}\u001B\\${title}\u001B]8;;\u001B\\`
-};
-
-//#endregion
-//#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);
-		if (![
-			".ts",
-			".mts",
-			".cts"
-		].includes(extension)) return;
-		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(args, ts);
-	});
-};
-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");
+//#region src/service-vc-init.ts
+async function applyServiceVcInit(args) {
+	const { format, extension } = await resolveShimFormat$1(args);
+	const handlerDir = dirname(args.handler);
+	const vcInitName = `${basename(args.handler, extname(args.handler))}.__vc_service_vc_init${extension}`;
+	const vcInitHandler = handlerDir === "." ? vcInitName : join(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
+			})
 		}
-		const parsed = ts.parseJsonConfigFileContent(configRead.config, ts.sys, dirname(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");
 }
-function resolveTypeScriptModule(workPath) {
-	try {
-		return require_(require_.resolve("typescript", { paths: [workPath] }));
-	} catch (_e) {
-		return null;
-	}
+async function resolveShimFormat$1(args) {
+	const { format } = await resolveEntrypointAndFormat({
+		entrypoint: args.handler,
+		workPath: args.workPath
+	});
+	return {
+		format,
+		extension: extname(args.handler) || (format === "esm" ? ".mjs" : ".cjs")
+	};
 }
-const findNearestTsconfig = async (workPath) => {
-	const tsconfigPath = join(workPath, "tsconfig.json");
-	if (existsSync(tsconfigPath)) return tsconfigPath;
-	if (workPath === "/") return;
-	return findNearestTsconfig(join(workPath, ".."));
-};
-
-//#endregion
-//#region src/find-entrypoint.ts
-const frameworks = [
-	"express",
-	"hono",
-	"elysia",
-	"fastify",
-	"@nestjs/core",
-	"h3"
-];
-const entrypointFilenames = [
-	"app",
-	"index",
-	"server",
-	"main",
-	"src/app",
-	"src/index",
-	"src/server",
-	"src/main"
-];
-const entrypointExtensions = [
-	"js",
-	"cjs",
-	"mjs",
-	"ts",
-	"cts",
-	"mts"
-];
-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 packageJsonObject = null;
-	try {
-		const packageJson = await readFile(join(cwd, "package.json"), "utf-8");
-		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(cwd, entrypoint);
-		try {
-			await readFile(entrypointPath, "utf-8");
-			return entrypoint;
-		} catch (_) {}
-	}
-	const regex = framework ? createFrameworkRegex(framework) : void 0;
-	for (const entrypoint of entrypoints) {
-		const entrypointPath = join(cwd, entrypoint);
-		try {
-			const content = await readFile(entrypointPath, "utf-8");
-			if (regex) {
-				if (regex.test(content)) return entrypoint;
-			}
-		} catch (_) {}
-	}
-};
-const findEntrypointOrThrow = async (cwd) => {
-	const entrypoint = await findEntrypoint(cwd);
-	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;
-};
-/**
-* Normalized entrypoint detector for Node services. Wraps {@link findEntrypoint}
-* and returns the result in the shared {@link DetectedEntrypoint} shape consumed
-* by services auto-detection.
-*/
-const detectEntrypoint = async ({ workPath }) => {
-	const file = await findEntrypoint(workPath);
-	if (!file) return null;
-	return {
-		kind: "file",
-		entrypoint: file
-	};
-};
-
-//#endregion
-//#region src/cervel/index.ts
-const require$2 = createRequire(import.meta.url);
-const getBuildSummary = async (outputDir) => {
-	const buildSummary = await readFile$1(join(outputDir, ".cervel.json"), "utf-8");
-	return JSON.parse(buildSummary);
-};
-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({
-		entrypoint,
-		workPath: args.workPath,
-		span
-	}), rolldown$1({
-		entrypoint,
-		workPath: args.workPath,
-		repoRootPath: args.repoRootPath,
-		out: args.out,
-		span
-	})]);
-	await writeFile(join(args.workPath, args.out, ".cervel.json"), JSON.stringify({ handler: rolldownResult.result.handler }, null, 2));
-	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) => {
-	const entrypoint = await findEntrypointOrThrow(args.workPath);
-	const srvxBin = join(require$2.resolve("srvx"), "..", "..", "..", "bin", "srvx.mjs");
-	const tsxBin = require$2.resolve("tsx");
-	const restArgs = Object.entries(args.rest).filter(([, value]) => value !== void 0 && value !== false).map(([key, value]) => typeof value === "boolean" ? `--${key}` : `--${key}=${value}`);
-	if (!args.rest.import) restArgs.push("--import", tsxBin);
-	await execa("npx", [
-		srvxBin,
-		...restArgs,
-		entrypoint
-	], {
-		cwd: args.workPath,
-		stdio: "inherit"
-	});
-};
-const srvxOptions = {
-	help: {
-		type: "boolean",
-		short: "h"
-	},
-	version: {
-		type: "boolean",
-		short: "v"
-	},
-	prod: { type: "boolean" },
-	port: {
-		type: "string",
-		short: "p"
-	},
-	host: {
-		type: "string",
-		short: "H"
-	},
-	static: {
-		type: "string",
-		short: "s"
-	},
-	import: { type: "string" },
-	tls: { type: "boolean" },
-	cert: { type: "string" },
-	key: { type: "string" }
-};
-
-//#endregion
-//#region src/rolldown/resolve-format.ts
-const resolveEntrypointAndFormat = async (args) => {
-	const extension = extname(args.entrypoint);
-	const extensionMap = {
-		".ts": {
-			format: "auto",
-			extension: "js"
-		},
-		".mts": {
-			format: "esm",
-			extension: "mjs"
-		},
-		".cts": {
-			format: "cjs",
-			extension: "cjs"
-		},
-		".cjs": {
-			format: "cjs",
-			extension: "cjs"
-		},
-		".js": {
-			format: "auto",
-			extension: "js"
-		},
-		".mjs": {
-			format: "esm",
-			extension: "mjs"
-		}
-	};
-	const extensionInfo = extensionMap[extension] || extensionMap[".js"];
-	let resolvedFormat = extensionInfo.format === "auto" ? args.defaultFormat : extensionInfo.format;
-	const packageJsonPath = join(args.workPath, "package.json");
-	let pkg = {};
-	if (existsSync(packageJsonPath)) {
-		const source = await readFile(packageJsonPath, "utf8");
-		try {
-			pkg = JSON.parse(source.toString());
-		} catch (_e) {
-			pkg = {};
-		}
-		if (extensionInfo.format === "auto") if (pkg.type === "module") resolvedFormat = "esm";
-		else resolvedFormat = "cjs";
-	}
-	if (!resolvedFormat) throw new Error(`Unable to resolve format for ${args.entrypoint}`);
-	return {
-		format: resolvedFormat,
-		extension: resolvedFormat === "esm" ? "mjs" : "cjs"
-	};
-};
-
-//#endregion
-//#region src/service-vc-init.ts
-async function applyServiceVcInit(args) {
-	const { format, extension } = await resolveShimFormat$1(args);
-	const handlerDir = dirname(args.handler);
-	const vcInitName = `${basename(args.handler, extname(args.handler))}.__vc_service_vc_init${extension}`;
-	const vcInitHandler = handlerDir === "." ? vcInitName : join(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$1(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')
+const sharedShimPrelude = String.raw`
+const PATCH_SYMBOL = Symbol.for('vc.service.route-prefix-strip.patch')
 
 function normalizeServiceRoutePrefix(rawPrefix) {
   if (!rawPrefix) {
@@ -906,7 +402,7 @@ async function applyCronDispatch(args) {
 	const handlerDir = posix.dirname(args.handler);
 	const dispatchName = `${posix.basename(args.handler, extname(args.handler))}.__vc_cron_dispatch${extension}`;
 	const dispatchHandler = handlerDir === "." ? dispatchName : posix.join(handlerDir, dispatchName);
-	const handlerImportPath = `./${posix.basename(args.handler)}`;
+	const handlerImportPath = args.modulePathOverride ?? `./${posix.basename(args.handler)}`;
 	const routesJson = JSON.stringify(args.routes);
 	if (routesJson.includes("\\") || routesJson.includes("'")) throw new Error(`cron route table contains characters that need JS-string escaping: ${routesJson}`);
 	const dispatchSource = (format === "esm" ? ESM_TEMPLATE : CJS_TEMPLATE).replace(USER_MODULE_PLACEHOLDER, JSON.stringify(handlerImportPath)).replace(ROUTES_PLACEHOLDER, `'${routesJson}'`);
@@ -962,6 +458,515 @@ async function getServiceCrons(opts) {
 	}];
 }
 
+//#endregion
+//#region src/cervel/plugin.ts
+const CJS_SHIM_PREFIX$1 = "\0cjs-shim:";
+const plugin = (args) => {
+	const packageJsonCache = /* @__PURE__ */ new Map();
+	const shimMeta = /* @__PURE__ */ new Map();
+	const { tracedPaths } = args.context;
+	const isBareImport = (id) => {
+		return !id.startsWith(".") && !id.startsWith("/") && !/^[a-z][a-z0-9+.-]*:/i.test(id);
+	};
+	/**
+	* Read and cache package.json contents
+	*/
+	const getPackageJson = async (pkgPath) => {
+		if (packageJsonCache.has(pkgPath)) return packageJsonCache.get(pkgPath);
+		try {
+			const contents = await readFile(pkgPath, "utf-8");
+			const parsed = JSON.parse(contents);
+			packageJsonCache.set(pkgPath, parsed);
+			return parsed;
+		} catch {
+			packageJsonCache.set(pkgPath, null);
+			return null;
+		}
+	};
+	/**
+	* Determine if a resolved module is CommonJS based on package.json exports
+	*/
+	const isCommonJS = async (bareImport, resolvedPath, resolvedInfo) => {
+		const ext = extname(resolvedPath);
+		if (ext === ".cjs") return true;
+		if (ext === ".mjs") return false;
+		if (ext === ".js" || ext === ".ts") {
+			const pkgJsonPath = resolvedInfo.packageJsonPath;
+			if (!pkgJsonPath) return true;
+			const pkgJson = await getPackageJson(pkgJsonPath);
+			if (!pkgJson) return true;
+			const pkgDir = dirname(pkgJsonPath);
+			const relativePath = resolvedPath.startsWith(pkgDir) ? resolvedPath.slice(pkgDir.length + 1).replace(/\\/g, "/") : null;
+			if (!relativePath) return pkgJson.type !== "module";
+			const pkgName = pkgJson.name || "";
+			const subpath = bareImport.startsWith(pkgName) ? `.${bareImport.slice(pkgName.length)}` || "." : ".";
+			try {
+				if (exports(pkgJson, subpath, {
+					require: false,
+					conditions: ["node", "import"]
+				})?.some((p) => p === relativePath || p === `./${relativePath}`)) return false;
+				if (exports(pkgJson, subpath, {
+					require: true,
+					conditions: ["node", "require"]
+				})?.some((p) => p === relativePath || p === `./${relativePath}`)) return true;
+			} catch (err) {
+				console.warn("Export resolution failed::", err);
+			}
+			if (pkgJson.module) return false;
+			return pkgJson.type !== "module";
+		}
+		return true;
+	};
+	const isLocalImport = (id) => {
+		if (id.startsWith("node:")) return false;
+		if (id.includes("node_modules")) return false;
+		return true;
+	};
+	return {
+		name: "cervel",
+		resolveId: {
+			order: "pre",
+			async handler(id, importer, rOpts) {
+				if (id.startsWith(CJS_SHIM_PREFIX$1)) return {
+					id,
+					external: false
+				};
+				const resolved = await this.resolve(id, importer, rOpts);
+				if (builtinModules.includes(id)) return {
+					id: `node:${id}`,
+					external: true
+				};
+				if (resolved?.id && isLocalImport(resolved.id)) tracedPaths.add(resolved.id);
+				if (importer?.startsWith(CJS_SHIM_PREFIX$1) && isBareImport(id)) return {
+					id,
+					external: true
+				};
+				if (importer && isBareImport(id) && resolved?.id?.includes("node_modules")) {
+					if (args.shimBareImports) {
+						if (await isCommonJS(id, resolved.id, resolved)) {
+							const importerPkgJsonPath = (await this.resolve(importer))?.packageJsonPath;
+							if (importerPkgJsonPath) {
+								const importerPkgDir = relative(args.repoRootPath, dirname(importerPkgJsonPath));
+								const shimId$1 = `${CJS_SHIM_PREFIX$1}${importerPkgDir.replace(/\//g, "_")}_${id.replace(/\//g, "_")}`;
+								shimMeta.set(shimId$1, {
+									pkgDir: importerPkgDir,
+									pkgName: id
+								});
+								return {
+									id: shimId$1,
+									external: false
+								};
+							}
+							const shimId = `${CJS_SHIM_PREFIX$1}${id.replace(/\//g, "_")}`;
+							shimMeta.set(shimId, {
+								pkgDir: "",
+								pkgName: id
+							});
+							return {
+								id: shimId,
+								external: false
+							};
+						}
+					}
+					return {
+						external: true,
+						id
+					};
+				}
+				if (importer && isBareImport(id)) return resolved;
+				return {
+					external: true,
+					...resolved,
+					id: resolved?.id || id
+				};
+			}
+		},
+		load: { async handler(id) {
+			if (id.startsWith(CJS_SHIM_PREFIX$1)) {
+				const meta = shimMeta.get(id);
+				if (!meta) return { code: `module.exports = require('${id.slice(10)}');` };
+				const { pkgDir, pkgName } = meta;
+				if (pkgDir) return { code: `
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const requireFromContext = createRequire(join(dirname(fileURLToPath(import.meta.url)), '${join("..", pkgDir, "package.json")}'));
+module.exports = requireFromContext('${pkgName}');
+`.trim() };
+				return { code: `module.exports = require('${pkgName}');` };
+			}
+			return null;
+		} }
+	};
+};
+
+//#endregion
+//#region src/cervel/node-file-trace.ts
+const nodeFileTrace = async (args) => {
+	const { span } = args;
+	const files = {};
+	const { tracedPaths } = args;
+	const compiledSourceFiles = await glob("**/*", {
+		cwd: args.outDir,
+		follow: true,
+		includeDirectories: true
+	});
+	for (const file of Object.keys(compiledSourceFiles)) files[file] = compiledSourceFiles[file];
+	/**
+	* While we're not using NFT to process source code, we are using it
+	* to tree shake node deps, and include any fs reads for files that are
+	* not part of the traced paths or compiled source files.
+	* Most of this is identical to the `@vercel/node` implementation
+	*/
+	const runNft = () => nodeFileTrace$1(Array.from(tracedPaths), {
+		base: args.repoRootPath,
+		processCwd: args.workPath,
+		ts: true,
+		mixedModules: true,
+		async resolve(id, parent, job, cjsResolve) {
+			return resolve$1(id, parent, job, cjsResolve);
+		},
+		async readFile(fsPath) {
+			try {
+				let source = await readFile(fsPath);
+				if (fsPath.endsWith(".ts") && !fsPath.endsWith(".d.ts") || fsPath.endsWith(".tsx") || fsPath.endsWith(".mts") || fsPath.endsWith(".cts")) source = (await transform(fsPath, source.toString())).code;
+				return source;
+			} catch (error) {
+				if (isNativeError(error) && "code" in error && (error.code === "ENOENT" || error.code === "EISDIR")) return null;
+				throw error;
+			}
+		}
+	});
+	const result = await span.child("vc.builder.backends.nft").trace(runNft);
+	if (!args.keepTracedPaths) for (const file of tracedPaths) {
+		const relativeFile = relative(args.repoRootPath, file);
+		result.fileList.delete(relativeFile);
+	}
+	debug("NFT traced files count:", result.fileList.size);
+	for (const file of result.fileList) {
+		const absolutePath = join(args.repoRootPath, file);
+		const stats = await lstat(absolutePath);
+		const outputPath = file;
+		if (stats.isSymbolicLink() || stats.isFile()) files[outputPath] = new FileFsRef({
+			fsPath: absolutePath,
+			mode: stats.mode
+		});
+	}
+	debug("Total files in context:", Object.keys(files).length);
+	return files;
+};
+
+//#endregion
+//#region src/cervel/rolldown.ts
+const __dirname__filenameShim = `
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+var require = typeof require !== 'undefined' ? require : __createRequire(import.meta.url);
+var __filename = typeof __filename !== 'undefined' ? __filename : __fileURLToPath(import.meta.url);
+var __dirname = typeof __dirname !== 'undefined' ? __dirname : __dirname_(__filename);
+`.trim();
+const rolldown$1 = async (args) => {
+	const entrypointPath = join(args.workPath, args.entrypoint);
+	const outputDir = join(args.workPath, args.out);
+	const extension = extname(args.entrypoint);
+	const extensionMap = {
+		".ts": {
+			format: "auto",
+			extension: "js"
+		},
+		".mts": {
+			format: "esm",
+			extension: "mjs"
+		},
+		".cts": {
+			format: "cjs",
+			extension: "cjs"
+		},
+		".cjs": {
+			format: "cjs",
+			extension: "cjs"
+		},
+		".js": {
+			format: "auto",
+			extension: "js"
+		},
+		".mjs": {
+			format: "esm",
+			extension: "mjs"
+		}
+	};
+	const extensionInfo = extensionMap[extension] || extensionMap[".js"];
+	let resolvedFormat = extensionInfo.format === "auto" ? void 0 : extensionInfo.format;
+	const packageJsonPath = join(args.workPath, "package.json");
+	const external = [];
+	let pkg = {};
+	if (existsSync(packageJsonPath)) {
+		const source = await readFile(packageJsonPath, "utf8");
+		try {
+			pkg = JSON.parse(source.toString());
+		} catch (_e) {
+			pkg = {};
+		}
+		if (extensionInfo.format === "auto") if (pkg.type === "module") resolvedFormat = "esm";
+		else resolvedFormat = "cjs";
+		for (const dependency of Object.keys(pkg.dependencies || {})) external.push(dependency);
+		for (const dependency of Object.keys(pkg.devDependencies || {})) external.push(dependency);
+		for (const dependency of Object.keys(pkg.peerDependencies || {})) external.push(dependency);
+		for (const dependency of Object.keys(pkg.optionalDependencies || {})) external.push(dependency);
+	}
+	const resolvedExtension = resolvedFormat === "esm" ? "mjs" : "cjs";
+	const context = { tracedPaths: /* @__PURE__ */ new Set() };
+	const runRolldown = () => build$2({
+		input: entrypointPath,
+		cwd: args.workPath,
+		platform: "node",
+		tsconfig: true,
+		plugins: [plugin({
+			repoRootPath: args.repoRootPath,
+			outDir: outputDir,
+			workPath: args.workPath,
+			shimBareImports: resolvedFormat === "esm",
+			context
+		})],
+		output: {
+			cleanDir: true,
+			dir: outputDir,
+			format: resolvedFormat,
+			entryFileNames: `[name].${resolvedExtension}`,
+			preserveModules: true,
+			preserveModulesRoot: args.repoRootPath,
+			sourcemap: false,
+			banner: resolvedFormat === "esm" ? __dirname__filenameShim : void 0
+		}
+	});
+	const out = await args.span.child("vc.builder.backends.rolldown").trace(runRolldown);
+	let handler = null;
+	for (const entry of out.output) if (entry.type === "chunk") {
+		if (entry.isEntry) handler = entry.fileName;
+	}
+	if (typeof handler !== "string") throw new Error(`Unable to resolve module for ${args.entrypoint}`);
+	const outputFiles = await nodeFileTrace({
+		outDir: outputDir,
+		tracedPaths: Array.from(context.tracedPaths),
+		repoRootPath: args.repoRootPath,
+		workPath: args.workPath,
+		keepTracedPaths: false,
+		span: args.span
+	});
+	const cleanup = async () => {
+		await rm(outputDir, {
+			recursive: true,
+			force: true
+		});
+	};
+	return {
+		result: {
+			handler,
+			outputDir,
+			outputFiles
+		},
+		cleanup
+	};
+};
+
+//#endregion
+//#region src/cervel/utils.ts
+const noColor = globalThis.process?.env?.NO_COLOR === "1" || globalThis.process?.env?.TERM === "dumb";
+const resets = {
+	1: 22,
+	31: 39,
+	32: 39,
+	33: 39,
+	34: 39,
+	35: 39,
+	36: 39,
+	90: 39
+};
+const _c = (c) => (text) => {
+	if (noColor) return text;
+	return `\u001B[${c}m${text}\u001B[${resets[c] ?? 0}m`;
+};
+const Colors = {
+	bold: _c(1),
+	red: _c(31),
+	green: _c(32),
+	yellow: _c(33),
+	blue: _c(34),
+	magenta: _c(35),
+	cyan: _c(36),
+	gray: _c(90),
+	url: (title, url) => noColor ? `[${title}](${url})` : `\u001B]8;;${url}\u001B\\${title}\u001B]8;;\u001B\\`
+};
+
+//#endregion
+//#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);
+		if (![
+			".ts",
+			".mts",
+			".cts"
+		].includes(extension)) return;
+		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(args, ts);
+	});
+};
+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(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");
+}
+function resolveTypeScriptModule(workPath) {
+	try {
+		return require_(require_.resolve("typescript", { paths: [workPath] }));
+	} catch (_e) {
+		return null;
+	}
+}
+const findNearestTsconfig = async (workPath) => {
+	const tsconfigPath = join(workPath, "tsconfig.json");
+	if (existsSync(tsconfigPath)) return tsconfigPath;
+	if (workPath === "/") return;
+	return findNearestTsconfig(join(workPath, ".."));
+};
+
+//#endregion
+//#region src/cervel/index.ts
+const require$2 = createRequire(import.meta.url);
+const getBuildSummary = async (outputDir) => {
+	const buildSummary = await readFile$1(join(outputDir, ".cervel.json"), "utf-8");
+	return JSON.parse(buildSummary);
+};
+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({
+		entrypoint,
+		workPath: args.workPath,
+		span
+	}), rolldown$1({
+		entrypoint,
+		workPath: args.workPath,
+		repoRootPath: args.repoRootPath,
+		out: args.out,
+		span
+	})]);
+	await writeFile(join(args.workPath, args.out, ".cervel.json"), JSON.stringify({ handler: rolldownResult.result.handler }, null, 2));
+	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) => {
+	const entrypoint = await findEntrypointOrThrow(args.workPath);
+	const srvxBin = join(require$2.resolve("srvx"), "..", "..", "..", "bin", "srvx.mjs");
+	const tsxBin = require$2.resolve("tsx");
+	const restArgs = Object.entries(args.rest).filter(([, value]) => value !== void 0 && value !== false).map(([key, value]) => typeof value === "boolean" ? `--${key}` : `--${key}=${value}`);
+	if (!args.rest.import) restArgs.push("--import", tsxBin);
+	await execa("npx", [
+		srvxBin,
+		...restArgs,
+		entrypoint
+	], {
+		cwd: args.workPath,
+		stdio: "inherit"
+	});
+};
+const srvxOptions = {
+	help: {
+		type: "boolean",
+		short: "h"
+	},
+	version: {
+		type: "boolean",
+		short: "v"
+	},
+	prod: { type: "boolean" },
+	port: {
+		type: "string",
+		short: "p"
+	},
+	host: {
+		type: "string",
+		short: "H"
+	},
+	static: {
+		type: "string",
+		short: "s"
+	},
+	import: { type: "string" },
+	tls: { type: "boolean" },
+	cert: { type: "string" },
+	key: { type: "string" }
+};
+
 //#endregion
 //#region src/rolldown/nft.ts
 const nft = async (args) => {
@@ -1669,8 +1674,7 @@ const build = async (args) => {
 	span.setAttributes({ "builder.name": builderName });
 	const buildSpan = span.child("vc.builder.backends.build");
 	return buildSpan.trace(async () => {
-		const explicit = args.entrypoint && args.entrypoint !== "package.json" ? args.entrypoint : null;
-		const entrypoint = explicit && existsSync(join(args.workPath, explicit)) ? explicit : await findEntrypointOrThrow(args.workPath);
+		const entrypoint = await findEntrypointWithHintOrThrow(args.workPath, args.entrypoint);
 		debug("Entrypoint", entrypoint);
 		args.entrypoint = entrypoint;
 		const cronEntries = await getServiceCrons({