@vercel/python 6.32.0 → 6.33.1

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}`);
     }
@@ -4313,6 +4314,11 @@ 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 FUNCTIONS_BETA_CTA = "Run `vercel deploy --functions-beta` to use extended function limits (up to 1 GB), or reduce your dependency footprint.";
+function shouldShowFunctionsBetaHint() {
+  const v = process.env.VERCEL_FUNCTIONS_BETA_HINT;
+  return v === "1" || v === "true";
+}
 var PythonDependencyExternalizer = class {
   constructor(options) {
     // Populated by analyze()
@@ -4367,7 +4373,9 @@ var PythonDependencyExternalizer = class {
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils5.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the Lambda size limit (${limitMB} MB).
+        message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the size limit (${limitMB} MB).
+
+` + FUNCTIONS_BETA_CTA : `Total bundle size (${totalBundleSizeMB} MB) exceeds the Lambda size limit (${limitMB} MB).
 
 Runtime dependency installation is not available for projects that use a custom build or install command, because custom commands may install dependencies that are not tracked in uv.lock.
 
@@ -4419,7 +4427,9 @@ To resolve this, either:
       const ephemeralLimitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils5.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total dependency size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB). Even with runtime dependency installation, all packages must fit within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda functions. Consider removing unused dependencies or splitting your application into smaller functions.`,
+        message: shouldShowFunctionsBetaHint() ? `Total dependency size (${totalBundleSizeMB} MB) exceeds the size limit (${ephemeralLimitMB} MB).
+
+` + FUNCTIONS_BETA_CTA : `Total dependency size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB). Even with runtime dependency installation, all packages must fit within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda functions. 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"
       });
@@ -4613,7 +4623,9 @@ To fix this, either:
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils5.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after deferring public packages to runtime installation. This usually means your private packages or source code are too large. Consider reducing the size of private dependencies or splitting your application.`,
+        message: shouldShowFunctionsBetaHint() ? `Bundle size (${finalSizeMB} MB) exceeds the size limit (${limitMB} MB).
+
+` + FUNCTIONS_BETA_CTA : `Bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after deferring public packages to runtime installation. This usually means your private packages or source code are too large. Consider reducing the size of private dependencies or splitting your application.`,
         link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
         action: "Learn More"
       });
@@ -5103,20 +5115,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",
@@ -5133,27 +5286,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;
@@ -5168,7 +5321,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 };
     }
   }
@@ -5178,19 +5331,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;
@@ -5198,7 +5351,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();
@@ -5208,7 +5361,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`,
@@ -5223,7 +5376,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;
   }
 }
@@ -5232,7 +5385,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") };
@@ -5242,7 +5395,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;
   }
 }
@@ -5258,11 +5411,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",
@@ -5368,17 +5521,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}`
     );
   }
@@ -5411,7 +5564,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)}`
     });
@@ -5426,14 +5579,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/",
@@ -5455,11 +5608,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),
@@ -5503,7 +5656,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({
@@ -5529,8 +5682,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,
     "..",
     "..",
@@ -5538,21 +5691,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"] };
@@ -5567,14 +5720,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);
@@ -5599,7 +5752,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({
@@ -5625,8 +5778,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,
     "..",
     "..",
@@ -5634,21 +5787,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"] };
@@ -5663,14 +5816,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);
@@ -5700,12 +5853,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);
     }
@@ -5713,7 +5866,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;
     }
@@ -5730,55 +5883,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) => {
@@ -5841,7 +5994,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
@@ -5852,7 +6005,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."
     });
@@ -5881,7 +6034,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.`
@@ -5898,11 +6051,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,
@@ -5911,9 +6064,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";
@@ -5962,13 +6115,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,
@@ -5979,8 +6141,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);
@@ -5989,12 +6151,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) {
@@ -6038,7 +6200,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;
@@ -6048,7 +6210,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
@@ -6062,9 +6224,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",
@@ -6074,9 +6236,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 {
     }
@@ -6091,32 +6253,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}`
       );
     }
@@ -6125,10 +6287,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) {
@@ -6166,22 +6328,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 {
     }
@@ -6192,32 +6354,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)}`
@@ -6227,7 +6389,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"
     });
@@ -6241,7 +6403,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",
@@ -6251,7 +6413,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 {
@@ -6263,21 +6425,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}`],
         {
@@ -6287,11 +6449,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)
@@ -6299,47 +6461,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();
@@ -6352,16 +6514,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}`],
             {
@@ -6371,11 +6533,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)
@@ -6386,12 +6548,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(
@@ -6485,13 +6647,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);
@@ -6512,14 +6674,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
   });
@@ -6545,21 +6707,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
     };
@@ -6571,9 +6733,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)}`
@@ -6581,10 +6743,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"
@@ -6592,7 +6754,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 = [
@@ -6601,17 +6763,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
   };
@@ -6619,7 +6781,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;
@@ -6634,7 +6796,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;
@@ -6648,13 +6810,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`);
@@ -6667,7 +6829,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"];
@@ -6676,7 +6838,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 };
@@ -6684,7 +6846,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,
@@ -6704,14 +6866,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;
@@ -6727,13 +6889,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,
@@ -6742,7 +6904,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) {
@@ -6765,8 +6927,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({
@@ -6796,12 +6958,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}`
     );
   }
@@ -6809,17 +6985,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,
@@ -6841,38 +7018,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
       });
@@ -6893,7 +7057,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,
@@ -6913,21 +7077,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
         });
@@ -6942,7 +7106,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,
@@ -6954,25 +7118,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]
     });
   }
@@ -6980,14 +7144,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.`
       });
@@ -6996,9 +7160,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
@@ -7014,7 +7192,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}'
@@ -7067,10 +7245,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({
@@ -7106,12 +7284,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,
@@ -7127,16 +7305,17 @@ 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 = service?.name ? void 0 : [{ handle: "filesystem" }, { src: "/(.*)", dest: `/${lambdaPath}` }];
   return {
     resultVersion: 2,
     result: {
@@ -7144,10 +7323,8 @@ from vercel_runtime.vc_init import vc_handler
         [lambdaPath]: output,
         ...staticFiles
       },
-      routes: [
-        { handle: "filesystem" },
-        { src: "/(.*)", dest: `/${lambdaPath}` }
-      ]
+      ...routes ? { routes } : {},
+      crons
     }
   };
 };
@@ -7169,14 +7346,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;
@@ -7195,7 +7372,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;
   }