@vercel/python 6.25.0 → 6.28.0

package/dist/index.js

@@ -3223,11 +3223,12 @@ __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.0";
+var VERCEL_RUNTIME_VERSION = "0.11.0";
 var VERCEL_WORKERS_VERSION = "0.0.13";
 
 // src/index.ts
@@ -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";
@@ -3331,34 +3332,16 @@ var UvRunner = class {
     args.push("--no-editable");
     await this.runUvCmd(args, projectDir, venvPath);
   }
-  async lock(projectDir, options) {
-    const args = ["lock"];
-    if (options?.noBuild) {
+  async lock(options) {
+    const { projectDir, venvPath, noBuild, upgrade } = options;
+    const args = ["lock", "--python", getVenvPythonBin(venvPath)];
+    if (noBuild) {
       args.push("--no-build");
     }
-    if (options?.upgrade) {
+    if (upgrade) {
       args.push("--upgrade");
     }
-    const pretty = `uv ${args.join(" ")}`;
-    (0, import_build_utils.debug)(`Running "${pretty}" in ${projectDir}...`);
-    try {
-      await (0, import_execa.default)(this.uvPath, args, {
-        cwd: projectDir,
-        env: getProtectedUvEnv(process.env)
-      });
-    } catch (err) {
-      const error = new Error(
-        `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
-      );
-      if (err && typeof err === "object") {
-        if ("code" in err) {
-          error.code = err.code;
-        } else if ("signal" in err) {
-          error.code = err.signal;
-        }
-      }
-      throw error;
-    }
+    await this.runUvCmd(args, projectDir, venvPath);
   }
   async addDependencies(options) {
     const { venvPath, projectDir, dependencies } = options;
@@ -3659,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
@@ -4017,6 +4020,7 @@ function detectInstallSource(pythonPackage, rootDir) {
 async function ensureUvProject({
   workPath,
   rootDir,
+  venvPath,
   pythonPackage,
   pythonVersion,
   uv,
@@ -4073,16 +4077,18 @@ async function ensureUvProject({
     if (workspaceLockFile) {
       lockPath = (0, import_path5.join)(rootDir, workspaceLockFile.path);
     } else {
-      await uv.lock(
+      await uv.lock({
         projectDir,
-        requireBinaryWheels ? { noBuild: true, upgrade: true } : void 0
-      );
+        venvPath,
+        ...requireBinaryWheels ? { noBuild: true, upgrade: true } : {}
+      });
     }
     if (generateLockFile && !lockPath) {
-      await uv.lock(
+      await uv.lock({
         projectDir,
-        requireBinaryWheels ? { noBuild: true, upgrade: true } : void 0
-      );
+        venvPath,
+        ...requireBinaryWheels ? { noBuild: true, upgrade: true } : {}
+      });
     }
   } else {
     projectDir = workPath;
@@ -4098,10 +4104,11 @@ async function ensureUvProject({
     });
     const content = (0, import_python_analysis2.stringifyManifest)(minimalManifest);
     await import_fs3.default.promises.writeFile(pyprojectPath, content);
-    await uv.lock(
+    await uv.lock({
       projectDir,
-      requireBinaryWheels ? { noBuild: true, upgrade: true } : void 0
-    );
+      venvPath,
+      ...requireBinaryWheels ? { noBuild: true, upgrade: true } : {}
+    });
   }
   const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : (0, import_path5.join)(projectDir, "uv.lock");
   return {
@@ -4418,6 +4425,19 @@ To fix this, either:
         runtimeToolingOverhead = 50 * 1024 * 1024;
       }
     }
+    runtimeToolingOverhead += 4 * 1024;
+    const projectDirRel = (0, import_path6.relative)(this.workPath, this.uvProjectDir);
+    const uvLockRel = (0, import_path6.relative)(this.workPath, this.uvLockPath);
+    const isOutsideWorkPath = projectDirRel.startsWith("..") || uvLockRel.startsWith("..");
+    if (isOutsideWorkPath) {
+      const pyprojectPath = (0, import_path6.join)(this.uvProjectDir, "pyproject.toml");
+      const pyprojectStats = await import_fs4.default.promises.stat(pyprojectPath).catch(() => null);
+      const uvLockStats = await import_fs4.default.promises.stat(this.uvLockPath).catch(() => null);
+      if (pyprojectStats)
+        runtimeToolingOverhead += pyprojectStats.size;
+      if (uvLockStats)
+        runtimeToolingOverhead += uvLockStats.size;
+    }
     const remainingCapacity = LAMBDA_SIZE_THRESHOLD_BYTES - fixedOverhead - runtimeToolingOverhead;
     (0, import_build_utils5.debug)(
       `Fixed overhead: ${(fixedOverhead / (1024 * 1024)).toFixed(2)} MB, runtime tooling: ${(runtimeToolingOverhead / (1024 * 1024)).toFixed(2)} MB, remaining capacity for public packages: ${(remainingCapacity / (1024 * 1024)).toFixed(2)} MB`
@@ -4446,9 +4466,6 @@ To fix this, either:
       ...this.alwaysBundlePackages,
       ...forceBundledDueToWheels
     ];
-    const projectDirRel = (0, import_path6.relative)(this.workPath, this.uvProjectDir);
-    const uvLockRel = (0, import_path6.relative)(this.workPath, this.uvLockPath);
-    const isOutsideWorkPath = projectDirRel.startsWith("..") || uvLockRel.startsWith("..");
     if (isOutsideWorkPath) {
       const srcPyproject = (0, import_path6.join)(this.uvProjectDir, "pyproject.toml");
       files[`${UV_BUNDLE_DIR}/pyproject.toml`] = new import_build_utils5.FileFsRef({
@@ -4488,7 +4505,7 @@ To fix this, either:
       }
     }
     const finalBundleSize = await calculateBundleSize(files);
-    if (finalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
+    if (finalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES + 100 * 1024) {
       const finalSizeMB = (finalBundleSize / (1024 * 1024)).toFixed(2);
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils5.NowBuildError({
@@ -4503,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);
@@ -4515,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) {
@@ -4554,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,
@@ -4917,6 +5013,7 @@ 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_python_analysis5 = require("@vercel/python-analysis");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
   "index",
@@ -4947,8 +5044,9 @@ 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"));
@@ -4974,9 +5072,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_utils7.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
+      return { entrypoint: candidate, variableName: varName };
     }
   }
   return null;
@@ -5006,9 +5105,10 @@ async function getSubdirectories(workPath) {
 async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    if (await checkEntrypoint(workPath, entry)) {
+    const varName = await checkEntrypoint(workPath, entry);
+    if (varName) {
       (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
-      return { entrypoint: entry };
+      return { entrypoint: { entrypoint: entry, variableName: varName } };
     }
     const found = await findValidEntrypoint(
       workPath,
@@ -5023,9 +5123,10 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
 async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    if (await checkEntrypoint(workPath, entry)) {
+    const varName = await checkEntrypoint(workPath, entry);
+    if (varName) {
       (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
-      return { entrypoint: entry };
+      return { entrypoint: { entrypoint: entry, variableName: varName } };
     }
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
@@ -5049,16 +5150,11 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint)
   if (result)
     return result;
   const pyprojectEntry = await getPyprojectEntrypoint(workPath);
-  if (!pyprojectEntry)
-    return null;
-  return {
-    entrypoint: pyprojectEntry.entrypoint,
-    variableName: pyprojectEntry.variableName
-  };
+  return pyprojectEntry ? { entrypoint: pyprojectEntry } : null;
 }
 
 // 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(
@@ -5151,7 +5247,7 @@ async function syncDependencies({
     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)(
@@ -5593,19 +5689,18 @@ var startDevServer = async (opts) => {
   installGlobalCleanupHandlers();
   const env = { ...process.env, ...meta.env || {} };
   const serviceType = env.VERCEL_SERVICE_TYPE;
-  let entry;
-  let variableName;
+  let resolved;
   if ((serviceType === "cron" || serviceType === "worker") && rawEntrypoint?.endsWith(".py")) {
-    entry = rawEntrypoint;
+    resolved = { entrypoint: rawEntrypoint, variableName: "app" };
   } else {
     const detected = await detectPythonEntrypoint(
       framework,
       workPath,
       rawEntrypoint
     );
-    entry = detected?.entrypoint;
-    variableName = detected?.variableName;
-    if (!entry) {
+    if (detected?.entrypoint) {
+      resolved = detected.entrypoint;
+    } else {
       const hookResult = await runFrameworkHook(framework, {
         pythonEnv: env,
         projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
@@ -5613,10 +5708,9 @@ var startDevServer = async (opts) => {
         entrypoint: rawEntrypoint,
         detected: detected ?? void 0
       });
-      entry = hookResult?.entrypoint;
-      variableName = hookResult?.variableName;
+      resolved = hookResult?.entrypoint;
     }
-    if (!entry) {
+    if (!resolved) {
       const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
       throw new import_build_utils9.NowBuildError({
         code: "PYTHON_ENTRYPOINT_NOT_FOUND",
@@ -5626,6 +5720,7 @@ var startDevServer = async (opts) => {
       });
     }
   }
+  const { entrypoint: entry, variableName } = resolved;
   const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
   let childProcess = null;
   let stdoutLogListener = null;
@@ -5817,7 +5912,7 @@ 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_python_analysis8 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
 var matplotlibQuirk = {
@@ -5897,7 +5992,7 @@ 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_python_analysis7 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
     const stderr = String(err.stderr);
@@ -6157,7 +6252,7 @@ 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`);
       }
@@ -6182,7 +6277,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();
@@ -6193,7 +6288,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);
@@ -6202,7 +6297,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);
@@ -6243,14 +6338,14 @@ 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`);
@@ -6329,6 +6424,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     return {
       staticSourceDirs,
       staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
+      cdnOutputDir: null,
       manifestRelPath: null
     };
   }
@@ -6380,14 +6476,15 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   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);
@@ -6409,28 +6506,27 @@ var frameworkHooks = {
     if (!settingsResult)
       return;
     const { djangoSettings, settingsModule } = settingsResult;
-    let entrypoint;
-    let variableName;
+    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_utils14.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;
+        const ep = baseDir ? `${baseDir}/${rel}` : rel;
         (0, import_build_utils14.debug)(
-          `Django hook: WSGI entrypoint: ${entrypoint} (variable: ${variableName})`
+          `Django hook: WSGI entrypoint: ${ep} (variable: ${variableName})`
         );
+        resolvedEntrypoint = { entrypoint: ep, variableName };
       }
     }
     let djangoStatic = null;
@@ -6445,7 +6541,7 @@ var frameworkHooks = {
         djangoSettings
       );
     }
-    return { entrypoint, variableName, djangoStatic };
+    return { entrypoint: resolvedEntrypoint, djangoStatic };
   }
 };
 async function downloadFilesInWorkPath({
@@ -6458,7 +6554,8 @@ async function downloadFilesInWorkPath({
   let downloadedFiles = await (0, import_build_utils14.download)(files, workPath, meta);
   if (meta.isDev) {
     const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path13.join)(devCacheDir, (0, import_path13.basename)(entrypoint, ".py"));
+    const cacheKey = (0, import_path13.basename)(entrypoint).replace(/\./g, "_");
+    const destCache = (0, import_path13.join)(devCacheDir, cacheKey);
     await (0, import_build_utils14.download)(downloadedFiles, destCache);
     downloadedFiles = await (0, import_build_utils14.glob)("**", destCache);
     workPath = destCache;
@@ -6509,9 +6606,9 @@ var build = async ({
     ) ?? void 0;
     if (detected?.entrypoint) {
       (0, import_build_utils14.debug)(
-        `Resolved Python entrypoint to "${detected.entrypoint}" (configured "${entrypoint}" not found).`
+        `Resolved Python entrypoint to "${detected.entrypoint.entrypoint}" (configured "${entrypoint}" not found).`
       );
-      entrypoint = detected.entrypoint;
+      entrypoint = detected.entrypoint.entrypoint;
     } else {
       const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
       entrypointNotFound = new import_build_utils14.NowBuildError({
@@ -6522,6 +6619,27 @@ var build = async ({
       });
     }
   }
+  if (!detected?.entrypoint && entrypoint.endsWith(".py") && fsFiles[entrypoint]) {
+    const content = await import_fs11.default.promises.readFile(
+      (0, import_path13.join)(workPath, entrypoint),
+      "utf-8"
+    );
+    let varName = await (0, import_python_analysis9.findAppOrHandler)(content);
+    if (!varName) {
+      const isSpecialService = service?.type === "cron" || service?.type === "worker";
+      if (isSpecialService) {
+        varName = "app";
+      } else if (!varName) {
+        throw new import_build_utils14.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"
+        });
+      }
+    }
+    detected = { entrypoint: { entrypoint, variableName: varName } };
+  }
   if (entrypointNotFound && detected?.baseDir === void 0) {
     throw entrypointNotFound;
   }
@@ -6596,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(
@@ -6636,6 +6757,7 @@ var build = async ({
       const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
         workPath,
         rootDir,
+        venvPath,
         pythonPackage,
         pythonVersion: pythonVersionString(pythonVersion),
         uv,
@@ -6682,8 +6804,9 @@ var build = async ({
     entrypoint,
     detected
   });
-  if (entrypointNotFound && hookResult?.entrypoint) {
-    entrypoint = hookResult.entrypoint;
+  const resolved = hookResult?.entrypoint ?? detected?.entrypoint;
+  if (entrypointNotFound && resolved) {
+    entrypoint = resolved.entrypoint;
     entrypointNotFound = void 0;
   }
   if (entrypointNotFound) {
@@ -6716,7 +6839,7 @@ var build = async ({
   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({
         code: "PYTHON_HANDLER_NOT_FOUND",
@@ -6730,7 +6853,7 @@ var build = async ({
   (0, import_build_utils14.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
@@ -6875,7 +6998,24 @@ from vercel_runtime.vc_init import vc_handler
       );
     }
   }
-  return { output };
+  if (djangoStatic?.cdnOutputDir) {
+    const lambdaPath = entrypoint.replace(/\.py$/, "");
+    const staticFiles = await (0, import_build_utils14.glob)("**", { cwd: djangoStatic.cdnOutputDir });
+    return {
+      resultVersion: 2,
+      result: {
+        output: {
+          [lambdaPath]: output,
+          ...staticFiles
+        },
+        routes: [
+          { handle: "filesystem" },
+          { src: "/(.*)", dest: `/${lambdaPath}` }
+        ]
+      }
+    };
+  }
+  return { resultVersion: 3, result: { output } };
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.25.0",
+  "version": "6.28.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -15,7 +15,7 @@
     "directory": "packages/python"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.10.1"
+    "@vercel/python-analysis": "0.11.0"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -36,14 +36,14 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.8.2",
-    "@vercel/error-utils": "2.0.3",
-    "@vercel/python-runtime": "0.10.0"
+    "@vercel/build-utils": "13.10.0",
+    "@vercel/python-runtime": "0.11.0",
+    "@vercel/error-utils": "2.0.3"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",
     "type-check": "tsc --noEmit",
-    "test": "cross-env VERCEL_FORCE_PYTHON_STREAMING=1 jest --reporters=default --reporters=jest-junit --env node --verbose --runInBand --bail",
+    "test": "cross-env VERCEL_FORCE_PYTHON_STREAMING=1 NODE_OPTIONS=--experimental-vm-modules jest --reporters=default --reporters=jest-junit --env node --verbose --runInBand --bail",
     "test-unit": "vitest run --config ../../vitest.config.mts test/unit.test.ts",
     "test-e2e": "pnpm test test/integration-*",
     "vitest-run": "vitest -c ../../vitest.config.mts",