@vercel/python 6.16.1 → 6.18.0

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs6.stat(path, function(er, stat) {
+      fs7.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs6.statSync(path), path, options);
+      return checkStat(fs7.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     function isexe(path, options, cb) {
-      fs6.stat(path, function(er, stat) {
+      fs7.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs6.statSync(path), options);
+      return checkStat(fs7.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs6.openSync(command, "r");
-        fs6.readSync(fd, buffer, 0, size, 0);
-        fs6.closeSync(fd);
+        fd = fs7.openSync(command, "r");
+        fs7.readSync(fd, buffer, 0, size, 0);
+        fs7.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -423,15 +423,15 @@ var require_readShebang = __commonJS({
 var require_semver = __commonJS({
   "../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js"(exports, module2) {
     exports = module2.exports = SemVer;
-    var debug7;
+    var debug9;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug7 = function() {
+      debug9 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug7 = function() {
+      debug9 = function() {
       };
     }
     exports.SEMVER_SPEC_VERSION = "2.0.0";
@@ -540,7 +540,7 @@ var require_semver = __commonJS({
     var STAR = R++;
     src[STAR] = "(<|>)?=?\\s*\\*";
     for (i = 0; i < R; i++) {
-      debug7(i, src[i]);
+      debug9(i, src[i]);
       if (!re[i]) {
         re[i] = new RegExp(src[i]);
         safeRe[i] = new RegExp(makeSafeRe(src[i]));
@@ -607,7 +607,7 @@ var require_semver = __commonJS({
       if (!(this instanceof SemVer)) {
         return new SemVer(version2, options);
       }
-      debug7("SemVer", version2, options);
+      debug9("SemVer", version2, options);
       this.options = options;
       this.loose = !!options.loose;
       var m = version2.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL]);
@@ -654,7 +654,7 @@ var require_semver = __commonJS({
       return this.version;
     };
     SemVer.prototype.compare = function(other) {
-      debug7("SemVer.compare", this.version, this.options, other);
+      debug9("SemVer.compare", this.version, this.options, other);
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
@@ -681,7 +681,7 @@ var require_semver = __commonJS({
       do {
         var a = this.prerelease[i2];
         var b = other.prerelease[i2];
-        debug7("prerelease compare", i2, a, b);
+        debug9("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -935,7 +935,7 @@ var require_semver = __commonJS({
         return new Comparator(comp, options);
       }
       comp = comp.trim().split(/\s+/).join(" ");
-      debug7("comparator", comp, options);
+      debug9("comparator", comp, options);
       this.options = options;
       this.loose = !!options.loose;
       this.parse(comp);
@@ -944,7 +944,7 @@ var require_semver = __commonJS({
       } else {
         this.value = this.operator + this.semver.version;
       }
-      debug7("comp", this);
+      debug9("comp", this);
     }
     var ANY = {};
     Comparator.prototype.parse = function(comp) {
@@ -967,7 +967,7 @@ var require_semver = __commonJS({
       return this.value;
     };
     Comparator.prototype.test = function(version2) {
-      debug7("Comparator.test", version2, this.options.loose);
+      debug9("Comparator.test", version2, this.options.loose);
       if (this.semver === ANY) {
         return true;
       }
@@ -1050,9 +1050,9 @@ var require_semver = __commonJS({
       var loose = this.options.loose;
       var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
       range = range.replace(hr, hyphenReplace);
-      debug7("hyphen replace", range);
+      debug9("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug7("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug9("comparator trim", range, safeRe[COMPARATORTRIM]);
       range = range.replace(safeRe[TILDETRIM], tildeTrimReplace);
       range = range.replace(safeRe[CARETTRIM], caretTrimReplace);
       var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR];
@@ -1092,15 +1092,15 @@ var require_semver = __commonJS({
       });
     }
     function parseComparator(comp, options) {
-      debug7("comp", comp, options);
+      debug9("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug7("caret", comp);
+      debug9("caret", comp);
       comp = replaceTildes(comp, options);
-      debug7("tildes", comp);
+      debug9("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug7("xrange", comp);
+      debug9("xrange", comp);
       comp = replaceStars(comp, options);
-      debug7("stars", comp);
+      debug9("stars", comp);
       return comp;
     }
     function isX(id) {
@@ -1114,7 +1114,7 @@ var require_semver = __commonJS({
     function replaceTilde(comp, options) {
       var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug7("tilde", comp, _, M, m, p, pr);
+        debug9("tilde", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1123,12 +1123,12 @@ var require_semver = __commonJS({
         } else if (isX(p)) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         } else if (pr) {
-          debug7("replaceTilde pr", pr);
+          debug9("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug7("tilde return", ret);
+        debug9("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug7("caret", comp, options);
+      debug9("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug7("caret", comp, _, M, m, p, pr);
+        debug9("caret", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1154,7 +1154,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
           }
         } else if (pr) {
-          debug7("replaceCaret pr", pr);
+          debug9("replaceCaret pr", pr);
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
@@ -1165,7 +1165,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
           }
         } else {
-          debug7("no pr");
+          debug9("no pr");
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
@@ -1176,12 +1176,12 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
           }
         }
-        debug7("caret return", ret);
+        debug9("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug7("replaceXRanges", comp, options);
+      debug9("replaceXRanges", comp, options);
       return comp.split(/\s+/).map(function(comp2) {
         return replaceXRange(comp2, options);
       }).join(" ");
@@ -1190,7 +1190,7 @@ var require_semver = __commonJS({
       comp = comp.trim();
       var r = options.loose ? safeRe[XRANGELOOSE] : safeRe[XRANGE];
       return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
-        debug7("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug9("xRange", comp, ret, gtlt, M, m, p, pr);
         var xM = isX(M);
         var xm = xM || isX(m);
         var xp = xm || isX(p);
@@ -1233,12 +1233,12 @@ var require_semver = __commonJS({
         } else if (xp) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         }
-        debug7("xRange return", ret);
+        debug9("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug7("replaceStars", comp, options);
+      debug9("replaceStars", comp, options);
       return comp.trim().replace(safeRe[STAR], "");
     }
     function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
@@ -1286,7 +1286,7 @@ var require_semver = __commonJS({
       }
       if (version2.prerelease.length && !options.includePrerelease) {
         for (i2 = 0; i2 < set.length; i2++) {
-          debug7(set[i2].semver);
+          debug9(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs6;
+    var fs7;
     try {
-      fs6 = require("fs");
+      fs7 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs6)
+      if (!fs7)
         return false;
-      return (stream instanceof (fs6.ReadStream || noop) || stream instanceof (fs6.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs7.ReadStream || noop) || stream instanceof (fs7.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -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: join8, delimiter: delimiter2, sep: sep2, posix } = require("path");
+    var { join: join9, 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 + join8(pathPart, cmd);
+      return prefix + join9(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2867,15 +2867,15 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_fs6 = __toESM(require("fs"));
+var import_fs7 = __toESM(require("fs"));
 var import_util2 = require("util");
-var import_path8 = require("path");
+var import_path9 = require("path");
 
-// src/runtime-version.ts
-var VERCEL_RUNTIME_VERSION = "0.5.1";
+// src/package-versions.ts
+var VERCEL_RUNTIME_VERSION = "0.5.3";
 
 // src/index.ts
-var import_build_utils9 = require("@vercel/build-utils");
+var import_build_utils11 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -3881,6 +3881,7 @@ var PythonDependencyExternalizer = class {
     this.noBuildCheckFailed = options.noBuildCheckFailed;
     this.pythonPath = options.pythonPath;
     this.hasCustomCommand = options.hasCustomCommand;
+    this.alwaysBundlePackages = options.alwaysBundlePackages ?? [];
   }
   shouldEnableRuntimeInstall() {
     if (this.hasCustomCommand) {
@@ -4033,7 +4034,8 @@ ${error.fileContent}`
     const alwaysBundled = [
       ...classification.privatePackages,
       "vercel-runtime",
-      "vercel_runtime"
+      "vercel_runtime",
+      ...this.alwaysBundlePackages
     ];
     const alwaysBundledFiles = await mirrorPackagesIntoVendor({
       venvPath: this.venvPath,
@@ -4076,7 +4078,8 @@ ${error.fileContent}`
     }
     const bundledPackagesForConfig = [
       ...classification.privatePackages,
-      ...bundledPublic
+      ...bundledPublic,
+      ...this.alwaysBundlePackages
     ];
     const projectDirRel = (0, import_path5.relative)(this.workPath, this.uvProjectDir);
     const uvLockRel = (0, import_path5.relative)(this.workPath, this.uvLockPath);
@@ -4241,7 +4244,7 @@ async function calculatePerPackageSizes(venvPath) {
 }
 
 // src/index.ts
-var import_build_utils10 = require("@vercel/build-utils");
+var import_build_utils12 = require("@vercel/build-utils");
 
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
@@ -4264,11 +4267,16 @@ var PYTHON_ENTRYPOINT_FILENAMES = [
   "asgi"
 ];
 var PYTHON_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
-var PYTHON_CANDIDATE_ENTRYPOINTS = PYTHON_ENTRYPOINT_FILENAMES.flatMap(
-  (filename) => PYTHON_ENTRYPOINT_DIRS.map(
-    (dir) => import_path6.posix.join(dir, `${filename}.py`)
-  )
+var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
+  PYTHON_ENTRYPOINT_DIRS
 );
+function getCandidateEntrypointsInDirs(dirs) {
+  return dirs.flatMap(
+    (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
+      (filename) => import_path6.posix.join(dir, `${filename}.py`)
+    )
+  );
+}
 async function getPyprojectEntrypoint(workPath) {
   const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path6.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
@@ -4295,6 +4303,18 @@ async function getPyprojectEntrypoint(workPath) {
     return null;
   }
 }
+async function findValidEntrypoint(fsFiles, candidates) {
+  for (const candidate of candidates) {
+    if (fsFiles[candidate]) {
+      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[candidate]);
+      if (isValid) {
+        (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
 async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
@@ -4309,24 +4329,54 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
     const candidates = PYTHON_CANDIDATE_ENTRYPOINTS.filter(
       (c) => !!fsFiles[c]
     );
-    for (const candidate of candidates) {
-      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[candidate]);
+    return findValidEntrypoint(fsFiles, candidates);
+  } catch {
+    (0, import_build_utils6.debug)("Failed to discover Python entrypoint");
+    return null;
+  }
+}
+async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
+  const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
+  try {
+    const fsFiles = await (0, import_build_utils6.glob)("**", workPath);
+    if (fsFiles[entry]) {
+      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[entry]);
       if (isValid) {
-        (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
-        return candidate;
+        (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
+        return entry;
       }
     }
-    return null;
+    const rootGlobs = await (0, import_build_utils6.glob)("*", {
+      cwd: workPath,
+      includeDirectories: true
+    });
+    const rootDirs = [
+      "",
+      ...Object.keys(rootGlobs).filter(
+        (name) => !name.startsWith(".") && rootGlobs[name].mode != null && (0, import_build_utils6.isDirectory)(rootGlobs[name].mode)
+      )
+    ];
+    for (const rootDir of rootDirs) {
+      const currPath = (0, import_path6.join)(workPath, rootDir);
+      const wsgiEntry = await (0, import_build_utils6.getDjangoEntrypoint)(currPath);
+      if (wsgiEntry) {
+        const fullWsgiEntry = import_path6.posix.join(rootDir, wsgiEntry);
+        if (fsFiles[fullWsgiEntry]) {
+          (0, import_build_utils6.debug)(`Using Django WSGI entrypoint: ${fullWsgiEntry}`);
+          return fullWsgiEntry;
+        }
+      }
+    }
+    const baseCandidates = getCandidateEntrypointsInDirs(rootDirs);
+    const candidates = baseCandidates.filter((c) => !!fsFiles[c]);
+    return findValidEntrypoint(fsFiles, candidates);
   } catch {
-    (0, import_build_utils6.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils6.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
-async function detectPythonEntrypoint(_framework, workPath, configuredEntrypoint) {
-  const entrypoint = await detectGenericPythonEntrypoint(
-    workPath,
-    configuredEntrypoint
-  );
+async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint) {
+  const entrypoint = framework === "django" ? await detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) : await detectGenericPythonEntrypoint(workPath, configuredEntrypoint);
   if (entrypoint)
     return entrypoint;
   return await getPyprojectEntrypoint(workPath);
@@ -4579,17 +4629,25 @@ function installGlobalCleanupHandlers() {
     killAll();
   });
 }
-function createDevShim(workPath, modulePath) {
+function createDevShim(workPath, entry, modulePath) {
   try {
     const vercelPythonDir = (0, import_path7.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);
+      qualifiedModule = `${pkgName}.${modulePath}`;
+      extraPythonPath = (0, import_path7.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 template = (0, import_fs5.readFileSync)(templatePath, "utf8");
-    const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
+    const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs);
     (0, import_fs5.writeFileSync)(shimPath, shimSource, "utf8");
     (0, import_build_utils8.debug)(`Prepared Python dev shim at ${shimPath}`);
-    return DEV_SHIM_MODULE;
+    return { module: DEV_SHIM_MODULE, extraPythonPath };
   } catch (err) {
     (0, import_build_utils8.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
     return null;
@@ -4753,22 +4811,33 @@ If you are using a virtual environment, activate it before running "vercel dev",
     }
     const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
     env.PORT = `${port}`;
-    const devShimModule = createDevShim(workPath, modulePath);
-    if (devShimModule) {
+    const devShim = createDevShim(workPath, entry, modulePath);
+    if (devShim) {
       const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
+      const pathParts = [vercelPythonDir];
+      if (devShim.extraPythonPath) {
+        pathParts.push(devShim.extraPythonPath);
+      }
       const existingPythonPath = env.PYTHONPATH || "";
-      env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
+      if (existingPythonPath) {
+        pathParts.push(existingPythonPath);
+      }
+      env.PYTHONPATH = pathParts.join(import_path7.delimiter);
     }
-    const moduleToRun = devShimModule || modulePath;
+    const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
     (0, import_build_utils8.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
+    if (process.stdout.columns) {
+      env.COLUMNS = `${process.stdout.columns}`;
+    }
     const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
       cwd: workPath,
       env,
-      stdio: ["inherit", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
     });
     childProcess = child;
     stdoutLogListener = createLogListener(onStdout, process.stdout);
@@ -4811,9 +4880,399 @@ If you are using a virtual environment, activate it before running "vercel dev",
   }
 };
 
+// src/quirks/index.ts
+var import_build_utils10 = require("@vercel/build-utils");
+var import_python_analysis5 = require("@vercel/python-analysis");
+
+// src/quirks/prisma.ts
+var import_fs6 = __toESM(require("fs"));
+var import_path8 = require("path");
+var import_execa4 = __toESM(require_execa());
+var import_build_utils9 = require("@vercel/build-utils");
+var import_python_analysis4 = require("@vercel/python-analysis");
+function execErrorMessage(err) {
+  if (err != null && typeof err === "object" && "stderr" in err) {
+    const stderr = String(err.stderr);
+    if (stderr)
+      return stderr;
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+var DUMMY_SCHEMA_NAME = "_prisma_dummy.prisma";
+var LAMBDA_ROOT = "/var/task";
+var RUNTIME_OPENSSL_VERSION = "3.2";
+function getLambdaBinaryTarget() {
+  return process.arch === "arm64" ? "linux-arm64-openssl-3.0.x" : "rhel-openssl-3.0.x";
+}
+function buildDummySchema(generatedDir) {
+  const lambdaTarget = getLambdaBinaryTarget();
+  return `datasource db {
+  provider = "sqlite"
+  url      = "file:dev.db"
+}
+
+generator client {
+  provider      = "prisma-client-py"
+  binaryTargets = ["native", "${lambdaTarget}"]
+  output        = "${generatedDir}"
+}
+
+model DummyModel {
+  id Int @id
+}
+`;
+}
+async function findUserSchema(workPath) {
+  const envPath = process.env.PRISMA_SCHEMA_PATH;
+  if (envPath) {
+    const resolved = (0, import_path8.isAbsolute)(envPath) ? envPath : (0, import_path8.join)(workPath, envPath);
+    try {
+      await import_fs6.default.promises.access(resolved);
+      return resolved;
+    } catch {
+      (0, import_build_utils9.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      return null;
+    }
+  }
+  const candidates = [
+    (0, import_path8.join)(workPath, "schema.prisma"),
+    (0, import_path8.join)(workPath, "prisma", "schema.prisma")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await import_fs6.default.promises.access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+async function collectFiles(dir, base) {
+  const result = [];
+  let entries;
+  try {
+    entries = await import_fs6.default.promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  for (const entry of entries) {
+    if (entry.name === "__pycache__")
+      continue;
+    const full = (0, import_path8.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      result.push(...await collectFiles(full, base));
+    } else {
+      result.push((0, import_path8.relative)(base, full));
+    }
+  }
+  return result;
+}
+async function cleanCacheArtifacts(cacheDir, extras = []) {
+  const paths = [
+    (0, import_path8.join)(cacheDir, "node_modules"),
+    (0, import_path8.join)(cacheDir, "package.json"),
+    (0, import_path8.join)(cacheDir, "package-lock.json"),
+    ...extras
+  ];
+  for (const p of paths) {
+    try {
+      await import_fs6.default.promises.rm(p, { recursive: true, force: true });
+    } catch (err) {
+      console.warn(
+        `could not clean up ${p}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+async function isClientGenerated(pythonPath, env) {
+  try {
+    await (0, import_execa4.default)(pythonPath, ["-c", "import prisma.client"], {
+      env,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var prismaQuirk = {
+  dependency: "prisma",
+  async run(ctx) {
+    const { venvPath, pythonEnv, workPath } = ctx;
+    const pythonPath = getVenvPythonBin(venvPath);
+    const runtimeCacheDir = (0, import_path8.join)(
+      LAMBDA_ROOT,
+      resolveVendorDir(),
+      "prisma",
+      "__bincache__"
+    );
+    const sitePackagesDirs = await getVenvSitePackagesDirs(venvPath);
+    let sitePackages;
+    for (const dir of sitePackagesDirs) {
+      try {
+        await import_fs6.default.promises.access((0, import_path8.join)(dir, "prisma"));
+        sitePackages = dir;
+        break;
+      } catch {
+      }
+    }
+    if (!sitePackages) {
+      console.warn(
+        "prisma: could not find prisma in any site-packages directory"
+      );
+      return {};
+    }
+    const cacheDir = (0, import_path8.join)(sitePackages, "prisma", "__bincache__");
+    await import_fs6.default.promises.mkdir(cacheDir, { recursive: true });
+    const generateEnv = {
+      ...pythonEnv,
+      PRISMA_BINARY_CACHE_DIR: cacheDir
+    };
+    const generatedDir = (0, import_path8.join)(workPath, "_prisma_generated");
+    const dummySchemaPath = (0, import_path8.join)(workPath, DUMMY_SCHEMA_NAME);
+    await import_fs6.default.promises.writeFile(
+      dummySchemaPath,
+      buildDummySchema(generatedDir)
+    );
+    (0, import_build_utils9.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    try {
+      const dummyResult = await (0, import_execa4.default)(
+        pythonPath,
+        ["-m", "prisma", "generate", `--schema=${dummySchemaPath}`],
+        {
+          cwd: workPath,
+          env: generateEnv,
+          stdio: "pipe"
+        }
+      );
+      if (dummyResult.stdout)
+        (0, import_build_utils9.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+      if (dummyResult.stderr)
+        (0, import_build_utils9.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+    } catch (err) {
+      throw new import_build_utils9.NowBuildError({
+        code: "PRISMA_GENERATE_FAILED",
+        message: `Prisma engine download failed during \`prisma generate\`. Check that your prisma version is compatible with this Python version.
+` + execErrorMessage(err)
+      });
+    }
+    const srcBinaryPrefix = `query-engine-${getLambdaBinaryTarget()}`;
+    const runtimeName = `prisma-query-engine-rhel-openssl-${RUNTIME_OPENSSL_VERSION}.x`;
+    const nodeModulesDir = (0, import_path8.join)(cacheDir, "node_modules", "prisma");
+    let engineCopied = false;
+    try {
+      const entries = await import_fs6.default.promises.readdir(nodeModulesDir);
+      for (const entry of entries) {
+        if (!entry.startsWith(srcBinaryPrefix))
+          continue;
+        const srcPath = (0, import_path8.join)(nodeModulesDir, entry);
+        const destPath = (0, import_path8.join)(cacheDir, runtimeName);
+        try {
+          await import_fs6.default.promises.access(destPath);
+          (0, import_build_utils9.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+        } catch {
+          (0, import_build_utils9.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          await import_fs6.default.promises.copyFile(srcPath, destPath);
+        }
+        engineCopied = true;
+      }
+    } catch (err) {
+      throw new import_build_utils9.NowBuildError({
+        code: "PRISMA_ENGINE_NOT_FOUND",
+        message: `could not read Prisma engine directory "${nodeModulesDir}". This may indicate an incompatible prisma version.
+` + (err instanceof Error ? err.message : String(err))
+      });
+    }
+    if (!engineCopied) {
+      throw new import_build_utils9.NowBuildError({
+        code: "PRISMA_ENGINE_NOT_FOUND",
+        message: `could not find engine binary matching "${srcBinaryPrefix}*" in "${nodeModulesDir}". This may indicate an incompatible prisma version or an unsupported platform (${process.arch}).`
+      });
+    }
+    const shimPath = (0, import_path8.join)(cacheDir, "openssl");
+    await import_fs6.default.promises.writeFile(
+      shimPath,
+      `#!/bin/sh
+echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIME_OPENSSL_VERSION}.0)"
+`
+    );
+    await import_fs6.default.promises.chmod(shimPath, 493);
+    for (const p of [generatedDir, dummySchemaPath]) {
+      await import_fs6.default.promises.rm(p, { recursive: true, force: true });
+    }
+    await cleanCacheArtifacts(cacheDir);
+    const generateMode = (process.env.VERCEL_PRISMA_GENERATE_CLIENT ?? "auto").toLowerCase();
+    const userSchema = generateMode !== "never" ? await findUserSchema(workPath) : null;
+    if (userSchema) {
+      let shouldGenerate = true;
+      if (generateMode === "auto") {
+        const clientAlreadyGenerated = await isClientGenerated(
+          pythonPath,
+          pythonEnv
+        );
+        if (clientAlreadyGenerated) {
+          (0, import_build_utils9.debug)(
+            "Prisma quirk: client already generated, skipping user schema generate"
+          );
+          shouldGenerate = false;
+        }
+      }
+      if (shouldGenerate) {
+        (0, import_build_utils9.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        try {
+          const userResult = await (0, import_execa4.default)(
+            pythonPath,
+            ["-m", "prisma", "generate", `--schema=${userSchema}`],
+            {
+              cwd: workPath,
+              env: generateEnv,
+              stdio: "pipe"
+            }
+          );
+          if (userResult.stdout)
+            (0, import_build_utils9.debug)(`prisma generate stdout: ${userResult.stdout}`);
+          if (userResult.stderr)
+            (0, import_build_utils9.debug)(`prisma generate stderr: ${userResult.stderr}`);
+        } catch (err) {
+          throw new import_build_utils9.NowBuildError({
+            code: "PRISMA_GENERATE_FAILED",
+            message: `\`prisma generate\` failed for schema "${userSchema}".
+` + execErrorMessage(err)
+          });
+        }
+        await cleanCacheArtifacts(cacheDir);
+      }
+    }
+    try {
+      const allFiles = await collectFiles(
+        (0, import_path8.join)(sitePackages, "prisma"),
+        sitePackages
+      );
+      const count = await (0, import_python_analysis4.extendDistRecord)(sitePackages, "prisma", allFiles);
+      if (count > 0) {
+        (0, import_build_utils9.debug)(`Appended ${count} entries to prisma RECORD`);
+      }
+    } catch (err) {
+      console.warn(
+        `could not patch prisma RECORD: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    return {
+      env: {
+        PRISMA_BINARY_CACHE_DIR: runtimeCacheDir,
+        VERCEL_RUNTIME_ENV_PATH_PREPEND: runtimeCacheDir
+      },
+      buildEnv: { PRISMA_BINARY_CACHE_DIR: cacheDir },
+      alwaysBundlePackages: ["prisma"]
+    };
+  }
+};
+
+// src/quirks/index.ts
+var quirks = [prismaQuirk];
+function toposortQuirks(activated) {
+  const nameToQuirk = /* @__PURE__ */ new Map();
+  for (const q of activated) {
+    nameToQuirk.set((0, import_python_analysis5.normalizePackageName)(q.dependency), q);
+  }
+  const adj = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const q of activated) {
+    adj.set(q, /* @__PURE__ */ new Set());
+    inDegree.set(q, 0);
+  }
+  for (const q of activated) {
+    if (q.runsBefore) {
+      for (const dep of q.runsBefore) {
+        const target = nameToQuirk.get((0, import_python_analysis5.normalizePackageName)(dep));
+        if (target) {
+          adj.get(q).add(target);
+          inDegree.set(target, inDegree.get(target) + 1);
+        }
+      }
+    }
+    if (q.runsAfter) {
+      for (const dep of q.runsAfter) {
+        const source = nameToQuirk.get((0, import_python_analysis5.normalizePackageName)(dep));
+        if (source) {
+          adj.get(source).add(q);
+          inDegree.set(q, inDegree.get(q) + 1);
+        }
+      }
+    }
+  }
+  const queue = [];
+  for (const q of activated) {
+    if (inDegree.get(q) === 0) {
+      queue.push(q);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const q = queue.shift();
+    sorted.push(q);
+    for (const neighbor of adj.get(q)) {
+      const deg = inDegree.get(neighbor) - 1;
+      inDegree.set(neighbor, deg);
+      if (deg === 0) {
+        queue.push(neighbor);
+      }
+    }
+  }
+  if (sorted.length !== activated.length) {
+    const unsorted = activated.filter((q) => !sorted.includes(q)).map((q) => q.dependency);
+    throw new Error(
+      `Circular dependency detected among quirks: ${unsorted.join(", ")}`
+    );
+  }
+  return sorted;
+}
+async function runQuirks(ctx) {
+  const mergedEnv = {};
+  const mergedBuildEnv = {};
+  const mergedAlwaysBundle = [];
+  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);
+    for (const name of distributions.keys()) {
+      installedNames.add((0, import_python_analysis5.normalizePackageName)(name));
+    }
+  }
+  const activated = quirks.filter((quirk) => {
+    const installed = installedNames.has(
+      (0, import_python_analysis5.normalizePackageName)(quirk.dependency)
+    );
+    if (!installed) {
+      (0, import_build_utils10.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+    }
+    return installed;
+  });
+  const sorted = toposortQuirks(activated);
+  for (const quirk of sorted) {
+    (0, import_build_utils10.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    const result = await quirk.run(ctx);
+    if (result.env) {
+      Object.assign(mergedEnv, result.env);
+    }
+    if (result.buildEnv) {
+      Object.assign(mergedBuildEnv, result.buildEnv);
+      Object.assign(process.env, result.buildEnv);
+    }
+    if (result.alwaysBundlePackages) {
+      mergedAlwaysBundle.push(...result.alwaysBundlePackages);
+    }
+  }
+  return {
+    env: mergedEnv,
+    buildEnv: mergedBuildEnv,
+    alwaysBundlePackages: mergedAlwaysBundle
+  };
+}
+
 // src/index.ts
-var readFile2 = (0, import_util2.promisify)(import_fs6.default.readFile);
-var writeFile = (0, import_util2.promisify)(import_fs6.default.writeFile);
+var readFile2 = (0, import_util2.promisify)(import_fs7.default.readFile);
+var writeFile = (0, import_util2.promisify)(import_fs7.default.writeFile);
 var version = 3;
 async function downloadFilesInWorkPath({
   entrypoint,
@@ -4821,13 +5280,13 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils9.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils9.download)(files, workPath, meta);
+  (0, import_build_utils11.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils11.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path8.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path8.join)(devCacheDir, (0, import_path8.basename)(entrypoint, ".py"));
-    await (0, import_build_utils9.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils9.glob)("**", destCache);
+    const { devCacheDir = (0, import_path9.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path9.join)(devCacheDir, (0, import_path9.basename)(entrypoint, ".py"));
+    await (0, import_build_utils11.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils11.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -4844,7 +5303,7 @@ var build = async ({
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils9.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils11.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -4853,72 +5312,28 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path8.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path9.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  if ((0, import_build_utils9.isPythonFramework)(framework)) {
-    const {
-      cliType,
-      lockfileVersion,
-      packageJsonPackageManager,
-      turboSupportsCorepackHome
-    } = await (0, import_build_utils9.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils9.getEnvForPackageManager)({
-      cliType,
-      lockfileVersion,
-      packageJsonPackageManager,
-      env: process.env,
-      turboSupportsCorepackHome,
-      projectCreatedAt: config?.projectSettings?.createdAt
-    });
-    const installCommand = config?.projectSettings?.installCommand;
-    if (typeof installCommand === "string") {
-      const trimmed = installCommand.trim();
-      if (trimmed) {
-        projectInstallCommand = trimmed;
-      } else {
-        console.log('Skipping "install" command...');
-      }
-    }
-    const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
-    config?.buildCommand;
-    if (projectBuildCommand) {
-      console.log(`Running "${projectBuildCommand}"`);
-      await (0, import_build_utils9.execCommand)(projectBuildCommand, {
-        env: spawnEnv,
-        cwd: workPath
-      });
-      hasCustomCommand = true;
-    } else {
-      const ranBuildScript = await runPyprojectScript(
-        workPath,
-        ["vercel-build", "now-build", "build"],
-        spawnEnv
-      );
-      if (ranBuildScript) {
-        hasCustomCommand = true;
-      }
-    }
-  }
-  let fsFiles = await (0, import_build_utils9.glob)("**", workPath);
-  if ((0, import_build_utils9.isPythonFramework)(framework) && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
+  let fsFiles = await (0, import_build_utils11.glob)("**", workPath);
+  if ((0, import_build_utils11.isPythonFramework)(framework) && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
     const detected = await detectPythonEntrypoint(
       config.framework,
       workPath,
       entrypoint
     );
     if (detected) {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils11.debug)(
         `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected;
     } else {
       const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils9.NowBuildError({
+      throw new import_build_utils11.NowBuildError({
         code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
         message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searchedList}.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -4926,7 +5341,7 @@ var build = async ({
       });
     }
   }
-  const entryDirectory = (0, import_path8.dirname)(entrypoint);
+  const entryDirectory = (0, import_path9.dirname)(entrypoint);
   const pyprojectDir = findDir({
     file: "pyproject.toml",
     entryDirectory,
@@ -4949,37 +5364,37 @@ var build = async ({
   if (pythonVersionFileDir) {
     try {
       const content = await readFile2(
-        (0, import_path8.join)(pythonVersionFileDir, ".python-version"),
+        (0, import_path9.join)(pythonVersionFileDir, ".python-version"),
         "utf8"
       );
       const version2 = parsePythonVersionFile(content);
       if (version2) {
         declaredPythonVersion = { version: version2, source: ".python-version" };
-        (0, import_build_utils9.debug)(`Found Python version ${version2} in .python-version`);
+        (0, import_build_utils11.debug)(`Found Python version ${version2} in .python-version`);
       }
     } catch (err) {
-      (0, import_build_utils9.debug)("Failed to read .python-version file", err);
+      (0, import_build_utils11.debug)("Failed to read .python-version file", err);
     }
   }
   if (!declaredPythonVersion && pyprojectDir) {
     let requiresPython;
     try {
-      const pyproject = await (0, import_build_utils10.readConfigFile)((0, import_path8.join)(pyprojectDir, "pyproject.toml"));
+      const pyproject = await (0, import_build_utils12.readConfigFile)((0, import_path9.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
     } catch (err) {
-      (0, import_build_utils9.debug)("Failed to parse pyproject.toml", err);
+      (0, import_build_utils11.debug)("Failed to parse pyproject.toml", err);
     }
     if (typeof requiresPython === "string" && requiresPython.trim()) {
       declaredPythonVersion = {
         version: requiresPython.trim(),
         source: "pyproject.toml"
       };
-      (0, import_build_utils9.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
+      (0, import_build_utils11.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
     }
   }
   if (!declaredPythonVersion && pipfileLockDir) {
     let lock = {};
-    const pipfileLockPath = (0, import_path8.join)(pipfileLockDir, "Pipfile.lock");
+    const pipfileLockPath = (0, import_path9.join)(pipfileLockDir, "Pipfile.lock");
     try {
       const pipfileLockContent = await readFile2(pipfileLockPath, "utf8");
       try {
@@ -4992,7 +5407,7 @@ ${pipfileLockContent}`
         throw err;
       }
     } catch (err) {
-      throw new import_build_utils9.NowBuildError({
+      throw new import_build_utils11.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",
         message: "Unable to parse Pipfile.lock"
       });
@@ -5000,7 +5415,7 @@ ${pipfileLockContent}`
     const pyFromLock = lock?._meta?.requires?.python_version;
     if (pyFromLock) {
       declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils9.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      (0, import_build_utils11.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
     }
   }
   const pythonVersion = getSupportedPythonVersion({
@@ -5010,26 +5425,51 @@ ${pipfileLockContent}`
   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_path8.join)(pyprojectDir, ".python-version");
+    const pythonVersionFilePath = (0, import_path9.join)(pyprojectDir, ".python-version");
     await writeFile(pythonVersionFilePath, `${pythonVersion.version}
 `);
     console.log(
       `Writing .python-version file with version ${pythonVersion.version}`
     );
   }
-  fsFiles = await (0, import_build_utils9.glob)("**", workPath);
-  const venvPath = (0, import_path8.join)(workPath, ".vercel", "python", ".venv");
+  fsFiles = await (0, import_build_utils11.glob)("**", workPath);
+  const venvPath = (0, import_path9.join)(workPath, ".vercel", "python", ".venv");
   await ensureVenv({
     pythonPath: pythonVersion.pythonPath,
     venvPath
   });
+  if ((0, import_build_utils11.isPythonFramework)(framework)) {
+    const {
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      turboSupportsCorepackHome
+    } = await (0, import_build_utils11.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils11.getEnvForPackageManager)({
+      cliType,
+      lockfileVersion,
+      packageJsonPackageManager,
+      env: process.env,
+      turboSupportsCorepackHome,
+      projectCreatedAt: config?.projectSettings?.createdAt
+    });
+    const installCommand = config?.projectSettings?.installCommand;
+    if (typeof installCommand === "string") {
+      const trimmed = installCommand.trim();
+      if (trimmed) {
+        projectInstallCommand = trimmed;
+      } else {
+        console.log('Skipping "install" command...');
+      }
+    }
+  }
   const baseEnv = spawnEnv || process.env;
   const pythonEnv = createVenvEnv(venvPath, baseEnv);
   pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
   let assumeDepsInstalled = false;
   if (projectInstallCommand) {
     console.log(`Running "install" command: \`${projectInstallCommand}\`...`);
-    await (0, import_build_utils9.execCommand)(projectInstallCommand, {
+    await (0, import_build_utils11.execCommand)(projectInstallCommand, {
       env: pythonEnv,
       cwd: workPath
     });
@@ -5090,7 +5530,7 @@ ${pipfileLockContent}`
         });
       } catch (err) {
         noBuildCheckFailed = true;
-        (0, import_build_utils9.debug)(
+        (0, import_build_utils11.debug)(
           `--no-build check failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
@@ -5102,19 +5542,40 @@ ${pipfileLockContent}`
       locked: !lockFileProvidedByUser
     });
   }
+  if ((0, import_build_utils11.isPythonFramework)(framework)) {
+    const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
+    config?.buildCommand;
+    if (projectBuildCommand) {
+      console.log(`Running "${projectBuildCommand}"`);
+      await (0, import_build_utils11.execCommand)(projectBuildCommand, {
+        env: pythonEnv,
+        cwd: workPath
+      });
+    } else {
+      await runPyprojectScript(
+        workPath,
+        ["vercel-build", "now-build", "build"],
+        pythonEnv
+      );
+    }
+  }
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils9.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils11.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
-    projectDir: (0, import_path8.join)(workPath, entryDirectory),
+    projectDir: (0, import_path9.join)(workPath, entryDirectory),
     args: ["install", runtimeDep]
   });
-  (0, import_build_utils9.debug)("Entrypoint is", entrypoint);
+  const quirksResult = await runQuirks({ venvPath, pythonEnv, workPath });
+  if (quirksResult.buildEnv) {
+    Object.assign(pythonEnv, quirksResult.buildEnv);
+  }
+  (0, import_build_utils11.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils9.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils11.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const runtimeTrampoline = `
 import importlib
 import os
@@ -5173,11 +5634,12 @@ from vercel_runtime.vc_init import vc_handler
   ];
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
+  Object.assign(lambdaEnv, quirksResult.env);
   const globOptions = {
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils9.glob)("**", globOptions);
+  const files = await (0, import_build_utils11.glob)("**", globOptions);
   const depExternalizer = new PythonDependencyExternalizer({
     venvPath,
     vendorDir,
@@ -5187,7 +5649,8 @@ from vercel_runtime.vc_init import vc_handler
     projectName,
     noBuildCheckFailed,
     pythonPath: pythonVersion.pythonPath,
-    hasCustomCommand
+    hasCustomCommand,
+    alwaysBundlePackages: quirksResult.alwaysBundlePackages
   });
   const { runtimeInstallEnabled, allVendorFiles } = await depExternalizer.analyze(files);
   if (runtimeInstallEnabled) {
@@ -5198,12 +5661,12 @@ from vercel_runtime.vc_init import vc_handler
     }
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils9.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils11.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils9.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils11.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils9.Lambda({
+  const output = new import_build_utils11.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -5214,7 +5677,7 @@ from vercel_runtime.vc_init import vc_handler
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils9.isPythonFramework)(framework)) {
+  if ((0, import_build_utils11.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;
@@ -5233,7 +5696,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path8.parse)(entrypoint);
+  const { dir, name } = (0, import_path9.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }