@vercel/build-utils 14.10.0 → 14.10.1

package/dist/lambda.js

@@ -36,6 +36,7 @@ __export(lambda_exports, {
 });
 module.exports = __toCommonJS(lambda_exports);
 var import_assert = __toESM(require("assert"));
+var import_max_concurrency = require("./max-concurrency");
 var import_async_sema = __toESM(require("async-sema"));
 var import_yazl = require("yazl");
 var import_minimatch = __toESM(require("minimatch"));
@@ -140,12 +141,7 @@ class Lambda {
         '"affinity" must be an object with only `mode: "strict"`'
       );
     }
-    if (maxConcurrency !== void 0) {
-      (0, import_assert.default)(
-        Number.isInteger(maxConcurrency) && maxConcurrency >= 1,
-        '"maxConcurrency" must be an integer greater than or equal to 1'
-      );
-    }
+    (0, import_max_concurrency.validateMaxConcurrency)(maxConcurrency);
     if (allowQuery !== void 0) {
       (0, import_assert.default)(Array.isArray(allowQuery), '"allowQuery" is not an Array');
       (0, import_assert.default)(

package/dist/max-concurrency.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_CONCURRENCY = 8192;
+export declare function validateMaxConcurrency(value: number | undefined): void;

package/dist/max-concurrency.js

@@ -0,0 +1,49 @@
+"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 max_concurrency_exports = {};
+__export(max_concurrency_exports, {
+  MAX_CONCURRENCY: () => MAX_CONCURRENCY,
+  validateMaxConcurrency: () => validateMaxConcurrency
+});
+module.exports = __toCommonJS(max_concurrency_exports);
+var import_assert = __toESM(require("assert"));
+const MAX_CONCURRENCY = 8192;
+function validateMaxConcurrency(value) {
+  if (value !== void 0) {
+    (0, import_assert.default)(
+      Number.isInteger(value) && value >= 1 && value <= MAX_CONCURRENCY,
+      '"maxConcurrency" must be an integer from 1 to 8192'
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_CONCURRENCY,
+  validateMaxConcurrency
+});

package/dist/schemas.d.ts

@@ -45,6 +45,7 @@ export declare const getFunctionsSchema: () => {
                 maxConcurrency: {
                     type: string;
                     minimum: number;
+                    maximum: number;
                 };
                 regions: {
                     type: string;
@@ -142,6 +143,7 @@ export declare const functionsSchema: {
                 maxConcurrency: {
                     type: string;
                     minimum: number;
+                    maximum: number;
                 };
                 regions: {
                     type: string;

package/dist/schemas.js

@@ -25,6 +25,7 @@ __export(schemas_exports, {
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_max_duration = require("./max-duration");
+var import_max_concurrency = require("./max-concurrency");
 const triggerEventSchemaV1 = {
   type: "object",
   properties: {
@@ -145,7 +146,8 @@ const getFunctionsSchema = () => ({
         },
         maxConcurrency: {
           type: "integer",
-          minimum: 1
+          minimum: 1,
+          maximum: import_max_concurrency.MAX_CONCURRENCY
         },
         regions: {
           type: "array",

package/dist/types.d.ts

@@ -50,6 +50,8 @@ export interface Config {
     middlewareMatcher?: string | string[];
     /** Owning service name; scopes per-function config such as the v2beta consumer. */
     serviceName?: string;
+    /** Buildpack runtime slug (e.g. "ruby"). */
+    buildpack?: string;
     [key: string]: unknown;
 }
 export type { HasField };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "14.10.0",
+  "version": "14.10.1",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -52,8 +52,8 @@
     "vitest": "4.1.10",
     "typescript": "4.9.5",
     "yazl": "2.5.1",
-    "@vercel/error-utils": "2.2.1",
-    "@vercel/routing-utils": "6.5.0"
+    "@vercel/routing-utils": "6.6.0",
+    "@vercel/error-utils": "2.2.1"
   },
   "scripts": {
     "build": "node build.mjs",