@vercel/build-utils 13.8.2 → 13.11.0

package/dist/process-serverless/get-encrypted-env-file.d.ts

@@ -0,0 +1,11 @@
+import FileBlob from '../file-blob';
+/**
+ * A type to represent the encrypted environment file that needs to be
+ * attached to Lambdas with ENV > 4kb
+ */
+export type EncryptedEnvFile = [string, FileBlob];
+/**
+ * Get the encrypted environment file from the environment variables if it
+ * exists and it is supported by the runtime.
+ */
+export declare function getEncryptedEnv(envFilename: string | undefined, envContent: string | undefined): EncryptedEnvFile | undefined;

package/dist/process-serverless/get-encrypted-env-file.js

@@ -0,0 +1,47 @@
+"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 get_encrypted_env_file_exports = {};
+__export(get_encrypted_env_file_exports, {
+  getEncryptedEnv: () => getEncryptedEnv
+});
+module.exports = __toCommonJS(get_encrypted_env_file_exports);
+var import_file_blob = __toESM(require("../file-blob"));
+function getEncryptedEnv(envFilename, envContent) {
+  if (!envFilename || !envContent) {
+    return;
+  }
+  return [
+    envFilename,
+    new import_file_blob.default({ data: Buffer.from(envContent, "base64") })
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEncryptedEnv
+});

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { type BytecodeCachingOptions } from './get-lambda-preload-scripts';
+interface LambdaLike {
+    awsLambdaHandler?: string;
+    launcherType?: string;
+    runtime: string;
+    shouldAddHelpers?: boolean;
+    shouldAddSourcemapSupport?: boolean;
+    useWebApi?: boolean;
+    shouldDisableAutomaticFetchInstrumentation?: boolean;
+}
+/**
+ * Extract system environment variables that need to be injected in the Lambda.
+ * 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 {};

package/dist/process-serverless/get-lambda-environment.js

@@ -0,0 +1,53 @@
+"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 get_lambda_environment_exports = {};
+__export(get_lambda_environment_exports, {
+  getLambdaEnvironment: () => getLambdaEnvironment
+});
+module.exports = __toCommonJS(get_lambda_environment_exports);
+var import_get_lambda_preload_scripts = require("./get-lambda-preload-scripts");
+function getLambdaEnvironment(lambda, buffer, options) {
+  const environment = {};
+  if ("launcherType" in lambda && lambda.launcherType === "Nodejs") {
+    if (lambda.awsLambdaHandler) {
+      environment.AWS_LAMBDA_HANDLER = lambda.awsLambdaHandler;
+    }
+    if (lambda.shouldAddHelpers) {
+      environment.VERCEL_SHOULD_ADD_HELPERS = "1";
+    }
+    if (lambda.useWebApi === true) {
+      environment.VERCEL_USE_WEB_API = "1";
+    }
+    if (lambda.shouldAddSourcemapSupport) {
+      environment.VERCEL_SOURCE_MAP = "1";
+    }
+    if (lambda.shouldDisableAutomaticFetchInstrumentation) {
+      environment.VERCEL_TRACING_DISABLE_AUTOMATIC_FETCH_INSTRUMENTATION = "1";
+    }
+    const scripts = (0, import_get_lambda_preload_scripts.getLambdaPreloadScripts)(lambda, buffer, options);
+    if (scripts.length > 0) {
+      environment.VERCEL_NODE_PRELOAD_SCRIPTS = scripts.join(",");
+    }
+  }
+  return environment;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLambdaEnvironment
+});

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

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+export interface BytecodeCachingOptions {
+    vercelEnv: string | undefined;
+    useBytecodeCaching: string | undefined;
+    useNativeBytecodeCaching: string | undefined;
+    bytecodeCachingThreshold: string | undefined;
+}
+interface LambdaLike {
+    framework?: {
+        slug: string;
+    };
+    runtime: string;
+    shouldAddSourcemapSupport?: boolean;
+}
+/**
+ * Returns an array of scripts that should be preloaded in Node.js Lambdas.
+ * 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 {};

package/dist/process-serverless/get-lambda-preload-scripts.js

@@ -0,0 +1,43 @@
+"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 get_lambda_preload_scripts_exports = {};
+__export(get_lambda_preload_scripts_exports, {
+  getLambdaPreloadScripts: () => getLambdaPreloadScripts
+});
+module.exports = __toCommonJS(get_lambda_preload_scripts_exports);
+function getLambdaPreloadScripts(lambda, buffer, options) {
+  const scripts = [];
+  if (lambda.shouldAddSourcemapSupport) {
+    scripts.push("/opt/rust/source-map-support.js");
+  }
+  const BYTECODE_MIN_SIZE_BYTES = (Number.parseInt(options.bytecodeCachingThreshold || "", 10) || 400) * 1024;
+  if (options.vercelEnv === "production" && options.useBytecodeCaching === "1" && ["nodejs20.x", "nodejs22.x", "nodejs24.x"].includes(lambda.runtime) && buffer.byteLength >= BYTECODE_MIN_SIZE_BYTES) {
+    scripts.push(
+      ["nodejs22.x", "nodejs24.x"].includes(lambda.runtime) && options.useNativeBytecodeCaching === "1" ? "/opt/rust/bytecode-native.js" : "/opt/rust/bytecode.js"
+    );
+  }
+  if (lambda.framework?.slug === "nextjs") {
+    scripts.push("/opt/rust/next-data.js");
+  }
+  return scripts;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLambdaPreloadScripts
+});

package/dist/process-serverless/get-lambda-supports-streaming.d.ts

@@ -0,0 +1,23 @@
+import type { Files } from '../types';
+interface LambdaLike {
+    files?: Files;
+    handler: string;
+    launcherType?: string;
+    runtime: string;
+    supportsResponseStreaming?: boolean;
+}
+export interface SupportsStreamingResult {
+    supportsStreaming: boolean | undefined;
+    error?: {
+        handler: string;
+        message: string;
+    };
+}
+/**
+ * Determines if a Lambda should have streaming enabled. If
+ * `forceStreamingRuntime` is true, streaming is always enabled. If the
+ * setting is defined it will be honored. For Node.js it checks the handler
+ * exports which is why it needs to be asynchronous.
+ */
+export declare function getLambdaSupportsStreaming(lambda: LambdaLike, forceStreamingRuntime: boolean): Promise<SupportsStreamingResult>;
+export {};

package/dist/process-serverless/get-lambda-supports-streaming.js

@@ -0,0 +1,98 @@
+"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 get_lambda_supports_streaming_exports = {};
+__export(get_lambda_supports_streaming_exports, {
+  getLambdaSupportsStreaming: () => getLambdaSupportsStreaming
+});
+module.exports = __toCommonJS(get_lambda_supports_streaming_exports);
+var import_cjs_module_lexer = require("cjs-module-lexer");
+var import_es_module_lexer = require("es-module-lexer");
+async function getLambdaSupportsStreaming(lambda, forceStreamingRuntime) {
+  if (forceStreamingRuntime) {
+    return { supportsStreaming: true };
+  }
+  if (typeof lambda.supportsResponseStreaming === "boolean") {
+    return { supportsStreaming: lambda.supportsResponseStreaming };
+  }
+  if ("launcherType" in lambda && lambda.launcherType === "Nodejs") {
+    return lambdaShouldStream(lambda);
+  }
+  return { supportsStreaming: void 0 };
+}
+const HTTP_METHODS = [
+  "GET",
+  "HEAD",
+  "OPTIONS",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH"
+];
+async function lambdaShouldStream(lambda) {
+  const stream = lambda.files?.[lambda.handler]?.toStream();
+  if (!stream) {
+    return { supportsStreaming: void 0 };
+  }
+  try {
+    const buffer = await streamToBuffer(stream);
+    const names = await getFileExports(lambda.handler, buffer.toString("utf8"));
+    for (const name of names) {
+      if (HTTP_METHODS.includes(name)) {
+        return { supportsStreaming: true };
+      }
+    }
+  } catch (err) {
+    return {
+      supportsStreaming: void 0,
+      error: { handler: lambda.handler, message: String(err) }
+    };
+  }
+  return { supportsStreaming: void 0 };
+}
+async function getFileExports(filename, content) {
+  if (filename.endsWith(".mjs")) {
+    await import_es_module_lexer.init;
+    return (0, import_es_module_lexer.parse)(content)[1].map((specifier) => specifier.n);
+  }
+  try {
+    await (0, import_cjs_module_lexer.init)();
+    return (0, import_cjs_module_lexer.parse)(content).exports;
+  } catch {
+    await import_es_module_lexer.init;
+    return (0, import_es_module_lexer.parse)(content)[1].map((specifier) => specifier.n);
+  }
+}
+function streamToBuffer(stream) {
+  return new Promise((resolve, reject) => {
+    const buffers = [];
+    stream.on("error", (err) => {
+      reject(err);
+    });
+    stream.on("data", (buffer) => {
+      buffers.push(buffer);
+    });
+    stream.on("end", () => {
+      resolve(Buffer.concat(buffers));
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLambdaSupportsStreaming
+});

package/dist/python.js

@@ -40,7 +40,7 @@ async function isPythonEntrypoint(file) {
     if (!fsPath)
       return false;
     const content = await import_fs.default.promises.readFile(fsPath, "utf-8");
-    return await (0, import_python_analysis.containsAppOrHandler)(content);
+    return await (0, import_python_analysis.findAppOrHandler)(content) !== null;
   } catch (err) {
     (0, import_debug.default)(`Failed to check Python entrypoint: ${err}`);
     return false;

package/dist/schemas.d.ts

@@ -121,3 +121,83 @@ export declare const buildsSchema: {
         };
     };
 };
+/**
+ * JSON Schema for builder-produced `package-manifest.json` files.
+ *
+ * Each builder (e.g. @vercel/python) may emit a `package-manifest.json`
+ * in its diagnostics output.
+ */
+export declare const packageManifestSchema: {
+    readonly type: "object";
+    readonly required: readonly ["runtime", "dependencies"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+            readonly description: "Manifest schema version, e.g. \"20260304\".";
+        };
+        readonly runtime: {
+            readonly type: "string";
+            readonly description: "Runtime identifier, e.g. \"python\", \"node\".";
+        };
+        readonly runtimeVersion: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["resolved"];
+            readonly properties: {
+                readonly requested: {
+                    readonly type: "string";
+                    readonly description: "Version constraint from the project manifest, e.g. \">=3.10\".";
+                };
+                readonly requestedSource: {
+                    readonly type: "string";
+                    readonly description: "File that declared the constraint, e.g. \"pyproject.toml\".";
+                };
+                readonly resolved: {
+                    readonly type: "string";
+                    readonly description: "Actual resolved version, e.g. \"3.12\".";
+                };
+            };
+        };
+        readonly dependencies: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["name", "type", "scopes", "resolved"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                    };
+                    readonly type: {
+                        readonly type: "string";
+                        readonly enum: readonly ["direct", "transitive", "peer"];
+                    };
+                    readonly scopes: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Dependency groups this package belongs to, e.g. [\"main\", \"dev\"].";
+                    };
+                    readonly requested: {
+                        readonly type: "string";
+                        readonly description: "Version specifier as declared, e.g. \"flask>=2.0\".";
+                    };
+                    readonly resolved: {
+                        readonly type: "string";
+                        readonly description: "Resolved version, e.g. \"3.1.0\".";
+                    };
+                    readonly source: {
+                        readonly type: "string";
+                        readonly description: "Package source type, e.g. \"registry\", \"git\", \"path\".";
+                    };
+                    readonly sourceUrl: {
+                        readonly type: "string";
+                        readonly description: "Source URL, e.g. \"https://pypi.org\".";
+                    };
+                };
+            };
+        };
+    };
+};

package/dist/schemas.js

@@ -19,7 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var schemas_exports = {};
 __export(schemas_exports, {
   buildsSchema: () => buildsSchema,
-  functionsSchema: () => functionsSchema
+  functionsSchema: () => functionsSchema,
+  packageManifestSchema: () => packageManifestSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 const triggerEventSchemaV1 = {
@@ -173,8 +174,76 @@ const buildsSchema = {
     }
   }
 };
+const packageManifestSchema = {
+  type: "object",
+  required: ["runtime", "dependencies"],
+  additionalProperties: false,
+  properties: {
+    version: {
+      type: "string",
+      description: 'Manifest schema version, e.g. "20260304".'
+    },
+    runtime: {
+      type: "string",
+      description: 'Runtime identifier, e.g. "python", "node".'
+    },
+    runtimeVersion: {
+      type: "object",
+      additionalProperties: false,
+      required: ["resolved"],
+      properties: {
+        requested: {
+          type: "string",
+          description: 'Version constraint from the project manifest, e.g. ">=3.10".'
+        },
+        requestedSource: {
+          type: "string",
+          description: 'File that declared the constraint, e.g. "pyproject.toml".'
+        },
+        resolved: {
+          type: "string",
+          description: 'Actual resolved version, e.g. "3.12".'
+        }
+      }
+    },
+    dependencies: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["name", "type", "scopes", "resolved"],
+        additionalProperties: false,
+        properties: {
+          name: { type: "string" },
+          type: { type: "string", enum: ["direct", "transitive", "peer"] },
+          scopes: {
+            type: "array",
+            items: { type: "string" },
+            description: 'Dependency groups this package belongs to, e.g. ["main", "dev"].'
+          },
+          requested: {
+            type: "string",
+            description: 'Version specifier as declared, e.g. "flask>=2.0".'
+          },
+          resolved: {
+            type: "string",
+            description: 'Resolved version, e.g. "3.1.0".'
+          },
+          source: {
+            type: "string",
+            description: 'Package source type, e.g. "registry", "git", "path".'
+          },
+          sourceUrl: {
+            type: "string",
+            description: 'Source URL, e.g. "https://pypi.org".'
+          }
+        }
+      }
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildsSchema,
-  functionsSchema
+  functionsSchema,
+  packageManifestSchema
 });

package/dist/types.d.ts

@@ -110,6 +110,8 @@ export interface BuildOptions {
     service?: {
         /** The service name as declared in the project configuration. */
         name?: string;
+        /** The service type (e.g., "web", "cron", "worker"). */
+        type?: ServiceType;
         /** URL path prefix where the service is mounted (e.g., "/api"). */
         routePrefix?: string;
         /** Optional subdomain this service is mounted on (e.g., "api"). */
@@ -384,6 +386,14 @@ export interface ProjectSettings {
     gitForkProtection?: boolean;
     commandForIgnoringBuildStep?: string | null;
 }
+export interface BuilderVX {
+    version: -1;
+    build: BuildVX;
+    diagnostics?: Diagnostics;
+    prepareCache?: PrepareCache;
+    shouldServe?: ShouldServe;
+    startDevServer?: StartDevServer;
+}
 export interface BuilderV2 {
     version: 2;
     build: BuildV2;
@@ -491,9 +501,17 @@ export interface Service {
     subdomain?: string;
     schedule?: string;
     handlerFunction?: string;
-    topic?: string;
+    topics?: string[];
     consumer?: string;
+    /** custom prefix to inject service URL env vars */
+    envPrefix?: string;
 }
+/**
+ * Returns the topics a worker service subscribes to, defaulting to ['default'].
+ */
+export declare function getWorkerTopics(config: {
+    topics?: string[];
+}): [string, ...string[]];
 /** The framework which created the function */
 export interface FunctionFramework {
     slug: string;
@@ -528,11 +546,19 @@ export interface BuildResultV2Typical {
      */
     deploymentId?: string;
 }
+export type BuildResultVX = {
+    resultVersion: 2;
+    result: BuildResultV2;
+} | {
+    resultVersion: 3;
+    result: BuildResultV3;
+};
 export type BuildResultV2 = BuildResultV2Typical | BuildResultBuildOutput;
 export interface BuildResultV3 {
     routes?: any[];
     output: Lambda | EdgeFunction;
 }
+export type BuildVX = (options: BuildOptions) => Promise<BuildResultVX>;
 export type BuildV2 = (options: BuildOptions) => Promise<BuildResultV2>;
 export type BuildV3 = (options: BuildOptions) => Promise<BuildResultV3>;
 export type PrepareCache = (options: PrepareCacheOptions) => Promise<Files>;
@@ -664,8 +690,10 @@ export interface ExperimentalServiceConfig {
     subdomain?: string;
     /** Cron schedule expression (e.g., "0 0 * * *") */
     schedule?: string;
-    topic?: string;
+    topics?: string[];
     consumer?: string;
+    /** Custom prefix to use to inject service URL env vars */
+    envPrefix?: string;
 }
 /**
  * Map of service name to service configuration.

package/dist/types.js

@@ -20,7 +20,8 @@ var types_exports = {};
 __export(types_exports, {
   BunVersion: () => BunVersion,
   NodeVersion: () => NodeVersion,
-  Version: () => Version
+  Version: () => Version,
+  getWorkerTopics: () => getWorkerTopics
 });
 module.exports = __toCommonJS(types_exports);
 class Version {
@@ -47,9 +48,13 @@ class NodeVersion extends Version {
 }
 class BunVersion extends Version {
 }
+function getWorkerTopics(config) {
+  return config.topics?.length ? config.topics : ["default"];
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BunVersion,
   NodeVersion,
-  Version
+  Version,
+  getWorkerTopics
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "13.8.2",
+  "version": "13.11.0",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -11,7 +11,9 @@
     "directory": "packages/now-build-utils"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.10.1"
+    "cjs-module-lexer": "1.2.3",
+    "es-module-lexer": "1.5.0",
+    "@vercel/python-analysis": "0.11.0"
   },
   "devDependencies": {
     "@iarna/toml": "2.2.3",
@@ -50,7 +52,7 @@
     "yazl": "2.5.1",
     "vitest": "2.0.1",
     "json5": "2.2.3",
-    "@vercel/routing-utils": "6.0.2",
+    "@vercel/routing-utils": "6.1.1",
     "@vercel/error-utils": "2.0.3"
   },
   "scripts": {