@vercel/build-utils 13.12.0 → 13.12.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @vercel/build-utils
 
+## 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
+
+- Switch to using smol-toml for toml parsing ([#15730](https://github.com/vercel/vercel/pull/15730))
+
 ## 13.12.0
 
 ### Minor 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,43 @@
+/// <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>) => Promise<T>;
+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;
+}
+export interface FinalizeLambdaResult {
+    buffer: Buffer;
+    digest: string;
+    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 buffer
+ * 4. Computes SHA-256 digest
+ * 5. Merges environment variables (bytecode caching, helpers, etc.)
+ * 6. 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,82 @@
+"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
+  } = 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 buffer = lambda.zipBuffer || await trace("createZip", () => lambda.createZip());
+  const digest = (0, import_stream_to_digest_async.sha256)(buffer);
+  lambda.environment = {
+    ...lambda.environment,
+    ...(0, import_get_lambda_environment.getLambdaEnvironment)(lambda, buffer, bytecodeCachingOptions)
+  };
+  const streamingResult = await (0, import_get_lambda_supports_streaming.getLambdaSupportsStreaming)(
+    lambda,
+    forceStreamingRuntime
+  );
+  lambda.supportsResponseStreaming = streamingResult.supportsStreaming;
+  return {
+    buffer,
+    digest,
+    uncompressedBytes,
+    streamingError: streamingResult.error
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  finalizeLambda
+});

package/dist/fs/read-config-file.js

@@ -33,7 +33,7 @@ __export(read_config_file_exports, {
 });
 module.exports = __toCommonJS(read_config_file_exports);
 var import_js_yaml = __toESM(require("js-yaml"));
-var import_toml = __toESM(require("@iarna/toml"));
+var import_smol_toml = require("smol-toml");
 var import_fs_extra = require("fs-extra");
 var import_error_utils = require("@vercel/error-utils");
 var import_path = require("path");
@@ -61,7 +61,7 @@ async function readConfigFile(files) {
         if (name.endsWith(".json")) {
           return JSON.parse(str);
         } else if (name.endsWith(".toml")) {
-          return import_toml.default.parse(str);
+          return (0, import_smol_toml.parse)(str);
         } else if (name.endsWith(".yaml") || name.endsWith(".yml")) {
           return import_js_yaml.default.safeLoad(str, { filename: name });
         }

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 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';