@vercel/python 6.26.0 → 6.29.0

package/dist/index.js

@@ -3223,15 +3223,16 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
+var import_child_process3 = require("child_process");
 var import_fs11 = __toESM(require("fs"));
 var import_path13 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.10.1";
+var VERCEL_RUNTIME_VERSION = "0.12.0";
 var VERCEL_WORKERS_VERSION = "0.0.13";
 
 // src/index.ts
-var import_build_utils14 = require("@vercel/build-utils");
+var import_build_utils15 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -3257,7 +3258,7 @@ var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_which = __toESM(require_lib());
 var import_build_utils = require("@vercel/build-utils");
-var UV_VERSION = "0.9.22";
+var UV_VERSION = "0.10.11";
 var UV_PYTHON_PATH_PREFIX = "/uv/python/";
 var UV_PYTHON_DOWNLOADS_MODE = "automatic";
 var isWin = process.platform === "win32";
@@ -3641,7 +3642,27 @@ function detectPlatform() {
     osMinor = 17;
   }
   const libc = libcFamily === detectLibc.MUSL ? "musl" : "gnu";
-  return { osName, archName, osMajor, osMinor, os: "linux", libc };
+  const SYS_PLATFORM_MAP = {
+    linux: "linux",
+    win32: "win32",
+    darwin: "darwin"
+  };
+  const sysPlatform = SYS_PLATFORM_MAP[process.platform] || "linux";
+  const OS_MAP = {
+    linux: "linux",
+    win32: "windows",
+    darwin: "macos"
+  };
+  const detectedOs = OS_MAP[process.platform] || "linux";
+  return {
+    osName,
+    archName,
+    osMajor,
+    osMinor,
+    os: detectedOs,
+    sysPlatform,
+    libc
+  };
 }
 
 // src/version.ts
@@ -4499,10 +4520,31 @@ To fix this, either:
    * Identify public packages that have no compatible wheel for the Lambda platform.
    * These packages must be force-bundled because `uv sync --no-build` at cold start
    * will refuse to build from source.
+   *
+   * Packages that are not reachable on the target platform (e.g. pywin32 which is
+   * only a dependency when `sys_platform == 'win32'`) are excluded -- they will
+   * never be installed by `uv sync` on Lambda, so their wheel compatibility is
+   * irrelevant.
    */
   async findPackagesWithoutCompatibleWheels(lockFile, publicPackageNames) {
     const platform = detectPlatform();
-    const publicSet = new Set(publicPackageNames.map(import_python_analysis3.normalizePackageName));
+    const reachable = await getPackagesReachableOnPlatform(
+      lockFile,
+      this.projectName,
+      this.pythonMajor,
+      this.pythonMinor,
+      platform.sysPlatform,
+      platform.archName
+    );
+    const relevantPackages = reachable ? publicPackageNames.filter(
+      (name) => reachable.has((0, import_python_analysis3.normalizePackageName)(name))
+    ) : publicPackageNames;
+    if (relevantPackages.length < publicPackageNames.length) {
+      (0, import_build_utils5.debug)(
+        `Skipping wheel check for ${publicPackageNames.length - relevantPackages.length} package(s) not reachable on the target platform`
+      );
+    }
+    const publicSet = new Set(relevantPackages.map(import_python_analysis3.normalizePackageName));
     const packageWheels = /* @__PURE__ */ new Map();
     for (const pkg of lockFile.packages) {
       const normalized = (0, import_python_analysis3.normalizePackageName)(pkg.name);
@@ -4511,7 +4553,7 @@ To fix this, either:
       }
     }
     const incompatible = [];
-    for (const name of publicPackageNames) {
+    for (const name of relevantPackages) {
       const normalized = (0, import_python_analysis3.normalizePackageName)(name);
       const wheels = packageWheels.get(normalized);
       if (!wheels || wheels.length === 0) {
@@ -4550,6 +4592,64 @@ To fix this, either:
     return incompatible;
   }
 };
+async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor, pythonMinor, sysPlatform, platformMachine) {
+  if (!projectName)
+    return null;
+  const rootNormalized = (0, import_python_analysis3.normalizePackageName)(projectName);
+  const packageMap = /* @__PURE__ */ new Map();
+  for (const pkg of lockFile.packages) {
+    packageMap.set((0, import_python_analysis3.normalizePackageName)(pkg.name), pkg);
+  }
+  const rootPkg = packageMap.get(rootNormalized);
+  if (!rootPkg)
+    return null;
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [];
+  let queueHead = 0;
+  async function enqueueDeps(pkg) {
+    if (!pkg.dependencies)
+      return;
+    for (const dep of pkg.dependencies) {
+      const normalized = (0, import_python_analysis3.normalizePackageName)(dep.name);
+      if (visited.has(normalized))
+        continue;
+      if (dep.marker) {
+        try {
+          const compatible = await (0, import_python_analysis3.evaluateMarker)(
+            dep.marker,
+            pythonMajor,
+            pythonMinor,
+            sysPlatform,
+            platformMachine
+          );
+          if (!compatible) {
+            (0, import_build_utils5.debug)(
+              `Skipping dependency ${dep.name}: marker "${dep.marker}" not satisfied on ${sysPlatform}`
+            );
+            continue;
+          }
+        } catch (err) {
+          (0, import_build_utils5.debug)(
+            `Failed to evaluate marker "${dep.marker}" for ${dep.name}, including conservatively: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      queue.push(normalized);
+    }
+  }
+  await enqueueDeps(rootPkg);
+  while (queueHead < queue.length) {
+    const current = queue[queueHead++];
+    if (visited.has(current))
+      continue;
+    visited.add(current);
+    const pkg = packageMap.get(current);
+    if (pkg) {
+      await enqueueDeps(pkg);
+    }
+  }
+  return visited;
+}
 async function mirrorPackagesIntoVendor({
   venvPath,
   vendorDirName,
@@ -4904,7 +5004,7 @@ var diagnostics = async ({
 var import_child_process2 = require("child_process");
 var import_fs7 = require("fs");
 var import_path9 = require("path");
-var import_build_utils9 = require("@vercel/build-utils");
+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());
 
@@ -4913,6 +5013,8 @@ var import_fs6 = __toESM(require("fs"));
 var import_path8 = 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_python_analysis5 = require("@vercel/python-analysis");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
   "index",
@@ -4943,11 +5045,12 @@ async function fileExists(filePath) {
 async function checkEntrypoint(workPath, relPath) {
   const absPath = (0, import_path8.join)(workPath, relPath);
   if (!await fileExists(absPath))
-    return false;
-  return (0, import_build_utils7.isPythonEntrypoint)({ fsPath: absPath });
+    return null;
+  const content = await import_fs6.default.promises.readFile(absPath, "utf-8");
+  return (0, import_python_analysis5.findAppOrHandler)(content);
 }
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils8.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -4970,9 +5073,10 @@ async function getPyprojectEntrypoint(workPath) {
 }
 async function findValidEntrypoint(workPath, candidates) {
   for (const candidate of candidates) {
-    if (await checkEntrypoint(workPath, candidate)) {
-      (0, import_build_utils7.debug)(`Detected Python entrypoint: ${candidate}`);
-      return candidate;
+    const varName = await checkEntrypoint(workPath, candidate);
+    if (varName) {
+      (0, import_build_utils8.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
+      return { entrypoint: candidate, variableName: varName };
     }
   }
   return null;
@@ -4983,7 +5087,7 @@ async function checkDjangoManage(workPath) {
     const content = await import_fs6.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
-    (0, import_build_utils7.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;
@@ -4999,62 +5103,82 @@ async function getSubdirectories(workPath) {
     return [];
   }
 }
-async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
-  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+function makeDetectError(framework) {
+  const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
+  return new import_build_utils7.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`,
+    action: "Learn More"
+  });
+}
+async function detectGenericPythonEntrypoint(workPath) {
   try {
-    if (await checkEntrypoint(workPath, entry)) {
-      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
-      return { entrypoint: entry };
-    }
     const found = await findValidEntrypoint(
       workPath,
       PYTHON_CANDIDATE_ENTRYPOINTS
     );
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils7.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Python entrypoint");
     return null;
   }
 }
-async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
-  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+async function detectDjangoPythonEntrypoint(workPath) {
   try {
-    if (await checkEntrypoint(workPath, entry)) {
-      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
-      return { entrypoint: entry };
-    }
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
     for (const rootDir of rootDirs) {
       const currPath = (0, import_path8.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
-        return { baseDir: rootDir };
+        return { baseDir: rootDir, error: makeDetectError("django") };
       }
     }
     const candidates = getCandidateEntrypointsInDirs(rootDirs);
     const found = await findValidEntrypoint(workPath, candidates);
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils7.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils8.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
-async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint) {
-  const result = framework === "django" ? await detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) : await detectGenericPythonEntrypoint(workPath, configuredEntrypoint);
+async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint, service) {
+  if (configuredEntrypoint) {
+    const entrypoint = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+    let varName = await checkEntrypoint(workPath, entrypoint);
+    if (!varName) {
+      const isSpecialService = service?.type === "cron" || service?.type === "worker";
+      if (isSpecialService) {
+        varName = "app";
+      }
+    }
+    if (varName) {
+      (0, import_build_utils8.debug)(`Using configured Python entrypoint: ${entrypoint}`);
+      return { entrypoint: { entrypoint, variableName: varName } };
+    } else {
+      return {
+        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: "https://vercel.com/docs/functions/serverless-functions/runtimes/python",
+          action: "Learn More"
+        })
+      };
+    }
+  }
+  if (!framework) {
+    return null;
+  }
+  const result = framework === "django" ? await detectDjangoPythonEntrypoint(workPath) : await detectGenericPythonEntrypoint(workPath);
   if (result)
     return result;
   const pyprojectEntry = await getPyprojectEntrypoint(workPath);
-  if (!pyprojectEntry)
-    return null;
-  return {
-    entrypoint: pyprojectEntry.entrypoint,
-    variableName: pyprojectEntry.variableName
-  };
+  return pyprojectEntry ? { entrypoint: pyprojectEntry } : { error: makeDetectError(framework) };
 }
 
 // src/start-dev-server.ts
-var import_python_analysis5 = require("@vercel/python-analysis");
+var import_python_analysis6 = require("@vercel/python-analysis");
 var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
@@ -5140,17 +5264,17 @@ async function syncDependencies({
   let { manifestPath } = installInfo;
   const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils9.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils10.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_fs7.mkdirSync)(syncDir, { recursive: true });
     const tempPyproject = (0, import_path9.join)(syncDir, "pyproject.toml");
-    const content = (0, import_python_analysis5.stringifyManifest)(manifest.data);
+    const content = (0, import_python_analysis6.stringifyManifest)(manifest.data);
     (0, import_fs7.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils9.debug)(
+    (0, import_build_utils10.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -5183,7 +5307,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils9.NowBuildError({
+    throw new import_build_utils10.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -5205,7 +5329,7 @@ async function runSync({
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils9.NowBuildError({
+        throw new import_build_utils10.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/",
@@ -5227,11 +5351,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils9.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils10.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve3, reject) => {
-    (0, import_build_utils9.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils10.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -5318,13 +5442,13 @@ async function doInstallVercelRuntime({
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
     if ((0, import_fs7.existsSync)(distInfo)) {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils9.debug)(
+  (0, import_build_utils10.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"] };
@@ -5339,14 +5463,14 @@ async function doInstallVercelRuntime({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5414,13 +5538,13 @@ async function doInstallVercelWorkers({
       `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
     );
     if ((0, import_fs7.existsSync)(distInfo)) {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils9.debug)(
+  (0, import_build_utils10.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"] };
@@ -5435,14 +5559,14 @@ async function doInstallVercelWorkers({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils9.debug)(data.toString());
+        (0, import_build_utils10.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -5472,12 +5596,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils10.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils10.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -5485,7 +5609,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils9.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils10.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -5522,26 +5646,26 @@ function createDevShim(workPath, entry, modulePath, serviceName, framework, vari
     const template = (0, import_fs7.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_build_utils9.debug)(`Prepared Python dev shim at ${shimPath}`);
+    (0, import_build_utils10.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
       extraPythonPath,
       shimDir: vercelPythonDir
     };
   } catch (err) {
-    (0, import_build_utils9.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
+    (0, import_build_utils10.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_utils9.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils10.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path9.join)(workPath, ".venv");
   await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
-  (0, import_build_utils9.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  (0, import_build_utils10.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
@@ -5554,11 +5678,12 @@ var startDevServer = async (opts) => {
     workPath,
     meta = {},
     config,
+    service,
     onStdout,
     onStderr
   } = opts;
   const framework = config?.framework;
-  const serviceName = typeof meta.serviceName === "string" ? meta.serviceName : void 0;
+  const serviceName = service?.name ?? (typeof meta.serviceName === "string" ? meta.serviceName : void 0);
   const serverKey = serviceName ? `${workPath}::${framework}::${serviceName}` : `${workPath}::${framework}`;
   const existing = PERSISTENT_SERVERS.get(serverKey);
   if (existing) {
@@ -5588,40 +5713,36 @@ var startDevServer = async (opts) => {
     restoreWarnings = silenceNodeWarnings();
   installGlobalCleanupHandlers();
   const env = { ...process.env, ...meta.env || {} };
-  const serviceType = env.VERCEL_SERVICE_TYPE;
-  let entry;
-  let variableName;
-  if ((serviceType === "cron" || serviceType === "worker") && rawEntrypoint?.endsWith(".py")) {
-    entry = rawEntrypoint;
+  const entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
+  let resolved;
+  const detected = await detectPythonEntrypoint(
+    framework,
+    workPath,
+    entrypoint,
+    service
+  );
+  if (detected?.entrypoint) {
+    resolved = detected.entrypoint;
   } else {
-    const detected = await detectPythonEntrypoint(
-      framework,
+    const hookResult = await runFrameworkHook(framework, {
+      pythonEnv: env,
+      projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
       workPath,
-      rawEntrypoint
-    );
-    entry = detected?.entrypoint;
-    variableName = detected?.variableName;
-    if (!entry) {
-      const hookResult = await runFrameworkHook(framework, {
-        pythonEnv: env,
-        projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
-        workPath,
-        entrypoint: rawEntrypoint,
-        detected: detected ?? void 0
-      });
-      entry = hookResult?.entrypoint;
-      variableName = hookResult?.variableName;
-    }
-    if (!entry) {
-      const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils9.NowBuildError({
-        code: "PYTHON_ENTRYPOINT_NOT_FOUND",
-        message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searched}.`,
-        link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
-        action: "Learn More"
-      });
+      entrypoint,
+      detected: detected ?? void 0
+    });
+    resolved = hookResult?.entrypoint;
+  }
+  if (!resolved) {
+    if (detected?.error) {
+      throw detected.error;
     }
+    throw new import_build_utils10.NowBuildError({
+      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+      message: "No Python entrypoint could be detected. Please specify an entrypoint file."
+    });
   }
+  const { entrypoint: entry, variableName } = resolved;
   const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
   let childProcess = null;
   let stdoutLogListener = null;
@@ -5645,7 +5766,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils9.NowBuildError({
+      throw new import_build_utils10.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.`
@@ -5662,11 +5783,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils9.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils10.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -5675,9 +5796,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils9.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils10.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils9.debug)("No virtualenv found");
+        (0, import_build_utils10.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -5758,7 +5879,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils9.debug)(
+    (0, import_build_utils10.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
     if (process.stdout.columns) {
@@ -5812,8 +5933,8 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 
 // src/quirks/index.ts
-var import_build_utils12 = require("@vercel/build-utils");
-var import_python_analysis7 = require("@vercel/python-analysis");
+var import_build_utils13 = require("@vercel/build-utils");
+var import_python_analysis8 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
 var matplotlibQuirk = {
@@ -5828,7 +5949,7 @@ var matplotlibQuirk = {
 // src/quirks/litellm.ts
 var import_fs8 = __toESM(require("fs"));
 var import_path10 = require("path");
-var import_build_utils10 = require("@vercel/build-utils");
+var import_build_utils11 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
   "litellm_config.yaml",
@@ -5863,24 +5984,24 @@ var litellmQuirk = {
       );
       try {
         await import_fs8.default.promises.access(schemaPath);
-        (0, import_build_utils10.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
+        (0, import_build_utils11.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
       } catch {
       }
     }
     if (!buildEnv.PRISMA_SCHEMA_PATH) {
-      (0, import_build_utils10.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
+      (0, import_build_utils11.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_utils10.debug)(`LiteLLM quirk: found config at ${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);
       }
     } else {
-      (0, import_build_utils10.debug)(
+      (0, import_build_utils11.debug)(
         `LiteLLM quirk: CONFIG_FILE_PATH already set to ${process.env.CONFIG_FILE_PATH}`
       );
     }
@@ -5892,8 +6013,8 @@ var litellmQuirk = {
 var import_fs9 = __toESM(require("fs"));
 var import_path11 = require("path");
 var import_execa4 = __toESM(require_execa());
-var import_build_utils11 = require("@vercel/build-utils");
-var import_python_analysis6 = require("@vercel/python-analysis");
+var import_build_utils12 = require("@vercel/build-utils");
+var import_python_analysis7 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
     const stderr = String(err.stderr);
@@ -5935,7 +6056,7 @@ async function findUserSchema(workPath) {
       await import_fs9.default.promises.access(resolved);
       return resolved;
     } catch {
-      (0, import_build_utils11.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      (0, import_build_utils12.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
       return null;
     }
   }
@@ -6039,7 +6160,7 @@ var prismaQuirk = {
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
-    (0, import_build_utils11.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    (0, import_build_utils12.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
     try {
       const dummyResult = await (0, import_execa4.default)(
         pythonPath,
@@ -6051,11 +6172,11 @@ var prismaQuirk = {
         }
       );
       if (dummyResult.stdout)
-        (0, import_build_utils11.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+        (0, import_build_utils12.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
       if (dummyResult.stderr)
-        (0, import_build_utils11.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+        (0, import_build_utils12.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
     } catch (err) {
-      throw new import_build_utils11.NowBuildError({
+      throw new import_build_utils12.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)
@@ -6074,22 +6195,22 @@ var prismaQuirk = {
         const destPath = (0, import_path11.join)(cacheDir, runtimeName);
         try {
           await import_fs9.default.promises.access(destPath);
-          (0, import_build_utils11.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+          (0, import_build_utils12.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
-          (0, import_build_utils11.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          (0, import_build_utils12.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
           await import_fs9.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
     } catch (err) {
-      throw new import_build_utils11.NowBuildError({
+      throw new import_build_utils12.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_utils11.NowBuildError({
+      throw new import_build_utils12.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}).`
       });
@@ -6116,14 +6237,14 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
           pythonEnv
         );
         if (clientAlreadyGenerated) {
-          (0, import_build_utils11.debug)(
+          (0, import_build_utils12.debug)(
             "Prisma quirk: client already generated, skipping user schema generate"
           );
           shouldGenerate = false;
         }
       }
       if (shouldGenerate) {
-        (0, import_build_utils11.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        (0, import_build_utils12.debug)(`Running prisma generate with user schema: ${userSchema}`);
         try {
           const userResult = await (0, import_execa4.default)(
             pythonPath,
@@ -6135,11 +6256,11 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
             }
           );
           if (userResult.stdout)
-            (0, import_build_utils11.debug)(`prisma generate stdout: ${userResult.stdout}`);
+            (0, import_build_utils12.debug)(`prisma generate stdout: ${userResult.stdout}`);
           if (userResult.stderr)
-            (0, import_build_utils11.debug)(`prisma generate stderr: ${userResult.stderr}`);
+            (0, import_build_utils12.debug)(`prisma generate stderr: ${userResult.stderr}`);
         } catch (err) {
-          throw new import_build_utils11.NowBuildError({
+          throw new import_build_utils12.NowBuildError({
             code: "PRISMA_GENERATE_FAILED",
             message: `\`prisma generate\` failed for schema "${userSchema}".
 ` + execErrorMessage(err)
@@ -6153,9 +6274,9 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
         (0, import_path11.join)(sitePackages, "prisma"),
         sitePackages
       );
-      const count = await (0, import_python_analysis6.extendDistRecord)(sitePackages, "prisma", allFiles);
+      const count = await (0, import_python_analysis7.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
-        (0, import_build_utils11.debug)(`Appended ${count} entries to prisma RECORD`);
+        (0, import_build_utils12.debug)(`Appended ${count} entries to prisma RECORD`);
       }
     } catch (err) {
       console.warn(
@@ -6178,7 +6299,7 @@ var quirks = [litellmQuirk, prismaQuirk, matplotlibQuirk];
 function toposortQuirks(activated) {
   const nameToQuirk = /* @__PURE__ */ new Map();
   for (const q of activated) {
-    nameToQuirk.set((0, import_python_analysis7.normalizePackageName)(q.dependency), q);
+    nameToQuirk.set((0, import_python_analysis8.normalizePackageName)(q.dependency), q);
   }
   const adj = /* @__PURE__ */ new Map();
   const inDegree = /* @__PURE__ */ new Map();
@@ -6189,7 +6310,7 @@ function toposortQuirks(activated) {
   for (const q of activated) {
     if (q.runsBefore) {
       for (const dep of q.runsBefore) {
-        const target = nameToQuirk.get((0, import_python_analysis7.normalizePackageName)(dep));
+        const target = nameToQuirk.get((0, import_python_analysis8.normalizePackageName)(dep));
         if (target) {
           adj.get(q).add(target);
           inDegree.set(target, inDegree.get(target) + 1);
@@ -6198,7 +6319,7 @@ function toposortQuirks(activated) {
     }
     if (q.runsAfter) {
       for (const dep of q.runsAfter) {
-        const source = nameToQuirk.get((0, import_python_analysis7.normalizePackageName)(dep));
+        const source = nameToQuirk.get((0, import_python_analysis8.normalizePackageName)(dep));
         if (source) {
           adj.get(source).add(q);
           inDegree.set(q, inDegree.get(q) + 1);
@@ -6239,23 +6360,23 @@ async function runQuirks(ctx) {
   const installedNames = /* @__PURE__ */ new Set();
   const sitePackageDirs = await getVenvSitePackagesDirs(ctx.venvPath);
   for (const dir of sitePackageDirs) {
-    const distributions = await (0, import_python_analysis7.scanDistributions)(dir);
+    const distributions = await (0, import_python_analysis8.scanDistributions)(dir);
     for (const name of distributions.keys()) {
-      installedNames.add((0, import_python_analysis7.normalizePackageName)(name));
+      installedNames.add((0, import_python_analysis8.normalizePackageName)(name));
     }
   }
   const activated = quirks.filter((quirk) => {
     const installed = installedNames.has(
-      (0, import_python_analysis7.normalizePackageName)(quirk.dependency)
+      (0, import_python_analysis8.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
-      (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+      (0, import_build_utils13.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
     }
     return installed;
   });
   const sorted = toposortQuirks(activated);
   for (const quirk of sorted) {
-    (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    (0, import_build_utils13.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
     const result = await quirk.run(ctx);
     if (result.env) {
       Object.assign(mergedEnv, result.env);
@@ -6279,31 +6400,30 @@ async function runQuirks(ctx) {
 var import_fs10 = __toESM(require("fs"));
 var import_path12 = require("path");
 var import_execa5 = __toESM(require_execa());
-var import_build_utils13 = require("@vercel/build-utils");
+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");
 async function getDjangoSettings(projectDir, env) {
-  try {
-    const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
-      env,
-      cwd: projectDir
-    });
-    const parsed = JSON.parse(stdout);
-    if (!parsed)
-      return null;
-    return {
-      settingsModule: parsed.settings_module,
-      djangoSettings: parsed.django_settings
-    };
-  } catch (err) {
-    (0, import_build_utils13.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
-    return null;
+  const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
+    env,
+    cwd: projectDir
+  });
+  const parsed = JSON.parse(stdout);
+  if (!parsed) {
+    throw new Error("manage.py did not return any settings");
   }
+  return {
+    settingsModule: parsed.settings_module,
+    djangoSettings: parsed.django_settings,
+    djangoVersion: parsed.django_version ?? null
+  };
 }
-async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings) {
+async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings, djangoVersion) {
   const pythonPath = getVenvPythonBin(venvPath);
   const storages = djangoSettings["STORAGES"];
-  const storageBackend = storages?.staticfiles?.BACKEND ?? djangoSettings["STATICFILES_STORAGE"] ?? "django.contrib.staticfiles.storage.StaticFilesStorage";
+  const useLegacySetting = !djangoVersion || djangoVersion[0] < 5 || djangoVersion[0] === 5 && djangoVersion[1] < 1;
+  const legacyBackend = useLegacySetting ? djangoSettings["STATICFILES_STORAGE"] : void 0;
+  const storageBackend = storages?.staticfiles?.BACKEND ?? legacyBackend ?? "django.contrib.staticfiles.storage.StaticFilesStorage";
   const staticUrl = djangoSettings["STATIC_URL"] ?? "/static/";
   const staticRoot = djangoSettings["STATIC_ROOT"] != null ? String(djangoSettings["STATIC_ROOT"]) : null;
   const whitenoiseUseFinders = djangoSettings["WHITENOISE_USE_FINDERS"] === true;
@@ -6325,6 +6445,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     return {
       staticSourceDirs,
       staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
+      cdnOutputDir: null,
       manifestRelPath: null
     };
   }
@@ -6371,19 +6492,20 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     await import_fs10.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
     await import_fs10.default.promises.copyFile(manifestSrc, manifestDest);
     manifestRelPath = (0, import_path12.relative)(workPath, manifestDest);
-    (0, import_build_utils13.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
+    (0, import_build_utils14.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
   return {
     staticSourceDirs,
     staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
+    cdnOutputDir: outputStaticDir,
     manifestRelPath
   };
 }
 
 // src/index.ts
-var import_python_analysis8 = require("@vercel/python-analysis");
+var import_python_analysis9 = require("@vercel/python-analysis");
 var writeFile = import_fs11.default.promises.writeFile;
-var version = 3;
+var version = -1;
 async function runFrameworkHook(framework, ctx) {
   const hook = framework ? frameworkHooks[framework] : void 0;
   return hook?.(ctx);
@@ -6397,36 +6519,52 @@ var frameworkHooks = {
     detected
   }) => {
     if (detected?.baseDir === void 0) {
-      (0, import_build_utils14.debug)("Django hook: no manage.py detected, skipping");
+      (0, import_build_utils15.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
-    const settingsResult = await getDjangoSettings(projectDir, pythonEnv);
-    (0, import_build_utils14.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
-    if (!settingsResult)
-      return;
-    const { djangoSettings, settingsModule } = settingsResult;
-    let entrypoint;
-    let variableName;
+    let settingsResult;
+    try {
+      settingsResult = await getDjangoSettings(projectDir, pythonEnv);
+    } catch (err) {
+      let detail;
+      if (err?.code === "ENOENT") {
+        detail = `command not found: python
+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({
+        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)}`);
+    const { djangoSettings, settingsModule, djangoVersion } = settingsResult;
+    if (djangoVersion) {
+      console.log(`Django ${djangoVersion.join(".")} detected`);
+    }
+    let resolvedEntrypoint;
     const baseDir = detected?.baseDir ?? "";
     const asgiApp = djangoSettings["ASGI_APPLICATION"];
     if (typeof asgiApp === "string") {
       const parts = asgiApp.split(".");
-      variableName = parts.at(-1);
+      const variableName = parts.at(-1);
       const rel = `${parts.slice(0, -1).join("/")}.py`;
-      entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils14.debug)(
-        `Django hook: ASGI entrypoint: ${entrypoint} (variable: ${variableName})`
-      );
+      const ep = baseDir ? `${baseDir}/${rel}` : rel;
+      (0, import_build_utils15.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
+      resolvedEntrypoint = { entrypoint: ep, variableName };
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
       if (typeof wsgiApp === "string") {
         const parts = wsgiApp.split(".");
-        variableName = parts.at(-1);
+        const variableName = parts.at(-1);
         const rel = `${parts.slice(0, -1).join("/")}.py`;
-        entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils14.debug)(
-          `Django hook: WSGI entrypoint: ${entrypoint} (variable: ${variableName})`
+        const ep = baseDir ? `${baseDir}/${rel}` : rel;
+        (0, import_build_utils15.debug)(
+          `Django hook: WSGI entrypoint: ${ep} (variable: ${variableName})`
         );
+        resolvedEntrypoint = { entrypoint: ep, variableName };
       }
     }
     let djangoStatic = null;
@@ -6438,10 +6576,11 @@ var frameworkHooks = {
         pythonEnv,
         outputStaticDir,
         settingsModule,
-        djangoSettings
+        djangoSettings,
+        djangoVersion
       );
     }
-    return { entrypoint, variableName, djangoStatic };
+    return { entrypoint: resolvedEntrypoint, djangoStatic };
   }
 };
 async function downloadFilesInWorkPath({
@@ -6450,13 +6589,14 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils14.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils14.download)(files, workPath, meta);
-  if (meta.isDev) {
+  (0, import_build_utils15.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils15.download)(files, workPath, meta);
+  if (meta.isDev && entrypoint) {
     const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path13.join)(devCacheDir, (0, import_path13.basename)(entrypoint, ".py"));
-    await (0, import_build_utils14.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils14.glob)("**", destCache);
+    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);
     workPath = destCache;
   }
   return workPath;
@@ -6465,19 +6605,20 @@ var build = async ({
   workPath,
   repoRootPath,
   files: originalFiles,
-  entrypoint,
+  entrypoint: rawEntrypoint,
   meta = {},
   config,
   span: parentSpan,
   service
 }) => {
-  const builderSpan = parentSpan ?? new import_build_utils14.Span({ name: "vc.builder" });
+  let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
+  const builderSpan = parentSpan ?? new import_build_utils15.Span({ name: "vc.builder" });
   const framework = config?.framework;
   const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils14.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils15.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -6493,35 +6634,17 @@ var build = async ({
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils14.glob)("**", workPath);
   let detected;
-  let entrypointNotFound;
-  if ((0, import_build_utils14.isPythonFramework)(framework) && // XXX: we might want to detect anyway for django!
-  (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
-    detected = await detectPythonEntrypoint(
-      config.framework,
-      workPath,
-      entrypoint
-    ) ?? void 0;
-    if (detected?.entrypoint) {
-      (0, import_build_utils14.debug)(
-        `Resolved Python entrypoint to "${detected.entrypoint}" (configured "${entrypoint}" not found).`
-      );
-      entrypoint = detected.entrypoint;
-    } else {
-      const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      entrypointNotFound = new import_build_utils14.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`,
-        action: "Learn More"
-      });
-    }
-  }
-  if (entrypointNotFound && detected?.baseDir === void 0) {
-    throw entrypointNotFound;
+  detected = await detectPythonEntrypoint(
+    config.framework,
+    workPath,
+    entrypoint,
+    service
+  ) ?? void 0;
+  if (detected?.error && detected?.baseDir === void 0) {
+    throw detected?.error;
   }
-  const entryDirectory = detected?.baseDir ?? (0, import_path13.dirname)(entrypoint);
+  const entryDirectory = detected?.baseDir ?? (entrypoint ? (0, import_path13.dirname)(entrypoint) : ".");
   const entrypointAbsDir = (0, import_path13.join)(workPath, entryDirectory);
   const rootDir = repoRootPath ?? workPath;
   const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
@@ -6552,7 +6675,6 @@ var build = async ({
 `
     );
   }
-  fsFiles = await (0, import_build_utils14.glob)("**", workPath);
   const venvPath = service?.name ? (0, import_path13.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path13.join)(workPath, ".vercel", "python", ".venv");
   await builderSpan.child("vc.builder.python.venv").trace(async () => {
     await ensureVenv({
@@ -6560,14 +6682,14 @@ var build = async ({
       venvPath
     });
   });
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils14.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils14.getEnvForPackageManager)({
+    } = await (0, import_build_utils15.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils15.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -6592,8 +6714,11 @@ var build = async ({
   let uv;
   try {
     const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
-    console.log(`Using uv at "${uvPath}"`);
     uv = new UvRunner(uvPath);
+    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(
@@ -6603,14 +6728,14 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  await builderSpan.child(import_build_utils14.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils15.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils14.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils15.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -6650,15 +6775,15 @@ var build = async ({
       });
     }
   });
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils14.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils15.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils14.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils15.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
@@ -6679,16 +6804,20 @@ var build = async ({
     entrypoint,
     detected
   });
-  if (entrypointNotFound && hookResult?.entrypoint) {
-    entrypoint = hookResult.entrypoint;
-    entrypointNotFound = void 0;
-  }
-  if (entrypointNotFound) {
-    throw entrypointNotFound;
+  const resolved = hookResult?.entrypoint ?? detected?.entrypoint;
+  if (!resolved && detected?.error) {
+    throw detected?.error;
+  }
+  entrypoint = resolved?.entrypoint;
+  if (!entrypoint) {
+    throw new import_build_utils15.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_utils14.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils15.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
     projectDir: (0, import_path13.join)(workPath, entryDirectory),
@@ -6696,7 +6825,7 @@ var build = async ({
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
-    (0, import_build_utils14.debug)(`Installing ${workersDep}`);
+    (0, import_build_utils15.debug)(`Installing ${workersDep}`);
     await uv.pip({
       venvPath,
       projectDir: (0, import_path13.join)(workPath, entryDirectory),
@@ -6707,15 +6836,15 @@ var build = async ({
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
-  (0, import_build_utils14.debug)("Entrypoint is", entrypoint);
+  (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 found = await (0, import_python_analysis8.containsTopLevelCallable)(source, handlerFunction);
+    const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
-      throw new import_build_utils14.NowBuildError({
+      throw new import_build_utils15.NowBuildError({
         code: "PYTHON_HANDLER_NOT_FOUND",
         message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
       });
@@ -6724,10 +6853,10 @@ var build = async ({
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils14.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils15.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerFuncEnvLine = handlerFunction ? `
   "__VC_HANDLER_FUNC_NAME": "${handlerFunction}",` : "";
-  const variableName = hookResult?.variableName ?? detected?.variableName ?? "";
+  const variableName = resolved?.variableName ?? "";
   const runtimeTrampoline = `
 import importlib
 import os
@@ -6785,18 +6914,6 @@ from vercel_runtime.vc_init import vc_handler
     "**/yarn.lock",
     "**/package-lock.json"
   ];
-  if (djangoStatic) {
-    const dirsToExclude = [
-      ...djangoStatic.staticSourceDirs,
-      ...djangoStatic.staticRoot ? [djangoStatic.staticRoot] : []
-    ];
-    for (const absDir of dirsToExclude) {
-      const rel = (0, import_path13.relative)(workPath, absDir);
-      if (!rel.startsWith("..")) {
-        predefinedExcludes.push(`${rel}/**`);
-      }
-    }
-  }
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
   Object.assign(lambdaEnv, quirksResult.env);
@@ -6807,9 +6924,9 @@ 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_utils14.glob)("**", globOptions);
+  const files = await (0, import_build_utils15.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils14.FileFsRef({
+    files[djangoStatic.manifestRelPath] = new import_build_utils15.FileFsRef({
       fsPath: (0, import_path13.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
@@ -6846,12 +6963,12 @@ from vercel_runtime.vc_init import vc_handler
     }
   });
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils14.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils15.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils14.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils15.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils14.Lambda({
+  const output = new import_build_utils15.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -6867,16 +6984,33 @@ from vercel_runtime.vc_init import vc_handler
         uvLockPath
       });
     } catch (err) {
-      (0, import_build_utils14.debug)(
+      (0, import_build_utils15.debug)(
         `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-  return { output };
+  if (!(0, import_build_utils15.isPythonFramework)(framework)) {
+    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 }) : {};
+  return {
+    resultVersion: 2,
+    result: {
+      output: {
+        [lambdaPath]: output,
+        ...staticFiles
+      },
+      routes: [
+        { handle: "filesystem" },
+        { src: "/(.*)", dest: `/${lambdaPath}` }
+      ]
+    }
+  };
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils14.isPythonFramework)(framework)) {
+  if ((0, import_build_utils15.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;