@vercel/python 6.39.0 → 6.41.0

package/dist/index.js

@@ -4341,6 +4341,11 @@ var PythonDependencyExternalizer = class {
     this.allVendorFiles = {};
     this.totalBundleSize = 0;
     this.analyzed = false;
+    // Resolved once at the start of analyze().  The venv is immutable
+    // after construction (quirks run before the bundle span) so these
+    // do not change between analyze() and generateBundle().
+    this.sitePackageDirs = null;
+    this.distributions = null;
     this.venvPath = options.venvPath;
     this.vendorDir = options.vendorDir;
     this.workPath = options.workPath;
@@ -4371,8 +4376,17 @@ var PythonDependencyExternalizer = class {
    * Must be called before generateBundle().
    */
   async analyze(files) {
-    this.allVendorFiles = await mirrorPackagesIntoVendor({
-      venvPath: this.venvPath,
+    this.sitePackageDirs = await getVenvSitePackagesDirs(this.venvPath);
+    this.distributions = /* @__PURE__ */ new Map();
+    for (const dir of this.sitePackageDirs) {
+      try {
+        await import_fs5.default.promises.access(dir);
+      } catch {
+        continue;
+      }
+      this.distributions.set(dir, await (0, import_python_analysis3.scanDistributions)(dir));
+    }
+    this.allVendorFiles = await this.mirrorPackagesIntoVendor({
       vendorDirName: this.vendorDir
     });
     const tempFilesForSizing = { ...files };
@@ -4542,7 +4556,7 @@ To fix this, either:
      wheels available.`
       });
     }
-    const packageSizes = await calculatePerPackageSizes(this.venvPath);
+    const packageSizes = await this.calculatePerPackageSizes();
     const alwaysBundled = [
       ...classification.privatePackages,
       "vercel-runtime",
@@ -4550,8 +4564,7 @@ To fix this, either:
       ...this.alwaysBundlePackages,
       ...forceBundledDueToWheels
     ];
-    const alwaysBundledFiles = await mirrorPackagesIntoVendor({
-      venvPath: this.venvPath,
+    const alwaysBundledFiles = await this.mirrorPackagesIntoVendor({
       vendorDirName: this.vendorDir,
       includePackages: alwaysBundled
     });
@@ -4597,8 +4610,7 @@ To fix this, either:
     );
     const bundledPublic = lambdaKnapsack(publicPackageSizes, remainingCapacity);
     const allBundledPackages = [...alwaysBundled, ...bundledPublic];
-    const selectedVendorFiles = await mirrorPackagesIntoVendor({
-      venvPath: this.venvPath,
+    const selectedVendorFiles = await this.mirrorPackagesIntoVendor({
       vendorDirName: this.vendorDir,
       includePackages: allBundledPackages
     });
@@ -4747,6 +4759,130 @@ splitting your application.`,
     }
     return incompatible;
   }
+  /**
+   * Mirror packages from site-packages into the _vendor directory.
+   *
+   * When `includePackages` is provided, only distributions whose normalized
+   * name is in the list are included.  When omitted, every distribution is
+   * included.
+   *
+   * Reads `this.sitePackageDirs` and `this.distributions` which are
+   * resolved once at the start of `analyze()`.
+   */
+  async mirrorPackagesIntoVendor({
+    vendorDirName,
+    includePackages
+  }) {
+    const vendorFiles = {};
+    if (includePackages && includePackages.length === 0) {
+      return vendorFiles;
+    }
+    const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis3.normalizePackageName)) : null;
+    const pending = [];
+    for (const dir of this.sitePackageDirs) {
+      const dirDistributions = this.distributions.get(dir);
+      if (!dirDistributions)
+        continue;
+      const resolvedDir = (0, import_path6.resolve)(dir);
+      const dirPrefix = resolvedDir + import_path6.sep;
+      for (const [name, dist] of dirDistributions) {
+        if (includeSet && !includeSet.has(name))
+          continue;
+        for (const { path: rawPath, size: recordSize } of dist.files) {
+          const filePath = rawPath.replaceAll("/", import_path6.sep);
+          if (!(0, import_path6.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+            continue;
+          }
+          if (filePath.endsWith(".pyc") || filePath.split(import_path6.sep).includes("__pycache__")) {
+            continue;
+          }
+          const srcFsPath = (0, import_path6.join)(dir, filePath);
+          const bundlePath = (0, import_path6.join)(vendorDirName, filePath).replace(/\\/g, "/");
+          pending.push({
+            bundlePath,
+            srcFsPath,
+            // RECORD sizes are bigint; convert to number for FileFsRef.
+            recordSize: recordSize !== void 0 && recordSize !== null ? Number(recordSize) : void 0
+          });
+        }
+      }
+    }
+    const results = await Promise.all(
+      pending.map(async ({ bundlePath, srcFsPath, recordSize }) => {
+        if (recordSize !== void 0) {
+          try {
+            await import_fs5.default.promises.access(srcFsPath);
+            return { bundlePath, srcFsPath, size: recordSize };
+          } catch {
+            return null;
+          }
+        } else {
+          try {
+            const stats = await import_fs5.default.promises.stat(srcFsPath);
+            return { bundlePath, srcFsPath, size: stats.size };
+          } catch {
+            return null;
+          }
+        }
+      })
+    );
+    for (const result of results) {
+      if (result) {
+        vendorFiles[result.bundlePath] = new import_build_utils5.FileFsRef({
+          fsPath: result.srcFsPath,
+          size: result.size
+        });
+      }
+    }
+    (0, import_build_utils5.debug)(
+      `Mirrored ${Object.keys(vendorFiles).length} files` + (includePackages ? ` from ${includePackages.length} packages` : "")
+    );
+    return vendorFiles;
+  }
+  /**
+   * Calculate the uncompressed size of each installed distribution.
+   *
+   * Returns a map of normalized package name to total size in bytes.
+   * Uses RECORD sizes when available, falling back to stat for files
+   * without a recorded size.  All stat calls run in parallel.
+   */
+  async calculatePerPackageSizes() {
+    const sizes = /* @__PURE__ */ new Map();
+    for (const dir of this.sitePackageDirs) {
+      const dirDistributions = this.distributions.get(dir);
+      if (!dirDistributions)
+        continue;
+      const resolvedDir = (0, import_path6.resolve)(dir);
+      const dirPrefix = resolvedDir + import_path6.sep;
+      for (const [name, dist] of dirDistributions) {
+        let knownSize = 0;
+        const statPromises = [];
+        for (const { path: rawPath, size: recordSize } of dist.files) {
+          const filePath = rawPath.replaceAll("/", import_path6.sep);
+          if (!(0, import_path6.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+            continue;
+          }
+          if (filePath.endsWith(".pyc") || filePath.split(import_path6.sep).includes("__pycache__")) {
+            continue;
+          }
+          if (recordSize !== void 0 && recordSize !== null) {
+            knownSize += Number(recordSize);
+          } else {
+            statPromises.push(
+              import_fs5.default.promises.stat((0, import_path6.join)(dir, filePath)).then((stats) => stats.size).catch(() => 0)
+            );
+          }
+        }
+        const statSizes = await Promise.all(statPromises);
+        let totalSize = knownSize;
+        for (const s of statSizes) {
+          totalSize += s;
+        }
+        sizes.set(name, totalSize);
+      }
+    }
+    return sizes;
+  }
 };
 async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor, pythonMinor, sysPlatform, platformMachine) {
   if (!projectName)
@@ -4806,66 +4942,35 @@ async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor
   }
   return visited;
 }
-async function mirrorPackagesIntoVendor({
-  venvPath,
-  vendorDirName,
-  includePackages
-}) {
-  const vendorFiles = {};
-  if (includePackages && includePackages.length === 0) {
-    return vendorFiles;
-  }
-  const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis3.normalizePackageName)) : null;
-  const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
-  for (const dir of sitePackageDirs) {
-    if (!import_fs5.default.existsSync(dir))
-      continue;
-    const resolvedDir = (0, import_path6.resolve)(dir);
-    const dirPrefix = resolvedDir + import_path6.sep;
-    const distributions = await (0, import_python_analysis3.scanDistributions)(dir);
-    for (const [name, dist] of distributions) {
-      if (includeSet && !includeSet.has(name))
-        continue;
-      for (const { path: rawPath } of dist.files) {
-        const filePath = rawPath.replaceAll("/", import_path6.sep);
-        if (!(0, import_path6.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
-          continue;
-        }
-        if (filePath.endsWith(".pyc") || filePath.split(import_path6.sep).includes("__pycache__")) {
-          continue;
-        }
-        const srcFsPath = (0, import_path6.join)(dir, filePath);
-        if (!import_fs5.default.existsSync(srcFsPath)) {
-          continue;
-        }
-        const bundlePath = (0, import_path6.join)(vendorDirName, filePath).replace(/\\/g, "/");
-        vendorFiles[bundlePath] = new import_build_utils5.FileFsRef({ fsPath: srcFsPath });
-      }
-    }
-  }
-  (0, import_build_utils5.debug)(
-    `Mirrored ${Object.keys(vendorFiles).length} files` + (includePackages ? ` from ${includePackages.length} packages` : "")
-  );
-  return vendorFiles;
-}
 async function calculateBundleSize(files) {
-  let totalSize = 0;
+  let knownSize = 0;
+  const statPromises = [];
   for (const filePath of Object.keys(files)) {
     const file = files[filePath];
     if ("fsPath" in file && file.fsPath) {
-      try {
-        const stats = await import_fs5.default.promises.stat(file.fsPath);
-        totalSize += stats.size;
-      } catch (err) {
-        console.warn(
-          `Warning: Failed to stat file ${file.fsPath}, size will not be included in bundle calculation: ${err}`
+      const fsRef = file;
+      if (typeof fsRef.size === "number") {
+        knownSize += fsRef.size;
+      } else {
+        statPromises.push(
+          import_fs5.default.promises.stat(fsRef.fsPath).then((stats) => stats.size).catch((err) => {
+            console.warn(
+              `Warning: Failed to stat file ${fsRef.fsPath}, size will not be included in bundle calculation: ${err}`
+            );
+            return 0;
+          })
         );
       }
     } else if ("data" in file) {
       const data = file.data;
-      totalSize += typeof data === "string" ? Buffer.byteLength(data) : data.length;
+      knownSize += typeof data === "string" ? Buffer.byteLength(data) : data.length;
     }
   }
+  const statSizes = await Promise.all(statPromises);
+  let totalSize = knownSize;
+  for (const s of statSizes) {
+    totalSize += s;
+  }
   return totalSize;
 }
 function lambdaKnapsack(packages, capacity) {
@@ -4883,36 +4988,6 @@ function lambdaKnapsack(packages, capacity) {
   }
   return bundled;
 }
-async function calculatePerPackageSizes(venvPath) {
-  const sizes = /* @__PURE__ */ new Map();
-  const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
-  for (const dir of sitePackageDirs) {
-    if (!import_fs5.default.existsSync(dir))
-      continue;
-    const resolvedDir = (0, import_path6.resolve)(dir);
-    const dirPrefix = resolvedDir + import_path6.sep;
-    const distributions = await (0, import_python_analysis3.scanDistributions)(dir);
-    for (const [name, dist] of distributions) {
-      let totalSize = 0;
-      for (const { path: rawPath } of dist.files) {
-        const filePath = rawPath.replaceAll("/", import_path6.sep);
-        if (!(0, import_path6.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
-          continue;
-        }
-        if (filePath.endsWith(".pyc") || filePath.split(import_path6.sep).includes("__pycache__")) {
-          continue;
-        }
-        try {
-          const stats = await import_fs5.default.promises.stat((0, import_path6.join)(dir, filePath));
-          totalSize += stats.size;
-        } catch {
-        }
-      }
-      sizes.set(name, totalSize);
-    }
-  }
-  return sizes;
-}
 
 // src/diagnostics.ts
 var import_fs6 = __toESM(require("fs"));
@@ -5140,161 +5215,17 @@ async function generateProjectManifest({
 var diagnostics = (0, import_build_utils6.createDiagnostics)("python");
 
 // src/crons.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path7 = require("path");
+var import_fs8 = __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_path7.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;
-  const isScheduledService = !!service && (0, import_build_utils7.isScheduleTriggeredService)(service);
-  if (!isScheduledService || !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_fs9 = require("fs");
-var import_path9 = 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());
+var import_build_utils10 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
-var import_fs8 = __toESM(require("fs"));
-var import_path8 = require("path");
+var import_fs7 = __toESM(require("fs"));
+var import_path7 = require("path");
+var import_build_utils7 = require("@vercel/build-utils");
 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",
@@ -5309,16 +5240,17 @@ var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
   PYTHON_ENTRYPOINT_DIRS
 );
 var PYTHON_ENTRYPOINT_DOCS_URL = "https://vercel.com/docs/functions/runtimes/python#python-entrypoints";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["__pycache__", "node_modules"]);
 function getCandidateEntrypointsInDirs(dirs) {
   return dirs.flatMap(
     (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
-      (filename) => import_path8.posix.join(dir, `${filename}.py`)
+      (filename) => import_path7.posix.join(dir, `${filename}.py`)
     )
   );
 }
 async function fileExists(filePath) {
   try {
-    const stat = await import_fs8.default.promises.stat(filePath);
+    const stat = await import_fs7.default.promises.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
@@ -5369,34 +5301,67 @@ function getMissingExportMessage(framework, entrypoints) {
       return entrypoints.length === 1 ? `Found ${fileList} but it does not export a top-level "app", "application", or "handler" variable.` : `Found ${fileList} but none export a top-level "app", "application", or "handler" variable.`;
   }
 }
+function entrypointToModule(entrypoint) {
+  return entrypoint.replace(/\\/g, "/").replace(/\.py$/i, "").replace(/\//g, ".");
+}
 async function checkEntrypoint(workPath, relPath) {
-  const absPath = (0, import_path8.join)(workPath, relPath);
+  const absPath = (0, import_path7.join)(workPath, relPath);
   if (!await fileExists(absPath))
     return null;
-  const content = await import_fs8.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 findOtherPyFiles(workPath, dirs, candidateSet) {
+async function findPythonFilesRecursive(dir, rootDir) {
   const results = [];
-  for (const dir of dirs) {
-    const dirPath = (0, import_path8.join)(workPath, dir);
+  let entries;
+  try {
+    entries = await import_fs7.default.promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || SKIP_DIRS.has(entry.name))
+      continue;
+    const fullPath = (0, import_path7.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await findPythonFilesRecursive(fullPath, rootDir));
+    } else if (entry.isFile() && entry.name.endsWith(".py")) {
+      results.push((0, import_path7.relative)(rootDir, fullPath).replace(/\\/g, "/"));
+    }
+  }
+  return results;
+}
+async function findEntrypointCandidates(workPath) {
+  const pyFiles = await findPythonFilesRecursive(workPath, workPath);
+  const candidates = [];
+  for (const relPath of pyFiles) {
     try {
-      const entries = await import_fs8.default.promises.readdir(dirPath);
-      for (const entry of entries) {
-        if (!entry.endsWith(".py"))
-          continue;
-        const relPath = dir ? import_path8.posix.join(dir, entry) : entry;
-        if (candidateSet.has(relPath))
-          continue;
-        const stat = await import_fs8.default.promises.stat((0, import_path8.join)(dirPath, entry));
-        if (stat.isFile()) {
-          results.push(relPath);
-        }
+      const content = await import_fs7.default.promises.readFile(
+        (0, import_path7.join)(workPath, relPath),
+        "utf-8"
+      );
+      const varName = await (0, import_python_analysis5.findAppOrHandler)(content);
+      if (varName) {
+        candidates.push({ entrypoint: relPath, variableName: varName });
       }
     } catch {
     }
   }
-  return results;
+  return candidates;
+}
+function renderCandidateSuggestion(candidates) {
+  const lines = candidates.map(
+    (c) => `  ${c.entrypoint} (variable: ${c.variableName})`
+  );
+  const suggested = candidates[0];
+  const moduleAttr = `${entrypointToModule(suggested.entrypoint)}:${suggested.variableName}`;
+  return `but found potential entrypoints:
+${lines.join("\n")}
+
+Add this to your pyproject.toml:
+
+[tool.vercel]
+entrypoint = "${moduleAttr}"`;
 }
 async function resolveModuleAttrEntrypoint(workPath, value) {
   const match = value.match(/([A-Za-z_][\w.]*)\s*:\s*([A-Za-z_][\w]*)/);
@@ -5407,14 +5372,14 @@ async function resolveModuleAttrEntrypoint(workPath, value) {
   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_path7.join)(workPath, candidate))) {
       return { entrypoint: candidate, variableName };
     }
   }
   return null;
 }
 async function getVercelToolsEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils10.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const vercelEntrypoint = pyprojectData.tool?.vercel?.entrypoint;
@@ -5423,7 +5388,7 @@ async function getVercelToolsEntrypoint(workPath) {
   return resolveModuleAttrEntrypoint(workPath, vercelEntrypoint);
 }
 async function getPyprojectEntrypointWithDiagnostics(workPath) {
-  const pyprojectData = await (0, import_build_utils10.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return { entrypoint: null };
   const scripts = pyprojectData.project?.scripts;
@@ -5438,7 +5403,7 @@ async function getPyprojectEntrypointWithDiagnostics(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_path7.join)(workPath, candidate))) {
       return { entrypoint: { entrypoint: candidate, variableName } };
     }
   }
@@ -5447,13 +5412,13 @@ async function getPyprojectEntrypointWithDiagnostics(workPath) {
 async function findValidEntrypoint(workPath, candidates) {
   const existingWithoutEntrypoint = [];
   for (const candidate of candidates) {
-    const absPath = (0, import_path8.join)(workPath, candidate);
+    const absPath = (0, import_path7.join)(workPath, candidate);
     if (!await fileExists(absPath))
       continue;
-    const content = await import_fs8.default.promises.readFile(absPath, "utf-8");
+    const content = await import_fs7.default.promises.readFile(absPath, "utf-8");
     const varName = await (0, import_python_analysis5.findAppOrHandler)(content);
     if (varName) {
-      (0, import_build_utils9.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
+      (0, import_build_utils8.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
       return {
         entrypoint: { entrypoint: candidate, variableName: varName },
         existingWithoutEntrypoint
@@ -5464,12 +5429,12 @@ async function findValidEntrypoint(workPath, candidates) {
   return { entrypoint: null, existingWithoutEntrypoint };
 }
 async function checkDjangoManage(workPath) {
-  const managePath = (0, import_path8.join)(workPath, "manage.py");
+  const managePath = (0, import_path7.join)(workPath, "manage.py");
   try {
-    const content = await import_fs8.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_utils9.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    (0, import_build_utils8.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
     return true;
   } catch {
     return false;
@@ -5477,7 +5442,7 @@ async function checkDjangoManage(workPath) {
 }
 async function getSubdirectories(workPath) {
   try {
-    const entries = await import_fs8.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();
@@ -5490,23 +5455,39 @@ function makeDiagnosticError(framework, diagnostics2) {
   const link = getFrameworkEntrypointDocsUrl(framework);
   const action = "Learn More";
   const displayName = getFrameworkDisplayName(framework);
+  const elsewhere = diagnostics2.validCandidatesElsewhere ?? [];
+  const suggestion = elsewhere.length > 0 ? renderCandidateSuggestion(elsewhere) : null;
   let message;
   if (diagnostics2.existingWithoutEntrypoint.length > 0) {
     message = getMissingExportMessage(
       framework,
       diagnostics2.existingWithoutEntrypoint
     );
+    if (suggestion)
+      message += `
+
+${suggestion}`;
+  } else if (diagnostics2.djangoManageBaseDir !== void 0) {
+    const where = diagnostics2.djangoManageBaseDir || ".";
+    message = `Found Django manage.py in "${where}" but could not resolve the application entrypoint. Ensure WSGI_APPLICATION or ASGI_APPLICATION is set in your Django settings.`;
+    if (suggestion)
+      message += `
+
+${suggestion}`;
   } else if (diagnostics2.pyprojectAppScript && diagnostics2.pyprojectCheckedPaths?.length) {
     const checked = diagnostics2.pyprojectCheckedPaths.join(" or ");
     message = `pyproject.toml [project.scripts] defines app = "${diagnostics2.pyprojectAppScript}" but ${checked} was not found.`;
-  } else if (diagnostics2.otherPyFiles.length > 0) {
-    const fileList = diagnostics2.otherPyFiles.slice(0, 5).join(", ");
-    message = `No ${displayName} entrypoint found in standard locations. Found Python files: ${fileList}. Rename one to app.py or set "tool.vercel.entrypoint" in pyproject.toml.`;
+    if (suggestion)
+      message += `
+
+${suggestion}`;
+  } else if (suggestion) {
+    message = `No ${displayName} entrypoint found in default locations, ${suggestion}`;
   } else {
     const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
     message = `No ${displayName} entrypoint found. Set "tool.vercel.entrypoint" in pyproject.toml or define an entrypoint in one of: ${searchedList}.`;
   }
-  return new import_build_utils8.NowBuildError({ code, message, link, action });
+  return new import_build_utils7.NowBuildError({ code, message, link, action });
 }
 async function detectGenericPythonEntrypoint(workPath) {
   try {
@@ -5519,7 +5500,7 @@ async function detectGenericPythonEntrypoint(workPath) {
       findDiagnostics: result
     };
   } catch {
-    (0, import_build_utils9.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Python entrypoint");
     return {
       detected: null,
       findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] }
@@ -5532,20 +5513,18 @@ async function detectDjangoPythonEntrypoint(workPath) {
     findDiagnostics: {
       entrypoint: null,
       existingWithoutEntrypoint: []
-    },
-    dirs: PYTHON_ENTRYPOINT_DIRS
+    }
   };
   try {
     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_path7.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
         return {
           detected: { baseDir: rootDir },
-          findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] },
-          dirs: rootDirs
+          findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] }
         };
       }
     }
@@ -5553,11 +5532,10 @@ async function detectDjangoPythonEntrypoint(workPath) {
     const result = await findValidEntrypoint(workPath, candidates);
     return {
       detected: result.entrypoint ? { entrypoint: result.entrypoint } : null,
-      findDiagnostics: result,
-      dirs: rootDirs
+      findDiagnostics: result
     };
   } catch {
-    (0, import_build_utils9.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Django Python entrypoint");
     return emptyResult;
   }
 }
@@ -5565,10 +5543,10 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
   if (configuredEntrypoint) {
     const { filePath: configEntryFile, varName: configEntryVar } = configuredEntrypoint;
     const entrypoint = configEntryFile.endsWith(".py") ? configEntryFile : `${configEntryFile}.py`;
-    const entrypointExists = await fileExists((0, import_path8.join)(workPath, entrypoint));
+    const entrypointExists = await fileExists((0, import_path7.join)(workPath, entrypoint));
     if (!entrypointExists) {
       return {
-        error: new import_build_utils8.NowBuildError({
+        error: new import_build_utils7.NowBuildError({
           code: "PYTHON_ENTRYPOINT_NOT_FOUND",
           message: `Configured Python entrypoint "${entrypoint}" was not found.`,
           link: PYTHON_ENTRYPOINT_DOCS_URL,
@@ -5578,17 +5556,17 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
     }
     let varName = configEntryVar ?? await checkEntrypoint(workPath, entrypoint);
     if (!varName) {
-      const needsDynamicApp = !!service && ((0, import_build_utils8.isScheduleTriggeredService)(service) || (0, import_build_utils8.isQueueTriggeredService)(service));
+      const needsDynamicApp = !!service && ((0, import_build_utils7.isScheduleTriggeredService)(service) || (0, import_build_utils7.isQueueTriggeredService)(service));
       if (needsDynamicApp) {
         varName = "app";
       }
     }
     if (varName) {
-      (0, import_build_utils9.debug)(`Using configured Python entrypoint: ${entrypoint}`);
+      (0, import_build_utils8.debug)(`Using configured Python entrypoint: ${entrypoint}`);
       return { entrypoint: { entrypoint, variableName: varName } };
     } else {
       return {
-        error: new import_build_utils8.NowBuildError({
+        error: new import_build_utils7.NowBuildError({
           code: "PYTHON_ENTRYPOINT_NOT_FOUND",
           message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
           link: PYTHON_ENTRYPOINT_DOCS_URL,
@@ -5604,36 +5582,18 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
   if (vercelEntry)
     return { entrypoint: vercelEntry };
   let findDiagnostics;
-  let searchDirs;
+  let djangoManageBaseDir;
   if (framework === "django") {
     const djangoResult = await detectDjangoPythonEntrypoint(workPath);
     findDiagnostics = djangoResult.findDiagnostics;
-    searchDirs = djangoResult.dirs;
     if (djangoResult.detected) {
       if (djangoResult.detected.entrypoint)
         return djangoResult.detected;
-      const candidateSet2 = new Set(getCandidateEntrypointsInDirs(searchDirs));
-      const otherPyFiles2 = await findOtherPyFiles(
-        workPath,
-        searchDirs,
-        candidateSet2
-      );
-      const pyprojectResult2 = await getPyprojectEntrypointWithDiagnostics(workPath);
-      const diagnostics3 = {
-        existingWithoutEntrypoint: findDiagnostics.existingWithoutEntrypoint,
-        otherPyFiles: otherPyFiles2,
-        pyprojectAppScript: pyprojectResult2.appScript,
-        pyprojectCheckedPaths: pyprojectResult2.checkedPaths
-      };
-      return {
-        baseDir: djangoResult.detected.baseDir,
-        error: makeDiagnosticError("django", diagnostics3)
-      };
+      djangoManageBaseDir = djangoResult.detected.baseDir;
     }
   } else {
     const genericResult = await detectGenericPythonEntrypoint(workPath);
     findDiagnostics = genericResult.findDiagnostics;
-    searchDirs = PYTHON_ENTRYPOINT_DIRS;
     if (genericResult.detected)
       return genericResult.detected;
   }
@@ -5641,22 +5601,165 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
   if (pyprojectResult.entrypoint) {
     return { entrypoint: pyprojectResult.entrypoint };
   }
-  const candidateSet = new Set(getCandidateEntrypointsInDirs(searchDirs));
-  const otherPyFiles = await findOtherPyFiles(
-    workPath,
-    searchDirs,
-    candidateSet
-  );
+  const validCandidatesElsewhere = await findEntrypointCandidates(workPath);
   const diagnostics2 = {
     existingWithoutEntrypoint: findDiagnostics.existingWithoutEntrypoint,
-    otherPyFiles,
     pyprojectAppScript: pyprojectResult.appScript,
-    pyprojectCheckedPaths: pyprojectResult.checkedPaths
+    pyprojectCheckedPaths: pyprojectResult.checkedPaths,
+    validCandidatesElsewhere,
+    djangoManageBaseDir
   };
-  return { error: makeDiagnosticError(framework, diagnostics2) };
+  const error = makeDiagnosticError(framework, diagnostics2);
+  return djangoManageBaseDir !== void 0 ? { baseDir: djangoManageBaseDir, error } : { error };
+}
+
+// src/crons.ts
+var DYNAMIC_SCHEDULE = "<dynamic>";
+var scriptPath = (0, import_path8.join)(__dirname, "..", "templates", "vc_cron_detect.py");
+var script = import_fs8.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;
+  const isScheduledService = !!service && (0, import_build_utils10.isScheduleTriggeredService)(service);
+  if (!isScheduledService || !service.name || typeof service.schedule !== "string" && !Array.isArray(service.schedule)) {
+    return void 0;
+  }
+  const cronEntrypoint = entrypoint || rawEntrypoint;
+  if (!cronEntrypoint) {
+    throw new import_build_utils10.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_utils10.getInternalServiceCronPath)(
+    service.name,
+    cronEntrypoint,
+    handlerFunction || "cron"
+  );
+  const moduleName = entrypointToModule(cronEntrypoint);
+  const resolvedHandler = handlerFunction ? `${moduleName}:${handlerFunction}` : moduleName;
+  const schedules = Array.isArray(service.schedule) ? service.schedule : [service.schedule];
+  return schedules.map((schedule) => ({
+    path: cronPath,
+    schedule,
+    resolvedHandler
+  }));
+}
+async function getServiceCronsDynamic(opts) {
+  const {
+    serviceName,
+    cronEntrypoint,
+    handlerFunction,
+    pythonBin,
+    env,
+    workPath
+  } = opts;
+  if (!handlerFunction) {
+    throw new import_build_utils10.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_utils10.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_utils10.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_utils10.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_utils10.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_utils10.getInternalServiceCronPath)(serviceName, entrypointPath, funcPart);
 }
 
 // src/start-dev-server.ts
+var import_child_process2 = require("child_process");
+var import_fs9 = require("fs");
+var import_path9 = 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());
 var import_python_analysis6 = require("@vercel/python-analysis");
 var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
 function silenceNodeWarnings() {
@@ -6233,7 +6336,7 @@ var startDevServer = async (opts) => {
     });
   }
   const { entrypoint: entry, variableName } = resolved;
-  const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
+  const modulePath = entrypointToModule(entry);
   let childProcess = null;
   let stdoutLogListener = null;
   let stderrLogListener = null;
@@ -7362,7 +7465,7 @@ var build = async ({
   await uv.pip({
     venvPath,
     projectDir: (0, import_path13.join)(workPath, entryDirectory),
-    args: ["install", runtimeDep]
+    args: ["install", "--link-mode", "copy", runtimeDep]
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
@@ -7370,7 +7473,7 @@ var build = async ({
     await uv.pip({
       venvPath,
       projectDir: (0, import_path13.join)(workPath, entryDirectory),
-      args: ["install", workersDep]
+      args: ["install", "--link-mode", "copy", workersDep]
     });
   }
   const quirksResult = await runQuirks({ venvPath, pythonEnv, workPath });
@@ -7378,7 +7481,7 @@ var build = async ({
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
   (0, import_build_utils16.debug)("Entrypoint is", entrypoint);
-  const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
+  const moduleName = entrypointToModule(entrypoint);
   if (handlerFunction) {
     const entrypointPath = (0, import_path13.join)(workPath, entrypoint);
     const source = await import_fs13.default.promises.readFile(entrypointPath, "utf-8");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.39.0",
+  "version": "6.41.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -34,9 +34,9 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/error-utils": "2.1.0",
+    "@vercel/build-utils": "13.24.0",
     "@vercel/python-runtime": "0.13.2",
-    "@vercel/build-utils": "13.22.0"
+    "@vercel/error-utils": "2.1.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",