@vercel/client 17.3.0-canary.20260211174907.cdd2da6 → 17.3.0

package/dist/check-deployment-status.js

@@ -85,7 +85,7 @@ async function* checkDeploymentStatus(deployment, clientOptions) {
     let deploymentResponse;
     let retriesLeft = RETRY_COUNT;
     while (true) {
-      deploymentResponse = await (0, import_utils.fetch)(
+      deploymentResponse = await (0, import_utils.fetchApi)(
         `${apiDeployments}/${deployment.id || deployment.deploymentId}${teamId ? `?teamId=${teamId}` : ""}`,
         token,
         { apiUrl, userAgent, agent: clientOptions.agent }
@@ -156,6 +156,14 @@ async function* checkDeploymentStatus(deployment, clientOptions) {
         yield { type: "checks-running", payload: deploymentUpdate };
       }
     }
+    if (deploymentUpdate.checks?.["deployment-alias"]?.state === "failed" && !finishedEvents.has("checks-v2-failed")) {
+      debug("v2 deployment-alias check failed");
+      finishedEvents.add("checks-v2-failed");
+      return yield {
+        type: "checks-v2-failed",
+        payload: deploymentUpdate
+      };
+    }
     if ((0, import_ready_state.isAliasAssigned)(deploymentUpdate)) {
       debug("Deployment alias assigned");
       return yield { type: "alias-assigned", payload: deploymentUpdate };

package/dist/continue.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import type { Agent } from 'http';
+import type { ArchiveFormat, DeploymentEventType } from './types';
+/**
+ * Continues a manual deployment by uploading build outputs and calling the
+ * continue endpoint. Waits for READY state unless the caller stops consuming
+ * events early.
+ */
+export declare function continueDeployment(options: {
+    agent?: Agent;
+    apiUrl?: string;
+    debug?: boolean;
+    deploymentId: string;
+    path: string;
+    teamId?: string;
+    token: string;
+    userAgent?: string;
+    vercelOutputDir?: string;
+    archive?: ArchiveFormat;
+}): AsyncIterableIterator<{
+    type: DeploymentEventType;
+    payload: any;
+}>;

package/dist/continue.js

@@ -0,0 +1,224 @@
+"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 continue_exports = {};
+__export(continue_exports, {
+  continueDeployment: () => continueDeployment
+});
+module.exports = __toCommonJS(continue_exports);
+var import_path = require("path");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_check_deployment_status = require("./check-deployment-status");
+var import_utils = require("./utils");
+var import_hashes = require("./utils/hashes");
+var import_ready_state = require("./utils/ready-state");
+var import_upload = require("./upload");
+var import_errors = require("./errors");
+var import_archive = require("./utils/archive");
+async function* continueDeployment(options) {
+  const debug = (0, import_utils.createDebug)(options.debug);
+  debug(`Continuing deployment: ${options.deploymentId}`);
+  const outputDir = options.vercelOutputDir || (0, import_path.join)(options.path, ".vercel", "output");
+  if (!await import_fs_extra.default.pathExists(outputDir)) {
+    return yield {
+      type: "error",
+      payload: new import_errors.DeploymentError({
+        code: "output_dir_not_found",
+        message: `Output directory not found at ${outputDir}. Run 'vercel build' first.`
+      })
+    };
+  }
+  const { fileList } = await (0, import_utils.buildFileTree)(
+    options.path,
+    { isDirectory: true, prebuilt: true, vercelOutputDir: outputDir },
+    debug
+  );
+  const provisionJsonPath = (0, import_path.join)(outputDir, "provision.json");
+  const unbundledFiles = fileList.filter((f) => f === provisionJsonPath);
+  let files;
+  if (options.archive === "tgz") {
+    files = await (0, import_archive.createTgzFiles)(options.path, fileList, debug, unbundledFiles);
+    if (unbundledFiles.length > 0) {
+      const individualFiles = await (0, import_hashes.hashes)(unbundledFiles);
+      for (const [sha, entry] of individualFiles) {
+        files.set(sha, entry);
+      }
+    }
+  } else {
+    files = await (0, import_hashes.hashes)(fileList);
+  }
+  debug(`Calculated ${files.size} unique hashes`);
+  yield { type: "hashes-calculated", payload: (0, import_hashes.mapToObject)(files) };
+  let deployment;
+  let result = await postContinue({
+    deploymentId: options.deploymentId,
+    files,
+    outputDir,
+    path: options.path,
+    token: options.token,
+    teamId: options.teamId,
+    apiUrl: options.apiUrl,
+    userAgent: options.userAgent,
+    agent: options.agent,
+    debug: options.debug
+  });
+  if (result.type === "missing_files") {
+    debug(`Uploading ${result.missing.length} missing files...`);
+    const uploads = result.missing.map(
+      (sha) => new import_upload.UploadProgress(sha, files.get(sha))
+    );
+    yield {
+      type: "file-count",
+      payload: { total: files, missing: result.missing, uploads }
+    };
+    for await (const event of (0, import_upload.uploadFiles)({
+      agent: options.agent,
+      apiUrl: options.apiUrl,
+      debug: options.debug,
+      teamId: options.teamId,
+      token: options.token,
+      userAgent: options.userAgent,
+      shas: result.missing,
+      files,
+      uploads
+    })) {
+      if (event.type === "error") {
+        return yield event;
+      }
+      yield event;
+    }
+    yield { type: "all-files-uploaded", payload: files };
+    result = await postContinue({
+      deploymentId: options.deploymentId,
+      files,
+      outputDir,
+      path: options.path,
+      token: options.token,
+      teamId: options.teamId,
+      apiUrl: options.apiUrl,
+      userAgent: options.userAgent,
+      agent: options.agent,
+      debug: options.debug
+    });
+    if (result.type === "missing_files") {
+      return yield {
+        type: "error",
+        payload: {
+          code: "missing_files",
+          message: "Missing files",
+          missing: result.missing
+        }
+      };
+    }
+  }
+  if (result.type === "error") {
+    return yield { type: "error", payload: result.error };
+  }
+  if (result.type === "success") {
+    deployment = result.deployment;
+    yield { type: "created", payload: deployment };
+  }
+  if (!deployment) {
+    return yield {
+      type: "error",
+      payload: new import_errors.DeploymentError({
+        code: "continue_failed",
+        message: "Failed to continue deployment after uploading files"
+      })
+    };
+  }
+  if ((0, import_ready_state.isReady)(deployment) && (0, import_ready_state.isAliasAssigned)(deployment)) {
+    yield { type: "ready", payload: deployment };
+    return yield { type: "alias-assigned", payload: deployment };
+  }
+  yield* (0, import_check_deployment_status.checkDeploymentStatus)(deployment, {
+    agent: options.agent,
+    apiUrl: options.apiUrl,
+    debug: options.debug,
+    path: options.path,
+    teamId: options.teamId,
+    token: options.token,
+    userAgent: options.userAgent
+  });
+}
+async function postContinue(options) {
+  const debug = (0, import_utils.createDebug)(options.debug);
+  debug(`Calling continue deployment endpoint for ${options.deploymentId}`);
+  const response = await (0, import_utils.fetchApi)(
+    `/deployments/${options.deploymentId}/continue${options.teamId ? `?teamId=${options.teamId}` : ""}`,
+    options.token,
+    {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        files: (0, import_utils.prepareFiles)(options.files, {
+          isDirectory: true,
+          path: options.path,
+          token: options.token
+        })
+      }),
+      apiUrl: options.apiUrl,
+      userAgent: options.userAgent,
+      agent: options.agent
+    }
+  );
+  let result;
+  try {
+    result = await response.json();
+  } catch {
+    return {
+      type: "error",
+      error: new Error("Invalid JSON response from continue endpoint")
+    };
+  }
+  if (!response.ok || result.error) {
+    if (result.error?.code === "missing_files" || result.code === "missing_files") {
+      debug(
+        `Continue deployment returned missing_files: ${(result.error?.missing || result.missing || []).length} files`
+      );
+      return {
+        type: "missing_files",
+        missing: result.error?.missing || result.missing || []
+      };
+    }
+    debug("Continue deployment request failed");
+    return {
+      type: "error",
+      error: result.error ? { ...result.error, status: response.status } : { ...result, status: response.status }
+    };
+  }
+  debug("Continue deployment succeeded");
+  return { type: "success", deployment: result };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  continueDeployment
+});

package/dist/create-deployment.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 create_deployment_exports = {};
 __export(create_deployment_exports, {
@@ -34,13 +24,12 @@ module.exports = __toCommonJS(create_deployment_exports);
 var import_fs_extra = require("fs-extra");
 var import_path = require("path");
 var import_hashes = require("./utils/hashes");
+var import_deploy = require("./deploy");
 var import_upload = require("./upload");
 var import_utils = require("./utils");
 var import_errors = require("./errors");
 var import_error_utils = require("@vercel/error-utils");
-var import_build_utils = require("@vercel/build-utils");
-var import_tar_fs = __toESM(require("tar-fs"));
-var import_zlib = require("zlib");
+var import_archive = require("./utils/archive");
 function buildCreateDeployment() {
   return async function* createDeployment(clientOptions, deploymentOptions = {}) {
     const { path } = clientOptions;
@@ -64,6 +53,22 @@ function buildCreateDeployment() {
         message: "Options object must include a `token`"
       });
     }
+    if (clientOptions.manual) {
+      debug("Manual provisioning mode enabled");
+      if (!clientOptions.prebuilt) {
+        throw new import_errors.DeploymentError({
+          code: "invalid_options",
+          message: "The `manual` option requires `prebuilt` to be true"
+        });
+      }
+      deploymentOptions.build = deploymentOptions.build || {};
+      deploymentOptions.build.env = deploymentOptions.build.env || {};
+      deploymentOptions.build.env.VERCEL_MANUAL_PROVISIONING = "1";
+      deploymentOptions.version = 2;
+      debug("Creating deployment with manual provisioning...");
+      yield* (0, import_deploy.deploy)(/* @__PURE__ */ new Map(), clientOptions, deploymentOptions);
+      return;
+    }
     clientOptions.isDirectory = !Array.isArray(path) && (0, import_fs_extra.lstatSync)(path).isDirectory();
     if (Array.isArray(path)) {
       for (const filePath of path) {
@@ -99,22 +104,7 @@ function buildCreateDeployment() {
     let files;
     try {
       if (clientOptions.archive === "tgz") {
-        debug("Packing tarball");
-        const tarStream = import_tar_fs.default.pack(workPath, {
-          entries: fileList.map((file) => (0, import_path.relative)(workPath, file))
-        }).pipe((0, import_zlib.createGzip)());
-        const chunkedTarBuffers = await (0, import_build_utils.streamToBufferChunks)(tarStream);
-        debug(`Packed tarball into ${chunkedTarBuffers.length} chunks`);
-        files = new Map(
-          chunkedTarBuffers.map((chunk, index) => [
-            (0, import_hashes.hash)(chunk),
-            {
-              names: [(0, import_path.join)(workPath, `.vercel/source.tgz.part${index + 1}`)],
-              data: chunk,
-              mode: 438
-            }
-          ])
-        );
+        files = await (0, import_archive.createTgzFiles)(workPath, fileList, debug);
       } else {
         files = await (0, import_hashes.hashes)(fileList);
       }

package/dist/deploy.d.ts

@@ -1,6 +1,6 @@
 import { FilesMap } from './utils/hashes';
-import { DeploymentOptions, VercelClientOptions } from './types';
+import { DeploymentOptions, VercelClientOptions, DeploymentEventType } from './types';
 export declare function deploy(files: FilesMap, clientOptions: VercelClientOptions, deploymentOptions: DeploymentOptions): AsyncIterableIterator<{
-    type: string;
+    type: DeploymentEventType;
     payload: any;
 }>;

package/dist/deploy.js

@@ -41,7 +41,7 @@ async function* postDeployment(files, clientOptions, deploymentOptions) {
   }
   debug("Sending deployment creation API request");
   try {
-    const response = await (0, import_utils.fetch)(
+    const response = await (0, import_utils.fetchApi)(
       `${apiDeployments}${(0, import_query_string.generateQueryString)(clientOptions)}`,
       clientOptions.token,
       {
@@ -62,7 +62,7 @@ async function* postDeployment(files, clientOptions, deploymentOptions) {
     let deployment = void 0;
     try {
       deployment = await response.json();
-    } catch (error) {
+    } catch (_error) {
       throw new Error("Invalid JSON response");
     }
     if (clientOptions.debug) {
@@ -110,14 +110,14 @@ function getDefaultName(files, clientOptions) {
 }
 async function* deploy(files, clientOptions, deploymentOptions) {
   const debug = (0, import_utils.createDebug)(clientOptions.debug);
-  if (!deploymentOptions.name) {
+  if (!deploymentOptions.name && files.size > 0) {
     deploymentOptions.version = 2;
     deploymentOptions.name = files.size === 1 ? "file" : getDefaultName(files, clientOptions);
     if (deploymentOptions.name === "file") {
       debug('Setting deployment name to "file" for single-file deployment');
     }
   }
-  if (!deploymentOptions.name) {
+  if (!deploymentOptions.name && files.size > 0) {
     deploymentOptions.name = clientOptions.defaultName || getDefaultName(files, clientOptions);
     debug("No name provided. Defaulting to", deploymentOptions.name);
   }
@@ -144,6 +144,10 @@ async function* deploy(files, clientOptions, deploymentOptions) {
     debug("An unexpected error occurred when creating the deployment");
     return yield { type: "error", payload: e };
   }
+  if (clientOptions.manual) {
+    debug("Manual mode - skipping ready state check");
+    return;
+  }
   if (deployment) {
     if ((0, import_ready_state.isReady)(deployment) && (0, import_ready_state.isAliasAssigned)(deployment)) {
       debug("Deployment state changed to READY 3");

package/dist/index.d.ts

@@ -1,7 +1,8 @@
+export { continueDeployment } from './continue';
 export { checkDeploymentStatus } from './check-deployment-status';
 export { getVercelIgnore, buildFileTree } from './utils/index';
 export declare const createDeployment: (clientOptions: import("./types").VercelClientOptions, deploymentOptions?: import("./types").DeploymentOptions) => AsyncIterableIterator<{
-    type: "hashes-calculated" | "file-count" | "file-uploaded" | "all-files-uploaded" | "created" | "building" | "ready" | "alias-assigned" | "warning" | "error" | "notice" | "tip" | "canceled" | "checks-registered" | "checks-completed" | "checks-running" | "checks-conclusion-succeeded" | "checks-conclusion-failed" | "checks-conclusion-skipped" | "checks-conclusion-canceled";
+    type: "hashes-calculated" | "file-count" | "file-uploaded" | "all-files-uploaded" | "created" | "building" | "ready" | "alias-assigned" | "warning" | "error" | "notice" | "tip" | "canceled" | "checks-registered" | "checks-completed" | "checks-running" | "checks-conclusion-succeeded" | "checks-conclusion-failed" | "checks-conclusion-skipped" | "checks-conclusion-canceled" | "checks-v2-failed";
     payload: any;
 }>;
 export * from './errors';

package/dist/index.js

@@ -31,11 +31,13 @@ var src_exports = {};
 __export(src_exports, {
   buildFileTree: () => import_utils.buildFileTree,
   checkDeploymentStatus: () => import_check_deployment_status.checkDeploymentStatus,
+  continueDeployment: () => import_continue.continueDeployment,
   createDeployment: () => createDeployment,
   getVercelIgnore: () => import_utils.getVercelIgnore
 });
 module.exports = __toCommonJS(src_exports);
 var import_create_deployment = __toESM(require("./create-deployment"));
+var import_continue = require("./continue");
 var import_check_deployment_status = require("./check-deployment-status");
 var import_utils = require("./utils/index");
 __reExport(src_exports, require("./errors"), module.exports);
@@ -45,6 +47,7 @@ const createDeployment = (0, import_create_deployment.default)();
 0 && (module.exports = {
   buildFileTree,
   checkDeploymentStatus,
+  continueDeployment,
   createDeployment,
   getVercelIgnore,
   ...require("./errors"),

package/dist/types.d.ts

@@ -31,6 +31,11 @@ export interface VercelClientOptions {
      * This file will be included in prebuilt deployments.
      */
     bulkRedirectsPath?: string | null;
+    /**
+     * When true, creates an experimental manual deployment. This mode requires
+     * that the user later continues the deployment with an API call.
+     */
+    manual?: boolean;
 }
 /** @deprecated Use VercelClientOptions instead. */
 export type NowClientOptions = VercelClientOptions;
@@ -71,6 +76,11 @@ export interface Deployment {
     alias: string[];
     aliasAssigned: boolean;
     aliasError: string | null;
+    checks?: Record<string, {
+        state: 'pending' | 'succeeded' | 'failed';
+        startedAt?: string;
+        completedAt?: string;
+    }>;
     expiration?: number;
     proposedExpiration?: number;
     undeletedAt?: number;

package/dist/upload.d.ts

@@ -1,3 +1,30 @@
-import { FilesMap } from './utils/hashes';
-import { VercelClientOptions, DeploymentOptions } from './types';
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+import { DeploymentFile, FilesMap } from './utils/hashes';
+import type { Agent } from 'http';
+import type { VercelClientOptions, DeploymentOptions, DeploymentEventType } from './types';
 export declare function upload(files: FilesMap, clientOptions: VercelClientOptions, deploymentOptions: DeploymentOptions): AsyncIterableIterator<any>;
+/**
+ * Uploads files to the /v2/files endpoint with retry and fault tolerance.
+ */
+export declare function uploadFiles(options: {
+    agent?: Agent;
+    apiUrl?: string;
+    debug?: boolean;
+    files: FilesMap;
+    shas: string[];
+    teamId?: string;
+    token: string;
+    uploads: UploadProgress[];
+    userAgent?: string;
+}): AsyncIterableIterator<{
+    type: DeploymentEventType;
+    payload: any;
+}>;
+export declare class UploadProgress extends EventEmitter {
+    sha: string;
+    file: DeploymentFile;
+    bytesUploaded: number;
+    constructor(sha: string, file: DeploymentFile);
+}

package/dist/upload.js

@@ -28,7 +28,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var upload_exports = {};
 __export(upload_exports, {
-  upload: () => upload
+  UploadProgress: () => UploadProgress,
+  upload: () => upload,
+  uploadFiles: () => uploadFiles
 });
 module.exports = __toCommonJS(upload_exports);
 var import_http = __toESM(require("http"));
@@ -47,9 +49,8 @@ const isClientNetworkError = (err) => {
   return false;
 };
 async function* upload(files, clientOptions, deploymentOptions) {
-  const { token, teamId, apiUrl, userAgent } = clientOptions;
   const debug = (0, import_utils.createDebug)(clientOptions.debug);
-  if (!files && !token && !teamId) {
+  if (!files && !clientOptions.token && !clientOptions.teamId) {
     debug(`Neither 'files', 'token' nor 'teamId are present. Exiting`);
     return;
   }
@@ -64,8 +65,10 @@ async function* upload(files, clientOptions, deploymentOptions) {
         return yield event;
       }
     } else {
-      if (event.type === "alias-assigned") {
-        debug("Deployment succeeded on file check");
+      if (event.type === "alias-assigned" || event.type === "checks-v2-failed") {
+        debug(
+          event.type === "alias-assigned" ? "Deployment succeeded on file check" : "v2 deployment-alias check failed on file check"
+        );
         return yield event;
       }
       yield event;
@@ -78,23 +81,60 @@ async function* upload(files, clientOptions, deploymentOptions) {
     type: "file-count",
     payload: { total: files, missing: shas, uploads }
   };
+  const uploadGenerator = uploadFiles({
+    agent: clientOptions.agent,
+    apiUrl: clientOptions.apiUrl,
+    debug: clientOptions.debug,
+    teamId: clientOptions.teamId,
+    token: clientOptions.token,
+    userAgent: clientOptions.userAgent,
+    files,
+    shas,
+    uploads
+  });
+  for await (const event of uploadGenerator) {
+    if (event.type === "error") {
+      return yield event;
+    } else {
+      yield event;
+    }
+  }
+  debug("All files uploaded");
+  yield { type: "all-files-uploaded", payload: files };
+  try {
+    debug("Starting deployment creation");
+    for await (const event of (0, import_deploy.deploy)(files, clientOptions, deploymentOptions)) {
+      if (event.type === "alias-assigned" || event.type === "checks-v2-failed") {
+        debug("Deployment is ready");
+        return yield event;
+      }
+      yield event;
+    }
+  } catch (e) {
+    debug("An unexpected error occurred when starting deployment creation");
+    yield { type: "error", payload: e };
+  }
+}
+async function* uploadFiles(options) {
+  const debug = (0, import_utils.createDebug)(options.debug);
   const uploadList = {};
   debug("Building an upload list...");
   const semaphore = new import_async_sema.Sema(50, { capacity: 50 });
-  const defaultAgent = apiUrl?.startsWith("https://") ? new import_https.default.Agent({ keepAlive: true }) : new import_http.default.Agent({ keepAlive: true });
+  const defaultAgent = options.apiUrl?.startsWith("https://") ? new import_https.default.Agent({ keepAlive: true }) : new import_http.default.Agent({ keepAlive: true });
   const abortControllers = /* @__PURE__ */ new Set();
   let aborted = false;
-  shas.forEach((sha, index) => {
-    const uploadProgress = uploads[index];
+  options.shas.forEach((sha, index) => {
+    const uploadProgress = options.uploads[index];
     uploadList[sha] = (0, import_async_retry.default)(
       async (bail) => {
-        const file = files.get(sha);
+        const file = options.files.get(sha);
         if (!file) {
           debug(`File ${sha} is undefined. Bailing`);
           return bail(new Error(`File ${sha} is undefined`));
         }
         await semaphore.acquire();
         if (aborted) {
+          semaphore.release();
           return bail(new Error("Upload aborted"));
         }
         const { data } = file;
@@ -123,11 +163,11 @@ async function* upload(files, clientOptions, deploymentOptions) {
         const abortController = new AbortController();
         abortControllers.add(abortController);
         try {
-          const res = await (0, import_utils.fetch)(
+          const res = await (0, import_utils.fetchApi)(
             import_utils.API_FILES,
-            token,
+            options.token,
             {
-              agent: clientOptions.agent || defaultAgent,
+              agent: options.agent || defaultAgent,
               method: "POST",
               headers: {
                 "Content-Type": "application/octet-stream",
@@ -136,13 +176,13 @@ async function* upload(files, clientOptions, deploymentOptions) {
                 "x-now-size": data.length
               },
               body,
-              teamId,
-              apiUrl,
-              userAgent,
+              teamId: options.teamId,
+              apiUrl: options.apiUrl,
+              userAgent: options.userAgent,
               // @ts-expect-error: typescript is getting confused with the signal types from node (web & server) and node-fetch (server only)
               signal: abortController.signal
             },
-            clientOptions.debug
+            options.debug
           );
           if (res.status === 200) {
             debug(
@@ -202,21 +242,6 @@ ${e}`);
       return yield { type: "error", payload: e };
     }
   }
-  debug("All files uploaded");
-  yield { type: "all-files-uploaded", payload: files };
-  try {
-    debug("Starting deployment creation");
-    for await (const event of (0, import_deploy.deploy)(files, clientOptions, deploymentOptions)) {
-      if (event.type === "alias-assigned") {
-        debug("Deployment is ready");
-        return yield event;
-      }
-      yield event;
-    }
-  } catch (e) {
-    debug("An unexpected error occurred when starting deployment creation");
-    yield { type: "error", payload: e };
-  }
 }
 class UploadProgress extends import_node_events.EventEmitter {
   constructor(sha, file) {
@@ -228,5 +253,7 @@ class UploadProgress extends import_node_events.EventEmitter {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  upload
+  UploadProgress,
+  upload,
+  uploadFiles
 });

package/dist/utils/archive.d.ts

@@ -0,0 +1,2 @@
+import { type FilesMap } from './hashes';
+export declare function createTgzFiles(workPath: string, fileList: string[], debug?: (message: string) => void, exclude?: string[]): Promise<FilesMap>;

package/dist/utils/archive.js

@@ -0,0 +1,61 @@
+"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 archive_exports = {};
+__export(archive_exports, {
+  createTgzFiles: () => createTgzFiles
+});
+module.exports = __toCommonJS(archive_exports);
+var import_node_path = require("node:path");
+var import_node_zlib = require("node:zlib");
+var import_build_utils = require("@vercel/build-utils");
+var import_tar_fs = __toESM(require("tar-fs"));
+var import_hashes = require("./hashes");
+async function createTgzFiles(workPath, fileList, debug, exclude) {
+  const filesToArchive = exclude ? fileList.filter((file) => !exclude.includes(file)) : fileList;
+  debug?.("Packing tarball");
+  const tarStream = import_tar_fs.default.pack(workPath, {
+    entries: filesToArchive.map((file) => (0, import_node_path.relative)(workPath, file))
+  }).pipe((0, import_node_zlib.createGzip)());
+  const chunkedTarBuffers = await (0, import_build_utils.streamToBufferChunks)(tarStream);
+  debug?.(`Packed tarball into ${chunkedTarBuffers.length} chunks`);
+  return new Map(
+    chunkedTarBuffers.map((chunk, index) => [
+      (0, import_hashes.hash)(chunk),
+      {
+        names: [(0, import_node_path.join)(workPath, `.vercel/source.tgz.part${index + 1}`)],
+        data: chunk,
+        mode: 438
+      }
+    ])
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTgzFiles
+});

package/dist/utils/index.d.ts

@@ -4,9 +4,9 @@ import ignore from 'ignore';
 import { VercelClientOptions, VercelConfig } from '../types';
 type Ignore = ReturnType<typeof ignore>;
 export declare const API_FILES = "/v2/files";
-declare const EVENTS_ARRAY: readonly ["hashes-calculated", "file-count", "file-uploaded", "all-files-uploaded", "created", "building", "ready", "alias-assigned", "warning", "error", "notice", "tip", "canceled", "checks-registered", "checks-completed", "checks-running", "checks-conclusion-succeeded", "checks-conclusion-failed", "checks-conclusion-skipped", "checks-conclusion-canceled"];
+declare const EVENTS_ARRAY: readonly ["hashes-calculated", "file-count", "file-uploaded", "all-files-uploaded", "created", "building", "ready", "alias-assigned", "warning", "error", "notice", "tip", "canceled", "checks-registered", "checks-completed", "checks-running", "checks-conclusion-succeeded", "checks-conclusion-failed", "checks-conclusion-skipped", "checks-conclusion-canceled", "checks-v2-failed"];
 export type DeploymentEventType = (typeof EVENTS_ARRAY)[number];
-export declare const EVENTS: Set<"hashes-calculated" | "file-count" | "file-uploaded" | "all-files-uploaded" | "created" | "building" | "ready" | "alias-assigned" | "warning" | "error" | "notice" | "tip" | "canceled" | "checks-registered" | "checks-completed" | "checks-running" | "checks-conclusion-succeeded" | "checks-conclusion-failed" | "checks-conclusion-skipped" | "checks-conclusion-canceled">;
+export declare const EVENTS: Set<"hashes-calculated" | "file-count" | "file-uploaded" | "all-files-uploaded" | "created" | "building" | "ready" | "alias-assigned" | "warning" | "error" | "notice" | "tip" | "canceled" | "checks-registered" | "checks-completed" | "checks-running" | "checks-conclusion-succeeded" | "checks-conclusion-failed" | "checks-conclusion-skipped" | "checks-conclusion-canceled" | "checks-v2-failed">;
 export declare function getApiDeploymentsUrl(): string;
 export declare function parseVercelConfig(filePath?: string): Promise<VercelConfig>;
 export declare function buildFileTree(path: string | string[], { isDirectory, prebuilt, vercelOutputDir, rootDirectory, projectName, bulkRedirectsPath, }: Pick<VercelClientOptions, 'isDirectory' | 'prebuilt' | 'vercelOutputDir' | 'rootDirectory' | 'projectName' | 'bulkRedirectsPath'>, debug: Debug): Promise<{
@@ -26,7 +26,7 @@ interface FetchOpts extends RequestInit {
     };
     userAgent?: string;
 }
-export declare const fetch: (url: string, token: string, opts?: FetchOpts, debugEnabled?: boolean) => Promise<any>;
+export declare const fetchApi: (url: string, token: string, opts?: FetchOpts, debugEnabled?: boolean) => Promise<any>;
 export interface PreparedFile {
     file: string;
     sha?: string;

package/dist/utils/index.js

@@ -32,7 +32,7 @@ __export(utils_exports, {
   EVENTS: () => EVENTS,
   buildFileTree: () => buildFileTree,
   createDebug: () => createDebug,
-  fetch: () => fetch,
+  fetchApi: () => fetchApi,
   getApiDeploymentsUrl: () => getApiDeploymentsUrl,
   getVercelIgnore: () => getVercelIgnore,
   parseVercelConfig: () => parseVercelConfig,
@@ -67,14 +67,16 @@ const EVENTS_ARRAY = [
   "notice",
   "tip",
   "canceled",
-  // Checks events
+  // v1 Checks events
   "checks-registered",
   "checks-completed",
   "checks-running",
   "checks-conclusion-succeeded",
   "checks-conclusion-failed",
   "checks-conclusion-skipped",
-  "checks-conclusion-canceled"
+  "checks-conclusion-canceled",
+  // v2 Checks events
+  "checks-v2-failed"
 ];
 const EVENTS = new Set(EVENTS_ARRAY);
 function getApiDeploymentsUrl() {
@@ -95,7 +97,7 @@ async function parseVercelConfig(filePath) {
 const maybeRead = async function(path, default_) {
   try {
     return await (0, import_fs_extra.readFile)(path, "utf8");
-  } catch (err) {
+  } catch (_err) {
     return default_;
   }
 };
@@ -178,24 +180,31 @@ async function buildFileTree(path, {
         const relativeFromRoot = (0, import_path.relative)(projectRoot, bulkRedirectsFullPath);
         if (relativeFromRoot.startsWith("..")) {
           debug(
-            `Skipping bulk redirects file "${bulkRedirectsPath}" - path traversal detected (resolves outside project root)`
+            `Skipping bulk redirects path "${bulkRedirectsPath}" - path traversal detected (resolves outside project root)`
           );
         } else {
-          const bulkRedirectsContent = await maybeRead(
-            bulkRedirectsFullPath,
-            null
-          );
-          if (bulkRedirectsContent !== null) {
-            refs.add(bulkRedirectsFullPath);
-            debug(
-              `Including bulk redirects file "${bulkRedirectsPath}" in deployment`
-            );
-          } else {
-            debug(`Bulk redirects file "${bulkRedirectsPath}" not found`);
+          try {
+            const stats = await (0, import_fs_extra.stat)(bulkRedirectsFullPath);
+            if (stats.isDirectory()) {
+              const dirFiles = await (0, import_readdir_recursive.default)(bulkRedirectsFullPath, []);
+              for (const file of dirFiles) {
+                refs.add(file);
+              }
+              debug(
+                `Including ${dirFiles.length} files from bulk redirects directory "${bulkRedirectsPath}" in deployment`
+              );
+            } else if (stats.isFile()) {
+              refs.add(bulkRedirectsFullPath);
+              debug(
+                `Including bulk redirects file "${bulkRedirectsPath}" in deployment`
+              );
+            }
+          } catch (_e) {
+            debug(`Bulk redirects path "${bulkRedirectsPath}" not found`);
           }
         }
       } catch (e) {
-        debug(`Error checking for bulk redirects file: ${e}`);
+        debug(`Error checking for bulk redirects path: ${e}`);
       }
     }
     if (refs.size > 0) {
@@ -287,7 +296,7 @@ ${clearRelative(ignoreFile)}`);
 function clearRelative(str) {
   return str.replace(/(\n|^)\.\//g, "$1");
 }
-const fetch = async (url, token, opts = {}, debugEnabled) => {
+const fetchApi = async (url, token, opts = {}, debugEnabled) => {
   semaphore.acquire();
   const debug = createDebug(debugEnabled);
   let time;
@@ -357,7 +366,7 @@ function createDebug(debug) {
   EVENTS,
   buildFileTree,
   createDebug,
-  fetch,
+  fetchApi,
   getApiDeploymentsUrl,
   getVercelIgnore,
   parseVercelConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/client",
-  "version": "17.3.0-canary.20260211174907.cdd2da6",
+  "version": "17.3.0",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "homepage": "https://vercel.com",
@@ -42,9 +42,9 @@
     "querystring": "^0.2.0",
     "sleep-promise": "8.0.1",
     "tar-fs": "1.16.3",
-    "@vercel/build-utils": "13.4.0-canary.20260211174907.cdd2da6",
-    "@vercel/error-utils": "2.1.0-canary.20260211174907.cdd2da6",
-    "@vercel/routing-utils": "5.4.0-canary.20260211174907.cdd2da6"
+    "@vercel/build-utils": "13.14.1",
+    "@vercel/error-utils": "2.0.3",
+    "@vercel/routing-utils": "6.1.1"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",