@vercel/build-utils 13.12.1 → 13.13.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @vercel/build-utils
 
+## 13.13.0
+
+### Minor Changes
+
+- Extend `finalizeLambda` with pluggable ZIP strategy (`createZip`), pre-digest validation hook (`validateZip`), and optional trace tags. Widen `getLambdaEnvironment` buffer param to `{ byteLength: number }`. ([#15856](https://github.com/vercel/vercel/pull/15856))
+
+## 13.12.2
+
+### Patch Changes
+
+- Extract finalize/validate function utils for build-utils ([#15776](https://github.com/vercel/vercel/pull/15776))
+
 ## 13.12.1
 
 ### Patch Changes

package/dist/collect-uncompressed-size.d.ts

@@ -0,0 +1,6 @@
+import type { Files } from './types';
+/**
+ * Collects the total uncompressed size of a set of Lambda files.
+ * Handles both FileBlob (in-memory) and FileFsRef (on-disk) file types.
+ */
+export declare const collectUncompressedSize: (files: Files, ignoreFn?: ((fileKey: string) => boolean) | undefined) => Promise<number>;

package/dist/collect-uncompressed-size.js

@@ -0,0 +1,59 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var collect_uncompressed_size_exports = {};
+__export(collect_uncompressed_size_exports, {
+  collectUncompressedSize: () => collectUncompressedSize
+});
+module.exports = __toCommonJS(collect_uncompressed_size_exports);
+var import_promises = require("fs/promises");
+const fileSizeCache = /* @__PURE__ */ new Map();
+const getFileSize = (path) => {
+  if (!path)
+    return Promise.resolve(0);
+  const cached = fileSizeCache.get(path);
+  if (cached) {
+    return cached;
+  }
+  const promise = (0, import_promises.lstat)(path).then((stats) => stats.size);
+  fileSizeCache.set(path, promise);
+  return promise;
+};
+const collectUncompressedSize = async (files, ignoreFn) => {
+  let size = 0;
+  await Promise.all(
+    Object.keys(files).map(async (fileKey) => {
+      if (ignoreFn?.(fileKey)) {
+        return;
+      }
+      const file = files[fileKey];
+      if (file.type === "FileBlob") {
+        size += file.data.length;
+      } else if (file.type === "FileFsRef") {
+        const fsRef = file;
+        const curSize = fsRef.size ?? await getFileSize(fsRef.fsPath);
+        size += curSize;
+      }
+    })
+  );
+  return size;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectUncompressedSize
+});

package/dist/finalize-lambda.d.ts

@@ -0,0 +1,81 @@
+/// <reference types="node" />
+import type { Lambda } from './lambda';
+import type { NodejsLambda } from './nodejs-lambda';
+import type { BytecodeCachingOptions } from './process-serverless/get-lambda-preload-scripts';
+import type { SupportsStreamingResult } from './process-serverless/get-lambda-supports-streaming';
+/**
+ * Optional wrapper around async work, allowing callers to inject tracing
+ * (e.g. dd-trace spans) without coupling the shared code to a tracer.
+ */
+export type TraceFn = <T>(name: string, fn: () => Promise<T>, tags?: Record<string, string>) => Promise<T>;
+/**
+ * Result of a custom ZIP creation strategy.
+ */
+export interface CreateZipResult {
+    /** The zip as a Buffer (in-memory), or null for disk-based paths. */
+    buffer: Buffer | null;
+    /** Path to the zip file on disk, or undefined for in-memory. */
+    zipPath?: string;
+    /** SHA-256 hex digest of the zip contents. */
+    digest: string;
+    /** Compressed size in bytes. */
+    size: number;
+}
+/**
+ * Custom ZIP creation strategy. When provided, replaces the default
+ * in-memory `lambda.createZip()` + `sha256()` path. This allows callers
+ * to stream large zips to disk instead.
+ */
+export type CreateZipFn = (lambda: Lambda | NodejsLambda) => Promise<CreateZipResult>;
+export interface FinalizeLambdaParams {
+    lambda: Lambda | NodejsLambda;
+    encryptedEnvFilename?: string;
+    encryptedEnvContent?: string;
+    bytecodeCachingOptions: BytecodeCachingOptions;
+    forceStreamingRuntime: boolean;
+    /** When true, collect the uncompressed size of lambda files before zipping. */
+    enableUncompressedLambdaSizeCheck?: boolean;
+    /** Optional tracing wrapper for `collectUncompressedSize` and `createZip`. */
+    trace?: TraceFn;
+    /** Custom ZIP creation strategy. Defaults to in-memory lambda.createZip(). */
+    createZip?: CreateZipFn;
+    /**
+     * Called after ZIP creation but before digest/environment/streaming.
+     * Throw to abort (e.g. size validation). For the default in-memory path,
+     * this runs before sha256.
+     */
+    validateZip?: (zip: {
+        buffer: Buffer | null;
+        zipPath?: string;
+        size: number;
+    }) => void;
+}
+export interface FinalizeLambdaResult {
+    /** The zip as a Buffer, or null when a custom createZip returns a disk path. */
+    buffer: Buffer | null;
+    /** Path to zip on disk (set by custom createZip), undefined for in-memory. */
+    zipPath?: string;
+    /** SHA-256 hex digest. */
+    digest: string;
+    /** Compressed size in bytes. */
+    size: number;
+    uncompressedBytes: number;
+    /** Non-fatal streaming detection error, if any. Caller decides how to log. */
+    streamingError?: SupportsStreamingResult['error'];
+}
+/**
+ * Core Lambda finalization logic shared between BYOF and build-container.
+ *
+ * This function:
+ * 1. Injects encrypted env file into lambda.files when provided
+ * 2. Collects uncompressed size when enabled
+ * 3. Creates the ZIP (in-memory or via custom strategy)
+ * 4. Runs optional validateZip hook (e.g. size check)
+ * 5. Computes SHA-256 digest (default path only; custom path provides its own)
+ * 6. Merges environment variables (bytecode caching, helpers, etc.)
+ * 7. Detects streaming support
+ *
+ * Note: This function mutates the `lambda` (files, environment,
+ * supportsResponseStreaming).
+ */
+export declare function finalizeLambda(params: FinalizeLambdaParams): Promise<FinalizeLambdaResult>;

package/dist/finalize-lambda.js

@@ -0,0 +1,118 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var finalize_lambda_exports = {};
+__export(finalize_lambda_exports, {
+  finalizeLambda: () => finalizeLambda
+});
+module.exports = __toCommonJS(finalize_lambda_exports);
+var import_get_encrypted_env_file = require("./process-serverless/get-encrypted-env-file");
+var import_get_lambda_environment = require("./process-serverless/get-lambda-environment");
+var import_get_lambda_supports_streaming = require("./process-serverless/get-lambda-supports-streaming");
+var import_stream_to_digest_async = require("./fs/stream-to-digest-async");
+var import_collect_uncompressed_size = require("./collect-uncompressed-size");
+const defaultTrace = (_name, fn) => fn();
+async function finalizeLambda(params) {
+  const {
+    lambda,
+    encryptedEnvFilename,
+    encryptedEnvContent,
+    bytecodeCachingOptions,
+    forceStreamingRuntime,
+    enableUncompressedLambdaSizeCheck,
+    trace = defaultTrace,
+    createZip: createZipOverride,
+    validateZip
+  } = params;
+  const encryptedEnv = (0, import_get_encrypted_env_file.getEncryptedEnv)(
+    encryptedEnvFilename,
+    encryptedEnvContent
+  );
+  if (encryptedEnv) {
+    const [envFilename, envFile] = encryptedEnv;
+    lambda.zipBuffer = void 0;
+    lambda.files = {
+      ...lambda.files,
+      [envFilename]: envFile
+    };
+  }
+  let uncompressedBytes = 0;
+  if (enableUncompressedLambdaSizeCheck) {
+    if (lambda.files) {
+      uncompressedBytes = await trace(
+        "collectUncompressedSize",
+        () => (0, import_collect_uncompressed_size.collectUncompressedSize)(lambda.files ?? {})
+      );
+    }
+  }
+  const zipTags = {
+    fileCount: String(Object.keys(lambda.files ?? {}).length),
+    uncompressedBytes: String(uncompressedBytes)
+  };
+  let zipResult;
+  if (createZipOverride) {
+    zipResult = await trace(
+      "createZip",
+      () => createZipOverride(lambda),
+      zipTags
+    );
+  } else {
+    const buffer = lambda.zipBuffer || await trace("createZip", () => lambda.createZip(), zipTags);
+    zipResult = {
+      buffer,
+      digest: "",
+      // computed in step 5
+      size: buffer.byteLength
+    };
+  }
+  if (validateZip) {
+    validateZip({
+      buffer: zipResult.buffer,
+      zipPath: zipResult.zipPath,
+      size: zipResult.size
+    });
+  }
+  if (!createZipOverride && zipResult.buffer) {
+    zipResult.digest = (0, import_stream_to_digest_async.sha256)(zipResult.buffer);
+  }
+  lambda.environment = {
+    ...lambda.environment,
+    ...(0, import_get_lambda_environment.getLambdaEnvironment)(
+      lambda,
+      zipResult.buffer ?? { byteLength: zipResult.size },
+      bytecodeCachingOptions
+    )
+  };
+  const streamingResult = await (0, import_get_lambda_supports_streaming.getLambdaSupportsStreaming)(
+    lambda,
+    forceStreamingRuntime
+  );
+  lambda.supportsResponseStreaming = streamingResult.supportsStreaming;
+  return {
+    buffer: zipResult.buffer,
+    zipPath: zipResult.zipPath,
+    digest: zipResult.digest,
+    size: zipResult.size,
+    uncompressedBytes,
+    streamingError: streamingResult.error
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  finalizeLambda
+});

package/dist/index.d.ts

@@ -46,3 +46,6 @@ export { getLambdaByOutputPath } from './collect-build-result/get-lambda-by-outp
 export { isRouteMiddleware } from './collect-build-result/is-route-middleware';
 export { getPrerenderChain } from './collect-build-result/get-prerender-chain';
 export { streamWithExtendedPayload, type ExtendedBodyData, } from './collect-build-result/stream-with-extended-payload';
+export { collectUncompressedSize } from './collect-uncompressed-size';
+export { finalizeLambda, type CreateZipResult, type CreateZipFn, type FinalizeLambdaParams, type FinalizeLambdaResult, type TraceFn, } from './finalize-lambda';
+export { validateLambdaSize, validateUncompressedLambdaSize, FunctionSizeError, MAX_LAMBDA_SIZE, MAX_LAMBDA_UNCOMPRESSED_SIZE, validateEnvWrapperSupport, ENV_WRAPPER_SUPPORTED_FAMILIES, } from './validate-lambda-size';

package/dist/index.js

@@ -11924,18 +11924,18 @@ var require_sync = __commonJS({
       if (this.follow)
         return this._readdir(abs, false);
       var entries;
-      var lstat2;
+      var lstat3;
       var stat;
       try {
-        lstat2 = this.fs.lstatSync(abs);
+        lstat3 = this.fs.lstatSync(abs);
       } catch (er) {
         if (er.code === "ENOENT") {
           return null;
         }
       }
-      var isSym = lstat2 && lstat2.isSymbolicLink();
+      var isSym = lstat3 && lstat3.isSymbolicLink();
       this.symlinks[abs] = isSym;
-      if (!isSym && lstat2 && !lstat2.isDirectory())
+      if (!isSym && lstat3 && !lstat3.isDirectory())
         this.cache[abs] = "FILE";
       else
         entries = this._readdir(abs, false);
@@ -12060,23 +12060,23 @@ var require_sync = __commonJS({
       var exists;
       var stat = this.statCache[abs];
       if (!stat) {
-        var lstat2;
+        var lstat3;
         try {
-          lstat2 = this.fs.lstatSync(abs);
+          lstat3 = this.fs.lstatSync(abs);
         } catch (er) {
           if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
             this.statCache[abs] = false;
             return false;
           }
         }
-        if (lstat2 && lstat2.isSymbolicLink()) {
+        if (lstat3 && lstat3.isSymbolicLink()) {
           try {
             stat = this.fs.statSync(abs);
           } catch (er) {
-            stat = lstat2;
+            stat = lstat3;
           }
         } else {
-          stat = lstat2;
+          stat = lstat3;
         }
       }
       this.statCache[abs] = stat;
@@ -12493,12 +12493,12 @@ var require_glob = __commonJS({
       var lstatcb = inflight(lstatkey, lstatcb_);
       if (lstatcb)
         self2.fs.lstat(abs, lstatcb);
-      function lstatcb_(er, lstat2) {
+      function lstatcb_(er, lstat3) {
         if (er && er.code === "ENOENT")
           return cb();
-        var isSym = lstat2 && lstat2.isSymbolicLink();
+        var isSym = lstat3 && lstat3.isSymbolicLink();
         self2.symlinks[abs] = isSym;
-        if (!isSym && lstat2 && !lstat2.isDirectory()) {
+        if (!isSym && lstat3 && !lstat3.isDirectory()) {
           self2.cache[abs] = "FILE";
           cb();
         } else
@@ -12666,16 +12666,16 @@ var require_glob = __commonJS({
       var statcb = inflight("stat\0" + abs, lstatcb_);
       if (statcb)
         self2.fs.lstat(abs, statcb);
-      function lstatcb_(er, lstat2) {
-        if (lstat2 && lstat2.isSymbolicLink()) {
+      function lstatcb_(er, lstat3) {
+        if (lstat3 && lstat3.isSymbolicLink()) {
           return self2.fs.stat(abs, function(er2, stat2) {
             if (er2)
-              self2._stat2(f, abs, null, lstat2, cb);
+              self2._stat2(f, abs, null, lstat3, cb);
             else
               self2._stat2(f, abs, er2, stat2, cb);
           });
         } else {
-          self2._stat2(f, abs, er, lstat2, cb);
+          self2._stat2(f, abs, er, lstat3, cb);
         }
       }
     };
@@ -19806,6 +19806,95 @@ var require_ignore = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/bytes@3.1.2/node_modules/bytes/index.js
+var require_bytes = __commonJS({
+  "../../node_modules/.pnpm/bytes@3.1.2/node_modules/bytes/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = bytes2;
+    module2.exports.format = format;
+    module2.exports.parse = parse6;
+    var formatThousandsRegExp = /\B(?=(\d{3})+(?!\d))/g;
+    var formatDecimalsRegExp = /(?:\.0*|(\.[^0]+)0+)$/;
+    var map = {
+      b: 1,
+      kb: 1 << 10,
+      mb: 1 << 20,
+      gb: 1 << 30,
+      tb: Math.pow(1024, 4),
+      pb: Math.pow(1024, 5)
+    };
+    var parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
+    function bytes2(value, options) {
+      if (typeof value === "string") {
+        return parse6(value);
+      }
+      if (typeof value === "number") {
+        return format(value, options);
+      }
+      return null;
+    }
+    function format(value, options) {
+      if (!Number.isFinite(value)) {
+        return null;
+      }
+      var mag = Math.abs(value);
+      var thousandsSeparator = options && options.thousandsSeparator || "";
+      var unitSeparator = options && options.unitSeparator || "";
+      var decimalPlaces = options && options.decimalPlaces !== void 0 ? options.decimalPlaces : 2;
+      var fixedDecimals = Boolean(options && options.fixedDecimals);
+      var unit = options && options.unit || "";
+      if (!unit || !map[unit.toLowerCase()]) {
+        if (mag >= map.pb) {
+          unit = "PB";
+        } else if (mag >= map.tb) {
+          unit = "TB";
+        } else if (mag >= map.gb) {
+          unit = "GB";
+        } else if (mag >= map.mb) {
+          unit = "MB";
+        } else if (mag >= map.kb) {
+          unit = "KB";
+        } else {
+          unit = "B";
+        }
+      }
+      var val = value / map[unit.toLowerCase()];
+      var str = val.toFixed(decimalPlaces);
+      if (!fixedDecimals) {
+        str = str.replace(formatDecimalsRegExp, "$1");
+      }
+      if (thousandsSeparator) {
+        str = str.split(".").map(function(s, i) {
+          return i === 0 ? s.replace(formatThousandsRegExp, thousandsSeparator) : s;
+        }).join(".");
+      }
+      return str + unitSeparator + unit;
+    }
+    function parse6(val) {
+      if (typeof val === "number" && !isNaN(val)) {
+        return val;
+      }
+      if (typeof val !== "string") {
+        return null;
+      }
+      var results = parseRegExp.exec(val);
+      var floatValue;
+      var unit = "b";
+      if (!results) {
+        floatValue = parseInt(val, 10);
+        unit = "b";
+      } else {
+        floatValue = parseFloat(results[1]);
+        unit = results[4].toLowerCase();
+      }
+      if (isNaN(floatValue)) {
+        return null;
+      }
+      return Math.floor(map[unit] * floatValue);
+    }
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -19814,11 +19903,15 @@ __export(src_exports, {
   BUILDER_COMPILE_STEP: () => BUILDER_COMPILE_STEP,
   BUILDER_INSTALLER_STEP: () => BUILDER_INSTALLER_STEP,
   BunVersion: () => BunVersion,
+  ENV_WRAPPER_SUPPORTED_FAMILIES: () => ENV_WRAPPER_SUPPORTED_FAMILIES,
   EdgeFunction: () => EdgeFunction,
   FileBlob: () => FileBlob,
   FileFsRef: () => file_fs_ref_default,
   FileRef: () => FileRef,
+  FunctionSizeError: () => FunctionSizeError,
   Lambda: () => Lambda,
+  MAX_LAMBDA_SIZE: () => MAX_LAMBDA_SIZE,
+  MAX_LAMBDA_UNCOMPRESSED_SIZE: () => MAX_LAMBDA_UNCOMPRESSED_SIZE,
   NODE_VERSIONS: () => NODE_VERSIONS,
   NodeVersion: () => NodeVersion,
   NodejsLambda: () => NodejsLambda,
@@ -19830,6 +19923,7 @@ __export(src_exports, {
   Version: () => Version,
   buildsSchema: () => buildsSchema,
   cloneEnv: () => cloneEnv,
+  collectUncompressedSize: () => collectUncompressedSize,
   createLambda: () => createLambda,
   debug: () => debug,
   defaultCachePathGlob: () => defaultCachePathGlob,
@@ -19837,6 +19931,7 @@ __export(src_exports, {
   download: () => download,
   downloadFile: () => downloadFile,
   execCommand: () => execCommand,
+  finalizeLambda: () => finalizeLambda,
   findPackageJson: () => findPackageJson,
   functionsSchema: () => functionsSchema,
   generateNodeBuilderFunctions: () => generateNodeBuilderFunctions,
@@ -19908,7 +20003,10 @@ __export(src_exports, {
   streamToDigestAsync: () => streamToDigestAsync,
   streamWithExtendedPayload: () => streamWithExtendedPayload,
   traverseUpDirectories: () => traverseUpDirectories,
+  validateEnvWrapperSupport: () => validateEnvWrapperSupport,
+  validateLambdaSize: () => validateLambdaSize,
   validateNpmrc: () => validateNpmrc,
+  validateUncompressedLambdaSize: () => validateUncompressedLambdaSize,
   walkParentDirs: () => walkParentDirs
 });
 module.exports = __toCommonJS(src_exports);
@@ -24343,6 +24441,197 @@ var MultipartContentStream = class extends import_stream.Readable {
   _read() {
   }
 };
+
+// src/collect-uncompressed-size.ts
+var import_promises2 = require("fs/promises");
+var fileSizeCache = /* @__PURE__ */ new Map();
+var getFileSize = (path7) => {
+  if (!path7)
+    return Promise.resolve(0);
+  const cached = fileSizeCache.get(path7);
+  if (cached) {
+    return cached;
+  }
+  const promise = (0, import_promises2.lstat)(path7).then((stats) => stats.size);
+  fileSizeCache.set(path7, promise);
+  return promise;
+};
+var collectUncompressedSize = async (files, ignoreFn) => {
+  let size = 0;
+  await Promise.all(
+    Object.keys(files).map(async (fileKey) => {
+      if (ignoreFn?.(fileKey)) {
+        return;
+      }
+      const file = files[fileKey];
+      if (file.type === "FileBlob") {
+        size += file.data.length;
+      } else if (file.type === "FileFsRef") {
+        const fsRef = file;
+        const curSize = fsRef.size ?? await getFileSize(fsRef.fsPath);
+        size += curSize;
+      }
+    })
+  );
+  return size;
+};
+
+// src/finalize-lambda.ts
+var defaultTrace = (_name, fn) => fn();
+async function finalizeLambda(params) {
+  const {
+    lambda,
+    encryptedEnvFilename,
+    encryptedEnvContent,
+    bytecodeCachingOptions,
+    forceStreamingRuntime,
+    enableUncompressedLambdaSizeCheck,
+    trace = defaultTrace,
+    createZip: createZipOverride,
+    validateZip
+  } = params;
+  const encryptedEnv = getEncryptedEnv(
+    encryptedEnvFilename,
+    encryptedEnvContent
+  );
+  if (encryptedEnv) {
+    const [envFilename, envFile] = encryptedEnv;
+    lambda.zipBuffer = void 0;
+    lambda.files = {
+      ...lambda.files,
+      [envFilename]: envFile
+    };
+  }
+  let uncompressedBytes = 0;
+  if (enableUncompressedLambdaSizeCheck) {
+    if (lambda.files) {
+      uncompressedBytes = await trace(
+        "collectUncompressedSize",
+        () => collectUncompressedSize(lambda.files ?? {})
+      );
+    }
+  }
+  const zipTags = {
+    fileCount: String(Object.keys(lambda.files ?? {}).length),
+    uncompressedBytes: String(uncompressedBytes)
+  };
+  let zipResult;
+  if (createZipOverride) {
+    zipResult = await trace(
+      "createZip",
+      () => createZipOverride(lambda),
+      zipTags
+    );
+  } else {
+    const buffer = lambda.zipBuffer || await trace("createZip", () => lambda.createZip(), zipTags);
+    zipResult = {
+      buffer,
+      digest: "",
+      // computed in step 5
+      size: buffer.byteLength
+    };
+  }
+  if (validateZip) {
+    validateZip({
+      buffer: zipResult.buffer,
+      zipPath: zipResult.zipPath,
+      size: zipResult.size
+    });
+  }
+  if (!createZipOverride && zipResult.buffer) {
+    zipResult.digest = sha256(zipResult.buffer);
+  }
+  lambda.environment = {
+    ...lambda.environment,
+    ...getLambdaEnvironment(
+      lambda,
+      zipResult.buffer ?? { byteLength: zipResult.size },
+      bytecodeCachingOptions
+    )
+  };
+  const streamingResult = await getLambdaSupportsStreaming(
+    lambda,
+    forceStreamingRuntime
+  );
+  lambda.supportsResponseStreaming = streamingResult.supportsStreaming;
+  return {
+    buffer: zipResult.buffer,
+    zipPath: zipResult.zipPath,
+    digest: zipResult.digest,
+    size: zipResult.size,
+    uncompressedBytes,
+    streamingError: streamingResult.error
+  };
+}
+
+// src/validate-lambda-size.ts
+var import_bytes = __toESM(require_bytes());
+var MAX_LAMBDA_SIZE = (0, import_bytes.default)("300mb");
+var MAX_LAMBDA_UNCOMPRESSED_SIZE = 250 * 1024 * 1024;
+var FunctionSizeError = class extends NowBuildError {
+  constructor(outputPath, size) {
+    super({
+      code: "NOW_SANDBOX_WORKER_MAX_LAMBDA_SIZE",
+      message: `The Vercel Function "${outputPath}" is ${(0, import_bytes.default)(
+        size
+      ).toLowerCase()} which exceeds the maximum size limit of ${(0, import_bytes.default)(
+        MAX_LAMBDA_SIZE
+      ).toLowerCase()}.`,
+      link: "https://vercel.link/serverless-function-size",
+      action: "Learn More"
+    });
+    this.size = size;
+    this.maxSize = MAX_LAMBDA_SIZE;
+  }
+};
+function validateLambdaSize(outputPath, runtime, size) {
+  if (runtime.startsWith("python")) {
+    return;
+  }
+  if (size > MAX_LAMBDA_SIZE) {
+    throw new FunctionSizeError(outputPath, size);
+  }
+}
+function validateUncompressedLambdaSize(outputPath, uncompressedBytes) {
+  if (uncompressedBytes >= MAX_LAMBDA_UNCOMPRESSED_SIZE) {
+    throw new NowBuildError({
+      code: "NOW_SANDBOX_WORKER_MAX_UNCOMPRESSED_LAMBDA_SIZE",
+      message: `The Vercel Function "${outputPath}" is ${(0, import_bytes.default)(
+        uncompressedBytes
+      ).toLowerCase()} uncompressed which exceeds the maximum uncompressed size limit of ${(0, import_bytes.default)(
+        MAX_LAMBDA_UNCOMPRESSED_SIZE
+      ).toLowerCase()}.`,
+      link: "https://vercel.link/serverless-function-size",
+      action: "Learn More"
+    });
+  }
+}
+var ENV_WRAPPER_SUPPORTED_FAMILIES = [
+  "nodejs",
+  "python",
+  "ruby",
+  "java",
+  "dotnetcore",
+  "bun",
+  "executable"
+];
+function validateEnvWrapperSupport(encryptedEnvFilename, encryptedEnvContent, lambda) {
+  if (!encryptedEnvFilename || !encryptedEnvContent) {
+    return;
+  }
+  if (!lambda.supportsWrapper && !ENV_WRAPPER_SUPPORTED_FAMILIES.some(
+    (family) => lambda.runtime.startsWith(family)
+  )) {
+    throw new Error(
+      `Serverless Function runtime ${lambda.runtime} does not support more than 4KB for environment variables`
+    );
+  }
+  if (typeof lambda.createZip !== "function") {
+    throw new Error(
+      `Serverless Function with runtime ${lambda.runtime} has no createZip function`
+    );
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BACKEND_BUILDERS,
@@ -24350,11 +24639,15 @@ var MultipartContentStream = class extends import_stream.Readable {
   BUILDER_COMPILE_STEP,
   BUILDER_INSTALLER_STEP,
   BunVersion,
+  ENV_WRAPPER_SUPPORTED_FAMILIES,
   EdgeFunction,
   FileBlob,
   FileFsRef,
   FileRef,
+  FunctionSizeError,
   Lambda,
+  MAX_LAMBDA_SIZE,
+  MAX_LAMBDA_UNCOMPRESSED_SIZE,
   NODE_VERSIONS,
   NodeVersion,
   NodejsLambda,
@@ -24366,6 +24659,7 @@ var MultipartContentStream = class extends import_stream.Readable {
   Version,
   buildsSchema,
   cloneEnv,
+  collectUncompressedSize,
   createLambda,
   debug,
   defaultCachePathGlob,
@@ -24373,6 +24667,7 @@ var MultipartContentStream = class extends import_stream.Readable {
   download,
   downloadFile,
   execCommand,
+  finalizeLambda,
   findPackageJson,
   functionsSchema,
   generateNodeBuilderFunctions,
@@ -24444,11 +24739,22 @@ var MultipartContentStream = class extends import_stream.Readable {
   streamToDigestAsync,
   streamWithExtendedPayload,
   traverseUpDirectories,
+  validateEnvWrapperSupport,
+  validateLambdaSize,
   validateNpmrc,
+  validateUncompressedLambdaSize,
   walkParentDirs
 });
 /*! Bundled license information:
 
+bytes/index.js:
+  (*!
+   * bytes
+   * Copyright(c) 2012-2014 TJ Holowaychuk
+   * Copyright(c) 2015 Jed Watson
+   * MIT Licensed
+   *)
+
 smol-toml/dist/error.js:
   (*!
    * Copyright (c) Squirrel Chat et al., All rights reserved.

package/dist/process-serverless/get-lambda-environment.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { type BytecodeCachingOptions } from './get-lambda-preload-scripts';
 interface LambdaLike {
     awsLambdaHandler?: string;
@@ -14,5 +13,7 @@ interface LambdaLike {
  * Buffer is required just to determine if Bytecode Caching should be enabled
  * but it doesn't need to be super precise.
  */
-export declare function getLambdaEnvironment(lambda: LambdaLike, buffer: Buffer, options: BytecodeCachingOptions): Record<string, string>;
+export declare function getLambdaEnvironment(lambda: LambdaLike, buffer: {
+    byteLength: number;
+}, options: BytecodeCachingOptions): Record<string, string>;
 export {};

package/dist/process-serverless/get-lambda-preload-scripts.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export interface BytecodeCachingOptions {
     vercelEnv: string | undefined;
     useBytecodeCaching: string | undefined;
@@ -17,5 +16,7 @@ interface LambdaLike {
  * The `buffer` parameter is needed to decide wether or not to enable Bytecode
  * Caching so it doesn't **need** to be exact (we can leave out the env layer)
  */
-export declare function getLambdaPreloadScripts(lambda: LambdaLike, buffer: Buffer, options: BytecodeCachingOptions): string[];
+export declare function getLambdaPreloadScripts(lambda: LambdaLike, buffer: {
+    byteLength: number;
+}, options: BytecodeCachingOptions): string[];
 export {};

package/dist/validate-lambda-size.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { NowBuildError } from './errors';
+/**
+ * Max compressed ZIP size (300 MB).
+ * Limit is 250 MB uncompressed; we set 300 MB compressed as a safety
+ * buffer. Python is exempt because AI workloads commonly exceed this.
+ */
+export declare const MAX_LAMBDA_SIZE: number;
+/**
+ * Max uncompressed size (250 MB).
+ */
+export declare const MAX_LAMBDA_UNCOMPRESSED_SIZE: number;
+/**
+ * Error thrown when a Lambda's compressed ZIP exceeds the allowed size.
+ */
+export declare class FunctionSizeError extends NowBuildError {
+    size: number;
+    maxSize: number;
+    constructor(outputPath: string, size: number);
+}
+/**
+ * Validates the compressed size of a Lambda function.
+ * Python runtimes are exempt because AI workloads commonly exceed 300 MB.
+ */
+export declare function validateLambdaSize(outputPath: string, runtime: string, size: number): void;
+/**
+ * Validates the uncompressed size of a Lambda function.
+ */
+export declare function validateUncompressedLambdaSize(outputPath: string, uncompressedBytes: number): void;
+/**
+ * Runtimes that support env wrapper.
+ */
+export declare const ENV_WRAPPER_SUPPORTED_FAMILIES: string[];
+interface LambdaLikeForEnvWrapper {
+    createZip?: () => Promise<Buffer>;
+    runtime: string;
+    supportsWrapper?: boolean;
+}
+/**
+ * When the function requires a file for the encrypted environment variables,
+ * it needs to support wrappers. Also, the function must have a `createZip`
+ * function since we need to "re-compress" to include the file in the final
+ * lambda.
+ */
+export declare function validateEnvWrapperSupport(encryptedEnvFilename: string | undefined, encryptedEnvContent: string | undefined, lambda: LambdaLikeForEnvWrapper): void;
+export {};

package/dist/validate-lambda-size.js

@@ -0,0 +1,117 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_lambda_size_exports = {};
+__export(validate_lambda_size_exports, {
+  ENV_WRAPPER_SUPPORTED_FAMILIES: () => ENV_WRAPPER_SUPPORTED_FAMILIES,
+  FunctionSizeError: () => FunctionSizeError,
+  MAX_LAMBDA_SIZE: () => MAX_LAMBDA_SIZE,
+  MAX_LAMBDA_UNCOMPRESSED_SIZE: () => MAX_LAMBDA_UNCOMPRESSED_SIZE,
+  validateEnvWrapperSupport: () => validateEnvWrapperSupport,
+  validateLambdaSize: () => validateLambdaSize,
+  validateUncompressedLambdaSize: () => validateUncompressedLambdaSize
+});
+module.exports = __toCommonJS(validate_lambda_size_exports);
+var import_errors = require("./errors");
+var import_bytes = __toESM(require("bytes"));
+const MAX_LAMBDA_SIZE = (0, import_bytes.default)("300mb");
+const MAX_LAMBDA_UNCOMPRESSED_SIZE = 250 * 1024 * 1024;
+class FunctionSizeError extends import_errors.NowBuildError {
+  constructor(outputPath, size) {
+    super({
+      code: "NOW_SANDBOX_WORKER_MAX_LAMBDA_SIZE",
+      message: `The Vercel Function "${outputPath}" is ${(0, import_bytes.default)(
+        size
+      ).toLowerCase()} which exceeds the maximum size limit of ${(0, import_bytes.default)(
+        MAX_LAMBDA_SIZE
+      ).toLowerCase()}.`,
+      link: "https://vercel.link/serverless-function-size",
+      action: "Learn More"
+    });
+    this.size = size;
+    this.maxSize = MAX_LAMBDA_SIZE;
+  }
+}
+function validateLambdaSize(outputPath, runtime, size) {
+  if (runtime.startsWith("python")) {
+    return;
+  }
+  if (size > MAX_LAMBDA_SIZE) {
+    throw new FunctionSizeError(outputPath, size);
+  }
+}
+function validateUncompressedLambdaSize(outputPath, uncompressedBytes) {
+  if (uncompressedBytes >= MAX_LAMBDA_UNCOMPRESSED_SIZE) {
+    throw new import_errors.NowBuildError({
+      code: "NOW_SANDBOX_WORKER_MAX_UNCOMPRESSED_LAMBDA_SIZE",
+      message: `The Vercel Function "${outputPath}" is ${(0, import_bytes.default)(
+        uncompressedBytes
+      ).toLowerCase()} uncompressed which exceeds the maximum uncompressed size limit of ${(0, import_bytes.default)(
+        MAX_LAMBDA_UNCOMPRESSED_SIZE
+      ).toLowerCase()}.`,
+      link: "https://vercel.link/serverless-function-size",
+      action: "Learn More"
+    });
+  }
+}
+const ENV_WRAPPER_SUPPORTED_FAMILIES = [
+  "nodejs",
+  "python",
+  "ruby",
+  "java",
+  "dotnetcore",
+  "bun",
+  "executable"
+];
+function validateEnvWrapperSupport(encryptedEnvFilename, encryptedEnvContent, lambda) {
+  if (!encryptedEnvFilename || !encryptedEnvContent) {
+    return;
+  }
+  if (!lambda.supportsWrapper && !ENV_WRAPPER_SUPPORTED_FAMILIES.some(
+    (family) => lambda.runtime.startsWith(family)
+  )) {
+    throw new Error(
+      `Serverless Function runtime ${lambda.runtime} does not support more than 4KB for environment variables`
+    );
+  }
+  if (typeof lambda.createZip !== "function") {
+    throw new Error(
+      `Serverless Function with runtime ${lambda.runtime} has no createZip function`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENV_WRAPPER_SUPPORTED_FAMILIES,
+  FunctionSizeError,
+  MAX_LAMBDA_SIZE,
+  MAX_LAMBDA_UNCOMPRESSED_SIZE,
+  validateEnvWrapperSupport,
+  validateLambdaSize,
+  validateUncompressedLambdaSize
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "13.12.1",
+  "version": "13.13.0",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -16,8 +16,10 @@
     "@vercel/python-analysis": "0.11.0"
   },
   "devDependencies": {
+    "bytes": "3.1.2",
     "smol-toml": "1.5.2",
     "@types/async-retry": "^1.2.1",
+    "@types/bytes": "3.1.1",
     "@types/cross-spawn": "6.0.0",
     "@types/end-of-stream": "^1.4.0",
     "@types/fs-extra": "9.0.13",