@vercel/python 6.20.0 → 6.20.2

package/dist/index.js

@@ -989,10 +989,10 @@ var require_semver = __commonJS({
       var rangeTmp;
       if (this.operator === "") {
         rangeTmp = new Range(comp.value, options);
-        return satisfies2(this.value, rangeTmp, options);
+        return satisfies(this.value, rangeTmp, options);
       } else if (comp.operator === "") {
         rangeTmp = new Range(this.value, options);
-        return satisfies2(comp.semver, rangeTmp, options);
+        return satisfies(comp.semver, rangeTmp, options);
       }
       var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
       var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
@@ -1301,8 +1301,8 @@ var require_semver = __commonJS({
       }
       return true;
     }
-    exports.satisfies = satisfies2;
-    function satisfies2(version2, range, options) {
+    exports.satisfies = satisfies;
+    function satisfies(version2, range, options) {
       try {
         range = new Range(range, options);
       } catch (er) {
@@ -1430,7 +1430,7 @@ var require_semver = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies2(version2, range, options)) {
+      if (satisfies(version2, range, options)) {
         return false;
       }
       for (var i2 = 0; i2 < range.set.length; ++i2) {
@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join10, delimiter: delimiter2, sep: sep2, posix } = require("path");
+    var { join: join11, delimiter: delimiter2, sep: sep2, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep2 === posix.sep ? "" : sep2}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,7 +2680,7 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join10(pathPart, cmd);
+      return prefix + join11(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2868,11 +2868,11 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_fs8 = __toESM(require("fs"));
-var import_util2 = require("util");
-var import_path10 = require("path");
+var import_path11 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.5.4";
+var VERCEL_RUNTIME_VERSION = "0.5.6";
+var VERCEL_WORKERS_VERSION = "0.0.12";
 
 // src/index.ts
 var import_build_utils12 = require("@vercel/build-utils");
@@ -2880,9 +2880,9 @@ var import_build_utils12 = require("@vercel/build-utils");
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
 var import_fs3 = __toESM(require("fs"));
-var import_path4 = require("path");
+var import_path5 = require("path");
 var import_build_utils4 = require("@vercel/build-utils");
-var import_python_analysis = require("@vercel/python-analysis");
+var import_python_analysis2 = require("@vercel/python-analysis");
 
 // src/utils.ts
 var import_fs2 = __toESM(require("fs"));
@@ -3268,72 +3268,41 @@ async function runPyprojectScript(workPath, scriptNames, env, useUserVirtualEnv
   }
   return false;
 }
-function findDir({
-  file,
-  entryDirectory,
-  workPath,
-  fsFiles
-}) {
-  if (fsFiles[(0, import_path3.join)(entryDirectory, file)]) {
-    return (0, import_path3.join)(workPath, entryDirectory);
-  }
-  if (fsFiles[file]) {
-    return workPath;
-  }
-  return null;
-}
 
 // src/version.ts
+var import_path4 = require("path");
 var import_build_utils3 = require("@vercel/build-utils");
-var DEFAULT_PYTHON_VERSION = "3.12";
+var import_python_analysis = require("@vercel/python-analysis");
+function pythonVersionString(pv) {
+  return `${pv.major}.${pv.minor}`;
+}
+var DEFAULT_PYTHON_VERSION = makePythonVersion(3, 12);
+var DEFAULT_PYTHON_VERSION_STRING = pythonVersionString(
+  DEFAULT_PYTHON_VERSION
+);
+function makePythonVersion(major, minor, discontinueDate) {
+  return {
+    major,
+    minor,
+    pipPath: `pip${major}.${minor}`,
+    pythonPath: `python${major}.${minor}`,
+    runtime: `python${major}.${minor}`,
+    discontinueDate
+  };
+}
 var allOptions = [
-  {
-    version: "3.14",
-    pipPath: "pip3.14",
-    pythonPath: "python3.14",
-    runtime: "python3.14"
-  },
-  {
-    version: "3.13",
-    pipPath: "pip3.13",
-    pythonPath: "python3.13",
-    runtime: "python3.13"
-  },
-  {
-    version: "3.12",
-    pipPath: "pip3.12",
-    pythonPath: "python3.12",
-    runtime: "python3.12"
-  },
-  {
-    version: "3.11",
-    pipPath: "pip3.11",
-    pythonPath: "python3.11",
-    runtime: "python3.11"
-  },
-  {
-    version: "3.10",
-    pipPath: "pip3.10",
-    pythonPath: "python3.10",
-    runtime: "python3.10"
-  },
-  {
-    version: "3.9",
-    pipPath: "pip3.9",
-    pythonPath: "python3.9",
-    runtime: "python3.9"
-  },
-  {
-    version: "3.6",
-    pipPath: "pip3.6",
-    pythonPath: "python3.6",
-    runtime: "python3.6",
-    discontinueDate: /* @__PURE__ */ new Date("2022-07-18")
-  }
+  makePythonVersion(3, 14),
+  makePythonVersion(3, 13),
+  makePythonVersion(3, 12),
+  makePythonVersion(3, 11),
+  makePythonVersion(3, 10),
+  makePythonVersion(3, 9),
+  makePythonVersion(3, 6, /* @__PURE__ */ new Date("2022-07-18"))
 ];
 function getDevPythonVersion() {
   return {
-    version: "3",
+    major: 3,
+    minor: 0,
     pipPath: "pip3",
     pythonPath: "python3",
     runtime: "python3"
@@ -3346,7 +3315,7 @@ function getDefaultPythonVersion({
     return getDevPythonVersion();
   }
   const defaultOption = allOptions.find(
-    (opt) => opt.version === DEFAULT_PYTHON_VERSION && isInstalled(opt)
+    (opt) => versionsEqual(opt, DEFAULT_PYTHON_VERSION) && isInstalled(opt)
   );
   if (defaultOption) {
     return defaultOption;
@@ -3361,148 +3330,143 @@ function getDefaultPythonVersion({
   }
   return selection;
 }
-function parseVersionTuple(input) {
-  const cleaned = input.trim().replace(/\s+/g, "");
-  const m = cleaned.match(/^(\d+)(?:\.(\d+))?/);
-  if (!m)
-    return null;
-  const major = Number(m[1]);
-  const minor = m[2] !== void 0 ? Number(m[2]) : 0;
-  if (Number.isNaN(major) || Number.isNaN(minor))
-    return null;
-  return [major, minor];
+function versionsEqual(a, b) {
+  return a.major === b.major && a.minor === b.minor;
 }
-function compareTuples(a, b) {
-  if (a[0] !== b[0])
-    return a[0] - b[0];
-  return a[1] - b[1];
+function versionLessOrEqual(a, b) {
+  if (a.major !== b.major)
+    return a.major < b.major;
+  return a.minor <= b.minor;
 }
-function parseSpecifier(spec) {
-  const s = spec.trim();
-  const m = s.match(
-    /^(<=|>=|==|!=|~=|<|>)\s*([0-9]+(?:\.[0-9]+)?)(?:\.[0-9]+)?(?:\.\*)?$/
-  ) || // Bare version like "3.11" or "3.11.4" -> implied ==
-  s.match(/^()([0-9]+(?:\.[0-9]+)?)(?:\.[0-9]+)?(?:\.\*)?$/);
-  if (!m)
-    return null;
-  const op = m[1] || "==";
-  const vt = parseVersionTuple(m[2]);
-  if (!vt)
-    return null;
-  return { op, ver: vt };
+function toPythonBuild(opt) {
+  return {
+    version: { major: opt.major, minor: opt.minor },
+    implementation: "cpython",
+    variant: "default",
+    os: "linux",
+    architecture: "x86_64",
+    libc: "gnu"
+  };
 }
-function satisfies(candidate, spec) {
-  const cmp = compareTuples(candidate, spec.ver);
-  switch (spec.op) {
-    case "==":
-      return cmp === 0;
-    case "!=":
-      return cmp !== 0;
-    case "<":
-      return cmp < 0;
-    case "<=":
-      return cmp <= 0;
-    case ">":
-      return cmp > 0;
-    case ">=":
-      return cmp >= 0;
-    case "~=": {
-      const lowerOk = cmp >= 0;
-      const upper = [spec.ver[0], spec.ver[1] + 1];
-      return lowerOk && compareTuples(candidate, upper) < 0;
-    }
-    default:
-      return false;
-  }
+function getAvailablePythonBuilds() {
+  const installed = allOptions.filter(
+    (opt) => !isDiscontinued(opt) && isInstalled(opt)
+  );
+  const defaultOpt = installed.find(
+    (opt) => versionsEqual(opt, DEFAULT_PYTHON_VERSION)
+  );
+  const rest = installed.filter(
+    (opt) => !versionsEqual(opt, DEFAULT_PYTHON_VERSION)
+  );
+  const ordered = defaultOpt ? [defaultOpt, ...rest] : rest;
+  return ordered.map(toPythonBuild);
 }
-function selectFromRequiresPython(expr) {
-  const raw = expr.trim();
-  if (!raw)
-    return void 0;
-  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
-  const specifiers = [];
-  for (const p of parts) {
-    const sp = parseSpecifier(p);
-    if (sp)
-      specifiers.push(sp);
-  }
-  if (specifiers.length === 0) {
-    return allOptions.find((o) => o.version === raw);
-  }
-  const matches = allOptions.filter((opt) => {
-    const vt = parseVersionTuple(opt.version);
-    return specifiers.every((sp) => satisfies(vt, sp));
-  });
-  if (matches.length === 0)
-    return void 0;
-  const defaultMatch = matches.find(
-    (opt) => opt.version === DEFAULT_PYTHON_VERSION && isInstalled(opt)
+function getAllPythonBuilds() {
+  return allOptions.map(toPythonBuild);
+}
+function getPythonVersionForBuild(build2) {
+  return allOptions.find(
+    (opt) => opt.major === build2.version.major && opt.minor === build2.version.minor
   );
-  if (defaultMatch) {
-    return defaultMatch;
-  }
-  const installedMatch = matches.find(isInstalled);
-  return installedMatch ?? matches[0];
 }
-function getSupportedPythonVersion({
+function resolvePythonVersion({
   isDev,
-  declaredPythonVersion
+  pythonPackage,
+  rootDir
 }) {
   if (isDev) {
-    return getDevPythonVersion();
+    return {
+      pythonVersion: getDevPythonVersion(),
+      pythonPackage
+    };
   }
-  let selection = getDefaultPythonVersion({ isDev: false });
-  if (declaredPythonVersion) {
-    const { version: version2, source } = declaredPythonVersion;
-    let requested;
-    if (source === "pyproject.toml" || source === ".python-version") {
-      requested = selectFromRequiresPython(version2);
-    } else {
-      requested = allOptions.find((o) => o.version === version2);
-    }
-    if (requested) {
-      if (isDiscontinued(requested)) {
+  const constraints = pythonPackage.requiresPython;
+  const defaultPv = getDefaultPythonVersion({ isDev: false });
+  let selection;
+  let source;
+  let autoUpgraded = false;
+  if (!constraints || constraints.length === 0) {
+    console.log(
+      `No Python version specified in .python-version, pyproject.toml, or Pipfile.lock. Using python version: ${pythonVersionString(defaultPv)}`
+    );
+    selection = defaultPv;
+  } else {
+    const defaultBuild = toPythonBuild(defaultPv);
+    const availableBuilds = getAvailablePythonBuilds();
+    const allBuilds = getAllPythonBuilds();
+    const result = (0, import_python_analysis.selectPythonVersion)({
+      constraints,
+      availableBuilds,
+      allBuilds,
+      defaultBuild,
+      majorMinorOnly: true,
+      legacyTildeEquals: true
+    });
+    source = result.source;
+    selection = getPythonVersionForBuild(result.build) ?? defaultPv;
+    if (pythonPackage.manifest?.origin && !result.notAvailable && !result.invalidConstraint && !versionLessOrEqual(defaultPv, selection)) {
+      const originalVersion = pythonVersionString(selection);
+      selection = defaultPv;
+      autoUpgraded = true;
+      console.log(
+        `Python version ${originalVersion} detected in ${source} is below the minimum supported version. Using python version: ${pythonVersionString(selection)}`
+      );
+    } else if (result.notAvailable) {
+      const npv = getPythonVersionForBuild(result.notAvailable.build);
+      if (npv && isDiscontinued(npv)) {
         throw new import_build_utils3.NowBuildError({
           code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
           link: "https://vercel.link/python-version",
-          message: `Python version "${requested.version}" detected in ${source} is discontinued and must be upgraded.`
+          message: `Python version "${pythonVersionString(npv)}" detected in ${source} is discontinued and must be upgraded.`
         });
       }
-      if (isInstalled(requested)) {
-        selection = requested;
-        console.log(`Using Python ${selection.version} from ${source}`);
-      } else {
+      if (npv) {
         console.warn(
-          `Warning: Python version "${version2}" detected in ${source} is not installed and will be ignored. https://vercel.link/python-version`
+          `Warning: Python version "${pythonVersionString(npv)}" detected in ${source} is not installed and will be ignored. https://vercel.link/python-version`
         );
-        console.log(`Using python version: ${selection.version}`);
       }
-    } else {
+      console.log(`Using python version: ${pythonVersionString(selection)}`);
+    } else if (result.invalidConstraint) {
       console.warn(
-        `Warning: Python version "${version2}" detected in ${source} is invalid and will be ignored. https://vercel.link/python-version`
+        `Warning: Python version "${result.invalidConstraint.versionString}" detected in ${source} is invalid and will be ignored. https://vercel.link/python-version`
+      );
+      console.log(`Using python version: ${pythonVersionString(selection)}`);
+    } else {
+      console.log(
+        `Using Python ${pythonVersionString(selection)} from ${source}`
       );
-      console.log(`Using python version: ${selection.version}`);
     }
-  } else {
-    console.log(
-      `No Python version specified in .python-version, pyproject.toml, or Pipfile.lock. Using python version: ${selection.version}`
-    );
   }
   if (isDiscontinued(selection)) {
     throw new import_build_utils3.NowBuildError({
       code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
       link: "https://vercel.link/python-version",
-      message: `Python version "${selection.version}" declared in project configuration is discontinued and must be upgraded.`
+      message: `Python version "${pythonVersionString(selection)}" declared in project configuration is discontinued and must be upgraded.`
     });
   }
   if (selection.discontinueDate) {
     const d = selection.discontinueDate.toISOString().split("T")[0];
-    const srcSuffix = declaredPythonVersion ? `detected in ${declaredPythonVersion.source}` : "selected by runtime";
+    const srcSuffix = source ? `detected in ${source}` : "selected by runtime";
     console.warn(
-      `Error: Python version "${selection.version}" ${srcSuffix} has reached End-of-Life. Deployments created on or after ${d} will fail to build. https://vercel.link/python-version`
+      `Error: Python version "${pythonVersionString(selection)}" ${srcSuffix} has reached End-of-Life. Deployments created on or after ${d} will fail to build. https://vercel.link/python-version`
     );
   }
-  return selection;
+  let pinVersionFilePath;
+  const hasPythonVersionFile = pythonPackage.configs?.some(
+    (configSet) => configSet[import_python_analysis.PythonConfigKind.PythonVersion] !== void 0
+  ) ?? false;
+  if (!hasPythonVersionFile && pythonPackage.manifest && versionLessOrEqual(selection, defaultPv)) {
+    if (autoUpgraded || !pythonPackage.manifest.origin && source?.endsWith("pyproject.toml")) {
+      const manifestDir = (0, import_path4.join)(rootDir, (0, import_path4.dirname)(pythonPackage.manifest.path));
+      pinVersionFilePath = (0, import_path4.join)(manifestDir, ".python-version");
+    }
+  }
+  return {
+    pythonVersion: selection,
+    pythonPackage,
+    versionSource: source,
+    pinVersionFilePath
+  };
 }
 function isDiscontinued({ discontinueDate }) {
   const today = Date.now();
@@ -3525,10 +3489,10 @@ function getInstalledPythons() {
   installedPythonsCache = uv.listInstalledPythons();
   return installedPythonsCache;
 }
-function isInstalled({ version: version2 }) {
+function isInstalled(pv) {
   try {
     const installed = getInstalledPythons();
-    return installed.has(version2);
+    return installed.has(pythonVersionString(pv));
   } catch (err) {
     throw new import_build_utils3.NowBuildError({
       code: "UV_ERROR",
@@ -3553,11 +3517,11 @@ async function isInstalled2(pythonPath, dependency, cwd) {
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path4.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path5.join)(cwd, resolveVendorDir()) }
       }
     );
     return stdout.startsWith(cwd);
-  } catch (err) {
+  } catch (_err) {
     return false;
   }
 }
@@ -3576,11 +3540,11 @@ async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path4.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path5.join)(cwd, resolveVendorDir()) }
       }
     );
     return true;
-  } catch (err) {
+  } catch (_err) {
     return false;
   }
 }
@@ -3614,88 +3578,74 @@ function resolveVendorDir() {
   const vendorDir = process.env.VERCEL_PYTHON_VENDOR_DIR || "_vendor";
   return vendorDir;
 }
-function toBuildError(error) {
-  return new import_build_utils4.NowBuildError({
-    code: error.code,
-    message: error.message,
-    link: error.link,
-    action: error.action
-  });
-}
-async function detectInstallSource({
-  workPath,
-  entryDirectory,
-  repoRootPath
+async function discoverPackage({
+  entrypointDir,
+  rootDir
 }) {
-  const entrypointDir = (0, import_path4.join)(workPath, entryDirectory);
-  const rootDir = repoRootPath ?? workPath;
-  let pythonPackage;
   try {
-    pythonPackage = await (0, import_python_analysis.discoverPythonPackage)({
-      entrypointDir,
-      rootDir
-    });
+    return await (0, import_python_analysis2.discoverPythonPackage)({ entrypointDir, rootDir });
   } catch (error) {
-    if (error instanceof import_python_analysis.PythonAnalysisError) {
+    if (error instanceof import_python_analysis2.PythonAnalysisError) {
       if (error.fileContent && (error.code.endsWith("_PARSE_ERROR") || error.code.endsWith("_VALIDATION_ERROR"))) {
         console.log(
           `Failed to parse "${error.path}". File content:
 ${error.fileContent}`
         );
       }
-      throw toBuildError(error);
+      throw new import_build_utils4.NowBuildError({
+        code: error.code,
+        message: error.message,
+        link: error.link,
+        action: error.action
+      });
     }
     throw error;
   }
+}
+function detectInstallSource(pythonPackage, rootDir) {
   let manifestType = null;
   let manifestPath = null;
   const lockFile = pythonPackage.manifest?.lockFile ?? pythonPackage.workspaceLockFile;
   if (lockFile) {
-    if (lockFile.kind === import_python_analysis.PythonLockFileKind.UvLock) {
+    if (lockFile.kind === import_python_analysis2.PythonLockFileKind.UvLock) {
       manifestType = "uv.lock";
-      manifestPath = (0, import_path4.join)(rootDir, lockFile.path);
-    } else if (lockFile.kind === import_python_analysis.PythonLockFileKind.PylockToml) {
+      manifestPath = (0, import_path5.join)(rootDir, lockFile.path);
+    } else if (lockFile.kind === import_python_analysis2.PythonLockFileKind.PylockToml) {
       manifestType = "pylock.toml";
-      manifestPath = (0, import_path4.join)(rootDir, lockFile.path);
+      manifestPath = (0, import_path5.join)(rootDir, lockFile.path);
     }
   } else if (pythonPackage.manifest) {
     manifestType = "pyproject.toml";
-    manifestPath = (0, import_path4.join)(rootDir, pythonPackage.manifest.path);
+    manifestPath = (0, import_path5.join)(rootDir, pythonPackage.manifest.path);
   }
   return { manifestPath, manifestType, pythonPackage };
 }
 async function ensureUvProject({
   workPath,
-  entryDirectory,
-  repoRootPath,
+  rootDir,
+  pythonPackage,
   pythonVersion,
   uv,
   generateLockFile = false,
   requireBinaryWheels = false
 }) {
-  const rootDir = repoRootPath ?? workPath;
-  const installInfo = await detectInstallSource({
-    workPath,
-    entryDirectory,
-    repoRootPath
-  });
-  const { manifestType, pythonPackage } = installInfo;
-  const manifest = pythonPackage?.manifest;
+  const { manifestType } = detectInstallSource(pythonPackage, rootDir);
+  const manifest = pythonPackage.manifest;
   let projectDir;
   let pyprojectPath;
   let lockPath = null;
   let lockFileProvidedByUser = false;
   if (manifestType === "uv.lock" || manifestType === "pylock.toml") {
     lockFileProvidedByUser = true;
-    const lockFile = pythonPackage?.manifest?.lockFile ?? pythonPackage?.workspaceLockFile;
+    const lockFile = pythonPackage.manifest?.lockFile ?? pythonPackage.workspaceLockFile;
     if (!lockFile) {
       throw new Error(
         `Expected lock file path to be resolved, but it was null`
       );
     }
-    lockPath = (0, import_path4.join)(rootDir, lockFile.path);
-    projectDir = (0, import_path4.dirname)(lockPath);
-    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+    lockPath = (0, import_path5.join)(rootDir, lockFile.path);
+    projectDir = (0, import_path5.dirname)(lockPath);
+    pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
     if (!import_fs3.default.existsSync(pyprojectPath)) {
       throw new Error(
         `Expected "pyproject.toml" next to "${lockFile.kind}" in "${projectDir}"`
@@ -3703,14 +3653,14 @@ async function ensureUvProject({
     }
     console.log(`Installing required dependencies from ${lockFile.kind}...`);
   } else if (manifest) {
-    projectDir = (0, import_path4.join)(rootDir, (0, import_path4.dirname)(manifest.path));
-    pyprojectPath = (0, import_path4.join)(rootDir, manifest.path);
+    projectDir = (0, import_path5.join)(rootDir, (0, import_path5.dirname)(manifest.path));
+    pyprojectPath = (0, import_path5.join)(rootDir, manifest.path);
     const originKind = manifest.origin?.kind;
-    if (originKind === import_python_analysis.PythonManifestConvertedKind.Pipfile) {
+    if (originKind === import_python_analysis2.PythonManifestConvertedKind.Pipfile) {
       console.log("Installing required dependencies from Pipfile...");
-    } else if (originKind === import_python_analysis.PythonManifestConvertedKind.PipfileLock) {
+    } else if (originKind === import_python_analysis2.PythonManifestConvertedKind.PipfileLock) {
       console.log("Installing required dependencies from Pipfile.lock...");
-    } else if (originKind === import_python_analysis.PythonManifestConvertedKind.RequirementsTxt || originKind === import_python_analysis.PythonManifestConvertedKind.RequirementsIn) {
+    } else if (originKind === import_python_analysis2.PythonManifestConvertedKind.RequirementsTxt || originKind === import_python_analysis2.PythonManifestConvertedKind.RequirementsIn) {
       console.log(
         `Installing required dependencies from ${manifest.origin?.path ?? "requirements.txt"}...`
       );
@@ -3718,16 +3668,16 @@ async function ensureUvProject({
       console.log("Installing required dependencies from pyproject.toml...");
     }
     if (manifest.origin) {
-      if (manifest.data.project && !manifest.data.project["requires-python"]) {
+      if (manifest.data.project) {
         manifest.data.project["requires-python"] = `~=${pythonVersion}.0`;
       }
-      const content = (0, import_python_analysis.stringifyManifest)(manifest.data);
-      pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+      const content = (0, import_python_analysis2.stringifyManifest)(manifest.data);
+      pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
       await import_fs3.default.promises.writeFile(pyprojectPath, content);
     }
-    const workspaceLockFile = pythonPackage?.workspaceLockFile;
+    const workspaceLockFile = pythonPackage.workspaceLockFile;
     if (workspaceLockFile) {
-      lockPath = (0, import_path4.join)(rootDir, workspaceLockFile.path);
+      lockPath = (0, import_path5.join)(rootDir, workspaceLockFile.path);
     } else {
       await uv.lock(
         projectDir,
@@ -3742,24 +3692,24 @@ async function ensureUvProject({
     }
   } else {
     projectDir = workPath;
-    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+    pyprojectPath = (0, import_path5.join)(projectDir, "pyproject.toml");
     console.log(
       "No Python manifest found; creating an empty pyproject.toml and uv.lock..."
     );
     const requiresPython = `~=${pythonVersion}.0`;
-    const minimalManifest = (0, import_python_analysis.createMinimalManifest)({
+    const minimalManifest = (0, import_python_analysis2.createMinimalManifest)({
       name: "app",
       requiresPython,
       dependencies: []
     });
-    const content = (0, import_python_analysis.stringifyManifest)(minimalManifest);
+    const content = (0, import_python_analysis2.stringifyManifest)(minimalManifest);
     await import_fs3.default.promises.writeFile(pyprojectPath, content);
     await uv.lock(
       projectDir,
       requireBinaryWheels ? { noBuild: true, upgrade: true } : void 0
     );
   }
-  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : (0, import_path4.join)(projectDir, "uv.lock");
+  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : (0, import_path5.join)(projectDir, "uv.lock");
   return {
     projectDir,
     pyprojectPath,
@@ -3768,7 +3718,7 @@ async function ensureUvProject({
   };
 }
 async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
-  const target = targetDir ? (0, import_path4.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
+  const target = targetDir ? (0, import_path5.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
   process.env.PIP_USER = "0";
   if (uvPath) {
     const uvArgs = [
@@ -3862,9 +3812,9 @@ async function installRequirementsFile({
 // src/dependency-externalizer.ts
 var import_fs4 = __toESM(require("fs"));
 var import_util = require("util");
-var import_path5 = require("path");
+var import_path6 = require("path");
 var import_build_utils5 = require("@vercel/build-utils");
-var import_python_analysis2 = require("@vercel/python-analysis");
+var import_python_analysis3 = require("@vercel/python-analysis");
 var readFile = (0, import_util.promisify)(import_fs4.default.readFile);
 var LAMBDA_SIZE_THRESHOLD_BYTES = 249 * 1024 * 1024;
 var LAMBDA_PACKING_TARGET_BYTES = 245 * 1024 * 1024;
@@ -4001,9 +3951,9 @@ To fix this, either:
     }
     let lockFile;
     try {
-      lockFile = (0, import_python_analysis2.parseUvLock)(lockContent, this.uvLockPath);
+      lockFile = (0, import_python_analysis3.parseUvLock)(lockContent, this.uvLockPath);
     } catch (error) {
-      if (error instanceof import_python_analysis2.PythonAnalysisError) {
+      if (error instanceof import_python_analysis3.PythonAnalysisError) {
         if (error.fileContent) {
           console.log(
             `Failed to parse "${error.path}". File content:
@@ -4024,7 +3974,7 @@ ${error.fileContent}`
         `Excluding project package "${this.projectName}" from runtime installation`
       );
     }
-    const classification = (0, import_python_analysis2.classifyPackages)({
+    const classification = (0, import_python_analysis3.classifyPackages)({
       lockFile,
       excludePackages
     });
@@ -4088,11 +4038,11 @@ ${error.fileContent}`
       ...bundledPublic,
       ...this.alwaysBundlePackages
     ];
-    const projectDirRel = (0, import_path5.relative)(this.workPath, this.uvProjectDir);
-    const uvLockRel = (0, import_path5.relative)(this.workPath, this.uvLockPath);
+    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_path5.join)(this.uvProjectDir, "pyproject.toml");
+      const srcPyproject = (0, import_path6.join)(this.uvProjectDir, "pyproject.toml");
       files[`${UV_BUNDLE_DIR}/pyproject.toml`] = new import_build_utils5.FileFsRef({
         fsPath: srcPyproject
       });
@@ -4110,8 +4060,8 @@ ${error.fileContent}`
     if (process.env.VERCEL_BUILD_IMAGE) {
       try {
         const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
-        const uvBundleDir = (0, import_path5.join)(this.workPath, UV_BUNDLE_DIR);
-        const uvLocalPath = (0, import_path5.join)(uvBundleDir, "uv");
+        const uvBundleDir = (0, import_path6.join)(this.workPath, UV_BUNDLE_DIR);
+        const uvLocalPath = (0, import_path6.join)(uvBundleDir, "uv");
         await import_fs4.default.promises.mkdir(uvBundleDir, { recursive: true });
         await import_fs4.default.promises.copyFile(uvBinaryPath, uvLocalPath);
         await import_fs4.default.promises.chmod(uvLocalPath, 493);
@@ -4151,30 +4101,30 @@ async function mirrorPackagesIntoVendor({
   if (includePackages && includePackages.length === 0) {
     return vendorFiles;
   }
-  const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis2.normalizePackageName)) : null;
+  const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis3.normalizePackageName)) : null;
   const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
   for (const dir of sitePackageDirs) {
     if (!import_fs4.default.existsSync(dir))
       continue;
-    const resolvedDir = (0, import_path5.resolve)(dir);
-    const dirPrefix = resolvedDir + import_path5.sep;
-    const distributions = await (0, import_python_analysis2.scanDistributions)(dir);
+    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_path5.sep);
-        if (!(0, import_path5.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+        const filePath = rawPath.replaceAll("/", import_path6.sep);
+        if (!(0, import_path6.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
           continue;
         }
-        if (filePath.endsWith(".pyc") || filePath.split(import_path5.sep).includes("__pycache__")) {
+        if (filePath.endsWith(".pyc") || filePath.split(import_path6.sep).includes("__pycache__")) {
           continue;
         }
-        const srcFsPath = (0, import_path5.join)(dir, filePath);
+        const srcFsPath = (0, import_path6.join)(dir, filePath);
         if (!import_fs4.default.existsSync(srcFsPath)) {
           continue;
         }
-        const bundlePath = (0, import_path5.join)(vendorDirName, filePath).replace(/\\/g, "/");
+        const bundlePath = (0, import_path6.join)(vendorDirName, filePath).replace(/\\/g, "/");
         vendorFiles[bundlePath] = new import_build_utils5.FileFsRef({ fsPath: srcFsPath });
       }
     }
@@ -4225,21 +4175,21 @@ async function calculatePerPackageSizes(venvPath) {
   for (const dir of sitePackageDirs) {
     if (!import_fs4.default.existsSync(dir))
       continue;
-    const resolvedDir = (0, import_path5.resolve)(dir);
-    const dirPrefix = resolvedDir + import_path5.sep;
-    const distributions = await (0, import_python_analysis2.scanDistributions)(dir);
+    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_path5.sep);
-        if (!(0, import_path5.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+        const filePath = rawPath.replaceAll("/", import_path6.sep);
+        if (!(0, import_path6.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
           continue;
         }
-        if (filePath.endsWith(".pyc") || filePath.split(import_path5.sep).includes("__pycache__")) {
+        if (filePath.endsWith(".pyc") || filePath.split(import_path6.sep).includes("__pycache__")) {
           continue;
         }
         try {
-          const stats = await import_fs4.default.promises.stat((0, import_path5.join)(dir, filePath));
+          const stats = await import_fs4.default.promises.stat((0, import_path6.join)(dir, filePath));
           totalSize += stats.size;
         } catch {
         }
@@ -4250,19 +4200,16 @@ async function calculatePerPackageSizes(venvPath) {
   return sizes;
 }
 
-// src/index.ts
-var import_build_utils13 = require("@vercel/build-utils");
-
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
 var import_fs5 = require("fs");
-var import_path7 = require("path");
+var import_path8 = require("path");
 var import_build_utils8 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
 
 // src/entrypoint.ts
-var import_path6 = require("path");
+var import_path7 = require("path");
 var import_build_utils6 = require("@vercel/build-utils");
 var import_build_utils7 = require("@vercel/build-utils");
 var PYTHON_ENTRYPOINT_FILENAMES = [
@@ -4280,12 +4227,12 @@ var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
 function getCandidateEntrypointsInDirs(dirs) {
   return dirs.flatMap(
     (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
-      (filename) => import_path6.posix.join(dir, `${filename}.py`)
+      (filename) => import_path7.posix.join(dir, `${filename}.py`)
     )
   );
 }
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path6.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -4364,10 +4311,10 @@ async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
       )
     ];
     for (const rootDir of rootDirs) {
-      const currPath = (0, import_path6.join)(workPath, rootDir);
+      const currPath = (0, import_path7.join)(workPath, rootDir);
       const wsgiEntry = await (0, import_build_utils6.getDjangoEntrypoint)(currPath);
       if (wsgiEntry) {
-        const fullWsgiEntry = import_path6.posix.join(rootDir, wsgiEntry);
+        const fullWsgiEntry = import_path7.posix.join(rootDir, wsgiEntry);
         if (fsFiles[fullWsgiEntry]) {
           (0, import_build_utils6.debug)(`Using Django WSGI entrypoint: ${fullWsgiEntry}`);
           return fullWsgiEntry;
@@ -4390,7 +4337,7 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint)
 }
 
 // src/start-dev-server.ts
-var import_python_analysis3 = require("@vercel/python-analysis");
+var import_python_analysis4 = require("@vercel/python-analysis");
 var DEV_SERVER_STARTUP_TIMEOUT = 1e4;
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
@@ -4463,21 +4410,23 @@ async function syncDependencies({
   onStdout,
   onStderr
 }) {
-  const installInfo = await detectInstallSource({
-    workPath,
-    entryDirectory: "."
+  const pythonPackage = await discoverPackage({
+    entrypointDir: workPath,
+    rootDir: workPath
   });
-  let { manifestType, manifestPath } = installInfo;
-  const manifest = installInfo.pythonPackage?.manifest;
+  const installInfo = detectInstallSource(pythonPackage, workPath);
+  const { manifestType } = installInfo;
+  let { manifestPath } = installInfo;
+  const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
     (0, import_build_utils8.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
-    const syncDir = (0, import_path7.join)(workPath, ".vercel", "python", "sync");
+    const syncDir = (0, import_path8.join)(workPath, ".vercel", "python", "sync");
     (0, import_fs5.mkdirSync)(syncDir, { recursive: true });
-    const tempPyproject = (0, import_path7.join)(syncDir, "pyproject.toml");
-    const content = (0, import_python_analysis3.stringifyManifest)(manifest.data);
+    const tempPyproject = (0, import_path8.join)(syncDir, "pyproject.toml");
+    const content = (0, import_python_analysis4.stringifyManifest)(manifest.data);
     (0, import_fs5.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
     (0, import_build_utils8.debug)(
@@ -4528,7 +4477,7 @@ async function runSync({
   onStdout,
   onStderr
 }) {
-  const projectDir = (0, import_path7.dirname)(manifestPath);
+  const projectDir = (0, import_path8.dirname)(manifestPath);
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   let spawnCmd;
   let spawnArgs;
@@ -4638,18 +4587,18 @@ function installGlobalCleanupHandlers() {
 }
 function createDevShim(workPath, entry, modulePath) {
   try {
-    const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
+    const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
     (0, import_fs5.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs5.existsSync)((0, import_path7.join)(workPath, "__init__.py"))) {
-      const pkgName = (0, import_path7.basename)(workPath);
+    if ((0, import_fs5.existsSync)((0, import_path8.join)(workPath, "__init__.py"))) {
+      const pkgName = (0, import_path8.basename)(workPath);
       qualifiedModule = `${pkgName}.${modulePath}`;
-      extraPythonPath = (0, import_path7.dirname)(workPath);
+      extraPythonPath = (0, import_path8.dirname)(workPath);
     }
-    const entryAbs = (0, import_path7.join)(workPath, entry);
-    const shimPath = (0, import_path7.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path7.join)(__dirname, "..", `${DEV_SHIM_MODULE}.py`);
+    const entryAbs = (0, import_path8.join)(workPath, entry);
+    const shimPath = (0, import_path8.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path8.join)(__dirname, "..", `${DEV_SHIM_MODULE}.py`);
     const template = (0, import_fs5.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs);
     (0, import_fs5.writeFileSync)(shimPath, shimSource, "utf8");
@@ -4666,13 +4615,13 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
     (0, import_build_utils8.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
-  const venvPath = (0, import_path7.join)(workPath, ".venv");
+  const venvPath = (0, import_path8.join)(workPath, ".venv");
   await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
   (0, import_build_utils8.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
-  env.PATH = `${binDir}${import_path7.delimiter}${env.PATH || ""}`;
+  env.PATH = `${binDir}${import_path8.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
 var startDevServer = async (opts) => {
@@ -4820,7 +4769,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
     env.PORT = `${port}`;
     const devShim = createDevShim(workPath, entry, modulePath);
     if (devShim) {
-      const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
+      const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
       const pathParts = [vercelPythonDir];
       if (devShim.extraPythonPath) {
         pathParts.push(devShim.extraPythonPath);
@@ -4829,7 +4778,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (existingPythonPath) {
         pathParts.push(existingPythonPath);
       }
-      env.PYTHONPATH = pathParts.join(import_path7.delimiter);
+      env.PYTHONPATH = pathParts.join(import_path8.delimiter);
     }
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
@@ -4889,7 +4838,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
 
 // src/quirks/index.ts
 var import_build_utils11 = require("@vercel/build-utils");
-var import_python_analysis5 = require("@vercel/python-analysis");
+var import_python_analysis6 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
 var matplotlibQuirk = {
@@ -4903,7 +4852,7 @@ var matplotlibQuirk = {
 
 // src/quirks/litellm.ts
 var import_fs6 = __toESM(require("fs"));
-var import_path8 = require("path");
+var import_path9 = require("path");
 var import_build_utils9 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
@@ -4914,7 +4863,7 @@ var CONFIG_CANDIDATES = [
 ];
 async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
-    const candidate = (0, import_path8.join)(workPath, name);
+    const candidate = (0, import_path9.join)(workPath, name);
     try {
       await import_fs6.default.promises.access(candidate);
       return name;
@@ -4931,7 +4880,7 @@ var litellmQuirk = {
     const env = {};
     const sitePackagesDirs = await getVenvSitePackagesDirs(ctx.venvPath);
     for (const sitePackages of sitePackagesDirs) {
-      const schemaPath = (0, import_path8.join)(
+      const schemaPath = (0, import_path9.join)(
         sitePackages,
         "litellm",
         "proxy",
@@ -4952,8 +4901,8 @@ var litellmQuirk = {
       const configName = await findConfigFile(ctx.workPath);
       if (configName) {
         (0, import_build_utils9.debug)(`LiteLLM quirk: found config at ${configName}`);
-        buildEnv.CONFIG_FILE_PATH = (0, import_path8.join)(ctx.workPath, configName);
-        env.CONFIG_FILE_PATH = (0, import_path8.join)(LAMBDA_ROOT, configName);
+        buildEnv.CONFIG_FILE_PATH = (0, import_path9.join)(ctx.workPath, configName);
+        env.CONFIG_FILE_PATH = (0, import_path9.join)(LAMBDA_ROOT, configName);
       }
     } else {
       (0, import_build_utils9.debug)(
@@ -4966,10 +4915,10 @@ var litellmQuirk = {
 
 // src/quirks/prisma.ts
 var import_fs7 = __toESM(require("fs"));
-var import_path9 = require("path");
+var import_path10 = require("path");
 var import_execa4 = __toESM(require_execa());
 var import_build_utils10 = require("@vercel/build-utils");
-var import_python_analysis4 = require("@vercel/python-analysis");
+var import_python_analysis5 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
     const stderr = String(err.stderr);
@@ -5005,7 +4954,7 @@ model DummyModel {
 async function findUserSchema(workPath) {
   const envPath = process.env.PRISMA_SCHEMA_PATH;
   if (envPath) {
-    const resolved = (0, import_path9.isAbsolute)(envPath) ? envPath : (0, import_path9.join)(workPath, envPath);
+    const resolved = (0, import_path10.isAbsolute)(envPath) ? envPath : (0, import_path10.join)(workPath, envPath);
     try {
       await import_fs7.default.promises.access(resolved);
       return resolved;
@@ -5015,8 +4964,8 @@ async function findUserSchema(workPath) {
     }
   }
   const candidates = [
-    (0, import_path9.join)(workPath, "schema.prisma"),
-    (0, import_path9.join)(workPath, "prisma", "schema.prisma")
+    (0, import_path10.join)(workPath, "schema.prisma"),
+    (0, import_path10.join)(workPath, "prisma", "schema.prisma")
   ];
   for (const candidate of candidates) {
     try {
@@ -5038,20 +4987,20 @@ async function collectFiles(dir, base) {
   for (const entry of entries) {
     if (entry.name === "__pycache__")
       continue;
-    const full = (0, import_path9.join)(dir, entry.name);
+    const full = (0, import_path10.join)(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...await collectFiles(full, base));
     } else {
-      result.push((0, import_path9.relative)(base, full));
+      result.push((0, import_path10.relative)(base, full));
     }
   }
   return result;
 }
 async function cleanCacheArtifacts(cacheDir, extras = []) {
   const paths = [
-    (0, import_path9.join)(cacheDir, "node_modules"),
-    (0, import_path9.join)(cacheDir, "package.json"),
-    (0, import_path9.join)(cacheDir, "package-lock.json"),
+    (0, import_path10.join)(cacheDir, "node_modules"),
+    (0, import_path10.join)(cacheDir, "package.json"),
+    (0, import_path10.join)(cacheDir, "package-lock.json"),
     ...extras
   ];
   for (const p of paths) {
@@ -5080,7 +5029,7 @@ var prismaQuirk = {
   async run(ctx) {
     const { venvPath, pythonEnv, workPath } = ctx;
     const pythonPath = getVenvPythonBin(venvPath);
-    const runtimeCacheDir = (0, import_path9.join)(
+    const runtimeCacheDir = (0, import_path10.join)(
       LAMBDA_ROOT2,
       resolveVendorDir(),
       "prisma",
@@ -5090,7 +5039,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs7.default.promises.access((0, import_path9.join)(dir, "prisma"));
+        await import_fs7.default.promises.access((0, import_path10.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -5102,14 +5051,14 @@ var prismaQuirk = {
       );
       return {};
     }
-    const cacheDir = (0, import_path9.join)(sitePackages, "prisma", "__bincache__");
+    const cacheDir = (0, import_path10.join)(sitePackages, "prisma", "__bincache__");
     await import_fs7.default.promises.mkdir(cacheDir, { recursive: true });
     const generateEnv = {
       ...pythonEnv,
       PRISMA_BINARY_CACHE_DIR: cacheDir
     };
-    const generatedDir = (0, import_path9.join)(workPath, "_prisma_generated");
-    const dummySchemaPath = (0, import_path9.join)(workPath, DUMMY_SCHEMA_NAME);
+    const generatedDir = (0, import_path10.join)(workPath, "_prisma_generated");
+    const dummySchemaPath = (0, import_path10.join)(workPath, DUMMY_SCHEMA_NAME);
     await import_fs7.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
@@ -5138,15 +5087,15 @@ var prismaQuirk = {
     }
     const srcBinaryPrefix = `query-engine-${getLambdaBinaryTarget()}`;
     const runtimeName = `prisma-query-engine-rhel-openssl-${RUNTIME_OPENSSL_VERSION}.x`;
-    const nodeModulesDir = (0, import_path9.join)(cacheDir, "node_modules", "prisma");
+    const nodeModulesDir = (0, import_path10.join)(cacheDir, "node_modules", "prisma");
     let engineCopied = false;
     try {
       const entries = await import_fs7.default.promises.readdir(nodeModulesDir);
       for (const entry of entries) {
         if (!entry.startsWith(srcBinaryPrefix))
           continue;
-        const srcPath = (0, import_path9.join)(nodeModulesDir, entry);
-        const destPath = (0, import_path9.join)(cacheDir, runtimeName);
+        const srcPath = (0, import_path10.join)(nodeModulesDir, entry);
+        const destPath = (0, import_path10.join)(cacheDir, runtimeName);
         try {
           await import_fs7.default.promises.access(destPath);
           (0, import_build_utils10.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
@@ -5169,7 +5118,7 @@ var prismaQuirk = {
         message: `could not find engine binary matching "${srcBinaryPrefix}*" in "${nodeModulesDir}". This may indicate an incompatible prisma version or an unsupported platform (${process.arch}).`
       });
     }
-    const shimPath = (0, import_path9.join)(cacheDir, "openssl");
+    const shimPath = (0, import_path10.join)(cacheDir, "openssl");
     await import_fs7.default.promises.writeFile(
       shimPath,
       `#!/bin/sh
@@ -5225,10 +5174,10 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
     }
     try {
       const allFiles = await collectFiles(
-        (0, import_path9.join)(sitePackages, "prisma"),
+        (0, import_path10.join)(sitePackages, "prisma"),
         sitePackages
       );
-      const count = await (0, import_python_analysis4.extendDistRecord)(sitePackages, "prisma", allFiles);
+      const count = await (0, import_python_analysis5.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
         (0, import_build_utils10.debug)(`Appended ${count} entries to prisma RECORD`);
       }
@@ -5253,7 +5202,7 @@ var quirks = [litellmQuirk, prismaQuirk, matplotlibQuirk];
 function toposortQuirks(activated) {
   const nameToQuirk = /* @__PURE__ */ new Map();
   for (const q of activated) {
-    nameToQuirk.set((0, import_python_analysis5.normalizePackageName)(q.dependency), q);
+    nameToQuirk.set((0, import_python_analysis6.normalizePackageName)(q.dependency), q);
   }
   const adj = /* @__PURE__ */ new Map();
   const inDegree = /* @__PURE__ */ new Map();
@@ -5264,7 +5213,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_analysis5.normalizePackageName)(dep));
+        const target = nameToQuirk.get((0, import_python_analysis6.normalizePackageName)(dep));
         if (target) {
           adj.get(q).add(target);
           inDegree.set(target, inDegree.get(target) + 1);
@@ -5273,7 +5222,7 @@ function toposortQuirks(activated) {
     }
     if (q.runsAfter) {
       for (const dep of q.runsAfter) {
-        const source = nameToQuirk.get((0, import_python_analysis5.normalizePackageName)(dep));
+        const source = nameToQuirk.get((0, import_python_analysis6.normalizePackageName)(dep));
         if (source) {
           adj.get(source).add(q);
           inDegree.set(q, inDegree.get(q) + 1);
@@ -5314,14 +5263,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_analysis5.scanDistributions)(dir);
+    const distributions = await (0, import_python_analysis6.scanDistributions)(dir);
     for (const name of distributions.keys()) {
-      installedNames.add((0, import_python_analysis5.normalizePackageName)(name));
+      installedNames.add((0, import_python_analysis6.normalizePackageName)(name));
     }
   }
   const activated = quirks.filter((quirk) => {
     const installed = installedNames.has(
-      (0, import_python_analysis5.normalizePackageName)(quirk.dependency)
+      (0, import_python_analysis6.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
       (0, import_build_utils11.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
@@ -5351,8 +5300,7 @@ async function runQuirks(ctx) {
 }
 
 // src/index.ts
-var readFile2 = (0, import_util2.promisify)(import_fs8.default.readFile);
-var writeFile = (0, import_util2.promisify)(import_fs8.default.writeFile);
+var writeFile = import_fs8.default.promises.writeFile;
 var version = 3;
 async function downloadFilesInWorkPath({
   entrypoint,
@@ -5363,8 +5311,8 @@ async function downloadFilesInWorkPath({
   (0, import_build_utils12.debug)("Downloading user files...");
   let downloadedFiles = await (0, import_build_utils12.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path10.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path10.join)(devCacheDir, (0, import_path10.basename)(entrypoint, ".py"));
+    const { devCacheDir = (0, import_path11.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path11.join)(devCacheDir, (0, import_path11.basename)(entrypoint, ".py"));
     await (0, import_build_utils12.download)(downloadedFiles, destCache);
     downloadedFiles = await (0, import_build_utils12.glob)("**", destCache);
     workPath = destCache;
@@ -5382,6 +5330,7 @@ var build = async ({
 }) => {
   const builderSpan = parentSpan ?? new import_build_utils12.Span({ name: "vc.builder" });
   const framework = config?.framework;
+  const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
@@ -5394,7 +5343,7 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path10.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path11.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
@@ -5423,106 +5372,39 @@ var build = async ({
       });
     }
   }
-  const entryDirectory = (0, import_path10.dirname)(entrypoint);
-  const pyprojectDir = findDir({
-    file: "pyproject.toml",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const pipfileLockDir = findDir({
-    file: "Pipfile.lock",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const pythonVersionFileDir = findDir({
-    file: ".python-version",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const { pythonVersion, declaredPythonVersion } = await builderSpan.child("vc.builder.python.version").trace(async (versionSpan) => {
-    let declared;
-    if (pythonVersionFileDir) {
-      try {
-        const content = await readFile2(
-          (0, import_path10.join)(pythonVersionFileDir, ".python-version"),
-          "utf8"
-        );
-        const version2 = parsePythonVersionFile(content);
-        if (version2) {
-          declared = { version: version2, source: ".python-version" };
-          (0, import_build_utils12.debug)(`Found Python version ${version2} in .python-version`);
-        }
-      } catch (err) {
-        (0, import_build_utils12.debug)("Failed to read .python-version file", err);
-      }
-    }
-    if (!declared && pyprojectDir) {
-      let requiresPython;
-      try {
-        const pyproject = await (0, import_build_utils13.readConfigFile)((0, import_path10.join)(pyprojectDir, "pyproject.toml"));
-        requiresPython = pyproject?.project?.["requires-python"];
-      } catch (err) {
-        (0, import_build_utils12.debug)("Failed to parse pyproject.toml", err);
-      }
-      if (typeof requiresPython === "string" && requiresPython.trim()) {
-        declared = {
-          version: requiresPython.trim(),
-          source: "pyproject.toml"
-        };
-        (0, import_build_utils12.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
-      }
-    }
-    if (!declared && pipfileLockDir) {
-      let lock = {};
-      const pipfileLockPath = (0, import_path10.join)(pipfileLockDir, "Pipfile.lock");
-      try {
-        const pipfileLockContent = await readFile2(pipfileLockPath, "utf8");
-        try {
-          lock = JSON.parse(pipfileLockContent);
-        } catch (err) {
-          console.log(
-            `Failed to parse "Pipfile.lock". File content:
-${pipfileLockContent}`
-          );
-          throw err;
-        }
-      } catch (err) {
-        throw new import_build_utils12.NowBuildError({
-          code: "INVALID_PIPFILE_LOCK",
-          message: "Unable to parse Pipfile.lock"
-        });
-      }
-      const pyFromLock = lock?._meta?.requires?.python_version;
-      if (pyFromLock) {
-        declared = { version: pyFromLock, source: "Pipfile.lock" };
-        (0, import_build_utils12.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
-      }
-    }
-    const resolved = getSupportedPythonVersion({
+  const entryDirectory = (0, import_path11.dirname)(entrypoint);
+  const entrypointAbsDir = (0, import_path11.join)(workPath, entryDirectory);
+  const rootDir = repoRootPath ?? workPath;
+  const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
+    () => discoverPackage({
+      entrypointDir: entrypointAbsDir,
+      rootDir
+    })
+  );
+  const { pythonVersion, pinVersionFilePath } = await builderSpan.child("vc.builder.python.version").trace((versionSpan) => {
+    const resolution = resolvePythonVersion({
       isDev: meta.isDev,
-      declaredPythonVersion: declared
+      pythonPackage,
+      rootDir
     });
     versionSpan.setAttributes({
-      "python.version": resolved.version,
-      "python.versionSource": declared?.source
+      "python.version": pythonVersionString(resolution.pythonVersion),
+      "python.versionSource": resolution.versionSource
     });
-    return { pythonVersion: resolved, declaredPythonVersion: declared };
+    return resolution;
   });
-  const selectedVersionTuple = parseVersionTuple(pythonVersion.version);
-  const defaultVersionTuple = parseVersionTuple(DEFAULT_PYTHON_VERSION);
-  if (!pythonVersionFileDir && pyprojectDir && declaredPythonVersion?.source === "pyproject.toml" && selectedVersionTuple && defaultVersionTuple && compareTuples(selectedVersionTuple, defaultVersionTuple) <= 0) {
-    const pythonVersionFilePath = (0, import_path10.join)(pyprojectDir, ".python-version");
-    await writeFile(pythonVersionFilePath, `${pythonVersion.version}
-`);
+  if (pinVersionFilePath) {
     console.log(
-      `Writing .python-version file with version ${pythonVersion.version}`
+      `Writing .python-version file with version ${pythonVersionString(pythonVersion)}`
+    );
+    await writeFile(
+      pinVersionFilePath,
+      `${pythonVersionString(pythonVersion)}
+`
     );
   }
   fsFiles = await (0, import_build_utils12.glob)("**", workPath);
-  const venvPath = (0, import_path10.join)(workPath, ".vercel", "python", ".venv");
+  const venvPath = (0, import_path11.join)(workPath, ".vercel", "python", ".venv");
   await builderSpan.child("vc.builder.python.venv").trace(async () => {
     await ensureVenv({
       pythonPath: pythonVersion.pythonPath,
@@ -5601,21 +5483,16 @@ ${pipfileLockContent}`
     if (!assumeDepsInstalled) {
       const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
         workPath,
-        entryDirectory,
-        repoRootPath,
-        pythonVersion: pythonVersion.version,
+        rootDir,
+        pythonPackage,
+        pythonVersion: pythonVersionString(pythonVersion),
         uv,
         generateLockFile: true,
         requireBinaryWheels: false
       });
       uvLockPath = lockPath;
       uvProjectDir = projectDir;
-      const installInfo = await detectInstallSource({
-        workPath,
-        entryDirectory,
-        repoRootPath
-      });
-      projectName = installInfo.pythonPackage?.manifest?.data?.project?.name;
+      projectName = pythonPackage?.manifest?.data?.project?.name;
       if (lockFileProvidedByUser) {
         try {
           await uv.sync({
@@ -5665,9 +5542,18 @@ ${pipfileLockContent}`
   (0, import_build_utils12.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
-    projectDir: (0, import_path10.join)(workPath, entryDirectory),
+    projectDir: (0, import_path11.join)(workPath, entryDirectory),
     args: ["install", runtimeDep]
   });
+  if (shouldInstallVercelWorkers) {
+    const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
+    (0, import_build_utils12.debug)(`Installing ${workersDep}`);
+    await uv.pip({
+      venvPath,
+      projectDir: (0, import_path11.join)(workPath, entryDirectory),
+      args: ["install", workersDep]
+    });
+  }
   const quirksResult = await runQuirks({ venvPath, pythonEnv, workPath });
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
@@ -5752,7 +5638,10 @@ from vercel_runtime.vc_init import vc_handler
     noBuildCheckFailed,
     pythonPath: pythonVersion.pythonPath,
     hasCustomCommand,
-    alwaysBundlePackages: quirksResult.alwaysBundlePackages
+    alwaysBundlePackages: [
+      ...quirksResult.alwaysBundlePackages ?? [],
+      ...shouldInstallVercelWorkers ? ["vercel-workers", "vercel_workers"] : []
+    ]
   });
   await builderSpan.child("vc.builder.python.bundle").trace(async (bundleSpan) => {
     const depAnalysis = await depExternalizer.analyze(files);
@@ -5806,7 +5695,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path10.parse)(entrypoint);
+  const { dir, name } = (0, import_path11.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -5815,16 +5704,6 @@ var defaultShouldServe = ({
 function hasProp(obj, key) {
   return Object.hasOwnProperty.call(obj, key);
 }
-function parsePythonVersionFile(content) {
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#"))
-      continue;
-    return trimmed;
-  }
-  return void 0;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,