vercel 59.9.1 → 59.10.0

package/dist/commands/build/index.js

@@ -11,21 +11,21 @@ import {
   require_service_schedules,
   require_write_build_result,
   writeBuildResult
-} from "../../chunks/chunk-IWNFDR3C.js";
+} from "../../chunks/chunk-VV5XULGR.js";
 import {
   importBuilders,
   import_import_builders
-} from "../../chunks/chunk-2TXLG52H.js";
+} from "../../chunks/chunk-O6VHU65V.js";
 import {
   js_yaml_default,
   pullCommandLogic
-} from "../../chunks/chunk-PGTGT7AU.js";
+} from "../../chunks/chunk-FNYNYZAZ.js";
 import {
   require_semver
 } from "../../chunks/chunk-IB5L4LKZ.js";
 import {
   readProjectSettings
-} from "../../chunks/chunk-I7ZVTKXM.js";
+} from "../../chunks/chunk-7TYA36S5.js";
 import "../../chunks/chunk-7AEEQOD4.js";
 import "../../chunks/chunk-5XECIWME.js";
 import {
@@ -64,7 +64,7 @@ import {
   resolveProjectCwd,
   ua_default,
   validateConfig
-} from "../../chunks/chunk-OHQJEOP7.js";
+} from "../../chunks/chunk-Z44PATWW.js";
 import "../../chunks/chunk-FXD67VN5.js";
 import {
   TelemetryClient
@@ -275,6 +275,310 @@ var require_execute_builder = __commonJS({
   }
 });
 
+// ../../internals/cli-builder-integration/dist/build-concurrency.js
+var require_build_concurrency = __commonJS({
+  "../../internals/cli-builder-integration/dist/build-concurrency.js"(exports, module) {
+    "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 __toESM2 = (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 build_concurrency_exports = {};
+    __export(build_concurrency_exports, {
+      getInstallScopeKey: () => getInstallScopeKey,
+      groupIntoScopeChains: () => groupIntoScopeChains,
+      resolveBuildConcurrency: () => resolveBuildConcurrency,
+      resolveInstallScopeRoot: () => resolveInstallScopeRoot,
+      runBuildsWithConcurrency: () => runBuildsWithConcurrency,
+      runWithConcurrency: () => runWithConcurrency
+    });
+    module.exports = __toCommonJS(build_concurrency_exports);
+    var import_node_os = __toESM2(__require("os"));
+    var import_node_fs3 = __require("fs");
+    var import_node_path3 = __require("path");
+    var MAX_AUTO_CONCURRENCY = 8;
+    function resolveBuildConcurrency(raw = process.env.VERCEL_EXPERIMENTAL_BUILD_CONCURRENCY) {
+      const value = raw?.trim();
+      if (!value)
+        return 1;
+      const parallelism = Math.max(
+        typeof import_node_os.default.availableParallelism === "function" ? import_node_os.default.availableParallelism() : import_node_os.default.cpus().length,
+        1
+      );
+      if (value.toLowerCase() === "auto") {
+        return Math.min(
+          Math.max(parallelism - 1, 2),
+          MAX_AUTO_CONCURRENCY,
+          parallelism
+        );
+      }
+      if (value.endsWith("%")) {
+        const pct = Number(value.slice(0, -1));
+        if (Number.isFinite(pct) && pct > 0) {
+          return Math.max(1, Math.floor(parallelism * pct / 100));
+        }
+        return 1;
+      }
+      const n = Number(value);
+      return Number.isFinite(n) && n >= 1 ? Math.floor(n) : 1;
+    }
+    async function runWithConcurrency(items, limit, fn, onSecondaryError) {
+      const queue = [...items];
+      const max = Math.max(limit, 1);
+      let active = 0;
+      let failed = false;
+      let firstError;
+      await new Promise((finish) => {
+        const enqueue = (item) => {
+          queue.push(item);
+          pump();
+        };
+        const pump = () => {
+          while (active < max && queue.length > 0 && !failed) {
+            const item = queue.shift();
+            active++;
+            fn(item, enqueue).then(
+              () => {
+                active--;
+                pump();
+              },
+              (err) => {
+                active--;
+                if (failed) {
+                  onSecondaryError?.(err, item);
+                } else {
+                  failed = true;
+                  firstError = err;
+                }
+                pump();
+              }
+            );
+          }
+          if (active === 0)
+            finish();
+        };
+        pump();
+      });
+      if (failed)
+        throw firstError;
+    }
+    function getInstallScopeKey({
+      toolchain,
+      installDirectory,
+      installCommand
+    }) {
+      return JSON.stringify([
+        toolchain,
+        (0, import_node_path3.normalize)(installDirectory),
+        typeof installCommand === "string" ? ["cmd", installCommand.trim()] : "default"
+      ]);
+    }
+    var NODE_LOCKFILES = [
+      "pnpm-lock.yaml",
+      "yarn.lock",
+      "package-lock.json",
+      "npm-shrinkwrap.json",
+      "bun.lock",
+      "bun.lockb"
+    ];
+    async function fileExists(path) {
+      try {
+        await import_node_fs3.promises.stat(path);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    var SERVICE_DIR_TOOLCHAINS = /* @__PURE__ */ new Set(["go", "ruby", "rust", "container"]);
+    async function resolveInstallScopeRoot({
+      toolchain,
+      serviceDir,
+      ceilingDir
+    }) {
+      if (toolchain !== "node" && toolchain !== "python") {
+        return SERVICE_DIR_TOOLCHAINS.has(toolchain) ? (0, import_node_path3.normalize)(serviceDir) : (0, import_node_path3.normalize)(ceilingDir);
+      }
+      const ceiling = (0, import_node_path3.normalize)(ceilingDir);
+      let dir = (0, import_node_path3.normalize)(serviceDir);
+      if (dir !== ceiling && !dir.startsWith(ceiling + import_node_path3.sep)) {
+        return dir;
+      }
+      let nearestLockfileDir;
+      let nearestPackageJsonDir;
+      let done = false;
+      while (!done) {
+        if (toolchain === "node") {
+          if (nearestLockfileDir === void 0) {
+            for (const lockfile of NODE_LOCKFILES) {
+              if (await fileExists((0, import_node_path3.join)(dir, lockfile))) {
+                nearestLockfileDir = dir;
+                break;
+              }
+            }
+          }
+          if (await fileExists((0, import_node_path3.join)(dir, "pnpm-workspace.yaml")))
+            return dir;
+          try {
+            const pkg = JSON.parse(
+              await import_node_fs3.promises.readFile((0, import_node_path3.join)(dir, "package.json"), "utf8")
+            );
+            if (pkg && typeof pkg === "object") {
+              if ("workspaces" in pkg)
+                return dir;
+              nearestPackageJsonDir ??= dir;
+            }
+          } catch {
+          }
+        } else {
+          try {
+            const pyproject = await import_node_fs3.promises.readFile(
+              (0, import_node_path3.join)(dir, "pyproject.toml"),
+              "utf8"
+            );
+            if (pyproject.includes("[tool.uv.workspace]"))
+              return dir;
+          } catch {
+          }
+        }
+        const parent = (0, import_node_path3.dirname)(dir);
+        done = dir === ceiling || parent === dir;
+        dir = parent;
+      }
+      return nearestLockfileDir ?? nearestPackageJsonDir ?? (0, import_node_path3.normalize)(serviceDir);
+    }
+    async function runBuildsWithConcurrency({
+      builds,
+      concurrency,
+      isEligible,
+      resolveScope,
+      forceSingleChain,
+      runBuild,
+      log,
+      reportSecondaryError
+    }) {
+      if (concurrency <= 1) {
+        for (const build of builds) {
+          await runBuild(build, false);
+        }
+        return;
+      }
+      const parallelBuilds = [];
+      const sequentialBuilds = [];
+      for (const build of builds) {
+        (isEligible(build) ? parallelBuilds : sequentialBuilds).push(build);
+      }
+      if (parallelBuilds.length > 0) {
+        let chains;
+        let siblingsOf;
+        if (forceSingleChain) {
+          chains = [parallelBuilds];
+          siblingsOf = /* @__PURE__ */ new Map();
+        } else {
+          const scopeByBuild = /* @__PURE__ */ new Map();
+          for (const build of parallelBuilds) {
+            scopeByBuild.set(build, await resolveScope(build));
+          }
+          ({ chains, siblingsOf } = groupIntoScopeChains(
+            parallelBuilds,
+            (build) => scopeByBuild.get(build)
+          ));
+        }
+        log(
+          `Running ${parallelBuilds.length} builds across ${chains.length} install scope${chains.length === 1 ? "" : "s"} (concurrency ${concurrency})`
+        );
+        let abortedRun = false;
+        const activeBuildOfChain = /* @__PURE__ */ new Map();
+        await runWithConcurrency(
+          chains,
+          concurrency,
+          async (chain, enqueue) => {
+            for (const build of chain) {
+              if (abortedRun)
+                return;
+              activeBuildOfChain.set(chain, build);
+              try {
+                await runBuild(build, true);
+              } catch (err) {
+                abortedRun = true;
+                throw err;
+              }
+              const siblings = siblingsOf.get(build);
+              if (siblings) {
+                for (const sibling of siblings)
+                  enqueue([sibling]);
+              }
+            }
+          },
+          (err, chain) => {
+            const build = activeBuildOfChain.get(chain);
+            if (build !== void 0)
+              reportSecondaryError(err, build);
+          }
+        );
+      }
+      for (const build of sequentialBuilds) {
+        await runBuild(build, false);
+      }
+    }
+    function groupIntoScopeChains(items, scopeOf) {
+      const chainByOuter = /* @__PURE__ */ new Map();
+      const leaderByInnerByOuter = /* @__PURE__ */ new Map();
+      const siblingsOf = /* @__PURE__ */ new Map();
+      for (const item of items) {
+        const scope = scopeOf(item);
+        let chain = chainByOuter.get(scope.outerKey);
+        if (!chain) {
+          chain = [];
+          chainByOuter.set(scope.outerKey, chain);
+        }
+        let leaderByInner = leaderByInnerByOuter.get(scope.outerKey);
+        if (!leaderByInner) {
+          leaderByInner = /* @__PURE__ */ new Map();
+          leaderByInnerByOuter.set(scope.outerKey, leaderByInner);
+        }
+        const leader = leaderByInner.get(scope.innerKey);
+        if (leader === void 0) {
+          leaderByInner.set(scope.innerKey, item);
+          chain.push(item);
+        } else if (scope.siblingsSkipInstall) {
+          let siblings = siblingsOf.get(leader);
+          if (!siblings) {
+            siblings = [];
+            siblingsOf.set(leader, siblings);
+          }
+          siblings.push(item);
+        } else {
+          chain.push(item);
+        }
+      }
+      return { chains: Array.from(chainByOuter.values()), siblingsOf };
+    }
+  }
+});
+
 // ../../internals/cli-builder-integration/dist/backend-rewrite-warning.js
 var require_backend_rewrite_warning = __commonJS({
   "../../internals/cli-builder-integration/dist/backend-rewrite-warning.js"(exports, module) {
@@ -1280,7 +1584,8 @@ var require_corepack = __commonJS({
       repoRootPath,
       output,
       readJSONFile: readJSONFile2,
-      isCantParseJSONFile
+      isCantParseJSONFile,
+      warmPackageManager = false
     }) {
       if (process.env.ENABLE_EXPERIMENTAL_COREPACK !== "1") {
         return null;
@@ -1316,6 +1621,18 @@ var require_corepack = __commonJS({
             prettyCommand: `corepack enable ${pkgManagerName}`
           }
         );
+        if (warmPackageManager) {
+          try {
+            await (0, import_build_utils3.spawnAsync)(pkgManagerName, ["--version"], {
+              prettyCommand: `${pkgManagerName} --version`,
+              stdio: "pipe"
+            });
+          } catch (err) {
+            output.debug(
+              `Failed to pre-download "${pkg.packageManager}" via corepack: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
         return corepackShimDir;
       }
       return null;
@@ -1384,6 +1701,7 @@ var require_do_build = __commonJS({
     var import_write_build_result3 = require_write_build_result();
     var import_build_runner2 = require_build_runner();
     var import_execute_builder = require_execute_builder();
+    var import_build_concurrency = require_build_concurrency();
     var import_backend_rewrite_warning = require_backend_rewrite_warning();
     var import_service_route_ownership = require_service_route_ownership();
     var import_service_schedules = require_service_schedules();
@@ -1418,13 +1736,6 @@ var require_do_build = __commonJS({
     function hasNonEmptyObject(value) {
       return value != null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
     }
-    function unsetServiceBuildImmutableEnvVars(restoreEnv) {
-      for (const key of SERVICE_BUILD_IMMUTABLE_ENV_VARS) {
-        if (!restoreEnv.has(key))
-          restoreEnv.set(key, process.env[key]);
-        delete process.env[key];
-      }
-    }
     function getGeneratedServiceAlreadyBuiltWarning(service) {
       const framework = service.framework ?? "unknown";
       const entrypoint = service.entrypoint ?? service.builder.src ?? "unknown";
@@ -1445,6 +1756,7 @@ var require_do_build = __commonJS({
       const {
         output,
         createBuildRunner: createBuildRunner2,
+        canBuildInSubprocess: canBuildInSubprocess2,
         importBuilders: importBuilders2,
         formatResolvedBuilders: formatResolvedBuilders2,
         writeBuildResult: writeBuildResult2,
@@ -1467,7 +1779,8 @@ var require_do_build = __commonJS({
           repoRootPath,
           output,
           readJSONFile: readJSONFile2,
-          isCantParseJSONFile
+          isCantParseJSONFile,
+          warmPackageManager: (0, import_build_concurrency.resolveBuildConcurrency)() > 1
         });
         const installDepsSpan = span.child("vc.installDeps");
         let installRan = false;
@@ -1805,7 +2118,8 @@ var require_do_build = __commonJS({
           repoRootPath,
           output,
           readJSONFile: readJSONFile2,
-          isCantParseJSONFile
+          isCantParseJSONFile,
+          warmPackageManager: (0, import_build_concurrency.resolveBuildConcurrency)() > 1
         });
       }
       const diagnostics = {};
@@ -1824,11 +2138,12 @@ var require_do_build = __commonJS({
       }
       const preDeployEntries = [];
       const liveRunners = /* @__PURE__ */ new Set();
+      const buildOrdinals = /* @__PURE__ */ new Map();
       const runBuilders = async (buildsToRun) => {
         await addBuildsToBuildJson(buildsToRun);
-        for (const build of (0, import_execute_builder.sortBuildsForExecution)(buildsToRun)) {
+        const buildOne = async (build, concurrent) => {
           if (typeof build.src !== "string")
-            continue;
+            return;
           const builderWithPkg = buildersWithPkgs.get(build.use);
           if (!builderWithPkg) {
             throw new Error(`Failed to load Builder "${build.use}"`);
@@ -1856,6 +2171,16 @@ var require_do_build = __commonJS({
                 `Service "${service.name}": workspace-rooted build at "${buildWorkPath}", entrypoint "${buildEntrypoint}" (original: "${build.src}")`
               );
             }
+            const restoreEnv = /* @__PURE__ */ new Map();
+            const perBuildEnv = concurrent ? { ...process.env } : process.env;
+            const setBuildEnv = (key, value) => {
+              if (!concurrent)
+                restoreEnv.set(key, process.env[key]);
+              if (value === void 0)
+                delete perBuildEnv[key];
+              else
+                perBuildEnv[key] = value;
+            };
             const settingsForEnv = service ? {
               buildCommand: service.buildCommand ?? void 0,
               installCommand: service.installCommand ?? void 0,
@@ -1870,19 +2195,15 @@ var require_do_build = __commonJS({
             ]) {
               const value = settingsForEnv[key];
               const envKey = `VERCEL_PROJECT_SETTINGS_` + key.replace(/[A-Z]/g, (letter) => `_${letter}`).toUpperCase();
+              setBuildEnv(envKey, typeof value === "string" ? value : void 0);
               if (typeof value === "string") {
-                process.env[envKey] = value;
                 output.debug(`Setting env ${envKey} to "${value}"`);
-              } else {
-                delete process.env[envKey];
               }
             }
             const isFrontendBuilder = build.config && "framework" in build.config;
             const builderFramework = build.config?.framework ?? projectSettings.framework;
-            const apiDirFramework = isZeroConfig && !service && !isFrontendBuilder ? await apiDirFrameworkDetector.detect(
-              build.use ?? "",
-              buildWorkPath
-            ) : void 0;
+            const isApiDir = isZeroConfig && !service && !isFrontendBuilder;
+            const apiDirFramework = isApiDir ? await apiDirFrameworkDetector.detect(build.use ?? "", buildWorkPath) : void 0;
             let buildConfig;
             if (isZeroConfig) {
               if (service) {
@@ -1937,7 +2258,10 @@ var require_do_build = __commonJS({
             const serviceRoutePrefix = build.config?.routePrefix;
             const serviceConfigWorkspace = build.config?.workspace;
             const preDeployCmd = legacyExperimentalService?.preDeployCommand?.trim();
-            const preDeployEntry = preDeployCmd && service ? { service: service.name } : void 0;
+            const preDeployEntry = preDeployCmd && service ? {
+              ordinal: buildOrdinals.get(build) ?? Number.MAX_SAFE_INTEGER,
+              service: service.name
+            } : void 0;
             if (preDeployEntry) {
               preDeployEntries.push(preDeployEntry);
             }
@@ -1970,7 +2294,6 @@ var require_do_build = __commonJS({
             output.debug(
               `Building entrypoint "${build.src}" with "${builderPkg.name}"`
             );
-            const restoreEnv = /* @__PURE__ */ new Map();
             if (detectedServices && legacyExperimentalService?.env) {
               const perServiceEnv = (0, import_build_utils3.getServiceUrlEnvVars)({
                 requestedEnv: legacyExperimentalService.env,
@@ -1983,13 +2306,14 @@ var require_do_build = __commonJS({
               for (const [key, value] of Object.entries(perServiceEnv)) {
                 if (key in process.env)
                   continue;
-                restoreEnv.set(key, process.env[key]);
-                process.env[key] = value;
+                setBuildEnv(key, value);
                 output.debug(`Injected service URL env var: ${key}=${value}`);
               }
             }
             if (service) {
-              unsetServiceBuildImmutableEnvVars(restoreEnv);
+              for (const key of SERVICE_BUILD_IMMUTABLE_ENV_VARS) {
+                setBuildEnv(key, void 0);
+              }
             }
             let buildResult;
             let rawBuildResult;
@@ -1998,7 +2322,8 @@ var require_do_build = __commonJS({
               buildOptions,
               cwd: buildWorkPath,
               expectsPreDeploy: Boolean(preDeployCmd),
-              builderSpan
+              builderSpan,
+              env: perBuildEnv
             };
             const runner = createBuildRunner2?.({
               ctx: runnerContext,
@@ -2007,6 +2332,11 @@ var require_do_build = __commonJS({
               builderPath: builderWithPkg.path,
               hasBuildCallback: Boolean(buildOptions.buildCallback)
             }) ?? new import_build_runner2.InprocessBuildRunner(runnerContext, builder);
+            if (concurrent && runner instanceof import_build_runner2.InprocessBuildRunner) {
+              throw new Error(
+                `Internal error: build for "${buildOptions.entrypoint}" was scheduled concurrently but cannot run in a subprocess`
+              );
+            }
             liveRunners.add(runner);
             try {
               ({ buildResult, rawBuildResult } = await (0, import_execute_builder.executeBuilder)({
@@ -2050,21 +2380,28 @@ var require_do_build = __commonJS({
                           );
                         } else {
                           const workspace = service && serviceWorkspace && serviceWorkspace !== "." ? serviceWorkspace : ".";
-                          const alreadyPushed = packageManifests.some(
+                          const buildType = packageManifest.buildType ?? (buildConfig.middleware === true ? "middleware" : isApiDir ? "api-dir" : "app");
+                          const entry = {
+                            ordinal: buildOrdinals.get(build) ?? Number.MAX_SAFE_INTEGER,
+                            workspace,
+                            key: fullKey,
+                            buildConfig,
+                            manifest: {
+                              ...packageManifest,
+                              framework: packageManifest.framework ?? apiDirFramework,
+                              buildType
+                            },
+                            service,
+                            builderUse: builderPkg.name
+                          };
+                          const existingIndex = packageManifests.findIndex(
                             (m) => m.builderUse === builderPkg.name && m.workspace === workspace
                           );
-                          if (!alreadyPushed) {
-                            packageManifests.push({
-                              workspace,
-                              key: fullKey,
-                              buildConfig,
-                              manifest: {
-                                ...packageManifest,
-                                framework: packageManifest.framework ?? apiDirFramework
-                              },
-                              service,
-                              builderUse: builderPkg.name
-                            });
+                          const existing = existingIndex === -1 ? void 0 : packageManifests[existingIndex];
+                          if (!existing) {
+                            packageManifests.push(entry);
+                          } else if (entry.ordinal < existing.ordinal) {
+                            packageManifests[existingIndex] = entry;
                           }
                         }
                       } catch (e) {
@@ -2156,12 +2493,15 @@ var require_do_build = __commonJS({
                 const cronEntrypoint = legacyExperimentalService.entrypoint || legacyExperimentalService.builder.src || "index";
                 for (const schedule of staticSchedules) {
                   synthesizedServiceCrons.push({
-                    path: (0, import_build_utils3.getInternalServiceCronPath)(
-                      legacyExperimentalService.name,
-                      cronEntrypoint,
-                      legacyExperimentalService.handlerFunction || "cron"
-                    ),
-                    schedule
+                    ordinal: buildOrdinals.get(build) ?? Number.MAX_SAFE_INTEGER,
+                    cron: {
+                      path: (0, import_build_utils3.getInternalServiceCronPath)(
+                        legacyExperimentalService.name,
+                        cronEntrypoint,
+                        legacyExperimentalService.handlerFunction || "cron"
+                      ),
+                      schedule
+                    }
                   });
                 }
               } else {
@@ -2257,8 +2597,12 @@ var require_do_build = __commonJS({
               ops.push(
                 writeBuildResultPromise.then(
                   (override) => {
-                    if (override)
-                      overrides.push(override);
+                    if (override) {
+                      overrides.push({
+                        ordinal: buildOrdinals.get(build) ?? Number.MAX_SAFE_INTEGER,
+                        override
+                      });
+                    }
                   },
                   (err) => err
                 )
@@ -2278,7 +2622,71 @@ var require_do_build = __commonJS({
               )
             );
           }
+        };
+        const sortedBuilds = (0, import_execute_builder.sortBuildsForExecution)(buildsToRun);
+        for (const build of sortedBuilds) {
+          if (!buildOrdinals.has(build)) {
+            buildOrdinals.set(build, buildOrdinals.size);
+          }
         }
+        const concurrency = createBuildRunner2 && canBuildInSubprocess2 ? (0, import_build_concurrency.resolveBuildConcurrency)() : 1;
+        await (0, import_build_concurrency.runBuildsWithConcurrency)({
+          builds: sortedBuilds,
+          concurrency,
+          isEligible: (build) => {
+            const bp = typeof build.src === "string" ? buildersWithPkgs.get(build.use) : void 0;
+            return !!bp && !!canBuildInSubprocess2 && canBuildInSubprocess2({
+              hasDetectedServices: getHasDetectedServices(),
+              builderPath: bp.path
+            });
+          },
+          // Generated services flow:
+          // each build READS the shared `outputDir/config.json` to inherit
+          // sibling-emitted services fields while siblings WRITE
+          // it, so what a build inherits is execution-order-dependent.
+          forceSingleChain: !hasExperimentalServicesV1ConfiguredInVercelConfig && !hasExperimentalServicesV2ConfiguredInVercelConfig,
+          resolveScope: async (build) => {
+            const service = getHasDetectedServices() && typeof build.src === "string" ? serviceByBuilder.get(build) : void 0;
+            if (!service) {
+              const key = "no-service-context";
+              return {
+                outerKey: key,
+                innerKey: `${key}:${build.use}:${String(build.src)}`,
+                siblingsSkipInstall: false
+              };
+            }
+            const serviceWorkspace = (0, import_build_utils3.isExperimentalService)(service) ? service.workspace : service.root;
+            const serviceDir = serviceWorkspace && serviceWorkspace !== "." ? (0, import_path2.join)(workPath, serviceWorkspace) : workPath;
+            const toolchain = service.runtime ?? ["python", "go", "ruby", "rust", "container"].find(
+              (t) => build.use.startsWith(`@vercel/${t}`)
+            ) ?? "node";
+            const customInstall = Boolean(service.installCommand?.trim());
+            const installRoot = await (0, import_build_concurrency.resolveInstallScopeRoot)({
+              toolchain,
+              serviceDir,
+              ceilingDir: repoRootPath
+            });
+            return {
+              outerKey: `${toolchain}:${installRoot}`,
+              innerKey: (0, import_build_concurrency.getInstallScopeKey)({
+                toolchain,
+                installDirectory: serviceDir,
+                installCommand: service.installCommand
+              }),
+              // Only Node default installs are deduped across workers via the
+              // merged-back `meta.runNpmInstallSet`, custom commands and other
+              // toolchains would re-run a real install.
+              siblingsSkipInstall: toolchain === "node" && !customInstall
+            };
+          },
+          runBuild: (build, concurrent) => buildOne(build, concurrent),
+          log: (message) => output.log(message),
+          reportSecondaryError: (err, build) => {
+            output.error(
+              `Build failed for "${build.src}": ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        });
       };
       const flushOps = async () => {
         const errors = await Promise.all(ops.splice(0));
@@ -2325,9 +2733,19 @@ var require_do_build = __commonJS({
           zeroConfigFallbackRoutes.push(...serviceRoutes.fallbacks);
         }
       };
+      const sortBuildResultsByOrdinal = () => {
+        const orderedResults = Array.from(buildResults.entries()).sort(
+          ([a], [b]) => (buildOrdinals.get(a) ?? Number.MAX_SAFE_INTEGER) - (buildOrdinals.get(b) ?? Number.MAX_SAFE_INTEGER)
+        );
+        buildResults.clear();
+        for (const [build, result] of orderedResults) {
+          buildResults.set(build, result);
+        }
+      };
       try {
         await runBuilders(builds);
         await flushOps();
+        sortBuildResultsByOrdinal();
         if (!hasExperimentalServicesV1ConfiguredInVercelConfig && !hasExperimentalServicesV2ConfiguredInVercelConfig) {
           const generatedConfigPath = (0, import_path2.join)(outputDir, "config.json");
           const generatedConfig = await readJSONFile2(generatedConfigPath);
@@ -2436,6 +2854,7 @@ var require_do_build = __commonJS({
             }
           }
         }
+        preDeployEntries.sort((a, b) => a.ordinal - b.ordinal);
         for (const entry of preDeployEntries) {
           if (entry.callback) {
             await entry.callback();
@@ -2446,6 +2865,11 @@ var require_do_build = __commonJS({
           }
         }
       } finally {
+        const settled = await Promise.all(ops.splice(0));
+        for (const err of settled) {
+          if (err)
+            ops.push(Promise.resolve(err));
+        }
         for (const runner of liveRunners) {
           try {
             runner.teardown();
@@ -2456,6 +2880,8 @@ var require_do_build = __commonJS({
           }
         }
       }
+      sortBuildResultsByOrdinal();
+      packageManifests.sort((a, b) => a.ordinal - b.ordinal);
       await (0, import_manifest.writeManifests)(packageManifests, diagnostics, ops, outputDir);
       if (corepackShimDir) {
         (0, import_corepack.cleanupCorepack)(corepackShimDir);
@@ -2508,7 +2934,10 @@ var require_do_build = __commonJS({
           }
         }
         if (existingConfig.overrides && !nestExperimentalServicesV2Output) {
-          overrides.push(existingConfig.overrides);
+          overrides.push({
+            ordinal: Number.MAX_SAFE_INTEGER,
+            override: existingConfig.overrides
+          });
         }
       }
       const topLevelBuildResults = nestExperimentalServicesV2Output ? new Map(
@@ -2556,8 +2985,9 @@ var require_do_build = __commonJS({
         localConfig.images,
         topLevelBuildResults.values()
       );
+      const orderedServiceCrons = synthesizedServiceCrons.slice().sort((a, b) => a.ordinal - b.ordinal).map((entry) => entry.cron);
       const mergedCrons = mergeCrons(
-        [...localConfig.crons || [], ...synthesizedServiceCrons],
+        [...localConfig.crons || [], ...orderedServiceCrons],
         buildResults.values()
       );
       const mergedWildcard = mergeWildcard(topLevelBuildResults.values());
@@ -2585,7 +3015,8 @@ var require_do_build = __commonJS({
         }
       }
       const topLevelBuildResultOverrides = Array.from(topLevelBuildResults.values()).map((result) => "overrides" in result ? result.overrides : void 0).filter((value) => Boolean(value));
-      const mergedOverrides = overrides.length > 0 || topLevelBuildResultOverrides.length > 0 ? Object.assign({}, ...overrides, ...topLevelBuildResultOverrides) : void 0;
+      const orderedOverrides = overrides.slice().sort((a, b) => a.ordinal - b.ordinal).map((entry) => entry.override);
+      const mergedOverrides = overrides.length > 0 || topLevelBuildResultOverrides.length > 0 ? Object.assign({}, ...orderedOverrides, ...topLevelBuildResultOverrides) : void 0;
       const framework = topLevelBuildResults.size > 0 ? await getFramework(workPath, topLevelBuildResults) : void 0;
       const explicitRootRoutes = appendBuildOutputRouteTables(
         routesResult.routes,
@@ -3119,12 +3550,24 @@ function toError(error) {
     return error;
   return Object.assign(new Error(), error);
 }
+function mergeWorkerMeta(target, workerMeta) {
+  for (const [key, value] of Object.entries(workerMeta)) {
+    const existing = target[key];
+    if (existing instanceof Set && value instanceof Set) {
+      for (const entry of value) {
+        existing.add(entry);
+      }
+    } else if (existing === true && typeof value !== "object") {
+    } else {
+      target[key] = value;
+    }
+  }
+}
 function canBuildInSubprocess({
   hasDetectedServices,
-  builderPath,
-  hasBuildCallback
+  builderPath
 }) {
-  return hasDetectedServices && Boolean(builderPath) && !hasBuildCallback;
+  return hasDetectedServices && Boolean(builderPath);
 }
 function rehydrateFile(obj) {
   if (obj.type === "FileBlob") {
@@ -3212,7 +3655,7 @@ var SubprocessBuildRunner = class extends import_build_runner.BuildRunner {
     const child = fork(workerPath, [], {
       cwd: this.ctx.cwd,
       execArgv: [],
-      env: process.env,
+      env: this.ctx.env ?? process.env,
       // V8 structured clone (not the default JSON) so the build result rides across with its
       // Buffers, cycles (e.g. `@vercel/next`'s `childProcesses`), and shared object identity
       // (one Lambda referenced by many outputs stays one instance) intact.
@@ -3254,7 +3697,7 @@ var SubprocessBuildRunner = class extends import_build_runner.BuildRunner {
       const buildResult = message.result;
       rehydrateResult(buildResult, message.outputVersion);
       if (this.ctx.buildOptions.meta && message.meta) {
-        Object.assign(this.ctx.buildOptions.meta, message.meta);
+        mergeWorkerMeta(this.ctx.buildOptions.meta, message.meta);
       }
       if (message.hasPreDeploy) {
         child.on("close", (code, signal) => {
@@ -3587,13 +4030,11 @@ function normalizeRelative(p) {
 function createBuildRunner({
   ctx,
   hasDetectedServices,
-  builderPath,
-  hasBuildCallback
+  builderPath
 }) {
   return canBuildInSubprocess({
     hasDetectedServices,
-    builderPath,
-    hasBuildCallback
+    builderPath
   }) ? new SubprocessBuildRunner(ctx) : void 0;
 }
 function buildCommandWithGlobalFlags(baseSubcommand, argv) {
@@ -3901,6 +4342,7 @@ async function main(client) {
           {
             output: output_manager_default,
             createBuildRunner,
+            canBuildInSubprocess,
             importBuilders,
             formatResolvedBuilders: import_import_builders.formatResolvedBuilders,
             writeBuildResult,