@vercel/backends 0.3.0 → 0.4.0

package/dist/index.d.mts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import * as _vercel_build_utils0 from "@vercel/build-utils";
 import { BuildOptions, BuildV2, Files, PrepareCache, Span } from "@vercel/build-utils";
 import { ParseArgsConfig } from "node:util";

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import { builtinModules, createRequire } from "node:module";
-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 { createWriteStream, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import path, { delimiter, dirname as dirname$1, join as join$1 } from "path";
+import { FileBlob, FileFsRef, MANIFEST_VERSION, NodejsLambda, Span, createDiagnostics, debug, defaultCachePathGlob, download, execCommand, getEnvForPackageManager, getInternalServiceCronPath, getLambdaOptionsFromFunction, getNodeBinPaths, getNodeVersion, getReportedServiceType, glob, isBackendFramework, isBunVersion, isExperimentalBackendsWithoutIntrospectionEnabled, isScheduleTriggeredService, 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 { 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";
@@ -14,6 +14,7 @@ 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";
@@ -22,7 +23,7 @@ import { z } from "zod";
 async function downloadInstallAndBundle(args) {
 	const { entrypoint, files, workPath, meta, config, repoRootPath } = args;
 	await download(files, workPath, meta);
-	const entrypointFsDirname = join(workPath, dirname(entrypoint));
+	const entrypointFsDirname = join$1(workPath, dirname$1(entrypoint));
 	const { cliType, lockfilePath, lockfileVersion, packageJsonPackageManager, turboSupportsCorepackHome } = await scanParentDirs(entrypointFsDirname, true, repoRootPath);
 	const spawnEnv = getEnvForPackageManager({
 		cliType,
@@ -352,7 +353,7 @@ function buildDirectMaps(pkgJson) {
 		directRequested
 	};
 }
-async function generateProjectManifest({ workPath, nodeVersion, cliType, lockfilePath, lockfileVersion, framework }) {
+async function generateProjectManifest({ workPath, nodeVersion, cliType, lockfilePath, lockfileVersion, framework, serviceType }) {
 	try {
 		const pkgJson = await readPackageJson(workPath);
 		if (!pkgJson) return;
@@ -402,6 +403,7 @@ async function generateProjectManifest({ workPath, nodeVersion, cliType, lockfil
 			version: MANIFEST_VERSION,
 			runtime: "node",
 			...framework ? { framework } : {},
+			...serviceType ? { serviceType } : {},
 			runtimeVersion,
 			dependencies: [...directDeps.sort((a, b) => a.name.localeCompare(b.name)), ...transitiveDeps.sort((a, b) => a.name.localeCompare(b.name))]
 		}, workPath, "node");
@@ -448,7 +450,7 @@ const plugin = (args) => {
 			if (!pkgJsonPath) return true;
 			const pkgJson = await getPackageJson(pkgJsonPath);
 			if (!pkgJson) return true;
-			const pkgDir = dirname$1(pkgJsonPath);
+			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 || "";
@@ -499,7 +501,7 @@ const plugin = (args) => {
 						if (await isCommonJS(id, resolved.id, resolved)) {
 							const importerPkgJsonPath = (await this.resolve(importer))?.packageJsonPath;
 							if (importerPkgJsonPath) {
-								const importerPkgDir = relative(args.repoRootPath, dirname$1(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,
@@ -544,7 +546,7 @@ 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$1("..", pkgDir, "package.json")}'));
+const requireFromContext = createRequire(join(dirname(fileURLToPath(import.meta.url)), '${join("..", pkgDir, "package.json")}'));
 module.exports = requireFromContext('${pkgName}');
 `.trim() };
 				return { code: `module.exports = require('${pkgName}');` };
@@ -598,7 +600,7 @@ const nodeFileTrace = async (args) => {
 	}
 	debug("NFT traced files count:", result.fileList.size);
 	for (const file of result.fileList) {
-		const absolutePath = join$1(args.repoRootPath, file);
+		const absolutePath = join(args.repoRootPath, file);
 		const stats = await lstat(absolutePath);
 		const outputPath = file;
 		if (stats.isSymbolicLink() || stats.isFile()) files[outputPath] = new FileFsRef({
@@ -621,8 +623,8 @@ var __filename = typeof __filename !== 'undefined' ? __filename : __fileURLToPat
 var __dirname = typeof __dirname !== 'undefined' ? __dirname : __dirname_(__filename);
 `.trim();
 const rolldown$1 = async (args) => {
-	const entrypointPath = join$1(args.workPath, args.entrypoint);
-	const outputDir = join$1(args.workPath, args.out);
+	const entrypointPath = join(args.workPath, args.entrypoint);
+	const outputDir = join(args.workPath, args.out);
 	const extension = extname(args.entrypoint);
 	const extensionMap = {
 		".ts": {
@@ -652,7 +654,7 @@ const rolldown$1 = async (args) => {
 	};
 	const extensionInfo = extensionMap[extension] || extensionMap[".js"];
 	let resolvedFormat = extensionInfo.format === "auto" ? void 0 : extensionInfo.format;
-	const packageJsonPath = join$1(args.workPath, "package.json");
+	const packageJsonPath = join(args.workPath, "package.json");
 	const external = [];
 	let pkg = {};
 	if (existsSync(packageJsonPath)) {
@@ -807,7 +809,7 @@ async function doTypeCheck(args, ts) {
 			console.error(message);
 			throw new Error("TypeScript type check failed");
 		}
-		const parsed = ts.parseJsonConfigFileContent(configRead.config, ts.sys, dirname$1(tsconfig), void 0, tsconfig);
+		const parsed = ts.parseJsonConfigFileContent(configRead.config, ts.sys, dirname(tsconfig), void 0, tsconfig);
 		parseDiagnostics = parsed.errors;
 		options = {
 			...parsed.options,
@@ -846,10 +848,10 @@ function resolveTypeScriptModule(workPath) {
 	}
 }
 const findNearestTsconfig = async (workPath) => {
-	const tsconfigPath = join$1(workPath, "tsconfig.json");
+	const tsconfigPath = join(workPath, "tsconfig.json");
 	if (existsSync(tsconfigPath)) return tsconfigPath;
 	if (workPath === "/") return;
-	return findNearestTsconfig(join$1(workPath, ".."));
+	return findNearestTsconfig(join(workPath, ".."));
 };
 
 //#endregion
@@ -885,7 +887,7 @@ const createFrameworkRegex = (framework) => new RegExp(`(?:from|require|import)\
 const findEntrypoint = async (cwd) => {
 	let packageJsonObject = null;
 	try {
-		const packageJson = await readFile(join$1(cwd, "package.json"), "utf-8");
+		const packageJson = await readFile(join(cwd, "package.json"), "utf-8");
 		packageJsonObject = JSON.parse(packageJson);
 	} catch (_) {}
 	if (packageJsonObject) {
@@ -902,7 +904,7 @@ const findEntrypoint = async (cwd) => {
 	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);
+		const entrypointPath = join(cwd, entrypoint);
 		try {
 			await readFile(entrypointPath, "utf-8");
 			return entrypoint;
@@ -910,7 +912,7 @@ const findEntrypoint = async (cwd) => {
 	}
 	const regex = framework ? createFrameworkRegex(framework) : void 0;
 	for (const entrypoint of entrypoints) {
-		const entrypointPath = join$1(cwd, entrypoint);
+		const entrypointPath = join(cwd, entrypoint);
 		try {
 			const content = await readFile(entrypointPath, "utf-8");
 			if (regex) {
@@ -929,7 +931,7 @@ const findEntrypointOrThrow = async (cwd) => {
 //#region src/cervel/index.ts
 const require$2 = createRequire(import.meta.url);
 const getBuildSummary = async (outputDir) => {
-	const buildSummary = await readFile$1(join$1(outputDir, ".cervel.json"), "utf-8");
+	const buildSummary = await readFile$1(join(outputDir, ".cervel.json"), "utf-8");
 	return JSON.parse(buildSummary);
 };
 const build$1 = async (args) => {
@@ -946,13 +948,13 @@ const build$1 = async (args) => {
 		out: args.out,
 		span
 	})]);
-	await writeFile(join$1(args.workPath, args.out, ".cervel.json"), JSON.stringify({ handler: rolldownResult.result.handler }, null, 2));
+	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$1(require$2.resolve("srvx"), "..", "..", "..", "bin", "srvx.mjs");
+	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);
@@ -1024,8 +1026,8 @@ const resolveEntrypointAndFormat = async (args) => {
 		}
 	};
 	const extensionInfo = extensionMap[extension] || extensionMap[".js"];
-	let resolvedFormat = extensionInfo.format === "auto" ? void 0 : extensionInfo.format;
-	const packageJsonPath = join$1(args.workPath, "package.json");
+	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");
@@ -1047,10 +1049,10 @@ 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 { 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$1(handlerDir, vcInitName);
+	const vcInitHandler = handlerDir === "." ? vcInitName : join(handlerDir, vcInitName);
 	const handlerImportPath = `./${basename(args.handler)}`;
 	const vcInitSource = format === "esm" ? createEsmServiceVcInit(handlerImportPath) : createCjsServiceVcInit(handlerImportPath);
 	return {
@@ -1064,7 +1066,7 @@ async function applyServiceVcInit(args) {
 		}
 	};
 }
-async function resolveShimFormat(args) {
+async function resolveShimFormat$1(args) {
 	const { format } = await resolveEntrypointAndFormat({
 		entrypoint: args.handler,
 		workPath: args.workPath
@@ -1205,6 +1207,96 @@ module.exports = require(${JSON.stringify(handlerImportPath)})
 `.trimStart();
 }
 
+//#endregion
+//#region src/cron-dispatch.ts
+const TEMPLATES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "templates");
+const ESM_TEMPLATE = readFileSync(join(TEMPLATES_DIR, "vc_cron_dispatch.mjs"), "utf-8");
+const CJS_TEMPLATE = readFileSync(join(TEMPLATES_DIR, "vc_cron_dispatch.cjs"), "utf-8");
+const USER_MODULE_PLACEHOLDER = /['"]__VC_USER_MODULE_PATH__['"]/g;
+const ROUTES_PLACEHOLDER = /'__VC_ROUTES_JSON__'/g;
+/**
+* Wrap a cron service handler with a dispatcher shim that:
+*   - looks up the inbound request path in a route table baked into the
+*     shim at build time and invokes the named export on the user module
+*     (or the default export when the table value is `"default"`)
+*   - verifies `CRON_SECRET` via `Authorization: Bearer ...` when set
+*
+* The dispatcher source lives in templates/vc_cron_dispatch.{mjs,cjs};
+* this function picks the right template, swaps in the user module
+* import path and the cron route table, and writes the result into the
+* lambda files.
+*
+* The route table is embedded inline rather than passed via a lambda
+* env var because AWS Lambda rejects env var names that don't start
+* with a letter — `__VC_CRON_ROUTES` would fail at deploy time. The
+* Python builder works around the same constraint by writing the route
+* table into its trampoline source.
+*/
+async function applyCronDispatch(args) {
+	const { format, extension } = await resolveShimFormat(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 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}'`);
+	return {
+		handler: dispatchHandler,
+		files: {
+			...args.files,
+			[dispatchHandler]: new FileBlob({
+				data: dispatchSource,
+				mode: 420
+			})
+		}
+	};
+}
+async function resolveShimFormat(args) {
+	const { format } = await resolveEntrypointAndFormat({
+		entrypoint: args.handler,
+		workPath: args.workPath,
+		defaultFormat: "cjs"
+	});
+	return {
+		format,
+		extension: extname(args.handler) || (format === "esm" ? ".mjs" : ".cjs")
+	};
+}
+
+//#endregion
+//#region src/crons.ts
+const DYNAMIC_SCHEDULE = "<dynamic>";
+/** Build the JSON route table embedded in `__VC_CRON_ROUTES`. */
+function buildCronRouteTable(crons) {
+	const table = {};
+	for (const cron of crons) table[cron.path] = "default";
+	return table;
+}
+/**
+* Compute cron entries for a JS/TS cron service build.
+*
+* Mirrors `packages/python/src/crons.ts` for static schedules. Returns
+* `undefined` when the service is not schedule-triggered. Throws on
+* `<dynamic>` schedules — that path is reserved for a follow-up.
+*
+* v1 always invokes the user module's default export, so this returns
+* plain `Cron[]` (no handler-name field). When `handlerFunction` or
+* `<dynamic>` support lands, this will need to grow a per-path handler
+* name back.
+*/
+function getServiceCrons(opts) {
+	const { service, entrypoint } = opts;
+	if (!service || !isScheduleTriggeredService(service)) return;
+	if (!service.name || typeof service.schedule !== "string") return;
+	if (!entrypoint) throw new Error("Cron service is missing an entrypoint");
+	if (service.schedule === DYNAMIC_SCHEDULE) throw new Error("Dynamic cron schedules (\"<dynamic>\") are not yet supported for JavaScript/TypeScript services. Use a static cron expression in vercel.json.");
+	return [{
+		path: getInternalServiceCronPath(service.name, entrypoint, "cron"),
+		schedule: service.schedule
+	}];
+}
+
 //#endregion
 //#region src/rolldown/nft.ts
 const nft = async (args) => {
@@ -1230,7 +1322,7 @@ const nft = async (args) => {
 			}
 		});
 		for (const file of nftResult.fileList) {
-			const absolutePath = join$1(args.repoRootPath, file);
+			const absolutePath = join(args.repoRootPath, file);
 			let stats;
 			try {
 				stats = await lstat(absolutePath);
@@ -1239,7 +1331,7 @@ const nft = async (args) => {
 				throw error;
 			}
 			const outputPath = file;
-			if (args.localBuildFiles.has(join$1(args.repoRootPath, outputPath))) continue;
+			if (args.localBuildFiles.has(join(args.repoRootPath, outputPath))) continue;
 			if (stats.isSymbolicLink() || stats.isFile()) if (args.ignoreNodeModules) {
 				if ((stats.isSymbolicLink() ? await stat(absolutePath) : stats).isFile()) {
 					const content = await readFile(absolutePath, "utf-8");
@@ -1297,7 +1389,7 @@ const rolldown = async (args) => {
 			if (!pkgJsonPath) return true;
 			const pkgJson = await getPackageJson(pkgJsonPath);
 			if (!pkgJson) return true;
-			const pkgDir = dirname$1(pkgJsonPath);
+			const pkgDir = dirname(pkgJsonPath);
 			const relativePath = resolvedPath.slice(pkgDir.length + 1).replace(/\\/g, "/");
 			const pkgName = pkgJson.name || "";
 			const subpath = bareImport.startsWith(pkgName) ? `.${bareImport.slice(pkgName.length)}` || "." : ".";
@@ -1354,7 +1446,7 @@ const rolldown = async (args) => {
 					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);
+						const candidate = join(args.workPath, id);
 						if (existsSync(candidate)) localBuildFiles.add(candidate);
 					}
 					if (importer?.startsWith(CJS_SHIM_PREFIX) && isBareImport(id)) return {
@@ -1371,7 +1463,7 @@ const rolldown = async (args) => {
 						if (resolved ? await isCommonJS(id, resolved.id, resolved) : false) {
 							const importerPkgJsonPath = (await this.resolve(importer))?.packageJsonPath;
 							if (importerPkgJsonPath) {
-								const importerPkgDir = relative(args.repoRootPath, dirname$1(importerPkgJsonPath));
+								const importerPkgDir = relative(args.repoRootPath, dirname(importerPkgJsonPath));
 								const shimId$1 = `${CJS_SHIM_PREFIX}${importerPkgDir.replace(/\//g, "_")}_${id.replace(/\//g, "_")}`;
 								shimMeta.set(shimId$1, {
 									pkgDir: importerPkgDir,
@@ -1412,7 +1504,7 @@ 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)), '${pkgDir ? join$1("..", pkgDir, "package.json") : "../package.json"}'));
+const requireFromContext = createRequire(join(dirname(fileURLToPath(import.meta.url)), '${pkgDir ? join("..", pkgDir, "package.json") : "../package.json"}'));
 module.exports = requireFromContext('${pkgName}');
 `.trim() };
 				}
@@ -1495,13 +1587,13 @@ const introspection = async (args) => {
 	const runIntrospection = async () => {
 		const rolldownEsmLoaderPath = `file://${require$1.resolve("@vercel/backends/rolldown/esm")}`;
 		const rolldownCjsLoaderPath = require$1.resolve("@vercel/backends/rolldown/cjs-hooks");
-		const handlerPath = join$1(args.workPath, args.entrypoint);
+		const handlerPath = join(args.workPath, args.entrypoint);
 		const files = args.files;
-		const tmpDir = mkdtempSync(join$1(tmpdir(), "vercel-introspection-"));
+		const tmpDir = mkdtempSync(join(tmpdir(), "vercel-introspection-"));
 		for (const [key, value] of Object.entries(files)) {
 			if (!(value instanceof FileBlob) || typeof value.data !== "string") continue;
-			const filePath = join$1(tmpDir, key);
-			mkdirSync(dirname$1(filePath), { recursive: true });
+			const filePath = join(tmpDir, key);
+			mkdirSync(dirname(filePath), { recursive: true });
 			writeFileSync(filePath, value.data);
 		}
 		let introspectionData;
@@ -1509,8 +1601,8 @@ const introspection = async (args) => {
 		await new Promise((resolvePromise) => {
 			try {
 				debug("Spawning introspection process");
-				const outputTempDir = mkdtempSync(join$1(tmpdir(), "introspection-output-"));
-				const tempFilePath = join$1(outputTempDir, "output.txt");
+				const outputTempDir = mkdtempSync(join(tmpdir(), "introspection-output-"));
+				const tempFilePath = join(outputTempDir, "output.txt");
 				const writeStream = createWriteStream(tempFilePath);
 				let streamClosed = false;
 				const child = spawn("node", [
@@ -1673,7 +1765,7 @@ const maybeDoBuildCommand = async (args, downloadResult) => {
 	let outputDir;
 	let entrypoint;
 	if (buildCommandResult && outputSetting) if (outputSetting) {
-		const _outputDir = join$1(args.workPath, outputSetting);
+		const _outputDir = join(args.workPath, outputSetting);
 		const _entrypoint = await findEntrypointInOutputDir(_outputDir);
 		if (_entrypoint) {
 			outputDir = _outputDir;
@@ -1684,7 +1776,7 @@ const maybeDoBuildCommand = async (args, downloadResult) => {
 		"build",
 		"output"
 	]) {
-		const _outputDir = join$1(args.workPath, outputDirectory);
+		const _outputDir = join(args.workPath, outputDirectory);
 		if (existsSync(_outputDir)) {
 			const _entrypoint = await findEntrypointInOutputDir(_outputDir);
 			if (_entrypoint) {
@@ -1698,7 +1790,7 @@ const maybeDoBuildCommand = async (args, downloadResult) => {
 	let files;
 	if (outputDir && entrypoint) {
 		files = await glob("**", outputDir);
-		for (const file of Object.keys(files)) localBuildFiles.add(join$1(outputDir, file));
+		for (const file of Object.keys(files)) localBuildFiles.add(join(outputDir, file));
 	}
 	return {
 		localBuildFiles,
@@ -1717,7 +1809,7 @@ const introspectApp = async (args) => {
 	if (isExperimentalBackendsWithoutIntrospectionEnabled()) return defaultResult(args);
 	const cjsLoaderPath = require.resolve("@vercel/backends/introspection/loaders/cjs");
 	const rolldownEsmLoaderPath = `file://${require.resolve("@vercel/backends/introspection/loaders/rolldown-esm")}`;
-	const handlerPath = join$1(args.dir, args.handler);
+	const handlerPath = join(args.dir, args.handler);
 	const introspectionSchema$1 = z.object({
 		frameworkSlug: z.string().optional(),
 		routes: z.array(z.object({
@@ -1755,8 +1847,8 @@ const introspectApp = async (args) => {
 					...args.env
 				}
 			});
-			const tempDir = mkdtempSync(join$1(tmpdir(), "introspection-"));
-			const tempFilePath = join$1(tempDir, "output.txt");
+			const tempDir = mkdtempSync(join(tmpdir(), "introspection-"));
+			const tempFilePath = join(tempDir, "output.txt");
 			const writeStream = createWriteStream(tempFilePath);
 			let streamClosed = false;
 			child.stdout?.pipe(writeStream);
@@ -1872,9 +1964,9 @@ const getFramework = (args) => {
 		if (args.framework) {
 			const frameworkLibPath = require.resolve(`${args.framework}`, { paths: [args.dir] });
 			const findNearestPackageJson = (dir) => {
-				const packageJsonPath = join$1(dir, "package.json");
+				const packageJsonPath = join(dir, "package.json");
 				if (existsSync(packageJsonPath)) return packageJsonPath;
-				const parentDir = dirname$1(dir);
+				const parentDir = dirname(dir);
 				if (parentDir === dir) return;
 				return findNearestPackageJson(parentDir);
 			};
@@ -1903,6 +1995,7 @@ function hasExplicitBuildCommand(config) {
 	return typeof cmd === "string" && cmd.trim().length > 0;
 }
 const build = async (args) => {
+	if (typeof args.config?.handlerFunction === "string") throw new Error(`Named-function entrypoints are not supported for JavaScript services (got "${args.entrypoint}:${args.config.handlerFunction}"). Put each handler in its own file with a default export.`);
 	const downloadResult = await downloadInstallAndBundle(args);
 	const nodeVersion = await getNodeVersion(args.workPath, void 0, args.config, args.meta);
 	const isBun = isBunVersion(nodeVersion);
@@ -1911,9 +2004,15 @@ const build = async (args) => {
 	span.setAttributes({ "builder.name": builderName });
 	const buildSpan = span.child("vc.builder.backends.build");
 	return buildSpan.trace(async () => {
-		const entrypoint = await findEntrypointOrThrow(args.workPath);
+		const explicit = args.entrypoint && args.entrypoint !== "package.json" ? args.entrypoint : null;
+		const entrypoint = explicit && existsSync(join(args.workPath, explicit)) ? explicit : await findEntrypointOrThrow(args.workPath);
 		debug("Entrypoint", entrypoint);
 		args.entrypoint = entrypoint;
+		const cronEntries = getServiceCrons({
+			service: args.service,
+			entrypoint
+		});
+		const isCronService = cronEntries !== void 0;
 		const userBuildResult = await maybeDoBuildCommand(args, downloadResult);
 		const functionConfig = args.config.functions?.[entrypoint];
 		if (functionConfig) {
@@ -1922,9 +2021,10 @@ const build = async (args) => {
 		}
 		const rolldownResult = await rolldown({
 			...args,
-			span: buildSpan
+			span: buildSpan,
+			defaultFormat: isCronService ? "cjs" : void 0
 		});
-		const introspectionPromise = rolldownResult.framework.slug === "hono" ? introspection({
+		const introspectionPromise = !isCronService && rolldownResult.framework.slug === "hono" ? introspection({
 			...args,
 			span: buildSpan,
 			files: rolldownResult.files,
@@ -1964,7 +2064,8 @@ const build = async (args) => {
 				cliType: downloadResult.cliType,
 				lockfilePath: downloadResult.lockfilePath,
 				lockfileVersion: downloadResult.lockfileVersion,
-				framework: rolldownResult.framework.slug || void 0
+				framework: rolldownResult.framework.slug || void 0,
+				serviceType: args.service ? getReportedServiceType(args.service) : void 0
 			});
 		} catch (err) {
 			debug(`Failed to write node manifest: ${err instanceof Error ? err.message : String(err)}`);
@@ -1982,7 +2083,16 @@ const build = async (args) => {
 		const shouldStripServiceRoutePrefix = !!serviceRoutePrefix && (typeof args.config?.serviceName === "string" || !!args.service);
 		let lambdaFiles = files;
 		let lambdaHandler = handler;
-		if (shouldStripServiceRoutePrefix) {
+		if (isCronService && cronEntries) {
+			const dispatched = await applyCronDispatch({
+				files,
+				handler,
+				workPath: nftWorkPath,
+				routes: buildCronRouteTable(cronEntries)
+			});
+			lambdaFiles = dispatched.files;
+			lambdaHandler = dispatched.handler;
+		} else if (shouldStripServiceRoutePrefix) {
 			const shimmedLambda = await applyServiceVcInit({
 				files,
 				handler,
@@ -2018,7 +2128,7 @@ const build = async (args) => {
 				dest: internalServiceFunctionPath
 			};
 		};
-		const routes = [
+		const routes = isCronService ? [{ handle: "filesystem" }] : [
 			{ handle: "filesystem" },
 			...introspectionResult.routes.map(remapRouteDestination),
 			{
@@ -2034,7 +2144,8 @@ const build = async (args) => {
 		}
 		return {
 			routes,
-			output
+			output,
+			...cronEntries ? { crons: cronEntries } : {}
 		};
 	});
 };

package/dist/introspection/loaders/rolldown-hooks.d.mts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 //#region src/introspection/loaders/rolldown-hooks.d.ts
 declare function resolve(specifier: string, context: {
   parentURL?: string;

package/dist/rolldown/hooks.d.mts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 //#region src/rolldown/hooks.d.ts
 interface ResolveContext {
   parentURL?: string;

package/dist/rolldown/index.d.mts

@@ -1,8 +1,9 @@
 import { BuildOptions, Files, Span } from "@vercel/build-utils";
 
 //#region src/rolldown/index.d.ts
-declare const rolldown: (args: Pick<BuildOptions, 'entrypoint' | 'workPath' | 'repoRootPath' | 'config'> & {
+declare const rolldown: (args: Pick<BuildOptions, "entrypoint" | "workPath" | "repoRootPath" | "config"> & {
   span?: Span;
+  defaultFormat?: "esm" | "cjs";
 }) => Promise<{
   files: Files;
   handler: string;

package/dist/rolldown/index.mjs

@@ -68,7 +68,7 @@ const resolveEntrypointAndFormat = 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");
 	let pkg = {};
 	if (existsSync(packageJsonPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/backends",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",
   "homepage": "https://vercel.com/docs",
@@ -21,7 +21,8 @@
     "directory": "packages/backends"
   },
   "files": [
-    "dist"
+    "dist",
+    "templates"
   ],
   "dependencies": {
     "@yarnpkg/parsers": "^3.0.0",
@@ -36,19 +37,14 @@
     "srvx": "0.8.9",
     "tsx": "4.21.0",
     "zod": "3.22.4",
-    "@vercel/build-utils": "13.21.0"
-  },
-  "peerDependencies": {
-    "typescript": "^4.0.0 || ^5.0.0"
+    "@vercel/build-utils": "13.22.0"
   },
   "devDependencies": {
     "@types/express": "5.0.3",
-    "@types/js-yaml": "3.12.1",
     "@types/fs-extra": "11",
-    "@types/jest": "27.5.1",
+    "@types/js-yaml": "3.12.1",
     "@types/node": "20.11.0",
     "hono": "4.10.1",
-    "jest-junit": "16.0.0",
     "tsdown": "0.16.3",
     "vite": "^5.1.6",
     "vitest": "^2.0.1"

package/templates/vc_cron_dispatch.cjs

@@ -0,0 +1,119 @@
+// Runtime cron dispatcher (CJS). Generated into a Vercel cron service
+// lambda by `applyCronDispatch` in @vercel/backends. JS analog of
+// vercel-runtime/src/vercel_runtime/crons.py — pre-resolves the route
+// table at module load and dispatches inbound requests to the matching
+// handler on the user's module.
+//
+// `__VC_USER_MODULE_PATH__` is replaced at build time with the relative
+// path to the user's cron entrypoint.
+const { timingSafeEqual: __vc_timingSafeEqual } = require('node:crypto');
+const __vc_user_module = require('__VC_USER_MODULE_PATH__');
+
+function jsonResponse(res, status, body) {
+  res.statusCode = status;
+  res.setHeader('content-type', 'application/json');
+  res.end(JSON.stringify(body));
+}
+
+function unwrapDefault(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;
+}
+
+function resolveCronHandler(userModule, name) {
+  if (name === 'default') {
+    const unwrapped = unwrapDefault(userModule);
+    if (typeof unwrapped === 'function') return unwrapped;
+    if (typeof userModule === 'function') return userModule;
+    return undefined;
+  }
+  const fn = userModule != null ? userModule[name] : undefined;
+  return typeof fn === 'function' ? fn : undefined;
+}
+
+function safeBearerEqual(authHeader, secret) {
+  if (typeof authHeader !== 'string') return false;
+  const expected = 'Bearer ' + secret;
+  const a = Buffer.from(authHeader);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length) return false;
+  return __vc_timingSafeEqual(a, b);
+}
+
+// Pre-resolve every route at module load. A bad route table fails the
+// lambda at boot rather than at first request.
+//
+// `__VC_ROUTES_JSON__` is replaced at build time with the JSON route
+// table. Embedded inline here (instead of read from env) because AWS
+// Lambda env var names must start with a letter, so `__VC_CRON_ROUTES`
+// would fail at deploy time. The Python builder works around the same
+// constraint by writing the route table into its trampoline source.
+const __vc_routes_parsed = JSON.parse('__VC_ROUTES_JSON__');
+const RESOLVED_HANDLERS = new Map();
+for (const __vc_path in __vc_routes_parsed) {
+  const __vc_name = __vc_routes_parsed[__vc_path];
+  const __vc_fn = resolveCronHandler(__vc_user_module, __vc_name);
+  if (typeof __vc_fn !== 'function') {
+    throw new Error(
+      'cron handler "' +
+        __vc_name +
+        '" is not a function in the user module (route: ' +
+        __vc_path +
+        ')'
+    );
+  }
+  RESOLVED_HANDLERS.set(__vc_path, __vc_fn);
+}
+
+async function vcCronDispatch(req, res) {
+  // Drain any inbound request body so the underlying stream completes
+  // independently of whether the user's cron handler reads it. Cron
+  // handlers take no arguments — body bytes are never used. Idempotent
+  // and a no-op for non-streaming runtimes.
+  if (typeof req.resume === 'function') req.resume();
+
+  const method = (req.method || 'GET').toUpperCase();
+  if (method !== 'GET' && method !== 'POST') {
+    jsonResponse(res, 405, { error: 'method not allowed' });
+    return;
+  }
+  const secret = process.env.CRON_SECRET;
+  if (secret) {
+    const headers = req.headers || {};
+    const authorization = headers.authorization || headers.Authorization;
+    if (!safeBearerEqual(authorization, secret)) {
+      jsonResponse(res, 401, { error: 'unauthorized' });
+      return;
+    }
+  }
+  const rawUrl = typeof req.url === 'string' ? req.url : '/';
+  const path = rawUrl.split('?')[0];
+  const fn = RESOLVED_HANDLERS.get(path);
+  if (!fn) {
+    jsonResponse(res, 404, { error: 'no cron handler for path: ' + path });
+    return;
+  }
+  try {
+    await fn();
+    jsonResponse(res, 200, { ok: true });
+  } catch (err) {
+    console.error(err);
+    jsonResponse(res, 500, { error: 'internal' });
+  }
+}
+
+module.exports = function (req, res) {
+  return vcCronDispatch(req, res);
+};

package/templates/vc_cron_dispatch.mjs

@@ -0,0 +1,119 @@
+// Runtime cron dispatcher (ESM). Generated into a Vercel cron service
+// lambda by `applyCronDispatch` in @vercel/backends. JS analog of
+// vercel-runtime/src/vercel_runtime/crons.py — pre-resolves the route
+// table at module load and dispatches inbound requests to the matching
+// handler on the user's module.
+//
+// `__VC_USER_MODULE_PATH__` is replaced at build time with the relative
+// path to the user's cron entrypoint.
+import { timingSafeEqual as __vc_timingSafeEqual } from 'node:crypto';
+import * as __vc_user_module from '__VC_USER_MODULE_PATH__';
+
+function jsonResponse(res, status, body) {
+  res.statusCode = status;
+  res.setHeader('content-type', 'application/json');
+  res.end(JSON.stringify(body));
+}
+
+function unwrapDefault(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;
+}
+
+function resolveCronHandler(userModule, name) {
+  if (name === 'default') {
+    const unwrapped = unwrapDefault(userModule);
+    if (typeof unwrapped === 'function') return unwrapped;
+    if (typeof userModule === 'function') return userModule;
+    return undefined;
+  }
+  const fn = userModule != null ? userModule[name] : undefined;
+  return typeof fn === 'function' ? fn : undefined;
+}
+
+function safeBearerEqual(authHeader, secret) {
+  if (typeof authHeader !== 'string') return false;
+  const expected = 'Bearer ' + secret;
+  const a = Buffer.from(authHeader);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length) return false;
+  return __vc_timingSafeEqual(a, b);
+}
+
+// Pre-resolve every route at module load. A bad route table fails the
+// lambda at boot rather than at first request.
+//
+// `__VC_ROUTES_JSON__` is replaced at build time with the JSON route
+// table. Embedded inline here (instead of read from env) because AWS
+// Lambda env var names must start with a letter, so `__VC_CRON_ROUTES`
+// would fail at deploy time. The Python builder works around the same
+// constraint by writing the route table into its trampoline source.
+const __vc_routes_parsed = JSON.parse('__VC_ROUTES_JSON__');
+const RESOLVED_HANDLERS = new Map();
+for (const __vc_path in __vc_routes_parsed) {
+  const __vc_name = __vc_routes_parsed[__vc_path];
+  const __vc_fn = resolveCronHandler(__vc_user_module, __vc_name);
+  if (typeof __vc_fn !== 'function') {
+    throw new Error(
+      'cron handler "' +
+        __vc_name +
+        '" is not a function in the user module (route: ' +
+        __vc_path +
+        ')'
+    );
+  }
+  RESOLVED_HANDLERS.set(__vc_path, __vc_fn);
+}
+
+async function vcCronDispatch(req, res) {
+  // Drain any inbound request body so the underlying stream completes
+  // independently of whether the user's cron handler reads it. Cron
+  // handlers take no arguments — body bytes are never used. Idempotent
+  // and a no-op for non-streaming runtimes.
+  if (typeof req.resume === 'function') req.resume();
+
+  const method = (req.method || 'GET').toUpperCase();
+  if (method !== 'GET' && method !== 'POST') {
+    jsonResponse(res, 405, { error: 'method not allowed' });
+    return;
+  }
+  const secret = process.env.CRON_SECRET;
+  if (secret) {
+    const headers = req.headers || {};
+    const authorization = headers.authorization || headers.Authorization;
+    if (!safeBearerEqual(authorization, secret)) {
+      jsonResponse(res, 401, { error: 'unauthorized' });
+      return;
+    }
+  }
+  const rawUrl = typeof req.url === 'string' ? req.url : '/';
+  const path = rawUrl.split('?')[0];
+  const fn = RESOLVED_HANDLERS.get(path);
+  if (!fn) {
+    jsonResponse(res, 404, { error: 'no cron handler for path: ' + path });
+    return;
+  }
+  try {
+    await fn();
+    jsonResponse(res, 200, { ok: true });
+  } catch (err) {
+    console.error(err);
+    jsonResponse(res, 500, { error: 'internal' });
+  }
+}
+
+export default function (req, res) {
+  return vcCronDispatch(req, res);
+}