vercel 54.8.0 → 54.9.1

package/dist/chunks/{add-7PN3D2CB.js → add-DLK472F2.js}

@@ -9,8 +9,8 @@ import {
   handleRulesApiError,
   parseRulesFlagsAndScope,
   rulesCollectionPath
-} from "./chunk-MZ6WX76F.js";
-import "./chunk-6MRFETFX.js";
+} from "./chunk-LZQB35VT.js";
+import "./chunk-5DEFO6LE.js";
 import "./chunk-5SYDEK2N.js";
 import {
   validateJsonOutput
@@ -20,9 +20,9 @@ import {
 } from "./chunk-NGRSQRSN.js";
 import {
   AGENT_REASON
-} from "./chunk-L6Q2EQPI.js";
-import "./chunk-BLBP6PJV.js";
-import "./chunk-KFVMKDQD.js";
+} from "./chunk-LJ5WXXG6.js";
+import "./chunk-WA3URLW4.js";
+import "./chunk-H3M6DIPE.js";
 import "./chunk-DPXUXH7G.js";
 import {
   buildCommandWithGlobalFlags,

package/dist/chunks/{chunk-TKYXKHYP.js → chunk-2WIR65ZA.js}

@@ -25,10 +25,10 @@ import {
 import {
   buildCommand,
   pullCommand
-} from "./chunk-UVSQEC2H.js";
+} from "./chunk-7BNN27HP.js";
 import {
   envCommand
-} from "./chunk-KFVMKDQD.js";
+} from "./chunk-H3M6DIPE.js";
 import {
   confirmOption,
   forceOption,
@@ -4742,6 +4742,48 @@ var createThresholdSubcommand = {
     }
   ]
 };
+var claimSubcommand = {
+  name: "claim",
+  aliases: [],
+  description: "Claim a sandbox marketplace resource (e.g. Stripe, Shopify) by opening the provider claim URL in your browser",
+  arguments: [
+    {
+      name: "resource",
+      required: false
+    }
+  ],
+  options: [
+    {
+      ...yesOption,
+      description: "Skip the confirmation prompt when claiming a single sandbox resource"
+    },
+    {
+      name: "no-wait",
+      description: "Print the claim URL and exit without polling for completion",
+      shorthand: null,
+      type: Boolean,
+      deprecated: false
+    },
+    formatOption
+  ],
+  examples: [
+    {
+      name: "Claim a sandbox resource by name",
+      value: [
+        `${packageName} integration-resource claim <resource>`,
+        `${packageName} integration-resource claim my-stripe`
+      ]
+    },
+    {
+      name: "Pick a sandbox resource interactively (current team)",
+      value: `${packageName} integration-resource claim`
+    },
+    {
+      name: "Print the claim URL as JSON without waiting",
+      value: `${packageName} integration-resource claim my-stripe --format=json --no-wait`
+    }
+  ]
+};
 var integrationResourceCommand = {
   name: "integration-resource",
   aliases: ["ir"],
@@ -4752,7 +4794,8 @@ var integrationResourceCommand = {
     connectSubcommand2,
     createThresholdSubcommand,
     disconnectSubcommand2,
-    removeSubcommand9
+    removeSubcommand9,
+    claimSubcommand
   ],
   examples: []
 };
@@ -4831,6 +4874,20 @@ var addSubcommand7 = {
       argument: "ID",
       description: "Installation ID to use when multiple installations exist for the integration"
     },
+    {
+      name: "claim",
+      shorthand: null,
+      type: Boolean,
+      deprecated: false,
+      description: "If the new resource is a sandbox (e.g. Stripe, Shopify), claim it immediately without prompting"
+    },
+    {
+      name: "no-claim",
+      shorthand: null,
+      type: Boolean,
+      deprecated: false,
+      description: "If the new resource is a sandbox, skip the offer to claim it (only print a hint)"
+    },
     formatOption
   ],
   examples: [
@@ -5272,14 +5329,15 @@ var guideSubcommand = {
 var resourceSubcommand = {
   name: "resource",
   aliases: [],
-  description: "Manage marketplace integration resources (connect, disconnect, remove, create-threshold)",
+  description: "Manage marketplace integration resources (connect, disconnect, remove, create-threshold, claim)",
   options: [],
   arguments: [],
   subcommands: [
     connectSubcommand2,
     createThresholdSubcommand,
     disconnectSubcommand2,
-    removeSubcommand9
+    removeSubcommand9,
+    claimSubcommand
   ],
   examples: [
     {
@@ -8651,6 +8709,7 @@ export {
   disconnectSubcommand2,
   connectSubcommand2,
   createThresholdSubcommand,
+  claimSubcommand,
   integrationResourceCommand,
   addSubcommand7 as addSubcommand6,
   acceptTermsSubcommand,

package/dist/chunks/{chunk-6MRFETFX.js → chunk-5DEFO6LE.js}

@@ -9,14 +9,14 @@ import {
 } from "./chunk-5SYDEK2N.js";
 import {
   AGENT_REASON
-} from "./chunk-L6Q2EQPI.js";
+} from "./chunk-LJ5WXXG6.js";
 import {
   getScope
-} from "./chunk-BLBP6PJV.js";
+} from "./chunk-WA3URLW4.js";
 import {
   getLinkedProject,
   getProjectByNameOrId
-} from "./chunk-KFVMKDQD.js";
+} from "./chunk-H3M6DIPE.js";
 import {
   buildCommandWithGlobalFlags,
   outputAgentError

package/dist/chunks/{chunk-MZXIRI4R.js → chunk-5MNBLHCW.js}

@@ -7,7 +7,7 @@ const __dirname = __dirname_(__filename);
 import {
   VERCEL_DIR,
   isVercelTomlEnabled
-} from "./chunk-KFVMKDQD.js";
+} from "./chunk-H3M6DIPE.js";
 import {
   parseArguments
 } from "./chunk-6IQZVQV6.js";

package/dist/chunks/{chunk-BGOG7M2L.js → chunk-6TKGW3ER.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   require_lib
-} from "./chunk-KFVMKDQD.js";
+} from "./chunk-H3M6DIPE.js";
 import {
   packageName
 } from "./chunk-LN6B7ZI3.js";

package/dist/chunks/{chunk-UVSQEC2H.js → chunk-7BNN27HP.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   getEnvTargetPlaceholder
-} from "./chunk-KFVMKDQD.js";
+} from "./chunk-H3M6DIPE.js";
 import {
   projectOption,
   yesOption

package/dist/chunks/{chunk-3UG4R5C6.js → chunk-BR7Z2MXT.js}

@@ -8,22 +8,22 @@ import {
   getUpdateCommand,
   isGlobal,
   isNativeBinaryInstall
-} from "./chunk-BGOG7M2L.js";
+} from "./chunk-6TKGW3ER.js";
 import {
   getGlobalPathConfig,
   writeToConfigFile
-} from "./chunk-2VNVOF6Y.js";
+} from "./chunk-OZLTZQ6G.js";
 import {
   apiCommand,
   listSubcommand2 as listSubcommand,
   loginCommand
-} from "./chunk-TKYXKHYP.js";
+} from "./chunk-2WIR65ZA.js";
 import {
   help
 } from "./chunk-5ZJHY4AC.js";
 import {
   login
-} from "./chunk-KFVMKDQD.js";
+} from "./chunk-H3M6DIPE.js";
 import {
   TelemetryClient
 } from "./chunk-DPXUXH7G.js";

package/dist/chunks/{chunk-6GCPDK6C.js → chunk-BTHBAHZ7.js}

@@ -7,7 +7,7 @@ const __dirname = __dirname_(__filename);
 import {
   formatCondition,
   formatTransform
-} from "./chunk-QSUXC4XD.js";
+} from "./chunk-J5JWEUV2.js";
 import {
   output_manager_default
 } from "./chunk-Z5SBJH6L.js";

package/dist/chunks/{chunk-C2JLV23W.js → chunk-CSYB45VZ.js}

@@ -18,7 +18,7 @@ import {
   require_lib,
   require_minimatch,
   require_pluralize
-} from "./chunk-KFVMKDQD.js";
+} from "./chunk-H3M6DIPE.js";
 import {
   CantParseJSONFile,
   cmd,
@@ -11897,6 +11897,15 @@ async function* findDirs(name, dir, root = dir) {
     }
   }
 }
+function stripParentSegments(path2) {
+  const normalized = normalizePath(path2);
+  const segments = normalized.split("/");
+  let i = 0;
+  while (i < segments.length && segments[i] === "..") {
+    i++;
+  }
+  return segments.slice(i).join("/");
+}
 function filesWithoutFsRefs(files, repoRootPath, sharedDest, standalone) {
   let filePathMap;
   const out = {};
@@ -11909,9 +11918,10 @@ function filesWithoutFsRefs(files, repoRootPath, sharedDest, standalone) {
         if (isExternalSymlink(file)) {
           continue;
         }
-        shared[path2] = file;
-        filePathMap[normalizePath(path2)] = normalizePath(
-          relative2(repoRootPath, join4(sharedDest, path2))
+        const funcPath = stripParentSegments(path2);
+        shared[funcPath] = file;
+        filePathMap[funcPath] = normalizePath(
+          relative2(repoRootPath, join4(sharedDest, funcPath))
         );
       } else {
         filePathMap[normalizePath(path2)] = normalizePath(

package/dist/chunks/{chunk-KFVMKDQD.js → chunk-H3M6DIPE.js}

@@ -23125,8 +23125,13 @@ var require_resolve2 = __commonJS({
     var __toCommonJS2 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
     var resolve_exports = {};
     __export2(resolve_exports, {
+      detectFrameworkFromWorkspace: () => detectFrameworkFromWorkspace,
+      getServiceFs: () => getServiceFs,
+      inferWorkspaceFromNearestManifest: () => inferWorkspaceFromNearestManifest,
+      parsePyModuleAttrEntrypoint: () => parsePyModuleAttrEntrypoint,
       resolveAllConfiguredServices: () => resolveAllConfiguredServices,
       resolveConfiguredService: () => resolveConfiguredService,
+      resolveEntrypointPath: () => resolveEntrypointPath,
       validateServiceConfig: () => validateServiceConfig,
       validateServiceEntrypoint: () => validateServiceEntrypoint
     });
@@ -23773,6 +23778,7 @@ var require_resolve2 = __commonJS({
         builderConfig.handlerFunction = moduleAttrParsed.attrName;
       }
       return {
+        schema: "experimentalServices",
         name,
         type,
         trigger,
@@ -23978,6 +23984,270 @@ var require_resolve2 = __commonJS({
   }
 });
 
+// ../fs-detectors/dist/services/resolve-v2.js
+var require_resolve_v2 = __commonJS({
+  "../fs-detectors/dist/services/resolve-v2.js"(exports, module) {
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export2 = (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 __toCommonJS2 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var resolve_v2_exports = {};
+    __export2(resolve_v2_exports, {
+      resolveAllConfiguredServicesV2: () => resolveAllConfiguredServicesV22,
+      resolveConfiguredServiceV2: () => resolveConfiguredServiceV22,
+      validateServiceConfigV2: () => validateServiceConfigV22
+    });
+    module.exports = __toCommonJS2(resolve_v2_exports);
+    var import_path12 = __require("path");
+    var import_build_utils6 = __require("@vercel/build-utils");
+    var import_frameworks2 = require_frameworks();
+    var import_types = require_types3();
+    var import_resolve = require_resolve2();
+    var import_utils4 = require_utils3();
+    var frameworksBySlug = new Map(import_frameworks2.frameworkList.map((f) => [f.slug, f]));
+    var SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+    function validateServiceConfigV22(name, config) {
+      if (!SERVICE_NAME_REGEX.test(name)) {
+        return {
+          code: "INVALID_SERVICE_NAME",
+          message: `Service name "${name}" is invalid. Names must start with a letter, end with an alphanumeric character, and contain only alphanumeric characters, hyphens, and underscores.`,
+          serviceName: name
+        };
+      }
+      if (!config || typeof config !== "object") {
+        return {
+          code: "INVALID_SERVICE_CONFIG",
+          message: `Service "${name}" has an invalid configuration. Expected an object.`,
+          serviceName: name
+        };
+      }
+      if (typeof config.root !== "string" || config.root.length === 0) {
+        return {
+          code: "MISSING_ROOT",
+          message: `Service "${name}" must specify a "root".`,
+          serviceName: name
+        };
+      }
+      const normalizedRoot = import_path12.posix.normalize(config.root);
+      if (normalizedRoot.startsWith("/")) {
+        return {
+          code: "INVALID_ROOT",
+          message: `Service "${name}" has invalid "root" "${config.root}". Must be a relative path.`,
+          serviceName: name
+        };
+      }
+      if (normalizedRoot === ".." || normalizedRoot.startsWith("../")) {
+        return {
+          code: "INVALID_ROOT",
+          message: `Service "${name}" has invalid "root" "${config.root}". Must not escape the project root.`,
+          serviceName: name
+        };
+      }
+      if (config.runtime && !(config.runtime in import_types.RUNTIME_BUILDERS)) {
+        return {
+          code: "INVALID_RUNTIME",
+          message: `Service "${name}" has invalid runtime "${config.runtime}".`,
+          serviceName: name
+        };
+      }
+      if (config.framework && !frameworksBySlug.has(config.framework)) {
+        return {
+          code: "INVALID_FRAMEWORK",
+          message: `Service "${name}" has invalid framework "${config.framework}".`,
+          serviceName: name
+        };
+      }
+      if (config.runtime && config.framework) {
+        const frameworkRuntime = (0, import_utils4.inferRuntimeFromFramework)(config.framework);
+        if (frameworkRuntime && frameworkRuntime !== config.runtime) {
+          return {
+            code: "RUNTIME_FRAMEWORK_MISMATCH",
+            message: `Service "${name}" has conflicting runtime/framework: runtime "${config.runtime}" is incompatible with framework "${config.framework}" (runtime "${frameworkRuntime}").`,
+            serviceName: name
+          };
+        }
+      }
+      if (!config.framework && !config.entrypoint) {
+        return {
+          code: "MISSING_SERVICE_CONFIG",
+          message: `Service "${name}" must specify "framework" or "entrypoint".`,
+          serviceName: name
+        };
+      }
+      return null;
+    }
+    async function resolveConfiguredServiceV22(name, config, fs5) {
+      const root = config.root;
+      const normalizedRoot = import_path12.posix.normalize(root);
+      const serviceFsResult = normalizedRoot === "." ? { fs: fs5 } : await (0, import_resolve.getServiceFs)(fs5, name, root);
+      if (serviceFsResult.error) {
+        return { error: serviceFsResult.error };
+      }
+      const serviceFs = serviceFsResult.fs;
+      const rawEntrypoint = config.entrypoint;
+      const moduleAttr = typeof rawEntrypoint === "string" ? (0, import_resolve.parsePyModuleAttrEntrypoint)(rawEntrypoint) : null;
+      let normalizedEntrypoint;
+      let entrypointIsDirectory = false;
+      if (typeof rawEntrypoint === "string") {
+        const entrypointToResolve = moduleAttr ? moduleAttr.filePath : rawEntrypoint;
+        const resolved = await (0, import_resolve.resolveEntrypointPath)({
+          fs: serviceFs,
+          serviceName: name,
+          entrypoint: entrypointToResolve
+        });
+        if (resolved.error) {
+          return { error: resolved.error };
+        }
+        normalizedEntrypoint = resolved.entrypoint?.normalized;
+        entrypointIsDirectory = Boolean(resolved.entrypoint?.isDirectory);
+      }
+      const entrypointFile = entrypointIsDirectory || !normalizedEntrypoint ? void 0 : normalizedEntrypoint;
+      const inferredRuntime = (0, import_utils4.inferServiceRuntime)({
+        runtime: config.runtime,
+        framework: config.framework,
+        entrypoint: entrypointFile
+      });
+      let framework = config.framework;
+      if (!framework && normalizedEntrypoint) {
+        const workspace = entrypointIsDirectory ? normalizedEntrypoint : import_path12.posix.dirname(normalizedEntrypoint) || ".";
+        const detection = await (0, import_resolve.detectFrameworkFromWorkspace)({
+          fs: serviceFs,
+          workspace,
+          serviceName: name,
+          runtime: inferredRuntime
+        });
+        if (detection.error) {
+          return { error: detection.error };
+        }
+        framework = detection.framework;
+      }
+      if (entrypointIsDirectory && !framework) {
+        return {
+          error: {
+            code: "MISSING_SERVICE_FRAMEWORK",
+            message: `Service "${name}" uses directory entrypoint "${config.entrypoint}" but no framework could be detected. Specify "framework" explicitly or use a file entrypoint.`,
+            serviceName: name
+          }
+        };
+      }
+      const frameworkDefinition = framework ? frameworksBySlug.get(framework) : void 0;
+      let builderUse;
+      let builderSrc;
+      if (framework) {
+        builderUse = (0, import_build_utils6.isNodeBackendFramework)(framework) ? "@vercel/backends" : frameworkDefinition?.useRuntime?.use || "@vercel/static-build";
+        builderSrc = entrypointFile || frameworkDefinition?.useRuntime?.src || "package.json";
+      } else {
+        if (!inferredRuntime) {
+          return {
+            error: {
+              code: "MISSING_SERVICE_CONFIG",
+              message: `Service "${name}" must specify "framework" or a runtime-resolvable "entrypoint".`,
+              serviceName: name
+            }
+          };
+        }
+        builderUse = inferredRuntime === "node" ? "@vercel/backends" : (0, import_utils4.getBuilderForRuntime)(inferredRuntime);
+        builderSrc = entrypointFile;
+      }
+      const isRoot = normalizedRoot === ".";
+      const projectRelativeSrc = isRoot ? builderSrc : import_path12.posix.join(normalizedRoot, builderSrc);
+      const builderConfig = { zeroConfig: true };
+      if (builderUse === "@vercel/backends") {
+        builderConfig.serviceName = name;
+      }
+      if (framework) {
+        builderConfig.framework = framework;
+      }
+      if (!isRoot) {
+        builderConfig.workspace = normalizedRoot;
+      }
+      if (moduleAttr) {
+        builderConfig.handlerFunction = moduleAttr.attrName;
+      }
+      const runtime = import_types.STATIC_BUILDERS.has(builderUse) ? void 0 : inferredRuntime;
+      return {
+        service: {
+          schema: "experimentalServicesV2",
+          name,
+          root,
+          framework,
+          runtime,
+          entrypoint: entrypointFile,
+          builder: {
+            src: projectRelativeSrc,
+            use: builderUse,
+            config: builderConfig
+          },
+          installCommand: config.installCommand,
+          buildCommand: config.buildCommand,
+          devCommand: config.devCommand,
+          ignoreCommand: config.ignoreCommand,
+          outputDirectory: config.outputDirectory,
+          bindings: config.bindings,
+          functions: config.functions,
+          headers: config.headers,
+          redirects: config.redirects,
+          rewrites: config.rewrites,
+          routes: config.routes,
+          cleanUrls: config.cleanUrls,
+          trailingSlash: config.trailingSlash
+        }
+      };
+    }
+    async function resolveAllConfiguredServicesV22(services, fs5) {
+      const resolved = [];
+      const errors = [];
+      for (const name of Object.keys(services)) {
+        const config = services[name];
+        const validationError = validateServiceConfigV22(name, config);
+        if (validationError) {
+          errors.push(validationError);
+          continue;
+        }
+        const { service, error } = await resolveConfiguredServiceV22(
+          name,
+          config,
+          fs5
+        );
+        if (error) {
+          errors.push(error);
+          continue;
+        }
+        if (service) {
+          resolved.push(service);
+        }
+      }
+      const serviceNames = new Set(Object.keys(services));
+      for (const service of resolved) {
+        for (const binding of service.bindings ?? []) {
+          if (!serviceNames.has(binding.service)) {
+            errors.push({
+              code: "UNKNOWN_SERVICE_BINDING",
+              message: `Service "${service.name}" declares a binding to unknown service "${binding.service}".`,
+              serviceName: service.name
+            });
+          }
+        }
+      }
+      return { services: resolved, errors };
+    }
+  }
+});
+
 // ../fs-detectors/dist/services/auto-detect.js
 var require_auto_detect = __commonJS({
   "../fs-detectors/dist/services/auto-detect.js"(exports, module) {
@@ -27869,6 +28139,7 @@ var require_detect_services = __commonJS({
     var import_routing_utils2 = require_dist5();
     var import_utils4 = require_utils3();
     var import_resolve = require_resolve2();
+    var import_resolve_v2 = require_resolve_v2();
     var import_auto_detect = require_auto_detect();
     var import_detect_railway = require_detect_railway();
     var import_detect_render = require_detect_render();
@@ -27933,7 +28204,8 @@ var require_detect_services = __commonJS({
         fs: fs5,
         workPath,
         detectEntrypoint,
-        configuredServices: providedConfiguredServices
+        configuredServices: providedConfiguredServices,
+        configuredServicesType
       } = options;
       const scopedFs = workPath ? fs5.chdir(workPath) : fs5;
       const { config: vercelConfig, error: configError } = await (0, import_utils4.readVercelConfig)(scopedFs);
@@ -27948,6 +28220,23 @@ var require_detect_services = __commonJS({
         });
       }
       const hasProvidedConfiguredServices = providedConfiguredServices && Object.keys(providedConfiguredServices).length > 0;
+      const experimentalServicesV2 = hasProvidedConfiguredServices && configuredServicesType === "experimentalServicesV2" ? providedConfiguredServices : hasProvidedConfiguredServices ? void 0 : vercelConfig?.experimentalServicesV2;
+      if (experimentalServicesV2 && Object.keys(experimentalServicesV2).length > 0) {
+        const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(
+          experimentalServicesV2,
+          scopedFs
+        );
+        return withResolvedResult({
+          services: result2.services,
+          source: "configured",
+          // V2 uses explicit `bindings`, so no implicit `{NAME}_URL` injection.
+          useImplicitEnvInjection: false,
+          // V2 routes are explicitly carried per-service to output them separately.
+          routes: emptyRoutes(),
+          errors: result2.errors,
+          warnings: []
+        });
+      }
       const configuredServices = hasProvidedConfiguredServices ? providedConfiguredServices : vercelConfig?.experimentalServices;
       const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
       if (!hasConfiguredServices) {
@@ -28053,7 +28342,8 @@ var require_detect_services = __commonJS({
         inferred
       );
     }
-    function generateServicesRoutes2(services) {
+    function generateServicesRoutes2(allServices) {
+      const services = allServices.filter(import_build_utils6.isExperimentalService);
       const hostRewrites = [];
       const rewrites = [];
       const defaults = [];
@@ -28610,10 +28900,14 @@ var require_detect_builders = __commonJS({
       return publicBuilder ? publicBuilder.src.replace("/**/*", "") : null;
     }
     async function detectBuilders2(files, pkg, options = {}) {
-      const { experimentalServices, projectSettings = {} } = options;
+      const {
+        experimentalServices,
+        experimentalServicesV2,
+        projectSettings = {}
+      } = options;
       const { framework } = projectSettings;
-      const configuredServices = experimentalServices;
-      const configuredServicesType = "experimentalServices";
+      const configuredServices = experimentalServices ?? experimentalServicesV2;
+      const configuredServicesType = experimentalServices ? "experimentalServices" : "experimentalServicesV2";
       const hasServicesConfig = configuredServices != null && typeof configuredServices === "object";
       if (hasServicesConfig || framework === "services") {
         return (0, import_get_services_builders.getServicesBuilders)({
@@ -33865,17 +34159,24 @@ var require_dist6 = __commonJS({
       getServicesBuilders: () => import_get_services_builders.getServicesBuilders,
       getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
       getWorkspaces: () => import_get_workspaces.getWorkspaces,
+      isExperimentalService: () => import_build_utils6.isExperimentalService,
+      isExperimentalServiceV2: () => import_build_utils6.isExperimentalServiceV2,
       isOfficialRuntime: () => import_is_official_runtime.isOfficialRuntime,
       isRouteOwningBuilder: () => import_utils4.isRouteOwningBuilder,
       isStaticBuild: () => import_utils4.isStaticBuild,
       isStaticRuntime: () => import_is_official_runtime.isStaticRuntime,
       monorepoManagers: () => import_monorepo_managers.monorepoManagers,
       packageManagers: () => import_package_managers.packageManagers,
+      resolveAllConfiguredServicesV2: () => import_resolve_v2.resolveAllConfiguredServicesV2,
+      resolveConfiguredServiceV2: () => import_resolve_v2.resolveConfiguredServiceV2,
+      validateServiceConfigV2: () => import_resolve_v2.validateServiceConfigV2,
       workspaceManagers: () => import_workspace_managers.workspaceManagers
     });
     module.exports = __toCommonJS2(src_exports);
     var import_detect_builders = require_detect_builders();
     var import_detect_services2 = require_detect_services();
+    var import_resolve_v2 = require_resolve_v2();
+    var import_build_utils6 = __require("@vercel/build-utils");
     var import_auto_detect = require_auto_detect();
     var import_utils4 = require_utils3();
     var import_get_services_builders = require_get_services_builders();
@@ -36920,7 +37221,7 @@ var require_package = __commonJS({
   "../client/package.json"(exports, module) {
     module.exports = {
       name: "@vercel/client",
-      version: "17.5.8",
+      version: "17.5.10",
       main: "dist/index.js",
       typings: "dist/index.d.ts",
       homepage: "https://vercel.com",

package/dist/chunks/{chunk-QSUXC4XD.js → chunk-J5JWEUV2.js}

@@ -7,10 +7,10 @@ const __dirname = __dirname_(__filename);
 import {
   AGENT_REASON,
   AGENT_STATUS
-} from "./chunk-L6Q2EQPI.js";
+} from "./chunk-LJ5WXXG6.js";
 import {
   getLinkedProject
-} from "./chunk-KFVMKDQD.js";
+} from "./chunk-H3M6DIPE.js";
 import {
   buildCommandWithYes,
   outputAgentError