@vercel/python 6.30.0 → 6.31.0

package/dist/index.js

@@ -3225,19 +3225,19 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_child_process3 = require("child_process");
-var import_fs11 = __toESM(require("fs"));
+var import_fs12 = __toESM(require("fs"));
 var import_path13 = require("path");
 
 // src/package-versions.ts
 var VERCEL_RUNTIME_VERSION = "0.12.0";
-var VERCEL_WORKERS_VERSION = "0.0.15";
+var VERCEL_WORKERS_VERSION = "0.0.16";
 
 // src/index.ts
 var import_build_utils15 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
-var import_fs3 = __toESM(require("fs"));
+var import_fs4 = __toESM(require("fs"));
 var import_path5 = require("path");
 var import_build_utils4 = require("@vercel/build-utils");
 var import_python_analysis2 = require("@vercel/python-analysis");
@@ -3265,8 +3265,14 @@ var UV_PYTHON_DOWNLOADS_MODE = "automatic";
 var UV_CACHE_DIR_SUBPATH = [".vercel", "python", "cache", "uv"];
 var isWin = process.platform === "win32";
 var uvExec = isWin ? "uv.exe" : "uv";
+var KNOWN_UV_PATH = "/usr/local/bin/uv";
+function findUvOnBuildImage(knownPath = KNOWN_UV_PATH) {
+  if (!process.env.VERCEL_BUILD_IMAGE)
+    return null;
+  return import_fs.default.existsSync(knownPath) ? knownPath : null;
+}
 function findUvInPath() {
-  return import_which.default.sync("uv", { nothrow: true });
+  return findUvOnBuildImage() ?? import_which.default.sync("uv", { nothrow: true });
 }
 function getUvCacheDir(workPath) {
   return (0, import_path.join)(workPath, ...UV_CACHE_DIR_SUBPATH);
@@ -3448,6 +3454,9 @@ async function getUserScriptsDir(pythonPath) {
   }
 }
 async function findUvBinary(pythonPath) {
+  const buildImageUv = findUvOnBuildImage();
+  if (buildImageUv)
+    return buildImageUv;
   const found = import_which.default.sync("uv", { nothrow: true });
   if (found)
     return found;
@@ -3573,7 +3582,9 @@ function useVirtualEnv(workPath, env, systemPython) {
 function createVenvEnv(venvPath, baseEnv = process.env, uvCacheDir) {
   const env = {
     ...getProtectedUvEnv(baseEnv, uvCacheDir),
-    VIRTUAL_ENV: venvPath
+    VIRTUAL_ENV: venvPath,
+    UV_PROJECT_ENVIRONMENT: venvPath,
+    UV_NO_DEV: "true"
   };
   const binDir = getVenvBinDir(venvPath);
   const existingPath = env.PATH || process.env.PATH || "";
@@ -3729,6 +3740,7 @@ function detectPlatform() {
 
 // src/version.ts
 var import_path4 = require("path");
+var import_fs3 = require("fs");
 var import_build_utils3 = require("@vercel/build-utils");
 var import_python_analysis = require("@vercel/python-analysis");
 function pythonVersionString(pv) {
@@ -3932,10 +3944,24 @@ function isDiscontinued({ discontinueDate }) {
   return discontinueDate !== void 0 && discontinueDate.getTime() <= today;
 }
 var installedPythonsCache = null;
+function getInstalledPythonsFromFilesystem(basePath = UV_PYTHON_PATH_PREFIX) {
+  const result = /* @__PURE__ */ new Set();
+  for (const opt of allOptions) {
+    const binPath = (0, import_path4.join)(basePath, "bin", `python${opt.major}.${opt.minor}`);
+    if ((0, import_fs3.existsSync)(binPath)) {
+      result.add(pythonVersionString(opt));
+    }
+  }
+  return result;
+}
 function getInstalledPythons() {
   if (installedPythonsCache !== null) {
     return installedPythonsCache;
   }
+  if (process.env.VERCEL_BUILD_IMAGE) {
+    installedPythonsCache = getInstalledPythonsFromFilesystem();
+    return installedPythonsCache;
+  }
   const uvPath = findUvInPath();
   if (!uvPath) {
     throw new import_build_utils3.NowBuildError({
@@ -3966,9 +3992,9 @@ async function restoreCachedLock(cachedLockPath, projectDir) {
   if (!cachedLockPath)
     return;
   const targetLockPath = (0, import_path5.join)(projectDir, "uv.lock");
-  if (import_fs3.default.existsSync(cachedLockPath) && !import_fs3.default.existsSync(targetLockPath)) {
+  if (import_fs4.default.existsSync(cachedLockPath) && !import_fs4.default.existsSync(targetLockPath)) {
     (0, import_build_utils4.debug)("Restoring cached uv.lock");
-    await import_fs3.default.promises.copyFile(cachedLockPath, targetLockPath);
+    await import_fs4.default.promises.copyFile(cachedLockPath, targetLockPath);
   }
 }
 var makeDependencyCheckCode = (dependency) => `
@@ -4115,7 +4141,7 @@ async function ensureUvProject({
     lockPath = (0, import_path5.join)(rootDir, lockFile.path);
     projectDir = (0, import_path5.dirname)(lockPath);
     pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
-    if (!import_fs3.default.existsSync(pyprojectPath)) {
+    if (!import_fs4.default.existsSync(pyprojectPath)) {
       throw new Error(
         `Expected "pyproject.toml" next to "${lockFile.kind}" in "${projectDir}"`
       );
@@ -4142,7 +4168,7 @@ async function ensureUvProject({
       }
       const content = (0, import_python_analysis2.stringifyManifest)(manifest.data);
       pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
-      await import_fs3.default.promises.writeFile(pyprojectPath, content);
+      await import_fs4.default.promises.writeFile(pyprojectPath, content);
     }
     const workspaceLockFile = pythonPackage.workspaceLockFile;
     if (workspaceLockFile) {
@@ -4169,7 +4195,7 @@ async function ensureUvProject({
       dependencies: []
     });
     const content = (0, import_python_analysis2.stringifyManifest)(minimalManifest);
-    await import_fs3.default.promises.writeFile(pyprojectPath, content);
+    await import_fs4.default.promises.writeFile(pyprojectPath, content);
     await restoreCachedLock(cachedLockPath, projectDir);
     await uv.lock({
       projectDir,
@@ -4177,7 +4203,7 @@ async function ensureUvProject({
       ...requireBinaryWheels ? { noBuild: true, upgrade: true } : {}
     });
   }
-  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : (0, import_path5.join)(projectDir, "uv.lock");
+  const resolvedLockPath = lockPath && import_fs4.default.existsSync(lockPath) ? lockPath : (0, import_path5.join)(projectDir, "uv.lock");
   return {
     projectDir,
     pyprojectPath,
@@ -4278,12 +4304,12 @@ async function installRequirementsFile({
 }
 
 // src/dependency-externalizer.ts
-var import_fs4 = __toESM(require("fs"));
+var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
 var import_path6 = require("path");
 var import_build_utils5 = require("@vercel/build-utils");
 var import_python_analysis3 = require("@vercel/python-analysis");
-var readFile = (0, import_util.promisify)(import_fs4.default.readFile);
+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 PythonDependencyExternalizer = class {
@@ -4486,7 +4512,7 @@ To fix this, either:
     if (process.env.VERCEL_BUILD_IMAGE) {
       try {
         const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
-        const uvStats = await import_fs4.default.promises.stat(uvBinaryPath);
+        const uvStats = await import_fs5.default.promises.stat(uvBinaryPath);
         runtimeToolingOverhead = uvStats.size;
       } catch {
         runtimeToolingOverhead = 50 * 1024 * 1024;
@@ -4498,8 +4524,8 @@ To fix this, either:
     const isOutsideWorkPath = projectDirRel.startsWith("..") || uvLockRel.startsWith("..");
     if (isOutsideWorkPath) {
       const pyprojectPath = (0, import_path6.join)(this.uvProjectDir, "pyproject.toml");
-      const pyprojectStats = await import_fs4.default.promises.stat(pyprojectPath).catch(() => null);
-      const uvLockStats = await import_fs4.default.promises.stat(this.uvLockPath).catch(() => null);
+      const pyprojectStats = await import_fs5.default.promises.stat(pyprojectPath).catch(() => null);
+      const uvLockStats = await import_fs5.default.promises.stat(this.uvLockPath).catch(() => null);
       if (pyprojectStats)
         runtimeToolingOverhead += pyprojectStats.size;
       if (uvLockStats)
@@ -4554,9 +4580,9 @@ To fix this, either:
         const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
         const uvBundleDir = (0, import_path6.join)(this.workPath, UV_BUNDLE_DIR);
         const uvLocalPath = (0, import_path6.join)(uvBundleDir, "uv");
-        await import_fs4.default.promises.mkdir(uvBundleDir, { recursive: true });
-        await import_fs4.default.promises.copyFile(uvBinaryPath, uvLocalPath);
-        await import_fs4.default.promises.chmod(uvLocalPath, 493);
+        await import_fs5.default.promises.mkdir(uvBundleDir, { recursive: true });
+        await import_fs5.default.promises.copyFile(uvBinaryPath, uvLocalPath);
+        await import_fs5.default.promises.chmod(uvLocalPath, 493);
         const uvBundlePath = `${UV_BUNDLE_DIR}/uv`;
         files[uvBundlePath] = new import_build_utils5.FileFsRef({
           fsPath: uvLocalPath,
@@ -4729,7 +4755,7 @@ async function mirrorPackagesIntoVendor({
   const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis3.normalizePackageName)) : null;
   const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
   for (const dir of sitePackageDirs) {
-    if (!import_fs4.default.existsSync(dir))
+    if (!import_fs5.default.existsSync(dir))
       continue;
     const resolvedDir = (0, import_path6.resolve)(dir);
     const dirPrefix = resolvedDir + import_path6.sep;
@@ -4746,7 +4772,7 @@ async function mirrorPackagesIntoVendor({
           continue;
         }
         const srcFsPath = (0, import_path6.join)(dir, filePath);
-        if (!import_fs4.default.existsSync(srcFsPath)) {
+        if (!import_fs5.default.existsSync(srcFsPath)) {
           continue;
         }
         const bundlePath = (0, import_path6.join)(vendorDirName, filePath).replace(/\\/g, "/");
@@ -4765,7 +4791,7 @@ async function calculateBundleSize(files) {
     const file = files[filePath];
     if ("fsPath" in file && file.fsPath) {
       try {
-        const stats = await import_fs4.default.promises.stat(file.fsPath);
+        const stats = await import_fs5.default.promises.stat(file.fsPath);
         totalSize += stats.size;
       } catch (err) {
         console.warn(
@@ -4798,7 +4824,7 @@ async function calculatePerPackageSizes(venvPath) {
   const sizes = /* @__PURE__ */ new Map();
   const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
   for (const dir of sitePackageDirs) {
-    if (!import_fs4.default.existsSync(dir))
+    if (!import_fs5.default.existsSync(dir))
       continue;
     const resolvedDir = (0, import_path6.resolve)(dir);
     const dirPrefix = resolvedDir + import_path6.sep;
@@ -4814,7 +4840,7 @@ async function calculatePerPackageSizes(venvPath) {
           continue;
         }
         try {
-          const stats = await import_fs4.default.promises.stat((0, import_path6.join)(dir, filePath));
+          const stats = await import_fs5.default.promises.stat((0, import_path6.join)(dir, filePath));
           totalSize += stats.size;
         } catch {
         }
@@ -4826,7 +4852,7 @@ async function calculatePerPackageSizes(venvPath) {
 }
 
 // src/diagnostics.ts
-var import_fs5 = __toESM(require("fs"));
+var import_fs6 = __toESM(require("fs"));
 var import_path7 = require("path");
 var import_build_utils6 = require("@vercel/build-utils");
 var import_python_analysis4 = require("@vercel/python-analysis");
@@ -4943,7 +4969,7 @@ async function generateProjectManifest({
   const directEntries = [];
   const transitiveEntries = [];
   {
-    const content = await import_fs5.default.promises.readFile(uvLockPath, "utf-8");
+    const content = await import_fs6.default.promises.readFile(uvLockPath, "utf-8");
     const uvLock = (0, import_python_analysis4.parseUvLock)(content, uvLockPath);
     const projectName = project?.name;
     const excludeSet = new Set(
@@ -5047,15 +5073,15 @@ async function generateProjectManifest({
     ]
   };
   const outPath = (0, import_path7.join)(workPath, DIAGNOSTICS_PATH);
-  await import_fs5.default.promises.mkdir((0, import_path7.dirname)(outPath), { recursive: true });
-  await import_fs5.default.promises.writeFile(outPath, JSON.stringify(manifest, null, 2));
+  await import_fs6.default.promises.mkdir((0, import_path7.dirname)(outPath), { recursive: true });
+  await import_fs6.default.promises.writeFile(outPath, JSON.stringify(manifest, null, 2));
 }
 var diagnostics = async ({
   workPath
 }) => {
   try {
     const manifestPath = (0, import_path7.join)(workPath, DIAGNOSTICS_PATH);
-    const data = await import_fs5.default.promises.readFile(manifestPath, "utf-8");
+    const data = await import_fs6.default.promises.readFile(manifestPath, "utf-8");
     return {
       [MANIFEST_FILENAME]: new import_build_utils6.FileBlob({ data })
     };
@@ -5069,14 +5095,14 @@ var diagnostics = async ({
 
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs7 = require("fs");
+var import_fs8 = require("fs");
 var import_path9 = require("path");
 var import_build_utils10 = 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_fs6 = __toESM(require("fs"));
+var import_fs7 = __toESM(require("fs"));
 var import_path8 = require("path");
 var import_build_utils7 = require("@vercel/build-utils");
 var import_build_utils8 = require("@vercel/build-utils");
@@ -5103,7 +5129,7 @@ function getCandidateEntrypointsInDirs(dirs) {
 }
 async function fileExists(filePath) {
   try {
-    const stat = await import_fs6.default.promises.stat(filePath);
+    const stat = await import_fs7.default.promises.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
@@ -5113,7 +5139,7 @@ async function checkEntrypoint(workPath, relPath) {
   const absPath = (0, import_path8.join)(workPath, relPath);
   if (!await fileExists(absPath))
     return null;
-  const content = await import_fs6.default.promises.readFile(absPath, "utf-8");
+  const content = await import_fs7.default.promises.readFile(absPath, "utf-8");
   return (0, import_python_analysis5.findAppOrHandler)(content);
 }
 async function getPyprojectEntrypoint(workPath) {
@@ -5151,7 +5177,7 @@ async function findValidEntrypoint(workPath, candidates) {
 async function checkDjangoManage(workPath) {
   const managePath = (0, import_path8.join)(workPath, "manage.py");
   try {
-    const content = await import_fs6.default.promises.readFile(managePath, "utf-8");
+    const content = await import_fs7.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}`);
@@ -5162,7 +5188,7 @@ async function checkDjangoManage(workPath) {
 }
 async function getSubdirectories(workPath) {
   try {
-    const entries = await import_fs6.default.promises.readdir(workPath, {
+    const entries = await import_fs7.default.promises.readdir(workPath, {
       withFileTypes: true
     });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
@@ -5212,8 +5238,9 @@ async function detectDjangoPythonEntrypoint(workPath) {
 }
 async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint, service) {
   if (configuredEntrypoint) {
-    const entrypoint = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
-    let varName = await checkEntrypoint(workPath, entrypoint);
+    const { filePath: configEntryFile, varName: configEntryVar } = configuredEntrypoint;
+    const entrypoint = configEntryFile.endsWith(".py") ? configEntryFile : `${configEntryFile}.py`;
+    let varName = configEntryVar ?? await checkEntrypoint(workPath, entrypoint);
     if (!varName) {
       const isSpecialService = service?.type === "cron" || service?.type === "worker";
       if (isSpecialService) {
@@ -5336,10 +5363,10 @@ async function syncDependencies({
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
     const syncDir = (0, import_path9.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs7.mkdirSync)(syncDir, { recursive: true });
+    (0, import_fs8.mkdirSync)(syncDir, { recursive: true });
     const tempPyproject = (0, import_path9.join)(syncDir, "pyproject.toml");
     const content = (0, import_python_analysis6.stringifyManifest)(manifest.data);
-    (0, import_fs7.writeFileSync)(tempPyproject, content, "utf8");
+    (0, import_fs8.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
     (0, import_build_utils10.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
@@ -5492,7 +5519,7 @@ async function doInstallVercelRuntime({
   onStdout,
   onStderr
 }) {
-  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  (0, import_fs8.mkdirSync)(targetDir, { recursive: true });
   const localRuntimeDir = (0, import_path9.join)(
     __dirname,
     "..",
@@ -5501,14 +5528,14 @@ async function doInstallVercelRuntime({
     "python",
     "vercel-runtime"
   );
-  const isLocalDev = (0, import_fs7.existsSync)((0, import_path9.join)(localRuntimeDir, "pyproject.toml"));
+  const isLocalDev = (0, import_fs8.existsSync)((0, import_path9.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)(
       targetDir,
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
-    if ((0, import_fs7.existsSync)(distInfo)) {
+    if ((0, import_fs8.existsSync)(distInfo)) {
       (0, import_build_utils10.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
@@ -5588,7 +5615,7 @@ async function doInstallVercelWorkers({
   onStdout,
   onStderr
 }) {
-  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  (0, import_fs8.mkdirSync)(targetDir, { recursive: true });
   const localWorkersDir = (0, import_path9.join)(
     __dirname,
     "..",
@@ -5597,14 +5624,14 @@ async function doInstallVercelWorkers({
     "python",
     "vercel-workers"
   );
-  const isLocalDev = (0, import_fs7.existsSync)((0, import_path9.join)(localWorkersDir, "pyproject.toml"));
+  const isLocalDev = (0, import_fs8.existsSync)((0, import_path9.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)(
       targetDir,
       `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
     );
-    if ((0, import_fs7.existsSync)(distInfo)) {
+    if ((0, import_fs8.existsSync)(distInfo)) {
       (0, import_build_utils10.debug)(
         `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
       );
@@ -5694,10 +5721,10 @@ 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_fs7.mkdirSync)(vercelPythonDir, { recursive: true });
+    (0, import_fs8.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs7.existsSync)((0, import_path9.join)(workPath, "__init__.py"))) {
+    if ((0, import_fs8.existsSync)((0, import_path9.join)(workPath, "__init__.py"))) {
       const pkgName = (0, import_path9.basename)(workPath);
       qualifiedModule = `${pkgName}.${modulePath}`;
       extraPythonPath = (0, import_path9.dirname)(workPath);
@@ -5710,9 +5737,9 @@ function createDevShim(workPath, entry, modulePath, serviceName, framework, vari
       "templates",
       `${DEV_SHIM_MODULE}.py`
     );
-    const template = (0, import_fs7.readFileSync)(templatePath, "utf8");
+    const template = (0, import_fs8.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_fs7.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_fs8.writeFileSync)(shimPath, shimSource, "utf8");
     (0, import_build_utils10.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
@@ -5787,10 +5814,16 @@ var startDevServer = async (opts) => {
   const env = { ...process.env, ...meta.env || {} };
   const entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
   let resolved;
+  const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   const detected = await detectPythonEntrypoint(
     framework,
     workPath,
-    entrypoint,
+    entrypoint ? {
+      filePath: entrypoint,
+      // For cron services, the WSGI variable is always 'app' (created dynamically).
+      // For other services, handlerFunction is used as the entrypoint variable name.
+      varName: service?.type === "cron" ? void 0 : handlerFunction
+    } : void 0,
     service
   );
   if (detected?.entrypoint) {
@@ -6019,7 +6052,7 @@ var matplotlibQuirk = {
 };
 
 // src/quirks/litellm.ts
-var import_fs8 = __toESM(require("fs"));
+var import_fs9 = __toESM(require("fs"));
 var import_path10 = require("path");
 var import_build_utils11 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
@@ -6033,7 +6066,7 @@ async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
     const candidate = (0, import_path10.join)(workPath, name);
     try {
-      await import_fs8.default.promises.access(candidate);
+      await import_fs9.default.promises.access(candidate);
       return name;
     } catch {
     }
@@ -6055,7 +6088,7 @@ var litellmQuirk = {
         "schema.prisma"
       );
       try {
-        await import_fs8.default.promises.access(schemaPath);
+        await import_fs9.default.promises.access(schemaPath);
         (0, import_build_utils11.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
@@ -6082,7 +6115,7 @@ var litellmQuirk = {
 };
 
 // src/quirks/prisma.ts
-var import_fs9 = __toESM(require("fs"));
+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");
@@ -6125,7 +6158,7 @@ async function findUserSchema(workPath) {
   if (envPath) {
     const resolved = (0, import_path11.isAbsolute)(envPath) ? envPath : (0, import_path11.join)(workPath, envPath);
     try {
-      await import_fs9.default.promises.access(resolved);
+      await import_fs10.default.promises.access(resolved);
       return resolved;
     } catch {
       (0, import_build_utils12.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
@@ -6138,7 +6171,7 @@ async function findUserSchema(workPath) {
   ];
   for (const candidate of candidates) {
     try {
-      await import_fs9.default.promises.access(candidate);
+      await import_fs10.default.promises.access(candidate);
       return candidate;
     } catch {
     }
@@ -6149,7 +6182,7 @@ async function collectFiles(dir, base) {
   const result = [];
   let entries;
   try {
-    entries = await import_fs9.default.promises.readdir(dir, { withFileTypes: true });
+    entries = await import_fs10.default.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return result;
   }
@@ -6174,7 +6207,7 @@ async function cleanCacheArtifacts(cacheDir, extras = []) {
   ];
   for (const p of paths) {
     try {
-      await import_fs9.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs10.default.promises.rm(p, { recursive: true, force: true });
     } catch (err) {
       console.warn(
         `could not clean up ${p}: ${err instanceof Error ? err.message : String(err)}`
@@ -6208,7 +6241,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs9.default.promises.access((0, import_path11.join)(dir, "prisma"));
+        await import_fs10.default.promises.access((0, import_path11.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -6221,14 +6254,14 @@ var prismaQuirk = {
       return {};
     }
     const cacheDir = (0, import_path11.join)(sitePackages, "prisma", "__bincache__");
-    await import_fs9.default.promises.mkdir(cacheDir, { recursive: true });
+    await import_fs10.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_fs9.default.promises.writeFile(
+    await import_fs10.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
@@ -6259,18 +6292,18 @@ var prismaQuirk = {
     const nodeModulesDir = (0, import_path11.join)(cacheDir, "node_modules", "prisma");
     let engineCopied = false;
     try {
-      const entries = await import_fs9.default.promises.readdir(nodeModulesDir);
+      const entries = await import_fs10.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);
         try {
-          await import_fs9.default.promises.access(destPath);
+          await import_fs10.default.promises.access(destPath);
           (0, import_build_utils12.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
           (0, import_build_utils12.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
-          await import_fs9.default.promises.copyFile(srcPath, destPath);
+          await import_fs10.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
@@ -6288,15 +6321,15 @@ var prismaQuirk = {
       });
     }
     const shimPath = (0, import_path11.join)(cacheDir, "openssl");
-    await import_fs9.default.promises.writeFile(
+    await import_fs10.default.promises.writeFile(
       shimPath,
       `#!/bin/sh
 echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIME_OPENSSL_VERSION}.0)"
 `
     );
-    await import_fs9.default.promises.chmod(shimPath, 493);
+    await import_fs10.default.promises.chmod(shimPath, 493);
     for (const p of [generatedDir, dummySchemaPath]) {
-      await import_fs9.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs10.default.promises.rm(p, { recursive: true, force: true });
     }
     await cleanCacheArtifacts(cacheDir);
     const generateMode = (process.env.VERCEL_PRISMA_GENERATE_CLIENT ?? "auto").toLowerCase();
@@ -6469,12 +6502,12 @@ async function runQuirks(ctx) {
 }
 
 // src/django.ts
-var import_fs10 = __toESM(require("fs"));
+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_fs10.default.readFileSync(scriptPath, "utf-8");
+var script = import_fs11.default.readFileSync(scriptPath, "utf-8");
 async function getDjangoSettings(projectDir, env) {
   const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
     env,
@@ -6505,7 +6538,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     ...installedApps.map((app) => (0, import_path12.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_fs10.default.existsSync(d));
+  ].filter((d) => import_fs11.default.existsSync(d));
   if (storageBackend.startsWith("storages.backends.")) {
     console.log(
       "django-storages detected \u2014 running collectstatic with original settings"
@@ -6529,7 +6562,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   }
   const staticUrlPath = staticUrl.replace(/^\/|\/$/g, "") || "static";
   const staticOutputDir = (0, import_path12.join)(outputStaticDir, staticUrlPath);
-  await import_fs10.default.promises.mkdir(staticOutputDir, { recursive: true });
+  await import_fs11.default.promises.mkdir(staticOutputDir, { recursive: true });
   const shimPath = (0, import_path12.join)(workPath, "_vercel_collectstatic_settings.py");
   const shimLines = [
     `from ${settingsModule} import *`,
@@ -6538,7 +6571,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   if (whitenoiseUseFinders) {
     shimLines.push(`WHITENOISE_USE_FINDERS = False`);
   }
-  await import_fs10.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
+  await import_fs11.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
   try {
     console.log("Running collectstatic...");
     await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
@@ -6549,7 +6582,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
       cwd: workPath
     });
   } finally {
-    await import_fs10.default.promises.unlink(shimPath).catch(() => {
+    await import_fs11.default.promises.unlink(shimPath).catch(() => {
     });
   }
   const MANIFEST_STORAGE_BACKENDS = [
@@ -6561,8 +6594,8 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     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_fs10.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
-    await import_fs10.default.promises.copyFile(manifestSrc, manifestDest);
+    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`);
   }
@@ -6576,7 +6609,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
 
 // src/index.ts
 var import_python_analysis9 = require("@vercel/python-analysis");
-var writeFile = import_fs11.default.promises.writeFile;
+var writeFile = import_fs12.default.promises.writeFile;
 var version = -1;
 async function runFrameworkHook(framework, ctx) {
   const hook = framework ? frameworkHooks[framework] : void 0;
@@ -6707,10 +6740,16 @@ var build = async ({
     throw err;
   }
   let detected;
+  const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   detected = await detectPythonEntrypoint(
     config.framework,
     workPath,
-    entrypoint,
+    entrypoint ? {
+      filePath: entrypoint,
+      // For cron services, the WSGI variable is always 'app' (created dynamically).
+      // For other services, handlerFunction is used as the entrypoint variable name.
+      varName: service?.type === "cron" ? void 0 : handlerFunction
+    } : void 0,
     service
   ) ?? void 0;
   if (detected?.error && detected?.baseDir === void 0) {
@@ -6749,8 +6788,8 @@ 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_fs11.default.existsSync((0, import_path13.join)(venvPath, "pyvenv.cfg"));
-  const hasCachedUv = import_fs11.default.existsSync(uvCacheDir);
+  const hasCachedVenv = import_fs12.default.existsSync((0, import_path13.join)(venvPath, "pyvenv.cfg"));
+  const hasCachedUv = import_fs12.default.existsSync(uvCacheDir);
   if (hasCachedVenv || hasCachedUv) {
     (0, import_build_utils15.debug)(
       `Build cache detected: venv=${hasCachedVenv}, uv-cache=${hasCachedUv}`
@@ -6813,7 +6852,7 @@ var build = async ({
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
-      await import_fs11.default.promises.rm(venvPath, { recursive: true, force: true });
+      await import_fs12.default.promises.rm(venvPath, { recursive: true, force: true });
       await ensureVenv({
         pythonVersion,
         venvPath,
@@ -6864,9 +6903,9 @@ var build = async ({
         frozen: lockFileProvidedByUser,
         locked: !lockFileProvidedByUser
       });
-      if (lockPath && import_fs11.default.existsSync(lockPath)) {
-        await import_fs11.default.promises.mkdir(uvCacheDir, { recursive: true });
-        await import_fs11.default.promises.copyFile(lockPath, cachedLockPath);
+      if (lockPath && import_fs12.default.existsSync(lockPath)) {
+        await import_fs12.default.promises.mkdir(uvCacheDir, { recursive: true });
+        await import_fs12.default.promises.copyFile(lockPath, cachedLockPath);
       }
     }
   });
@@ -6933,10 +6972,9 @@ var build = async ({
   }
   (0, import_build_utils15.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
-  const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   if (handlerFunction) {
     const entrypointPath = (0, import_path13.join)(workPath, entrypoint);
-    const source = await import_fs11.default.promises.readFile(entrypointPath, "utf-8");
+    const source = await import_fs12.default.promises.readFile(entrypointPath, "utf-8");
     const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
       throw new import_build_utils15.NowBuildError({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.30.0",
+  "version": "6.31.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -36,9 +36,9 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/error-utils": "2.0.3",
+    "@vercel/build-utils": "13.15.0",
     "@vercel/python-runtime": "0.12.0",
-    "@vercel/build-utils": "13.14.2"
+    "@vercel/error-utils": "2.0.3"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",