@vercel/python 6.31.0 → 6.33.0

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs11 = require("fs");
+    var fs12 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs11.stat(path, function(er, stat) {
+      fs12.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs11.statSync(path), path, options);
+      return checkStat(fs12.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs11 = require("fs");
+    var fs12 = require("fs");
     function isexe(path, options, cb) {
-      fs11.stat(path, function(er, stat) {
+      fs12.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs11.statSync(path), options);
+      return checkStat(fs12.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs11 = require("fs");
+    var fs12 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs11 = require("fs");
+    var fs12 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs11.openSync(command, "r");
-        fs11.readSync(fd, buffer, 0, size, 0);
-        fs11.closeSync(fd);
+        fd = fs12.openSync(command, "r");
+        fs12.readSync(fd, buffer, 0, size, 0);
+        fs12.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs11;
+    var fs12;
     try {
-      fs11 = require("fs");
+      fs12 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs11)
+      if (!fs12)
         return false;
-      return (stream instanceof (fs11.ReadStream || noop) || stream instanceof (fs11.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs12.ReadStream || noop) || stream instanceof (fs12.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2141,7 +2141,7 @@ var require_signal_exit = __commonJS({
         };
       };
     } else {
-      assert = require("assert");
+      assert2 = require("assert");
       signals = require_signals();
       isWin3 = /^win/i.test(process2.platform);
       EE = require("events");
@@ -2164,7 +2164,7 @@ var require_signal_exit = __commonJS({
           return function() {
           };
         }
-        assert.equal(typeof cb, "function", "a callback must be provided for exit handler");
+        assert2.equal(typeof cb, "function", "a callback must be provided for exit handler");
         if (loaded === false) {
           load();
         }
@@ -2270,7 +2270,7 @@ var require_signal_exit = __commonJS({
         }
       };
     }
-    var assert;
+    var assert2;
     var signals;
     var isWin3;
     var EE;
@@ -2674,27 +2674,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js"(exports, module2) {
     "use strict";
-    var fs11 = require("fs");
+    var fs12 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
     var readFileSync2 = (path) => {
-      const fd = fs11.openSync(path, "r");
+      const fd = fs12.openSync(path, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs11.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs11.close(fd, () => {
+      const bytesRead = fs12.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs12.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
     var readFile2 = (path) => new Promise((resolve3, reject) => {
-      fs11.open(path, "r", (err, fd) => {
+      fs12.open(path, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs11.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs12.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve3(buffer.subarray(0, bytesRead));
-            fs11.close(fd, () => {
+            fs12.close(fd, () => {
             });
           });
         }
@@ -3005,7 +3005,7 @@ var require_detect_libc = __commonJS({
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join13, delimiter: delimiter2, sep: sep2, posix } = require("path");
+    var { join: join14, delimiter: delimiter2, sep: sep2, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep2 === posix.sep ? "" : sep2}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -3034,7 +3034,7 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join13(pathPart, cmd);
+      return prefix + join14(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -3224,16 +3224,17 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
+var import_assert = __toESM(require("assert"));
 var import_child_process3 = require("child_process");
-var import_fs12 = __toESM(require("fs"));
-var import_path13 = require("path");
+var import_fs13 = __toESM(require("fs"));
+var import_path14 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.12.0";
+var VERCEL_RUNTIME_VERSION = "0.13.0";
 var VERCEL_WORKERS_VERSION = "0.0.16";
 
 // src/index.ts
-var import_build_utils15 = require("@vercel/build-utils");
+var import_build_utils16 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -3636,7 +3637,7 @@ async function ensureVenv({
     }
   }
   if (uvPath) {
-    const args = ["venv", venvPath, "--allow-existing"];
+    const args = ["venv", venvPath, "--allow-existing", "--seed"];
     if (pythonVersion.major != null && pythonVersion.minor != null) {
       args.push("--python", `${pythonVersion.major}.${pythonVersion.minor}`);
     }
@@ -4312,6 +4313,7 @@ var import_python_analysis3 = require("@vercel/python-analysis");
 var readFile = (0, import_util.promisify)(import_fs5.default.readFile);
 var LAMBDA_SIZE_THRESHOLD_BYTES = 245 * 1024 * 1024;
 var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
+var HIVE_LAMBDA_SIZE_BYTES = 1 * 1024 * 1024 * 1024;
 var PythonDependencyExternalizer = class {
   constructor(options) {
     // Populated by analyze()
@@ -4377,6 +4379,15 @@ To resolve this, either:
         action: "Learn More"
       });
     }
+    if (pythonOnHiveEnabled && this.totalBundleSize > HIVE_LAMBDA_SIZE_BYTES) {
+      const limitMB = (HIVE_LAMBDA_SIZE_BYTES / (1024 * 1024)).toFixed(0);
+      throw new import_build_utils5.NowBuildError({
+        code: "LAMBDA_SIZE_EXCEEDED",
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB). Consider removing unused dependencies or splitting your application into smaller functions.`,
+        link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
+        action: "Learn More"
+      });
+    }
     return {
       runtimeInstallEnabled,
       allVendorFiles: this.allVendorFiles,
@@ -5093,20 +5104,161 @@ var diagnostics = async ({
   }
 };
 
+// src/crons.ts
+var import_fs7 = __toESM(require("fs"));
+var import_path8 = require("path");
+var import_execa4 = __toESM(require_execa());
+var import_build_utils7 = require("@vercel/build-utils");
+var DYNAMIC_SCHEDULE = "<dynamic>";
+function entrypointToModule(entrypoint) {
+  return entrypoint.replace(/\\/g, "/").replace(/\.py$/i, "").replace(/\//g, ".");
+}
+var scriptPath = (0, import_path8.join)(__dirname, "..", "templates", "vc_cron_detect.py");
+var script = import_fs7.default.readFileSync(scriptPath, "utf-8");
+function buildCronRouteTable(crons) {
+  const table = {};
+  for (const cron of crons) {
+    table[cron.path] = cron.resolvedHandler;
+  }
+  return table;
+}
+async function getServiceCrons(opts) {
+  const { service, entrypoint, rawEntrypoint, handlerFunction } = opts;
+  if (service?.type !== "cron" || !service.name || typeof service.schedule !== "string") {
+    return void 0;
+  }
+  const cronEntrypoint = entrypoint || rawEntrypoint;
+  if (!cronEntrypoint) {
+    throw new import_build_utils7.NowBuildError({
+      code: "PYTHON_CRON_NO_ENTRYPOINT",
+      message: "Cron service is missing an entrypoint."
+    });
+  }
+  if (service.schedule === DYNAMIC_SCHEDULE) {
+    return getServiceCronsDynamic({
+      serviceName: service.name,
+      cronEntrypoint,
+      handlerFunction,
+      pythonBin: opts.pythonBin,
+      env: opts.env,
+      workPath: opts.workPath
+    });
+  }
+  const cronPath = (0, import_build_utils7.getInternalServiceCronPath)(
+    service.name,
+    cronEntrypoint,
+    handlerFunction || "cron"
+  );
+  const moduleName = entrypointToModule(cronEntrypoint);
+  const resolvedHandler = handlerFunction ? `${moduleName}:${handlerFunction}` : moduleName;
+  return [{ path: cronPath, schedule: service.schedule, resolvedHandler }];
+}
+async function getServiceCronsDynamic(opts) {
+  const {
+    serviceName,
+    cronEntrypoint,
+    handlerFunction,
+    pythonBin,
+    env,
+    workPath
+  } = opts;
+  if (!handlerFunction) {
+    throw new import_build_utils7.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_NO_HANDLER",
+      message: 'Dynamic cron detection requires a "module:object" entrypoint where the object has a get_crons() method.'
+    });
+  }
+  const moduleName = entrypointToModule(cronEntrypoint);
+  const entries = await detectDynamicCrons({
+    pythonBin,
+    env,
+    workPath,
+    moduleName,
+    attrName: handlerFunction
+  });
+  console.log(
+    `Detected ${entries.length} cron entry(s): ${entries.map((e) => `${e.module_function} (${e.schedule})`).join(", ")}`
+  );
+  if (entries.length === 0) {
+    throw new import_build_utils7.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_EMPTY",
+      message: `Dynamic cron detection returned no entries. "${moduleName}.${handlerFunction}.get_crons()" returned an empty iterable.`
+    });
+  }
+  return entries.map((entry) => {
+    const cronPath = moduleColonFuncToCronPath(
+      serviceName,
+      entry.module_function
+    );
+    return {
+      path: cronPath,
+      schedule: entry.schedule,
+      resolvedHandler: entry.module_function
+    };
+  });
+}
+async function detectDynamicCrons(opts) {
+  const { pythonBin, env, workPath, moduleName, attrName } = opts;
+  let stdout;
+  try {
+    const result = await (0, import_execa4.default)(
+      pythonBin,
+      ["-c", script, moduleName, attrName],
+      { env, cwd: workPath }
+    );
+    stdout = result.stdout;
+  } catch (err) {
+    let detail = err?.stderr || err?.message || String(err);
+    try {
+      const parsed2 = JSON.parse(err?.stdout);
+      if (parsed2.error)
+        detail = parsed2.error;
+    } catch {
+    }
+    throw new import_build_utils7.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_DETECTION_FAILED",
+      message: `Failed to detect dynamic cron entries: ${detail}`
+    });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new import_build_utils7.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_DETECTION_FAILED",
+      message: `Dynamic cron detection returned invalid JSON: ${stdout}`
+    });
+  }
+  return parsed.entries || [];
+}
+function moduleColonFuncToCronPath(serviceName, moduleFunction) {
+  const colonIdx = moduleFunction.indexOf(":");
+  if (colonIdx === -1) {
+    throw new import_build_utils7.NowBuildError({
+      code: "PYTHON_DYNAMIC_CRON_INVALID_FORMAT",
+      message: `Dynamic cron entry must use "module:function" format, got: "${moduleFunction}"`
+    });
+  }
+  const modulePart = moduleFunction.slice(0, colonIdx);
+  const funcPart = moduleFunction.slice(colonIdx + 1);
+  const entrypointPath = modulePart.replace(/\./g, "/");
+  return (0, import_build_utils7.getInternalServiceCronPath)(serviceName, entrypointPath, funcPart);
+}
+
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs8 = require("fs");
-var import_path9 = require("path");
-var import_build_utils10 = require("@vercel/build-utils");
+var import_fs9 = require("fs");
+var import_path10 = require("path");
+var import_build_utils11 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
 
 // src/entrypoint.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path8 = require("path");
-var import_build_utils7 = require("@vercel/build-utils");
+var import_fs8 = __toESM(require("fs"));
+var import_path9 = require("path");
 var import_build_utils8 = require("@vercel/build-utils");
 var import_build_utils9 = require("@vercel/build-utils");
+var import_build_utils10 = require("@vercel/build-utils");
 var import_python_analysis5 = require("@vercel/python-analysis");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
@@ -5123,27 +5275,27 @@ var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
 function getCandidateEntrypointsInDirs(dirs) {
   return dirs.flatMap(
     (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
-      (filename) => import_path8.posix.join(dir, `${filename}.py`)
+      (filename) => import_path9.posix.join(dir, `${filename}.py`)
     )
   );
 }
 async function fileExists(filePath) {
   try {
-    const stat = await import_fs7.default.promises.stat(filePath);
+    const stat = await import_fs8.default.promises.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
   }
 }
 async function checkEntrypoint(workPath, relPath) {
-  const absPath = (0, import_path8.join)(workPath, relPath);
+  const absPath = (0, import_path9.join)(workPath, relPath);
   if (!await fileExists(absPath))
     return null;
-  const content = await import_fs7.default.promises.readFile(absPath, "utf-8");
+  const content = await import_fs8.default.promises.readFile(absPath, "utf-8");
   return (0, import_python_analysis5.findAppOrHandler)(content);
 }
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils10.readConfigFile)((0, import_path9.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -5158,7 +5310,7 @@ async function getPyprojectEntrypoint(workPath) {
   const relPath = modulePath.replace(/\./g, "/");
   const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
   for (const candidate of candidates) {
-    if (await fileExists((0, import_path8.join)(workPath, candidate))) {
+    if (await fileExists((0, import_path9.join)(workPath, candidate))) {
       return { entrypoint: candidate, variableName };
     }
   }
@@ -5168,19 +5320,19 @@ async function findValidEntrypoint(workPath, candidates) {
   for (const candidate of candidates) {
     const varName = await checkEntrypoint(workPath, candidate);
     if (varName) {
-      (0, import_build_utils8.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
+      (0, import_build_utils9.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
       return { entrypoint: candidate, variableName: varName };
     }
   }
   return null;
 }
 async function checkDjangoManage(workPath) {
-  const managePath = (0, import_path8.join)(workPath, "manage.py");
+  const managePath = (0, import_path9.join)(workPath, "manage.py");
   try {
-    const content = await import_fs7.default.promises.readFile(managePath, "utf-8");
+    const content = await import_fs8.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
-    (0, import_build_utils8.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    (0, import_build_utils9.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
     return true;
   } catch {
     return false;
@@ -5188,7 +5340,7 @@ async function checkDjangoManage(workPath) {
 }
 async function getSubdirectories(workPath) {
   try {
-    const entries = await import_fs7.default.promises.readdir(workPath, {
+    const entries = await import_fs8.default.promises.readdir(workPath, {
       withFileTypes: true
     });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
@@ -5198,7 +5350,7 @@ async function getSubdirectories(workPath) {
 }
 function makeDetectError(framework) {
   const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-  return new import_build_utils7.NowBuildError({
+  return new import_build_utils8.NowBuildError({
     code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
     message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searchedList}.`,
     link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -5213,7 +5365,7 @@ async function detectGenericPythonEntrypoint(workPath) {
     );
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils8.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils9.debug)("Failed to discover Python entrypoint");
     return null;
   }
 }
@@ -5222,7 +5374,7 @@ async function detectDjangoPythonEntrypoint(workPath) {
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
     for (const rootDir of rootDirs) {
-      const currPath = (0, import_path8.join)(workPath, rootDir);
+      const currPath = (0, import_path9.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
         return { baseDir: rootDir, error: makeDetectError("django") };
@@ -5232,7 +5384,7 @@ async function detectDjangoPythonEntrypoint(workPath) {
     const found = await findValidEntrypoint(workPath, candidates);
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils8.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils9.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
@@ -5248,11 +5400,11 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
       }
     }
     if (varName) {
-      (0, import_build_utils8.debug)(`Using configured Python entrypoint: ${entrypoint}`);
+      (0, import_build_utils9.debug)(`Using configured Python entrypoint: ${entrypoint}`);
       return { entrypoint: { entrypoint, variableName: varName } };
     } else {
       return {
-        error: new import_build_utils7.NowBuildError({
+        error: new import_build_utils8.NowBuildError({
           code: "PYTHON_ENTRYPOINT_NOT_FOUND",
           message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
           link: "https://vercel.com/docs/functions/serverless-functions/runtimes/python",
@@ -5358,17 +5510,17 @@ async function syncDependencies({
   let { manifestPath } = installInfo;
   const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils10.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils11.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
-    const syncDir = (0, import_path9.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs8.mkdirSync)(syncDir, { recursive: true });
-    const tempPyproject = (0, import_path9.join)(syncDir, "pyproject.toml");
+    const syncDir = (0, import_path10.join)(workPath, ".vercel", "python", "sync");
+    (0, import_fs9.mkdirSync)(syncDir, { recursive: true });
+    const tempPyproject = (0, import_path10.join)(syncDir, "pyproject.toml");
     const content = (0, import_python_analysis6.stringifyManifest)(manifest.data);
-    (0, import_fs8.writeFileSync)(tempPyproject, content, "utf8");
+    (0, import_fs9.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils10.debug)(
+    (0, import_build_utils11.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -5401,7 +5553,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils10.NowBuildError({
+    throw new import_build_utils11.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -5416,14 +5568,14 @@ async function runSync({
   onStdout,
   onStderr
 }) {
-  const projectDir = (0, import_path9.dirname)(manifestPath);
+  const projectDir = (0, import_path10.dirname)(manifestPath);
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   let spawnCmd;
   let spawnArgs;
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils10.NowBuildError({
+        throw new import_build_utils11.NowBuildError({
           code: "PYTHON_DEPENDENCY_SYNC_FAILED",
           message: "uv is required to install dependencies from uv.lock.",
           link: "https://docs.astral.sh/uv/getting-started/installation/",
@@ -5445,11 +5597,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils10.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils11.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve3, reject) => {
-    (0, import_build_utils10.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils11.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -5493,7 +5645,7 @@ async function installVercelRuntime({
   onStdout,
   onStderr
 }) {
-  const targetDir = (0, import_path9.join)(workPath, ".vercel", "python");
+  const targetDir = (0, import_path10.join)(workPath, ".vercel", "python");
   let pending = PENDING_RUNTIME_INSTALLS.get(targetDir);
   if (!pending) {
     pending = doInstallVercelRuntime({
@@ -5519,8 +5671,8 @@ async function doInstallVercelRuntime({
   onStdout,
   onStderr
 }) {
-  (0, import_fs8.mkdirSync)(targetDir, { recursive: true });
-  const localRuntimeDir = (0, import_path9.join)(
+  (0, import_fs9.mkdirSync)(targetDir, { recursive: true });
+  const localRuntimeDir = (0, import_path10.join)(
     __dirname,
     "..",
     "..",
@@ -5528,21 +5680,21 @@ async function doInstallVercelRuntime({
     "python",
     "vercel-runtime"
   );
-  const isLocalDev = (0, import_fs8.existsSync)((0, import_path9.join)(localRuntimeDir, "pyproject.toml"));
+  const isLocalDev = (0, import_fs9.existsSync)((0, import_path10.join)(localRuntimeDir, "pyproject.toml"));
   const runtimeDep = env.VERCEL_RUNTIME_PYTHON || (isLocalDev ? localRuntimeDir : `vercel-runtime==${VERCEL_RUNTIME_VERSION}`);
   if (!isLocalDev && !env.VERCEL_RUNTIME_PYTHON) {
-    const distInfo = (0, import_path9.join)(
+    const distInfo = (0, import_path10.join)(
       targetDir,
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
-    if ((0, import_fs8.existsSync)(distInfo)) {
-      (0, import_build_utils10.debug)(
+    if ((0, import_fs9.existsSync)(distInfo)) {
+      (0, import_build_utils11.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils10.debug)(
+  (0, import_build_utils11.debug)(
     `Installing vercel-runtime into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${runtimeDep})`
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
@@ -5557,14 +5709,14 @@ async function doInstallVercelRuntime({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils10.debug)(data.toString());
+        (0, import_build_utils11.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils10.debug)(data.toString());
+        (0, import_build_utils11.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5589,7 +5741,7 @@ async function installVercelWorkers({
   onStdout,
   onStderr
 }) {
-  const targetDir = (0, import_path9.join)(workPath, ".vercel", "python");
+  const targetDir = (0, import_path10.join)(workPath, ".vercel", "python");
   let pending = PENDING_WORKERS_INSTALLS.get(targetDir);
   if (!pending) {
     pending = doInstallVercelWorkers({
@@ -5615,8 +5767,8 @@ async function doInstallVercelWorkers({
   onStdout,
   onStderr
 }) {
-  (0, import_fs8.mkdirSync)(targetDir, { recursive: true });
-  const localWorkersDir = (0, import_path9.join)(
+  (0, import_fs9.mkdirSync)(targetDir, { recursive: true });
+  const localWorkersDir = (0, import_path10.join)(
     __dirname,
     "..",
     "..",
@@ -5624,21 +5776,21 @@ async function doInstallVercelWorkers({
     "python",
     "vercel-workers"
   );
-  const isLocalDev = (0, import_fs8.existsSync)((0, import_path9.join)(localWorkersDir, "pyproject.toml"));
+  const isLocalDev = (0, import_fs9.existsSync)((0, import_path10.join)(localWorkersDir, "pyproject.toml"));
   const workersDep = env.VERCEL_WORKERS_PYTHON || (isLocalDev ? localWorkersDir : `vercel-workers==${VERCEL_WORKERS_VERSION}`);
   if (!isLocalDev && !env.VERCEL_WORKERS_PYTHON) {
-    const distInfo = (0, import_path9.join)(
+    const distInfo = (0, import_path10.join)(
       targetDir,
       `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
     );
-    if ((0, import_fs8.existsSync)(distInfo)) {
-      (0, import_build_utils10.debug)(
+    if ((0, import_fs9.existsSync)(distInfo)) {
+      (0, import_build_utils11.debug)(
         `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils10.debug)(
+  (0, import_build_utils11.debug)(
     `Installing vercel-workers into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${workersDep})`
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
@@ -5653,14 +5805,14 @@ async function doInstallVercelWorkers({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils10.debug)(data.toString());
+        (0, import_build_utils11.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils10.debug)(data.toString());
+        (0, import_build_utils11.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5690,12 +5842,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils10.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils11.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils10.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils11.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -5703,7 +5855,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils10.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils11.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -5720,55 +5872,55 @@ function installGlobalCleanupHandlers() {
 }
 function createDevShim(workPath, entry, modulePath, serviceName, framework, variableName) {
   try {
-    const vercelPythonDir = serviceName ? (0, import_path9.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path9.join)(workPath, ".vercel", "python");
-    (0, import_fs8.mkdirSync)(vercelPythonDir, { recursive: true });
+    const vercelPythonDir = serviceName ? (0, import_path10.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path10.join)(workPath, ".vercel", "python");
+    (0, import_fs9.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs8.existsSync)((0, import_path9.join)(workPath, "__init__.py"))) {
-      const pkgName = (0, import_path9.basename)(workPath);
+    if ((0, import_fs9.existsSync)((0, import_path10.join)(workPath, "__init__.py"))) {
+      const pkgName = (0, import_path10.basename)(workPath);
       qualifiedModule = `${pkgName}.${modulePath}`;
-      extraPythonPath = (0, import_path9.dirname)(workPath);
+      extraPythonPath = (0, import_path10.dirname)(workPath);
     }
-    const entryAbs = (0, import_path9.join)(workPath, entry);
-    const shimPath = (0, import_path9.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path9.join)(
+    const entryAbs = (0, import_path10.join)(workPath, entry);
+    const shimPath = (0, import_path10.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path10.join)(
       __dirname,
       "..",
       "templates",
       `${DEV_SHIM_MODULE}.py`
     );
-    const template = (0, import_fs8.readFileSync)(templatePath, "utf8");
+    const template = (0, import_fs9.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs).replace(/__VC_DEV_FRAMEWORK__/g, framework).replace(/__VC_DEV_VARIABLE_NAME__/g, variableName);
-    (0, import_fs8.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils10.debug)(`Prepared Python dev shim at ${shimPath}`);
+    (0, import_fs9.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils11.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
       extraPythonPath,
       shimDir: vercelPythonDir
     };
   } catch (err) {
-    (0, import_build_utils10.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
+    (0, import_build_utils11.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
     return null;
   }
 }
 async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath) {
   const { pythonCmd, venvRoot } = useVirtualEnv(workPath, env, systemPython);
   if (venvRoot) {
-    (0, import_build_utils10.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils11.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
-  const venvPath = (0, import_path9.join)(workPath, ".venv");
+  const venvPath = (0, import_path10.join)(workPath, ".venv");
   await ensureVenv({
     pythonVersion: { pythonPath: systemPython },
     venvPath,
     uvPath,
     quiet: true
   });
-  (0, import_build_utils10.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  (0, import_build_utils11.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
-  env.PATH = `${binDir}${import_path9.delimiter}${env.PATH || ""}`;
+  env.PATH = `${binDir}${import_path10.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
 var startDevServer = async (opts) => {
@@ -5831,7 +5983,7 @@ var startDevServer = async (opts) => {
   } else {
     const hookResult = await runFrameworkHook(framework, {
       pythonEnv: env,
-      projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
+      projectDir: (0, import_path10.join)(workPath, detected?.baseDir ?? ""),
       workPath,
       entrypoint,
       detected: detected ?? void 0
@@ -5842,7 +5994,7 @@ var startDevServer = async (opts) => {
     if (detected?.error) {
       throw detected.error;
     }
-    throw new import_build_utils10.NowBuildError({
+    throw new import_build_utils11.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: "No Python entrypoint could be detected. Please specify an entrypoint file."
     });
@@ -5871,7 +6023,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils10.NowBuildError({
+      throw new import_build_utils11.NowBuildError({
         code: "PYTHON_EXTERNAL_VENV_DETECTED",
         message: `Detected activated venv at ${yellow}${venv}${reset}, ${white}vercel dev${reset} manages virtual environments automatically.
 Run ${white}deactivate${reset} and try again.`
@@ -5888,11 +6040,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils10.debug)(
+      (0, import_build_utils11.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils10.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils11.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -5901,9 +6053,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils10.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils11.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils10.debug)("No virtualenv found");
+        (0, import_build_utils11.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -5952,13 +6104,22 @@ If you are using a virtual environment, activate it before running "vercel dev",
         onStderr
       });
     }
+    const crons = await getServiceCrons({
+      service,
+      entrypoint,
+      rawEntrypoint,
+      handlerFunction,
+      pythonBin: spawnCommand,
+      env,
+      workPath
+    });
+    if (crons?.length) {
+      env.__VC_CRON_ROUTES = JSON.stringify(buildCronRouteTable(crons));
+    }
     const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
     env.PORT = `${port}`;
-    if (config.handlerFunction && typeof config?.handlerFunction === "string") {
-      env.__VC_HANDLER_FUNC_NAME = config.handlerFunction;
-    }
     if (entry) {
-      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path9.join)(workPath, entry);
+      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path10.join)(workPath, entry);
     }
     const devShim = createDevShim(
       workPath,
@@ -5969,8 +6130,8 @@ If you are using a virtual environment, activate it before running "vercel dev",
       variableName ?? ""
     );
     if (devShim) {
-      const shimDir = devShim.shimDir || (0, import_path9.join)(workPath, ".vercel", "python");
-      const runtimeDir = (0, import_path9.join)(workPath, ".vercel", "python");
+      const shimDir = devShim.shimDir || (0, import_path10.join)(workPath, ".vercel", "python");
+      const runtimeDir = (0, import_path10.join)(workPath, ".vercel", "python");
       const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
       if (devShim.extraPythonPath) {
         pathParts.push(devShim.extraPythonPath);
@@ -5979,12 +6140,12 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (existingPythonPath) {
         pathParts.push(existingPythonPath);
       }
-      env.PYTHONPATH = pathParts.join(import_path9.delimiter);
+      env.PYTHONPATH = pathParts.join(import_path10.delimiter);
     }
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils10.debug)(
+    (0, import_build_utils11.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
     if (process.stdout.columns) {
@@ -6028,7 +6189,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
     });
     const shutdown = async () => {
     };
-    return { port, pid, shutdown };
+    return { port, pid, shutdown, crons };
   } catch (err) {
     rejectChildReady(err);
     throw err;
@@ -6038,7 +6199,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 
 // src/quirks/index.ts
-var import_build_utils13 = require("@vercel/build-utils");
+var import_build_utils14 = require("@vercel/build-utils");
 var import_python_analysis8 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
@@ -6052,9 +6213,9 @@ var matplotlibQuirk = {
 };
 
 // src/quirks/litellm.ts
-var import_fs9 = __toESM(require("fs"));
-var import_path10 = require("path");
-var import_build_utils11 = require("@vercel/build-utils");
+var import_fs10 = __toESM(require("fs"));
+var import_path11 = require("path");
+var import_build_utils12 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
   "litellm_config.yaml",
@@ -6064,9 +6225,9 @@ var CONFIG_CANDIDATES = [
 ];
 async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
-    const candidate = (0, import_path10.join)(workPath, name);
+    const candidate = (0, import_path11.join)(workPath, name);
     try {
-      await import_fs9.default.promises.access(candidate);
+      await import_fs10.default.promises.access(candidate);
       return name;
     } catch {
     }
@@ -6081,32 +6242,32 @@ var litellmQuirk = {
     const env = {};
     const sitePackagesDirs = await getVenvSitePackagesDirs(ctx.venvPath);
     for (const sitePackages of sitePackagesDirs) {
-      const schemaPath = (0, import_path10.join)(
+      const schemaPath = (0, import_path11.join)(
         sitePackages,
         "litellm",
         "proxy",
         "schema.prisma"
       );
       try {
-        await import_fs9.default.promises.access(schemaPath);
-        (0, import_build_utils11.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
+        await import_fs10.default.promises.access(schemaPath);
+        (0, import_build_utils12.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
       } catch {
       }
     }
     if (!buildEnv.PRISMA_SCHEMA_PATH) {
-      (0, import_build_utils11.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
+      (0, import_build_utils12.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
     }
     if (!process.env.CONFIG_FILE_PATH) {
       const configName = await findConfigFile(ctx.workPath);
       if (configName) {
-        (0, import_build_utils11.debug)(`LiteLLM quirk: found config at ${configName}`);
-        buildEnv.CONFIG_FILE_PATH = (0, import_path10.join)(ctx.workPath, configName);
-        env.CONFIG_FILE_PATH = (0, import_path10.join)(LAMBDA_ROOT, configName);
+        (0, import_build_utils12.debug)(`LiteLLM quirk: found config at ${configName}`);
+        buildEnv.CONFIG_FILE_PATH = (0, import_path11.join)(ctx.workPath, configName);
+        env.CONFIG_FILE_PATH = (0, import_path11.join)(LAMBDA_ROOT, configName);
       }
     } else {
-      (0, import_build_utils11.debug)(
+      (0, import_build_utils12.debug)(
         `LiteLLM quirk: CONFIG_FILE_PATH already set to ${process.env.CONFIG_FILE_PATH}`
       );
     }
@@ -6115,10 +6276,10 @@ var litellmQuirk = {
 };
 
 // src/quirks/prisma.ts
-var import_fs10 = __toESM(require("fs"));
-var import_path11 = require("path");
-var import_execa4 = __toESM(require_execa());
-var import_build_utils12 = require("@vercel/build-utils");
+var import_fs11 = __toESM(require("fs"));
+var import_path12 = require("path");
+var import_execa5 = __toESM(require_execa());
+var import_build_utils13 = require("@vercel/build-utils");
 var import_python_analysis7 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
@@ -6156,22 +6317,22 @@ model DummyModel {
 async function findUserSchema(workPath) {
   const envPath = process.env.PRISMA_SCHEMA_PATH;
   if (envPath) {
-    const resolved = (0, import_path11.isAbsolute)(envPath) ? envPath : (0, import_path11.join)(workPath, envPath);
+    const resolved = (0, import_path12.isAbsolute)(envPath) ? envPath : (0, import_path12.join)(workPath, envPath);
     try {
-      await import_fs10.default.promises.access(resolved);
+      await import_fs11.default.promises.access(resolved);
       return resolved;
     } catch {
-      (0, import_build_utils12.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      (0, import_build_utils13.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
       return null;
     }
   }
   const candidates = [
-    (0, import_path11.join)(workPath, "schema.prisma"),
-    (0, import_path11.join)(workPath, "prisma", "schema.prisma")
+    (0, import_path12.join)(workPath, "schema.prisma"),
+    (0, import_path12.join)(workPath, "prisma", "schema.prisma")
   ];
   for (const candidate of candidates) {
     try {
-      await import_fs10.default.promises.access(candidate);
+      await import_fs11.default.promises.access(candidate);
       return candidate;
     } catch {
     }
@@ -6182,32 +6343,32 @@ async function collectFiles(dir, base) {
   const result = [];
   let entries;
   try {
-    entries = await import_fs10.default.promises.readdir(dir, { withFileTypes: true });
+    entries = await import_fs11.default.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (entry.name === "__pycache__")
       continue;
-    const full = (0, import_path11.join)(dir, entry.name);
+    const full = (0, import_path12.join)(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...await collectFiles(full, base));
     } else {
-      result.push((0, import_path11.relative)(base, full));
+      result.push((0, import_path12.relative)(base, full));
     }
   }
   return result;
 }
 async function cleanCacheArtifacts(cacheDir, extras = []) {
   const paths = [
-    (0, import_path11.join)(cacheDir, "node_modules"),
-    (0, import_path11.join)(cacheDir, "package.json"),
-    (0, import_path11.join)(cacheDir, "package-lock.json"),
+    (0, import_path12.join)(cacheDir, "node_modules"),
+    (0, import_path12.join)(cacheDir, "package.json"),
+    (0, import_path12.join)(cacheDir, "package-lock.json"),
     ...extras
   ];
   for (const p of paths) {
     try {
-      await import_fs10.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs11.default.promises.rm(p, { recursive: true, force: true });
     } catch (err) {
       console.warn(
         `could not clean up ${p}: ${err instanceof Error ? err.message : String(err)}`
@@ -6217,7 +6378,7 @@ async function cleanCacheArtifacts(cacheDir, extras = []) {
 }
 async function isClientGenerated(pythonPath, env) {
   try {
-    await (0, import_execa4.default)(pythonPath, ["-c", "import prisma.client"], {
+    await (0, import_execa5.default)(pythonPath, ["-c", "import prisma.client"], {
       env,
       stdio: "pipe"
     });
@@ -6231,7 +6392,7 @@ var prismaQuirk = {
   async run(ctx) {
     const { venvPath, pythonEnv, workPath } = ctx;
     const pythonPath = getVenvPythonBin(venvPath);
-    const runtimeCacheDir = (0, import_path11.join)(
+    const runtimeCacheDir = (0, import_path12.join)(
       LAMBDA_ROOT2,
       resolveVendorDir(),
       "prisma",
@@ -6241,7 +6402,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs10.default.promises.access((0, import_path11.join)(dir, "prisma"));
+        await import_fs11.default.promises.access((0, import_path12.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -6253,21 +6414,21 @@ var prismaQuirk = {
       );
       return {};
     }
-    const cacheDir = (0, import_path11.join)(sitePackages, "prisma", "__bincache__");
-    await import_fs10.default.promises.mkdir(cacheDir, { recursive: true });
+    const cacheDir = (0, import_path12.join)(sitePackages, "prisma", "__bincache__");
+    await import_fs11.default.promises.mkdir(cacheDir, { recursive: true });
     const generateEnv = {
       ...pythonEnv,
       PRISMA_BINARY_CACHE_DIR: cacheDir
     };
-    const generatedDir = (0, import_path11.join)(workPath, "_prisma_generated");
-    const dummySchemaPath = (0, import_path11.join)(workPath, DUMMY_SCHEMA_NAME);
-    await import_fs10.default.promises.writeFile(
+    const generatedDir = (0, import_path12.join)(workPath, "_prisma_generated");
+    const dummySchemaPath = (0, import_path12.join)(workPath, DUMMY_SCHEMA_NAME);
+    await import_fs11.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
-    (0, import_build_utils12.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    (0, import_build_utils13.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
     try {
-      const dummyResult = await (0, import_execa4.default)(
+      const dummyResult = await (0, import_execa5.default)(
         pythonPath,
         ["-m", "prisma", "generate", `--schema=${dummySchemaPath}`],
         {
@@ -6277,11 +6438,11 @@ var prismaQuirk = {
         }
       );
       if (dummyResult.stdout)
-        (0, import_build_utils12.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+        (0, import_build_utils13.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
       if (dummyResult.stderr)
-        (0, import_build_utils12.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+        (0, import_build_utils13.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
     } catch (err) {
-      throw new import_build_utils12.NowBuildError({
+      throw new import_build_utils13.NowBuildError({
         code: "PRISMA_GENERATE_FAILED",
         message: `Prisma engine download failed during \`prisma generate\`. Check that your prisma version is compatible with this Python version.
 ` + execErrorMessage(err)
@@ -6289,47 +6450,47 @@ var prismaQuirk = {
     }
     const srcBinaryPrefix = `query-engine-${getLambdaBinaryTarget()}`;
     const runtimeName = `prisma-query-engine-rhel-openssl-${RUNTIME_OPENSSL_VERSION}.x`;
-    const nodeModulesDir = (0, import_path11.join)(cacheDir, "node_modules", "prisma");
+    const nodeModulesDir = (0, import_path12.join)(cacheDir, "node_modules", "prisma");
     let engineCopied = false;
     try {
-      const entries = await import_fs10.default.promises.readdir(nodeModulesDir);
+      const entries = await import_fs11.default.promises.readdir(nodeModulesDir);
       for (const entry of entries) {
         if (!entry.startsWith(srcBinaryPrefix))
           continue;
-        const srcPath = (0, import_path11.join)(nodeModulesDir, entry);
-        const destPath = (0, import_path11.join)(cacheDir, runtimeName);
+        const srcPath = (0, import_path12.join)(nodeModulesDir, entry);
+        const destPath = (0, import_path12.join)(cacheDir, runtimeName);
         try {
-          await import_fs10.default.promises.access(destPath);
-          (0, import_build_utils12.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+          await import_fs11.default.promises.access(destPath);
+          (0, import_build_utils13.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
-          (0, import_build_utils12.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
-          await import_fs10.default.promises.copyFile(srcPath, destPath);
+          (0, import_build_utils13.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          await import_fs11.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
     } catch (err) {
-      throw new import_build_utils12.NowBuildError({
+      throw new import_build_utils13.NowBuildError({
         code: "PRISMA_ENGINE_NOT_FOUND",
         message: `could not read Prisma engine directory "${nodeModulesDir}". This may indicate an incompatible prisma version.
 ` + (err instanceof Error ? err.message : String(err))
       });
     }
     if (!engineCopied) {
-      throw new import_build_utils12.NowBuildError({
+      throw new import_build_utils13.NowBuildError({
         code: "PRISMA_ENGINE_NOT_FOUND",
         message: `could not find engine binary matching "${srcBinaryPrefix}*" in "${nodeModulesDir}". This may indicate an incompatible prisma version or an unsupported platform (${process.arch}).`
       });
     }
-    const shimPath = (0, import_path11.join)(cacheDir, "openssl");
-    await import_fs10.default.promises.writeFile(
+    const shimPath = (0, import_path12.join)(cacheDir, "openssl");
+    await import_fs11.default.promises.writeFile(
       shimPath,
       `#!/bin/sh
 echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIME_OPENSSL_VERSION}.0)"
 `
     );
-    await import_fs10.default.promises.chmod(shimPath, 493);
+    await import_fs11.default.promises.chmod(shimPath, 493);
     for (const p of [generatedDir, dummySchemaPath]) {
-      await import_fs10.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs11.default.promises.rm(p, { recursive: true, force: true });
     }
     await cleanCacheArtifacts(cacheDir);
     const generateMode = (process.env.VERCEL_PRISMA_GENERATE_CLIENT ?? "auto").toLowerCase();
@@ -6342,16 +6503,16 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
           pythonEnv
         );
         if (clientAlreadyGenerated) {
-          (0, import_build_utils12.debug)(
+          (0, import_build_utils13.debug)(
             "Prisma quirk: client already generated, skipping user schema generate"
           );
           shouldGenerate = false;
         }
       }
       if (shouldGenerate) {
-        (0, import_build_utils12.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        (0, import_build_utils13.debug)(`Running prisma generate with user schema: ${userSchema}`);
         try {
-          const userResult = await (0, import_execa4.default)(
+          const userResult = await (0, import_execa5.default)(
             pythonPath,
             ["-m", "prisma", "generate", `--schema=${userSchema}`],
             {
@@ -6361,11 +6522,11 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
             }
           );
           if (userResult.stdout)
-            (0, import_build_utils12.debug)(`prisma generate stdout: ${userResult.stdout}`);
+            (0, import_build_utils13.debug)(`prisma generate stdout: ${userResult.stdout}`);
           if (userResult.stderr)
-            (0, import_build_utils12.debug)(`prisma generate stderr: ${userResult.stderr}`);
+            (0, import_build_utils13.debug)(`prisma generate stderr: ${userResult.stderr}`);
         } catch (err) {
-          throw new import_build_utils12.NowBuildError({
+          throw new import_build_utils13.NowBuildError({
             code: "PRISMA_GENERATE_FAILED",
             message: `\`prisma generate\` failed for schema "${userSchema}".
 ` + execErrorMessage(err)
@@ -6376,12 +6537,12 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
     }
     try {
       const allFiles = await collectFiles(
-        (0, import_path11.join)(sitePackages, "prisma"),
+        (0, import_path12.join)(sitePackages, "prisma"),
         sitePackages
       );
       const count = await (0, import_python_analysis7.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
-        (0, import_build_utils12.debug)(`Appended ${count} entries to prisma RECORD`);
+        (0, import_build_utils13.debug)(`Appended ${count} entries to prisma RECORD`);
       }
     } catch (err) {
       console.warn(
@@ -6475,13 +6636,13 @@ async function runQuirks(ctx) {
       (0, import_python_analysis8.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
-      (0, import_build_utils13.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+      (0, import_build_utils14.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
     }
     return installed;
   });
   const sorted = toposortQuirks(activated);
   for (const quirk of sorted) {
-    (0, import_build_utils13.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    (0, import_build_utils14.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
     const result = await quirk.run(ctx);
     if (result.env) {
       Object.assign(mergedEnv, result.env);
@@ -6502,14 +6663,14 @@ async function runQuirks(ctx) {
 }
 
 // src/django.ts
-var import_fs11 = __toESM(require("fs"));
-var import_path12 = require("path");
-var import_execa5 = __toESM(require_execa());
-var import_build_utils14 = require("@vercel/build-utils");
-var scriptPath = (0, import_path12.join)(__dirname, "..", "templates", "vc_django_settings.py");
-var script = import_fs11.default.readFileSync(scriptPath, "utf-8");
+var import_fs12 = __toESM(require("fs"));
+var import_path13 = require("path");
+var import_execa6 = __toESM(require_execa());
+var import_build_utils15 = require("@vercel/build-utils");
+var scriptPath2 = (0, import_path13.join)(__dirname, "..", "templates", "vc_django_settings.py");
+var script2 = import_fs12.default.readFileSync(scriptPath2, "utf-8");
 async function getDjangoSettings(projectDir, env) {
-  const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
+  const { stdout } = await (0, import_execa6.default)("python", ["-c", script2], {
     env,
     cwd: projectDir
   });
@@ -6535,21 +6696,21 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   const installedApps = djangoSettings["INSTALLED_APPS"] ?? [];
   const staticfilesDirs = djangoSettings["STATICFILES_DIRS"] ?? [];
   const staticSourceDirs = [
-    ...installedApps.map((app) => (0, import_path12.join)(workPath, ...app.split("."), "static")),
+    ...installedApps.map((app) => (0, import_path13.join)(workPath, ...app.split("."), "static")),
     // TODO: Deal with optional prefixes in STATICFILES_DIRS.
     ...staticfilesDirs.map((d) => Array.isArray(d) ? d[1] : d)
-  ].filter((d) => import_fs11.default.existsSync(d));
+  ].filter((d) => import_fs12.default.existsSync(d));
   if (storageBackend.startsWith("storages.backends.")) {
     console.log(
       "django-storages detected \u2014 running collectstatic with original settings"
     );
-    await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
+    await (0, import_execa6.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
       env: { ...env, DJANGO_SETTINGS_MODULE: settingsModule },
       cwd: workPath
     });
     return {
       staticSourceDirs,
-      staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
+      staticRoot: staticRoot ? (0, import_path13.resolve)(workPath, staticRoot) : null,
       cdnOutputDir: null,
       manifestRelPath: null
     };
@@ -6561,9 +6722,9 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     return null;
   }
   const staticUrlPath = staticUrl.replace(/^\/|\/$/g, "") || "static";
-  const staticOutputDir = (0, import_path12.join)(outputStaticDir, staticUrlPath);
-  await import_fs11.default.promises.mkdir(staticOutputDir, { recursive: true });
-  const shimPath = (0, import_path12.join)(workPath, "_vercel_collectstatic_settings.py");
+  const staticOutputDir = (0, import_path13.join)(outputStaticDir, staticUrlPath);
+  await import_fs12.default.promises.mkdir(staticOutputDir, { recursive: true });
+  const shimPath = (0, import_path13.join)(workPath, "_vercel_collectstatic_settings.py");
   const shimLines = [
     `from ${settingsModule} import *`,
     `STATIC_ROOT = ${JSON.stringify(staticOutputDir)}`
@@ -6571,10 +6732,10 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   if (whitenoiseUseFinders) {
     shimLines.push(`WHITENOISE_USE_FINDERS = False`);
   }
-  await import_fs11.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
+  await import_fs12.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
   try {
     console.log("Running collectstatic...");
-    await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
+    await (0, import_execa6.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
       env: {
         ...env,
         DJANGO_SETTINGS_MODULE: "_vercel_collectstatic_settings"
@@ -6582,7 +6743,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
       cwd: workPath
     });
   } finally {
-    await import_fs11.default.promises.unlink(shimPath).catch(() => {
+    await import_fs12.default.promises.unlink(shimPath).catch(() => {
     });
   }
   const MANIFEST_STORAGE_BACKENDS = [
@@ -6591,17 +6752,17 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   ];
   let manifestRelPath = null;
   if (MANIFEST_STORAGE_BACKENDS.includes(storageBackend) && staticRoot) {
-    const manifestSrc = (0, import_path12.join)(staticOutputDir, "staticfiles.json");
-    const resolvedStaticRoot = (0, import_path12.resolve)(workPath, staticRoot);
-    const manifestDest = (0, import_path12.join)(resolvedStaticRoot, "staticfiles.json");
-    await import_fs11.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
-    await import_fs11.default.promises.copyFile(manifestSrc, manifestDest);
-    manifestRelPath = (0, import_path12.relative)(workPath, manifestDest);
-    (0, import_build_utils14.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
+    const manifestSrc = (0, import_path13.join)(staticOutputDir, "staticfiles.json");
+    const resolvedStaticRoot = (0, import_path13.resolve)(workPath, staticRoot);
+    const manifestDest = (0, import_path13.join)(resolvedStaticRoot, "staticfiles.json");
+    await import_fs12.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
+    await import_fs12.default.promises.copyFile(manifestSrc, manifestDest);
+    manifestRelPath = (0, import_path13.relative)(workPath, manifestDest);
+    (0, import_build_utils15.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
   return {
     staticSourceDirs,
-    staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
+    staticRoot: staticRoot ? (0, import_path13.resolve)(workPath, staticRoot) : null,
     cdnOutputDir: outputStaticDir,
     manifestRelPath
   };
@@ -6609,7 +6770,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
 
 // src/index.ts
 var import_python_analysis9 = require("@vercel/python-analysis");
-var writeFile = import_fs12.default.promises.writeFile;
+var writeFile = import_fs13.default.promises.writeFile;
 var version = -1;
 async function runFrameworkHook(framework, ctx) {
   const hook = framework ? frameworkHooks[framework] : void 0;
@@ -6624,7 +6785,7 @@ var frameworkHooks = {
     detected
   }) => {
     if (detected?.baseDir === void 0) {
-      (0, import_build_utils15.debug)("Django hook: no manage.py detected, skipping");
+      (0, import_build_utils16.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
     let settingsResult;
@@ -6638,13 +6799,13 @@ Hint: activate a venv or run with \`uv run vercel dev\``;
       } else {
         detail = err?.stderr || err?.message || String(err);
       }
-      throw new import_build_utils15.NowBuildError({
+      throw new import_build_utils16.NowBuildError({
         code: "DJANGO_SETTINGS_FAILED",
         message: `Failed to read Django application settings from ${projectDir}/manage.py:
 ${detail}`
       });
     }
-    (0, import_build_utils15.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    (0, import_build_utils16.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
     const { djangoSettings, settingsModule, djangoVersion } = settingsResult;
     if (djangoVersion) {
       console.log(`Django ${djangoVersion.join(".")} detected`);
@@ -6657,7 +6818,7 @@ ${detail}`
       const variableName = parts.at(-1);
       const rel = `${parts.slice(0, -1).join("/")}.py`;
       const ep = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils15.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
+      (0, import_build_utils16.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
       resolvedEntrypoint = { entrypoint: ep, variableName };
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
@@ -6666,7 +6827,7 @@ ${detail}`
         const variableName = parts.at(-1);
         const rel = `${parts.slice(0, -1).join("/")}.py`;
         const ep = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils15.debug)(
+        (0, import_build_utils16.debug)(
           `Django hook: WSGI entrypoint: ${ep} (variable: ${variableName})`
         );
         resolvedEntrypoint = { entrypoint: ep, variableName };
@@ -6674,7 +6835,7 @@ ${detail}`
     }
     let djangoStatic = null;
     if (workPath && venvPath) {
-      const outputStaticDir = (0, import_path13.join)(workPath, ".vercel", "output", "static");
+      const outputStaticDir = (0, import_path14.join)(workPath, ".vercel", "output", "static");
       djangoStatic = await runDjangoCollectStatic(
         venvPath,
         workPath,
@@ -6694,14 +6855,14 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils15.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils15.download)(files, workPath, meta);
+  (0, import_build_utils16.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils16.download)(files, workPath, meta);
   if (meta.isDev && entrypoint) {
-    const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
-    const cacheKey = (0, import_path13.basename)(entrypoint).replace(/\./g, "_");
-    const destCache = (0, import_path13.join)(devCacheDir, cacheKey);
-    await (0, import_build_utils15.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils15.glob)("**", destCache);
+    const { devCacheDir = (0, import_path14.join)(workPath, ".now", "cache") } = meta;
+    const cacheKey = (0, import_path14.basename)(entrypoint).replace(/\./g, "_");
+    const destCache = (0, import_path14.join)(devCacheDir, cacheKey);
+    await (0, import_build_utils16.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils16.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -6717,13 +6878,13 @@ var build = async ({
   service
 }) => {
   let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
-  const builderSpan = parentSpan ?? new import_build_utils15.Span({ name: "vc.builder" });
+  const builderSpan = parentSpan ?? new import_build_utils16.Span({ name: "vc.builder" });
   const framework = config?.framework;
   const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils15.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils16.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -6732,7 +6893,7 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path13.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path14.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
@@ -6755,8 +6916,8 @@ var build = async ({
   if (detected?.error && detected?.baseDir === void 0) {
     throw detected?.error;
   }
-  const entryDirectory = detected?.baseDir ?? (entrypoint ? (0, import_path13.dirname)(entrypoint) : ".");
-  const entrypointAbsDir = (0, import_path13.join)(workPath, entryDirectory);
+  const entryDirectory = detected?.baseDir ?? (entrypoint ? (0, import_path14.dirname)(entrypoint) : ".");
+  const entrypointAbsDir = (0, import_path14.join)(workPath, entryDirectory);
   const rootDir = repoRootPath ?? workPath;
   const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
     () => discoverPackage({
@@ -6786,12 +6947,26 @@ var build = async ({
 `
     );
   }
-  const venvPath = service?.name ? (0, import_path13.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path13.join)(workPath, ".vercel", "python", ".venv");
   const uvCacheDir = getUvCacheDir(workPath);
-  const hasCachedVenv = import_fs12.default.existsSync((0, import_path13.join)(venvPath, "pyvenv.cfg"));
-  const hasCachedUv = import_fs12.default.existsSync(uvCacheDir);
+  let uv;
+  try {
+    const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
+    uv = new UvRunner(uvPath, uvCacheDir);
+    const uvVersionOutput = (0, import_child_process3.execSync)(`${uvPath} --version`, {
+      encoding: "utf8"
+    }).trim();
+    console.log(`Using ${uvVersionOutput}`);
+  } catch (err) {
+    console.log("Failed to install or locate uv");
+    throw new Error(
+      `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const venvPath = service?.name ? (0, import_path14.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path14.join)(workPath, ".vercel", "python", ".venv");
+  const hasCachedVenv = import_fs13.default.existsSync((0, import_path14.join)(venvPath, "pyvenv.cfg"));
+  const hasCachedUv = import_fs13.default.existsSync(uvCacheDir);
   if (hasCachedVenv || hasCachedUv) {
-    (0, import_build_utils15.debug)(
+    (0, import_build_utils16.debug)(
       `Build cache detected: venv=${hasCachedVenv}, uv-cache=${hasCachedUv}`
     );
   }
@@ -6799,17 +6974,18 @@ var build = async ({
     await ensureVenv({
       pythonVersion,
       venvPath,
+      uvPath: uv.getPath(),
       uvCacheDir
     });
   });
-  if ((0, import_build_utils15.isPythonFramework)(framework)) {
+  if ((0, import_build_utils16.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils15.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils15.getEnvForPackageManager)({
+    } = await (0, import_build_utils16.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils16.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -6831,38 +7007,25 @@ var build = async ({
   const pythonEnv = createVenvEnv(venvPath, baseEnv, uvCacheDir);
   pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
   let assumeDepsInstalled = false;
-  let uv;
-  try {
-    const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
-    uv = new UvRunner(uvPath, uvCacheDir);
-    const uvVersionOutput = (0, import_child_process3.execSync)(`${uvPath} --version`, {
-      encoding: "utf8"
-    }).trim();
-    console.log(`Using ${uvVersionOutput}`);
-  } catch (err) {
-    console.log("Failed to install or locate uv");
-    throw new Error(
-      `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  await builderSpan.child(import_build_utils15.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils16.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
-      await import_fs12.default.promises.rm(venvPath, { recursive: true, force: true });
+      await import_fs13.default.promises.rm(venvPath, { recursive: true, force: true });
       await ensureVenv({
         pythonVersion,
         venvPath,
+        uvPath: uv.getPath(),
         uvCacheDir,
         quiet: true
       });
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils15.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils16.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -6883,7 +7046,7 @@ var build = async ({
     }
     if (!assumeDepsInstalled) {
       const lockCacheKey = service?.name ? `uv.lock.${service.name}` : "uv.lock";
-      const cachedLockPath = (0, import_path13.join)(uvCacheDir, lockCacheKey);
+      const cachedLockPath = (0, import_path14.join)(uvCacheDir, lockCacheKey);
       const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
         workPath,
         rootDir,
@@ -6903,21 +7066,21 @@ var build = async ({
         frozen: lockFileProvidedByUser,
         locked: !lockFileProvidedByUser
       });
-      if (lockPath && import_fs12.default.existsSync(lockPath)) {
-        await import_fs12.default.promises.mkdir(uvCacheDir, { recursive: true });
-        await import_fs12.default.promises.copyFile(lockPath, cachedLockPath);
+      if (lockPath && import_fs13.default.existsSync(lockPath)) {
+        await import_fs13.default.promises.mkdir(uvCacheDir, { recursive: true });
+        await import_fs13.default.promises.copyFile(lockPath, cachedLockPath);
       }
     }
   });
-  if ((0, import_build_utils15.isPythonFramework)(framework)) {
+  if ((0, import_build_utils16.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils15.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils16.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils15.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils16.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
@@ -6932,7 +7095,7 @@ var build = async ({
   }
   const hookResult = await runFrameworkHook(framework, {
     pythonEnv,
-    projectDir: (0, import_path13.join)(workPath, entryDirectory),
+    projectDir: (0, import_path14.join)(workPath, entryDirectory),
     workPath,
     venvPath,
     entrypoint,
@@ -6944,25 +7107,25 @@ var build = async ({
   }
   entrypoint = resolved?.entrypoint;
   if (!entrypoint) {
-    throw new import_build_utils15.NowBuildError({
+    throw new import_build_utils16.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: "No Python entrypoint could be detected. Please specify an entrypoint file."
     });
   }
   const djangoStatic = hookResult?.djangoStatic ?? null;
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils15.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils16.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
-    projectDir: (0, import_path13.join)(workPath, entryDirectory),
+    projectDir: (0, import_path14.join)(workPath, entryDirectory),
     args: ["install", runtimeDep]
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
-    (0, import_build_utils15.debug)(`Installing ${workersDep}`);
+    (0, import_build_utils16.debug)(`Installing ${workersDep}`);
     await uv.pip({
       venvPath,
-      projectDir: (0, import_path13.join)(workPath, entryDirectory),
+      projectDir: (0, import_path14.join)(workPath, entryDirectory),
       args: ["install", workersDep]
     });
   }
@@ -6970,14 +7133,14 @@ var build = async ({
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
-  (0, import_build_utils15.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils16.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   if (handlerFunction) {
-    const entrypointPath = (0, import_path13.join)(workPath, entrypoint);
-    const source = await import_fs12.default.promises.readFile(entrypointPath, "utf-8");
+    const entrypointPath = (0, import_path14.join)(workPath, entrypoint);
+    const source = await import_fs13.default.promises.readFile(entrypointPath, "utf-8");
     const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
-      throw new import_build_utils15.NowBuildError({
+      throw new import_build_utils16.NowBuildError({
         code: "PYTHON_HANDLER_NOT_FOUND",
         message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
       });
@@ -6986,9 +7149,23 @@ var build = async ({
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils15.debug)("Entrypoint with suffix is", entrypointWithSuffix);
-  const handlerFuncEnvLine = handlerFunction ? `
-  "__VC_HANDLER_FUNC_NAME": "${handlerFunction}",` : "";
+  (0, import_build_utils16.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  const crons = await getServiceCrons({
+    service,
+    entrypoint,
+    rawEntrypoint,
+    handlerFunction,
+    pythonBin: getVenvPythonBin(venvPath),
+    env: pythonEnv,
+    workPath
+  });
+  let cronEnvLine = "";
+  if (crons?.length) {
+    const json = JSON.stringify(buildCronRouteTable(crons));
+    (0, import_assert.default)(!json.includes("\\"), `backslash in cron route table: ${json}`);
+    cronEnvLine = `
+  "__VC_CRON_ROUTES": '${json}',`;
+  }
   const variableName = resolved?.variableName ?? "";
   const runtimeTrampoline = `
 import importlib
@@ -7004,7 +7181,7 @@ os.environ.update({
   "__VC_HANDLER_ENTRYPOINT": "${entrypointWithSuffix}",
   "__VC_HANDLER_ENTRYPOINT_ABS": os.path.join(_here, "${entrypointWithSuffix}"),
   "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",
-  "__VC_HANDLER_VARIABLE_NAME": "${variableName}",${handlerFuncEnvLine}
+  "__VC_HANDLER_VARIABLE_NAME": "${variableName}",${cronEnvLine}
 })
 
 _vendor_rel = '${vendorDir}'
@@ -7057,10 +7234,10 @@ from vercel_runtime.vc_init import vc_handler
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils15.glob)("**", globOptions);
+  const files = await (0, import_build_utils16.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils15.FileFsRef({
-      fsPath: (0, import_path13.join)(workPath, djangoStatic.manifestRelPath)
+    files[djangoStatic.manifestRelPath] = new import_build_utils16.FileFsRef({
+      fsPath: (0, import_path14.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
   const depExternalizer = new PythonDependencyExternalizer({
@@ -7096,12 +7273,12 @@ from vercel_runtime.vc_init import vc_handler
     }
   });
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils15.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils16.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils15.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils16.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils15.Lambda({
+  const output = new import_build_utils16.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -7117,16 +7294,20 @@ from vercel_runtime.vc_init import vc_handler
         uvLockPath
       });
     } catch (err) {
-      (0, import_build_utils15.debug)(
+      (0, import_build_utils16.debug)(
         `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-  if (!(0, import_build_utils15.isPythonFramework)(framework)) {
+  if (!(0, import_build_utils16.isPythonFramework)(framework) && !service?.name) {
     return { resultVersion: 3, result: { output } };
   }
   const lambdaPath = service?.name ? `_svc/${service.name}/index` : "index";
-  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils15.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
+  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils16.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
+  const routes = [
+    { handle: "filesystem" },
+    { src: "/(.*)", dest: `/${lambdaPath}` }
+  ];
   return {
     resultVersion: 2,
     result: {
@@ -7134,10 +7315,8 @@ from vercel_runtime.vc_init import vc_handler
         [lambdaPath]: output,
         ...staticFiles
       },
-      routes: [
-        { handle: "filesystem" },
-        { src: "/(.*)", dest: `/${lambdaPath}` }
-      ]
+      routes,
+      crons
     }
   };
 };
@@ -7159,14 +7338,14 @@ var prepareCache = async ({
     }
   } catch {
   }
-  return (0, import_build_utils15.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
+  return (0, import_build_utils16.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
     cwd: root,
     ignore
   });
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils15.isPythonFramework)(framework)) {
+  if ((0, import_build_utils16.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;
@@ -7185,7 +7364,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path13.parse)(entrypoint);
+  const { dir, name } = (0, import_path14.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }