@vercel/static-build 10.0.1 → 10.0.2

package/dist/index.js

@@ -19035,6 +19035,187 @@ var require_semver3 = __commonJS({
   }
 });
 
+// ../../internals/runtimes/dist/constants.js
+var require_constants2 = __commonJS({
+  "../../internals/runtimes/dist/constants.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var constants_exports = {};
+    __export2(constants_exports, {
+      BUILDER_RUNTIMES: () => BUILDER_RUNTIMES,
+      CONTAINER_ENTRYPOINT_CANDIDATES: () => CONTAINER_ENTRYPOINT_CANDIDATES,
+      ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
+      ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
+      RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
+      RUNTIME_MANIFESTS: () => RUNTIME_MANIFESTS,
+      STATIC_BUILDERS: () => STATIC_BUILDERS
+    });
+    module2.exports = __toCommonJS2(constants_exports);
+    var RUNTIME_BUILDERS = {
+      node: "@vercel/backends",
+      python: "@vercel/python",
+      go: "@vercel/go",
+      rust: "@vercel/rust",
+      ruby: "@vercel/ruby",
+      container: "@vercel/container"
+    };
+    var RUNTIME_MANIFESTS = {
+      node: ["package.json"],
+      python: [
+        "pyproject.toml",
+        "requirements.txt",
+        "Pipfile",
+        "pylock.yml",
+        "uv.lock",
+        "setup.py"
+      ],
+      go: ["go.mod"],
+      ruby: ["Gemfile"],
+      rust: ["Cargo.toml"]
+    };
+    var ENTRYPOINT_EXTENSIONS = {
+      ".ts": "node",
+      ".mts": "node",
+      ".js": "node",
+      ".mjs": "node",
+      ".cjs": "node",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".rb": "ruby",
+      ".ru": "ruby"
+    };
+    var BUILDER_RUNTIMES = Object.fromEntries(
+      Object.entries(RUNTIME_BUILDERS).map(([runtime, builder]) => [
+        builder,
+        runtime
+      ])
+    );
+    var STATIC_BUILDERS = /* @__PURE__ */ new Set([
+      "@vercel/static-build",
+      "@vercel/static"
+    ]);
+    var ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
+      "@vercel/next",
+      "@vercel/backends"
+    ]);
+    var CONTAINER_ENTRYPOINT_CANDIDATES = [
+      "Dockerfile.vercel",
+      "Containerfile.vercel",
+      "Dockerfile",
+      "Containerfile"
+    ];
+  }
+});
+
+// ../../internals/runtimes/dist/framework.js
+var require_framework = __commonJS({
+  "../../internals/runtimes/dist/framework.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var framework_exports = {};
+    __export2(framework_exports, {
+      DETECTION_FRAMEWORKS: () => DETECTION_FRAMEWORKS,
+      filterFrameworksByRuntime: () => filterFrameworksByRuntime,
+      frameworksBySlug: () => frameworksBySlug,
+      inferBuilderRuntimeFromFramework: () => inferBuilderRuntimeFromFramework,
+      inferRuntimeFromFramework: () => inferRuntimeFromFramework,
+      isBFFFramework: () => isBFFFramework,
+      isFrontendFramework: () => isFrontendFramework
+    });
+    module2.exports = __toCommonJS2(framework_exports);
+    var import_build_utils5 = require("@vercel/build-utils");
+    var import_frameworks2 = require_frameworks();
+    var import_constants = require_constants2();
+    var frameworksBySlug = new Map(
+      import_frameworks2.frameworkList.flatMap((f) => typeof f.slug === "string" ? [[f.slug, f]] : [])
+    );
+    var DETECTION_FRAMEWORKS = import_frameworks2.frameworkList.filter(
+      (framework) => !framework.experimental || framework.runtimeFramework
+    );
+    function inferRuntimeFromFramework(framework) {
+      if (!framework)
+        return void 0;
+      if (framework in import_constants.RUNTIME_BUILDERS)
+        return framework;
+      if ((0, import_build_utils5.isPythonFramework)(framework))
+        return "python";
+      if ((0, import_build_utils5.isBackendFramework)(framework))
+        return "node";
+      return void 0;
+    }
+    var STATIC_BUILDER_RUNTIMES = {
+      hugo: "go",
+      jekyll: "ruby",
+      middleman: "ruby",
+      zola: "rust"
+    };
+    function inferBuilderRuntimeFromFramework(framework) {
+      if (!framework || framework === "container" || framework === "services")
+        return void 0;
+      const f = frameworksBySlug.get(framework);
+      const declaredBuilder = f?.useRuntime?.use;
+      if (declaredBuilder)
+        return import_constants.BUILDER_RUNTIMES[declaredBuilder];
+      const detectorItems = [
+        ...f?.detectors?.every ?? [],
+        ...f?.detectors?.some ?? []
+      ];
+      return STATIC_BUILDER_RUNTIMES[framework] ?? (detectorItems.some((d) => d.matchPackage !== void 0) ? "node" : void 0);
+    }
+    function isFrontendFramework(framework) {
+      return !!framework && !inferRuntimeFromFramework(framework);
+    }
+    var BFF_FRAMEWORKS = /* @__PURE__ */ new Set([
+      "nextjs",
+      "nuxtjs",
+      "sveltekit",
+      "remix",
+      "solidstart"
+    ]);
+    function isBFFFramework(framework) {
+      return !!framework && BFF_FRAMEWORKS.has(framework);
+    }
+    function filterFrameworksByRuntime(frameworks2, runtime) {
+      if (!runtime)
+        return [...frameworks2];
+      return frameworks2.filter((f) => inferRuntimeFromFramework(f.slug) === runtime);
+    }
+  }
+});
+
 // ../fs-detectors/dist/is-official-runtime.js
 var require_is_official_runtime = __commonJS({
   "../fs-detectors/dist/is-official-runtime.js"(exports, module2) {
@@ -32212,6 +32393,56 @@ var require_python = __commonJS({
   }
 });
 
+// ../fs-detectors/dist/buildpack-runtimes.js
+var require_buildpack_runtimes = __commonJS({
+  "../fs-detectors/dist/buildpack-runtimes.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var buildpack_runtimes_exports = {};
+    __export2(buildpack_runtimes_exports, {
+      BUILDPACK_PROJECT_MARKERS: () => BUILDPACK_PROJECT_MARKERS,
+      hasBuildpackProjectMarker: () => hasBuildpackProjectMarker,
+      isBuildpackRuntimeEnabled: () => isBuildpackRuntimeEnabled,
+      toBuildpackRuntime: () => toBuildpackRuntime
+    });
+    module2.exports = __toCommonJS2(buildpack_runtimes_exports);
+    var BUILDPACK_PROJECT_MARKERS = /* @__PURE__ */ new Map([["ruby", ["Gemfile"]]]);
+    function isBuildpackRuntimeEnabled(runtime) {
+      return process.env[`VERCEL_EXPERIMENTAL_BUILDPACK_${runtime.toUpperCase()}`] === "1";
+    }
+    function toBuildpackRuntime(runtime) {
+      if (!runtime || !BUILDPACK_PROJECT_MARKERS.has(runtime) || !isBuildpackRuntimeEnabled(runtime)) {
+        return void 0;
+      }
+      return runtime;
+    }
+    async function hasBuildpackProjectMarker(runtime, hasFile) {
+      for (const marker of BUILDPACK_PROJECT_MARKERS.get(runtime) ?? []) {
+        if (await hasFile(marker)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+});
+
 // ../fs-detectors/dist/detect-builders.js
 var require_detect_builders = __commonJS({
   "../fs-detectors/dist/detect-builders.js"(exports, module2) {
@@ -32263,9 +32494,12 @@ var require_detect_builders = __commonJS({
     var import_semver2 = require_semver3();
     var import_path7 = require("path");
     var import_frameworks2 = require_frameworks();
+    var import_framework = require_framework();
+    var import_constants = require_constants2();
     var import_is_official_runtime = require_is_official_runtime();
     var import_build_utils5 = require("@vercel/build-utils");
     var import_python = require_python();
+    var import_buildpack_runtimes = require_buildpack_runtimes();
     var REGEX_MIDDLEWARE_FILES = "middleware.[jt]s";
     var VERCEL_PLATFORM_FILES = [
       "api/**",
@@ -32291,9 +32525,6 @@ var require_detect_builders = __commonJS({
       ].join(",")}}`;
     }
     var REGEX_NON_VERCEL_PLATFORM_FILES2 = getStaticFilesPattern();
-    var slugToFramework = new Map(
-      import_frameworks2.frameworkList.map((f) => [f.slug, f])
-    );
     var builderToFrameworks2 = (() => {
       const map = /* @__PURE__ */ new Map();
       for (const f of import_frameworks2.frameworkList) {
@@ -32378,7 +32609,7 @@ var require_detect_builders = __commonJS({
       };
       const absolutePathCache = /* @__PURE__ */ new Map();
       const { buildCommand, outputDirectory } = projectSettings;
-      const frameworkConfig = slugToFramework.get(framework || "");
+      const frameworkConfig = import_framework.frameworksBySlug.get(framework || "");
       const rustStaticOutput = isRustStaticOutput(framework, projectSettings);
       const ignoreRuntimes = new Set(
         rustStaticOutput ? void 0 : frameworkConfig?.ignoreRuntimes
@@ -32749,6 +32980,14 @@ var require_detect_builders = __commonJS({
           message: `The \`proxy\` property cannot be used with ${framework === "nextjs" ? "Next.js" : "Astro"} because the framework builds its own routing middleware.`
         };
       }
+      const appRuntime = (0, import_framework.inferBuilderRuntimeFromFramework)(framework);
+      const proxyRuntime = import_constants.ENTRYPOINT_EXTENSIONS[(0, import_path7.extname)(proxy.entrypoint)];
+      if (appRuntime !== void 0 && proxyRuntime !== void 0 && appRuntime !== proxyRuntime) {
+        return {
+          code: "proxy_runtime_mismatch",
+          message: `The proxy entrypoint \`${proxy.entrypoint}\` uses the ${proxyRuntime} runtime, but the app uses the ${appRuntime} runtime. The proxy and app must use the same runtime.`
+        };
+      }
       return null;
     }
     function hasBuildScript(pkg) {
@@ -32803,8 +33042,19 @@ var require_detect_builders = __commonJS({
           }
         });
       }
-      const f = slugToFramework.get(framework || "");
+      const f = import_framework.frameworksBySlug.get(framework || "");
       if (f && f.useRuntime && !isRustStaticOutput(framework, projectSettings)) {
+        const buildpackRuntime = (0, import_buildpack_runtimes.toBuildpackRuntime)(framework);
+        if (buildpackRuntime && (import_buildpack_runtimes.BUILDPACK_PROJECT_MARKERS.get(buildpackRuntime) ?? []).some(
+          (marker) => files.includes(marker)
+        )) {
+          config.buildpack = buildpackRuntime;
+          return {
+            src: "<detect>",
+            use: `@vercel/container${withTag}`,
+            config
+          };
+        }
         const { src, use } = f.useRuntime;
         const shouldUseUnifiedBackend = (0, import_build_utils5.isExperimentalBackendsEnabled)() && import_build_utils5.BACKEND_BUILDERS.includes(use);
         const finalUse = shouldUseUnifiedBackend ? import_build_utils5.UNIFIED_BACKEND_BUILDER : use;
@@ -33111,7 +33361,7 @@ var require_detect_builders = __commonJS({
       const framework = frontendBuilder?.config?.framework || "";
       const isGatsby = framework === "gatsby";
       const isNextjs = framework === "nextjs" || (0, import_is_official_runtime.isOfficialRuntime)("next", frontendBuilder?.use);
-      const ignoreRuntimes = slugToFramework.get(framework)?.ignoreRuntimes;
+      const ignoreRuntimes = import_framework.frameworksBySlug.get(framework)?.ignoreRuntimes;
       if (apiRoutes && apiRoutes.length > 0) {
         if (options.featHandleMiss) {
           const extSet = detectApiExtensions2(apiBuilders);
@@ -35982,7 +36232,7 @@ var require_dist8 = __commonJS({
 });
 
 // ../fs-detectors/dist/services/runtimes/constants.js
-var require_constants2 = __commonJS({
+var require_constants3 = __commonJS({
   "../fs-detectors/dist/services/runtimes/constants.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty;
@@ -36064,7 +36314,7 @@ var require_constants2 = __commonJS({
 });
 
 // ../fs-detectors/dist/services/runtimes/framework.js
-var require_framework = __commonJS({
+var require_framework2 = __commonJS({
   "../fs-detectors/dist/services/runtimes/framework.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty;
@@ -36095,7 +36345,7 @@ var require_framework = __commonJS({
     module2.exports = __toCommonJS2(framework_exports);
     var import_build_utils5 = require("@vercel/build-utils");
     var import_frameworks2 = require_frameworks();
-    var import_constants = require_constants2();
+    var import_constants = require_constants3();
     var DETECTION_FRAMEWORKS = import_frameworks2.frameworkList.filter(
       (framework) => !framework.experimental || framework.runtimeFramework
     );
@@ -37089,8 +37339,8 @@ var require_utils5 = __commonJS({
     });
     module2.exports = __toCommonJS2(utils_exports);
     var import_build_utils5 = require("@vercel/build-utils");
-    var import_constants = require_constants2();
-    var import_framework = require_framework();
+    var import_constants = require_constants3();
+    var import_framework = require_framework2();
     async function hasFile(fs5, filePath) {
       try {
         return await fs5.isFile(filePath);
@@ -37214,8 +37464,8 @@ var require_runtime = __commonJS({
       inferRuntime: () => inferRuntime
     });
     module2.exports = __toCommonJS2(runtime_exports);
-    var import_constants = require_constants2();
-    var import_framework = require_framework();
+    var import_constants = require_constants3();
+    var import_framework = require_framework2();
     function getBuilderForRuntime(runtime) {
       const builder = import_constants.RUNTIME_BUILDERS[runtime];
       if (!builder)
@@ -37278,7 +37528,7 @@ var require_entrypoint = __commonJS({
     });
     module2.exports = __toCommonJS2(entrypoint_exports);
     var import_path7 = require("path");
-    var import_constants = require_constants2();
+    var import_constants = require_constants3();
     var PYTHON_MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
     function parsePyModuleAttrEntrypoint(entrypoint) {
       const match = PYTHON_MODULE_ATTR_RE.exec(entrypoint);
@@ -37339,6 +37589,7 @@ var require_detect_framework = __commonJS({
     module2.exports = __toCommonJS2(detect_framework_exports);
     var import_build_utils5 = require("@vercel/build-utils");
     var import_child_process2 = require("child_process");
+    var import_buildpack_runtimes = require_buildpack_runtimes();
     function shouldIncludeExperimentalFrameworks(useExperimentalFrameworks) {
       if (typeof useExperimentalFrameworks === "boolean") {
         return useExperimentalFrameworks;
@@ -37353,7 +37604,10 @@ var require_detect_framework = __commonJS({
       }
       return frameworkList.filter((f) => {
         const experimental = f.experimental;
-        return !experimental;
+        if (!experimental) {
+          return true;
+        }
+        return (0, import_buildpack_runtimes.toBuildpackRuntime)(f.slug) !== void 0;
       });
     }
     async function matches(fs5, framework) {
@@ -37583,7 +37837,7 @@ var require_resolve = __commonJS({
       detectFrameworkFromWorkspace: () => detectFrameworkFromWorkspace,
       getServiceFs: () => getServiceFs,
       inferWorkspaceFromNearestManifest: () => inferWorkspaceFromNearestManifest,
-      resolveAllConfiguredServices: () => resolveAllConfiguredServices,
+      resolveAllConfiguredServices: () => resolveAllConfiguredServices2,
       resolveConfiguredService: () => resolveConfiguredService,
       resolveEntrypointPath: () => resolveEntrypointPath,
       validateServiceConfig: () => validateServiceConfig,
@@ -37592,8 +37846,9 @@ var require_resolve = __commonJS({
     module2.exports = __toCommonJS2(resolve_exports);
     var import_path7 = require("path");
     var import_build_utils5 = require("@vercel/build-utils");
-    var import_constants = require_constants2();
-    var import_framework = require_framework();
+    var import_constants = require_constants3();
+    var import_buildpack_runtimes = require_buildpack_runtimes();
+    var import_framework = require_framework2();
     var import_runtime3 = require_runtime();
     var import_entrypoint = require_entrypoint();
     var import_utils = require_utils5();
@@ -38073,6 +38328,15 @@ var require_resolve = __commonJS({
         };
       }
       if (hasBuilderOrRuntime && !hasFramework && !hasEntrypoint) {
+        const buildpackRuntime = config.builder ? void 0 : (0, import_buildpack_runtimes.toBuildpackRuntime)(config.runtime);
+        if (buildpackRuntime) {
+          const markers = import_buildpack_runtimes.BUILDPACK_PROJECT_MARKERS.get(buildpackRuntime) ?? [];
+          return {
+            code: "BUILDPACK_REQUIRES_SERVICES",
+            message: `Service "${name}" must specify "entrypoint" when using "runtime" with "experimentalServices". Move it to "services" to build without an "entrypoint" from a ${markers.join(" or ")} at the service root.`,
+            serviceName: name
+          };
+        }
         return {
           code: "MISSING_ENTRYPOINT",
           message: `Service "${name}" must specify "entrypoint" when using "${config.builder ? "builder" : "runtime"}".`,
@@ -38273,7 +38537,7 @@ var require_resolve = __commonJS({
         env: config.env
       };
     }
-    async function resolveAllConfiguredServices(services, fs5, routePrefixSource = "configured", options = {}) {
+    async function resolveAllConfiguredServices2(services, fs5, routePrefixSource = "configured", options = {}) {
       const resolved = [];
       const errors = [];
       const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
@@ -38484,11 +38748,13 @@ var require_resolve_v2 = __commonJS({
     var import_path7 = require("path");
     var import_build_utils5 = require("@vercel/build-utils");
     var import_frameworks2 = require_frameworks();
-    var import_constants = require_constants2();
-    var import_framework = require_framework();
+    var import_constants = require_constants3();
+    var import_framework = require_framework2();
     var import_runtime3 = require_runtime();
     var import_entrypoint = require_entrypoint();
+    var import_buildpack_runtimes = require_buildpack_runtimes();
     var import_resolve = require_resolve();
+    var import_utils = require_utils5();
     var frameworksBySlug = new Map(import_frameworks2.frameworkList.map((f) => [f.slug, f]));
     var MAX_SERVICE_NAME_LENGTH = 64;
     var SERVICE_NAME_REGEX = /^[a-z]([a-z_-]*[a-z])?$/;
@@ -38692,7 +38958,23 @@ var require_resolve_v2 = __commonJS({
           entrypoint: entrypointFile
         });
       }
-      if (entrypointIsDirectory && !framework) {
+      const flaggedBuildpackRuntime = (0, import_buildpack_runtimes.toBuildpackRuntime)(
+        inferredRuntime
+      );
+      if (flaggedBuildpackRuntime && config.command !== void 0) {
+        return {
+          error: {
+            code: "INVALID_COMMAND",
+            message: `Service "${name}" can only specify "command" when using runtime "container".`,
+            serviceName: name
+          }
+        };
+      }
+      const buildpackRuntime = flaggedBuildpackRuntime && !entrypointFile && !(0, import_framework.isFrontendFramework)(framework) && await (0, import_buildpack_runtimes.hasBuildpackProjectMarker)(
+        flaggedBuildpackRuntime,
+        (marker) => (0, import_utils.hasFile)(serviceFs, marker)
+      ) ? flaggedBuildpackRuntime : void 0;
+      if (entrypointIsDirectory && !framework && !buildpackRuntime) {
         return {
           error: {
             code: "MISSING_SERVICE_FRAMEWORK",
@@ -38702,7 +38984,7 @@ var require_resolve_v2 = __commonJS({
         };
       }
       const frameworkRuntime = (0, import_framework.inferRuntimeFromFramework)(framework);
-      if (detectedFramework && frameworkRuntime && !entrypointFile) {
+      if (detectedFramework && frameworkRuntime && !entrypointFile && !buildpackRuntime) {
         return {
           error: {
             code: "MISSING_SERVICE_CONFIG",
@@ -38714,7 +38996,10 @@ var require_resolve_v2 = __commonJS({
       const frameworkDefinition = framework ? frameworksBySlug.get(framework) : void 0;
       let builderUse;
       let builderSrc;
-      if (framework) {
+      if (buildpackRuntime) {
+        builderUse = "@vercel/container";
+        builderSrc = "<detect>";
+      } else if (framework) {
         builderUse = (0, import_build_utils5.isNodeBackendFramework)(framework) ? "@vercel/backends" : frameworkDefinition?.useRuntime?.use || "@vercel/static-build";
         builderSrc = entrypointFile || frameworkDefinition?.useRuntime?.src || "package.json";
       } else {
@@ -38749,6 +39034,9 @@ var require_resolve_v2 = __commonJS({
       if (framework) {
         builderConfig.framework = framework;
       }
+      if (buildpackRuntime) {
+        builderConfig.buildpack = buildpackRuntime;
+      }
       if (config.outputDirectory) {
         builderConfig.outputDirectory = config.outputDirectory;
       }
@@ -38864,7 +39152,7 @@ var require_auto_detect = __commonJS({
     module2.exports = __toCommonJS2(auto_detect_exports);
     var import_detect_framework = require_detect_framework();
     var import_frameworks2 = require_frameworks();
-    var import_framework = require_framework();
+    var import_framework = require_framework2();
     var import_utils = require_utils5();
     var FRONTEND_DIR = "frontend";
     var APPS_WEB_DIR = "apps/web";
@@ -39146,7 +39434,7 @@ var require_detect_railway = __commonJS({
     var import_path7 = require("path");
     var import_smol_toml = __toESM2(require_dist());
     var import_detect_framework = require_detect_framework();
-    var import_framework = require_framework();
+    var import_framework = require_framework2();
     var import_utils = require_utils5();
     var RAILWAY_JSON = "railway.json";
     var RAILWAY_TOML = "railway.toml";
@@ -42255,8 +42543,8 @@ var require_detect_render = __commonJS({
     module2.exports = __toCommonJS2(detect_render_exports);
     var import_js_yaml = __toESM2(require_js_yaml4());
     var import_detect_framework = require_detect_framework();
-    var import_constants = require_constants2();
-    var import_framework = require_framework();
+    var import_constants = require_constants3();
+    var import_framework = require_framework2();
     var import_utils = require_utils5();
     var RENDER_YAML = "render.yaml";
     var SERVICE_TYPE_MAP = {
@@ -42477,7 +42765,7 @@ var require_detect_procfile = __commonJS({
     });
     module2.exports = __toCommonJS2(detect_procfile_exports);
     var import_detect_framework = require_detect_framework();
-    var import_framework = require_framework();
+    var import_framework = require_framework2();
     var import_utils = require_utils5();
     var PROCFILE = "Procfile";
     var PROCFILE_LINE_RE = /^\s*([A-Za-z_][A-Za-z0-9_-]*):\s*(.+)/;
@@ -42732,7 +43020,8 @@ var require_detect_services = __commonJS({
     module2.exports = __toCommonJS2(detect_services_exports);
     var import_build_utils5 = require("@vercel/build-utils");
     var import_routing_utils = require_dist8();
-    var import_framework = require_framework();
+    var import_buildpack_runtimes = require_buildpack_runtimes();
+    var import_framework = require_framework2();
     var import_utils = require_utils5();
     var import_resolve = require_resolve();
     var import_resolve_v2 = require_resolve_v2();
@@ -42767,6 +43056,11 @@ var require_detect_services = __commonJS({
         inferred
       };
     }
+    function isBuildpackInferredService(svc) {
+      return (0, import_buildpack_runtimes.toBuildpackRuntime)(
+        svc.runtime ?? (0, import_framework.inferRuntimeFromFramework)(svc.framework)
+      ) !== void 0;
+    }
     function toInferredLayoutConfig(services) {
       const inferredConfig = {};
       for (const [name, service] of Object.entries(services)) {
@@ -42776,7 +43070,7 @@ var require_detect_services = __commonJS({
         if (service.type) {
           serviceConfig.type = service.type;
         }
-        if (typeof service.entrypoint === "string") {
+        if (typeof service.entrypoint === "string" && !isBuildpackInferredService(service)) {
           serviceConfig.entrypoint = service.entrypoint;
         }
         if (typeof service.mountPath === "string") {
@@ -42919,7 +43213,7 @@ var require_detect_services = __commonJS({
           v2Services[name] = {
             root: svc.root,
             ...svc.framework ? { framework: svc.framework } : {},
-            ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {}
+            ...svc.entrypoint && !isBuildpackInferredService(svc) ? { entrypoint: svc.entrypoint } : {}
           };
         }
         const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(v2Services, scopedFs);
@@ -42952,7 +43246,7 @@ var require_detect_services = __commonJS({
         v1Services[name] = {
           root: svc.root === "." ? void 0 : svc.root,
           ...svc.framework ? { framework: svc.framework } : {},
-          ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {},
+          ...svc.entrypoint && !isBuildpackInferredService(svc) ? { entrypoint: svc.entrypoint } : {},
           ...svc.type ? { type: svc.type } : {},
           ...svc.buildCommand ? { buildCommand: svc.buildCommand } : {},
           ...svc.preDeployCommand ? { preDeployCommand: svc.preDeployCommand } : {},
@@ -43126,6 +43420,523 @@ var require_detect_services = __commonJS({
   }
 });
 
+// ../fs-detectors/dist/services/migrate.js
+var require_migrate = __commonJS({
+  "../fs-detectors/dist/services/migrate.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var migrate_exports = {};
+    __export2(migrate_exports, {
+      hasLegacyServicesConfig: () => hasLegacyServicesConfig2,
+      migrateExperimentalServices: () => migrateExperimentalServices2,
+      planExperimentalServicesMigration: () => planExperimentalServicesMigration2
+    });
+    module2.exports = __toCommonJS2(migrate_exports);
+    var import_path7 = require("path");
+    var import_frameworks2 = require_frameworks();
+    var import_constants = require_constants3();
+    var import_resolve = require_resolve();
+    var import_resolve_v2 = require_resolve_v2();
+    var import_utils = require_utils5();
+    var SERVICES_DOCS_URL = "https://vercel.com/docs/services";
+    var SERVICES_ROUTING_DOCS_URL = "https://vercel.com/docs/services/routing";
+    var SERVICES_BINDINGS_DOCS_URL = "https://vercel.com/docs/services/bindings";
+    var EXPERIMENTAL_SERVICES_DOCS_URL = "https://vercel.com/docs/services/experimental";
+    var TOP_LEVEL_BUILD_KEYS = [
+      "functions",
+      "installCommand",
+      "buildCommand",
+      "devCommand",
+      "ignoreCommand",
+      "outputDirectory",
+      "framework"
+    ];
+    var PREVIEW_DOMAIN_MISSING = [
+      { type: "host", value: { suf: ".vercel.app" } },
+      { type: "host", value: { suf: ".vercel.dev" } }
+    ];
+    function hasLegacyServicesConfig2(config) {
+      return isNonEmptyObject(config?.experimentalServices) || isNonEmptyObject(config?.experimentalServicesV2);
+    }
+    function isNonEmptyObject(value) {
+      return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+    }
+    function getServicesConfigConflict(config) {
+      const keys = ["services", "experimentalServices", "experimentalServicesV2"].filter((key) => config[key] !== void 0);
+      if (keys.length > 1) {
+        return {
+          code: "CONFLICTING_SERVICES_CONFIG",
+          message: `Cannot migrate a configuration containing ${keys.map((key) => `\`${key}\``).join(" and ")}. Keep only the configuration you intend to migrate; existing services will not be overwritten or discarded.`
+        };
+      }
+      return void 0;
+    }
+    function normalizePrefix(prefix) {
+      const withSlash = prefix.startsWith("/") ? prefix : `/${prefix}`;
+      return withSlash !== "/" ? withSlash.replace(/\/+$/, "") : withSlash;
+    }
+    function publicRewrite(prefix, service) {
+      return {
+        source: prefix === "/" ? "/(.*)" : `${prefix}(/.*)?`,
+        destination: { service }
+      };
+    }
+    function planExperimentalServicesMigration2(config, resolvedServices) {
+      const conflict = getServicesConfigConflict(config);
+      if (conflict)
+        return emptyPlanWithErrors([conflict]);
+      const plan = emptyPlanWithErrors([]);
+      const legacy = config.experimentalServices;
+      if (isNonEmptyObject(config.experimentalServicesV2)) {
+        plan.patch.services = { ...config.experimentalServicesV2 };
+        plan.removeKeys.push("experimentalServicesV2");
+        return plan;
+      }
+      if (!isNonEmptyObject(legacy)) {
+        plan.errors.push({
+          code: "NO_LEGACY_SERVICES",
+          message: "No `experimentalServices` configuration found to migrate."
+        });
+        return plan;
+      }
+      plan.removeKeys.push("experimentalServices");
+      if (config.experimentalServiceGroups !== void 0) {
+        plan.removeKeys.push("experimentalServiceGroups");
+        plan.warnings.push({
+          code: "SERVICE_GROUPS_DROPPED",
+          message: "`experimentalServiceGroups` has no equivalent in `services` and was removed.",
+          link: SERVICES_DOCS_URL
+        });
+      }
+      const webServices = [];
+      const resolvedByName = new Map(resolvedServices.map((s) => [s.name, s]));
+      for (const [legacyName, serviceConfig] of Object.entries(legacy)) {
+        const resolved = resolvedByName.get(legacyName);
+        if (!resolved) {
+          plan.errors.push({
+            code: "UNRESOLVED_SERVICE",
+            serviceName: legacyName,
+            message: `Service "${legacyName}" could not be resolved. Fix the errors reported for it before migrating.`
+          });
+          continue;
+        }
+        if (resolved.type !== "web") {
+          plan.unmigrated.push(getUnmigratedNote(legacyName, resolved));
+          continue;
+        }
+        const name = legacyName.toLowerCase();
+        if (name.length > 64 || !/^[a-z]([a-z_-]*[a-z])?$/.test(name)) {
+          plan.errors.push({
+            code: "INVALID_SERVICE_NAME",
+            serviceName: legacyName,
+            message: `Service name "${legacyName}" is not valid for \`services\`. Names must be 1-64 characters, start and end with a lowercase letter, and contain only lowercase letters, hyphens, and underscores. Rename it in \`experimentalServices\` first.`
+          });
+          continue;
+        }
+        const conflict2 = webServices.find((s) => s.name === name);
+        if (conflict2) {
+          plan.errors.push({
+            code: "DUPLICATE_SERVICE_NAME",
+            serviceName: legacyName,
+            message: `Services "${conflict2.resolved.name}" and "${legacyName}" both map to "${name}". Rename one of them first.`
+          });
+          continue;
+        }
+        if (name !== legacyName) {
+          plan.renamedServices.push({ from: legacyName, to: name });
+        }
+        webServices.push({
+          name,
+          resolved,
+          config: serviceConfig,
+          prefix: normalizePrefix(resolved.routePrefix ?? "/")
+        });
+      }
+      if (plan.errors.length > 0)
+        return plan;
+      if (webServices.length === 0) {
+        plan.errors.push({
+          code: "NO_WEB_SERVICES",
+          message: "None of the configured services are web services. `services` only describes web services; see the manual steps for the others."
+        });
+        return plan;
+      }
+      for (const consumer of webServices) {
+        plan.patch.services[consumer.name] = convertWebService(
+          consumer,
+          webServices,
+          plan,
+          config.build?.env ?? {}
+        );
+      }
+      const subpaths = webServices.filter((svc) => svc.prefix !== "/").sort((a, b) => b.prefix.length - a.prefix.length);
+      plan.patch.rewrites = subpaths.map(
+        (svc) => publicRewrite(svc.prefix, svc.name)
+      );
+      for (const { name, prefix, resolved } of subpaths) {
+        const { subdomain } = resolved;
+        if (!subdomain)
+          continue;
+        const hostRewrite = {
+          source: "/(.*)",
+          has: [{ type: "host", value: { pre: `${subdomain}.` } }],
+          missing: PREVIEW_DOMAIN_MISSING,
+          destination: { service: name }
+        };
+        if (resolved.builder.use === "@vercel/next") {
+          plan.patch.rewrites.push({
+            ...hostRewrite,
+            source: "/",
+            destination: { service: name, path: prefix }
+          });
+          hostRewrite.source = "/:path(.*)";
+          hostRewrite.destination = { service: name, path: `${prefix}/:path` };
+        }
+        plan.patch.rewrites.push(hostRewrite);
+        plan.warnings.push({
+          code: "SUBDOMAIN_ROUTING",
+          serviceName: resolved.name,
+          message: `"${subdomain}.<your-domain>" routes to "${resolved.name}". Explicit service prefixes take precedence. Host routing still applies only to custom domains, not preview URLs.`,
+          link: SERVICES_ROUTING_DOCS_URL
+        });
+      }
+      plan.patch.rewrites.push(
+        ...webServices.filter((svc) => svc.prefix === "/").map((svc) => publicRewrite("/", svc.name))
+      );
+      const rootService = webServices.find((s) => s.resolved.workspace === ".");
+      for (const key of TOP_LEVEL_BUILD_KEYS) {
+        const value = config[key];
+        if (value === void 0)
+          continue;
+        plan.removeKeys.push(key);
+        if (key === "framework" && (value === "services" || value === null))
+          continue;
+        if (!rootService) {
+          plan.errors.push({
+            code: "TOP_LEVEL_SETTING_WITHOUT_ROOT_SERVICE",
+            message: `Top-level \`${key}\` is not allowed with \`services\` and there is no service with root "." to receive it. Move it into the relevant service manually.`
+          });
+          continue;
+        }
+        const target = plan.patch.services[rootService.name];
+        if (key === "functions") {
+          target.functions = {
+            ...value,
+            ...target.functions
+          };
+        } else if (value !== null && target[key] !== void 0) {
+          plan.warnings.push({
+            code: "TOP_LEVEL_SETTING_CONFLICT",
+            serviceName: rootService.resolved.name,
+            message: `Top-level \`${key}\` was dropped because service "${rootService.resolved.name}" already defines it.`
+          });
+          continue;
+        } else if (value !== null) {
+          target[key] = value;
+        }
+        plan.movedTopLevelKeys.push({ key, service: rootService.name });
+      }
+      if (Array.isArray(config.rewrites) && config.rewrites.length > 0) {
+        plan.warnings.push({
+          code: "EXISTING_REWRITES",
+          message: "Your existing top-level `rewrites` are kept ahead of the generated service rewrites. They are evaluated before a request is routed into a service, so rewrites that target a path inside a specific service should move into that service's own `rewrites`.",
+          link: SERVICES_ROUTING_DOCS_URL
+        });
+      }
+      return plan;
+    }
+    function convertWebService(consumer, webServices, plan, existingBuildEnv) {
+      const { resolved, config: serviceConfig, prefix } = consumer;
+      const { name: legacyName, entrypoint } = resolved;
+      const service = { root: resolved.workspace };
+      const warn = (code, message, link) => {
+        plan.warnings.push({
+          code,
+          serviceName: legacyName,
+          message: `Service "${legacyName}": ${message}`,
+          ...link ? { link } : {}
+        });
+      };
+      if (serviceConfig.framework)
+        service.framework = serviceConfig.framework;
+      const runtime = serviceConfig.runtime;
+      if (runtime) {
+        if (runtime in import_constants.RUNTIME_BUILDERS) {
+          service.runtime = runtime;
+        } else {
+          warn(
+            "RUNTIME_DROPPED",
+            `Runtime "${runtime}" is not supported (${Object.keys(import_constants.RUNTIME_BUILDERS).join(", ")}); it will be inferred from the entrypoint instead.`
+          );
+        }
+      }
+      if (entrypoint) {
+        const handler = resolved.builder.config?.handlerFunction;
+        service.entrypoint = typeof handler === "string" && entrypoint.endsWith(".py") ? `${entrypoint.slice(0, -3).replace(/\//g, ".")}:${handler}` : entrypoint;
+      }
+      if (serviceConfig.command !== void 0) {
+        service.command = serviceConfig.command;
+      }
+      if (serviceConfig.installCommand !== void 0) {
+        service.installCommand = serviceConfig.installCommand;
+      }
+      const buildCommand = (0, import_utils.combineBuildCommand)(
+        serviceConfig.buildCommand,
+        serviceConfig.preDeployCommand
+      );
+      if (buildCommand !== void 0)
+        service.buildCommand = buildCommand;
+      if (serviceConfig.preDeployCommand) {
+        warn(
+          "PRE_DEPLOY_COMMAND_FOLDED",
+          "`preDeployCommand` was appended to `buildCommand` and now runs at build time, not right before deployment."
+        );
+      }
+      if (serviceConfig.builder) {
+        warn(
+          "BUILDER_DROPPED",
+          `Builder "${serviceConfig.builder}" was removed; \`services\` selects it from the framework and runtime.`
+        );
+      }
+      if (serviceConfig.workspace) {
+        warn("WORKSPACE_REPLACED", "`workspace` is now expressed by `root`.");
+      }
+      const fnConfig = {};
+      for (const key of ["maxDuration", "includeFiles", "excludeFiles"]) {
+        if (serviceConfig[key] !== void 0)
+          fnConfig[key] = serviceConfig[key];
+      }
+      if (serviceConfig.memory !== void 0) {
+        warn(
+          "MEMORY_DROPPED",
+          "`memory` cannot be configured in vercel.json with Fluid compute; use the project's Functions settings instead.",
+          "https://vercel.com/docs/functions/configuring-functions/memory"
+        );
+      }
+      if (Object.keys(fnConfig).length > 0) {
+        if (entrypoint && resolved.runtime !== "container") {
+          service.functions = {
+            [import_path7.posix.normalize(entrypoint)]: fnConfig
+          };
+        } else {
+          warn(
+            "FUNCTION_CONFIG_DROPPED",
+            `No file entrypoint for ${Object.keys(fnConfig).join(", ")}; configure them under this service's \`functions\` manually.`
+          );
+        }
+      }
+      const isStatic = (0, import_utils.isStaticBuild)(resolved);
+      const rewrites = [];
+      if (prefix !== "/") {
+        if (isStatic || resolved.builder.use !== "@vercel/next") {
+          rewrites.push({ source: `${prefix}/:path(.*)?`, destination: "/:path" });
+        }
+        if (isStatic) {
+          rewrites.push({ source: "/:path*", destination: "/index.html" });
+          warn(
+            "STATIC_SUBPATH",
+            `Static output is no longer nested under "${prefix}"; a service rewrite maps "${prefix}/*" onto it. Keep the framework base path (e.g. Vite \`base\`) at "${prefix}/".`,
+            SERVICES_ROUTING_DOCS_URL
+          );
+        } else if (resolved.builder.use === "@vercel/next") {
+          warn("NEXT_SUBPATH", `Keep \`basePath\` in next.config at "${prefix}".`);
+        } else {
+          warn(
+            "PREFIX_STRIP",
+            `A service rewrite keeps stripping "${prefix}", but ASGI \`root_path\` / WSGI \`SCRIPT_NAME\` is no longer set. Check redirects and generated URLs; remove the rewrite if the app should handle the prefix itself.`,
+            SERVICES_ROUTING_DOCS_URL
+          );
+        }
+      } else if (isStatic) {
+        rewrites.push({ source: "/(.*)", destination: "/index.html" });
+      }
+      if (rewrites.length > 0)
+        service.rewrites = rewrites;
+      const bindings = [];
+      const seenEnv = /* @__PURE__ */ new Set();
+      const consumerPrefix = import_frameworks2.frameworkList.find(
+        (f) => f.slug === resolved.framework
+      )?.envPrefix;
+      const bindingsUnsupported = resolved.runtime === "go" || resolved.runtime === "rust";
+      const implicit = [];
+      const clientSide = [];
+      const unsupported = [];
+      const add = (target, env, explicit) => {
+        if (seenEnv.has(env))
+          return;
+        seenEnv.add(env);
+        if (consumerPrefix && env.startsWith(consumerPrefix)) {
+          if (Object.prototype.hasOwnProperty.call(existingBuildEnv, env))
+            return;
+          const defaults = (plan.patch.build ??= { env: {} }).env;
+          if (defaults[env] !== void 0 && defaults[env] !== target.prefix) {
+            plan.errors.push({
+              code: "CONFLICTING_BUILD_ENV",
+              serviceName: legacyName,
+              message: `Services use \`${env}\` for different public paths. Set a shared value in \`build.env\` or use distinct environment variable names before migrating.`
+            });
+          } else {
+            defaults[env] = target.prefix;
+          }
+          return;
+        }
+        if (isStatic) {
+          if (explicit) {
+            clientSide.push(`\`${env}="${target.prefix}"\``);
+          }
+          return;
+        }
+        if (bindingsUnsupported) {
+          unsupported.push(`\`${env}\``);
+          return;
+        }
+        if (!explicit)
+          implicit.push(`\`${env}\``);
+        bindings.push({
+          type: "service",
+          service: target.name,
+          format: "url",
+          env
+        });
+      };
+      for (const [env, ref] of Object.entries(serviceConfig.env ?? {})) {
+        if (ref?.type !== "service-ref")
+          continue;
+        const target = webServices.find((s) => s.resolved.name === ref.service);
+        if (!target) {
+          warn(
+            "SERVICE_REF_DROPPED",
+            `\`${env}\` referenced "${ref.service}", which is not a web service and cannot be bound.`
+          );
+          continue;
+        }
+        add(target, env, true);
+      }
+      for (const target of webServices) {
+        const env = `${target.resolved.name.replace(/-/g, "_").toUpperCase()}_URL`;
+        if (target !== consumer) {
+          add(target, env, false);
+        } else if (!seenEnv.has(env)) {
+          seenEnv.add(env);
+          warn(
+            "SELF_SERVICE_URL_DROPPED",
+            `Implicit self URL \`${env}\` is no longer injected; no self-binding was generated. If used at build time or on the server, define a project environment variable with the absolute public URL for "${prefix}" (including the origin), or derive it from the request.`,
+            SERVICES_BINDINGS_DOCS_URL
+          );
+        }
+        if (consumerPrefix)
+          add(target, `${consumerPrefix}${env}`, false);
+      }
+      if (implicit.length > 0) {
+        warn(
+          "IMPLICIT_URL_TO_BINDING",
+          `Previously implicit URLs now use bindings: ${implicit.join(", ")}. These resolve to internal URLs; remove unused bindings.`,
+          SERVICES_BINDINGS_DOCS_URL
+        );
+      }
+      if (clientSide.length > 0) {
+        warn(
+          "CLIENT_SIDE_SERVICE_URL",
+          `Bindings only cover server-side calls. Define any client-side URLs still in use as project environment variables: ${clientSide.join(", ")}.`,
+          SERVICES_BINDINGS_DOCS_URL
+        );
+      }
+      if (unsupported.length > 0) {
+        warn(
+          "BINDINGS_UNSUPPORTED_RUNTIME",
+          `The ${resolved.runtime} runtime does not support bindings; ${unsupported.join(", ")} will no longer be injected. Build a container image to use bindings, or call other services through public URLs.`,
+          SERVICES_BINDINGS_DOCS_URL
+        );
+      }
+      if (bindings.length > 0)
+        service.bindings = bindings;
+      return service;
+    }
+    function getUnmigratedNote(legacyName, resolved) {
+      const isPython = resolved.runtime === "python";
+      let guidance;
+      if (resolved.type === "cron" || resolved.trigger === "schedule") {
+        guidance = isPython ? "Declare the schedule in your Python app (for example with APScheduler in the web service) or expose the job as a route and add it to top-level `crons`." : "Expose the job as a route in a web service and add it to top-level `crons`.";
+      } else if (resolved.trigger === "workflow") {
+        guidance = isPython ? "Declare it as a `[[tool.vercel.workflows]]` entry in the owning service's pyproject.toml." : "Move it into a web service that uses the Workflow SDK.";
+      } else {
+        guidance = isPython ? "Declare it as a `[[tool.vercel.subscribers]]` entry in the owning service's pyproject.toml." : "Move the queue consumer into a web service that subscribes to the topic.";
+      }
+      return {
+        code: "UNSUPPORTED_SERVICE_TYPE",
+        serviceName: legacyName,
+        message: `"${legacyName}" (type "${resolved.type}"${resolved.trigger ? `, trigger "${resolved.trigger}"` : ""}) has no equivalent in \`services\` and was left out. ${guidance}`,
+        link: EXPERIMENTAL_SERVICES_DOCS_URL
+      };
+    }
+    async function migrateExperimentalServices2(options) {
+      const { fs: fs5 } = options;
+      let { config, resolvedServices } = options;
+      if (!config) {
+        const read = await (0, import_utils.readVercelConfig)(fs5);
+        if (read.error)
+          return emptyPlanWithErrors([read.error]);
+        config = read.config ?? {};
+      }
+      const conflict = getServicesConfigConflict(config);
+      if (conflict)
+        return emptyPlanWithErrors([conflict]);
+      if (!resolvedServices && isNonEmptyObject(config.experimentalServices)) {
+        const result = await (0, import_resolve.resolveAllConfiguredServices)(
+          config.experimentalServices,
+          fs5,
+          "configured"
+        );
+        if (result.errors.length > 0) {
+          return emptyPlanWithErrors(result.errors);
+        }
+        resolvedServices = result.services;
+      }
+      const plan = planExperimentalServicesMigration2(
+        config,
+        resolvedServices ?? []
+      );
+      if (plan.errors.length > 0)
+        return plan;
+      const check = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(plan.patch.services, fs5);
+      plan.errors.push(
+        ...check.errors.map((error) => ({
+          ...error,
+          message: `Generated \`services\` config is invalid: ${error.message}`
+        }))
+      );
+      return plan;
+    }
+    function emptyPlanWithErrors(errors) {
+      return {
+        patch: { services: {}, rewrites: [] },
+        removeKeys: [],
+        movedTopLevelKeys: [],
+        renamedServices: [],
+        warnings: [],
+        unmigrated: [],
+        errors
+      };
+    }
+  }
+});
+
 // ../fs-detectors/dist/detect-file-system-api.js
 var require_detect_file_system_api = __commonJS({
   "../fs-detectors/dist/detect-file-system-api.js"(exports, module2) {
@@ -47915,14 +48726,18 @@ var require_dist9 = __commonJS({
       getProxyBuilder: () => import_detect_builders.getProxyBuilder,
       getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
       getWorkspaces: () => import_get_workspaces.getWorkspaces,
+      hasLegacyServicesConfig: () => import_migrate.hasLegacyServicesConfig,
       isExperimentalService: () => import_build_utils5.isExperimentalService,
       isExperimentalServiceV2: () => import_build_utils5.isExperimentalServiceV2,
       isOfficialRuntime: () => import_is_official_runtime.isOfficialRuntime,
       isRouteOwningBuilder: () => import_utils.isRouteOwningBuilder,
       isStaticBuild: () => import_utils.isStaticBuild,
       isStaticRuntime: () => import_is_official_runtime.isStaticRuntime,
+      migrateExperimentalServices: () => import_migrate.migrateExperimentalServices,
       monorepoManagers: () => import_monorepo_managers.monorepoManagers,
       packageManagers: () => import_package_managers.packageManagers,
+      planExperimentalServicesMigration: () => import_migrate.planExperimentalServicesMigration,
+      resolveAllConfiguredServices: () => import_resolve.resolveAllConfiguredServices,
       resolveAllConfiguredServicesV2: () => import_resolve_v2.resolveAllConfiguredServicesV2,
       resolveConfiguredServiceV2: () => import_resolve_v2.resolveConfiguredServiceV2,
       validateProxy: () => import_detect_builders.validateProxy,
@@ -47934,6 +48749,8 @@ var require_dist9 = __commonJS({
     var import_detect_builders = require_detect_builders();
     var import_detect_services = require_detect_services();
     var import_resolve_v2 = require_resolve_v2();
+    var import_resolve = require_resolve();
+    var import_migrate = require_migrate();
     var import_build_utils5 = require("@vercel/build-utils");
     var import_auto_detect = require_auto_detect();
     var import_utils = require_utils5();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-build",
-  "version": "10.0.1",
+  "version": "10.0.2",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/build-step",
@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "ts-morph": "12.0.0",
+    "@vercel/gatsby-plugin-vercel-builder": "2.2.58",
     "@vercel/gatsby-plugin-vercel-analytics": "1.0.12",
-    "@vercel/static-config": "3.4.3",
-    "@vercel/gatsby-plugin-vercel-builder": "2.2.57"
+    "@vercel/static-config": "3.4.3"
   },
   "peerDependencies": {
-    "@vercel/build-utils": "14.10.1"
+    "@vercel/build-utils": "14.10.2"
   },
   "devDependencies": {
     "@types/aws-lambda": "8.10.64",
@@ -41,10 +41,10 @@
     "tree-kill": "1.2.2",
     "vitest": "4.1.10",
     "@vercel/error-utils": "2.2.1",
-    "@vercel/build-utils": "14.10.1",
     "@vercel/frameworks": "3.34.0",
+    "@vercel/build-utils": "14.10.2",
     "@vercel/routing-utils": "6.6.0",
-    "@vercel/fs-detectors": "7.2.5"
+    "@vercel/fs-detectors": "7.6.1"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",