@vercel/python 6.23.0 → 6.24.0

package/dist/index.js

@@ -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) {
@@ -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 = 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 +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
@@ -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,
@@ -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;
@@ -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();
@@ -5547,15 +6059,18 @@ var frameworkHooks = {
         (0, import_build_utils13.debug)(`Django hook: WSGI entrypoint: ${entrypoint}`);
       }
     }
-    const outputStaticDir = (0, import_path12.join)(workPath, ".vercel", "output", "static");
-    const djangoStatic = await runDjangoCollectStatic(
-      venvPath,
-      workPath,
-      pythonEnv,
-      outputStaticDir,
-      settingsModule,
-      djangoSettings
-    );
+    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 };
   }
 };
@@ -5717,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 () => {
@@ -5756,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,
@@ -5945,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.23.0",
+  "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_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__",
     }
 )