@vercel/python 6.47.0 → 6.47.2

package/dist/index.js

@@ -5649,12 +5649,16 @@ var import_execa4 = __toESM(require_execa());
 var import_build_utils6 = require("@vercel/build-utils");
 var import_fs5 = __toESM(require("fs"));
 var import_path6 = require("path");
-function isPythonOnHive() {
-  const hive = process.env.VERCEL_PYTHON_ON_HIVE;
-  return hive === "1" || hive === "true";
+
+// src/large-functions.ts
+function isLargeFunctionsEnabled() {
+  const value = process.env.VERCEL_SUPPORT_LARGE_FUNCTIONS;
+  return value === "1" || value === "true";
 }
+
+// src/compileall.ts
 function isCompileAllEnabled() {
-  if (!isPythonOnHive())
+  if (!isLargeFunctionsEnabled())
     return false;
   const val = process.env.VERCEL_PYTHON_COMPILEALL;
   if (val === void 0 || val === "")
@@ -5664,11 +5668,12 @@ function isCompileAllEnabled() {
 }
 function shouldUseCompileAll({
   isDev,
-  hasCustomCommand
+  hasCustomCommand,
+  hasCustomBuildCommand
 }) {
   if (isDev)
     return false;
-  if (hasCustomCommand)
+  if (hasCustomCommand || hasCustomBuildCommand)
     return false;
   return isCompileAllEnabled();
 }
@@ -5788,11 +5793,9 @@ function shouldStripVendorFile(filePath) {
     return true;
   return false;
 }
-var LAMBDA_BASE_SIZE_THRESHOLD_BYTES = 245 * 1024 * 1024;
-var OTEL_LAYER_RESERVATION_BYTES = 5 * 1024 * 1024;
-var LAMBDA_SIZE_THRESHOLD_BYTES = process.env.VERCEL_DEPLOYMENT_HAS_OTEL_LAYER === "1" ? LAMBDA_BASE_SIZE_THRESHOLD_BYTES - OTEL_LAYER_RESERVATION_BYTES : LAMBDA_BASE_SIZE_THRESHOLD_BYTES;
+var LAMBDA_SIZE_THRESHOLD_BYTES = 225 * 1024 * 1024;
 var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
-var HIVE_LAMBDA_SIZE_BYTES = 1 * 1024 * 1024 * 1024;
+var MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE = 5 * 1024 * 1024 * 1024;
 var BUNDLING_DOCS_LINK = "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled";
 var PythonDependencyExternalizer = class {
   constructor(options) {
@@ -5818,13 +5821,13 @@ var PythonDependencyExternalizer = class {
     if (this.hasCustomCommand) {
       return false;
     }
-    const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
-    if (pythonOnHiveEnabled) {
+    if (this.totalBundleSize <= LAMBDA_SIZE_THRESHOLD_BYTES || this.uvLockPath === null) {
       return false;
-    } else if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.uvLockPath !== null) {
-      return true;
     }
-    return false;
+    if (isLargeFunctionsEnabled() && this.totalBundleSize > LAMBDA_EPHEMERAL_STORAGE_BYTES) {
+      return false;
+    }
+    return true;
   }
   /**
    * Analyze the bundle: mirror all vendor files, calculate total size,
@@ -5854,29 +5857,28 @@ var PythonDependencyExternalizer = class {
     const totalBundleSizeMB = (this.totalBundleSize / (1024 * 1024)).toFixed(2);
     (0, import_build_utils7.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";
+    const largeFunctionsEnabled = isLargeFunctionsEnabled();
     options.onSized?.({
       totalSizeBytes: this.totalBundleSize,
       runtimeInstallEnabled
     });
-    if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.hasCustomCommand && !pythonOnHiveEnabled) {
+    if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.hasCustomCommand && !largeFunctionsEnabled) {
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the size limit (${limitMB} MB).
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the maximum function size (${limitMB} MB).
 
-When using a custom install command, Vercel cannot automatically
-optimize dependency bundling. To reduce the size of your
-dependencies, you can:
-  1. Remove unused dependencies from your project.
-  2. Remove the custom install command to allow Vercel to manage
-     and optimize dependencies automatically.`,
+A custom install command prevents Vercel from optimizing your
+function bundle size automatically. To fix this, you can:
+  1. Remove unused dependencies from your project, or
+  2. Remove the custom install command so Vercel can optimize
+     the function bundle automatically.`,
         link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
-    if (pythonOnHiveEnabled && this.totalBundleSize > HIVE_LAMBDA_SIZE_BYTES) {
-      const limitMB = (HIVE_LAMBDA_SIZE_BYTES / (1024 * 1024)).toFixed(0);
+    if (largeFunctionsEnabled && this.totalBundleSize >= MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE) {
+      const limitMB = (MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
         message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB).
@@ -5898,6 +5900,10 @@ application into smaller functions.`,
    * Mutates `files` in place: adds vendor files (private + knapsack-selected
    * public), runtime config, and uv binary.
    * Must be called after analyze().
+   *
+   * If large functions are allowed and the bundle can't fit AWS Lambda, falls
+   * back to bundling everything for Hive and returns `fellBackToFullBundle:
+   * true` so the caller can apply the same compileall handling.
    */
   async generateBundle(files) {
     if (!this.analyzed) {
@@ -5906,54 +5912,49 @@ application into smaller functions.`,
       );
     }
     if (!this.uvLockPath || !this.uvProjectDir) {
-      throw new import_build_utils7.NowBuildError({
-        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: "Runtime dependency installation requires a uv.lock file and project directory."
-      });
+      throw new Error(
+        "generateBundle() requires uvLockPath and uvProjectDir to be set"
+      );
     }
     const totalBundleSizeMB = (this.totalBundleSize / (1024 * 1024)).toFixed(2);
-    console.log(
-      `Bundle size (${totalBundleSizeMB} MB) exceeds limit. Enabling runtime dependency installation.`
-    );
+    const largeFunctionsEnabled = isLargeFunctionsEnabled();
     if (this.totalBundleSize > LAMBDA_EPHEMERAL_STORAGE_BYTES) {
-      const ephemeralLimitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(0);
+      if (largeFunctionsEnabled) {
+        return this.bundleAllForHive(files);
+      }
+      const limitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(
+        0
+      );
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB).
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the maximum function size (${limitMB} 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.`,
+Reduce the size of your dependencies or split your application into
+smaller functions.`,
         link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
+    const relLockPath = (0, import_path7.relative)(this.workPath, this.uvLockPath);
     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)}`
-        );
-      }
+      (0, import_build_utils7.debug)(
+        `Failed to read uv.lock at ${this.uvLockPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
       throw new import_build_utils7.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Failed to read uv.lock file at "${this.uvLockPath}"`
+        message: `Failed to read the uv.lock file at "${relLockPath}".`
       });
     }
     let lockFile;
     try {
-      lockFile = (0, import_python_analysis3.parseUvLock)(lockContent, this.uvLockPath);
+      lockFile = (0, import_python_analysis3.parseUvLock)(lockContent, relLockPath);
     } catch (error) {
       if (error instanceof import_python_analysis3.PythonAnalysisError) {
         if (error.fileContent) {
-          console.log(
+          (0, import_build_utils7.debug)(
             `Failed to parse "${error.path}". File content:
 ${error.fileContent}`
           );
@@ -5995,19 +5996,18 @@ ${error.fileContent}`
       (name) => !forceBundledSet.has((0, import_python_analysis3.normalizePackageName)(name))
     );
     if (externalizablePublic.length === 0) {
+      if (largeFunctionsEnabled) {
+        return this.bundleAllForHive(files);
+      }
       throw new import_build_utils7.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Bundle size exceeds the Lambda limit and requires runtime
-dependency installation, but no public packages have compatible
-pre-built wheels for the Lambda platform.
-
-Runtime dependency installation requires packages to have binary
-wheels.
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the maximum function size and
+can't be optimized automatically because some dependencies don't
+provide a compatible pre-built wheel.
 
 To fix this, either:
   1. Regenerate your lock file with: uv lock --upgrade, or
-  2. Switch the problematic packages to ones that have pre-built
-     wheels available.`
+  2. Replace the packages that don't provide a pre-built wheel.`
       });
     }
     const packageSizes = await this.calculatePerPackageSizes();
@@ -6052,6 +6052,12 @@ To fix this, either:
     (0, import_build_utils7.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`
     );
+    if (largeFunctionsEnabled && remainingCapacity < 0) {
+      return this.bundleAllForHive(files);
+    }
+    console.log(
+      `Bundle size (${totalBundleSizeMB} MB) exceeds the standard size; optimizing dependencies.`
+    );
     const externalizableSet = new Set(
       externalizablePublic.map(import_python_analysis3.normalizePackageName)
     );
@@ -6105,27 +6111,54 @@ To fix this, either:
       });
       (0, import_build_utils7.debug)(`Bundled uv binary from ${uvBinaryPath} to ${uvLocalPath}`);
     } catch (err) {
+      (0, import_build_utils7.debug)(
+        `Failed to bundle uv binary: ${err instanceof Error ? err.message : String(err)}`
+      );
       throw new import_build_utils7.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Failed to bundle uv binary for runtime installation: ${err instanceof Error ? err.message : String(err)}`
+        message: "Failed to prepare dependency tooling."
       });
     }
     const finalBundleSize = await calculateBundleSize(files);
     if (finalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES + 100 * 1024) {
+      if (largeFunctionsEnabled) {
+        return this.bundleAllForHive(files);
+      }
       const finalSizeMB = (finalBundleSize / (1024 * 1024)).toFixed(2);
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after
-deferring public packages to runtime installation.
+        message: `Total bundle size (${finalSizeMB} MB) exceeds the maximum function size (${limitMB} MB) even after
+optimizing dependencies.
 
-This usually means your private packages or source code are too
-large. Consider reducing the size of private dependencies or
-splitting your application.`,
+This usually means your source code or private packages are too
+large. Reduce their size or split your application into smaller
+functions.`,
         link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
+    return { fellBackToFullBundle: false };
+  }
+  /**
+   * Discard any runtime-install artifacts added so far and bundle every
+   * dependency directly, for a function that will run on Hive. Returns the
+   * fell-back signal so the caller can apply the same compileall handling.
+   */
+  bundleAllForHive(files) {
+    for (const key of [
+      `${UV_BUNDLE_DIR}/_runtime_config.json`,
+      `${UV_BUNDLE_DIR}/uv`,
+      `${UV_BUNDLE_DIR}/pyproject.toml`,
+      `${UV_BUNDLE_DIR}/uv.lock`
+    ]) {
+      delete files[key];
+    }
+    for (const [p, f] of Object.entries(this.allVendorFiles)) {
+      files[p] = f;
+    }
+    (0, import_build_utils7.debug)("Bundling all dependencies for the large functions path.");
+    return { fellBackToFullBundle: true };
   }
   /**
    * Identify public packages that have no compatible wheel for the Lambda platform.
@@ -8939,6 +8972,29 @@ function getTargetPlatform(isDev) {
   }
   return { uvPlatform: UV_LINUX_TARGET, architecture: "x86_64" };
 }
+async function getPythonLambdaOptions({
+  config,
+  entrypoint
+}) {
+  if (!config?.functions) {
+    return {};
+  }
+  const sources = /* @__PURE__ */ new Set([entrypoint]);
+  if (entrypoint.endsWith(".py")) {
+    sources.add(entrypoint.slice(0, -".py".length));
+  }
+  for (const sourceFile of sources) {
+    const lambdaOptions = await (0, import_build_utils19.getLambdaOptionsFromFunction)({
+      sourceFile,
+      config
+    });
+    if (Object.keys(lambdaOptions).length > 0) {
+      delete lambdaOptions.architecture;
+      return lambdaOptions;
+    }
+  }
+  return {};
+}
 async function installInjectedPackage({
   name,
   pinned,
@@ -8985,6 +9041,7 @@ var build = async ({
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
+  let hasCustomBuildCommand = false;
   const target = getTargetPlatform(meta.isDev ?? false);
   (0, import_build_utils19.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
@@ -9190,12 +9247,16 @@ var build = async ({
           env: pythonEnv,
           cwd: workPath
         });
+        hasCustomBuildCommand = true;
       } else {
-        await runPyprojectScript(
+        const ranBuildScript = await runPyprojectScript(
           workPath,
           ["vercel-build", "now-build", "build"],
           pythonEnv
         );
+        if (ranBuildScript) {
+          hasCustomBuildCommand = true;
+        }
       }
     });
   }
@@ -9302,7 +9363,8 @@ var build = async ({
   });
   const automaticCompileAllEnabled = shouldUseCompileAll({
     isDev: meta.isDev,
-    hasCustomCommand
+    hasCustomCommand,
+    hasCustomBuildCommand
   });
   const predefinedExcludes = [
     ".git/**",
@@ -9371,61 +9433,74 @@ var build = async ({
         });
       }
     });
-    if (depAnalysis.runtimeInstallEnabled) {
-      await depExternalizer.generateBundle(files);
-    } else {
-      addFiles(files, depAnalysis.allVendorFiles);
-      if (automaticCompileAllEnabled) {
-        await builderSpan.child("vc.builder.python.compileall").trace(async (compileSpan) => {
-          const sitePackageDirs = (await getVenvSitePackagesDirs(venvPath)).filter((d) => import_fs15.default.existsSync(d));
-          const pythonBin = getVenvPythonBin(venvPath);
-          console.log("Compiling Python application bytecode...");
-          await runCompileAll({
-            pythonBin,
-            filesOrDirectories: [workPath],
-            env: pythonEnv,
-            excludeRegex: getCompileAllAppExcludeRegex(workPath)
-          });
-          console.log("Compiling Python dependency bytecode...");
-          await runCompileAll({
-            pythonBin,
-            filesOrDirectories: sitePackageDirs,
-            env: pythonEnv
-          });
-          compileSpan.setAttributes({
-            "python.compileall.enabled": "true",
-            "python.compileall.sitePackageDirectoryCount": String(
-              sitePackageDirs.length
-            )
-          });
+    const runCompileAllAndFillBytecode = async () => {
+      await builderSpan.child("vc.builder.python.compileall").trace(async (compileSpan) => {
+        const sitePackageDirs = (await getVenvSitePackagesDirs(venvPath)).filter((d) => import_fs15.default.existsSync(d));
+        const pythonBin = getVenvPythonBin(venvPath);
+        console.log("Compiling Python application bytecode...");
+        await runCompileAll({
+          pythonBin,
+          filesOrDirectories: [workPath],
+          env: pythonEnv,
+          excludeRegex: getCompileAllAppExcludeRegex(workPath)
         });
-        const currentSize = await calculateBundleSize(files);
-        let remainingCapacity = HIVE_LAMBDA_SIZE_BYTES - currentSize;
-        if (pythonVersion.major != null && pythonVersion.minor != null) {
-          const appBytecodeInfo = await collectAppBytecodeFiles({
-            workPath,
-            files,
-            pythonMajor: pythonVersion.major,
-            pythonMinor: pythonVersion.minor
-          });
-          remainingCapacity = addBytecodeWithinCapacity(
-            files,
-            appBytecodeInfo,
-            remainingCapacity
-          );
-        }
-        const vendorBytecodeInfo = await depExternalizer.collectBytecodeFiles(
-          {
-            vendorDirName: vendorDir
-          }
-        );
-        await addVendorBytecodeWithinCapacity({
+        console.log("Compiling Python dependency bytecode...");
+        await runCompileAll({
+          pythonBin,
+          filesOrDirectories: sitePackageDirs,
+          env: pythonEnv
+        });
+        compileSpan.setAttributes({
+          "python.compileall.enabled": "true",
+          "python.compileall.sitePackageDirectoryCount": String(
+            sitePackageDirs.length
+          )
+        });
+      });
+      const currentSize = await calculateBundleSize(files);
+      let remainingCapacity = MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE - currentSize;
+      if (pythonVersion.major != null && pythonVersion.minor != null) {
+        const appBytecodeInfo = await collectAppBytecodeFiles({
+          workPath,
           files,
-          depExternalizer,
-          vendorDir,
-          bytecodeInfo: vendorBytecodeInfo,
-          capacity: remainingCapacity
+          pythonMajor: pythonVersion.major,
+          pythonMinor: pythonVersion.minor
         });
+        remainingCapacity = addBytecodeWithinCapacity(
+          files,
+          appBytecodeInfo,
+          remainingCapacity
+        );
+      }
+      const vendorBytecodeInfo = await depExternalizer.collectBytecodeFiles({
+        vendorDirName: vendorDir
+      });
+      await addVendorBytecodeWithinCapacity({
+        files,
+        depExternalizer,
+        vendorDir,
+        bytecodeInfo: vendorBytecodeInfo,
+        capacity: remainingCapacity
+      });
+    };
+    const announceLargeFunction = () => console.log(
+      `Function "${entrypoint}" exceeds the standard size limit; enabling large functions (beta).`
+    );
+    if (depAnalysis.runtimeInstallEnabled) {
+      const { fellBackToFullBundle } = await depExternalizer.generateBundle(files);
+      if (fellBackToFullBundle) {
+        announceLargeFunction();
+        if (automaticCompileAllEnabled) {
+          await runCompileAllAndFillBytecode();
+        }
+      }
+    } else {
+      addFiles(files, depAnalysis.allVendorFiles);
+      if (isLargeFunctionsEnabled() && depAnalysis.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
+        announceLargeFunction();
+      }
+      if (automaticCompileAllEnabled && depAnalysis.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
+        await runCompileAllAndFillBytecode();
       }
     }
   });
@@ -9433,10 +9508,15 @@ var build = async ({
     ...files,
     [`${handlerPyFilename}.py`]: new import_build_utils19.FileBlob({ data: runtimeTrampoline })
   };
+  const lambdaOptions = await getPythonLambdaOptions({
+    config,
+    entrypoint
+  });
   const output = new import_build_utils19.Lambda({
     files: webFiles,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
+    ...lambdaOptions,
     architecture: target.architecture,
     environment: lambdaEnv,
     supportsResponseStreaming: true
@@ -9499,7 +9579,11 @@ var build = async ({
   }
   const lambdaPath = service?.name ? `_svc/${service.name}/index` : "index";
   const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils19.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
-  const routes = service?.name ? void 0 : [{ handle: "filesystem" }, { src: "/(.*)", dest: `/${lambdaPath}` }];
+  const isNonWebService = service?.name && service.type && service.type !== "web";
+  const routes = isNonWebService ? void 0 : [
+    { handle: "filesystem" },
+    { src: "/(.*)", dest: `/${lambdaPath}` }
+  ];
   return {
     resultVersion: 2,
     result: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.47.0",
+  "version": "6.47.2",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -36,9 +36,9 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.30.0",
-    "@vercel/python-runtime": "0.15.0",
-    "@vercel/error-utils": "2.2.0"
+    "@vercel/error-utils": "2.2.0",
+    "@vercel/build-utils": "13.32.1",
+    "@vercel/python-runtime": "0.15.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",