@vercel/python 6.14.1 → 6.15.1

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs5 = require("fs");
+    var fs6 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs5.stat(path, function(er, stat) {
+      fs6.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs5.statSync(path), path, options);
+      return checkStat(fs6.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs5 = require("fs");
+    var fs6 = require("fs");
     function isexe(path, options, cb) {
-      fs5.stat(path, function(er, stat) {
+      fs6.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs5.statSync(path), options);
+      return checkStat(fs6.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs5 = require("fs");
+    var fs6 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs5 = require("fs");
+    var fs6 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs5.openSync(command, "r");
-        fs5.readSync(fd, buffer, 0, size, 0);
-        fs5.closeSync(fd);
+        fd = fs6.openSync(command, "r");
+        fs6.readSync(fd, buffer, 0, size, 0);
+        fs6.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -423,15 +423,15 @@ var require_readShebang = __commonJS({
 var require_semver = __commonJS({
   "../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js"(exports, module2) {
     exports = module2.exports = SemVer;
-    var debug6;
+    var debug7;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug6 = function() {
+      debug7 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug6 = function() {
+      debug7 = function() {
       };
     }
     exports.SEMVER_SPEC_VERSION = "2.0.0";
@@ -540,7 +540,7 @@ var require_semver = __commonJS({
     var STAR = R++;
     src[STAR] = "(<|>)?=?\\s*\\*";
     for (i = 0; i < R; i++) {
-      debug6(i, src[i]);
+      debug7(i, src[i]);
       if (!re[i]) {
         re[i] = new RegExp(src[i]);
         safeRe[i] = new RegExp(makeSafeRe(src[i]));
@@ -607,7 +607,7 @@ var require_semver = __commonJS({
       if (!(this instanceof SemVer)) {
         return new SemVer(version2, options);
       }
-      debug6("SemVer", version2, options);
+      debug7("SemVer", version2, options);
       this.options = options;
       this.loose = !!options.loose;
       var m = version2.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL]);
@@ -654,7 +654,7 @@ var require_semver = __commonJS({
       return this.version;
     };
     SemVer.prototype.compare = function(other) {
-      debug6("SemVer.compare", this.version, this.options, other);
+      debug7("SemVer.compare", this.version, this.options, other);
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
@@ -681,7 +681,7 @@ var require_semver = __commonJS({
       do {
         var a = this.prerelease[i2];
         var b = other.prerelease[i2];
-        debug6("prerelease compare", i2, a, b);
+        debug7("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -935,7 +935,7 @@ var require_semver = __commonJS({
         return new Comparator(comp, options);
       }
       comp = comp.trim().split(/\s+/).join(" ");
-      debug6("comparator", comp, options);
+      debug7("comparator", comp, options);
       this.options = options;
       this.loose = !!options.loose;
       this.parse(comp);
@@ -944,7 +944,7 @@ var require_semver = __commonJS({
       } else {
         this.value = this.operator + this.semver.version;
       }
-      debug6("comp", this);
+      debug7("comp", this);
     }
     var ANY = {};
     Comparator.prototype.parse = function(comp) {
@@ -967,7 +967,7 @@ var require_semver = __commonJS({
       return this.value;
     };
     Comparator.prototype.test = function(version2) {
-      debug6("Comparator.test", version2, this.options.loose);
+      debug7("Comparator.test", version2, this.options.loose);
       if (this.semver === ANY) {
         return true;
       }
@@ -1050,9 +1050,9 @@ var require_semver = __commonJS({
       var loose = this.options.loose;
       var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
       range = range.replace(hr, hyphenReplace);
-      debug6("hyphen replace", range);
+      debug7("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug6("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug7("comparator trim", range, safeRe[COMPARATORTRIM]);
       range = range.replace(safeRe[TILDETRIM], tildeTrimReplace);
       range = range.replace(safeRe[CARETTRIM], caretTrimReplace);
       var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR];
@@ -1092,15 +1092,15 @@ var require_semver = __commonJS({
       });
     }
     function parseComparator(comp, options) {
-      debug6("comp", comp, options);
+      debug7("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug6("caret", comp);
+      debug7("caret", comp);
       comp = replaceTildes(comp, options);
-      debug6("tildes", comp);
+      debug7("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug6("xrange", comp);
+      debug7("xrange", comp);
       comp = replaceStars(comp, options);
-      debug6("stars", comp);
+      debug7("stars", comp);
       return comp;
     }
     function isX(id) {
@@ -1114,7 +1114,7 @@ var require_semver = __commonJS({
     function replaceTilde(comp, options) {
       var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug6("tilde", comp, _, M, m, p, pr);
+        debug7("tilde", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1123,12 +1123,12 @@ var require_semver = __commonJS({
         } else if (isX(p)) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         } else if (pr) {
-          debug6("replaceTilde pr", pr);
+          debug7("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug6("tilde return", ret);
+        debug7("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug6("caret", comp, options);
+      debug7("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug6("caret", comp, _, M, m, p, pr);
+        debug7("caret", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1154,7 +1154,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
           }
         } else if (pr) {
-          debug6("replaceCaret pr", pr);
+          debug7("replaceCaret pr", pr);
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
@@ -1165,7 +1165,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
           }
         } else {
-          debug6("no pr");
+          debug7("no pr");
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
@@ -1176,12 +1176,12 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
           }
         }
-        debug6("caret return", ret);
+        debug7("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug6("replaceXRanges", comp, options);
+      debug7("replaceXRanges", comp, options);
       return comp.split(/\s+/).map(function(comp2) {
         return replaceXRange(comp2, options);
       }).join(" ");
@@ -1190,7 +1190,7 @@ var require_semver = __commonJS({
       comp = comp.trim();
       var r = options.loose ? safeRe[XRANGELOOSE] : safeRe[XRANGE];
       return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
-        debug6("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug7("xRange", comp, ret, gtlt, M, m, p, pr);
         var xM = isX(M);
         var xm = xM || isX(m);
         var xp = xm || isX(p);
@@ -1233,12 +1233,12 @@ var require_semver = __commonJS({
         } else if (xp) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         }
-        debug6("xRange return", ret);
+        debug7("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug6("replaceStars", comp, options);
+      debug7("replaceStars", comp, options);
       return comp.trim().replace(safeRe[STAR], "");
     }
     function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
@@ -1286,7 +1286,7 @@ var require_semver = __commonJS({
       }
       if (version2.prerelease.length && !options.includePrerelease) {
         for (i2 = 0; i2 < set.length; i2++) {
-          debug6(set[i2].semver);
+          debug7(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs5;
+    var fs6;
     try {
-      fs5 = require("fs");
+      fs6 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs5)
+      if (!fs6)
         return false;
-      return (stream instanceof (fs5.ReadStream || noop) || stream instanceof (fs5.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs6.ReadStream || noop) || stream instanceof (fs6.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 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: join7, delimiter: delimiter2, sep: sep2, posix } = require("path");
+    var { join: join8, delimiter: delimiter2, sep: sep2, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep2 === posix.sep ? "" : sep2}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,7 +2680,7 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join7(pathPart, cmd);
+      return prefix + join8(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2743,21 +2743,20 @@ __export(src_exports, {
   downloadFilesInWorkPath: () => downloadFilesInWorkPath,
   installRequirement: () => installRequirement,
   installRequirementsFile: () => installRequirementsFile,
-  shouldEnableRuntimeInstall: () => shouldEnableRuntimeInstall,
   shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_fs5 = __toESM(require("fs"));
-var import_util = require("util");
-var import_path7 = require("path");
+var import_fs6 = __toESM(require("fs"));
+var import_util2 = require("util");
+var import_path8 = require("path");
 
 // src/runtime-version.ts
-var VERCEL_RUNTIME_VERSION = "0.4.1";
+var VERCEL_RUNTIME_VERSION = "0.5.1";
 
 // src/index.ts
-var import_build_utils8 = require("@vercel/build-utils");
+var import_build_utils9 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -3418,8 +3417,6 @@ function isInstalled({ version: version2 }) {
 }
 
 // src/install.ts
-var LAMBDA_SIZE_THRESHOLD_BYTES = 249 * 1024 * 1024;
-var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
 var makeDependencyCheckCode = (dependency) => `
 from importlib import util
 dep = '${dependency}'.replace('-', '_')
@@ -3739,38 +3736,305 @@ async function installRequirementsFile({
     targetDir
   );
 }
-async function mirrorSitePackagesIntoVendor({
+
+// src/dependency-externalizer.ts
+var import_fs4 = __toESM(require("fs"));
+var import_util = require("util");
+var import_path5 = require("path");
+var import_build_utils5 = require("@vercel/build-utils");
+var import_python_analysis2 = require("@vercel/python-analysis");
+var readFile = (0, import_util.promisify)(import_fs4.default.readFile);
+var LAMBDA_SIZE_THRESHOLD_BYTES = 249 * 1024 * 1024;
+var LAMBDA_PACKING_TARGET_BYTES = 245 * 1024 * 1024;
+var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
+var PythonDependencyExternalizer = class {
+  constructor(options) {
+    // Populated by analyze()
+    this.allVendorFiles = {};
+    this.totalBundleSize = 0;
+    this.analyzed = false;
+    this.venvPath = options.venvPath;
+    this.vendorDir = options.vendorDir;
+    this.workPath = options.workPath;
+    this.uvLockPath = options.uvLockPath;
+    this.uvProjectDir = options.uvProjectDir;
+    this.projectName = options.projectName;
+    this.noBuildCheckFailed = options.noBuildCheckFailed;
+    this.pythonPath = options.pythonPath;
+  }
+  /**
+   * Analyze the bundle: mirror all vendor files, calculate total size,
+   * and determine whether runtime installation is needed.
+   * Must be called before generateBundle().
+   */
+  async analyze(files) {
+    this.allVendorFiles = await mirrorPackagesIntoVendor({
+      venvPath: this.venvPath,
+      vendorDirName: this.vendorDir
+    });
+    const tempFilesForSizing = { ...files };
+    for (const [p, f] of Object.entries(this.allVendorFiles)) {
+      tempFilesForSizing[p] = f;
+    }
+    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`);
+    const overLambdaLimit = shouldEnableRuntimeInstall({
+      totalBundleSize: this.totalBundleSize,
+      uvLockPath: this.uvLockPath
+    });
+    return { overLambdaLimit, allVendorFiles: this.allVendorFiles };
+  }
+  /**
+   * Generate the optimally-packed Lambda bundle.
+   * Mutates `files` in place: adds vendor files (private + knapsack-selected
+   * public), runtime config, and uv binary.
+   * Must be called after analyze().
+   */
+  async generateBundle(files) {
+    if (!this.analyzed) {
+      throw new Error(
+        "PythonDependencyExternalizer.analyze() must be called before generateBundle()"
+      );
+    }
+    if (!this.uvLockPath || !this.uvProjectDir) {
+      throw new import_build_utils5.NowBuildError({
+        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+        message: "Runtime dependency installation requires a uv.lock file and project directory."
+      });
+    }
+    const totalBundleSizeMB = (this.totalBundleSize / (1024 * 1024)).toFixed(2);
+    console.log(
+      `Bundle size (${totalBundleSizeMB} MB) exceeds limit. Enabling runtime dependency installation.`
+    );
+    if (this.totalBundleSize > LAMBDA_EPHEMERAL_STORAGE_BYTES) {
+      const ephemeralLimitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(0);
+      throw new import_build_utils5.NowBuildError({
+        code: "LAMBDA_SIZE_EXCEEDED",
+        message: `Total dependency size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB). Even with runtime dependency installation, all packages must fit within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda functions. Consider removing unused dependencies or splitting your application into smaller functions.`
+      });
+    }
+    if (this.noBuildCheckFailed) {
+      throw new import_build_utils5.NowBuildError({
+        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+        message: `Bundle size exceeds the Lambda limit and requires runtime dependency installation, but some packages in your uv.lock file do not have pre-built binary wheels available.
+Runtime dependency installation requires all public packages to have binary wheels.
+
+To fix this, either:
+ 1. Regenerate your lock file with: uv lock --upgrade --no-build, or
+ 2. Switch the problematic packages to ones that have pre-built wheels available`
+      });
+    }
+    let lockContent;
+    try {
+      lockContent = await readFile(this.uvLockPath, "utf8");
+    } catch (error) {
+      if (error instanceof Error) {
+        console.log(
+          `Failed to read uv.lock file at "${this.uvLockPath}": ${error.message}`
+        );
+      } else {
+        console.log(
+          `Failed to read uv.lock file at "${this.uvLockPath}": ${String(error)}`
+        );
+      }
+      throw new import_build_utils5.NowBuildError({
+        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+        message: `Failed to read uv.lock file at "${this.uvLockPath}"`
+      });
+    }
+    let lockFile;
+    try {
+      lockFile = (0, import_python_analysis2.parseUvLock)(lockContent, this.uvLockPath);
+    } catch (error) {
+      if (error instanceof import_python_analysis2.PythonAnalysisError) {
+        if (error.fileContent) {
+          console.log(
+            `Failed to parse "${error.path}". File content:
+${error.fileContent}`
+          );
+        }
+        throw new import_build_utils5.NowBuildError({
+          code: error.code,
+          message: error.message
+        });
+      }
+      throw error;
+    }
+    const excludePackages = [];
+    if (this.projectName) {
+      excludePackages.push(this.projectName);
+      (0, import_build_utils5.debug)(
+        `Excluding project package "${this.projectName}" from runtime installation`
+      );
+    }
+    const classification = (0, import_python_analysis2.classifyPackages)({
+      lockFile,
+      excludePackages
+    });
+    (0, import_build_utils5.debug)(
+      `Package classification: ${classification.privatePackages.length} private, ${classification.publicPackages.length} public`
+    );
+    if (classification.publicPackages.length === 0) {
+      throw new import_build_utils5.NowBuildError({
+        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
+        message: "Bundle size exceeds limit but no public packages found for runtime installation."
+      });
+    }
+    const packageSizes = await calculatePerPackageSizes(this.venvPath);
+    const alwaysBundled = [
+      ...classification.privatePackages,
+      "vercel-runtime",
+      "vercel_runtime"
+    ];
+    const alwaysBundledFiles = await mirrorPackagesIntoVendor({
+      venvPath: this.venvPath,
+      vendorDirName: this.vendorDir,
+      includePackages: alwaysBundled
+    });
+    const baseFiles = { ...files };
+    for (const [p, f] of Object.entries(alwaysBundledFiles)) {
+      baseFiles[p] = f;
+    }
+    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_fs4.default.promises.stat(uvBinaryPath);
+        runtimeToolingOverhead = uvStats.size;
+      } catch {
+        runtimeToolingOverhead = 50 * 1024 * 1024;
+      }
+    }
+    const remainingCapacity = LAMBDA_PACKING_TARGET_BYTES - fixedOverhead - runtimeToolingOverhead;
+    (0, import_build_utils5.debug)(
+      `Fixed overhead: ${(fixedOverhead / (1024 * 1024)).toFixed(2)} MB, runtime tooling: ${(runtimeToolingOverhead / (1024 * 1024)).toFixed(2)} MB, remaining capacity for public packages: ${(remainingCapacity / (1024 * 1024)).toFixed(2)} MB`
+    );
+    const publicPackageSizes = new Map(
+      [...packageSizes].filter(
+        ([name]) => classification.publicPackages.includes(name)
+      )
+    );
+    const bundledPublic = lambdaKnapsack(publicPackageSizes, remainingCapacity);
+    const allBundledPackages = [...alwaysBundled, ...bundledPublic];
+    const selectedVendorFiles = await mirrorPackagesIntoVendor({
+      venvPath: this.venvPath,
+      vendorDirName: this.vendorDir,
+      includePackages: allBundledPackages
+    });
+    for (const [p, f] of Object.entries(selectedVendorFiles)) {
+      files[p] = f;
+    }
+    const bundledPackagesForConfig = [
+      ...classification.privatePackages,
+      ...bundledPublic
+    ];
+    const projectDirRel = (0, import_path5.relative)(this.workPath, this.uvProjectDir);
+    const uvLockRel = (0, import_path5.relative)(this.workPath, this.uvLockPath);
+    const isOutsideWorkPath = projectDirRel.startsWith("..") || uvLockRel.startsWith("..");
+    if (isOutsideWorkPath) {
+      const srcPyproject = (0, import_path5.join)(this.uvProjectDir, "pyproject.toml");
+      files[`${UV_BUNDLE_DIR}/pyproject.toml`] = new import_build_utils5.FileFsRef({
+        fsPath: srcPyproject
+      });
+      files[`${UV_BUNDLE_DIR}/uv.lock`] = new import_build_utils5.FileFsRef({
+        fsPath: this.uvLockPath
+      });
+    }
+    const runtimeConfigData = JSON.stringify({
+      projectDir: isOutsideWorkPath ? UV_BUNDLE_DIR : projectDirRel,
+      bundledPackages: bundledPackagesForConfig
+    });
+    files[`${UV_BUNDLE_DIR}/_runtime_config.json`] = new import_build_utils5.FileBlob({
+      data: runtimeConfigData
+    });
+    if (process.env.VERCEL_BUILD_IMAGE) {
+      try {
+        const uvBinaryPath = await getUvBinaryForBundling(this.pythonPath);
+        const uvBundleDir = (0, import_path5.join)(this.workPath, UV_BUNDLE_DIR);
+        const uvLocalPath = (0, import_path5.join)(uvBundleDir, "uv");
+        await import_fs4.default.promises.mkdir(uvBundleDir, { recursive: true });
+        await import_fs4.default.promises.copyFile(uvBinaryPath, uvLocalPath);
+        await import_fs4.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)}`
+        });
+      }
+    }
+    const finalBundleSize = await calculateBundleSize(files);
+    if (finalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
+      const finalSizeMB = (finalBundleSize / (1024 * 1024)).toFixed(2);
+      const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
+      throw new import_build_utils5.NowBuildError({
+        code: "LAMBDA_SIZE_EXCEEDED",
+        message: `Bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after deferring public packages to runtime installation. This usually means your private packages or source code are too large. Consider reducing the size of private dependencies or splitting your application.`
+      });
+    }
+  }
+};
+function shouldEnableRuntimeInstall({
+  totalBundleSize,
+  uvLockPath
+}) {
+  const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
+  if (pythonOnHiveEnabled) {
+    return false;
+  } else if (totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && uvLockPath !== null) {
+    return true;
+  }
+  return false;
+}
+async function mirrorPackagesIntoVendor({
   venvPath,
-  vendorDirName
+  vendorDirName,
+  includePackages
 }) {
   const vendorFiles = {};
-  try {
-    const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
-    for (const dir of sitePackageDirs) {
-      if (!import_fs3.default.existsSync(dir))
+  if (includePackages && includePackages.length === 0) {
+    return vendorFiles;
+  }
+  const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis2.normalizePackageName)) : null;
+  const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
+  for (const dir of sitePackageDirs) {
+    if (!import_fs4.default.existsSync(dir))
+      continue;
+    const resolvedDir = (0, import_path5.resolve)(dir);
+    const dirPrefix = resolvedDir + import_path5.sep;
+    const distributions = await (0, import_python_analysis2.scanDistributions)(dir);
+    for (const [name, dist] of distributions) {
+      if (includeSet && !includeSet.has(name))
         continue;
-      const resolvedDir = (0, import_path4.resolve)(dir);
-      const dirPrefix = resolvedDir + import_path4.sep;
-      const distributions = await (0, import_python_analysis.scanDistributions)(dir);
-      for (const dist of distributions.values()) {
-        for (const { path: rawPath } of dist.files) {
-          const filePath = rawPath.replaceAll("/", import_path4.sep);
-          if (!(0, import_path4.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
-            continue;
-          }
-          if (filePath.endsWith(".pyc") || filePath.split(import_path4.sep).includes("__pycache__")) {
-            continue;
-          }
-          const srcFsPath = (0, import_path4.join)(dir, filePath);
-          const bundlePath = (0, import_path4.join)(vendorDirName, filePath).replace(/\\/g, "/");
-          vendorFiles[bundlePath] = new import_build_utils4.FileFsRef({ fsPath: srcFsPath });
+      for (const { path: rawPath } of dist.files) {
+        const filePath = rawPath.replaceAll("/", import_path5.sep);
+        if (!(0, import_path5.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+          continue;
+        }
+        if (filePath.endsWith(".pyc") || filePath.split(import_path5.sep).includes("__pycache__")) {
+          continue;
         }
+        const srcFsPath = (0, import_path5.join)(dir, filePath);
+        if (!import_fs4.default.existsSync(srcFsPath)) {
+          continue;
+        }
+        const bundlePath = (0, import_path5.join)(vendorDirName, filePath).replace(/\\/g, "/");
+        vendorFiles[bundlePath] = new import_build_utils5.FileFsRef({ fsPath: srcFsPath });
       }
     }
-  } catch (err) {
-    console.log("Failed to collect site-packages from virtual environment");
-    throw err;
   }
+  (0, import_build_utils5.debug)(
+    `Mirrored ${Object.keys(vendorFiles).length} files` + (includePackages ? ` from ${includePackages.length} packages` : "")
+  );
   return vendorFiles;
 }
 async function calculateBundleSize(files) {
@@ -3779,7 +4043,7 @@ async function calculateBundleSize(files) {
     const file = files[filePath];
     if ("fsPath" in file && file.fsPath) {
       try {
-        const stats = await import_fs3.default.promises.stat(file.fsPath);
+        const stats = await import_fs4.default.promises.stat(file.fsPath);
         totalSize += stats.size;
       } catch (err) {
         console.warn(
@@ -3793,66 +4057,65 @@ async function calculateBundleSize(files) {
   }
   return totalSize;
 }
-async function mirrorPrivatePackagesIntoVendor({
-  venvPath,
-  vendorDirName,
-  privatePackages
-}) {
-  const vendorFiles = {};
-  if (privatePackages.length === 0) {
-    (0, import_build_utils4.debug)("No private packages to bundle");
-    return vendorFiles;
+function lambdaKnapsack(packages, capacity) {
+  if (capacity <= 0) {
+    return [];
   }
-  const privatePackageSet = new Set(privatePackages.map(import_python_analysis.normalizePackageName));
-  try {
-    const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
-    for (const dir of sitePackageDirs) {
-      if (!import_fs3.default.existsSync(dir))
-        continue;
-      const resolvedDir = (0, import_path4.resolve)(dir);
-      const dirPrefix = resolvedDir + import_path4.sep;
-      const distributions = await (0, import_python_analysis.scanDistributions)(dir);
-      for (const [name, dist] of distributions) {
-        if (!privatePackageSet.has(name))
+  const sorted = [...packages.entries()].sort(([, a], [, b]) => b - a);
+  const bundled = [];
+  let remaining = capacity;
+  for (const [name, size] of sorted) {
+    if (size <= remaining) {
+      bundled.push(name);
+      remaining -= size;
+    }
+  }
+  return bundled;
+}
+async function calculatePerPackageSizes(venvPath) {
+  const sizes = /* @__PURE__ */ new Map();
+  const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
+  for (const dir of sitePackageDirs) {
+    if (!import_fs4.default.existsSync(dir))
+      continue;
+    const resolvedDir = (0, import_path5.resolve)(dir);
+    const dirPrefix = resolvedDir + import_path5.sep;
+    const distributions = await (0, import_python_analysis2.scanDistributions)(dir);
+    for (const [name, dist] of distributions) {
+      let totalSize = 0;
+      for (const { path: rawPath } of dist.files) {
+        const filePath = rawPath.replaceAll("/", import_path5.sep);
+        if (!(0, import_path5.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
+          continue;
+        }
+        if (filePath.endsWith(".pyc") || filePath.split(import_path5.sep).includes("__pycache__")) {
           continue;
-        for (const { path: rawPath } of dist.files) {
-          const filePath = rawPath.replaceAll("/", import_path4.sep);
-          if (!(0, import_path4.resolve)(resolvedDir, filePath).startsWith(dirPrefix)) {
-            continue;
-          }
-          if (filePath.endsWith(".pyc") || filePath.split(import_path4.sep).includes("__pycache__")) {
-            continue;
-          }
-          const srcFsPath = (0, import_path4.join)(dir, filePath);
-          const bundlePath = (0, import_path4.join)(vendorDirName, filePath).replace(/\\/g, "/");
-          vendorFiles[bundlePath] = new import_build_utils4.FileFsRef({ fsPath: srcFsPath });
+        }
+        try {
+          const stats = await import_fs4.default.promises.stat((0, import_path5.join)(dir, filePath));
+          totalSize += stats.size;
+        } catch {
         }
       }
+      sizes.set(name, totalSize);
     }
-    (0, import_build_utils4.debug)(
-      `Bundled ${Object.keys(vendorFiles).length} files from private packages`
-    );
-  } catch (err) {
-    console.log("Failed to collect private packages from virtual environment");
-    throw err;
   }
-  return vendorFiles;
+  return sizes;
 }
 
 // src/index.ts
-var import_python_analysis3 = require("@vercel/python-analysis");
-var import_build_utils9 = require("@vercel/build-utils");
+var import_build_utils10 = require("@vercel/build-utils");
 
 // src/start-dev-server.ts
 var import_child_process2 = require("child_process");
-var import_fs4 = require("fs");
-var import_path6 = require("path");
-var import_build_utils7 = require("@vercel/build-utils");
+var import_fs5 = require("fs");
+var import_path7 = require("path");
+var import_build_utils8 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
-var import_path5 = require("path");
-var import_build_utils5 = require("@vercel/build-utils");
+var import_path6 = require("path");
 var import_build_utils6 = require("@vercel/build-utils");
+var import_build_utils7 = require("@vercel/build-utils");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
   "index",
@@ -3864,11 +4127,11 @@ var PYTHON_ENTRYPOINT_FILENAMES = [
 var PYTHON_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
 var PYTHON_CANDIDATE_ENTRYPOINTS = PYTHON_ENTRYPOINT_FILENAMES.flatMap(
   (filename) => PYTHON_ENTRYPOINT_DIRS.map(
-    (dir) => import_path5.posix.join(dir, `${filename}.py`)
+    (dir) => import_path6.posix.join(dir, `${filename}.py`)
   )
 );
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils6.readConfigFile)((0, import_path5.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils7.readConfigFile)((0, import_path6.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -3881,7 +4144,7 @@ async function getPyprojectEntrypoint(workPath) {
   const modulePath = match[1];
   const relPath = modulePath.replace(/\./g, "/");
   try {
-    const fsFiles = await (0, import_build_utils5.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils6.glob)("**", workPath);
     const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
     for (const candidate of candidates) {
       if (fsFiles[candidate])
@@ -3889,18 +4152,18 @@ async function getPyprojectEntrypoint(workPath) {
     }
     return null;
   } catch {
-    (0, import_build_utils5.debug)("Failed to discover Python entrypoint from pyproject.toml");
+    (0, import_build_utils6.debug)("Failed to discover Python entrypoint from pyproject.toml");
     return null;
   }
 }
 async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const fsFiles = await (0, import_build_utils5.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils6.glob)("**", workPath);
     if (fsFiles[entry]) {
-      const isValid = await (0, import_build_utils5.isPythonEntrypoint)(fsFiles[entry]);
+      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[entry]);
       if (isValid) {
-        (0, import_build_utils5.debug)(`Using configured Python entrypoint: ${entry}`);
+        (0, import_build_utils6.debug)(`Using configured Python entrypoint: ${entry}`);
         return entry;
       }
     }
@@ -3908,15 +4171,15 @@ async function detectGenericPythonEntrypoint(workPath, configuredEntrypoint) {
       (c) => !!fsFiles[c]
     );
     for (const candidate of candidates) {
-      const isValid = await (0, import_build_utils5.isPythonEntrypoint)(fsFiles[candidate]);
+      const isValid = await (0, import_build_utils6.isPythonEntrypoint)(fsFiles[candidate]);
       if (isValid) {
-        (0, import_build_utils5.debug)(`Detected Python entrypoint: ${candidate}`);
+        (0, import_build_utils6.debug)(`Detected Python entrypoint: ${candidate}`);
         return candidate;
       }
     }
     return null;
   } catch {
-    (0, import_build_utils5.debug)("Failed to discover Python entrypoint");
+    (0, import_build_utils6.debug)("Failed to discover Python entrypoint");
     return null;
   }
 }
@@ -3931,7 +4194,7 @@ async function detectPythonEntrypoint(_framework, workPath, configuredEntrypoint
 }
 
 // src/start-dev-server.ts
-var import_python_analysis2 = require("@vercel/python-analysis");
+var import_python_analysis3 = require("@vercel/python-analysis");
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
     process
@@ -3990,17 +4253,17 @@ async function syncDependencies({
   let { manifestType, manifestPath } = installInfo;
   const manifest = installInfo.pythonPackage?.manifest;
   if (!manifestType || !manifestPath) {
-    (0, import_build_utils7.debug)("No Python project manifest found, skipping dependency sync");
+    (0, import_build_utils8.debug)("No Python project manifest found, skipping dependency sync");
     return;
   }
   if (manifest?.origin && manifestType === "pyproject.toml") {
-    const syncDir = (0, import_path6.join)(workPath, ".vercel", "python", "sync");
-    (0, import_fs4.mkdirSync)(syncDir, { recursive: true });
-    const tempPyproject = (0, import_path6.join)(syncDir, "pyproject.toml");
-    const content = (0, import_python_analysis2.stringifyManifest)(manifest.data);
-    (0, import_fs4.writeFileSync)(tempPyproject, content, "utf8");
+    const syncDir = (0, import_path7.join)(workPath, ".vercel", "python", "sync");
+    (0, import_fs5.mkdirSync)(syncDir, { recursive: true });
+    const tempPyproject = (0, import_path7.join)(syncDir, "pyproject.toml");
+    const content = (0, import_python_analysis3.stringifyManifest)(manifest.data);
+    (0, import_fs5.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
-    (0, import_build_utils7.debug)(
+    (0, import_build_utils8.debug)(
       `Wrote converted ${manifest.origin.kind} manifest to ${tempPyproject}`
     );
   }
@@ -4033,7 +4296,7 @@ async function syncDependencies({
     for (const [channel, chunk] of captured) {
       (channel === "stdout" ? writeOut : writeErr)(chunk.toString());
     }
-    throw new import_build_utils7.NowBuildError({
+    throw new import_build_utils8.NowBuildError({
       code: "PYTHON_DEPENDENCY_SYNC_FAILED",
       message: `Failed to install Python dependencies from ${manifestType}: ${err instanceof Error ? err.message : String(err)}`
     });
@@ -4048,14 +4311,14 @@ async function runSync({
   onStdout,
   onStderr
 }) {
-  const projectDir = (0, import_path6.dirname)(manifestPath);
+  const projectDir = (0, import_path7.dirname)(manifestPath);
   const pip = uvPath ? { cmd: uvPath, prefix: ["pip", "install"] } : { cmd: pythonBin, prefix: ["-m", "pip", "install"] };
   let spawnCmd;
   let spawnArgs;
   switch (manifestType) {
     case "uv.lock": {
       if (!uvPath) {
-        throw new import_build_utils7.NowBuildError({
+        throw new import_build_utils8.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/",
@@ -4077,11 +4340,11 @@ async function runSync({
       break;
     }
     default:
-      (0, import_build_utils7.debug)(`Unknown manifest type: ${manifestType}`);
+      (0, import_build_utils8.debug)(`Unknown manifest type: ${manifestType}`);
       return;
   }
   await new Promise((resolve2, reject) => {
-    (0, import_build_utils7.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
+    (0, import_build_utils8.debug)(`Running "${spawnCmd} ${spawnArgs.join(" ")}" in ${projectDir}...`);
     const child = (0, import_child_process2.spawn)(spawnCmd, spawnArgs, {
       cwd: projectDir,
       env: getProtectedUvEnv(env),
@@ -4128,12 +4391,12 @@ function installGlobalCleanupHandlers() {
       try {
         process.kill(info.pid, "SIGTERM");
       } catch (err) {
-        (0, import_build_utils7.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+        (0, import_build_utils8.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
       }
       try {
         process.kill(info.pid, "SIGKILL");
       } catch (err) {
-        (0, import_build_utils7.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+        (0, import_build_utils8.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
       }
       PERSISTENT_SERVERS.delete(key);
     }
@@ -4141,7 +4404,7 @@ function installGlobalCleanupHandlers() {
       try {
         restoreWarnings();
       } catch (err) {
-        (0, import_build_utils7.debug)(`Error restoring warnings: ${err}`);
+        (0, import_build_utils8.debug)(`Error restoring warnings: ${err}`);
       }
       restoreWarnings = null;
     }
@@ -4158,49 +4421,49 @@ function installGlobalCleanupHandlers() {
 }
 function createDevAsgiShim(workPath, modulePath) {
   try {
-    const vercelPythonDir = (0, import_path6.join)(workPath, ".vercel", "python");
-    (0, import_fs4.mkdirSync)(vercelPythonDir, { recursive: true });
-    const shimPath = (0, import_path6.join)(vercelPythonDir, `${ASGI_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path6.join)(__dirname, "..", `${ASGI_SHIM_MODULE}.py`);
-    const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
+    const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
+    (0, import_fs5.mkdirSync)(vercelPythonDir, { recursive: true });
+    const shimPath = (0, import_path7.join)(vercelPythonDir, `${ASGI_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path7.join)(__dirname, "..", `${ASGI_SHIM_MODULE}.py`);
+    const template = (0, import_fs5.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
-    (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils7.debug)(`Prepared Python dev static shim at ${shimPath}`);
+    (0, import_fs5.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils8.debug)(`Prepared Python dev static shim at ${shimPath}`);
     return ASGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils7.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
+    (0, import_build_utils8.debug)(`Failed to prepare dev static shim: ${err?.message || err}`);
     return null;
   }
 }
 function createDevWsgiShim(workPath, modulePath) {
   try {
-    const vercelPythonDir = (0, import_path6.join)(workPath, ".vercel", "python");
-    (0, import_fs4.mkdirSync)(vercelPythonDir, { recursive: true });
-    const shimPath = (0, import_path6.join)(vercelPythonDir, `${WSGI_SHIM_MODULE}.py`);
-    const templatePath = (0, import_path6.join)(__dirname, "..", `${WSGI_SHIM_MODULE}.py`);
-    const template = (0, import_fs4.readFileSync)(templatePath, "utf8");
+    const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
+    (0, import_fs5.mkdirSync)(vercelPythonDir, { recursive: true });
+    const shimPath = (0, import_path7.join)(vercelPythonDir, `${WSGI_SHIM_MODULE}.py`);
+    const templatePath = (0, import_path7.join)(__dirname, "..", `${WSGI_SHIM_MODULE}.py`);
+    const template = (0, import_fs5.readFileSync)(templatePath, "utf8");
     const shimSource = template.replace(/__VC_DEV_MODULE_PATH__/g, modulePath);
-    (0, import_fs4.writeFileSync)(shimPath, shimSource, "utf8");
-    (0, import_build_utils7.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
+    (0, import_fs5.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils8.debug)(`Prepared Python dev WSGI shim at ${shimPath}`);
     return WSGI_SHIM_MODULE;
   } catch (err) {
-    (0, import_build_utils7.debug)(`Failed to prepare dev WSGI shim: ${err?.message || err}`);
+    (0, import_build_utils8.debug)(`Failed to prepare dev WSGI 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_utils7.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    (0, import_build_utils8.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
     return { command: pythonCmd, args: [] };
   }
-  const venvPath = (0, import_path6.join)(workPath, ".venv");
+  const venvPath = (0, import_path7.join)(workPath, ".venv");
   await ensureVenv({ pythonPath: systemPython, venvPath, uvPath, quiet: true });
-  (0, import_build_utils7.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  (0, import_build_utils8.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
   const pythonBin = getVenvPythonBin(venvPath);
   const binDir = getVenvBinDir(venvPath);
   env.VIRTUAL_ENV = venvPath;
-  env.PATH = `${binDir}${import_path6.delimiter}${env.PATH || ""}`;
+  env.PATH = `${binDir}${import_path7.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
 var startDevServer = async (opts) => {
@@ -4226,7 +4489,7 @@ var startDevServer = async (opts) => {
   );
   if (!entry) {
     const searched = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-    throw new import_build_utils7.NowBuildError({
+    throw new import_build_utils8.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searched}.`,
       link: `https://vercel.com/docs/frameworks/backend/${framework?.toLowerCase()}#exporting-the-${framework?.toLowerCase()}-application`,
@@ -4279,7 +4542,7 @@ var startDevServer = async (opts) => {
       const yellow = "\x1B[33m";
       const white = "\x1B[1m";
       const reset = "\x1B[0m";
-      throw new import_build_utils7.NowBuildError({
+      throw new import_build_utils8.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.`
@@ -4296,11 +4559,11 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = runner.command;
       spawnArgsPrefix = runner.args;
-      (0, import_build_utils7.debug)(
+      (0, import_build_utils8.debug)(
         `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
       );
     } else if (venv) {
-      (0, import_build_utils7.debug)(`Running in virtualenv at ${venv}`);
+      (0, import_build_utils8.debug)(`Running in virtualenv at ${venv}`);
     } else {
       const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
         workPath,
@@ -4309,9 +4572,9 @@ Run ${white}deactivate${reset} and try again.`
       );
       spawnCommand = venvPythonCmd;
       if (venvRoot) {
-        (0, import_build_utils7.debug)(`Using virtualenv at ${venvRoot}`);
+        (0, import_build_utils8.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        (0, import_build_utils7.debug)("No virtualenv found");
+        (0, import_build_utils8.debug)("No virtualenv found");
         try {
           const yellow = "\x1B[33m";
           const reset = "\x1B[0m";
@@ -4349,14 +4612,14 @@ If you are using a virtual environment, activate it before running "vercel dev",
       if (framework !== "flask") {
         const devShimModule = createDevAsgiShim(workPath, modulePath);
         if (devShimModule) {
-          const vercelPythonDir = (0, import_path6.join)(workPath, ".vercel", "python");
+          const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
           const existingPythonPath = env.PYTHONPATH || "";
           env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
         }
         const moduleToRun = devShimModule || modulePath;
         const pythonArgs = ["-u", "-m", moduleToRun];
         const argv = [...spawnArgsPrefix, ...pythonArgs];
-        (0, import_build_utils7.debug)(
+        (0, import_build_utils8.debug)(
           `Starting ASGI dev server (${framework}): ${spawnCommand} ${argv.join(" ")}`
         );
         const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
@@ -4416,14 +4679,14 @@ If you are using a virtual environment, activate it before running "vercel dev",
       } else {
         const devShimModule = createDevWsgiShim(workPath, modulePath);
         if (devShimModule) {
-          const vercelPythonDir = (0, import_path6.join)(workPath, ".vercel", "python");
+          const vercelPythonDir = (0, import_path7.join)(workPath, ".vercel", "python");
           const existingPythonPath = env.PYTHONPATH || "";
           env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
         }
         const moduleToRun = devShimModule || modulePath;
         const pythonArgs = ["-u", "-m", moduleToRun];
         const argv = [...spawnArgsPrefix, ...pythonArgs];
-        (0, import_build_utils7.debug)(`Starting Flask dev server: ${spawnCommand} ${argv.join(" ")}`);
+        (0, import_build_utils8.debug)(`Starting Flask dev server: ${spawnCommand} ${argv.join(" ")}`);
         const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
           cwd: workPath,
           env,
@@ -4496,20 +4759,8 @@ If you are using a virtual environment, activate it before running "vercel dev",
 };
 
 // src/index.ts
-var readFile = (0, import_util.promisify)(import_fs5.default.readFile);
-var writeFile = (0, import_util.promisify)(import_fs5.default.writeFile);
-function shouldEnableRuntimeInstall({
-  totalBundleSize,
-  uvLockPath
-}) {
-  const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
-  if (pythonOnHiveEnabled) {
-    return false;
-  } else if (totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && uvLockPath !== null) {
-    return true;
-  }
-  return false;
-}
+var readFile2 = (0, import_util2.promisify)(import_fs6.default.readFile);
+var writeFile = (0, import_util2.promisify)(import_fs6.default.writeFile);
 var version = 3;
 async function downloadFilesInWorkPath({
   entrypoint,
@@ -4517,13 +4768,13 @@ async function downloadFilesInWorkPath({
   files,
   meta = {}
 }) {
-  (0, import_build_utils8.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils8.download)(files, workPath, meta);
+  (0, import_build_utils9.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils9.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path7.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path7.join)(devCacheDir, (0, import_path7.basename)(entrypoint, ".py"));
-    await (0, import_build_utils8.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils8.glob)("**", destCache);
+    const { devCacheDir = (0, import_path8.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path8.join)(devCacheDir, (0, import_path8.basename)(entrypoint, ".py"));
+    await (0, import_build_utils9.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils9.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -4539,7 +4790,7 @@ var build = async ({
   const framework = config?.framework;
   let spawnEnv;
   let projectInstallCommand;
-  (0, import_build_utils8.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils9.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -4548,21 +4799,21 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path7.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path8.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
     console.log('Failed to create "setup.cfg" file');
     throw err;
   }
-  if ((0, import_build_utils8.isPythonFramework)(framework)) {
+  if ((0, import_build_utils9.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils8.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils8.getEnvForPackageManager)({
+    } = await (0, import_build_utils9.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils9.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -4583,7 +4834,7 @@ var build = async ({
     config?.buildCommand;
     if (projectBuildCommand) {
       console.log(`Running "${projectBuildCommand}"`);
-      await (0, import_build_utils8.execCommand)(projectBuildCommand, {
+      await (0, import_build_utils9.execCommand)(projectBuildCommand, {
         env: spawnEnv,
         cwd: workPath
       });
@@ -4595,21 +4846,21 @@ var build = async ({
       );
     }
   }
-  let fsFiles = await (0, import_build_utils8.glob)("**", workPath);
-  if ((0, import_build_utils8.isPythonFramework)(framework) && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
+  let fsFiles = await (0, import_build_utils9.glob)("**", workPath);
+  if ((0, import_build_utils9.isPythonFramework)(framework) && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
     const detected = await detectPythonEntrypoint(
       config.framework,
       workPath,
       entrypoint
     );
     if (detected) {
-      (0, import_build_utils8.debug)(
+      (0, import_build_utils9.debug)(
         `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected;
     } else {
       const searchedList = PYTHON_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils8.NowBuildError({
+      throw new import_build_utils9.NowBuildError({
         code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
         message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searchedList}.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -4617,7 +4868,7 @@ var build = async ({
       });
     }
   }
-  const entryDirectory = (0, import_path7.dirname)(entrypoint);
+  const entryDirectory = (0, import_path8.dirname)(entrypoint);
   const pyprojectDir = findDir({
     file: "pyproject.toml",
     entryDirectory,
@@ -4639,40 +4890,40 @@ var build = async ({
   let declaredPythonVersion;
   if (pythonVersionFileDir) {
     try {
-      const content = await readFile(
-        (0, import_path7.join)(pythonVersionFileDir, ".python-version"),
+      const content = await readFile2(
+        (0, import_path8.join)(pythonVersionFileDir, ".python-version"),
         "utf8"
       );
       const version2 = parsePythonVersionFile(content);
       if (version2) {
         declaredPythonVersion = { version: version2, source: ".python-version" };
-        (0, import_build_utils8.debug)(`Found Python version ${version2} in .python-version`);
+        (0, import_build_utils9.debug)(`Found Python version ${version2} in .python-version`);
       }
     } catch (err) {
-      (0, import_build_utils8.debug)("Failed to read .python-version file", err);
+      (0, import_build_utils9.debug)("Failed to read .python-version file", err);
     }
   }
   if (!declaredPythonVersion && pyprojectDir) {
     let requiresPython;
     try {
-      const pyproject = await (0, import_build_utils9.readConfigFile)((0, import_path7.join)(pyprojectDir, "pyproject.toml"));
+      const pyproject = await (0, import_build_utils10.readConfigFile)((0, import_path8.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
     } catch (err) {
-      (0, import_build_utils8.debug)("Failed to parse pyproject.toml", err);
+      (0, import_build_utils9.debug)("Failed to parse pyproject.toml", err);
     }
     if (typeof requiresPython === "string" && requiresPython.trim()) {
       declaredPythonVersion = {
         version: requiresPython.trim(),
         source: "pyproject.toml"
       };
-      (0, import_build_utils8.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
+      (0, import_build_utils9.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
     }
   }
   if (!declaredPythonVersion && pipfileLockDir) {
     let lock = {};
-    const pipfileLockPath = (0, import_path7.join)(pipfileLockDir, "Pipfile.lock");
+    const pipfileLockPath = (0, import_path8.join)(pipfileLockDir, "Pipfile.lock");
     try {
-      const pipfileLockContent = await readFile(pipfileLockPath, "utf8");
+      const pipfileLockContent = await readFile2(pipfileLockPath, "utf8");
       try {
         lock = JSON.parse(pipfileLockContent);
       } catch (err) {
@@ -4683,7 +4934,7 @@ ${pipfileLockContent}`
         throw err;
       }
     } catch (err) {
-      throw new import_build_utils8.NowBuildError({
+      throw new import_build_utils9.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",
         message: "Unable to parse Pipfile.lock"
       });
@@ -4691,7 +4942,7 @@ ${pipfileLockContent}`
     const pyFromLock = lock?._meta?.requires?.python_version;
     if (pyFromLock) {
       declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils8.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      (0, import_build_utils9.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
     }
   }
   const pythonVersion = getSupportedPythonVersion({
@@ -4701,15 +4952,15 @@ ${pipfileLockContent}`
   const selectedVersionTuple = parseVersionTuple(pythonVersion.version);
   const defaultVersionTuple = parseVersionTuple(DEFAULT_PYTHON_VERSION);
   if (!pythonVersionFileDir && pyprojectDir && declaredPythonVersion?.source === "pyproject.toml" && selectedVersionTuple && defaultVersionTuple && compareTuples(selectedVersionTuple, defaultVersionTuple) <= 0) {
-    const pythonVersionFilePath = (0, import_path7.join)(pyprojectDir, ".python-version");
+    const pythonVersionFilePath = (0, import_path8.join)(pyprojectDir, ".python-version");
     await writeFile(pythonVersionFilePath, `${pythonVersion.version}
 `);
     console.log(
       `Writing .python-version file with version ${pythonVersion.version}`
     );
   }
-  fsFiles = await (0, import_build_utils8.glob)("**", workPath);
-  const venvPath = (0, import_path7.join)(workPath, ".vercel", "python", ".venv");
+  fsFiles = await (0, import_build_utils9.glob)("**", workPath);
+  const venvPath = (0, import_path8.join)(workPath, ".vercel", "python", ".venv");
   await ensureVenv({
     pythonPath: pythonVersion.pythonPath,
     venvPath
@@ -4720,7 +4971,7 @@ ${pipfileLockContent}`
   let assumeDepsInstalled = false;
   if (projectInstallCommand) {
     console.log(`Running "install" command: \`${projectInstallCommand}\`...`);
-    await (0, import_build_utils8.execCommand)(projectInstallCommand, {
+    await (0, import_build_utils9.execCommand)(projectInstallCommand, {
       env: pythonEnv,
       cwd: workPath
     });
@@ -4777,7 +5028,7 @@ ${pipfileLockContent}`
         });
       } catch (err) {
         noBuildCheckFailed = true;
-        (0, import_build_utils8.debug)(
+        (0, import_build_utils9.debug)(
           `--no-build check failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
@@ -4790,18 +5041,18 @@ ${pipfileLockContent}`
     });
   }
   const runtimeDep = baseEnv.VERCEL_RUNTIME_PYTHON || `vercel-runtime==${VERCEL_RUNTIME_VERSION}`;
-  (0, import_build_utils8.debug)(`Installing ${runtimeDep}`);
+  (0, import_build_utils9.debug)(`Installing ${runtimeDep}`);
   await uv.pip({
     venvPath,
-    projectDir: (0, import_path7.join)(workPath, entryDirectory),
+    projectDir: (0, import_path8.join)(workPath, entryDirectory),
     args: ["install", runtimeDep]
   });
-  (0, import_build_utils8.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils9.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils8.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils9.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const runtimeTrampoline = `
 import importlib
 import os
@@ -4864,166 +5115,32 @@ 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_utils8.glob)("**", globOptions);
-  const allVendorFiles = await mirrorSitePackagesIntoVendor({
+  const files = await (0, import_build_utils9.glob)("**", globOptions);
+  const depExternalizer = new PythonDependencyExternalizer({
     venvPath,
-    vendorDirName: vendorDir
-  });
-  const tempFilesForSizing = { ...files };
-  for (const [p, f] of Object.entries(allVendorFiles)) {
-    tempFilesForSizing[p] = f;
-  }
-  const totalBundleSize = await calculateBundleSize(tempFilesForSizing);
-  const totalBundleSizeMB = (totalBundleSize / (1024 * 1024)).toFixed(2);
-  (0, import_build_utils8.debug)(`Total bundle size: ${totalBundleSizeMB} MB`);
-  const runtimeInstallEnabled = shouldEnableRuntimeInstall({
-    totalBundleSize,
-    uvLockPath
+    vendorDir,
+    workPath,
+    uvLockPath,
+    uvProjectDir,
+    projectName,
+    noBuildCheckFailed,
+    pythonPath: pythonVersion.pythonPath
   });
-  if (runtimeInstallEnabled && uvLockPath && uvProjectDir) {
-    console.log(
-      `Bundle size (${totalBundleSizeMB} MB) exceeds limit. Enabling runtime dependency installation.`
-    );
-    if (totalBundleSize > LAMBDA_EPHEMERAL_STORAGE_BYTES) {
-      const ephemeralLimitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(0);
-      throw new import_build_utils8.NowBuildError({
-        code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total dependency size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB). Even with runtime dependency installation, all packages must fit within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda functions. Consider removing unused dependencies or splitting your application into smaller functions.`
-      });
-    }
-    if (noBuildCheckFailed) {
-      throw new import_build_utils8.NowBuildError({
-        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Bundle size exceeds the Lambda limit and requires runtime dependency installation, but some packages in your uv.lock file do not have pre-built binary wheels available.
-Runtime dependency installation requires all public packages to have binary wheels.
-
-To fix this, either:
- 1. Regenerate your lock file with: uv lock --upgrade --no-build, or
- 2. Switch the problematic packages to ones that have pre-built wheels available`
-      });
-    }
-    let lockContent;
-    try {
-      lockContent = await readFile(uvLockPath, "utf8");
-    } catch (error) {
-      if (error instanceof Error) {
-        console.log(
-          `Failed to read uv.lock file at "${uvLockPath}": ${error.message}`
-        );
-      } else {
-        console.log(
-          `Failed to read uv.lock file at "${uvLockPath}": ${String(error)}`
-        );
-      }
-      throw new import_build_utils8.NowBuildError({
-        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Failed to read uv.lock file at "${uvLockPath}"`
-      });
-    }
-    let lockFile;
-    try {
-      lockFile = (0, import_python_analysis3.parseUvLock)(lockContent, uvLockPath);
-    } catch (error) {
-      if (error instanceof import_python_analysis3.PythonAnalysisError) {
-        if (error.fileContent) {
-          console.log(
-            `Failed to parse "${error.path}". File content:
-${error.fileContent}`
-          );
-        }
-        throw new import_build_utils8.NowBuildError({
-          code: error.code,
-          message: error.message
-        });
-      }
-      throw error;
-    }
-    const excludePackages = [];
-    if (projectName) {
-      excludePackages.push(projectName);
-      (0, import_build_utils8.debug)(
-        `Excluding project package "${projectName}" from runtime installation`
-      );
-    }
-    const classification = (0, import_python_analysis3.classifyPackages)({
-      lockFile,
-      excludePackages
-    });
-    (0, import_build_utils8.debug)(
-      `Package classification: ${classification.privatePackages.length} private, ${classification.publicPackages.length} public`
-    );
-    if (classification.publicPackages.length > 0) {
-      const privatePackagesWithRuntime = [
-        ...classification.privatePackages,
-        "vercel-runtime",
-        "vercel_runtime"
-      ];
-      const privateVendorFiles = await mirrorPrivatePackagesIntoVendor({
-        venvPath,
-        vendorDirName: vendorDir,
-        privatePackages: privatePackagesWithRuntime
-      });
-      for (const [p, f] of Object.entries(privateVendorFiles)) {
-        files[p] = f;
-      }
-      const runtimeRequirementsContent = (0, import_python_analysis3.generateRuntimeRequirements)(classification);
-      const runtimeRequirementsPath = `${UV_BUNDLE_DIR}/_runtime_requirements.txt`;
-      files[runtimeRequirementsPath] = new import_build_utils8.FileBlob({
-        data: runtimeRequirementsContent
-      });
-      if (process.env.VERCEL_BUILD_IMAGE) {
-        try {
-          const uvBinaryPath = await getUvBinaryForBundling(
-            pythonVersion.pythonPath
-          );
-          const uvBundleDir = (0, import_path7.join)(workPath, UV_BUNDLE_DIR);
-          const uvLocalPath = (0, import_path7.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_utils8.FileFsRef({
-            fsPath: uvLocalPath,
-            mode: 33261
-            // Regular file + executable
-          });
-          (0, import_build_utils8.debug)(`Bundled uv binary from ${uvBinaryPath} to ${uvLocalPath}`);
-        } catch (err) {
-          throw new import_build_utils8.NowBuildError({
-            code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-            message: `Failed to bundle uv binary for runtime installation: ${err instanceof Error ? err.message : String(err)}`
-          });
-        }
-      }
-    } else {
-      throw new import_build_utils8.NowBuildError({
-        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: "Bundle size exceeds limit but no public packages found for runtime installation."
-      });
-    }
+  const { overLambdaLimit, allVendorFiles } = await depExternalizer.analyze(files);
+  if (overLambdaLimit) {
+    await depExternalizer.generateBundle(files);
   } else {
     for (const [p, f] of Object.entries(allVendorFiles)) {
       files[p] = f;
     }
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils8.FileBlob({ data: runtimeTrampoline });
+  files[`${handlerPyFilename}.py`] = new import_build_utils9.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils8.FileBlob({ data: `"${SESSKEY}"` });
-  }
-  if (runtimeInstallEnabled) {
-    const finalBundleSize = await calculateBundleSize(files);
-    if (finalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
-      const finalSizeMB = (finalBundleSize / (1024 * 1024)).toFixed(2);
-      const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
-      throw new import_build_utils8.NowBuildError({
-        code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after deferring public packages to runtime installation. This usually means your private packages or source code are too large. Consider reducing the size of private dependencies or splitting your application.`
-      });
-    }
+    files[".sesskey"] = new import_build_utils9.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils8.Lambda({
+  const output = new import_build_utils9.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -5059,7 +5176,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path7.parse)(entrypoint);
+  const { dir, name } = (0, import_path8.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
@@ -5085,7 +5202,6 @@ function parsePythonVersionFile(content) {
   downloadFilesInWorkPath,
   installRequirement,
   installRequirementsFile,
-  shouldEnableRuntimeInstall,
   shouldServe,
   startDevServer,
   version