@vercel/python 6.23.0 → 6.25.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 fs10 = require("fs");
+    var fs11 = 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) {
-      fs10.stat(path, function(er, stat) {
+      fs11.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs10.statSync(path), path, options);
+      return checkStat(fs11.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 fs10 = require("fs");
+    var fs11 = require("fs");
     function isexe(path, options, cb) {
-      fs10.stat(path, function(er, stat) {
+      fs11.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs10.statSync(path), options);
+      return checkStat(fs11.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 fs10 = require("fs");
+    var fs11 = 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 fs10 = require("fs");
+    var fs11 = 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 = fs10.openSync(command, "r");
-        fs10.readSync(fd, buffer, 0, size, 0);
-        fs10.closeSync(fd);
+        fd = fs11.openSync(command, "r");
+        fs11.readSync(fd, buffer, 0, size, 0);
+        fs11.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 debug11;
+    var debug12;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug11 = function() {
+      debug12 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug11 = function() {
+      debug12 = 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++) {
-      debug11(i, src[i]);
+      debug12(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);
       }
-      debug11("SemVer", version2, options);
+      debug12("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) {
-      debug11("SemVer.compare", this.version, this.options, other);
+      debug12("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];
-        debug11("prerelease compare", i2, a, b);
+        debug12("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(" ");
-      debug11("comparator", comp, options);
+      debug12("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;
       }
-      debug11("comp", this);
+      debug12("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) {
-      debug11("Comparator.test", version2, this.options.loose);
+      debug12("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);
-      debug11("hyphen replace", range);
+      debug12("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug11("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug12("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) {
-      debug11("comp", comp, options);
+      debug12("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug11("caret", comp);
+      debug12("caret", comp);
       comp = replaceTildes(comp, options);
-      debug11("tildes", comp);
+      debug12("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug11("xrange", comp);
+      debug12("xrange", comp);
       comp = replaceStars(comp, options);
-      debug11("stars", comp);
+      debug12("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) {
-        debug11("tilde", comp, _, M, m, p, pr);
+        debug12("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) {
-          debug11("replaceTilde pr", pr);
+          debug12("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug11("tilde return", ret);
+        debug12("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug11("caret", comp, options);
+      debug12("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug11("caret", comp, _, M, m, p, pr);
+        debug12("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) {
-          debug11("replaceCaret pr", pr);
+          debug12("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 {
-          debug11("no pr");
+          debug12("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";
           }
         }
-        debug11("caret return", ret);
+        debug12("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug11("replaceXRanges", comp, options);
+      debug12("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) {
-        debug11("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug12("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";
         }
-        debug11("xRange return", ret);
+        debug12("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug11("replaceStars", comp, options);
+      debug12("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++) {
-          debug11(set[i2].semver);
+          debug12(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 fs10;
+    var fs11;
     try {
-      fs10 = require("fs");
+      fs11 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs10)
+      if (!fs11)
         return false;
-      return (stream instanceof (fs10.ReadStream || noop) || stream instanceof (fs10.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs11.ReadStream || noop) || stream instanceof (fs11.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2647,11 +2647,365 @@ ${stderr}${stdout}`;
   }
 });
 
+// ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js
+var require_process = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js"(exports, module2) {
+    "use strict";
+    var isLinux = () => process.platform === "linux";
+    var report = null;
+    var getReport = () => {
+      if (!report) {
+        if (isLinux() && process.report) {
+          const orig = process.report.excludeNetwork;
+          process.report.excludeNetwork = true;
+          report = process.report.getReport();
+          process.report.excludeNetwork = orig;
+        } else {
+          report = {};
+        }
+      }
+      return report;
+    };
+    module2.exports = { isLinux, getReport };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js"(exports, module2) {
+    "use strict";
+    var fs11 = require("fs");
+    var LDD_PATH = "/usr/bin/ldd";
+    var SELF_PATH = "/proc/self/exe";
+    var MAX_LENGTH = 2048;
+    var readFileSync2 = (path) => {
+      const fd = fs11.openSync(path, "r");
+      const buffer = Buffer.alloc(MAX_LENGTH);
+      const bytesRead = fs11.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs11.close(fd, () => {
+      });
+      return buffer.subarray(0, bytesRead);
+    };
+    var readFile2 = (path) => new Promise((resolve3, reject) => {
+      fs11.open(path, "r", (err, fd) => {
+        if (err) {
+          reject(err);
+        } else {
+          const buffer = Buffer.alloc(MAX_LENGTH);
+          fs11.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+            resolve3(buffer.subarray(0, bytesRead));
+            fs11.close(fd, () => {
+            });
+          });
+        }
+      });
+    });
+    module2.exports = {
+      LDD_PATH,
+      SELF_PATH,
+      readFileSync: readFileSync2,
+      readFile: readFile2
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/elf.js
+var require_elf = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/elf.js"(exports, module2) {
+    "use strict";
+    var interpreterPath = (elf) => {
+      if (elf.length < 64) {
+        return null;
+      }
+      if (elf.readUInt32BE(0) !== 2135247942) {
+        return null;
+      }
+      if (elf.readUInt8(4) !== 2) {
+        return null;
+      }
+      if (elf.readUInt8(5) !== 1) {
+        return null;
+      }
+      const offset = elf.readUInt32LE(32);
+      const size = elf.readUInt16LE(54);
+      const count = elf.readUInt16LE(56);
+      for (let i = 0; i < count; i++) {
+        const headerOffset = offset + i * size;
+        const type = elf.readUInt32LE(headerOffset);
+        if (type === 3) {
+          const fileOffset = elf.readUInt32LE(headerOffset + 8);
+          const fileSize = elf.readUInt32LE(headerOffset + 32);
+          return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
+        }
+      }
+      return null;
+    };
+    module2.exports = {
+      interpreterPath
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS({
+  "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/detect-libc.js"(exports, module2) {
+    "use strict";
+    var childProcess = require("child_process");
+    var { isLinux, getReport } = require_process();
+    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync2 } = require_filesystem();
+    var { interpreterPath } = require_elf();
+    var cachedFamilyInterpreter;
+    var cachedFamilyFilesystem;
+    var cachedVersionFilesystem;
+    var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+    var commandOut = "";
+    var safeCommand = () => {
+      if (!commandOut) {
+        return new Promise((resolve3) => {
+          childProcess.exec(command, (err, out) => {
+            commandOut = err ? " " : out;
+            resolve3(commandOut);
+          });
+        });
+      }
+      return commandOut;
+    };
+    var safeCommandSync = () => {
+      if (!commandOut) {
+        try {
+          commandOut = childProcess.execSync(command, { encoding: "utf8" });
+        } catch (_err) {
+          commandOut = " ";
+        }
+      }
+      return commandOut;
+    };
+    var GLIBC2 = "glibc";
+    var RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
+    var MUSL2 = "musl";
+    var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+    var familyFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return GLIBC2;
+      }
+      if (Array.isArray(report.sharedObjects)) {
+        if (report.sharedObjects.some(isFileMusl)) {
+          return MUSL2;
+        }
+      }
+      return null;
+    };
+    var familyFromCommand = (out) => {
+      const [getconf, ldd1] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC2)) {
+        return GLIBC2;
+      }
+      if (ldd1 && ldd1.includes(MUSL2)) {
+        return MUSL2;
+      }
+      return null;
+    };
+    var familyFromInterpreterPath = (path) => {
+      if (path) {
+        if (path.includes("/ld-musl-")) {
+          return MUSL2;
+        } else if (path.includes("/ld-linux-")) {
+          return GLIBC2;
+        }
+      }
+      return null;
+    };
+    var getFamilyFromLddContent = (content) => {
+      content = content.toString();
+      if (content.includes("musl")) {
+        return MUSL2;
+      }
+      if (content.includes("GNU C Library")) {
+        return GLIBC2;
+      }
+      return null;
+    };
+    var familyFromFilesystem = async () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = await readFile2(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var familyFromFilesystemSync = () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = readFileSync2(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var familyFromInterpreter = async () => {
+      if (cachedFamilyInterpreter !== void 0) {
+        return cachedFamilyInterpreter;
+      }
+      cachedFamilyInterpreter = null;
+      try {
+        const selfContent = await readFile2(SELF_PATH);
+        const path = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path);
+      } catch (e) {
+      }
+      return cachedFamilyInterpreter;
+    };
+    var familyFromInterpreterSync = () => {
+      if (cachedFamilyInterpreter !== void 0) {
+        return cachedFamilyInterpreter;
+      }
+      cachedFamilyInterpreter = null;
+      try {
+        const selfContent = readFileSync2(SELF_PATH);
+        const path = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path);
+      } catch (e) {
+      }
+      return cachedFamilyInterpreter;
+    };
+    var family = async () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = await familyFromInterpreter();
+        if (!family2) {
+          family2 = await familyFromFilesystem();
+          if (!family2) {
+            family2 = familyFromReport();
+          }
+          if (!family2) {
+            const out = await safeCommand();
+            family2 = familyFromCommand(out);
+          }
+        }
+      }
+      return family2;
+    };
+    var familySync2 = () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = familyFromInterpreterSync();
+        if (!family2) {
+          family2 = familyFromFilesystemSync();
+          if (!family2) {
+            family2 = familyFromReport();
+          }
+          if (!family2) {
+            const out = safeCommandSync();
+            family2 = familyFromCommand(out);
+          }
+        }
+      }
+      return family2;
+    };
+    var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC2;
+    var isNonGlibcLinuxSync = () => isLinux() && familySync2() !== GLIBC2;
+    var versionFromFilesystem = async () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = await readFile2(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromFilesystemSync = () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = readFileSync2(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return report.header.glibcVersionRuntime;
+      }
+      return null;
+    };
+    var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+    var versionFromCommand = (out) => {
+      const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC2)) {
+        return versionSuffix(getconf);
+      }
+      if (ldd1 && ldd2 && ldd1.includes(MUSL2)) {
+        return versionSuffix(ldd2);
+      }
+      return null;
+    };
+    var version2 = async () => {
+      let version3 = null;
+      if (isLinux()) {
+        version3 = await versionFromFilesystem();
+        if (!version3) {
+          version3 = versionFromReport();
+        }
+        if (!version3) {
+          const out = await safeCommand();
+          version3 = versionFromCommand(out);
+        }
+      }
+      return version3;
+    };
+    var versionSync2 = () => {
+      let version3 = null;
+      if (isLinux()) {
+        version3 = versionFromFilesystemSync();
+        if (!version3) {
+          version3 = versionFromReport();
+        }
+        if (!version3) {
+          const out = safeCommandSync();
+          version3 = versionFromCommand(out);
+        }
+      }
+      return version3;
+    };
+    module2.exports = {
+      GLIBC: GLIBC2,
+      MUSL: MUSL2,
+      family,
+      familySync: familySync2,
+      isNonGlibcLinux,
+      isNonGlibcLinuxSync,
+      version: version2,
+      versionSync: versionSync2
+    };
+  }
+});
+
 // ../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js
 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: join12, delimiter: delimiter2, sep: sep2, posix } = require("path");
+    var { join: join13, 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 +3034,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 + join12(pathPart, cmd);
+      return prefix + join13(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2859,6 +3213,7 @@ var src_exports = {};
 __export(src_exports, {
   build: () => build,
   defaultShouldServe: () => defaultShouldServe,
+  diagnostics: () => diagnostics,
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
@@ -2868,15 +3223,15 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_fs10 = __toESM(require("fs"));
-var import_path12 = require("path");
+var import_fs11 = __toESM(require("fs"));
+var import_path13 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.7.0";
-var VERCEL_WORKERS_VERSION = "0.0.12";
+var VERCEL_RUNTIME_VERSION = "0.10.0";
+var VERCEL_WORKERS_VERSION = "0.0.13";
 
 // src/index.ts
-var import_build_utils13 = require("@vercel/build-utils");
+var import_build_utils14 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -2887,8 +3242,10 @@ var import_python_analysis2 = require("@vercel/python-analysis");
 
 // src/utils.ts
 var import_fs2 = __toESM(require("fs"));
+var import_os2 = __toESM(require("os"));
 var import_path3 = require("path");
 var import_build_utils2 = require("@vercel/build-utils");
+var detectLibc = __toESM(require_detect_libc());
 var import_execa2 = __toESM(require_execa());
 
 // src/uv.ts
@@ -3269,6 +3626,41 @@ async function runPyprojectScript(workPath, scriptNames, env, useUserVirtualEnv
   }
   return false;
 }
+var ARCH_MAP = {
+  x64: "x86_64",
+  arm64: "aarch64",
+  ia32: "i686",
+  arm: "armv7l",
+  ppc64: "ppc64le",
+  s390x: "s390x"
+};
+function detectPlatform() {
+  const arch = import_os2.default.arch();
+  const archName = ARCH_MAP[arch] || arch;
+  const libcFamily = detectLibc.familySync();
+  const libcVersion = detectLibc.versionSync();
+  let osName;
+  let osMajor;
+  let osMinor;
+  if (libcFamily === detectLibc.MUSL) {
+    osName = "musllinux";
+  } else {
+    osName = "manylinux";
+  }
+  if (libcVersion) {
+    const parts = libcVersion.split(".");
+    osMajor = parseInt(parts[0], 10);
+    osMinor = parseInt(parts[1], 10) || 0;
+  } else if (libcFamily === detectLibc.GLIBC) {
+    osMajor = 2;
+    osMinor = 17;
+  } else {
+    osMajor = 2;
+    osMinor = 17;
+  }
+  const libc = libcFamily === detectLibc.MUSL ? "musl" : "gnu";
+  return { osName, archName, osMajor, osMinor, os: "linux", libc };
+}
 
 // src/version.ts
 var import_path4 = require("path");
@@ -3340,13 +3732,14 @@ function versionLessOrEqual(a, b) {
   return a.minor <= b.minor;
 }
 function toPythonBuild(opt) {
+  const platform = detectPlatform();
   return {
     version: { major: opt.major, minor: opt.minor },
     implementation: "cpython",
     variant: "default",
-    os: "linux",
-    architecture: "x86_64",
-    libc: "gnu"
+    os: platform.os,
+    architecture: platform.archName,
+    libc: platform.libc
   };
 }
 function getAvailablePythonBuilds() {
@@ -3817,8 +4210,7 @@ var import_path6 = require("path");
 var import_build_utils5 = require("@vercel/build-utils");
 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 = 240 * 1024 * 1024;
+var LAMBDA_SIZE_THRESHOLD_BYTES = 245 * 1024 * 1024;
 var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
 var PythonDependencyExternalizer = class {
   constructor(options) {
@@ -3832,7 +4224,8 @@ var PythonDependencyExternalizer = class {
     this.uvLockPath = options.uvLockPath;
     this.uvProjectDir = options.uvProjectDir;
     this.projectName = options.projectName;
-    this.noBuildCheckFailed = options.noBuildCheckFailed;
+    this.pythonMajor = options.pythonMajor;
+    this.pythonMinor = options.pythonMinor;
     this.pythonPath = options.pythonPath;
     this.hasCustomCommand = options.hasCustomCommand;
     this.alwaysBundlePackages = options.alwaysBundlePackages ?? [];
@@ -3921,17 +4314,6 @@ To resolve this, either:
         action: "Learn More"
       });
     }
-    if (this.noBuildCheckFailed) {
-      throw new import_build_utils5.NowBuildError({
-        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Bundle size exceeds the Lambda limit and requires runtime dependency installation, but some packages in your uv.lock file do not have pre-built binary wheels available.
-Runtime dependency installation requires all public packages to have binary wheels.
-
-To fix this, either:
- 1. Regenerate your lock file with: uv lock --upgrade --no-build, or
- 2. Switch the problematic packages to ones that have pre-built wheels available`
-      });
-    }
     let lockContent;
     try {
       lockContent = await readFile(this.uvLockPath, "utf8");
@@ -3982,10 +4364,30 @@ ${error.fileContent}`
     (0, import_build_utils5.debug)(
       `Package classification: ${classification.privatePackages.length} private, ${classification.publicPackages.length} public`
     );
-    if (classification.publicPackages.length === 0) {
+    const forceBundledDueToWheels = await this.findPackagesWithoutCompatibleWheels(
+      lockFile,
+      classification.publicPackages
+    );
+    if (forceBundledDueToWheels.length > 0) {
+      console.log(
+        `Force-bundling ${forceBundledDueToWheels.length} package(s) without compatible wheels: ` + forceBundledDueToWheels.join(", ")
+      );
+    }
+    const forceBundledSet = new Set(
+      forceBundledDueToWheels.map(import_python_analysis3.normalizePackageName)
+    );
+    const externalizablePublic = classification.publicPackages.filter(
+      (name) => !forceBundledSet.has((0, import_python_analysis3.normalizePackageName)(name))
+    );
+    if (externalizablePublic.length === 0) {
       throw new import_build_utils5.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: "Bundle size exceeds limit but no public packages found for runtime installation."
+        message: `Bundle size exceeds the Lambda limit and requires runtime dependency installation, but no public packages have compatible pre-built wheels for the Lambda platform.
+Runtime dependency installation requires packages to have binary wheels.
+
+To fix this, either:
+ 1. Regenerate your lock file with: uv lock --upgrade, or
+ 2. Switch the problematic packages to ones that have pre-built wheels available`
       });
     }
     const packageSizes = await calculatePerPackageSizes(this.venvPath);
@@ -3993,7 +4395,8 @@ ${error.fileContent}`
       ...classification.privatePackages,
       "vercel-runtime",
       "vercel_runtime",
-      ...this.alwaysBundlePackages
+      ...this.alwaysBundlePackages,
+      ...forceBundledDueToWheels
     ];
     const alwaysBundledFiles = await mirrorPackagesIntoVendor({
       venvPath: this.venvPath,
@@ -4015,13 +4418,16 @@ ${error.fileContent}`
         runtimeToolingOverhead = 50 * 1024 * 1024;
       }
     }
-    const remainingCapacity = LAMBDA_PACKING_TARGET_BYTES - fixedOverhead - runtimeToolingOverhead;
+    const remainingCapacity = LAMBDA_SIZE_THRESHOLD_BYTES - fixedOverhead - runtimeToolingOverhead;
     (0, import_build_utils5.debug)(
       `Fixed overhead: ${(fixedOverhead / (1024 * 1024)).toFixed(2)} MB, runtime tooling: ${(runtimeToolingOverhead / (1024 * 1024)).toFixed(2)} MB, remaining capacity for public packages: ${(remainingCapacity / (1024 * 1024)).toFixed(2)} MB`
     );
+    const externalizableSet = new Set(
+      externalizablePublic.map(import_python_analysis3.normalizePackageName)
+    );
     const publicPackageSizes = new Map(
       [...packageSizes].filter(
-        ([name]) => classification.publicPackages.includes(name)
+        ([name]) => externalizableSet.has((0, import_python_analysis3.normalizePackageName)(name))
       )
     );
     const bundledPublic = lambdaKnapsack(publicPackageSizes, remainingCapacity);
@@ -4037,7 +4443,8 @@ ${error.fileContent}`
     const bundledPackagesForConfig = [
       ...classification.privatePackages,
       ...bundledPublic,
-      ...this.alwaysBundlePackages
+      ...this.alwaysBundlePackages,
+      ...forceBundledDueToWheels
     ];
     const projectDirRel = (0, import_path6.relative)(this.workPath, this.uvProjectDir);
     const uvLockRel = (0, import_path6.relative)(this.workPath, this.uvLockPath);
@@ -4092,6 +4499,60 @@ ${error.fileContent}`
       });
     }
   }
+  /**
+   * Identify public packages that have no compatible wheel for the Lambda platform.
+   * These packages must be force-bundled because `uv sync --no-build` at cold start
+   * will refuse to build from source.
+   */
+  async findPackagesWithoutCompatibleWheels(lockFile, publicPackageNames) {
+    const platform = detectPlatform();
+    const publicSet = new Set(publicPackageNames.map(import_python_analysis3.normalizePackageName));
+    const packageWheels = /* @__PURE__ */ new Map();
+    for (const pkg of lockFile.packages) {
+      const normalized = (0, import_python_analysis3.normalizePackageName)(pkg.name);
+      if (publicSet.has(normalized) && pkg.wheels.length > 0) {
+        packageWheels.set(normalized, pkg.wheels);
+      }
+    }
+    const incompatible = [];
+    for (const name of publicPackageNames) {
+      const normalized = (0, import_python_analysis3.normalizePackageName)(name);
+      const wheels = packageWheels.get(normalized);
+      if (!wheels || wheels.length === 0) {
+        incompatible.push(name);
+        continue;
+      }
+      let hasCompatible = false;
+      for (const wheel of wheels) {
+        const filename = wheel.url.split("/").pop();
+        if (!filename || !filename.endsWith(".whl"))
+          continue;
+        try {
+          const compatible = await (0, import_python_analysis3.isWheelCompatible)(
+            filename,
+            this.pythonMajor,
+            this.pythonMinor,
+            platform.osName,
+            platform.archName,
+            platform.osMajor,
+            platform.osMinor
+          );
+          if (compatible) {
+            hasCompatible = true;
+            break;
+          }
+        } catch (err) {
+          (0, import_build_utils5.debug)(
+            `Failed to check wheel compatibility for ${filename}: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      if (!hasCompatible) {
+        incompatible.push(name);
+      }
+    }
+    return incompatible;
+  }
 };
 async function mirrorPackagesIntoVendor({
   venvPath,
@@ -4201,19 +4662,261 @@ async function calculatePerPackageSizes(venvPath) {
   return sizes;
 }
 
+// src/diagnostics.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path7 = require("path");
+var import_build_utils6 = require("@vercel/build-utils");
+var import_python_analysis4 = require("@vercel/python-analysis");
+var MANIFEST_FILENAME = "package-manifest.json";
+var DIAGNOSTICS_PATH = (0, import_path7.join)(".vercel", "python", MANIFEST_FILENAME);
+var MANIFEST_VERSION = "20260304";
+function isDependencyGroupInclude(entry) {
+  return typeof entry === "object" && "include-group" in entry;
+}
+function resolveDependencyGroup(groupName, allGroups, ancestors = /* @__PURE__ */ new Set()) {
+  if (ancestors.has(groupName))
+    return [];
+  const entries = allGroups[groupName];
+  if (!Array.isArray(entries))
+    return [];
+  ancestors.add(groupName);
+  const result = [];
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      result.push(entry);
+    } else if (isDependencyGroupInclude(entry)) {
+      result.push(
+        ...resolveDependencyGroup(entry["include-group"], allGroups, ancestors)
+      );
+    }
+  }
+  ancestors.delete(groupName);
+  return result;
+}
+function mapSource(src) {
+  if (!src)
+    return {};
+  if (src.virtual)
+    return {};
+  if (src.registry) {
+    try {
+      const url = new URL(src.registry);
+      return { source: "registry", sourceUrl: url.origin };
+    } catch {
+      return { source: "registry", sourceUrl: src.registry };
+    }
+  }
+  if (src.git)
+    return { source: "git", sourceUrl: src.git };
+  if (src.url)
+    return { source: "url", sourceUrl: src.url };
+  if (src.editable)
+    return { source: "editable", sourceUrl: src.editable };
+  if (src.path)
+    return { source: "path", sourceUrl: src.path };
+  return {};
+}
+async function generateProjectManifest({
+  workPath,
+  pythonPackage,
+  pythonVersion,
+  uvLockPath
+}) {
+  const resolved = pythonVersionString(pythonVersion);
+  const constraint = pythonPackage.requiresPython?.[0];
+  const requested = constraint?.specifier;
+  const project = pythonPackage.manifest?.data?.project;
+  const pyprojectData = pythonPackage.manifest?.data;
+  const directScopesMap = /* @__PURE__ */ new Map();
+  const directRequested = /* @__PURE__ */ new Map();
+  const allRawDeps = [];
+  if (project?.dependencies && Array.isArray(project.dependencies)) {
+    for (const dep of project.dependencies) {
+      allRawDeps.push({ dep, scope: "main" });
+    }
+  }
+  const optDeps = project?.["optional-dependencies"];
+  if (optDeps) {
+    for (const [group, deps] of Object.entries(optDeps)) {
+      if (Array.isArray(deps)) {
+        for (const dep of deps) {
+          allRawDeps.push({ dep, scope: group });
+        }
+      }
+    }
+  }
+  const depGroups = pyprojectData?.["dependency-groups"];
+  if (depGroups) {
+    for (const group of Object.keys(depGroups)) {
+      const groupDeps = resolveDependencyGroup(group, depGroups);
+      for (const dep of groupDeps) {
+        allRawDeps.push({ dep, scope: group });
+      }
+    }
+  }
+  const uvDevDeps = pyprojectData?.tool?.uv?.["dev-dependencies"];
+  if (uvDevDeps && Array.isArray(uvDevDeps)) {
+    for (const dep of uvDevDeps) {
+      allRawDeps.push({ dep, scope: "dev" });
+    }
+  }
+  const allParsed = await (0, import_python_analysis4.parsePep508)(allRawDeps.map((d) => d.dep));
+  for (let i = 0; i < allRawDeps.length; i++) {
+    const parsed = allParsed[i];
+    if (!parsed)
+      continue;
+    const { dep, scope } = allRawDeps[i];
+    const normalized = (0, import_python_analysis4.normalizePackageName)(parsed.name);
+    let scopes = directScopesMap.get(normalized);
+    if (!scopes) {
+      scopes = /* @__PURE__ */ new Set();
+      directScopesMap.set(normalized, scopes);
+    }
+    scopes.add(scope);
+    if (!directRequested.has(normalized)) {
+      directRequested.set(normalized, dep);
+    }
+  }
+  const directEntries = [];
+  const transitiveEntries = [];
+  {
+    const content = await import_fs5.default.promises.readFile(uvLockPath, "utf-8");
+    const uvLock = (0, import_python_analysis4.parseUvLock)(content, uvLockPath);
+    const projectName = project?.name;
+    const excludeSet = new Set(
+      projectName ? [(0, import_python_analysis4.normalizePackageName)(projectName)] : []
+    );
+    const lockMap = /* @__PURE__ */ new Map();
+    const depGraph = /* @__PURE__ */ new Map();
+    for (const pkg of uvLock.packages) {
+      const normalized = (0, import_python_analysis4.normalizePackageName)(pkg.name);
+      if (excludeSet.has(normalized))
+        continue;
+      if (pkg.source?.virtual)
+        continue;
+      lockMap.set(normalized, { version: pkg.version, source: pkg.source });
+      if (pkg.dependencies) {
+        const deps = /* @__PURE__ */ new Set();
+        for (const d of pkg.dependencies) {
+          deps.add((0, import_python_analysis4.normalizePackageName)(d.name));
+        }
+        depGraph.set(normalized, deps);
+      }
+    }
+    const transitiveScopesMap = /* @__PURE__ */ new Map();
+    for (const [name, scopes] of directScopesMap) {
+      const queue = [name];
+      let head = 0;
+      const visited = /* @__PURE__ */ new Set();
+      while (head < queue.length) {
+        const current = queue[head++];
+        if (visited.has(current))
+          continue;
+        visited.add(current);
+        const children = depGraph.get(current);
+        if (!children)
+          continue;
+        for (const child of children) {
+          if (excludeSet.has(child))
+            continue;
+          if (!directScopesMap.has(child)) {
+            let childScopes = transitiveScopesMap.get(child);
+            if (!childScopes) {
+              childScopes = /* @__PURE__ */ new Set();
+              transitiveScopesMap.set(child, childScopes);
+            }
+            for (const s of scopes) {
+              childScopes.add(s);
+            }
+          }
+          if (!visited.has(child)) {
+            queue.push(child);
+          }
+        }
+      }
+    }
+    for (const [name, scopes] of directScopesMap) {
+      const info = lockMap.get(name);
+      const entry = {
+        name,
+        type: "direct",
+        scopes: [...scopes].sort(),
+        requested: directRequested.get(name)
+      };
+      if (info) {
+        entry.resolved = info.version;
+        const src = mapSource(info.source);
+        if (src.source)
+          entry.source = src.source;
+        if (src.sourceUrl)
+          entry.sourceUrl = src.sourceUrl;
+      }
+      directEntries.push(entry);
+    }
+    for (const [normalized, info] of lockMap) {
+      if (directScopesMap.has(normalized))
+        continue;
+      const scopes = transitiveScopesMap.get(normalized);
+      if (!scopes || scopes.size === 0)
+        continue;
+      const src = mapSource(info.source);
+      transitiveEntries.push({
+        name: normalized,
+        type: "transitive",
+        scopes: [...scopes].sort(),
+        resolved: info.version,
+        ...src.source ? { source: src.source } : {},
+        ...src.sourceUrl ? { sourceUrl: src.sourceUrl } : {}
+      });
+    }
+  }
+  const manifest = {
+    version: MANIFEST_VERSION,
+    runtime: "python",
+    runtimeVersion: {
+      ...requested ? { requested } : {},
+      ...constraint?.source ? { requestedSource: constraint.source } : {},
+      resolved
+    },
+    dependencies: [
+      ...directEntries.sort((a, b) => a.name.localeCompare(b.name)),
+      ...transitiveEntries.sort((a, b) => a.name.localeCompare(b.name))
+    ]
+  };
+  const outPath = (0, import_path7.join)(workPath, DIAGNOSTICS_PATH);
+  await import_fs5.default.promises.mkdir((0, import_path7.dirname)(outPath), { recursive: true });
+  await import_fs5.default.promises.writeFile(outPath, JSON.stringify(manifest, null, 2));
+}
+var diagnostics = async ({
+  workPath
+}) => {
+  try {
+    const manifestPath = (0, import_path7.join)(workPath, DIAGNOSTICS_PATH);
+    const data = await import_fs5.default.promises.readFile(manifestPath, "utf-8");
+    return {
+      [MANIFEST_FILENAME]: new import_build_utils6.FileBlob({ data })
+    };
+  } catch (err) {
+    (0, import_build_utils6.debug)(
+      `Diagnostics: no cached manifest found: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return {};
+  }
+};
+
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs6 = require("fs");
-var import_path8 = require("path");
-var import_build_utils8 = require("@vercel/build-utils");
+var import_fs7 = require("fs");
+var import_path9 = require("path");
+var import_build_utils9 = 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_fs5 = __toESM(require("fs"));
-var import_path7 = require("path");
-var import_build_utils6 = require("@vercel/build-utils");
+var import_fs6 = __toESM(require("fs"));
+var import_path8 = require("path");
 var import_build_utils7 = require("@vercel/build-utils");
+var import_build_utils8 = require("@vercel/build-utils");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
   "index",
@@ -4229,26 +4932,26 @@ var PYTHON_CANDIDATE_ENTRYPOINTS = getCandidateEntrypointsInDirs(
 function getCandidateEntrypointsInDirs(dirs) {
   return dirs.flatMap(
     (dir) => PYTHON_ENTRYPOINT_FILENAMES.map(
-      (filename) => import_path7.posix.join(dir, `${filename}.py`)
+      (filename) => import_path8.posix.join(dir, `${filename}.py`)
     )
   );
 }
 async function fileExists(filePath) {
   try {
-    const stat = await import_fs5.default.promises.stat(filePath);
+    const stat = await import_fs6.default.promises.stat(filePath);
     return stat.isFile();
   } catch {
     return false;
   }
 }
 async function checkEntrypoint(workPath, relPath) {
-  const absPath = (0, import_path7.join)(workPath, relPath);
+  const absPath = (0, import_path8.join)(workPath, relPath);
   if (!await fileExists(absPath))
     return false;
-  return (0, import_build_utils6.isPythonEntrypoint)({ fsPath: absPath });
+  return (0, import_build_utils7.isPythonEntrypoint)({ fsPath: absPath });
 }
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils8.readConfigFile)((0, import_path8.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -4259,30 +4962,32 @@ async function getPyprojectEntrypoint(workPath) {
   if (!match)
     return null;
   const modulePath = match[1];
+  const variableName = match[2];
   const relPath = modulePath.replace(/\./g, "/");
   const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
   for (const candidate of candidates) {
-    if (await fileExists((0, import_path7.join)(workPath, candidate)))
-      return candidate;
+    if (await fileExists((0, import_path8.join)(workPath, candidate))) {
+      return { entrypoint: candidate, variableName };
+    }
   }
   return null;
 }
 async function findValidEntrypoint(workPath, candidates) {
   for (const candidate of candidates) {
     if (await checkEntrypoint(workPath, candidate)) {
-      (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
+      (0, import_build_utils7.debug)(`Detected Python entrypoint: ${candidate}`);
       return candidate;
     }
   }
   return null;
 }
 async function checkDjangoManage(workPath) {
-  const managePath = (0, import_path7.join)(workPath, "manage.py");
+  const managePath = (0, import_path8.join)(workPath, "manage.py");
   try {
-    const content = await import_fs5.default.promises.readFile(managePath, "utf-8");
+    const content = await import_fs6.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
-    (0, import_build_utils6.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    (0, import_build_utils7.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
     return true;
   } catch {
     return false;
@@ -4290,7 +4995,7 @@ async function checkDjangoManage(workPath) {
 }
 async function getSubdirectories(workPath) {
   try {
-    const entries = await import_fs5.default.promises.readdir(workPath, {
+    const entries = await import_fs6.default.promises.readdir(workPath, {
       withFileTypes: true
     });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
@@ -4302,7 +5007,7 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
     if (await checkEntrypoint(workPath, entry)) {
-      (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
+      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
       return { entrypoint: entry };
     }
     const found = await findValidEntrypoint(
@@ -4311,7 +5016,7 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
     );
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils6.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils7.debug)("Failed to discover Python entrypoint");
     return null;
   }
 }
@@ -4319,13 +5024,13 @@ async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
     if (await checkEntrypoint(workPath, entry)) {
-      (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
+      (0, import_build_utils7.debug)(`Using configured Python entrypoint: ${entry}`);
       return { entrypoint: entry };
     }
     const subdirs = await getSubdirectories(workPath);
     const rootDirs = ["", ...subdirs];
     for (const rootDir of rootDirs) {
-      const currPath = (0, import_path7.join)(workPath, rootDir);
+      const currPath = (0, import_path8.join)(workPath, rootDir);
       const isDjango = await checkDjangoManage(currPath);
       if (isDjango) {
         return { baseDir: rootDir };
@@ -4335,7 +5040,7 @@ async function detectDjangoPythonEntrypoint(workPath, configuredEntrypoint) {
     const found = await findValidEntrypoint(workPath, candidates);
     return found ? { entrypoint: found } : null;
   } catch {
-    (0, import_build_utils6.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils7.debug)("Failed to discover Django Python entrypoint");
     return null;
   }
 }
@@ -4344,12 +5049,17 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint)
   if (result)
     return result;
   const pyprojectEntry = await getPyprojectEntrypoint(workPath);
-  return pyprojectEntry ? { entrypoint: pyprojectEntry } : null;
+  if (!pyprojectEntry)
+    return null;
+  return {
+    entrypoint: pyprojectEntry.entrypoint,
+    variableName: pyprojectEntry.variableName
+  };
 }
 
 // src/start-dev-server.ts
-var import_python_analysis4 = require("@vercel/python-analysis");
-var DEV_SERVER_STARTUP_TIMEOUT = 1e4;
+var import_python_analysis5 = require("@vercel/python-analysis");
+var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
     process
@@ -4375,6 +5085,10 @@ function silenceNodeWarnings() {
   };
 }
 var DEV_SHIM_MODULE = "vc_init_dev";
+function hasWorkerServicesEnabled(env) {
+  const value = env.VERCEL_HAS_WORKER_SERVICES || "";
+  return ["1", "true"].includes(value.trim().toLowerCase());
+}
 function createLogListener(callback, stream) {
   return (buf) => {
     if (callback) {
@@ -4430,17 +5144,17 @@ async function syncDependencies({
   let { manifestPath } = installInfo;
   const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils8.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils9.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
-    const syncDir = (0, import_path8.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs6.mkdirSync)(syncDir, { recursive: true });
-    const tempPyproject = (0, import_path8.join)(syncDir, "pyproject.toml");
-    const content = (0, import_python_analysis4.stringifyManifest)(manifest.data);
-    (0, import_fs6.writeFileSync)(tempPyproject, content, "utf8");
+    const syncDir = (0, import_path9.join)(workPath, ".vercel", "python", "sync");
+    (0, import_fs7.mkdirSync)(syncDir, { recursive: true });
+    const tempPyproject = (0, import_path9.join)(syncDir, "pyproject.toml");
+    const content = (0, import_python_analysis5.stringifyManifest)(manifest.data);
+    (0, import_fs7.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils8.debug)(
+    (0, import_build_utils9.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -4473,7 +5187,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils8.NowBuildError({
+    throw new import_build_utils9.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -4488,14 +5202,14 @@ async function runSync({
   onStdout,
   onStderr
 }) {
-  const projectDir = (0, import_path8.dirname)(manifestPath);
+  const projectDir = (0, import_path9.dirname)(manifestPath);
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   let spawnCmd;
   let spawnArgs;
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils8.NowBuildError({
+        throw new import_build_utils9.NowBuildError({
           code: "PYTHON_DEPENDENCY_SYNC_FAILED",
           message: "uv is required to install dependencies from uv.lock.",
           link: "https://docs.astral.sh/uv/getting-started/installation/",
@@ -4517,11 +5231,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils8.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils9.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve3, reject) => {
-    (0, import_build_utils8.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils9.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -4555,6 +5269,8 @@ async function runSync({
     });
   });
 }
+var PENDING_RUNTIME_INSTALLS = /* @__PURE__ */ new Map();
+var PENDING_WORKERS_INSTALLS = /* @__PURE__ */ new Map();
 async function installVercelRuntime({
   workPath,
   uvPath,
@@ -4563,9 +5279,34 @@ async function installVercelRuntime({
   onStdout,
   onStderr
 }) {
-  const targetDir = (0, import_path8.join)(workPath, ".vercel", "python");
-  (0, import_fs6.mkdirSync)(targetDir, { recursive: true });
-  const localRuntimeDir = (0, import_path8.join)(
+  const targetDir = (0, import_path9.join)(workPath, ".vercel", "python");
+  let pending = PENDING_RUNTIME_INSTALLS.get(targetDir);
+  if (!pending) {
+    pending = doInstallVercelRuntime({
+      targetDir,
+      workPath,
+      uvPath,
+      pythonBin,
+      env,
+      onStdout,
+      onStderr
+    });
+    PENDING_RUNTIME_INSTALLS.set(targetDir, pending);
+    pending.finally(() => PENDING_RUNTIME_INSTALLS.delete(targetDir));
+  }
+  await pending;
+}
+async function doInstallVercelRuntime({
+  targetDir,
+  workPath,
+  uvPath,
+  pythonBin,
+  env,
+  onStdout,
+  onStderr
+}) {
+  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  const localRuntimeDir = (0, import_path9.join)(
     __dirname,
     "..",
     "..",
@@ -4573,21 +5314,21 @@ async function installVercelRuntime({
     "python",
     "vercel-runtime"
   );
-  const isLocalDev = (0, import_fs6.existsSync)((0, import_path8.join)(localRuntimeDir, "pyproject.toml"));
+  const isLocalDev = (0, import_fs7.existsSync)((0, import_path9.join)(localRuntimeDir, "pyproject.toml"));
   const runtimeDep = env.VERCEL_RUNTIME_PYTHON || (isLocalDev ? localRuntimeDir : `vercel-runtime==${VERCEL_RUNTIME_VERSION}`);
   if (!isLocalDev && !env.VERCEL_RUNTIME_PYTHON) {
-    const distInfo = (0, import_path8.join)(
+    const distInfo = (0, import_path9.join)(
       targetDir,
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
-    if ((0, import_fs6.existsSync)(distInfo)) {
-      (0, import_build_utils8.debug)(
+    if ((0, import_fs7.existsSync)(distInfo)) {
+      (0, import_build_utils9.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils8.debug)(
+  (0, import_build_utils9.debug)(
     `Installing vercel-runtime into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${runtimeDep})`
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
@@ -4602,14 +5343,14 @@ async function installVercelRuntime({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils8.debug)(data.toString());
+        (0, import_build_utils9.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils8.debug)(data.toString());
+        (0, import_build_utils9.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -4626,6 +5367,102 @@ async function installVercelRuntime({
     });
   });
 }
+async function installVercelWorkers({
+  workPath,
+  uvPath,
+  pythonBin,
+  env,
+  onStdout,
+  onStderr
+}) {
+  const targetDir = (0, import_path9.join)(workPath, ".vercel", "python");
+  let pending = PENDING_WORKERS_INSTALLS.get(targetDir);
+  if (!pending) {
+    pending = doInstallVercelWorkers({
+      targetDir,
+      workPath,
+      uvPath,
+      pythonBin,
+      env,
+      onStdout,
+      onStderr
+    });
+    PENDING_WORKERS_INSTALLS.set(targetDir, pending);
+    pending.finally(() => PENDING_WORKERS_INSTALLS.delete(targetDir));
+  }
+  await pending;
+}
+async function doInstallVercelWorkers({
+  targetDir,
+  workPath,
+  uvPath,
+  pythonBin,
+  env,
+  onStdout,
+  onStderr
+}) {
+  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  const localWorkersDir = (0, import_path9.join)(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "python",
+    "vercel-workers"
+  );
+  const isLocalDev = (0, import_fs7.existsSync)((0, import_path9.join)(localWorkersDir, "pyproject.toml"));
+  const workersDep = env.VERCEL_WORKERS_PYTHON || (isLocalDev ? localWorkersDir : `vercel-workers==${VERCEL_WORKERS_VERSION}`);
+  if (!isLocalDev && !env.VERCEL_WORKERS_PYTHON) {
+    const distInfo = (0, import_path9.join)(
+      targetDir,
+      `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
+    );
+    if ((0, import_fs7.existsSync)(distInfo)) {
+      (0, import_build_utils9.debug)(
+        `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
+      );
+      return;
+    }
+  }
+  (0, import_build_utils9.debug)(
+    `Installing vercel-workers into ${targetDir} (type: ${isLocalDev ? "local" : "pypi"}, source: ${workersDep})`
+  );
+  const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
+  const spawnArgs = [...pip.prefix, "--target", targetDir, workersDep];
+  await new Promise((resolve3, reject) => {
+    const child = (0, import_child_process2.spawn)(pip.cmd, spawnArgs, {
+      cwd: workPath,
+      env: getProtectedUvEnv(env),
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (data) => {
+      if (onStdout) {
+        onStdout(data);
+      } else {
+        (0, import_build_utils9.debug)(data.toString());
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      if (onStderr) {
+        onStderr(data);
+      } else {
+        (0, import_build_utils9.debug)(data.toString());
+      }
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(
+          new Error(
+            `Installing vercel-workers failed with code ${code}, signal ${signal}`
+          )
+        );
+      }
+    });
+  });
+}
 var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
 var PENDING_STARTS = /* @__PURE__ */ new Map();
 var restoreWarnings = null;
@@ -4639,12 +5476,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils8.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils9.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils8.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils9.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -4652,7 +5489,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils8.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils9.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -4667,48 +5504,52 @@ function installGlobalCleanupHandlers() {
     killAll();
   });
 }
-function createDevShim(workPath, entry, modulePath) {
+function createDevShim(workPath, entry, modulePath, serviceName, framework, variableName) {
   try {
-    const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
-    (0, import_fs6.mkdirSync)(vercelPythonDir, { recursive: true });
+    const vercelPythonDir = serviceName ? (0, import_path9.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path9.join)(workPath, ".vercel", "python");
+    (0, import_fs7.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
-    if ((0, import_fs6.existsSync)((0, import_path8.join)(workPath, "__init__.py"))) {
-      const pkgName = (0, import_path8.basename)(workPath);
+    if ((0, import_fs7.existsSync)((0, import_path9.join)(workPath, "__init__.py"))) {
+      const pkgName = (0, import_path9.basename)(workPath);
       qualifiedModule = `${pkgName}.${modulePath}`;
-      extraPythonPath = (0, import_path8.dirname)(workPath);
+      extraPythonPath = (0, import_path9.dirname)(workPath);
     }
-    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)(
+    const entryAbs = (0, import_path9.join)(workPath, entry);
+    const shimPath = (0, import_path9.join)(vercelPythonDir, `${DEV_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path9.join)(
       __dirname,
       "..",
       "templates",
       `${DEV_SHIM_MODULE}.py`
     );
-    const template = (0, import_fs6.readFileSync)(templatePath, "utf8");
-    const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs);
-    (0, import_fs6.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils8.debug)(`Prepared Python dev shim at ${shimPath}`);
-    return { module: DEV_SHIM_MODULE, extraPythonPath };
+    const template = (0, import_fs7.readFileSync)(templatePath, "utf8");
+    const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs).replace(/__VC_DEV_FRAMEWORK__/g, framework).replace(/__VC_DEV_VARIABLE_NAME__/g, variableName);
+    (0, import_fs7.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils9.debug)(`Prepared Python dev shim at ${shimPath}`);
+    return {
+      module: DEV_SHIM_MODULE,
+      extraPythonPath,
+      shimDir: vercelPythonDir
+    };
   } catch (err) {
-    (0, import_build_utils8.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
+    (0, import_build_utils9.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
     return null;
   }
 }
 async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath) {
   const { pythonCmd, venvRoot } = useVirtualEnv(workPath, env, systemPython);
   if (venvRoot) {
-    (0, import_build_utils8.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils9.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
-  const venvPath = (0, import_path8.join)(workPath, ".venv");
+  const venvPath = (0, import_path9.join)(workPath, ".venv");
   await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
-  (0, import_build_utils8.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  (0, import_build_utils9.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_path8.delimiter}${env.PATH || ""}`;
+  env.PATH = `${binDir}${import_path9.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
 var startDevServer = async (opts) => {
@@ -4721,7 +5562,8 @@ var startDevServer = async (opts) => {
     onStderr
   } = opts;
   const framework = config?.framework;
-  const serverKey = `${workPath}::${framework}`;
+  const serviceName = typeof meta.serviceName === "string" ? meta.serviceName : void 0;
+  const serverKey = serviceName ? `${workPath}::${framework}::${serviceName}` : `${workPath}::${framework}`;
   const existing = PERSISTENT_SERVERS.get(serverKey);
   if (existing) {
     return {
@@ -4749,30 +5591,40 @@ var startDevServer = async (opts) => {
   if (!restoreWarnings)
     restoreWarnings = silenceNodeWarnings();
   installGlobalCleanupHandlers();
-  const detected = await detectPythonEntrypoint(
-    framework,
-    workPath,
-    rawEntrypoint
-  );
   const env = { ...process.env, ...meta.env || {} };
-  let entry = detected?.entrypoint;
-  if (!entry) {
-    const hookResult = await runFrameworkHook(framework, {
-      pythonEnv: env,
-      projectDir: (0, import_path8.join)(workPath, detected?.baseDir ?? ""),
-      entrypoint: rawEntrypoint,
-      detected: detected ?? void 0
-    });
-    entry = hookResult?.entrypoint;
-  }
-  if (!entry) {
-    const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-    throw new import_build_utils8.NowBuildError({
-      code: "PYTHON_ENTRYPOINT_NOT_FOUND",
-      message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searched}.`,
-      link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
-      action: "Learn More"
-    });
+  const serviceType = env.VERCEL_SERVICE_TYPE;
+  let entry;
+  let variableName;
+  if ((serviceType === "cron" || serviceType === "worker") && rawEntrypoint?.endsWith(".py")) {
+    entry = rawEntrypoint;
+  } else {
+    const detected = await detectPythonEntrypoint(
+      framework,
+      workPath,
+      rawEntrypoint
+    );
+    entry = detected?.entrypoint;
+    variableName = detected?.variableName;
+    if (!entry) {
+      const hookResult = await runFrameworkHook(framework, {
+        pythonEnv: env,
+        projectDir: (0, import_path9.join)(workPath, detected?.baseDir ?? ""),
+        workPath,
+        entrypoint: rawEntrypoint,
+        detected: detected ?? void 0
+      });
+      entry = hookResult?.entrypoint;
+      variableName = hookResult?.variableName;
+    }
+    if (!entry) {
+      const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
+      throw new import_build_utils9.NowBuildError({
+        code: "PYTHON_ENTRYPOINT_NOT_FOUND",
+        message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searched}.`,
+        link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
+        action: "Learn More"
+      });
+    }
   }
   const modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
   let childProcess = null;
@@ -4797,7 +5649,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils8.NowBuildError({
+      throw new import_build_utils9.NowBuildError({
         code: "PYTHON_EXTERNAL_VENV_DETECTED",
         message: `Detected activated venv at ${yellow}${venv}${reset}, ${white}vercel dev${reset} manages virtual environments automatically.
 Run ${white}deactivate${reset} and try again.`
@@ -4814,11 +5666,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils8.debug)(
+      (0, import_build_utils9.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils8.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils9.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -4827,9 +5679,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils8.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils9.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils8.debug)("No virtualenv found");
+        (0, import_build_utils9.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -4868,12 +5720,36 @@ If you are using a virtual environment, activate it before running "vercel dev",
       pythonBin: spawnCommand,
       env
     });
+    if (hasWorkerServicesEnabled(env)) {
+      await installVercelWorkers({
+        workPath,
+        uvPath,
+        pythonBin: spawnCommand,
+        env,
+        onStdout,
+        onStderr
+      });
+    }
     const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
     env.PORT = `${port}`;
-    const devShim = createDevShim(workPath, entry, modulePath);
+    if (config.handlerFunction && typeof config?.handlerFunction === "string") {
+      env.__VC_HANDLER_FUNC_NAME = config.handlerFunction;
+    }
+    if (entry) {
+      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path9.join)(workPath, entry);
+    }
+    const devShim = createDevShim(
+      workPath,
+      entry,
+      modulePath,
+      serviceName,
+      framework,
+      variableName ?? ""
+    );
     if (devShim) {
-      const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
-      const pathParts = [vercelPythonDir];
+      const shimDir = devShim.shimDir || (0, import_path9.join)(workPath, ".vercel", "python");
+      const runtimeDir = (0, import_path9.join)(workPath, ".vercel", "python");
+      const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
       if (devShim.extraPythonPath) {
         pathParts.push(devShim.extraPythonPath);
       }
@@ -4881,12 +5757,12 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (existingPythonPath) {
         pathParts.push(existingPythonPath);
       }
-      env.PYTHONPATH = pathParts.join(import_path8.delimiter);
+      env.PYTHONPATH = pathParts.join(import_path9.delimiter);
     }
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils8.debug)(
+    (0, import_build_utils9.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
     if (process.stdout.columns) {
@@ -4940,8 +5816,8 @@ 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_analysis6 = require("@vercel/python-analysis");
+var import_build_utils12 = require("@vercel/build-utils");
+var import_python_analysis7 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
 var matplotlibQuirk = {
@@ -4954,9 +5830,9 @@ var matplotlibQuirk = {
 };
 
 // src/quirks/litellm.ts
-var import_fs7 = __toESM(require("fs"));
-var import_path9 = require("path");
-var import_build_utils9 = require("@vercel/build-utils");
+var import_fs8 = __toESM(require("fs"));
+var import_path10 = require("path");
+var import_build_utils10 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
   "litellm_config.yaml",
@@ -4966,9 +5842,9 @@ var CONFIG_CANDIDATES = [
 ];
 async function findConfigFile(workPath) {
   for (const name of CONFIG_CANDIDATES) {
-    const candidate = (0, import_path9.join)(workPath, name);
+    const candidate = (0, import_path10.join)(workPath, name);
     try {
-      await import_fs7.default.promises.access(candidate);
+      await import_fs8.default.promises.access(candidate);
       return name;
     } catch {
     }
@@ -4983,32 +5859,32 @@ var litellmQuirk = {
     const env = {};
     const sitePackagesDirs = await getVenvSitePackagesDirs(ctx.venvPath);
     for (const sitePackages of sitePackagesDirs) {
-      const schemaPath = (0, import_path9.join)(
+      const schemaPath = (0, import_path10.join)(
         sitePackages,
         "litellm",
         "proxy",
         "schema.prisma"
       );
       try {
-        await import_fs7.default.promises.access(schemaPath);
-        (0, import_build_utils9.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
+        await import_fs8.default.promises.access(schemaPath);
+        (0, import_build_utils10.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
       } catch {
       }
     }
     if (!buildEnv.PRISMA_SCHEMA_PATH) {
-      (0, import_build_utils9.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
+      (0, import_build_utils10.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
     }
     if (!process.env.CONFIG_FILE_PATH) {
       const configName = await findConfigFile(ctx.workPath);
       if (configName) {
-        (0, import_build_utils9.debug)(`LiteLLM quirk: found config at ${configName}`);
-        buildEnv.CONFIG_FILE_PATH = (0, import_path9.join)(ctx.workPath, configName);
-        env.CONFIG_FILE_PATH = (0, import_path9.join)(LAMBDA_ROOT, configName);
+        (0, import_build_utils10.debug)(`LiteLLM quirk: found config at ${configName}`);
+        buildEnv.CONFIG_FILE_PATH = (0, import_path10.join)(ctx.workPath, configName);
+        env.CONFIG_FILE_PATH = (0, import_path10.join)(LAMBDA_ROOT, configName);
       }
     } else {
-      (0, import_build_utils9.debug)(
+      (0, import_build_utils10.debug)(
         `LiteLLM quirk: CONFIG_FILE_PATH already set to ${process.env.CONFIG_FILE_PATH}`
       );
     }
@@ -5017,11 +5893,11 @@ var litellmQuirk = {
 };
 
 // src/quirks/prisma.ts
-var import_fs8 = __toESM(require("fs"));
-var import_path10 = require("path");
+var import_fs9 = __toESM(require("fs"));
+var import_path11 = require("path");
 var import_execa4 = __toESM(require_execa());
-var import_build_utils10 = require("@vercel/build-utils");
-var import_python_analysis5 = require("@vercel/python-analysis");
+var import_build_utils11 = require("@vercel/build-utils");
+var import_python_analysis6 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
     const stderr = String(err.stderr);
@@ -5034,7 +5910,8 @@ var DUMMY_SCHEMA_NAME = "_prisma_dummy.prisma";
 var LAMBDA_ROOT2 = "/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";
+  const platform = detectPlatform();
+  return platform.archName === "aarch64" ? "linux-arm64-openssl-3.0.x" : "rhel-openssl-3.0.x";
 }
 function buildDummySchema(generatedDir) {
   const lambdaTarget = getLambdaBinaryTarget();
@@ -5057,22 +5934,22 @@ model DummyModel {
 async function findUserSchema(workPath) {
   const envPath = process.env.PRISMA_SCHEMA_PATH;
   if (envPath) {
-    const resolved = (0, import_path10.isAbsolute)(envPath) ? envPath : (0, import_path10.join)(workPath, envPath);
+    const resolved = (0, import_path11.isAbsolute)(envPath) ? envPath : (0, import_path11.join)(workPath, envPath);
     try {
-      await import_fs8.default.promises.access(resolved);
+      await import_fs9.default.promises.access(resolved);
       return resolved;
     } catch {
-      (0, import_build_utils10.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      (0, import_build_utils11.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
       return null;
     }
   }
   const candidates = [
-    (0, import_path10.join)(workPath, "schema.prisma"),
-    (0, import_path10.join)(workPath, "prisma", "schema.prisma")
+    (0, import_path11.join)(workPath, "schema.prisma"),
+    (0, import_path11.join)(workPath, "prisma", "schema.prisma")
   ];
   for (const candidate of candidates) {
     try {
-      await import_fs8.default.promises.access(candidate);
+      await import_fs9.default.promises.access(candidate);
       return candidate;
     } catch {
     }
@@ -5083,32 +5960,32 @@ async function collectFiles(dir, base) {
   const result = [];
   let entries;
   try {
-    entries = await import_fs8.default.promises.readdir(dir, { withFileTypes: true });
+    entries = await import_fs9.default.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const entry of entries) {
     if (entry.name === "__pycache__")
       continue;
-    const full = (0, import_path10.join)(dir, entry.name);
+    const full = (0, import_path11.join)(dir, entry.name);
     if (entry.isDirectory()) {
       result.push(...await collectFiles(full, base));
     } else {
-      result.push((0, import_path10.relative)(base, full));
+      result.push((0, import_path11.relative)(base, full));
     }
   }
   return result;
 }
 async function cleanCacheArtifacts(cacheDir, extras = []) {
   const paths = [
-    (0, import_path10.join)(cacheDir, "node_modules"),
-    (0, import_path10.join)(cacheDir, "package.json"),
-    (0, import_path10.join)(cacheDir, "package-lock.json"),
+    (0, import_path11.join)(cacheDir, "node_modules"),
+    (0, import_path11.join)(cacheDir, "package.json"),
+    (0, import_path11.join)(cacheDir, "package-lock.json"),
     ...extras
   ];
   for (const p of paths) {
     try {
-      await import_fs8.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs9.default.promises.rm(p, { recursive: true, force: true });
     } catch (err) {
       console.warn(
         `could not clean up ${p}: ${err instanceof Error ? err.message : String(err)}`
@@ -5132,7 +6009,7 @@ var prismaQuirk = {
   async run(ctx) {
     const { venvPath, pythonEnv, workPath } = ctx;
     const pythonPath = getVenvPythonBin(venvPath);
-    const runtimeCacheDir = (0, import_path10.join)(
+    const runtimeCacheDir = (0, import_path11.join)(
       LAMBDA_ROOT2,
       resolveVendorDir(),
       "prisma",
@@ -5142,7 +6019,7 @@ var prismaQuirk = {
     let sitePackages;
     for (const dir of sitePackagesDirs) {
       try {
-        await import_fs8.default.promises.access((0, import_path10.join)(dir, "prisma"));
+        await import_fs9.default.promises.access((0, import_path11.join)(dir, "prisma"));
         sitePackages = dir;
         break;
       } catch {
@@ -5154,19 +6031,19 @@ var prismaQuirk = {
       );
       return {};
     }
-    const cacheDir = (0, import_path10.join)(sitePackages, "prisma", "__bincache__");
-    await import_fs8.default.promises.mkdir(cacheDir, { recursive: true });
+    const cacheDir = (0, import_path11.join)(sitePackages, "prisma", "__bincache__");
+    await import_fs9.default.promises.mkdir(cacheDir, { recursive: true });
     const generateEnv = {
       ...pythonEnv,
       PRISMA_BINARY_CACHE_DIR: cacheDir
     };
-    const generatedDir = (0, import_path10.join)(workPath, "_prisma_generated");
-    const dummySchemaPath = (0, import_path10.join)(workPath, DUMMY_SCHEMA_NAME);
-    await import_fs8.default.promises.writeFile(
+    const generatedDir = (0, import_path11.join)(workPath, "_prisma_generated");
+    const dummySchemaPath = (0, import_path11.join)(workPath, DUMMY_SCHEMA_NAME);
+    await import_fs9.default.promises.writeFile(
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
-    (0, import_build_utils10.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    (0, import_build_utils11.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
     try {
       const dummyResult = await (0, import_execa4.default)(
         pythonPath,
@@ -5178,11 +6055,11 @@ var prismaQuirk = {
         }
       );
       if (dummyResult.stdout)
-        (0, import_build_utils10.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+        (0, import_build_utils11.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
       if (dummyResult.stderr)
-        (0, import_build_utils10.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+        (0, import_build_utils11.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
     } catch (err) {
-      throw new import_build_utils10.NowBuildError({
+      throw new import_build_utils11.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)
@@ -5190,47 +6067,47 @@ var prismaQuirk = {
     }
     const srcBinaryPrefix = `query-engine-${getLambdaBinaryTarget()}`;
     const runtimeName = `prisma-query-engine-rhel-openssl-${RUNTIME_OPENSSL_VERSION}.x`;
-    const nodeModulesDir = (0, import_path10.join)(cacheDir, "node_modules", "prisma");
+    const nodeModulesDir = (0, import_path11.join)(cacheDir, "node_modules", "prisma");
     let engineCopied = false;
     try {
-      const entries = await import_fs8.default.promises.readdir(nodeModulesDir);
+      const entries = await import_fs9.default.promises.readdir(nodeModulesDir);
       for (const entry of entries) {
         if (!entry.startsWith(srcBinaryPrefix))
           continue;
-        const srcPath = (0, import_path10.join)(nodeModulesDir, entry);
-        const destPath = (0, import_path10.join)(cacheDir, runtimeName);
+        const srcPath = (0, import_path11.join)(nodeModulesDir, entry);
+        const destPath = (0, import_path11.join)(cacheDir, runtimeName);
         try {
-          await import_fs8.default.promises.access(destPath);
-          (0, import_build_utils10.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+          await import_fs9.default.promises.access(destPath);
+          (0, import_build_utils11.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
-          (0, import_build_utils10.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
-          await import_fs8.default.promises.copyFile(srcPath, destPath);
+          (0, import_build_utils11.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          await import_fs9.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
     } catch (err) {
-      throw new import_build_utils10.NowBuildError({
+      throw new import_build_utils11.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_utils10.NowBuildError({
+      throw new import_build_utils11.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_path10.join)(cacheDir, "openssl");
-    await import_fs8.default.promises.writeFile(
+    const shimPath = (0, import_path11.join)(cacheDir, "openssl");
+    await import_fs9.default.promises.writeFile(
       shimPath,
       `#!/bin/sh
 echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIME_OPENSSL_VERSION}.0)"
 `
     );
-    await import_fs8.default.promises.chmod(shimPath, 493);
+    await import_fs9.default.promises.chmod(shimPath, 493);
     for (const p of [generatedDir, dummySchemaPath]) {
-      await import_fs8.default.promises.rm(p, { recursive: true, force: true });
+      await import_fs9.default.promises.rm(p, { recursive: true, force: true });
     }
     await cleanCacheArtifacts(cacheDir);
     const generateMode = (process.env.VERCEL_PRISMA_GENERATE_CLIENT ?? "auto").toLowerCase();
@@ -5243,14 +6120,14 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
           pythonEnv
         );
         if (clientAlreadyGenerated) {
-          (0, import_build_utils10.debug)(
+          (0, import_build_utils11.debug)(
             "Prisma quirk: client already generated, skipping user schema generate"
           );
           shouldGenerate = false;
         }
       }
       if (shouldGenerate) {
-        (0, import_build_utils10.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        (0, import_build_utils11.debug)(`Running prisma generate with user schema: ${userSchema}`);
         try {
           const userResult = await (0, import_execa4.default)(
             pythonPath,
@@ -5262,11 +6139,11 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
             }
           );
           if (userResult.stdout)
-            (0, import_build_utils10.debug)(`prisma generate stdout: ${userResult.stdout}`);
+            (0, import_build_utils11.debug)(`prisma generate stdout: ${userResult.stdout}`);
           if (userResult.stderr)
-            (0, import_build_utils10.debug)(`prisma generate stderr: ${userResult.stderr}`);
+            (0, import_build_utils11.debug)(`prisma generate stderr: ${userResult.stderr}`);
         } catch (err) {
-          throw new import_build_utils10.NowBuildError({
+          throw new import_build_utils11.NowBuildError({
             code: "PRISMA_GENERATE_FAILED",
             message: `\`prisma generate\` failed for schema "${userSchema}".
 ` + execErrorMessage(err)
@@ -5277,12 +6154,12 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
     }
     try {
       const allFiles = await collectFiles(
-        (0, import_path10.join)(sitePackages, "prisma"),
+        (0, import_path11.join)(sitePackages, "prisma"),
         sitePackages
       );
-      const count = await (0, import_python_analysis5.extendDistRecord)(sitePackages, "prisma", allFiles);
+      const count = await (0, import_python_analysis6.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
-        (0, import_build_utils10.debug)(`Appended ${count} entries to prisma RECORD`);
+        (0, import_build_utils11.debug)(`Appended ${count} entries to prisma RECORD`);
       }
     } catch (err) {
       console.warn(
@@ -5305,7 +6182,7 @@ var quirks = [litellmQuirk, prismaQuirk, matplotlibQuirk];
 function toposortQuirks(activated) {
   const nameToQuirk = /* @__PURE__ */ new Map();
   for (const q of activated) {
-    nameToQuirk.set((0, import_python_analysis6.normalizePackageName)(q.dependency), q);
+    nameToQuirk.set((0, import_python_analysis7.normalizePackageName)(q.dependency), q);
   }
   const adj = /* @__PURE__ */ new Map();
   const inDegree = /* @__PURE__ */ new Map();
@@ -5316,7 +6193,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_analysis6.normalizePackageName)(dep));
+        const target = nameToQuirk.get((0, import_python_analysis7.normalizePackageName)(dep));
         if (target) {
           adj.get(q).add(target);
           inDegree.set(target, inDegree.get(target) + 1);
@@ -5325,7 +6202,7 @@ function toposortQuirks(activated) {
     }
     if (q.runsAfter) {
       for (const dep of q.runsAfter) {
-        const source = nameToQuirk.get((0, import_python_analysis6.normalizePackageName)(dep));
+        const source = nameToQuirk.get((0, import_python_analysis7.normalizePackageName)(dep));
         if (source) {
           adj.get(source).add(q);
           inDegree.set(q, inDegree.get(q) + 1);
@@ -5366,23 +6243,23 @@ async function runQuirks(ctx) {
   const installedNames = /* @__PURE__ */ new Set();
   const sitePackageDirs = await getVenvSitePackagesDirs(ctx.venvPath);
   for (const dir of sitePackageDirs) {
-    const distributions = await (0, import_python_analysis6.scanDistributions)(dir);
+    const distributions = await (0, import_python_analysis7.scanDistributions)(dir);
     for (const name of distributions.keys()) {
-      installedNames.add((0, import_python_analysis6.normalizePackageName)(name));
+      installedNames.add((0, import_python_analysis7.normalizePackageName)(name));
     }
   }
   const activated = quirks.filter((quirk) => {
     const installed = installedNames.has(
-      (0, import_python_analysis6.normalizePackageName)(quirk.dependency)
+      (0, import_python_analysis7.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
-      (0, import_build_utils11.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+      (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
     }
     return installed;
   });
   const sorted = toposortQuirks(activated);
   for (const quirk of sorted) {
-    (0, import_build_utils11.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    (0, import_build_utils12.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
     const result = await quirk.run(ctx);
     if (result.env) {
       Object.assign(mergedEnv, result.env);
@@ -5403,12 +6280,12 @@ async function runQuirks(ctx) {
 }
 
 // src/django.ts
-var import_fs9 = __toESM(require("fs"));
-var import_path11 = require("path");
+var import_fs10 = __toESM(require("fs"));
+var import_path12 = require("path");
 var import_execa5 = __toESM(require_execa());
-var import_build_utils12 = require("@vercel/build-utils");
-var scriptPath = (0, import_path11.join)(__dirname, "..", "templates", "vc_django_settings.py");
-var script = import_fs9.default.readFileSync(scriptPath, "utf-8");
+var import_build_utils13 = require("@vercel/build-utils");
+var scriptPath = (0, import_path12.join)(__dirname, "..", "templates", "vc_django_settings.py");
+var script = import_fs10.default.readFileSync(scriptPath, "utf-8");
 async function getDjangoSettings(projectDir, env) {
   try {
     const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
@@ -5423,7 +6300,7 @@ async function getDjangoSettings(projectDir, env) {
       djangoSettings: parsed.django_settings
     };
   } catch (err) {
-    (0, import_build_utils12.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
+    (0, import_build_utils13.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
     return null;
   }
 }
@@ -5437,10 +6314,10 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   const installedApps = djangoSettings["INSTALLED_APPS"] ?? [];
   const staticfilesDirs = djangoSettings["STATICFILES_DIRS"] ?? [];
   const staticSourceDirs = [
-    ...installedApps.map((app) => (0, import_path11.join)(workPath, ...app.split("."), "static")),
+    ...installedApps.map((app) => (0, import_path12.join)(workPath, ...app.split("."), "static")),
     // TODO: Deal with optional prefixes in STATICFILES_DIRS.
     ...staticfilesDirs.map((d) => Array.isArray(d) ? d[1] : d)
-  ].filter((d) => import_fs9.default.existsSync(d));
+  ].filter((d) => import_fs10.default.existsSync(d));
   if (storageBackend.startsWith("storages.backends.")) {
     console.log(
       "django-storages detected \u2014 running collectstatic with original settings"
@@ -5451,7 +6328,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     });
     return {
       staticSourceDirs,
-      staticRoot: staticRoot ? (0, import_path11.resolve)(workPath, staticRoot) : null,
+      staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
       manifestRelPath: null
     };
   }
@@ -5462,9 +6339,9 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     return null;
   }
   const staticUrlPath = staticUrl.replace(/^\/|\/$/g, "") || "static";
-  const staticOutputDir = (0, import_path11.join)(outputStaticDir, staticUrlPath);
-  await import_fs9.default.promises.mkdir(staticOutputDir, { recursive: true });
-  const shimPath = (0, import_path11.join)(workPath, "_vercel_collectstatic_settings.py");
+  const staticOutputDir = (0, import_path12.join)(outputStaticDir, staticUrlPath);
+  await import_fs10.default.promises.mkdir(staticOutputDir, { recursive: true });
+  const shimPath = (0, import_path12.join)(workPath, "_vercel_collectstatic_settings.py");
   const shimLines = [
     `from ${settingsModule} import *`,
     `STATIC_ROOT = ${JSON.stringify(staticOutputDir)}`
@@ -5472,7 +6349,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   if (whitenoiseUseFinders) {
     shimLines.push(`WHITENOISE_USE_FINDERS = False`);
   }
-  await import_fs9.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
+  await import_fs10.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
   try {
     console.log("Running collectstatic...");
     await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
@@ -5483,7 +6360,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
       cwd: workPath
     });
   } finally {
-    await import_fs9.default.promises.unlink(shimPath).catch(() => {
+    await import_fs10.default.promises.unlink(shimPath).catch(() => {
     });
   }
   const MANIFEST_STORAGE_BACKENDS = [
@@ -5492,24 +6369,24 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
   ];
   let manifestRelPath = null;
   if (MANIFEST_STORAGE_BACKENDS.includes(storageBackend) && staticRoot) {
-    const manifestSrc = (0, import_path11.join)(staticOutputDir, "staticfiles.json");
-    const resolvedStaticRoot = (0, import_path11.resolve)(workPath, staticRoot);
-    const manifestDest = (0, import_path11.join)(resolvedStaticRoot, "staticfiles.json");
-    await import_fs9.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
-    await import_fs9.default.promises.copyFile(manifestSrc, manifestDest);
-    manifestRelPath = (0, import_path11.relative)(workPath, manifestDest);
-    (0, import_build_utils12.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
+    const manifestSrc = (0, import_path12.join)(staticOutputDir, "staticfiles.json");
+    const resolvedStaticRoot = (0, import_path12.resolve)(workPath, staticRoot);
+    const manifestDest = (0, import_path12.join)(resolvedStaticRoot, "staticfiles.json");
+    await import_fs10.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
+    await import_fs10.default.promises.copyFile(manifestSrc, manifestDest);
+    manifestRelPath = (0, import_path12.relative)(workPath, manifestDest);
+    (0, import_build_utils13.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
   return {
     staticSourceDirs,
-    staticRoot: staticRoot ? (0, import_path11.resolve)(workPath, staticRoot) : null,
+    staticRoot: staticRoot ? (0, import_path12.resolve)(workPath, staticRoot) : null,
     manifestRelPath
   };
 }
 
 // src/index.ts
-var import_python_analysis7 = require("@vercel/python-analysis");
-var writeFile = import_fs10.default.promises.writeFile;
+var import_python_analysis8 = require("@vercel/python-analysis");
+var writeFile = import_fs11.default.promises.writeFile;
 var version = 3;
 async function runFrameworkHook(framework, ctx) {
   const hook = framework ? frameworkHooks[framework] : void 0;
@@ -5524,39 +6401,51 @@ var frameworkHooks = {
     detected
   }) => {
     if (detected?.baseDir === void 0) {
-      (0, import_build_utils13.debug)("Django hook: no manage.py detected, skipping");
+      (0, import_build_utils14.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
     const settingsResult = await getDjangoSettings(projectDir, pythonEnv);
-    (0, import_build_utils13.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    (0, import_build_utils14.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
     if (!settingsResult)
       return;
     const { djangoSettings, settingsModule } = settingsResult;
     let entrypoint;
+    let variableName;
     const baseDir = detected?.baseDir ?? "";
     const asgiApp = djangoSettings["ASGI_APPLICATION"];
     if (typeof asgiApp === "string") {
-      const rel = `${asgiApp.split(".").slice(0, -1).join("/")}.py`;
+      const parts = asgiApp.split(".");
+      variableName = parts.at(-1);
+      const rel = `${parts.slice(0, -1).join("/")}.py`;
       entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils13.debug)(`Django hook: ASGI entrypoint: ${entrypoint}`);
+      (0, import_build_utils14.debug)(
+        `Django hook: ASGI entrypoint: ${entrypoint} (variable: ${variableName})`
+      );
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
       if (typeof wsgiApp === "string") {
-        const rel = `${wsgiApp.split(".").slice(0, -1).join("/")}.py`;
+        const parts = wsgiApp.split(".");
+        variableName = parts.at(-1);
+        const rel = `${parts.slice(0, -1).join("/")}.py`;
         entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils13.debug)(`Django hook: WSGI entrypoint: ${entrypoint}`);
+        (0, import_build_utils14.debug)(
+          `Django hook: WSGI entrypoint: ${entrypoint} (variable: ${variableName})`
+        );
       }
     }
-    const outputStaticDir = (0, import_path12.join)(workPath, ".vercel", "output", "static");
-    const djangoStatic = await runDjangoCollectStatic(
-      venvPath,
-      workPath,
-      pythonEnv,
-      outputStaticDir,
-      settingsModule,
-      djangoSettings
-    );
-    return { entrypoint, djangoStatic };
+    let djangoStatic = null;
+    if (workPath && venvPath) {
+      const outputStaticDir = (0, import_path13.join)(workPath, ".vercel", "output", "static");
+      djangoStatic = await runDjangoCollectStatic(
+        venvPath,
+        workPath,
+        pythonEnv,
+        outputStaticDir,
+        settingsModule,
+        djangoSettings
+      );
+    }
+    return { entrypoint, variableName, djangoStatic };
   }
 };
 async function downloadFilesInWorkPath({
@@ -5565,13 +6454,13 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils13.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils13.download)(files, workPath, meta);
+  (0, import_build_utils14.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils14.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path12.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path12.join)(devCacheDir, (0, import_path12.basename)(entrypoint, ".py"));
-    await (0, import_build_utils13.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils13.glob)("**", destCache);
+    const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path13.join)(devCacheDir, (0, import_path13.basename)(entrypoint, ".py"));
+    await (0, import_build_utils14.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils14.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -5583,15 +6472,16 @@ var build = async ({
   entrypoint,
   meta = {},
   config,
-  span: parentSpan
+  span: parentSpan,
+  service
 }) => {
-  const builderSpan = parentSpan ?? new import_build_utils13.Span({ name: "vc.builder" });
+  const builderSpan = parentSpan ?? new import_build_utils14.Span({ name: "vc.builder" });
   const framework = config?.framework;
   const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils13.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils14.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -5600,17 +6490,17 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path12.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path13.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  let fsFiles = await (0, import_build_utils13.glob)("**", workPath);
+  let fsFiles = await (0, import_build_utils14.glob)("**", workPath);
   let detected;
   let entrypointNotFound;
-  if ((0, import_build_utils13.isPythonFramework)(framework) && // XXX: we might want to detect anyway for django!
+  if ((0, import_build_utils14.isPythonFramework)(framework) && // XXX: we might want to detect anyway for django!
   (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
     detected = await detectPythonEntrypoint(
       config.framework,
@@ -5618,13 +6508,13 @@ var build = async ({
       entrypoint
     ) ?? void 0;
     if (detected?.entrypoint) {
-      (0, import_build_utils13.debug)(
+      (0, import_build_utils14.debug)(
         `Resolved Python entrypoint to "${detected.entrypoint}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected.entrypoint;
     } else {
       const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      entrypointNotFound = new import_build_utils13.NowBuildError({
+      entrypointNotFound = new import_build_utils14.NowBuildError({
         code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
         message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searchedList}.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -5635,8 +6525,8 @@ var build = async ({
   if (entrypointNotFound && detected?.baseDir === void 0) {
     throw entrypointNotFound;
   }
-  const entryDirectory = detected?.baseDir ?? (0, import_path12.dirname)(entrypoint);
-  const entrypointAbsDir = (0, import_path12.join)(workPath, entryDirectory);
+  const entryDirectory = detected?.baseDir ?? (0, import_path13.dirname)(entrypoint);
+  const entrypointAbsDir = (0, import_path13.join)(workPath, entryDirectory);
   const rootDir = repoRootPath ?? workPath;
   const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
     () => discoverPackage({
@@ -5666,22 +6556,22 @@ var build = async ({
 `
     );
   }
-  fsFiles = await (0, import_build_utils13.glob)("**", workPath);
-  const venvPath = (0, import_path12.join)(workPath, ".vercel", "python", ".venv");
+  fsFiles = await (0, import_build_utils14.glob)("**", workPath);
+  const venvPath = service?.name ? (0, import_path13.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path13.join)(workPath, ".vercel", "python", ".venv");
   await builderSpan.child("vc.builder.python.venv").trace(async () => {
     await ensureVenv({
       pythonPath: pythonVersion.pythonPath,
       venvPath
     });
   });
-  if ((0, import_build_utils13.isPythonFramework)(framework)) {
+  if ((0, import_build_utils14.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils13.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils13.getEnvForPackageManager)({
+    } = await (0, import_build_utils14.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils14.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -5717,15 +6607,14 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  let noBuildCheckFailed = false;
-  await builderSpan.child(import_build_utils13.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils14.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
     if (projectInstallCommand) {
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils13.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils14.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -5756,22 +6645,6 @@ var build = async ({
       uvLockPath = lockPath;
       uvProjectDir = projectDir;
       projectName = pythonPackage?.manifest?.data?.project?.name;
-      if (lockFileProvidedByUser) {
-        try {
-          await uv.sync({
-            venvPath,
-            projectDir,
-            frozen: true,
-            noBuild: true,
-            noInstallProject: true
-          });
-        } catch (err) {
-          noBuildCheckFailed = true;
-          (0, import_build_utils13.debug)(
-            `--no-build check failed: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-      }
       await uv.sync({
         venvPath,
         projectDir,
@@ -5780,15 +6653,15 @@ var build = async ({
       });
     }
   });
-  if ((0, import_build_utils13.isPythonFramework)(framework)) {
+  if ((0, import_build_utils14.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils13.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils14.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils13.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils14.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
@@ -5803,7 +6676,7 @@ var build = async ({
   }
   const hookResult = await runFrameworkHook(framework, {
     pythonEnv,
-    projectDir: (0, import_path12.join)(workPath, entryDirectory),
+    projectDir: (0, import_path13.join)(workPath, entryDirectory),
     workPath,
     venvPath,
     entrypoint,
@@ -5818,18 +6691,18 @@ var build = async ({
   }
   const djangoStatic = hookResult?.djangoStatic ?? null;
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils13.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils14.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
-    projectDir: (0, import_path12.join)(workPath, entryDirectory),
+    projectDir: (0, import_path13.join)(workPath, entryDirectory),
     args: ["install", runtimeDep]
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
-    (0, import_build_utils13.debug)(`Installing ${workersDep}`);
+    (0, import_build_utils14.debug)(`Installing ${workersDep}`);
     await uv.pip({
       venvPath,
-      projectDir: (0, import_path12.join)(workPath, entryDirectory),
+      projectDir: (0, import_path13.join)(workPath, entryDirectory),
       args: ["install", workersDep]
     });
   }
@@ -5837,15 +6710,15 @@ var build = async ({
   if (quirksResult.buildEnv) {
     Object.assign(pythonEnv, quirksResult.buildEnv);
   }
-  (0, import_build_utils13.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils14.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const handlerFunction = typeof config?.handlerFunction === "string" ? config.handlerFunction : void 0;
   if (handlerFunction) {
-    const entrypointPath = (0, import_path12.join)(workPath, entrypoint);
-    const source = await import_fs10.default.promises.readFile(entrypointPath, "utf-8");
-    const found = await (0, import_python_analysis7.containsTopLevelCallable)(source, handlerFunction);
+    const entrypointPath = (0, import_path13.join)(workPath, entrypoint);
+    const source = await import_fs11.default.promises.readFile(entrypointPath, "utf-8");
+    const found = await (0, import_python_analysis8.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
-      throw new import_build_utils13.NowBuildError({
+      throw new import_build_utils14.NowBuildError({
         code: "PYTHON_HANDLER_NOT_FOUND",
         message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
       });
@@ -5854,9 +6727,10 @@ var build = async ({
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils13.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils14.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerFuncEnvLine = handlerFunction ? `
   "__VC_HANDLER_FUNC_NAME": "${handlerFunction}",` : "";
+  const variableName = hookResult?.variableName ?? detected?.variableName ?? "";
   const runtimeTrampoline = `
 import importlib
 import os
@@ -5870,7 +6744,8 @@ os.environ.update({
   "__VC_HANDLER_MODULE_NAME": "${moduleName}",
   "__VC_HANDLER_ENTRYPOINT": "${entrypointWithSuffix}",
   "__VC_HANDLER_ENTRYPOINT_ABS": os.path.join(_here, "${entrypointWithSuffix}"),
-  "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",${handlerFuncEnvLine}
+  "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",
+  "__VC_HANDLER_VARIABLE_NAME": "${variableName}",${handlerFuncEnvLine}
 })
 
 _vendor_rel = '${vendorDir}'
@@ -5919,7 +6794,7 @@ from vercel_runtime.vc_init import vc_handler
       ...djangoStatic.staticRoot ? [djangoStatic.staticRoot] : []
     ];
     for (const absDir of dirsToExclude) {
-      const rel = (0, import_path12.relative)(workPath, absDir);
+      const rel = (0, import_path13.relative)(workPath, absDir);
       if (!rel.startsWith("..")) {
         predefinedExcludes.push(`${rel}/**`);
       }
@@ -5928,14 +6803,17 @@ from vercel_runtime.vc_init import vc_handler
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
   Object.assign(lambdaEnv, quirksResult.env);
+  if (shouldInstallVercelWorkers) {
+    lambdaEnv.VERCEL_HAS_WORKER_SERVICES = "1";
+  }
   const globOptions = {
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils13.glob)("**", globOptions);
+  const files = await (0, import_build_utils14.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils13.FileFsRef({
-      fsPath: (0, import_path12.join)(workPath, djangoStatic.manifestRelPath)
+    files[djangoStatic.manifestRelPath] = new import_build_utils14.FileFsRef({
+      fsPath: (0, import_path13.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
   const depExternalizer = new PythonDependencyExternalizer({
@@ -5945,7 +6823,8 @@ from vercel_runtime.vc_init import vc_handler
     uvLockPath,
     uvProjectDir,
     projectName,
-    noBuildCheckFailed,
+    pythonMajor: pythonVersion.major,
+    pythonMinor: pythonVersion.minor,
     pythonPath: pythonVersion.pythonPath,
     hasCustomCommand,
     alwaysBundlePackages: [
@@ -5970,23 +6849,37 @@ from vercel_runtime.vc_init import vc_handler
     }
   });
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils13.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils14.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils13.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils14.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils13.Lambda({
+  const output = new import_build_utils14.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
     environment: lambdaEnv,
     supportsResponseStreaming: true
   });
+  if (uvLockPath) {
+    try {
+      await generateProjectManifest({
+        workPath,
+        pythonPackage,
+        pythonVersion,
+        uvLockPath
+      });
+    } catch (err) {
+      (0, import_build_utils14.debug)(
+        `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
   return { output };
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils13.isPythonFramework)(framework)) {
+  if ((0, import_build_utils14.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;
@@ -6005,7 +6898,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path12.parse)(entrypoint);
+  const { dir, name } = (0, import_path13.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -6018,6 +6911,7 @@ function hasProp(obj, key) {
 0 && (module.exports = {
   build,
   defaultShouldServe,
+  diagnostics,
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,