@vercel/python 6.42.0 → 6.43.1

package/dist/index.js

@@ -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) || (0, import_build_utils8.isWorkflowTriggeredService)(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;