@vercel/build-utils 13.12.2 → 13.14.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @vercel/build-utils
 
+## 13.14.0
+
+### Minor Changes
+
+- Support configuration via vercel.toml ([#15750](https://github.com/vercel/vercel/pull/15750))
+
+## 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

package/dist/finalize-lambda.d.ts

@@ -7,7 +7,26 @@ import type { SupportsStreamingResult } from './process-serverless/get-lambda-su
  * 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>) => Promise<T>;
+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;
@@ -18,10 +37,28 @@ export interface FinalizeLambdaParams {
     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 {
-    buffer: Buffer;
+    /** 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'];
@@ -32,10 +69,11 @@ export interface FinalizeLambdaResult {
  * This function:
  * 1. Injects encrypted env file into lambda.files when provided
  * 2. Collects uncompressed size when enabled
- * 3. Creates the ZIP buffer
- * 4. Computes SHA-256 digest
- * 5. Merges environment variables (bytecode caching, helpers, etc.)
- * 6. Detects streaming support
+ * 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).

package/dist/finalize-lambda.js

@@ -35,7 +35,9 @@ async function finalizeLambda(params) {
     bytecodeCachingOptions,
     forceStreamingRuntime,
     enableUncompressedLambdaSizeCheck,
-    trace = defaultTrace
+    trace = defaultTrace,
+    createZip: createZipOverride,
+    validateZip
   } = params;
   const encryptedEnv = (0, import_get_encrypted_env_file.getEncryptedEnv)(
     encryptedEnvFilename,
@@ -58,11 +60,43 @@ async function finalizeLambda(params) {
       );
     }
   }
-  const buffer = lambda.zipBuffer || await trace("createZip", () => lambda.createZip());
-  const digest = (0, import_stream_to_digest_async.sha256)(buffer);
+  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, buffer, bytecodeCachingOptions)
+    ...(0, import_get_lambda_environment.getLambdaEnvironment)(
+      lambda,
+      zipResult.buffer ?? { byteLength: zipResult.size },
+      bytecodeCachingOptions
+    )
   };
   const streamingResult = await (0, import_get_lambda_supports_streaming.getLambdaSupportsStreaming)(
     lambda,
@@ -70,8 +104,10 @@ async function finalizeLambda(params) {
   );
   lambda.supportsResponseStreaming = streamingResult.supportsStreaming;
   return {
-    buffer,
-    digest,
+    buffer: zipResult.buffer,
+    zipPath: zipResult.zipPath,
+    digest: zipResult.digest,
+    size: zipResult.size,
     uncompressedBytes,
     streamingError: streamingResult.error
   };

package/dist/get-ignore-filter.js

@@ -83,7 +83,7 @@ async function get_ignore_filter_default(downloadPath, rootDirectory) {
   }
   const ignoreFilter = (0, import_ignore.default)().add(clearRelative(ignoreContents[0]));
   return function(p) {
-    if (p === "now.json" || p === "vercel.json")
+    if (p === "now.json" || p === "vercel.json" || p === "vercel.toml")
       return false;
     return ignoreFilter.test(p).ignored;
   };

package/dist/index.d.ts

@@ -47,5 +47,5 @@ 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 FinalizeLambdaParams, type FinalizeLambdaResult, type TraceFn, } from './finalize-lambda';
+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

@@ -23233,7 +23233,7 @@ async function get_ignore_filter_default(downloadPath, rootDirectory) {
   }
   const ignoreFilter = (0, import_ignore.default)().add(clearRelative(ignoreContents[0]));
   return function(p) {
-    if (p === "now.json" || p === "vercel.json")
+    if (p === "now.json" || p === "vercel.json" || p === "vercel.toml")
       return false;
     return ignoreFilter.test(p).ignored;
   };
@@ -24486,7 +24486,9 @@ async function finalizeLambda(params) {
     bytecodeCachingOptions,
     forceStreamingRuntime,
     enableUncompressedLambdaSizeCheck,
-    trace = defaultTrace
+    trace = defaultTrace,
+    createZip: createZipOverride,
+    validateZip
   } = params;
   const encryptedEnv = getEncryptedEnv(
     encryptedEnvFilename,
@@ -24509,11 +24511,43 @@ async function finalizeLambda(params) {
       );
     }
   }
-  const buffer = lambda.zipBuffer || await trace("createZip", () => lambda.createZip());
-  const digest = sha256(buffer);
+  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, buffer, bytecodeCachingOptions)
+    ...getLambdaEnvironment(
+      lambda,
+      zipResult.buffer ?? { byteLength: zipResult.size },
+      bytecodeCachingOptions
+    )
   };
   const streamingResult = await getLambdaSupportsStreaming(
     lambda,
@@ -24521,8 +24555,10 @@ async function finalizeLambda(params) {
   );
   lambda.supportsResponseStreaming = streamingResult.supportsStreaming;
   return {
-    buffer,
-    digest,
+    buffer: zipResult.buffer,
+    zipPath: zipResult.zipPath,
+    digest: zipResult.digest,
+    size: zipResult.size,
     uncompressedBytes,
     streamingError: streamingResult.error
   };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "13.12.2",
+  "version": "13.14.0",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",