vercel-cli 41.1.0__py3-none-any.whl → 46.1.1__py3-none-any.whl

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/lambda.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
-import type { Config, Env, Files, FunctionFramework } from './types';
+import type { Config, Env, Files, FunctionFramework, TriggerEvent } from './types';
+export type { TriggerEvent };
 export type LambdaOptions = LambdaOptionsWithFiles | LambdaOptionsWithZipBuffer;
 export type LambdaArchitecture = 'x86_64' | 'arm64';
 export interface LambdaOptionsBase {
@@ -20,6 +21,26 @@ export interface LambdaOptionsBase {
     experimentalResponseStreaming?: boolean;
     operationType?: string;
     framework?: FunctionFramework;
+    /**
+     * Experimental trigger event definitions that this Lambda can receive.
+     * Defines what types of trigger events this Lambda can handle as an HTTP endpoint.
+     * Currently supports queue triggers for Vercel's queue system.
+     *
+     * The delivery configuration provides HINTS to the system about preferred
+     * execution behavior (concurrency, retries) but these are NOT guarantees.
+     * The system may disregard these hints based on resource constraints.
+     *
+     * IMPORTANT: HTTP request-response semantics remain synchronous regardless
+     * of delivery configuration. Callers receive immediate responses.
+     *
+     * @experimental This feature is experimental and may change.
+     */
+    experimentalTriggers?: TriggerEvent[];
+    /**
+     * Whether this Lambda supports cancellation.
+     * When true, the Lambda runtime can be terminated mid-execution if the request is cancelled.
+     */
+    supportsCancellation?: boolean;
 }
 export interface LambdaOptionsWithFiles extends LambdaOptionsBase {
     files: Files;
@@ -49,7 +70,7 @@ export declare class Lambda {
     files?: Files;
     handler: string;
     runtime: string;
-    architecture?: LambdaArchitecture;
+    architecture: LambdaArchitecture;
     memory?: number;
     maxDuration?: number;
     environment: Env;
@@ -64,6 +85,26 @@ export declare class Lambda {
     supportsResponseStreaming?: boolean;
     framework?: FunctionFramework;
     experimentalAllowBundling?: boolean;
+    /**
+     * Experimental trigger event definitions that this Lambda can receive.
+     * Defines what types of trigger events this Lambda can handle as an HTTP endpoint.
+     * Currently supports queue triggers for Vercel's queue system.
+     *
+     * The delivery configuration provides HINTS to the system about preferred
+     * execution behavior (concurrency, retries) but these are NOT guarantees.
+     * The system may disregard these hints based on resource constraints.
+     *
+     * IMPORTANT: HTTP request-response semantics remain synchronous regardless
+     * of delivery configuration. Callers receive immediate responses.
+     *
+     * @experimental This feature is experimental and may change.
+     */
+    experimentalTriggers?: TriggerEvent[];
+    /**
+     * Whether this Lambda supports cancellation.
+     * When true, the Lambda runtime can be terminated mid-execution if the request is cancelled.
+     */
+    supportsCancellation?: boolean;
     constructor(opts: LambdaOptions);
     createZip(): Promise<Buffer>;
     /**
@@ -77,5 +118,4 @@ export declare class Lambda {
  */
 export declare function createLambda(opts: LambdaOptions): Promise<Lambda>;
 export declare function createZip(files: Files): Promise<Buffer>;
-export declare function getLambdaOptionsFromFunction({ sourceFile, config, }: GetLambdaOptionsFromFunctionOptions): Promise<Pick<LambdaOptions, 'memory' | 'maxDuration'>>;
-export {};
+export declare function getLambdaOptionsFromFunction({ sourceFile, config, }: GetLambdaOptionsFromFunctionOptions): Promise<Pick<LambdaOptions, 'architecture' | 'memory' | 'maxDuration' | 'experimentalTriggers' | 'supportsCancellation'>>;

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/lambda.js

@@ -41,6 +41,20 @@ var import_minimatch = __toESM(require("minimatch"));
 var import_fs_extra = require("fs-extra");
 var import_download = require("./fs/download");
 var import_stream_to_buffer = __toESM(require("./fs/stream-to-buffer"));
+function getDefaultLambdaArchitecture(architecture) {
+  if (architecture) {
+    return architecture;
+  }
+  switch (process.arch) {
+    case "arm":
+    case "arm64": {
+      return "arm64";
+    }
+    default: {
+      return "x86_64";
+    }
+  }
+}
 class Lambda {
   constructor(opts) {
     const {
@@ -57,7 +71,9 @@ class Lambda {
       supportsResponseStreaming,
       experimentalResponseStreaming,
       operationType,
-      framework
+      framework,
+      experimentalTriggers,
+      supportsCancellation
     } = opts;
     if ("files" in opts) {
       (0, import_assert.default)(typeof opts.files === "object", '"files" must be an object');
@@ -125,12 +141,79 @@ class Lambda {
         );
       }
     }
+    if (experimentalTriggers !== void 0) {
+      (0, import_assert.default)(
+        Array.isArray(experimentalTriggers),
+        '"experimentalTriggers" is not an Array'
+      );
+      for (let i = 0; i < experimentalTriggers.length; i++) {
+        const trigger = experimentalTriggers[i];
+        const prefix = `"experimentalTriggers[${i}]"`;
+        (0, import_assert.default)(
+          typeof trigger === "object" && trigger !== null,
+          `${prefix} is not an object`
+        );
+        (0, import_assert.default)(
+          trigger.type === "queue/v1beta",
+          `${prefix}.type must be "queue/v1beta"`
+        );
+        (0, import_assert.default)(
+          typeof trigger.topic === "string",
+          `${prefix}.topic is required and must be a string`
+        );
+        (0, import_assert.default)(trigger.topic.length > 0, `${prefix}.topic cannot be empty`);
+        (0, import_assert.default)(
+          typeof trigger.consumer === "string",
+          `${prefix}.consumer is required and must be a string`
+        );
+        (0, import_assert.default)(
+          trigger.consumer.length > 0,
+          `${prefix}.consumer cannot be empty`
+        );
+        if (trigger.maxDeliveries !== void 0) {
+          (0, import_assert.default)(
+            typeof trigger.maxDeliveries === "number",
+            `${prefix}.maxDeliveries must be a number`
+          );
+          (0, import_assert.default)(
+            Number.isInteger(trigger.maxDeliveries) && trigger.maxDeliveries >= 1,
+            `${prefix}.maxDeliveries must be at least 1`
+          );
+        }
+        if (trigger.retryAfterSeconds !== void 0) {
+          (0, import_assert.default)(
+            typeof trigger.retryAfterSeconds === "number",
+            `${prefix}.retryAfterSeconds must be a number`
+          );
+          (0, import_assert.default)(
+            trigger.retryAfterSeconds > 0,
+            `${prefix}.retryAfterSeconds must be a positive number`
+          );
+        }
+        if (trigger.initialDelaySeconds !== void 0) {
+          (0, import_assert.default)(
+            typeof trigger.initialDelaySeconds === "number",
+            `${prefix}.initialDelaySeconds must be a number`
+          );
+          (0, import_assert.default)(
+            trigger.initialDelaySeconds >= 0,
+            `${prefix}.initialDelaySeconds must be a non-negative number`
+          );
+        }
+      }
+    }
+    if (supportsCancellation !== void 0) {
+      (0, import_assert.default)(
+        typeof supportsCancellation === "boolean",
+        '"supportsCancellation" is not a boolean'
+      );
+    }
     this.type = "Lambda";
     this.operationType = operationType;
     this.files = "files" in opts ? opts.files : void 0;
     this.handler = handler;
     this.runtime = runtime;
-    this.architecture = architecture;
+    this.architecture = getDefaultLambdaArchitecture(architecture);
     this.memory = memory;
     this.maxDuration = maxDuration;
     this.environment = environment;
@@ -142,6 +225,8 @@ class Lambda {
     this.supportsResponseStreaming = supportsResponseStreaming ?? experimentalResponseStreaming;
     this.framework = framework;
     this.experimentalAllowBundling = "experimentalAllowBundling" in opts ? opts.experimentalAllowBundling : void 0;
+    this.experimentalTriggers = experimentalTriggers;
+    this.supportsCancellation = supportsCancellation;
   }
   async createZip() {
     let { zipBuffer } = this;
@@ -214,8 +299,11 @@ async function getLambdaOptionsFromFunction({
     for (const [pattern, fn] of Object.entries(config.functions)) {
       if (sourceFile === pattern || (0, import_minimatch.default)(sourceFile, pattern)) {
         return {
+          architecture: fn.architecture,
           memory: fn.memory,
-          maxDuration: fn.maxDuration
+          maxDuration: fn.maxDuration,
+          experimentalTriggers: fn.experimentalTriggers,
+          supportsCancellation: fn.supportsCancellation
         };
       }
     }

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/prerender.d.ts

@@ -2,6 +2,7 @@ import type { File, HasField, Chain } from './types';
 import { Lambda } from './lambda';
 interface PrerenderOptions {
     expiration: number | false;
+    staleExpiration?: number;
     lambda?: Lambda;
     fallback: File | null;
     group?: number;
@@ -18,7 +19,17 @@ interface PrerenderOptions {
 }
 export declare class Prerender {
     type: 'Prerender';
+    /**
+     * `expiration` is `revalidate` in Next.js terms, and `s-maxage` in
+     * `cache-control` terms.
+     */
     expiration: number | false;
+    /**
+     * `staleExpiration` is `expire` in Next.js terms, and
+     * `stale-while-revalidate` + `s-maxage` in `cache-control` terms. It's
+     * expected to be undefined if `expiration` is `false`.
+     */
+    staleExpiration?: number;
     lambda?: Lambda;
     fallback: File | null;
     group?: number;
@@ -32,6 +43,6 @@ export declare class Prerender {
     experimentalBypassFor?: HasField;
     experimentalStreamingLambdaPath?: string;
     chain?: Chain;
-    constructor({ expiration, lambda, fallback, group, bypassToken, allowQuery, allowHeader, initialHeaders, initialStatus, passQuery, sourcePath, experimentalBypassFor, experimentalStreamingLambdaPath, chain, }: PrerenderOptions);
+    constructor({ expiration, staleExpiration, lambda, fallback, group, bypassToken, allowQuery, allowHeader, initialHeaders, initialStatus, passQuery, sourcePath, experimentalBypassFor, experimentalStreamingLambdaPath, chain, }: PrerenderOptions);
 }
 export {};

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/prerender.js

@@ -24,6 +24,7 @@ module.exports = __toCommonJS(prerender_exports);
 class Prerender {
   constructor({
     expiration,
+    staleExpiration,
     lambda,
     fallback,
     group,
@@ -40,6 +41,7 @@ class Prerender {
   }) {
     this.type = "Prerender";
     this.expiration = expiration;
+    this.staleExpiration = staleExpiration;
     this.sourcePath = sourcePath;
     this.lambda = lambda;
     if (this.lambda) {
@@ -74,8 +76,7 @@ class Prerender {
     }
     if (experimentalBypassFor !== void 0) {
       if (!Array.isArray(experimentalBypassFor) || experimentalBypassFor.some(
-        (field) => typeof field !== "object" || // host doesn't need a key
-        field.type !== "host" && typeof field.key !== "string" || typeof field.type !== "string" || field.value !== void 0 && typeof field.value !== "string"
+        (field) => typeof field !== "object" || typeof field.type !== "string" || field.type === "host" && "key" in field || field.type !== "host" && typeof field.key !== "string" || field.value !== void 0 && typeof field.value !== "string" && (typeof field.value !== "object" || field.value === null || Array.isArray(field.value))
       )) {
         throw new Error(
           "The `experimentalBypassFor` argument for `Prerender` must be Array of objects with fields `type`, `key` and optionally `value`."

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/schemas.d.ts

@@ -8,6 +8,10 @@ export declare const functionsSchema: {
             type: string;
             additionalProperties: boolean;
             properties: {
+                architecture: {
+                    type: string;
+                    enum: string[];
+                };
                 runtime: {
                     type: string;
                     maxLength: number;
@@ -29,6 +33,43 @@ export declare const functionsSchema: {
                     type: string;
                     maxLength: number;
                 };
+                experimentalTriggers: {
+                    type: string;
+                    items: {
+                        type: string;
+                        properties: {
+                            type: {
+                                type: string;
+                                const: string;
+                            };
+                            topic: {
+                                type: string;
+                                minLength: number;
+                            };
+                            consumer: {
+                                type: string;
+                                minLength: number;
+                            };
+                            maxDeliveries: {
+                                type: string;
+                                minimum: number;
+                            };
+                            retryAfterSeconds: {
+                                type: string;
+                                exclusiveMinimum: number;
+                            };
+                            initialDelaySeconds: {
+                                type: string;
+                                minimum: number;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                };
+                supportsCancellation: {
+                    type: string;
+                };
             };
         };
     };

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/schemas.js

@@ -22,6 +22,37 @@ __export(schemas_exports, {
   functionsSchema: () => functionsSchema
 });
 module.exports = __toCommonJS(schemas_exports);
+const triggerEventSchema = {
+  type: "object",
+  properties: {
+    type: {
+      type: "string",
+      const: "queue/v1beta"
+    },
+    topic: {
+      type: "string",
+      minLength: 1
+    },
+    consumer: {
+      type: "string",
+      minLength: 1
+    },
+    maxDeliveries: {
+      type: "number",
+      minimum: 1
+    },
+    retryAfterSeconds: {
+      type: "number",
+      exclusiveMinimum: 0
+    },
+    initialDelaySeconds: {
+      type: "number",
+      minimum: 0
+    }
+  },
+  required: ["type", "topic", "consumer"],
+  additionalProperties: false
+};
 const functionsSchema = {
   type: "object",
   minProperties: 1,
@@ -32,13 +63,17 @@ const functionsSchema = {
       type: "object",
       additionalProperties: false,
       properties: {
+        architecture: {
+          type: "string",
+          enum: ["x86_64", "arm64"]
+        },
         runtime: {
           type: "string",
           maxLength: 256
         },
         memory: {
           minimum: 128,
-          maximum: 3009
+          maximum: 10240
         },
         maxDuration: {
           type: "number",
@@ -52,6 +87,13 @@ const functionsSchema = {
         excludeFiles: {
           type: "string",
           maxLength: 256
+        },
+        experimentalTriggers: {
+          type: "array",
+          items: triggerEventSchema
+        },
+        supportsCancellation: {
+          type: "boolean"
         }
       }
     }

vercel_cli/vendor/node_modules/@vercel/build-utils/dist/types.d.ts

@@ -2,10 +2,11 @@
 import type FileRef from './file-ref';
 import type FileFsRef from './file-fs-ref';
 import type FileBlob from './file-blob';
-import type { Lambda } from './lambda';
+import type { Lambda, LambdaArchitecture } from './lambda';
 import type { Prerender } from './prerender';
 import type { EdgeFunction } from './edge-function';
 import type { Span } from './trace';
+import type { HasField } from '@vercel/routing-utils';
 export interface Env {
     [name: string]: string | undefined;
 }
@@ -44,14 +45,7 @@ export interface Config {
     middleware?: boolean;
     [key: string]: unknown;
 }
-export type HasField = Array<{
-    type: 'host';
-    value: string;
-} | {
-    type: 'header' | 'cookie' | 'query';
-    key: string;
-    value?: string;
-}>;
+export type { HasField };
 export interface Meta {
     isDev?: boolean;
     devCacheDir?: string;
@@ -165,6 +159,10 @@ export interface ShouldServeOptions {
      * in `vercel.json`.
      */
     config: Config;
+    /**
+     * Whether another builder has already matched the given request.
+     */
+    hasMatched?: boolean;
 }
 /**
  * `startDevServer()` is given the same parameters as `build()`.
@@ -287,6 +285,7 @@ export interface PackageJson {
     readonly private?: boolean;
     readonly publishConfig?: PackageJson.PublishConfig;
     readonly packageManager?: string;
+    readonly type?: string;
 }
 export interface ConstructorVersion {
     /** major version number: 18 */
@@ -321,11 +320,14 @@ export interface Builder {
 }
 export interface BuilderFunctions {
     [key: string]: {
+        architecture?: LambdaArchitecture;
         memory?: number;
         maxDuration?: number;
         runtime?: string;
         includeFiles?: string;
         excludeFiles?: string;
+        experimentalTriggers?: TriggerEvent[];
+        supportsCancellation?: boolean;
     };
 }
 export interface ProjectSettings {
@@ -500,4 +502,33 @@ export interface Chain {
      */
     headers: Record<string, string>;
 }
-export {};
+/**
+ * Queue trigger event for Vercel's queue system.
+ * Handles "queue/v1beta" events with queue-specific configuration.
+ */
+export interface TriggerEvent {
+    /** Event type - must be "queue/v1beta" (REQUIRED) */
+    type: 'queue/v1beta';
+    /** Name of the queue topic to consume from (REQUIRED) */
+    topic: string;
+    /** Name of the consumer group for this trigger (REQUIRED) */
+    consumer: string;
+    /**
+     * Maximum number of delivery attempts for message processing (OPTIONAL)
+     * This represents the total number of times a message can be delivered,
+     * not the number of retries. Must be at least 1 if specified.
+     * Behavior when not specified depends on the server's default configuration.
+     */
+    maxDeliveries?: number;
+    /**
+     * Delay in seconds before retrying failed executions (OPTIONAL)
+     * Behavior when not specified depends on the server's default configuration.
+     */
+    retryAfterSeconds?: number;
+    /**
+     * Initial delay in seconds before first execution attempt (OPTIONAL)
+     * Must be 0 or greater. Use 0 for no initial delay.
+     * Behavior when not specified depends on the server's default configuration.
+     */
+    initialDelaySeconds?: number;
+}

vercel_cli/vendor/node_modules/@vercel/build-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "9.3.0",
+  "version": "11.0.2",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -27,6 +27,7 @@
     "@types/semver": "6.0.0",
     "@types/yazl": "2.4.2",
     "@vercel/error-utils": "2.0.3",
+    "@vercel/routing-utils": "5.1.1",
     "aggregate-error": "3.0.1",
     "async-retry": "1.2.3",
     "async-sema": "2.1.4",
@@ -54,7 +55,7 @@
     "test": "jest --reporters=default --reporters=jest-junit --env node --verbose --bail --runInBand",
     "vitest-run": "vitest -c ../../vitest.config.mts",
     "vitest-unit": "glob --absolute 'test/unit.*test.ts'",
-    "vitest-e2e": "glob --absolute 'test/integration-*.test.ts'",
+    "vitest-e2e": "glob --absolute 'test/integration*.test.ts'",
     "type-check": "tsc --noEmit"
   }
 }