@vercel/python 6.22.1 → 6.24.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 fs9 = require("fs");
+    var fs10 = 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) {
-      fs9.stat(path, function(er, stat) {
+      fs10.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs9.statSync(path), path, options);
+      return checkStat(fs10.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 fs9 = require("fs");
+    var fs10 = require("fs");
     function isexe(path, options, cb) {
-      fs9.stat(path, function(er, stat) {
+      fs10.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs9.statSync(path), options);
+      return checkStat(fs10.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 fs9 = require("fs");
+    var fs10 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -137,12 +137,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve2, reject) {
+        return new Promise(function(resolve3, reject) {
           isexe(path, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve2(is);
+              resolve3(is);
             }
           });
         });
@@ -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 fs9 = require("fs");
+    var fs10 = 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 = fs9.openSync(command, "r");
-        fs9.readSync(fd, buffer, 0, size, 0);
-        fs9.closeSync(fd);
+        fd = fs10.openSync(command, "r");
+        fs10.readSync(fd, buffer, 0, size, 0);
+        fs10.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -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 fs9;
+    var fs10;
     try {
-      fs9 = require("fs");
+      fs10 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs9)
+      if (!fs10)
         return false;
-      return (stream instanceof (fs9.ReadStream || noop) || stream instanceof (fs9.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs10.ReadStream || noop) || stream instanceof (fs10.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2042,7 +2042,7 @@ var require_get_stream = __commonJS({
       options = Object.assign({ maxBuffer: Infinity }, options);
       const { maxBuffer } = options;
       let stream;
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve3, reject) => {
         const rejectPromise = (error) => {
           if (error) {
             error.bufferedData = stream.getBufferedValue();
@@ -2054,7 +2054,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve2();
+          resolve3();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -2078,11 +2078,11 @@ var require_p_finally = __commonJS({
       onFinally = onFinally || (() => {
       });
       return promise.then(
-        (val) => new Promise((resolve2) => {
-          resolve2(onFinally());
+        (val) => new Promise((resolve3) => {
+          resolve3(onFinally());
         }).then(() => val),
-        (err) => new Promise((resolve2) => {
-          resolve2(onFinally());
+        (err) => new Promise((resolve3) => {
+          resolve3(onFinally());
         }).then(() => {
           throw err;
         })
@@ -2461,8 +2461,8 @@ var require_execa = __commonJS({
       }
       let ret;
       if (!buffer) {
-        ret = new Promise((resolve2, reject) => {
-          process2[stream].once("end", resolve2).once("error", reject);
+        ret = new Promise((resolve3, reject) => {
+          process2[stream].once("end", resolve3).once("error", reject);
         });
       } else if (encoding) {
         ret = _getStream(process2[stream], {
@@ -2551,19 +2551,19 @@ ${stderr}${stdout}`;
           spawned.kill(parsed.opts.killSignal);
         }, parsed.opts.timeout);
       }
-      const processDone = new Promise((resolve2) => {
+      const processDone = new Promise((resolve3) => {
         spawned.on("exit", (code, signal) => {
           cleanup();
-          resolve2({ code, signal });
+          resolve3({ code, signal });
         });
         spawned.on("error", (err) => {
           cleanup();
-          resolve2({ error: err });
+          resolve3({ error: err });
         });
         if (spawned.stdin) {
           spawned.stdin.on("error", (err) => {
             cleanup();
-            resolve2({ error: err });
+            resolve3({ error: err });
           });
         }
       });
@@ -2647,6 +2647,360 @@ ${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 fs10 = require("fs");
+    var LDD_PATH = "/usr/bin/ldd";
+    var SELF_PATH = "/proc/self/exe";
+    var MAX_LENGTH = 2048;
+    var readFileSync2 = (path) => {
+      const fd = fs10.openSync(path, "r");
+      const buffer = Buffer.alloc(MAX_LENGTH);
+      const bytesRead = fs10.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs10.close(fd, () => {
+      });
+      return buffer.subarray(0, bytesRead);
+    };
+    var readFile2 = (path) => new Promise((resolve3, reject) => {
+      fs10.open(path, "r", (err, fd) => {
+        if (err) {
+          reject(err);
+        } else {
+          const buffer = Buffer.alloc(MAX_LENGTH);
+          fs10.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+            resolve3(buffer.subarray(0, bytesRead));
+            fs10.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) {
@@ -2751,14 +3105,14 @@ var require_get_port = __commonJS({
     };
     var releaseOldLockedPortsIntervalMs = 1e3 * 15;
     var interval;
-    var getAvailablePort = (options) => new Promise((resolve2, reject) => {
+    var getAvailablePort = (options) => new Promise((resolve3, reject) => {
       const server = net.createServer();
       server.unref();
       server.on("error", reject);
       server.listen(options, () => {
         const { port } = server.address();
         server.close(() => {
-          resolve2(port);
+          resolve3(port);
         });
       });
     });
@@ -2830,7 +3184,7 @@ var require_is_port_reachable = __commonJS({
     "use strict";
     var net = require("net");
     module2.exports = async (port, { timeout = 1e3, host } = {}) => {
-      const promise = new Promise((resolve2, reject) => {
+      const promise = new Promise((resolve3, reject) => {
         const socket = new net.Socket();
         const onError = () => {
           socket.destroy();
@@ -2841,7 +3195,7 @@ var require_is_port_reachable = __commonJS({
         socket.once("timeout", onError);
         socket.connect(port, host, () => {
           socket.end();
-          resolve2();
+          resolve3();
         });
       });
       try {
@@ -2872,7 +3226,7 @@ var import_fs10 = __toESM(require("fs"));
 var import_path12 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.7.0";
+var VERCEL_RUNTIME_VERSION = "0.9.0";
 var VERCEL_WORKERS_VERSION = "0.0.12";
 
 // src/index.ts
@@ -2887,8 +3241,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 +3625,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 +3731,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 +4209,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 = 245 * 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 +4223,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 +4313,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 +4363,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 +4394,8 @@ ${error.fileContent}`
       ...classification.privatePackages,
       "vercel-runtime",
       "vercel_runtime",
-      ...this.alwaysBundlePackages
+      ...this.alwaysBundlePackages,
+      ...forceBundledDueToWheels
     ];
     const alwaysBundledFiles = await mirrorPackagesIntoVendor({
       venvPath: this.venvPath,
@@ -4015,13 +4417,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 +4442,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 +4498,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,
@@ -4349,7 +4809,7 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint)
 
 // src/start-dev-server.ts
 var import_python_analysis4 = require("@vercel/python-analysis");
-var DEV_SERVER_STARTUP_TIMEOUT = 1e4;
+var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
     process
@@ -4390,7 +4850,7 @@ function createLogListener(callback, stream) {
   };
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function checkForPort(port, timeout) {
   const start = Date.now();
@@ -4520,7 +4980,7 @@ async function runSync({
       (0, import_build_utils8.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     (0, import_build_utils8.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
@@ -4544,7 +5004,7 @@ async function runSync({
     child.on("error", reject);
     child.on("exit", (code, signal) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
       } else {
         reject(
           new Error(
@@ -4555,6 +5015,7 @@ async function runSync({
     });
   });
 }
+var PENDING_RUNTIME_INSTALLS = /* @__PURE__ */ new Map();
 async function installVercelRuntime({
   workPath,
   uvPath,
@@ -4564,6 +5025,31 @@ async function installVercelRuntime({
   onStderr
 }) {
   const targetDir = (0, import_path8.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_fs6.mkdirSync)(targetDir, { recursive: true });
   const localRuntimeDir = (0, import_path8.join)(
     __dirname,
@@ -4592,7 +5078,7 @@ async function installVercelRuntime({
   );
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   const spawnArgs = [...pip.prefix, "--target", targetDir, runtimeDep];
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const child = (0, import_child_process2.spawn)(pip.cmd, spawnArgs, {
       cwd: workPath,
       env: getProtectedUvEnv(env),
@@ -4615,7 +5101,7 @@ async function installVercelRuntime({
     child.on("error", reject);
     child.on("exit", (code, signal) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
       } else {
         reject(
           new Error(
@@ -4667,9 +5153,9 @@ function installGlobalCleanupHandlers() {
     killAll();
   });
 }
-function createDevShim(workPath, entry, modulePath) {
+function createDevShim(workPath, entry, modulePath, serviceName, framework) {
   try {
-    const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
+    const vercelPythonDir = serviceName ? (0, import_path8.join)(workPath, ".vercel", "python", "services", serviceName) : (0, import_path8.join)(workPath, ".vercel", "python");
     (0, import_fs6.mkdirSync)(vercelPythonDir, { recursive: true });
     let qualifiedModule = modulePath;
     let extraPythonPath;
@@ -4687,10 +5173,14 @@ function createDevShim(workPath, entry, modulePath) {
       `${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);
+    const shimSource = template.replace(/__VC_DEV_MODULE_NAME__/g, qualifiedModule).replace(/__VC_DEV_ENTRY_ABS__/g, entryAbs).replace(/__VC_DEV_FRAMEWORK__/g, framework);
     (0, import_fs6.writeFileSync)(shimPath, shimSource, "utf8");
     (0, import_build_utils8.debug)(`Prepared Python dev shim at ${shimPath}`);
-    return { module: DEV_SHIM_MODULE, extraPythonPath };
+    return {
+      module: DEV_SHIM_MODULE,
+      extraPythonPath,
+      shimDir: vercelPythonDir
+    };
   } catch (err) {
     (0, import_build_utils8.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
     return null;
@@ -4721,7 +5211,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 +5240,37 @@ 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;
+  if ((serviceType === "cron" || serviceType === "worker") && rawEntrypoint?.endsWith(".py")) {
+    entry = rawEntrypoint;
+  } else {
+    const detected = await detectPythonEntrypoint(
+      framework,
+      workPath,
+      rawEntrypoint
+    );
+    entry = detected?.entrypoint;
+    if (!entry) {
+      const hookResult = await runFrameworkHook(framework, {
+        pythonEnv: env,
+        projectDir: (0, import_path8.join)(workPath, detected?.baseDir ?? ""),
+        workPath,
+        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 modulePath = entry.replace(/\.py$/i, "").replace(/[\\/]/g, ".");
   let childProcess = null;
@@ -4781,8 +5279,8 @@ var startDevServer = async (opts) => {
   let resolveChildReady;
   let rejectChildReady;
   const childReady = new Promise(
-    (resolve2, reject) => {
-      resolveChildReady = resolve2;
+    (resolve3, reject) => {
+      resolveChildReady = resolve3;
       rejectChildReady = reject;
     }
   );
@@ -4870,10 +5368,23 @@ If you are using a virtual environment, activate it before running "vercel dev",
     });
     const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
     env.PORT = `${port}`;
-    const 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_path8.join)(workPath, entry);
+    }
+    const devShim = createDevShim(
+      workPath,
+      entry,
+      modulePath,
+      serviceName,
+      framework
+    );
     if (devShim) {
-      const vercelPythonDir = (0, import_path8.join)(workPath, ".vercel", "python");
-      const pathParts = [vercelPythonDir];
+      const shimDir = devShim.shimDir || (0, import_path8.join)(workPath, ".vercel", "python");
+      const runtimeDir = (0, import_path8.join)(workPath, ".vercel", "python");
+      const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
       if (devShim.extraPythonPath) {
         pathParts.push(devShim.extraPythonPath);
       }
@@ -5034,7 +5545,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();
@@ -5403,24 +5915,109 @@ async function runQuirks(ctx) {
 }
 
 // src/django.ts
-var import_fs9 = require("fs");
+var import_fs9 = __toESM(require("fs"));
 var import_path11 = 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 = (0, import_fs9.readFileSync)(scriptPath, "utf-8");
+var script = import_fs9.default.readFileSync(scriptPath, "utf-8");
 async function getDjangoSettings(projectDir, env) {
   try {
     const { stdout } = await (0, import_execa5.default)("python", ["-c", script], {
       env,
       cwd: projectDir
     });
-    return JSON.parse(stdout);
+    const parsed = JSON.parse(stdout);
+    if (!parsed)
+      return null;
+    return {
+      settingsModule: parsed.settings_module,
+      djangoSettings: parsed.django_settings
+    };
   } catch (err) {
     (0, import_build_utils12.debug)(`Django hook: failed to discover settings from manage.py: ${err}`);
     return null;
   }
 }
+async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir, settingsModule, djangoSettings) {
+  const pythonPath = getVenvPythonBin(venvPath);
+  const storages = djangoSettings["STORAGES"];
+  const storageBackend = storages?.staticfiles?.BACKEND ?? djangoSettings["STATICFILES_STORAGE"] ?? "django.contrib.staticfiles.storage.StaticFilesStorage";
+  const staticUrl = djangoSettings["STATIC_URL"] ?? "/static/";
+  const staticRoot = djangoSettings["STATIC_ROOT"] != null ? String(djangoSettings["STATIC_ROOT"]) : null;
+  const whitenoiseUseFinders = djangoSettings["WHITENOISE_USE_FINDERS"] === true;
+  const installedApps = djangoSettings["INSTALLED_APPS"] ?? [];
+  const staticfilesDirs = djangoSettings["STATICFILES_DIRS"] ?? [];
+  const staticSourceDirs = [
+    ...installedApps.map((app) => (0, import_path11.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));
+  if (storageBackend.startsWith("storages.backends.")) {
+    console.log(
+      "django-storages detected \u2014 running collectstatic with original settings"
+    );
+    await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
+      env: { ...env, DJANGO_SETTINGS_MODULE: settingsModule },
+      cwd: workPath
+    });
+    return {
+      staticSourceDirs,
+      staticRoot: staticRoot ? (0, import_path11.resolve)(workPath, staticRoot) : null,
+      manifestRelPath: null
+    };
+  }
+  if (!staticRoot && !whitenoiseUseFinders) {
+    console.log(
+      "No collectstatic strategy configured \u2014 skipping collectstatic"
+    );
+    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 shimLines = [
+    `from ${settingsModule} import *`,
+    `STATIC_ROOT = ${JSON.stringify(staticOutputDir)}`
+  ];
+  if (whitenoiseUseFinders) {
+    shimLines.push(`WHITENOISE_USE_FINDERS = False`);
+  }
+  await import_fs9.default.promises.writeFile(shimPath, shimLines.join("\n") + "\n");
+  try {
+    console.log("Running collectstatic...");
+    await (0, import_execa5.default)(pythonPath, ["manage.py", "collectstatic", "--noinput"], {
+      env: {
+        ...env,
+        DJANGO_SETTINGS_MODULE: "_vercel_collectstatic_settings"
+      },
+      cwd: workPath
+    });
+  } finally {
+    await import_fs9.default.promises.unlink(shimPath).catch(() => {
+    });
+  }
+  const MANIFEST_STORAGE_BACKENDS = [
+    "django.contrib.staticfiles.storage.ManifestStaticFilesStorage",
+    "whitenoise.storage.CompressedManifestStaticFilesStorage"
+  ];
+  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`);
+  }
+  return {
+    staticSourceDirs,
+    staticRoot: staticRoot ? (0, import_path11.resolve)(workPath, staticRoot) : null,
+    manifestRelPath
+  };
+}
 
 // src/index.ts
 var import_python_analysis7 = require("@vercel/python-analysis");
@@ -5431,30 +6028,50 @@ async function runFrameworkHook(framework, ctx) {
   return hook?.(ctx);
 }
 var frameworkHooks = {
-  django: async ({ pythonEnv, projectDir, detected }) => {
+  django: async ({
+    pythonEnv,
+    projectDir,
+    workPath,
+    venvPath,
+    detected
+  }) => {
     if (detected?.baseDir === void 0) {
       (0, import_build_utils13.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
-    const settings = await getDjangoSettings(projectDir, pythonEnv);
-    (0, import_build_utils13.debug)(`Django settings: ${JSON.stringify(settings)}`);
-    if (!settings)
+    const settingsResult = await getDjangoSettings(projectDir, pythonEnv);
+    (0, import_build_utils13.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    if (!settingsResult)
       return;
+    const { djangoSettings, settingsModule } = settingsResult;
+    let entrypoint;
     const baseDir = detected?.baseDir ?? "";
-    const asgiApp = settings["ASGI_APPLICATION"];
+    const asgiApp = djangoSettings["ASGI_APPLICATION"];
     if (typeof asgiApp === "string") {
       const rel = `${asgiApp.split(".").slice(0, -1).join("/")}.py`;
-      const entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
+      entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
       (0, import_build_utils13.debug)(`Django hook: ASGI entrypoint: ${entrypoint}`);
-      return { entrypoint };
+    } else {
+      const wsgiApp = djangoSettings["WSGI_APPLICATION"];
+      if (typeof wsgiApp === "string") {
+        const rel = `${wsgiApp.split(".").slice(0, -1).join("/")}.py`;
+        entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
+        (0, import_build_utils13.debug)(`Django hook: WSGI entrypoint: ${entrypoint}`);
+      }
     }
-    const wsgiApp = settings["WSGI_APPLICATION"];
-    if (typeof wsgiApp === "string") {
-      const rel = `${wsgiApp.split(".").slice(0, -1).join("/")}.py`;
-      const entrypoint = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils13.debug)(`Django hook: WSGI entrypoint: ${entrypoint}`);
-      return { entrypoint };
+    let djangoStatic = null;
+    if (venvPath) {
+      const outputStaticDir = (0, import_path12.join)(workPath, ".vercel", "output", "static");
+      djangoStatic = await runDjangoCollectStatic(
+        venvPath,
+        workPath,
+        pythonEnv,
+        outputStaticDir,
+        settingsModule,
+        djangoSettings
+      );
     }
+    return { entrypoint, djangoStatic };
   }
 };
 async function downloadFilesInWorkPath({
@@ -5615,7 +6232,6 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  let noBuildCheckFailed = false;
   await builderSpan.child(import_build_utils13.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0
   }).trace(async () => {
@@ -5654,22 +6270,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,
@@ -5702,6 +6302,8 @@ var build = async ({
   const hookResult = await runFrameworkHook(framework, {
     pythonEnv,
     projectDir: (0, import_path12.join)(workPath, entryDirectory),
+    workPath,
+    venvPath,
     entrypoint,
     detected
   });
@@ -5712,6 +6314,7 @@ var build = async ({
   if (entrypointNotFound) {
     throw entrypointNotFound;
   }
+  const djangoStatic = hookResult?.djangoStatic ?? null;
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
   (0, import_build_utils13.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
@@ -5808,6 +6411,18 @@ from vercel_runtime.vc_init import vc_handler
     "**/yarn.lock",
     "**/package-lock.json"
   ];
+  if (djangoStatic) {
+    const dirsToExclude = [
+      ...djangoStatic.staticSourceDirs,
+      ...djangoStatic.staticRoot ? [djangoStatic.staticRoot] : []
+    ];
+    for (const absDir of dirsToExclude) {
+      const rel = (0, import_path12.relative)(workPath, absDir);
+      if (!rel.startsWith("..")) {
+        predefinedExcludes.push(`${rel}/**`);
+      }
+    }
+  }
   const lambdaEnv = {};
   lambdaEnv.PYTHONPATH = vendorDir;
   Object.assign(lambdaEnv, quirksResult.env);
@@ -5816,6 +6431,11 @@ from vercel_runtime.vc_init import vc_handler
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
   const files = await (0, import_build_utils13.glob)("**", globOptions);
+  if (djangoStatic?.manifestRelPath) {
+    files[djangoStatic.manifestRelPath] = new import_build_utils13.FileFsRef({
+      fsPath: (0, import_path12.join)(workPath, djangoStatic.manifestRelPath)
+    });
+  }
   const depExternalizer = new PythonDependencyExternalizer({
     venvPath,
     vendorDir,
@@ -5823,7 +6443,8 @@ from vercel_runtime.vc_init import vc_handler
     uvLockPath,
     uvProjectDir,
     projectName,
-    noBuildCheckFailed,
+    pythonMajor: pythonVersion.major,
+    pythonMinor: pythonVersion.minor,
     pythonPath: pythonVersion.pythonPath,
     hasCustomCommand,
     alwaysBundlePackages: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.22.1",
+  "version": "6.24.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -15,7 +15,7 @@
     "directory": "packages/python"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.9.1"
+    "@vercel/python-analysis": "0.10.0"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -25,19 +25,20 @@
     "@types/node": "20.11.0",
     "@types/which": "3.0.0",
     "cross-env": "7.0.3",
+    "detect-libc": "2.1.2",
     "execa": "^1.0.0",
     "fs-extra": "11.1.1",
+    "get-port": "5.1.1",
+    "is-port-reachable": "3.1.0",
     "jest-junit": "16.0.0",
     "minimatch": "10.1.1",
     "pip-requirements-js": "1.0.2",
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "get-port": "5.1.1",
-    "is-port-reachable": "3.1.0",
-    "@vercel/build-utils": "13.8.0",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/python-runtime": "0.7.0"
+    "@vercel/python-runtime": "0.9.0",
+    "@vercel/build-utils": "13.8.1"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",

package/templates/vc_django_settings.py

@@ -33,4 +33,12 @@ else:
 
     mod = importlib.import_module(settings_module)
     settings = {k: getattr(mod, k) for k in dir(mod) if k.isupper()}
-    print(json.dumps(settings, default=str))
+    print(
+        json.dumps(
+            {
+                "settings_module": settings_module,
+                "django_settings": settings,
+            },
+            default=str,
+        )
+    )

package/templates/vc_init_dev.py

@@ -6,6 +6,7 @@ os.environ.update(
     {
         "VERCEL_DEV_MODULE_NAME": "__VC_DEV_MODULE_NAME__",
         "VERCEL_DEV_ENTRY_ABS": "__VC_DEV_ENTRY_ABS__",
+        "VERCEL_DEV_FRAMEWORK": "__VC_DEV_FRAMEWORK__",
     }
 )