npm - @vercel/python - Versions diffs - 6.42.0 → 6.43.0 - Mend

@vercel/python 6.42.0 → 6.43.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +506 -346
package/package.json +4 -4

package/dist/index.js CHANGED Viewed

@@ -2647,6 +2647,94 @@ ${stderr}${stdout}`;
   }
 });
+// ../../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: 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}`);
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, {
+      path: optPath = process.env.PATH,
+      pathExt: optPathExt = process.env.PATHEXT,
+      delimiter: optDelimiter = delimiter2
+    }) => {
+      const pathEnv = cmd.match(rSlash) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(optPath || /* istanbul ignore next: very unusual */
+        "").split(optDelimiter)
+      ];
+      if (isWindows) {
+        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+        const pathExt = pathExtExe.split(optDelimiter);
+        if (cmd.includes(".") && pathExt[0] !== "") {
+          pathExt.unshift("");
+        }
+        return { pathEnv, pathExt, pathExtExe };
+      }
+      return { pathEnv, pathExt: [""] };
+    };
+    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 + join13(pathPart, cmd);
+    };
+    var which2 = async (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const envPart of pathEnv) {
+        const p = getPathPart(envPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    var whichSync = (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const pathEnvPart of pathEnv) {
+        const p = getPathPart(pathEnvPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    module2.exports = which2;
+    which2.sync = whichSync;
+  }
+});
 // ../../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) {
@@ -2780,14 +2868,14 @@ var require_detect_libc = __commonJS({
       }
       return commandOut;
     };
-    var GLIBC2 = "glibc";
+    var GLIBC = "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;
+        return GLIBC;
       }
       if (Array.isArray(report.sharedObjects)) {
         if (report.sharedObjects.some(isFileMusl)) {
@@ -2798,8 +2886,8 @@ var require_detect_libc = __commonJS({
     };
     var familyFromCommand = (out) => {
       const [getconf, ldd1] = out.split(/[\r\n]+/);
-      if (getconf && getconf.includes(GLIBC2)) {
-        return GLIBC2;
+      if (getconf && getconf.includes(GLIBC)) {
+        return GLIBC;
       }
       if (ldd1 && ldd1.includes(MUSL2)) {
         return MUSL2;
@@ -2811,7 +2899,7 @@ var require_detect_libc = __commonJS({
         if (path.includes("/ld-musl-")) {
           return MUSL2;
         } else if (path.includes("/ld-linux-")) {
-          return GLIBC2;
+          return GLIBC;
         }
       }
       return null;
@@ -2822,7 +2910,7 @@ var require_detect_libc = __commonJS({
         return MUSL2;
       }
       if (content.includes("GNU C Library")) {
-        return GLIBC2;
+        return GLIBC;
       }
       return null;
     };
@@ -2910,8 +2998,8 @@ var require_detect_libc = __commonJS({
       }
       return family2;
     };
-    var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC2;
-    var isNonGlibcLinuxSync = () => isLinux() && familySync2() !== GLIBC2;
+    var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+    var isNonGlibcLinuxSync = () => isLinux() && familySync2() !== GLIBC;
     var versionFromFilesystem = async () => {
       if (cachedVersionFilesystem !== void 0) {
         return cachedVersionFilesystem;
@@ -2952,7 +3040,7 @@ var require_detect_libc = __commonJS({
     var versionSuffix = (s) => s.trim().split(/\s+/)[1];
     var versionFromCommand = (out) => {
       const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
-      if (getconf && getconf.includes(GLIBC2)) {
+      if (getconf && getconf.includes(GLIBC)) {
         return versionSuffix(getconf);
       }
       if (ldd1 && ldd2 && ldd1.includes(MUSL2)) {
@@ -2989,7 +3077,7 @@ var require_detect_libc = __commonJS({
       return version3;
     };
     module2.exports = {
-      GLIBC: GLIBC2,
+      GLIBC,
       MUSL: MUSL2,
       family,
       familySync: familySync2,
@@ -3001,94 +3089,6 @@ var require_detect_libc = __commonJS({
   }
 });
-// ../../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: 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}`);
-    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
-    var getPathInfo = (cmd, {
-      path: optPath = process.env.PATH,
-      pathExt: optPathExt = process.env.PATHEXT,
-      delimiter: optDelimiter = delimiter2
-    }) => {
-      const pathEnv = cmd.match(rSlash) ? [""] : [
-        // windows always checks the cwd first
-        ...isWindows ? [process.cwd()] : [],
-        ...(optPath || /* istanbul ignore next: very unusual */
-        "").split(optDelimiter)
-      ];
-      if (isWindows) {
-        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
-        const pathExt = pathExtExe.split(optDelimiter);
-        if (cmd.includes(".") && pathExt[0] !== "") {
-          pathExt.unshift("");
-        }
-        return { pathEnv, pathExt, pathExtExe };
-      }
-      return { pathEnv, pathExt: [""] };
-    };
-    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 + join13(pathPart, cmd);
-    };
-    var which2 = async (cmd, opt = {}) => {
-      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-      const found = [];
-      for (const envPart of pathEnv) {
-        const p = getPathPart(envPart, cmd);
-        for (const ext of pathExt) {
-          const withExt = p + ext;
-          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
-          if (is) {
-            if (!opt.all) {
-              return withExt;
-            }
-            found.push(withExt);
-          }
-        }
-      }
-      if (opt.all && found.length) {
-        return found;
-      }
-      if (opt.nothrow) {
-        return null;
-      }
-      throw getNotFoundError(cmd);
-    };
-    var whichSync = (cmd, opt = {}) => {
-      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-      const found = [];
-      for (const pathEnvPart of pathEnv) {
-        const p = getPathPart(pathEnvPart, cmd);
-        for (const ext of pathExt) {
-          const withExt = p + ext;
-          const is = isexe.sync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
-          if (is) {
-            if (!opt.all) {
-              return withExt;
-            }
-            found.push(withExt);
-          }
-        }
-      }
-      if (opt.all && found.length) {
-        return found;
-      }
-      if (opt.nothrow) {
-        return null;
-      }
-      throw getNotFoundError(cmd);
-    };
-    module2.exports = which2;
-    which2.sync = whichSync;
-  }
-});
 // ../../node_modules/.pnpm/get-port@5.1.1/node_modules/get-port/index.js
 var require_get_port = __commonJS({
   "../../node_modules/.pnpm/get-port@5.1.1/node_modules/get-port/index.js"(exports, module2) {
@@ -3231,31 +3231,32 @@ var import_fs13 = __toESM(require("fs"));
 var import_path13 = require("path");
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.13.2";
-var VERCEL_WORKERS_VERSION = "0.0.23";
+var VERCEL_RUNTIME_VERSION = "0.14.0";
+var VERCEL_WORKERS_VERSION = "0.0.24";
 // src/index.ts
-var import_build_utils16 = require("@vercel/build-utils");
+var import_build_utils17 = require("@vercel/build-utils");
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
 var import_fs4 = __toESM(require("fs"));
 var import_path5 = require("path");
-var import_build_utils4 = require("@vercel/build-utils");
+var import_build_utils5 = require("@vercel/build-utils");
 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
+var import_crypto = require("crypto");
 var import_child_process = require("child_process");
 var import_path = require("path");
 var import_path2 = require("path");
+var import_stream = require("stream");
+var import_promises = require("stream/promises");
 var import_execa = __toESM(require_execa());
 var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
@@ -3265,6 +3266,7 @@ var UV_VERSION = "0.10.11";
 var UV_PYTHON_PATH_PREFIX = "/uv/python/";
 var UV_PYTHON_DOWNLOADS_MODE = "automatic";
 var UV_CACHE_DIR_SUBPATH = [".vercel", "python", "cache", "uv"];
+var UV_BINARY_CHECKSUM = "5a360b0de092ddf4131f5313d0411b48c4e95e8107e40c3f8f2e9fcb636b3583";
 var isWin = process.platform === "win32";
 var uvExec = isWin ? "uv.exe" : "uv";
 var KNOWN_UV_PATH = "/usr/local/bin/uv";
@@ -3294,9 +3296,14 @@ var UvRunner = class {
   listInstalledPythons() {
     let output;
     try {
-      output = (0, import_child_process.execSync)(
-        `${this.uvPath} python list --only-installed --output-format json`,
-        { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+      output = (0, import_child_process.execFileSync)(
+        this.uvPath,
+        ["python", "list", "--only-installed", "--output-format", "json"],
+        {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "pipe"],
+          shell: isWin
+        }
       );
     } catch (err) {
       throw new Error(
@@ -3330,7 +3337,15 @@ var UvRunner = class {
     );
   }
   async sync(options) {
-    const { venvPath, projectDir, locked, frozen, noBuild, noInstallProject } = options;
+    const {
+      venvPath,
+      projectDir,
+      locked,
+      frozen,
+      noBuild,
+      noInstallProject,
+      pythonPlatform
+    } = options;
     const args = ["sync", "--active", "--no-dev", "--link-mode", "hardlink"];
     if (frozen) {
       args.push("--frozen");
@@ -3343,6 +3358,9 @@ var UvRunner = class {
     if (noInstallProject) {
       args.push("--no-install-project");
     }
+    if (pythonPlatform) {
+      args.push("--python-platform", pythonPlatform);
+    }
     args.push("--no-editable");
     await this.runUvCmd(args, projectDir, venvPath);
   }
@@ -3555,6 +3573,98 @@ async function getUvBinaryForBundling(pythonPath) {
   const resolvedPath = await import_fs.default.promises.realpath(uvPath);
   return resolvedPath;
 }
+var UV_LINUX_TARGET = "x86_64-unknown-linux-gnu";
+async function downloadUvBinaryForTarget(cacheDir) {
+  const destDir = (0, import_path.join)(cacheDir, `uv-${UV_VERSION}-${UV_LINUX_TARGET}`);
+  const destBinary = (0, import_path.join)(destDir, "uv");
+  try {
+    await import_fs.default.promises.access(destBinary, import_fs.default.constants.X_OK);
+    (0, import_build_utils.debug)(`Using cached uv binary at ${destBinary}`);
+    return destBinary;
+  } catch {
+  }
+  const tarballName = `uv-${UV_LINUX_TARGET}.tar.gz`;
+  const url = `https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${tarballName}`;
+  (0, import_build_utils.debug)(`Downloading uv ${UV_VERSION} from ${url}`);
+  console.log(
+    `Downloading uv ${UV_VERSION} (linux x86_64) for runtime dependency installation...`
+  );
+  await import_fs.default.promises.mkdir(destDir, { recursive: true });
+  const tarballPath = (0, import_path.join)(destDir, tarballName);
+  await downloadUvTarball(url, tarballPath);
+  const actualHash = await sha256File(tarballPath);
+  if (actualHash !== UV_BINARY_CHECKSUM) {
+    await import_fs.default.promises.unlink(tarballPath).catch(() => {
+    });
+    throw new import_build_utils.NowBuildError({
+      code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+      message: `checksum mismatch for ${tarballName}: expected ${UV_BINARY_CHECKSUM}, got ${actualHash}`
+    });
+  }
+  try {
+    await (0, import_execa.default)("tar", [
+      "xzf",
+      tarballPath,
+      "--strip-components=1",
+      "-C",
+      destDir
+    ]);
+  } catch (err) {
+    throw new import_build_utils.NowBuildError({
+      code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+      message: `could not extract ${tarballName}: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  await import_fs.default.promises.chmod(destBinary, 493);
+  await import_fs.default.promises.unlink(tarballPath).catch(() => {
+  });
+  (0, import_build_utils.debug)(`Downloaded uv binary to ${destBinary}`);
+  return destBinary;
+}
+async function downloadUvTarball(url, dest) {
+  const tmpDest = `${dest}.${process.pid}.${Date.now()}.tmp`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 6e4);
+  try {
+    const response = await fetch(url, {
+      redirect: "follow",
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new import_build_utils.NowBuildError({
+        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+        message: `could not download ${url}: HTTP ${response.status}`
+      });
+    }
+    if (!response.body) {
+      throw new import_build_utils.NowBuildError({
+        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+        message: `could not download ${url}: response body was empty`
+      });
+    }
+    await (0, import_promises.pipeline)(
+      import_stream.Readable.fromWeb(response.body),
+      import_fs.default.createWriteStream(tmpDest)
+    );
+    await import_fs.default.promises.rename(tmpDest, dest);
+  } catch (err) {
+    await import_fs.default.promises.unlink(tmpDest).catch(() => {
+    });
+    if (err instanceof import_build_utils.NowBuildError) {
+      throw err;
+    }
+    throw new import_build_utils.NowBuildError({
+      code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+      message: `could not download ${url}: ${err instanceof Error ? err.message : String(err)}`
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function sha256File(filePath) {
+  const data = await import_fs.default.promises.readFile(filePath);
+  return (0, import_crypto.createHash)("sha256").update(new Uint8Array(data)).digest("hex");
+}
 // src/utils.ts
 var isWin2 = process.platform === "win32";
@@ -3684,6 +3794,17 @@ async function runPyprojectScript(workPath, scriptNames, env, useUserVirtualEnv
   }
   return false;
 }
+// src/version.ts
+var import_path4 = require("path");
+var import_fs3 = require("fs");
+var import_build_utils4 = require("@vercel/build-utils");
+var import_python_analysis = require("@vercel/python-analysis");
+// src/platform-info.ts
+var import_os2 = __toESM(require("os"));
+var detectLibc = __toESM(require_detect_libc());
+var import_build_utils3 = require("@vercel/build-utils");
 var ARCH_MAP = {
   x64: "x86_64",
   arm64: "aarch64",
@@ -3693,58 +3814,73 @@ var ARCH_MAP = {
   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";
   const SYS_PLATFORM_MAP = {
     linux: "linux",
     win32: "win32",
     darwin: "darwin"
   };
-  const sysPlatform = SYS_PLATFORM_MAP[process.platform] || "linux";
   const OS_MAP = {
     linux: "linux",
     win32: "windows",
     darwin: "macos"
   };
-  const detectedOs = OS_MAP[process.platform] || "linux";
-  return {
-    osName,
-    archName,
-    osMajor,
-    osMinor,
-    os: detectedOs,
-    sysPlatform,
-    libc
+  const arch = import_os2.default.arch();
+  const libcFamily = detectLibc.familySync();
+  const libcVersion = detectLibc.versionSync();
+  const platform = {
+    osName: "manylinux",
+    archName: ARCH_MAP[arch] || arch,
+    osMajor: 2,
+    osMinor: 17,
+    os: OS_MAP[process.platform] || "linux",
+    sysPlatform: SYS_PLATFORM_MAP[process.platform] || "linux",
+    libc: "gnu"
   };
+  if (libcFamily === detectLibc.MUSL) {
+    platform.osName = "musllinux";
+    platform.libc = "musl";
+  }
+  if (libcVersion) {
+    const parts = libcVersion.split(".");
+    platform.osMajor = parseInt(parts[0], 10);
+    platform.osMinor = parseInt(parts[1], 10) || 0;
+  }
+  return platform;
+}
+function validateBuildArch(arch) {
+  switch (arch.toLowerCase()) {
+    case "x86_64":
+      return "x86_64";
+    case "aarch64":
+      return "aarch64";
+    default:
+      throw new import_build_utils3.NowBuildError({
+        code: "INVALID_BUILD_ARCH",
+        message: `Unrecognized VERCEL_BUILD_ARCH "${arch}". Expected "x86_64" or "aarch64".`
+      });
+  }
+}
+function detectTargetPlatform() {
+  if (process.env.VERCEL_BUILD_IMAGE && process.platform === "linux") {
+    return detectPlatform();
+  }
+  const arch = process.env.VERCEL_BUILD_ARCH;
+  const platform = {
+    osName: "manylinux",
+    archName: "x86_64",
+    osMajor: 2,
+    osMinor: 17,
+    os: "linux",
+    sysPlatform: "linux",
+    libc: "gnu"
+  };
+  if (arch) {
+    platform.archName = validateBuildArch(arch);
+  }
+  return platform;
 }
 // src/version.ts
-var import_path4 = require("path");
-var import_fs3 = require("fs");
-var import_build_utils3 = require("@vercel/build-utils");
-var import_python_analysis = require("@vercel/python-analysis");
 function pythonVersionString(pv) {
   if (pv.major === void 0 || pv.minor === void 0)
     return void 0;
@@ -3794,7 +3930,7 @@ function getDefaultPythonVersion({
   }
   const selection = allOptions.find(isInstalled);
   if (!selection) {
-    throw new import_build_utils3.NowBuildError({
+    throw new import_build_utils4.NowBuildError({
       code: "PYTHON_NOT_FOUND",
       link: "https://vercel.link/python-version",
       message: `Unable to find any supported Python versions.`
@@ -3894,7 +4030,7 @@ function resolvePythonVersion({
     } else if (result.notAvailable) {
       const npv = getPythonVersionForBuild(result.notAvailable.build);
       if (npv && isDiscontinued(npv)) {
-        throw new import_build_utils3.NowBuildError({
+        throw new import_build_utils4.NowBuildError({
           code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
           link: "https://vercel.link/python-version",
           message: `Python version "${pythonVersionString(npv)}" detected in ${source} is discontinued and must be upgraded.`
@@ -3918,7 +4054,7 @@ function resolvePythonVersion({
     }
   }
   if (isDiscontinued(selection)) {
-    throw new import_build_utils3.NowBuildError({
+    throw new import_build_utils4.NowBuildError({
       code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
       link: "https://vercel.link/python-version",
       message: `Python version "${pythonVersionString(selection)}" declared in project configuration is discontinued and must be upgraded.`
@@ -3976,7 +4112,7 @@ function getInstalledPythons() {
   }
   const uvPath = findUvInPath();
   if (!uvPath) {
-    throw new import_build_utils3.NowBuildError({
+    throw new import_build_utils4.NowBuildError({
       code: "UV_ERROR",
       link: "https://vercel.link/python-version",
       message: "uv is required but was not found in PATH."
@@ -3994,7 +4130,7 @@ function isInstalled(pv) {
       return false;
     return installed.has(version2);
   } catch (err) {
-    throw new import_build_utils3.NowBuildError({
+    throw new import_build_utils4.NowBuildError({
       code: "UV_ERROR",
       link: "https://vercel.link/python-version",
       message: err instanceof Error ? err.message : String(err)
@@ -4008,7 +4144,7 @@ async function restoreCachedLock(cachedLockPath, projectDir) {
     return;
   const targetLockPath = (0, import_path5.join)(projectDir, "uv.lock");
   if (import_fs4.default.existsSync(cachedLockPath) && !import_fs4.default.existsSync(targetLockPath)) {
-    (0, import_build_utils4.debug)("Restoring cached uv.lock");
+    (0, import_build_utils5.debug)("Restoring cached uv.lock");
     await import_fs4.default.promises.copyFile(cachedLockPath, targetLockPath);
   }
 }
@@ -4075,7 +4211,7 @@ print(json.dumps(paths))
       return parsed.filter((p) => typeof p === "string");
     }
   } catch (err) {
-    (0, import_build_utils4.debug)("Failed to parse site-packages output", err);
+    (0, import_build_utils5.debug)("Failed to parse site-packages output", err);
   }
   return [];
 }
@@ -4101,7 +4237,7 @@ async function discoverPackage({
 ${error.fileContent}`
         );
       }
-      throw new import_build_utils4.NowBuildError({
+      throw new import_build_utils5.NowBuildError({
         code: error.code,
         message: error.message,
         link: error.link,
@@ -4240,7 +4376,7 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
       ...filterUnsafeUvPipArgs(args)
     ];
     const prettyUv = `${uvPath} ${uvArgs.join(" ")}`;
-    (0, import_build_utils4.debug)(`Running "${prettyUv}"...`);
+    (0, import_build_utils5.debug)(`Running "${prettyUv}"...`);
     try {
       await (0, import_execa3.default)(uvPath, uvArgs, {
         cwd: workPath,
@@ -4249,7 +4385,7 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
       return;
     } catch (err) {
       console.log(`Failed to run "${prettyUv}", falling back to pip`);
-      (0, import_build_utils4.debug)(`error: ${err}`);
+      (0, import_build_utils5.debug)(`error: ${err}`);
     }
   }
   const cmdArgs = [
@@ -4262,14 +4398,14 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
     ...args
   ];
   const pretty = `${pipPath} ${cmdArgs.join(" ")}`;
-  (0, import_build_utils4.debug)(`Running "${pretty}"...`);
+  (0, import_build_utils5.debug)(`Running "${pretty}"...`);
   try {
     await (0, import_execa3.default)(pipPath, cmdArgs, {
       cwd: workPath
     });
   } catch (err) {
     console.log(`Failed to run "${pretty}"`);
-    (0, import_build_utils4.debug)(`error: ${err}`);
+    (0, import_build_utils5.debug)(`error: ${err}`);
     throw err;
   }
 }
@@ -4286,7 +4422,7 @@ async function installRequirement({
 }) {
   const actualTargetDir = targetDir || workPath;
   if (meta.isDev && await isInstalled2(pythonPath, dependency, actualTargetDir)) {
-    (0, import_build_utils4.debug)(
+    (0, import_build_utils5.debug)(
       `Skipping ${dependency} dependency installation, already installed in ${actualTargetDir}`
     );
     return;
@@ -4306,7 +4442,7 @@ async function installRequirementsFile({
 }) {
   const actualTargetDir = targetDir || workPath;
   if (meta.isDev && await areRequirementsInstalled(pythonPath, filePath, actualTargetDir)) {
-    (0, import_build_utils4.debug)(`Skipping requirements file installation, already installed`);
+    (0, import_build_utils5.debug)(`Skipping requirements file installation, already installed`);
     return;
   }
   await pipInstall(
@@ -4322,7 +4458,7 @@ async function installRequirementsFile({
 var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
 var import_path6 = require("path");
-var import_build_utils5 = require("@vercel/build-utils");
+var import_build_utils6 = require("@vercel/build-utils");
 var import_python_analysis3 = require("@vercel/python-analysis");
 var readFile = (0, import_util.promisify)(import_fs5.default.readFile);
 var LAMBDA_SIZE_THRESHOLD_BYTES = 245 * 1024 * 1024;
@@ -4339,14 +4475,11 @@ function shouldShowFunctionsBetaHint() {
 var PythonDependencyExternalizer = class {
   constructor(options) {
     // Populated by analyze()
+    this.sitePackageDirs = [];
+    this.distributions = /* @__PURE__ */ new Map();
     this.allVendorFiles = {};
     this.totalBundleSize = 0;
     this.analyzed = false;
-    // Resolved once at the start of analyze().  The venv is immutable
-    // after construction (quirks run before the bundle span) so these
-    // do not change between analyze() and generateBundle().
-    this.sitePackageDirs = null;
-    this.distributions = null;
     this.venvPath = options.venvPath;
     this.vendorDir = options.vendorDir;
     this.workPath = options.workPath;
@@ -4397,12 +4530,12 @@ var PythonDependencyExternalizer = class {
     this.totalBundleSize = await calculateBundleSize(tempFilesForSizing);
     this.analyzed = true;
     const totalBundleSizeMB = (this.totalBundleSize / (1024 * 1024)).toFixed(2);
-    (0, import_build_utils5.debug)(`Total bundle size: ${totalBundleSizeMB} MB`);
+    (0, import_build_utils6.debug)(`Total bundle size: ${totalBundleSizeMB} MB`);
     const runtimeInstallEnabled = this.shouldEnableRuntimeInstall();
     const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
     if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.hasCustomCommand && !pythonOnHiveEnabled) {
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils6.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
         message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the size limit (${limitMB} MB).
@@ -4420,7 +4553,7 @@ dependencies, you can:
     }
     if (pythonOnHiveEnabled && this.totalBundleSize > HIVE_LAMBDA_SIZE_BYTES) {
       const limitMB = (HIVE_LAMBDA_SIZE_BYTES / (1024 * 1024)).toFixed(0);
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils6.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
         message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB).
@@ -4451,7 +4584,7 @@ application into smaller functions.`,
       );
     }
     if (!this.uvLockPath || !this.uvProjectDir) {
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils6.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
         message: "Runtime dependency installation requires a uv.lock file and project directory."
       });
@@ -4462,7 +4595,7 @@ application into smaller functions.`,
     );
     if (this.totalBundleSize > LAMBDA_EPHEMERAL_STORAGE_BYTES) {
       const ephemeralLimitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(0);
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils6.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
         message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the ephemeral storage limit (${ephemeralLimitMB} MB).
@@ -4489,7 +4622,7 @@ your application into smaller functions.`,
           `Failed to read uv.lock file at "${this.uvLockPath}": ${String(error)}`
         );
       }
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils6.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
         message: `Failed to read uv.lock file at "${this.uvLockPath}"`
       });
@@ -4505,7 +4638,7 @@ your application into smaller functions.`,
 ${error.fileContent}`
           );
         }
-        throw new import_build_utils5.NowBuildError({
+        throw new import_build_utils6.NowBuildError({
           code: error.code,
           message: error.message
         });
@@ -4515,7 +4648,7 @@ ${error.fileContent}`
     const excludePackages = [];
     if (this.projectName) {
       excludePackages.push(this.projectName);
-      (0, import_build_utils5.debug)(
+      (0, import_build_utils6.debug)(
         `Excluding project package "${this.projectName}" from runtime installation`
       );
     }
@@ -4523,7 +4656,7 @@ ${error.fileContent}`
       lockFile,
       excludePackages
     });
-    (0, import_build_utils5.debug)(
+    (0, import_build_utils6.debug)(
       `Package classification: ${classification.privatePackages.length} private, ${classification.publicPackages.length} public`
     );
     const forceBundledDueToWheels = await this.findPackagesWithoutCompatibleWheels(
@@ -4542,7 +4675,7 @@ ${error.fileContent}`
       (name) => !forceBundledSet.has((0, import_python_analysis3.normalizePackageName)(name))
     );
     if (externalizablePublic.length === 0) {
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils6.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
         message: `Bundle size exceeds the Lambda limit and requires runtime
 dependency installation, but no public packages have compatible
@@ -4575,14 +4708,12 @@ To fix this, either:
     }
     const fixedOverhead = await calculateBundleSize(baseFiles);
     let runtimeToolingOverhead = 0;
-    if (process.env.VERCEL_BUILD_IMAGE) {
-      try {
-        const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
-        const uvStats = await import_fs5.default.promises.stat(uvBinaryPath);
-        runtimeToolingOverhead = uvStats.size;
-      } catch {
-        runtimeToolingOverhead = 50 * 1024 * 1024;
-      }
+    try {
+      const uvBinaryPath = await this.resolveUvBinaryForBundling();
+      const uvStats = await import_fs5.default.promises.stat(uvBinaryPath);
+      runtimeToolingOverhead = uvStats.size;
+    } catch {
+      runtimeToolingOverhead = 50 * 1024 * 1024;
     }
     runtimeToolingOverhead += 4 * 1024;
     const projectDirRel = (0, import_path6.relative)(this.workPath, this.uvProjectDir);
@@ -4598,7 +4729,7 @@ To fix this, either:
         runtimeToolingOverhead += uvLockStats.size;
     }
     const remainingCapacity = LAMBDA_SIZE_THRESHOLD_BYTES - fixedOverhead - runtimeToolingOverhead;
-    (0, import_build_utils5.debug)(
+    (0, import_build_utils6.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(
@@ -4626,10 +4757,10 @@ To fix this, either:
     ];
     if (isOutsideWorkPath) {
       const srcPyproject = (0, import_path6.join)(this.uvProjectDir, "pyproject.toml");
-      files[`${UV_BUNDLE_DIR}/pyproject.toml`] = new import_build_utils5.FileFsRef({
+      files[`${UV_BUNDLE_DIR}/pyproject.toml`] = new import_build_utils6.FileFsRef({
         fsPath: srcPyproject
       });
-      files[`${UV_BUNDLE_DIR}/uv.lock`] = new import_build_utils5.FileFsRef({
+      files[`${UV_BUNDLE_DIR}/uv.lock`] = new import_build_utils6.FileFsRef({
         fsPath: this.uvLockPath
       });
     }
@@ -4637,36 +4768,33 @@ To fix this, either:
       projectDir: isOutsideWorkPath ? UV_BUNDLE_DIR : projectDirRel,
       bundledPackages: bundledPackagesForConfig
     });
-    files[`${UV_BUNDLE_DIR}/_runtime_config.json`] = new import_build_utils5.FileBlob({
+    files[`${UV_BUNDLE_DIR}/_runtime_config.json`] = new import_build_utils6.FileBlob({
       data: runtimeConfigData
     });
-    if (process.env.VERCEL_BUILD_IMAGE) {
-      try {
-        const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
-        const uvBundleDir = (0, import_path6.join)(this.workPath, UV_BUNDLE_DIR);
-        const uvLocalPath = (0, import_path6.join)(uvBundleDir, "uv");
-        await import_fs5.default.promises.mkdir(uvBundleDir, { recursive: true });
-        await import_fs5.default.promises.copyFile(uvBinaryPath, uvLocalPath);
-        await import_fs5.default.promises.chmod(uvLocalPath, 493);
-        const uvBundlePath = `${UV_BUNDLE_DIR}/uv`;
-        files[uvBundlePath] = new import_build_utils5.FileFsRef({
-          fsPath: uvLocalPath,
-          mode: 33261
-          // Regular file + executable
-        });
-        (0, import_build_utils5.debug)(`Bundled uv binary from ${uvBinaryPath} to ${uvLocalPath}`);
-      } catch (err) {
-        throw new import_build_utils5.NowBuildError({
-          code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-          message: `Failed to bundle uv binary for runtime installation: ${err instanceof Error ? err.message : String(err)}`
-        });
-      }
+    try {
+      const uvBinaryPath = await this.resolveUvBinaryForBundling();
+      const uvBundleDir = (0, import_path6.join)(this.workPath, UV_BUNDLE_DIR);
+      const uvLocalPath = (0, import_path6.join)(uvBundleDir, "uv");
+      await import_fs5.default.promises.mkdir(uvBundleDir, { recursive: true });
+      await import_fs5.default.promises.copyFile(uvBinaryPath, uvLocalPath);
+      await import_fs5.default.promises.chmod(uvLocalPath, 493);
+      const uvBundlePath = `${UV_BUNDLE_DIR}/uv`;
+      files[uvBundlePath] = new import_build_utils6.FileFsRef({
+        fsPath: uvLocalPath,
+        mode: 33261
+      });
+      (0, import_build_utils6.debug)(`Bundled uv binary from ${uvBinaryPath} to ${uvLocalPath}`);
+    } catch (err) {
+      throw new import_build_utils6.NowBuildError({
+        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+        message: `Failed to bundle uv binary for runtime installation: ${err instanceof Error ? err.message : String(err)}`
+      });
     }
     const finalBundleSize = await calculateBundleSize(files);
     if (finalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES + 100 * 1024) {
       const finalSizeMB = (finalBundleSize / (1024 * 1024)).toFixed(2);
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
-      throw new import_build_utils5.NowBuildError({
+      throw new import_build_utils6.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
         message: shouldShowFunctionsBetaHint() ? `Total bundle size (${finalSizeMB} MB) exceeds the size limit (${limitMB} MB).
@@ -4692,9 +4820,9 @@ splitting your application.`,
    * irrelevant.
    */
   async findPackagesWithoutCompatibleWheels(lockFile, publicPackageNames) {
-    const platform = detectPlatform();
+    const platform = detectTargetPlatform();
     if (this.pythonMajor === void 0 || this.pythonMinor === void 0) {
-      (0, import_build_utils5.debug)("Skipping wheel compatibility check: dev mode");
+      (0, import_build_utils6.debug)("Skipping wheel compatibility check: dev mode");
       return [];
     }
     const reachable = await getPackagesReachableOnPlatform(
@@ -4709,7 +4837,7 @@ splitting your application.`,
       (name) => reachable.has((0, import_python_analysis3.normalizePackageName)(name))
     ) : publicPackageNames;
     if (relevantPackages.length < publicPackageNames.length) {
-      (0, import_build_utils5.debug)(
+      (0, import_build_utils6.debug)(
         `Skipping wheel check for ${publicPackageNames.length - relevantPackages.length} package(s) not reachable on the target platform`
       );
     }
@@ -4749,7 +4877,7 @@ splitting your application.`,
             break;
           }
         } catch (err) {
-          (0, import_build_utils5.debug)(
+          (0, import_build_utils6.debug)(
             `Failed to check wheel compatibility for ${filename}: ${err instanceof Error ? err.message : String(err)}`
           );
         }
@@ -4760,6 +4888,15 @@ splitting your application.`,
     }
     return incompatible;
   }
+  /** Resolve the uv binary for bundling (host binary on build image, downloaded on local). */
+  async resolveUvBinaryForBundling() {
+    if (process.env.VERCEL_BUILD_IMAGE) {
+      return getUvBinaryForBundling(this.pythonPath);
+    }
+    return downloadUvBinaryForTarget(
+      (0, import_path6.join)(this.workPath, ".vercel", "python", "cache")
+    );
+  }
   /**
    * Mirror packages from site-packages into the _vendor directory.
    *
@@ -4829,13 +4966,13 @@ splitting your application.`,
     );
     for (const result of results) {
       if (result) {
-        vendorFiles[result.bundlePath] = new import_build_utils5.FileFsRef({
+        vendorFiles[result.bundlePath] = new import_build_utils6.FileFsRef({
           fsPath: result.srcFsPath,
           size: result.size
         });
       }
     }
-    (0, import_build_utils5.debug)(
+    (0, import_build_utils6.debug)(
       `Mirrored ${Object.keys(vendorFiles).length} files` + (includePackages ? ` from ${includePackages.length} packages` : "")
     );
     return vendorFiles;
@@ -4916,13 +5053,13 @@ async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor
             platformMachine
           );
           if (!compatible) {
-            (0, import_build_utils5.debug)(
+            (0, import_build_utils6.debug)(
               `Skipping dependency ${dep.name}: marker "${dep.marker}" not satisfied on ${sysPlatform}`
             );
             continue;
           }
         } catch (err) {
-          (0, import_build_utils5.debug)(
+          (0, import_build_utils6.debug)(
             `Failed to evaluate marker "${dep.marker}" for ${dep.name}, including conservatively: ${err instanceof Error ? err.message : String(err)}`
           );
         }
@@ -4992,7 +5129,7 @@ function lambdaKnapsack(packages, capacity) {
 // src/diagnostics.ts
 var import_fs6 = __toESM(require("fs"));
-var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 var import_python_analysis4 = require("@vercel/python-analysis");
 function isDependencyGroupInclude(entry) {
   return typeof entry === "object" && "include-group" in entry;
@@ -5197,7 +5334,7 @@ async function generateProjectManifest({
     }
   }
   const manifest = {
-    version: import_build_utils6.MANIFEST_VERSION,
+    version: import_build_utils7.MANIFEST_VERSION,
     runtime: "python",
     ...framework ? { framework } : {},
     ...serviceType ? { serviceType } : {},
@@ -5211,22 +5348,22 @@ async function generateProjectManifest({
       ...transitiveEntries.sort((a, b) => a.name.localeCompare(b.name))
     ]
   };
-  await (0, import_build_utils6.writeProjectManifest)(manifest, workPath, "python");
+  await (0, import_build_utils7.writeProjectManifest)(manifest, workPath, "python");
 }
-var diagnostics = (0, import_build_utils6.createDiagnostics)("python");
+var diagnostics = (0, import_build_utils7.createDiagnostics)("python");
 // src/crons.ts
 var import_fs8 = __toESM(require("fs"));
 var import_path8 = require("path");
 var import_execa4 = __toESM(require_execa());
-var import_build_utils10 = require("@vercel/build-utils");
+var import_build_utils11 = require("@vercel/build-utils");
 // src/entrypoint.ts
 var import_fs7 = __toESM(require("fs"));
 var import_path7 = require("path");
-var import_build_utils7 = require("@vercel/build-utils");
 var import_build_utils8 = require("@vercel/build-utils");
 var import_build_utils9 = require("@vercel/build-utils");
+var import_build_utils10 = require("@vercel/build-utils");
 var import_python_analysis5 = require("@vercel/python-analysis");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
@@ -5380,7 +5517,7 @@ async function resolveModuleAttrEntrypoint(workPath, value) {
   return null;
 }
 async function getVercelToolsEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils10.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const vercelEntrypoint = pyprojectData.tool?.vercel?.entrypoint;
@@ -5389,7 +5526,7 @@ async function getVercelToolsEntrypoint(workPath) {
   return resolveModuleAttrEntrypoint(workPath, vercelEntrypoint);
 }
 async function getPyprojectEntrypointWithDiagnostics(workPath) {
-  const pyprojectData = await (0, import_build_utils9.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils10.readConfigFile)((0, import_path7.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return { entrypoint: null };
   const scripts = pyprojectData.project?.scripts;
@@ -5419,7 +5556,7 @@ async function findValidEntrypoint(workPath, candidates) {
     const content = await import_fs7.default.promises.readFile(absPath, "utf-8");
     const varName = await (0, import_python_analysis5.findAppOrHandler)(content);
     if (varName) {
-      (0, import_build_utils8.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
+      (0, import_build_utils9.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
       return {
         entrypoint: { entrypoint: candidate, variableName: varName },
         existingWithoutEntrypoint
@@ -5435,7 +5572,7 @@ async function checkDjangoManage(workPath) {
     const content = await import_fs7.default.promises.readFile(managePath, "utf-8");
     if (!content.includes("DJANGO_SETTINGS_MODULE"))
       return false;
-    (0, import_build_utils8.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
+    (0, import_build_utils9.debug)(`Found Django manage.py with DJANGO_SETTINGS_MODULE at ${workPath}`);
     return true;
   } catch {
     return false;
@@ -5488,7 +5625,7 @@ ${suggestion}`;
     const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
     message = `No ${displayName} entrypoint found. Set "tool.vercel.entrypoint" in pyproject.toml or define an entrypoint in one of: ${searchedList}.`;
   }
-  return new import_build_utils7.NowBuildError({ code, message, link, action });
+  return new import_build_utils8.NowBuildError({ code, message, link, action });
 }
 async function detectGenericPythonEntrypoint(workPath) {
   try {
@@ -5501,7 +5638,7 @@ async function detectGenericPythonEntrypoint(workPath) {
       findDiagnostics: result
     };
   } catch {
-    (0, import_build_utils8.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils9.debug)("Failed to discover Python entrypoint");
     return {
       detected: null,
       findDiagnostics: { entrypoint: null, existingWithoutEntrypoint: [] }
@@ -5536,7 +5673,7 @@ async function detectDjangoPythonEntrypoint(workPath) {
       findDiagnostics: result
     };
   } catch {
-    (0, import_build_utils8.debug)("Failed to discover Django Python entrypoint");
+    (0, import_build_utils9.debug)("Failed to discover Django Python entrypoint");
     return emptyResult;
   }
 }
@@ -5547,7 +5684,7 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
     const entrypointExists = await fileExists((0, import_path7.join)(workPath, entrypoint));
     if (!entrypointExists) {
       return {
-        error: new import_build_utils7.NowBuildError({
+        error: new import_build_utils8.NowBuildError({
           code: "PYTHON_ENTRYPOINT_NOT_FOUND",
           message: `Configured Python entrypoint "${entrypoint}" was not found.`,
           link: PYTHON_ENTRYPOINT_DOCS_URL,
@@ -5557,17 +5694,17 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint,
     }
     let varName = configEntryVar ?? await checkEntrypoint(workPath, entrypoint);
     if (!varName) {
-      const needsDynamicApp = !!service && ((0, import_build_utils7.isScheduleTriggeredService)(service) || (0, import_build_utils7.isQueueTriggeredService)(service));
+      const needsDynamicApp = !!service && ((0, import_build_utils8.isScheduleTriggeredService)(service) || (0, import_build_utils8.isQueueTriggeredService)(service));
       if (needsDynamicApp) {
         varName = "app";
       }
     }
     if (varName) {
-      (0, import_build_utils8.debug)(`Using configured Python entrypoint: ${entrypoint}`);
+      (0, import_build_utils9.debug)(`Using configured Python entrypoint: ${entrypoint}`);
       return { entrypoint: { entrypoint, variableName: varName } };
     } else {
       return {
-        error: new import_build_utils7.NowBuildError({
+        error: new import_build_utils8.NowBuildError({
           code: "PYTHON_ENTRYPOINT_NOT_FOUND",
           message: `Could not find a top-level "app", "application", or "handler" in "${entrypoint}".`,
           link: PYTHON_ENTRYPOINT_DOCS_URL,
@@ -5617,7 +5754,7 @@ var detectEntrypoint = async ({
   workPath,
   framework
 }) => {
-  if (!(0, import_build_utils7.isPythonFramework)(framework))
+  if (!(0, import_build_utils8.isPythonFramework)(framework))
     return null;
   const detected = await detectPythonEntrypoint(
     framework,
@@ -5645,13 +5782,13 @@ function buildCronRouteTable(crons) {
 }
 async function getServiceCrons(opts) {
   const { service, entrypoint, rawEntrypoint, handlerFunction } = opts;
-  const isScheduledService = !!service && (0, import_build_utils10.isScheduleTriggeredService)(service);
+  const isScheduledService = !!service && (0, import_build_utils11.isScheduleTriggeredService)(service);
   if (!isScheduledService || !service.name || typeof service.schedule !== "string" && !Array.isArray(service.schedule)) {
     return void 0;
   }
   const cronEntrypoint = entrypoint || rawEntrypoint;
   if (!cronEntrypoint) {
-    throw new import_build_utils10.NowBuildError({
+    throw new import_build_utils11.NowBuildError({
       code: "PYTHON_CRON_NO_ENTRYPOINT",
       message: "Cron service is missing an entrypoint."
     });
@@ -5666,7 +5803,7 @@ async function getServiceCrons(opts) {
       workPath: opts.workPath
     });
   }
-  const cronPath = (0, import_build_utils10.getInternalServiceCronPath)(
+  const cronPath = (0, import_build_utils11.getInternalServiceCronPath)(
     service.name,
     cronEntrypoint,
     handlerFunction || "cron"
@@ -5690,7 +5827,7 @@ async function getServiceCronsDynamic(opts) {
     workPath
   } = opts;
   if (!handlerFunction) {
-    throw new import_build_utils10.NowBuildError({
+    throw new import_build_utils11.NowBuildError({
       code: "PYTHON_DYNAMIC_CRON_NO_HANDLER",
       message: 'Dynamic cron detection requires a "module:object" entrypoint where the object has a get_crons() method.'
     });
@@ -5707,7 +5844,7 @@ async function getServiceCronsDynamic(opts) {
     `Detected ${entries.length} cron entry(s): ${entries.map((e) => `${e.module_function} (${e.schedule})`).join(", ")}`
   );
   if (entries.length === 0) {
-    throw new import_build_utils10.NowBuildError({
+    throw new import_build_utils11.NowBuildError({
       code: "PYTHON_DYNAMIC_CRON_EMPTY",
       message: `Dynamic cron detection returned no entries. "${moduleName}.${handlerFunction}.get_crons()" returned an empty iterable.`
     });
@@ -5742,7 +5879,7 @@ async function detectDynamicCrons(opts) {
         detail = parsed2.error;
     } catch {
     }
-    throw new import_build_utils10.NowBuildError({
+    throw new import_build_utils11.NowBuildError({
       code: "PYTHON_DYNAMIC_CRON_DETECTION_FAILED",
       message: `Failed to detect dynamic cron entries: ${detail}`
     });
@@ -5751,7 +5888,7 @@ async function detectDynamicCrons(opts) {
   try {
     parsed = JSON.parse(stdout);
   } catch {
-    throw new import_build_utils10.NowBuildError({
+    throw new import_build_utils11.NowBuildError({
       code: "PYTHON_DYNAMIC_CRON_DETECTION_FAILED",
       message: `Dynamic cron detection returned invalid JSON: ${stdout}`
     });
@@ -5761,7 +5898,7 @@ async function detectDynamicCrons(opts) {
 function moduleColonFuncToCronPath(serviceName, moduleFunction) {
   const colonIdx = moduleFunction.indexOf(":");
   if (colonIdx === -1) {
-    throw new import_build_utils10.NowBuildError({
+    throw new import_build_utils11.NowBuildError({
       code: "PYTHON_DYNAMIC_CRON_INVALID_FORMAT",
       message: `Dynamic cron entry must use "module:function" format, got: "${moduleFunction}"`
     });
@@ -5769,14 +5906,14 @@ function moduleColonFuncToCronPath(serviceName, moduleFunction) {
   const modulePart = moduleFunction.slice(0, colonIdx);
   const funcPart = moduleFunction.slice(colonIdx + 1);
   const entrypointPath = modulePart.replace(/\./g, "/");
-  return (0, import_build_utils10.getInternalServiceCronPath)(serviceName, entrypointPath, funcPart);
+  return (0, import_build_utils11.getInternalServiceCronPath)(serviceName, entrypointPath, funcPart);
 }
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
 var import_fs9 = require("fs");
 var import_path9 = require("path");
-var import_build_utils11 = require("@vercel/build-utils");
+var import_build_utils12 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
 var import_python_analysis6 = require("@vercel/python-analysis");
@@ -5865,7 +6002,7 @@ async function syncDependencies({
   let { manifestPath } = installInfo;
   const manifest = pythonPackage.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils11.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils12.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
@@ -5875,7 +6012,7 @@ async function syncDependencies({
     const content = (0, import_python_analysis6.stringifyManifest)(manifest.data);
     (0, import_fs9.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils11.debug)(
+    (0, import_build_utils12.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -5908,7 +6045,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils11.NowBuildError({
+    throw new import_build_utils12.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -5930,7 +6067,7 @@ async function runSync({
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils11.NowBuildError({
+        throw new import_build_utils12.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/",
@@ -5952,11 +6089,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils11.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils12.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve3, reject) => {
-    (0, import_build_utils11.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils12.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -6043,13 +6180,13 @@ async function doInstallVercelRuntime({
       `vercel_runtime-${VERCEL_RUNTIME_VERSION}.dist-info`
     );
     if ((0, import_fs9.existsSync)(distInfo)) {
-      (0, import_build_utils11.debug)(
+      (0, import_build_utils12.debug)(
         `vercel-runtime ${VERCEL_RUNTIME_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils11.debug)(
+  (0, import_build_utils12.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"] };
@@ -6064,14 +6201,14 @@ async function doInstallVercelRuntime({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils11.debug)(data.toString());
+        (0, import_build_utils12.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils11.debug)(data.toString());
+        (0, import_build_utils12.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -6139,13 +6276,13 @@ async function doInstallVercelWorkers({
       `vercel_workers-${VERCEL_WORKERS_VERSION}.dist-info`
     );
     if ((0, import_fs9.existsSync)(distInfo)) {
-      (0, import_build_utils11.debug)(
+      (0, import_build_utils12.debug)(
         `vercel-workers ${VERCEL_WORKERS_VERSION} already installed, skipping`
       );
       return;
     }
   }
-  (0, import_build_utils11.debug)(
+  (0, import_build_utils12.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"] };
@@ -6160,14 +6297,14 @@ async function doInstallVercelWorkers({
       if (onStdout) {
         onStdout(data);
       } else {
-        (0, import_build_utils11.debug)(data.toString());
+        (0, import_build_utils12.debug)(data.toString());
       }
     });
     child.stderr?.on("data", (data) => {
       if (onStderr) {
         onStderr(data);
       } else {
-        (0, import_build_utils11.debug)(data.toString());
+        (0, import_build_utils12.debug)(data.toString());
       }
     });
     child.on("error", reject);
@@ -6197,12 +6334,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils11.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils12.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils11.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils12.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -6210,7 +6347,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils11.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils12.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -6247,21 +6384,21 @@ function createDevShim(workPath, entry, modulePath, serviceName, framework, vari
     const template = (0, import_fs9.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_fs9.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils11.debug)(`Prepared Python dev shim at ${shimPath}`);
+    (0, import_build_utils12.debug)(`Prepared Python dev shim at ${shimPath}`);
     return {
       module: DEV_SHIM_MODULE,
       extraPythonPath,
       shimDir: vercelPythonDir
     };
   } catch (err) {
-    (0, import_build_utils11.debug)(`Failed to prepare dev shim: ${err?.message || err}`);
+    (0, import_build_utils12.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_utils11.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils12.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
   const venvPath = (0, import_path9.join)(workPath, ".venv");
@@ -6271,7 +6408,7 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
     uvPath,
     quiet: true
   });
-  (0, import_build_utils11.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  (0, import_build_utils12.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
@@ -6329,7 +6466,7 @@ var startDevServer = async (opts) => {
       filePath: entrypoint,
       // Schedule-triggered services create their own "app" wrapper dynamically.
       // Other services use handlerFunction as the entrypoint variable name.
-      varName: service && (0, import_build_utils11.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
+      varName: service && (0, import_build_utils12.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
     } : void 0,
     service
   );
@@ -6349,7 +6486,7 @@ var startDevServer = async (opts) => {
     if (detected?.error) {
       throw detected.error;
     }
-    throw new import_build_utils11.NowBuildError({
+    throw new import_build_utils12.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: "No Python entrypoint could be detected. Please specify an entrypoint file."
     });
@@ -6378,7 +6515,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils11.NowBuildError({
+      throw new import_build_utils12.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.`
@@ -6395,11 +6532,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils11.debug)(
+      (0, import_build_utils12.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils11.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils12.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -6408,9 +6545,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils11.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils12.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils11.debug)("No virtualenv found");
+        (0, import_build_utils12.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -6500,7 +6637,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
     const moduleToRun = devShim?.module || modulePath;
     const pythonArgs = ["-u", "-m", moduleToRun];
     const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils11.debug)(
+    (0, import_build_utils12.debug)(
       `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
     );
     if (process.stdout.columns) {
@@ -6554,7 +6691,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 // src/quirks/index.ts
-var import_build_utils14 = require("@vercel/build-utils");
+var import_build_utils15 = require("@vercel/build-utils");
 var import_python_analysis8 = require("@vercel/python-analysis");
 // src/quirks/matplotlib.ts
@@ -6570,7 +6707,7 @@ var matplotlibQuirk = {
 // src/quirks/litellm.ts
 var import_fs10 = __toESM(require("fs"));
 var import_path10 = require("path");
-var import_build_utils12 = require("@vercel/build-utils");
+var import_build_utils13 = require("@vercel/build-utils");
 var LAMBDA_ROOT = "/var/task";
 var CONFIG_CANDIDATES = [
   "litellm_config.yaml",
@@ -6605,24 +6742,24 @@ var litellmQuirk = {
       );
       try {
         await import_fs10.default.promises.access(schemaPath);
-        (0, import_build_utils12.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
+        (0, import_build_utils13.debug)(`LiteLLM quirk: found schema at ${schemaPath}`);
         buildEnv.PRISMA_SCHEMA_PATH = schemaPath;
         break;
       } catch {
       }
     }
     if (!buildEnv.PRISMA_SCHEMA_PATH) {
-      (0, import_build_utils12.debug)("LiteLLM quirk: schema.prisma not found in any site-packages");
+      (0, import_build_utils13.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_utils12.debug)(`LiteLLM quirk: found config at ${configName}`);
+        (0, import_build_utils13.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_utils12.debug)(
+      (0, import_build_utils13.debug)(
         `LiteLLM quirk: CONFIG_FILE_PATH already set to ${process.env.CONFIG_FILE_PATH}`
       );
     }
@@ -6634,7 +6771,7 @@ var litellmQuirk = {
 var import_fs11 = __toESM(require("fs"));
 var import_path11 = require("path");
 var import_execa5 = __toESM(require_execa());
-var import_build_utils13 = require("@vercel/build-utils");
+var import_build_utils14 = require("@vercel/build-utils");
 var import_python_analysis7 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
@@ -6648,7 +6785,7 @@ var DUMMY_SCHEMA_NAME = "_prisma_dummy.prisma";
 var LAMBDA_ROOT2 = "/var/task";
 var RUNTIME_OPENSSL_VERSION = "3.2";
 function getLambdaBinaryTarget() {
-  const platform = detectPlatform();
+  const platform = detectTargetPlatform();
   return platform.archName === "aarch64" ? "linux-arm64-openssl-3.0.x" : "rhel-openssl-3.0.x";
 }
 function buildDummySchema(generatedDir) {
@@ -6677,7 +6814,7 @@ async function findUserSchema(workPath) {
       await import_fs11.default.promises.access(resolved);
       return resolved;
     } catch {
-      (0, import_build_utils13.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
+      (0, import_build_utils14.debug)(`PRISMA_SCHEMA_PATH=${envPath} not found at ${resolved}`);
       return null;
     }
   }
@@ -6781,7 +6918,7 @@ var prismaQuirk = {
       dummySchemaPath,
       buildDummySchema(generatedDir)
     );
-    (0, import_build_utils13.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
+    (0, import_build_utils14.debug)(`Running prisma generate (dummy) with cache dir: ${cacheDir}`);
     try {
       const dummyResult = await (0, import_execa5.default)(
         pythonPath,
@@ -6793,11 +6930,11 @@ var prismaQuirk = {
         }
       );
       if (dummyResult.stdout)
-        (0, import_build_utils13.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
+        (0, import_build_utils14.debug)(`prisma generate (dummy) stdout: ${dummyResult.stdout}`);
       if (dummyResult.stderr)
-        (0, import_build_utils13.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
+        (0, import_build_utils14.debug)(`prisma generate (dummy) stderr: ${dummyResult.stderr}`);
     } catch (err) {
-      throw new import_build_utils13.NowBuildError({
+      throw new import_build_utils14.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)
@@ -6816,22 +6953,22 @@ var prismaQuirk = {
         const destPath = (0, import_path11.join)(cacheDir, runtimeName);
         try {
           await import_fs11.default.promises.access(destPath);
-          (0, import_build_utils13.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
+          (0, import_build_utils14.debug)(`Engine binary: ${runtimeName} already exists, skipping`);
         } catch {
-          (0, import_build_utils13.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
+          (0, import_build_utils14.debug)(`Engine binary: copying ${entry} -> ${runtimeName}`);
           await import_fs11.default.promises.copyFile(srcPath, destPath);
         }
         engineCopied = true;
       }
     } catch (err) {
-      throw new import_build_utils13.NowBuildError({
+      throw new import_build_utils14.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_utils13.NowBuildError({
+      throw new import_build_utils14.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}).`
       });
@@ -6858,14 +6995,14 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
           pythonEnv
         );
         if (clientAlreadyGenerated) {
-          (0, import_build_utils13.debug)(
+          (0, import_build_utils14.debug)(
             "Prisma quirk: client already generated, skipping user schema generate"
           );
           shouldGenerate = false;
         }
       }
       if (shouldGenerate) {
-        (0, import_build_utils13.debug)(`Running prisma generate with user schema: ${userSchema}`);
+        (0, import_build_utils14.debug)(`Running prisma generate with user schema: ${userSchema}`);
         try {
           const userResult = await (0, import_execa5.default)(
             pythonPath,
@@ -6877,11 +7014,11 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
             }
           );
           if (userResult.stdout)
-            (0, import_build_utils13.debug)(`prisma generate stdout: ${userResult.stdout}`);
+            (0, import_build_utils14.debug)(`prisma generate stdout: ${userResult.stdout}`);
           if (userResult.stderr)
-            (0, import_build_utils13.debug)(`prisma generate stderr: ${userResult.stderr}`);
+            (0, import_build_utils14.debug)(`prisma generate stderr: ${userResult.stderr}`);
         } catch (err) {
-          throw new import_build_utils13.NowBuildError({
+          throw new import_build_utils14.NowBuildError({
             code: "PRISMA_GENERATE_FAILED",
             message: `\`prisma generate\` failed for schema "${userSchema}".
 ` + execErrorMessage(err)
@@ -6897,7 +7034,7 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
       );
       const count = await (0, import_python_analysis7.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
-        (0, import_build_utils13.debug)(`Appended ${count} entries to prisma RECORD`);
+        (0, import_build_utils14.debug)(`Appended ${count} entries to prisma RECORD`);
       }
     } catch (err) {
       console.warn(
@@ -6991,13 +7128,13 @@ async function runQuirks(ctx) {
       (0, import_python_analysis8.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
-      (0, import_build_utils14.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
+      (0, import_build_utils15.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
     }
     return installed;
   });
   const sorted = toposortQuirks(activated);
   for (const quirk of sorted) {
-    (0, import_build_utils14.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
+    (0, import_build_utils15.debug)(`Quirk "${quirk.dependency}": detected, running fix-up`);
     const result = await quirk.run(ctx);
     if (result.env) {
       Object.assign(mergedEnv, result.env);
@@ -7021,7 +7158,7 @@ async function runQuirks(ctx) {
 var import_fs12 = __toESM(require("fs"));
 var import_path12 = require("path");
 var import_execa6 = __toESM(require_execa());
-var import_build_utils15 = require("@vercel/build-utils");
+var import_build_utils16 = require("@vercel/build-utils");
 var scriptPath2 = (0, import_path12.join)(__dirname, "..", "templates", "vc_django_settings.py");
 var script2 = import_fs12.default.readFileSync(scriptPath2, "utf-8");
 async function getDjangoSettings(projectDir, env) {
@@ -7113,7 +7250,7 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
     await import_fs12.default.promises.mkdir(resolvedStaticRoot, { recursive: true });
     await import_fs12.default.promises.copyFile(manifestSrc, manifestDest);
     manifestRelPath = (0, import_path12.relative)(workPath, manifestDest);
-    (0, import_build_utils15.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
+    (0, import_build_utils16.debug)(`Copied staticfiles.json to ${manifestDest} for Lambda bundle`);
   }
   return {
     staticSourceDirs,
@@ -7141,7 +7278,7 @@ var frameworkHooks = {
     detected
   }) => {
     if (detected?.baseDir === void 0) {
-      (0, import_build_utils16.debug)("Django hook: no manage.py detected, skipping");
+      (0, import_build_utils17.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
     let settingsResult;
@@ -7155,13 +7292,13 @@ Hint: activate a venv or run with \`uv run vercel dev\``;
       } else {
         detail = err?.stderr || err?.message || String(err);
       }
-      throw new import_build_utils16.NowBuildError({
+      throw new import_build_utils17.NowBuildError({
         code: "DJANGO_SETTINGS_FAILED",
         message: `Failed to read Django application settings from ${projectDir}/manage.py:
 ${detail}`
       });
     }
-    (0, import_build_utils16.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    (0, import_build_utils17.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
     const { djangoSettings, settingsModule, djangoVersion } = settingsResult;
     if (djangoVersion) {
       console.log(`Django ${djangoVersion.join(".")} detected`);
@@ -7174,7 +7311,7 @@ ${detail}`
       const variableName = parts.at(-1);
       const rel = `${parts.slice(0, -1).join("/")}.py`;
       const ep = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils16.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
+      (0, import_build_utils17.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
       resolvedEntrypoint = { entrypoint: ep, variableName };
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
@@ -7183,7 +7320,7 @@ ${detail}`
         const variableName = parts.at(-1);
         const rel = `${parts.slice(0, -1).join("/")}.py`;
         const ep = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils16.debug)(
+        (0, import_build_utils17.debug)(
           `Django hook: WSGI entrypoint: ${ep} (variable: ${variableName})`
         );
         resolvedEntrypoint = { entrypoint: ep, variableName };
@@ -7211,12 +7348,12 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils16.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils16.download)(files, workPath, meta);
+  (0, import_build_utils17.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils17.download)(files, workPath, meta);
   if (meta.isDev && entrypoint) {
     const normalizedEntrypoint = entrypoint.endsWith(".py") ? entrypoint : `${entrypoint}.py`;
     if (!hasProp(downloadedFiles, entrypoint) && !hasProp(downloadedFiles, normalizedEntrypoint)) {
-      throw new import_build_utils16.NowBuildError({
+      throw new import_build_utils17.NowBuildError({
         code: "PYTHON_ENTRYPOINT_NOT_FOUND",
         message: `Configured Python entrypoint "${normalizedEntrypoint}" was not found.`,
         link: PYTHON_ENTRYPOINT_DOCS_URL2,
@@ -7226,12 +7363,31 @@ async function downloadFilesInWorkPath({
     const { devCacheDir = (0, import_path13.join)(workPath, ".now", "cache") } = meta;
     const cacheKey = (0, import_path13.basename)(entrypoint).replace(/\./g, "_");
     const destCache = (0, import_path13.join)(devCacheDir, cacheKey);
-    await (0, import_build_utils16.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils16.glob)("**", destCache);
+    await (0, import_build_utils17.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils17.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
 }
+function archToUvPlatform(arch) {
+  return `${validateBuildArch(arch)}-unknown-linux-gnu`;
+}
+function archToLambdaArch(arch) {
+  return validateBuildArch(arch) === "aarch64" ? "arm64" : "x86_64";
+}
+function getTargetPlatform(isDev) {
+  const arch = process.env.VERCEL_BUILD_ARCH;
+  if (arch) {
+    return {
+      uvPlatform: archToUvPlatform(arch),
+      architecture: archToLambdaArch(arch)
+    };
+  }
+  if (isDev || process.env.VERCEL_BUILD_IMAGE) {
+    return { uvPlatform: void 0, architecture: void 0 };
+  }
+  return { uvPlatform: UV_LINUX_TARGET, architecture: "x86_64" };
+}
 var build = async ({
   workPath,
   repoRootPath,
@@ -7244,13 +7400,14 @@ var build = async ({
   registerPreDeploy
 }) => {
   let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
-  const builderSpan = parentSpan ?? new import_build_utils16.Span({ name: "vc.builder" });
+  const builderSpan = parentSpan ?? new import_build_utils17.Span({ name: "vc.builder" });
   const framework = config?.framework;
   const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
-  (0, import_build_utils16.debug)(`workPath: ${workPath}`);
+  const target = getTargetPlatform(meta.isDev ?? false);
+  (0, import_build_utils17.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -7275,7 +7432,7 @@ var build = async ({
       filePath: entrypoint,
       // For schedule-triggered jobs, the WSGI variable is always 'app' (created dynamically).
       // For other services, handlerFunction is used as the entrypoint variable name.
-      varName: service && (0, import_build_utils16.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
+      varName: service && (0, import_build_utils17.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
     } : void 0,
     service
   ) ?? void 0;
@@ -7331,7 +7488,7 @@ var build = async ({
   const hasCachedUv = import_fs13.default.existsSync(uvCacheDir);
   const restoredCache = hasCachedVenv && hasCachedUv ? "both" : hasCachedVenv ? "venv" : hasCachedUv ? "uv" : "none";
   if (hasCachedVenv || hasCachedUv) {
-    (0, import_build_utils16.debug)(
+    (0, import_build_utils17.debug)(
       `Build cache detected: venv=${hasCachedVenv}, uv-cache=${hasCachedUv}`
     );
   }
@@ -7343,14 +7500,14 @@ var build = async ({
       uvCacheDir
     });
   });
-  if ((0, import_build_utils16.isPythonFramework)(framework)) {
+  if ((0, import_build_utils17.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils16.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils16.getEnvForPackageManager)({
+    } = await (0, import_build_utils17.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils17.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -7375,7 +7532,7 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  await builderSpan.child(import_build_utils16.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils17.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0,
     runtime: "python",
     "python.cache.restored": restoredCache
@@ -7392,7 +7549,7 @@ var build = async ({
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils16.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils17.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -7431,7 +7588,8 @@ var build = async ({
         venvPath,
         projectDir,
         frozen: lockFileProvidedByUser,
-        locked: !lockFileProvidedByUser
+        locked: !lockFileProvidedByUser,
+        pythonPlatform: target.uvPlatform
       });
       if (lockPath && import_fs13.default.existsSync(lockPath)) {
         await import_fs13.default.promises.mkdir(uvCacheDir, { recursive: true });
@@ -7439,15 +7597,15 @@ var build = async ({
       }
     }
   });
-  if ((0, import_build_utils16.isPythonFramework)(framework)) {
+  if ((0, import_build_utils17.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils16.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils17.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils16.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils17.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
@@ -7474,26 +7632,27 @@ var build = async ({
   }
   entrypoint = resolved?.entrypoint;
   if (!entrypoint) {
-    throw new import_build_utils16.NowBuildError({
+    throw new import_build_utils17.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: "No Python entrypoint could be detected. Please specify an entrypoint file."
     });
   }
   const djangoStatic = hookResult?.djangoStatic ?? null;
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils16.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils17.debug)(`Installing ${runtimeDep}`);
+  const pipPlatformArgs = target.uvPlatform ? ["--python-platform", target.uvPlatform] : [];
   await uv.pip({
     venvPath,
     projectDir: (0, import_path13.join)(workPath, entryDirectory),
-    args: ["install", "--link-mode", "copy", runtimeDep]
+    args: ["install", "--link-mode", "copy", ...pipPlatformArgs, runtimeDep]
   });
   if (shouldInstallVercelWorkers) {
     const workersDep = baseEnv.VERCEL_WORKERS_PYTHON || `vercel-workers==${VERCEL_WORKERS_VERSION}`;
-    (0, import_build_utils16.debug)(`Installing ${workersDep}`);
+    (0, import_build_utils17.debug)(`Installing ${workersDep}`);
     await uv.pip({
       venvPath,
       projectDir: (0, import_path13.join)(workPath, entryDirectory),
-      args: ["install", "--link-mode", "copy", workersDep]
+      args: ["install", "--link-mode", "copy", ...pipPlatformArgs, workersDep]
     });
   }
   const quirksResult = await runQuirks({ venvPath, pythonEnv, workPath });
@@ -7505,25 +7664,25 @@ var build = async ({
     const capturedEnv = { ...pythonEnv };
     const capturedCwd = workPath;
     registerPreDeploy(async () => {
-      await builderSpan.child(import_build_utils16.BUILDER_PRE_DEPLOY_STEP, {
+      await builderSpan.child(import_build_utils17.BUILDER_PRE_DEPLOY_STEP, {
         preDeployCommand
       }).trace(async () => {
         console.log(`Running pre-deploy command: \`${preDeployCommand}\``);
-        await (0, import_build_utils16.execCommand)(preDeployCommand, {
+        await (0, import_build_utils17.execCommand)(preDeployCommand, {
           env: capturedEnv,
           cwd: capturedCwd
         });
       });
     });
   }
-  (0, import_build_utils16.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils17.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypointToModule(entrypoint);
   if (handlerFunction) {
     const entrypointPath = (0, import_path13.join)(workPath, entrypoint);
     const source = await import_fs13.default.promises.readFile(entrypointPath, "utf-8");
     const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
-      throw new import_build_utils16.NowBuildError({
+      throw new import_build_utils17.NowBuildError({
         code: "PYTHON_HANDLER_NOT_FOUND",
         message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
       });
@@ -7532,7 +7691,7 @@ var build = async ({
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils16.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils17.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const crons = await getServiceCrons({
     service,
     entrypoint,
@@ -7617,9 +7776,9 @@ from vercel_runtime.vc_init import vc_handler
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils16.glob)("**", globOptions);
+  const files = await (0, import_build_utils17.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils16.FileFsRef({
+    files[djangoStatic.manifestRelPath] = new import_build_utils17.FileFsRef({
       fsPath: (0, import_path13.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
@@ -7656,15 +7815,16 @@ from vercel_runtime.vc_init import vc_handler
     }
   });
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils16.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils17.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils16.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils17.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils16.Lambda({
+  const output = new import_build_utils17.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
+    architecture: target.architecture,
     environment: lambdaEnv,
     supportsResponseStreaming: true
   });
@@ -7676,19 +7836,19 @@ from vercel_runtime.vc_init import vc_handler
         pythonVersion,
         uvLockPath,
         framework,
-        serviceType: service ? (0, import_build_utils16.getReportedServiceType)(service) : void 0
+        serviceType: service ? (0, import_build_utils17.getReportedServiceType)(service) : void 0
       });
     } catch (err) {
-      (0, import_build_utils16.debug)(
+      (0, import_build_utils17.debug)(
         `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-  if (!(0, import_build_utils16.isPythonFramework)(framework) && !service?.name) {
+  if (!(0, import_build_utils17.isPythonFramework)(framework) && !service?.name) {
     return { resultVersion: 3, result: { output } };
   }
   const lambdaPath = service?.name ? `_svc/${service.name}/index` : "index";
-  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils16.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
+  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils17.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
   const routes = service?.name ? void 0 : [{ handle: "filesystem" }, { src: "/(.*)", dest: `/${lambdaPath}` }];
   return {
     resultVersion: 2,
@@ -7717,14 +7877,14 @@ var prepareCache = async ({
     }
   } catch {
   }
-  return (0, import_build_utils16.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
+  return (0, import_build_utils17.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
     cwd: root,
     ignore
   });
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils16.isPythonFramework)(framework)) {
+  if ((0, import_build_utils17.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;