vercel 59.1.4 → 59.3.0

package/dist/chunks/{chunk-SQGMTRZD.js → chunk-D35JUCTC.js}

@@ -18,10 +18,10 @@ import {
   require_lib,
   require_minimatch,
   require_pluralize
-} from "./chunk-VE545BR3.js";
+} from "./chunk-KDL2L4KL.js";
 import {
   isNativeBinaryInstall
-} from "./chunk-ECCWJHC6.js";
+} from "./chunk-CYNB6LL4.js";
 import {
   CantParseJSONFile,
   cmd,
@@ -629,8 +629,8 @@ var require_osenv = __commonJS({
 var require_npa = __commonJS({
   "../../node_modules/.pnpm/npm-package-arg@6.1.0/node_modules/npm-package-arg/npa.js"(exports, module) {
     "use strict";
-    module.exports = npa2;
-    module.exports.resolve = resolve2;
+    module.exports = npa;
+    module.exports.resolve = resolve;
     module.exports.Result = Result;
     var url;
     var HostedGit;
@@ -642,16 +642,16 @@ var require_npa = __commonJS({
     var hasSlashes = isWindows ? /\\|[/]/ : /[/]/;
     var isURL = /^(?:git[+])?[a-z]+:/i;
     var isFilename = /[.](?:tgz|tar.gz|tar)$/i;
-    function npa2(arg, where) {
+    function npa(arg, where) {
       let name;
       let spec;
       if (typeof arg === "object") {
         if (arg instanceof Result && (!where || where === arg.where)) {
           return arg;
         } else if (arg.name && arg.rawSpec) {
-          return npa2.resolve(arg.name, arg.rawSpec, where || arg.where);
+          return npa.resolve(arg.name, arg.rawSpec, where || arg.where);
         } else {
-          return npa2(arg.raw, where || arg.where);
+          return npa(arg.raw, where || arg.where);
         }
       }
       const nameEndsAt = arg[0] === "@" ? arg.slice(1).indexOf("@") + 1 : arg.indexOf("@");
@@ -666,17 +666,17 @@ var require_npa = __commonJS({
       } else {
         if (!validatePackageName)
           validatePackageName = require_validate_npm_package_name();
-        const valid2 = validatePackageName(arg);
-        if (valid2.validForOldPackages) {
+        const valid = validatePackageName(arg);
+        if (valid.validForOldPackages) {
           name = arg;
         } else {
           spec = arg;
         }
       }
-      return resolve2(name, spec, where, arg);
+      return resolve(name, spec, where, arg);
     }
     var isFilespec = isWindows ? /^(?:[.]|~[/]|[/\\]|[a-zA-Z]:)/ : /^(?:[.]|~[/]|[/]|[a-zA-Z]:)/;
-    function resolve2(name, spec, where, arg) {
+    function resolve(name, spec, where, arg) {
       const res = new Result({
         raw: arg,
         name,
@@ -703,8 +703,8 @@ var require_npa = __commonJS({
         return fromRegistry(res);
       }
     }
-    function invalidPackageName(name, valid2) {
-      const err = new Error(`Invalid package name "${name}": ${valid2.errors.join("; ")}`);
+    function invalidPackageName(name, valid) {
+      const err = new Error(`Invalid package name "${name}": ${valid.errors.join("; ")}`);
       err.code = "EINVALIDPACKAGENAME";
       return err;
     }
@@ -738,9 +738,9 @@ var require_npa = __commonJS({
     Result.prototype.setName = function(name) {
       if (!validatePackageName)
         validatePackageName = require_validate_npm_package_name();
-      const valid2 = validatePackageName(name);
-      if (!valid2.validForOldPackages) {
-        throw invalidPackageName(name, valid2);
+      const valid = validatePackageName(name);
+      if (!valid.validForOldPackages) {
+        throw invalidPackageName(name, valid);
       }
       this.name = name;
       this.scope = name[0] === "@" ? name.slice(0, name.indexOf("/")) : void 0;
@@ -778,7 +778,7 @@ var require_npa = __commonJS({
         path = __require("path");
       return path.resolve(where, spec);
     }
-    function isAbsolute2(dir) {
+    function isAbsolute(dir) {
       if (dir[0] === "/")
         return true;
       if (/^[A-Za-z]:/.test(dir))
@@ -798,7 +798,7 @@ var require_npa = __commonJS({
         res.saveSpec = "file:" + spec;
       } else {
         res.fetchSpec = resolvePath(where, spec);
-        if (isAbsolute2(spec)) {
+        if (isAbsolute(spec)) {
           res.saveSpec = "file:" + spec;
         } else {
           if (!path)
@@ -863,7 +863,7 @@ var require_npa = __commonJS({
       return res;
     }
     function fromAlias(res, where) {
-      const subSpec = npa2(res.rawSpec.substr(4), where);
+      const subSpec = npa(res.rawSpec.substr(4), where);
       if (subSpec.type === "alias") {
         throw new Error("nested aliases not supported");
       }
@@ -901,485 +901,665 @@ var require_npa = __commonJS({
   }
 });
 
-// src/util/build/import-builders.ts
-var import_npm_package_arg = __toESM(require_npa(), 1);
-var import_semver2 = __toESM(require_semver(), 1);
-var import_fs_extra2 = __toESM(require_lib(), 1);
-var import_fs_detectors = __toESM(require_dist2(), 1);
-import { dirname, isAbsolute, join as join2, resolve } from "path";
-import { createRequire } from "module";
-
-// src/util/build/static-builder.ts
-var static_builder_exports = {};
-__export(static_builder_exports, {
-  build: () => build,
-  shouldServe: () => shouldServe,
-  version: () => version
-});
-var import_minimatch = __toESM(require_minimatch(), 1);
-import { shouldServe as defaultShouldServe } from "@vercel/build-utils";
-var version = 2;
-var ALWAYS_EXCLUDED_PREFIXES = [".git/", "node_modules/"];
-var ALWAYS_EXCLUDED_FILES = [
-  "vercel.json",
-  "vercel.toml",
-  ...VERCEL_CONFIG_EXTENSIONS.map((ext) => `vercel.${ext}`),
-  ".vercelignore",
-  "now.json",
-  ".nowignore"
-];
-var DEFAULT_EXCLUDED_FILES = [
-  ".gitignore",
-  "package.json",
-  "package-lock.json",
-  "yarn.lock",
-  "pnpm-lock.yaml",
-  "bun.lock",
-  "bun.lockb",
-  "README.md"
-];
-var build = async ({ entrypoint, files, config }) => {
-  const output = {};
-  const outputDirectory = config.zeroConfig ? config.outputDirectory : "";
-  for (let [filename, fileFsRef] of Object.entries(files)) {
-    if (ALWAYS_EXCLUDED_PREFIXES.some((prefix) => filename.startsWith(prefix)) || ALWAYS_EXCLUDED_FILES.includes(filename) || DEFAULT_EXCLUDED_FILES.includes(filename) || filename.startsWith(".env")) {
-      continue;
-    }
-    if (entrypoint && !(entrypoint === filename || (0, import_minimatch.default)(filename, entrypoint, { dot: true }))) {
-      continue;
-    }
-    if (outputDirectory) {
-      const outputMatch = outputDirectory + "/";
-      if (filename.startsWith(outputMatch)) {
-        filename = filename.slice(outputMatch.length);
+// ../../internals/builder-orchestration/dist/import-builders.js
+var require_import_builders = __commonJS({
+  "../../internals/builder-orchestration/dist/import-builders.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 __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 });
       }
-    }
-    output[filename] = fileFsRef;
-  }
-  return { output };
-};
-var shouldServe = (_opts) => {
-  const opts = { ..._opts };
-  const {
-    config: { zeroConfig, outputDirectory }
-  } = opts;
-  if (zeroConfig && outputDirectory) {
-    opts.entrypoint = `${outputDirectory}/${opts.entrypoint}`;
-    opts.requestPath = `${outputDirectory}/${opts.requestPath}`;
-  }
-  return defaultShouldServe(opts);
-};
-
-// src/util/build/import-builders.ts
-var import_error_utils2 = __toESM(require_dist(), 1);
-
-// src/util/build/install-builders.ts
-var import_pluralize = __toESM(require_pluralize(), 1);
-var import_semver = __toESM(require_semver(), 1);
-var import_fs_extra = __toESM(require_lib(), 1);
-var import_execa = __toESM(require_execa(), 1);
-import { URL } from "url";
-import { join } from "path";
-var import_error_utils = __toESM(require_dist(), 1);
-function getErrorMessage(err, execaMessage) {
-  if (!err || !("stderr" in err)) {
-    return execaMessage;
-  }
-  if (typeof err.stderr === "string") {
-    return err.stderr;
-  }
-  return execaMessage;
-}
-async function untracedInstallBuilders(buildersDir, buildersToAdd) {
-  const resolvedSpecs = /* @__PURE__ */ new Map();
-  const buildersPkgPath = join(buildersDir, "package.json");
-  try {
-    const emptyPkgJson = {
-      private: true,
-      license: "UNLICENSED"
+      return to;
     };
-    await (0, import_fs_extra.outputJSON)(buildersPkgPath, emptyPkgJson, {
-      flag: "wx"
-    });
-  } catch (err) {
-    if (err.code !== "EEXIST")
-      throw err;
-  }
-  output_manager_default.log(
-    `Installing ${(0, import_pluralize.default)("Builder", buildersToAdd.size)}: ${Array.from(
-      buildersToAdd
-    ).join(", ")}`
-  );
-  const buildUtilsVersion = pkg_default.dependencies?.["@vercel/build-utils"];
-  const buildUtilsSpec = buildUtilsVersion && (0, import_semver.validRange)(buildUtilsVersion) ? `@vercel/build-utils@${buildUtilsVersion}` : "@vercel/build-utils";
-  const installArgs = ["install", buildUtilsSpec, ...buildersToAdd];
-  try {
-    const { stderr } = await (0, import_execa.default)("npm", installArgs, {
-      cwd: buildersDir,
-      stdio: "pipe",
-      reject: true
+    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 import_builders_exports = {};
+    __export2(import_builders_exports, {
+      createImportBuilders: () => createImportBuilders2,
+      formatResolvedBuilders: () => formatResolvedBuilders2,
+      getBuildersDir: () => getBuildersDir2
     });
-    stderr.split("/\r?\n/").filter((line) => line.includes("npm WARN deprecated")).forEach((line) => {
-      output_manager_default.warn(line);
-    });
-  } catch (err) {
-    if ((0, import_error_utils.isError)(err)) {
-      const execaMessage = err.message;
-      let message = getErrorMessage(err, execaMessage);
-      if (execaMessage.startsWith("Command failed with ENOENT")) {
-        message = `Please install ${cmd("npm")} before continuing`;
-      } else {
-        const notFound = /GET (.*) - Not found/.exec(message);
-        if (notFound) {
-          const url = new URL(notFound[1]);
-          const packagePath = decodeURIComponent(url.pathname);
-          const packageName = /(@[^/]+\/[^/]+)$/.exec(packagePath)?.[1] ?? packagePath.split("/").filter(Boolean).at(-1) ?? packagePath;
-          message = `The package ${code(
-            packageName
-          )} is not published on the npm registry`;
+    module.exports = __toCommonJS(import_builders_exports);
+    var import_npm_package_arg = __toESM2(require_npa());
+    var import_semver = require_semver();
+    var import_path = __require("path");
+    var import_fs_extra = require_lib();
+    var import_fs_detectors = require_dist2();
+    var import_error_utils = require_dist();
+    function isRemoteBuilderPin(pin) {
+      return /^https?:\/\//i.test(pin);
+    }
+    function isBareSpec(parsed) {
+      return parsed.type === "tag" && parsed.rawSpec === "";
+    }
+    function formatResolvedBuilders2(builders) {
+      return Array.from(
+        builders.values(),
+        (b) => b.pkgPath ? `${b.pkg.name}@${b.pkg.version}=${(0, import_path.dirname)(b.pkgPath)}` : `${b.pkg.name}=built-in`
+      ).join(",");
+    }
+    function pinBuilderSpecs(specs, pins) {
+      const pinnedSpecs = /* @__PURE__ */ new Map();
+      for (const spec of specs) {
+        const parsed = (0, import_npm_package_arg.default)(spec);
+        if (parsed.name && isBareSpec(parsed)) {
+          const version2 = pins.get(parsed.name);
+          if (version2) {
+            pinnedSpecs.set(
+              spec,
+              isRemoteBuilderPin(version2) ? version2 : `${parsed.name}@${version2}`
+            );
+          }
         }
       }
-      err.message = message;
-      err.link = "https://vercel.link/builder-dependencies-install-failed";
+      return pinnedSpecs;
     }
-    throw err;
-  }
-  const nowScopePath = join(buildersDir, "node_modules/@now");
-  await (0, import_fs_extra.mkdirp)(nowScopePath);
-  try {
-    await (0, import_fs_extra.symlink)("../@vercel/build-utils", join(nowScopePath, "build-utils"));
-  } catch (err) {
-    if (!(0, import_error_utils.isErrnoException)(err) || err.code !== "EEXIST") {
-      throw err;
+    function getBuildersDir2(cwd, vercelDir = ".vercel") {
+      const override = process.env.VERCEL_BUILDERS_DIR;
+      if (override) {
+        return (0, import_path.isAbsolute)(override) ? override : (0, import_path.resolve)(cwd, override);
+      }
+      return (0, import_path.join)(cwd, vercelDir, "builders");
     }
-  }
-  const buildersPkg = await readJSONFile(buildersPkgPath);
-  if (buildersPkg instanceof CantParseJSONFile)
-    throw buildersPkg;
-  if (!buildersPkg) {
-    throw new Error(`Failed to load "${buildersPkgPath}"`);
-  }
-  for (const spec of buildersToAdd) {
-    for (const [name, version2] of Object.entries(
-      buildersPkg.dependencies || {}
-    )) {
-      if (version2 === spec) {
-        output_manager_default.debug(`Resolved Builder spec "${spec}" to name "${name}"`);
-        resolvedSpecs.set(spec, name);
+    function createImportBuilders2(dependencies) {
+      const {
+        debug,
+        installBuilders: installBuilders2,
+        isNativeBinaryInstall: isNativeBinaryInstall2,
+        require: require2,
+        staticBuilder,
+        vercelDir
+      } = dependencies;
+      const builderPins = /* @__PURE__ */ new Map();
+      for (const [name, version2] of Object.entries(dependencies.builderPins)) {
+        if ((0, import_semver.validRange)(version2) || isRemoteBuilderPin(version2)) {
+          builderPins.set(name, version2);
+        }
       }
+      const resolveDependencies = {
+        builderPins,
+        debug,
+        isNativeBinaryInstall: isNativeBinaryInstall2,
+        require: require2,
+        staticBuilder
+      };
+      return async function importBuilders2(builderSpecs, cwd, span) {
+        const buildersDir = getBuildersDir2(cwd, vercelDir);
+        let importResult = await resolveBuilders(
+          buildersDir,
+          builderSpecs,
+          resolveDependencies
+        );
+        if ("buildersToAdd" in importResult) {
+          const { buildersToAdd, installReasons } = importResult;
+          const pinnedSpecs = pinBuilderSpecs(buildersToAdd, builderPins);
+          const installResult = await installBuilders2(
+            buildersDir,
+            new Set(
+              Array.from(buildersToAdd, (spec) => pinnedSpecs.get(spec) ?? spec)
+            ),
+            span,
+            installReasons,
+            pinnedSpecs
+          );
+          const allowedPinDriftSpecs = new Set(
+            Array.from(pinnedSpecs.keys()).filter((spec) => installResult.has(spec))
+          );
+          importResult = await resolveBuilders(
+            buildersDir,
+            builderSpecs,
+            resolveDependencies,
+            installResult,
+            allowedPinDriftSpecs
+          );
+          if ("buildersToAdd" in importResult) {
+            const { buildersToAdd: failed, installReasons: reasons } = importResult;
+            const failures = Array.from(failed, (spec) => {
+              const reason = reasons.get(spec);
+              return reason ? `${spec} (${reason})` : spec;
+            });
+            const err = new Error(
+              `Failed to load Builders after installing them: ${failures.join(
+                ", "
+              )}. Retry the build. If the failure persists, contact Vercel Support.`
+            );
+            Object.assign(err, {
+              link: "https://vercel.link/builder-dependencies-install-failed"
+            });
+            throw err;
+          }
+        }
+        const resolvedBuildersDebug = [];
+        for (const [spec, builderSpec] of importResult.builders) {
+          resolvedBuildersDebug.push(`${spec} => ${builderSpec.pkg.version}`);
+        }
+        debug(`Resolved builders: "${resolvedBuildersDebug.join(", ")}"`);
+        return importResult.builders;
+      };
     }
-  }
-  return resolvedSpecs;
-}
-async function installBuilders(buildersDir, buildersToAdd, span, installReasons, pinnedSpecs) {
-  const install = async () => {
-    try {
-      return await untracedInstallBuilders(buildersDir, buildersToAdd);
-    } catch (err) {
-      if (!pinnedSpecs?.size) {
-        throw err;
+    function missingModuleId(err) {
+      const match = /Cannot find module '([^']+)'/.exec(err.message);
+      const id = match?.[1];
+      if (!id) {
+        return void 0;
+      }
+      if (id.startsWith("/") || id.startsWith(".") || /^[A-Za-z]:[\\/]/.test(id)) {
+        return void 0;
       }
-      const fallbackSpecs = new Set(
-        Array.from(buildersToAdd, (spec) => {
-          for (const [originalSpec, pinnedSpec] of pinnedSpecs) {
-            if (pinnedSpec === spec) {
-              return originalSpec;
+      return id.replace(/[,=]/g, "_").slice(0, 100);
+    }
+    async function resolveBuilders(buildersDir, builderSpecs, dependencies, resolvedSpecs, allowedPinDriftSpecs) {
+      const builders = /* @__PURE__ */ new Map();
+      const buildersToAdd = /* @__PURE__ */ new Set();
+      const installReasons = /* @__PURE__ */ new Map();
+      for (const spec of builderSpecs) {
+        const resolvedSpec = resolvedSpecs?.get(spec) || spec;
+        const parsed = (0, import_npm_package_arg.default)(resolvedSpec);
+        const { name } = parsed;
+        if (!name) {
+          buildersToAdd.add(spec);
+          installReasons.set(spec, "url-spec");
+          continue;
+        }
+        if ((0, import_fs_detectors.isStaticRuntime)(name)) {
+          builders.set(name, {
+            builder: dependencies.staticBuilder,
+            pkg: { name },
+            path: "",
+            pkgPath: "",
+            dynamicallyInstalled: false
+          });
+          continue;
+        }
+        let entrypointLoadFailed = false;
+        try {
+          let pkgPath;
+          let builderPkg;
+          try {
+            pkgPath = (0, import_path.join)(buildersDir, "node_modules", name, "package.json");
+            builderPkg = await (0, import_fs_extra.readJSON)(pkgPath);
+          } catch (error) {
+            if (!(0, import_error_utils.isErrnoException)(error)) {
+              throw error;
+            }
+            if (error.code !== "ENOENT") {
+              throw error;
+            }
+            if (dependencies.isNativeBinaryInstall()) {
+              buildersToAdd.add(spec);
+              installReasons.set(spec, "not-installed");
+              continue;
             }
+            pkgPath = dependencies.require.resolve(`${name}/package.json`);
+            builderPkg = await (0, import_fs_extra.readJSON)(pkgPath);
+          }
+          if (!builderPkg || !pkgPath) {
+            throw new Error(`Failed to load \`package.json\` for "${name}"`);
+          }
+          if (typeof builderPkg.version !== "string") {
+            throw new Error(
+              `\`package.json\` for "${name}" does not contain a "version" field`
+            );
+          }
+          const peerVersion = dependencies.builderPins.get(name);
+          if (isBareSpec(parsed) && peerVersion && (0, import_semver.valid)(peerVersion) && builderPkg.version !== peerVersion && !allowedPinDriftSpecs?.has(spec)) {
+            dependencies.debug(
+              `Resolved "${name}@${builderPkg.version}" does not match pin "${peerVersion}"`
+            );
+            buildersToAdd.add(spec);
+            installReasons.set(spec, "pin-version-mismatch");
+            continue;
+          }
+          if (isBareSpec(parsed) && peerVersion && isRemoteBuilderPin(peerVersion) && pkgPath.startsWith(buildersDir)) {
+            let installedSpec;
+            try {
+              const buildersPkg = await (0, import_fs_extra.readJSON)((0, import_path.join)(buildersDir, "package.json"));
+              installedSpec = buildersPkg.dependencies?.[name];
+            } catch (error) {
+              if (!(0, import_error_utils.isErrnoException)(error) || error.code !== "ENOENT") {
+                throw error;
+              }
+            }
+            if (installedSpec !== peerVersion) {
+              dependencies.debug(
+                `Installed source for "${name}@${builderPkg.version}" is "${installedSpec ?? "unknown"}", not pin "${peerVersion}"`
+              );
+              buildersToAdd.add(spec);
+              installReasons.set(spec, "preview-pack-mismatch");
+              continue;
+            }
+          }
+          if (parsed.type === "version" && parsed.rawSpec !== builderPkg.version) {
+            dependencies.debug(
+              `Installed version "${name}@${builderPkg.version}" does not match "${parsed.rawSpec}"`
+            );
+            buildersToAdd.add(spec);
+            installReasons.set(spec, "version-mismatch");
+            continue;
+          }
+          if (parsed.type === "range" && !(0, import_semver.satisfies)(builderPkg.version, parsed.rawSpec)) {
+            dependencies.debug(
+              `Installed version "${name}@${builderPkg.version}" is not compatible with "${parsed.rawSpec}"`
+            );
+            buildersToAdd.add(spec);
+            installReasons.set(spec, "range-mismatch");
+            continue;
+          }
+          const path = (0, import_path.join)((0, import_path.dirname)(pkgPath), builderPkg.main || "index.js");
+          let builder;
+          try {
+            builder = dependencies.require(path);
+          } catch (requireErr) {
+            entrypointLoadFailed = true;
+            throw requireErr;
+          }
+          const dynamicallyInstalled = pkgPath.startsWith(buildersDir);
+          builders.set(spec, {
+            builder,
+            pkg: {
+              name,
+              ...builderPkg
+            },
+            path,
+            pkgPath,
+            dynamicallyInstalled
+          });
+          dependencies.debug(
+            `Imported Builder "${name}" from "${(0, import_path.dirname)(pkgPath)}"`
+          );
+        } catch (error) {
+          if (!(error instanceof Error)) {
+            throw error;
+          }
+          const err = error;
+          if ((err.code === "MODULE_NOT_FOUND" || err.code === "ENOENT") && !resolvedSpecs) {
+            dependencies.debug(`Failed to import "${name}": ${err}`);
+            buildersToAdd.add(spec);
+            if (entrypointLoadFailed) {
+              const missing = missingModuleId(err);
+              installReasons.set(
+                spec,
+                missing ? `entrypoint-load-failed:${missing}` : "entrypoint-load-failed"
+              );
+            } else {
+              installReasons.set(spec, "not-installed");
+            }
+          } else {
+            err.message = `Importing "${name}": ${err.message}`;
+            throw err;
           }
-          return spec;
-        })
-      );
-      output_manager_default.warn(
-        "Could not install the Builder versions pinned by this Vercel CLI release. Retrying with versions allowed by your npm settings."
-      );
-      const resolvedSpecs = await untracedInstallBuilders(
-        buildersDir,
-        fallbackSpecs
-      );
-      for (const originalSpec of pinnedSpecs.keys()) {
-        if (fallbackSpecs.has(originalSpec)) {
-          resolvedSpecs.set(originalSpec, originalSpec);
         }
       }
-      return resolvedSpecs;
+      if (buildersToAdd.size > 0) {
+        return { buildersToAdd, installReasons };
+      }
+      return { builders };
     }
-  };
-  if (!span) {
-    return install();
-  }
-  const attributes = {
-    packages: Array.from(buildersToAdd).join(",")
-  };
-  if (installReasons && installReasons.size > 0) {
-    attributes.reasons = Array.from(installReasons).map(([spec, reason]) => `${spec}=${reason}`).join(",");
-  }
-  if (pinnedSpecs && pinnedSpecs.size > 0) {
-    attributes.pinned = "true";
-    attributes.pinnedPackages = Array.from(pinnedSpecs.values()).join(",");
   }
-  const installSpan = span.child("vc.installBuilders", attributes);
-  return installSpan.trace(async (s) => {
-    try {
-      return await install();
-    } catch (err) {
-      s.setAttributes({
-        error: (0, import_error_utils.isError)(err) ? err.message : String(err)
-      });
-      throw err;
-    }
-  });
-}
+});
 
-// src/util/build/import-builders.ts
-var require_ = createRequire(__filename);
-function isRemoteBuilderPin(pin) {
-  return /^https?:\/\//i.test(pin);
-}
-function getBuilderPins() {
-  const builderPins = /* @__PURE__ */ new Map();
-  const pins = pkg_default.builders ?? {};
-  for (const [name, version2] of Object.entries(pins)) {
-    if ((0, import_semver2.validRange)(version2) || isRemoteBuilderPin(version2)) {
-      builderPins.set(name, version2);
-    }
-  }
-  return builderPins;
-}
-function isBareSpec(parsed) {
-  return parsed.type === "tag" && parsed.rawSpec === "";
-}
-function formatResolvedBuilders(builders) {
-  return Array.from(
-    builders.values(),
-    (b) => b.pkgPath ? `${b.pkg.name}@${b.pkg.version}=${dirname(b.pkgPath)}` : `${b.pkg.name}=built-in`
-  ).join(",");
-}
-function pinBuilderSpecs(specs) {
-  const pins = getBuilderPins();
-  const pinnedSpecs = /* @__PURE__ */ new Map();
-  for (const spec of specs) {
-    const parsed = (0, import_npm_package_arg.default)(spec);
-    if (parsed.name && isBareSpec(parsed)) {
-      const version2 = pins.get(parsed.name);
-      if (version2) {
-        pinnedSpecs.set(
-          spec,
-          isRemoteBuilderPin(version2) ? version2 : `${parsed.name}@${version2}`
-        );
+// ../../internals/builder-orchestration/dist/static-builder.js
+var require_static_builder = __commonJS({
+  "../../internals/builder-orchestration/dist/static-builder.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 __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 __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 static_builder_exports2 = {};
+    __export2(static_builder_exports2, {
+      createStaticBuilder: () => createStaticBuilder2,
+      version: () => version2
+    });
+    module.exports = __toCommonJS(static_builder_exports2);
+    var import_minimatch = __toESM2(require_minimatch());
+    var import_build_utils = __require("@vercel/build-utils");
+    var version2 = 2;
+    var ALWAYS_EXCLUDED_PREFIXES = [".git/", "node_modules/"];
+    var DEFAULT_EXCLUDED_FILES = [
+      ".gitignore",
+      "package.json",
+      "package-lock.json",
+      "yarn.lock",
+      "pnpm-lock.yaml",
+      "bun.lock",
+      "bun.lockb",
+      "README.md"
+    ];
+    function createStaticBuilder2(vercelConfigExtensions) {
+      const alwaysExcludedFiles = [
+        "vercel.json",
+        "vercel.toml",
+        ...vercelConfigExtensions.map((ext) => `vercel.${ext}`),
+        ".vercelignore",
+        "now.json",
+        ".nowignore"
+      ];
+      const build2 = async ({ entrypoint, files, config }) => {
+        const output = {};
+        const outputDirectory = config.zeroConfig ? config.outputDirectory : "";
+        for (let [filename, fileFsRef] of Object.entries(files)) {
+          if (ALWAYS_EXCLUDED_PREFIXES.some((prefix) => filename.startsWith(prefix)) || alwaysExcludedFiles.includes(filename) || DEFAULT_EXCLUDED_FILES.includes(filename) || filename.startsWith(".env")) {
+            continue;
+          }
+          if (entrypoint && !(entrypoint === filename || (0, import_minimatch.default)(filename, entrypoint, { dot: true }))) {
+            continue;
+          }
+          if (outputDirectory) {
+            const outputMatch = outputDirectory + "/";
+            if (filename.startsWith(outputMatch)) {
+              filename = filename.slice(outputMatch.length);
+            }
+          }
+          output[filename] = fileFsRef;
+        }
+        return { output };
+      };
+      const shouldServe2 = (_opts) => {
+        const opts = { ..._opts };
+        const {
+          config: { zeroConfig, outputDirectory }
+        } = opts;
+        if (zeroConfig && outputDirectory) {
+          opts.entrypoint = `${outputDirectory}/${opts.entrypoint}`;
+          opts.requestPath = `${outputDirectory}/${opts.requestPath}`;
+        }
+        return (0, import_build_utils.shouldServe)(opts);
+      };
+      return { version: version2, build: build2, shouldServe: shouldServe2 };
     }
   }
-  return pinnedSpecs;
-}
-function getBuildersDir(cwd) {
-  const override = process.env.VERCEL_BUILDERS_DIR;
-  if (override) {
-    return isAbsolute(override) ? override : resolve(cwd, override);
-  }
-  return join2(cwd, VERCEL_DIR, "builders");
-}
-async function importBuilders(builderSpecs, cwd, span) {
-  const buildersDir = getBuildersDir(cwd);
-  let importResult = await resolveBuilders(buildersDir, builderSpecs);
-  if ("buildersToAdd" in importResult) {
-    const { buildersToAdd, installReasons } = importResult;
-    const pinnedSpecs = pinBuilderSpecs(buildersToAdd);
-    const installResult = await installBuilders(
-      buildersDir,
-      new Set(Array.from(buildersToAdd, (spec) => pinnedSpecs.get(spec) ?? spec)),
-      span,
-      installReasons,
-      pinnedSpecs
-    );
-    const allowedPinDriftSpecs = new Set(
-      Array.from(pinnedSpecs.keys()).filter((spec) => installResult.has(spec))
-    );
-    importResult = await resolveBuilders(
-      buildersDir,
-      builderSpecs,
-      installResult,
-      allowedPinDriftSpecs
-    );
-    if ("buildersToAdd" in importResult) {
-      const { buildersToAdd: failed, installReasons: reasons } = importResult;
-      const failures = Array.from(failed, (spec) => {
-        const reason = reasons.get(spec);
-        return reason ? `${spec} (${reason})` : spec;
-      });
-      const err = new Error(
-        `Failed to load Builders after installing them: ${failures.join(
-          ", "
-        )}. Retry the build. If the failure persists, contact Vercel Support.`
-      );
-      err.link = "https://vercel.link/builder-dependencies-install-failed";
-      throw err;
-    }
-  }
-  const resolvedBuildersDebug = [];
-  for (const [spec, builderSpec] of importResult.builders) {
-    resolvedBuildersDebug.push(`${spec} => ${builderSpec.pkg.version}`);
-  }
-  output_manager_default.debug(`Resolved builders: "${resolvedBuildersDebug.join(", ")}"`);
-  return importResult.builders;
-}
-function missingModuleId(err) {
-  const match = /Cannot find module '([^']+)'/.exec(err.message);
-  const id = match?.[1];
-  if (!id) {
-    return void 0;
-  }
-  if (id.startsWith("/") || id.startsWith(".") || /^[A-Za-z]:[\\/]/.test(id)) {
-    return void 0;
-  }
-  return id.replace(/[,=]/g, "_").slice(0, 100);
-}
-async function resolveBuilders(buildersDir, builderSpecs, resolvedSpecs, allowedPinDriftSpecs) {
-  const builders = /* @__PURE__ */ new Map();
-  const buildersToAdd = /* @__PURE__ */ new Set();
-  const installReasons = /* @__PURE__ */ new Map();
-  for (const spec of builderSpecs) {
-    const resolvedSpec = resolvedSpecs?.get(spec) || spec;
-    const parsed = (0, import_npm_package_arg.default)(resolvedSpec);
-    const { name } = parsed;
-    if (!name) {
-      buildersToAdd.add(spec);
-      installReasons.set(spec, "url-spec");
-      continue;
-    }
-    if ((0, import_fs_detectors.isStaticRuntime)(name)) {
-      builders.set(name, {
-        builder: static_builder_exports,
-        pkg: { name },
-        path: "",
-        pkgPath: "",
-        dynamicallyInstalled: false
-      });
-      continue;
+});
+
+// ../../internals/builder-orchestration/dist/install-builders.js
+var require_install_builders = __commonJS({
+  "../../internals/builder-orchestration/dist/install-builders.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 __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 __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 install_builders_exports = {};
+    __export2(install_builders_exports, {
+      createInstallBuilders: () => createInstallBuilders2
+    });
+    module.exports = __toCommonJS(install_builders_exports);
+    var import_url = __require("url");
+    var import_pluralize = __toESM2(require_pluralize());
+    var import_path = __require("path");
+    var import_semver = require_semver();
+    var import_fs_extra = require_lib();
+    var import_error_utils = require_dist();
+    function getErrorMessage(err, execaMessage) {
+      if (!err || !("stderr" in err)) {
+        return execaMessage;
+      }
+      if (typeof err.stderr === "string") {
+        return err.stderr;
+      }
+      return execaMessage;
     }
-    let entrypointLoadFailed = false;
-    try {
-      let pkgPath;
-      let builderPkg;
+    async function untracedInstallBuilders(buildersDir, buildersToAdd, dependencies) {
+      const { buildUtilsVersion, code: code2, cmd: cmd2, output, readJSONFile: readJSONFile2, run } = dependencies;
+      const resolvedSpecs = /* @__PURE__ */ new Map();
+      const buildersPkgPath = (0, import_path.join)(buildersDir, "package.json");
       try {
-        pkgPath = join2(buildersDir, "node_modules", name, "package.json");
-        builderPkg = await (0, import_fs_extra2.readJSON)(pkgPath);
+        const emptyPkgJson = {
+          private: true,
+          license: "UNLICENSED"
+        };
+        await (0, import_fs_extra.outputJSON)(buildersPkgPath, emptyPkgJson, {
+          flag: "wx"
+        });
       } catch (error) {
-        if (!(0, import_error_utils2.isErrnoException)(error)) {
+        if (!(0, import_error_utils.isErrnoException)(error) || error.code !== "EEXIST")
           throw error;
-        }
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-        if (isNativeBinaryInstall()) {
-          buildersToAdd.add(spec);
-          installReasons.set(spec, "not-installed");
-          continue;
-        }
-        pkgPath = require_.resolve(`${name}/package.json`, {
-          paths: [__dirname]
+      }
+      output.log(
+        `Installing ${(0, import_pluralize.default)("Builder", buildersToAdd.size)}: ${Array.from(
+          buildersToAdd
+        ).join(", ")}`
+      );
+      const buildUtilsSpec = buildUtilsVersion && (0, import_semver.validRange)(buildUtilsVersion) ? `@vercel/build-utils@${buildUtilsVersion}` : "@vercel/build-utils";
+      const installArgs = ["install", buildUtilsSpec, ...buildersToAdd];
+      try {
+        const { stderr } = await run("npm", installArgs, {
+          cwd: buildersDir,
+          stdio: "pipe",
+          reject: true
         });
-        builderPkg = await (0, import_fs_extra2.readJSON)(pkgPath);
+        stderr.split("/\r?\n/").filter((line) => line.includes("npm WARN deprecated")).forEach((line) => {
+          output.warn(line);
+        });
+      } catch (err) {
+        if ((0, import_error_utils.isError)(err)) {
+          const execaMessage = err.message;
+          let message = getErrorMessage(err, execaMessage);
+          if (execaMessage.startsWith("Command failed with ENOENT")) {
+            message = `Please install ${cmd2("npm")} before continuing`;
+          } else {
+            const notFound = /GET (.*) - Not found/.exec(message);
+            const notFoundUrl = notFound?.[1];
+            if (notFoundUrl) {
+              const url = new import_url.URL(notFoundUrl);
+              const packagePath = decodeURIComponent(url.pathname);
+              const packageName = /(@[^/]+\/[^/]+)$/.exec(packagePath)?.[1] ?? packagePath.split("/").filter(Boolean).at(-1) ?? packagePath;
+              message = `The package ${code2(
+                packageName
+              )} is not published on the npm registry`;
+            }
+          }
+          err.message = message;
+          Object.assign(err, {
+            link: "https://vercel.link/builder-dependencies-install-failed"
+          });
+        }
+        throw err;
       }
-      if (!builderPkg || !pkgPath) {
-        throw new Error(`Failed to load \`package.json\` for "${name}"`);
+      const nowScopePath = (0, import_path.join)(buildersDir, "node_modules/@now");
+      await (0, import_fs_extra.mkdirp)(nowScopePath);
+      try {
+        await (0, import_fs_extra.symlink)("../@vercel/build-utils", (0, import_path.join)(nowScopePath, "build-utils"));
+      } catch (err) {
+        if (!(0, import_error_utils.isErrnoException)(err) || err.code !== "EEXIST") {
+          throw err;
+        }
       }
-      if (typeof builderPkg.version !== "string") {
-        throw new Error(
-          `\`package.json\` for "${name}" does not contain a "version" field`
-        );
+      const buildersPkg = await readJSONFile2(buildersPkgPath);
+      if (dependencies.isCantParseJSONFile(buildersPkg))
+        throw buildersPkg;
+      if (!buildersPkg) {
+        throw new Error(`Failed to load "${buildersPkgPath}"`);
       }
-      const peerVersion = getBuilderPins().get(name);
-      if (isBareSpec(parsed) && peerVersion && (0, import_semver2.valid)(peerVersion) && builderPkg.version !== peerVersion && !allowedPinDriftSpecs?.has(spec)) {
-        output_manager_default.debug(
-          `Resolved "${name}@${builderPkg.version}" does not match pin "${peerVersion}"`
-        );
-        buildersToAdd.add(spec);
-        installReasons.set(spec, "pin-version-mismatch");
-        continue;
+      for (const spec of buildersToAdd) {
+        for (const [name, version2] of Object.entries(
+          buildersPkg.dependencies || {}
+        )) {
+          if (version2 === spec) {
+            output.debug(`Resolved Builder spec "${spec}" to name "${name}"`);
+            resolvedSpecs.set(spec, name);
+          }
+        }
       }
-      if (isBareSpec(parsed) && peerVersion && isRemoteBuilderPin(peerVersion) && pkgPath.startsWith(buildersDir)) {
-        let installedSpec;
-        try {
-          const buildersPkg = await (0, import_fs_extra2.readJSON)(join2(buildersDir, "package.json"));
-          installedSpec = buildersPkg.dependencies?.[name];
-        } catch (error) {
-          if (!(0, import_error_utils2.isErrnoException)(error) || error.code !== "ENOENT") {
-            throw error;
+      return resolvedSpecs;
+    }
+    function createInstallBuilders2(dependencies) {
+      const { output } = dependencies;
+      return async function installBuilders2(buildersDir, buildersToAdd, span, installReasons, pinnedSpecs) {
+        const install = async () => {
+          try {
+            return await untracedInstallBuilders(
+              buildersDir,
+              buildersToAdd,
+              dependencies
+            );
+          } catch (err) {
+            if (!pinnedSpecs?.size) {
+              throw err;
+            }
+            const fallbackSpecs = new Set(
+              Array.from(buildersToAdd, (spec) => {
+                for (const [originalSpec, pinnedSpec] of pinnedSpecs) {
+                  if (pinnedSpec === spec) {
+                    return originalSpec;
+                  }
+                }
+                return spec;
+              })
+            );
+            output.warn(
+              "Could not install the Builder versions pinned by this Vercel CLI release. Retrying with versions allowed by your npm settings."
+            );
+            const resolvedSpecs = await untracedInstallBuilders(
+              buildersDir,
+              fallbackSpecs,
+              dependencies
+            );
+            for (const originalSpec of pinnedSpecs.keys()) {
+              if (fallbackSpecs.has(originalSpec)) {
+                resolvedSpecs.set(originalSpec, originalSpec);
+              }
+            }
+            return resolvedSpecs;
           }
+        };
+        if (!span) {
+          return install();
         }
-        if (installedSpec !== peerVersion) {
-          output_manager_default.debug(
-            `Installed source for "${name}@${builderPkg.version}" is "${installedSpec ?? "unknown"}", not pin "${peerVersion}"`
-          );
-          buildersToAdd.add(spec);
-          installReasons.set(spec, "preview-pack-mismatch");
-          continue;
+        const attributes = {
+          packages: Array.from(buildersToAdd).join(",")
+        };
+        if (installReasons && installReasons.size > 0) {
+          attributes.reasons = Array.from(installReasons).map(([spec, reason]) => `${spec}=${reason}`).join(",");
         }
-      }
-      if (parsed.type === "version" && parsed.rawSpec !== builderPkg.version) {
-        output_manager_default.debug(
-          `Installed version "${name}@${builderPkg.version}" does not match "${parsed.rawSpec}"`
-        );
-        buildersToAdd.add(spec);
-        installReasons.set(spec, "version-mismatch");
-        continue;
-      }
-      if (parsed.type === "range" && !(0, import_semver2.satisfies)(builderPkg.version, parsed.rawSpec)) {
-        output_manager_default.debug(
-          `Installed version "${name}@${builderPkg.version}" is not compatible with "${parsed.rawSpec}"`
-        );
-        buildersToAdd.add(spec);
-        installReasons.set(spec, "range-mismatch");
-        continue;
-      }
-      const path = join2(dirname(pkgPath), builderPkg.main || "index.js");
-      let builder;
-      try {
-        builder = require_(path);
-      } catch (requireErr) {
-        entrypointLoadFailed = true;
-        throw requireErr;
-      }
-      const dynamicallyInstalled = pkgPath.startsWith(buildersDir);
-      builders.set(spec, {
-        builder,
-        pkg: {
-          name,
-          ...builderPkg
-        },
-        path,
-        pkgPath,
-        dynamicallyInstalled
-      });
-      output_manager_default.debug(`Imported Builder "${name}" from "${dirname(pkgPath)}"`);
-    } catch (err) {
-      if ((err.code === "MODULE_NOT_FOUND" || err.code === "ENOENT") && !resolvedSpecs) {
-        output_manager_default.debug(`Failed to import "${name}": ${err}`);
-        buildersToAdd.add(spec);
-        if (entrypointLoadFailed) {
-          const missing = missingModuleId(err);
-          installReasons.set(
-            spec,
-            missing ? `entrypoint-load-failed:${missing}` : "entrypoint-load-failed"
-          );
-        } else {
-          installReasons.set(spec, "not-installed");
+        if (pinnedSpecs && pinnedSpecs.size > 0) {
+          attributes.pinned = "true";
+          attributes.pinnedPackages = Array.from(pinnedSpecs.values()).join(",");
         }
-      } else {
-        err.message = `Importing "${name}": ${err.message}`;
-        throw err;
-      }
+        const installSpan = span.child("vc.installBuilders", attributes);
+        return installSpan.trace(async (s) => {
+          try {
+            return await install();
+          } catch (err) {
+            s.setAttributes({
+              error: (0, import_error_utils.isError)(err) ? err.message : String(err)
+            });
+            throw err;
+          }
+        });
+      };
     }
   }
-  if (buildersToAdd.size > 0) {
-    return { buildersToAdd, installReasons };
-  }
-  return { builders };
-}
+});
+
+// src/builders/import-builders.ts
+var import_import_builders = __toESM(require_import_builders(), 1);
+
+// src/builders/static-builder.ts
+var static_builder_exports = {};
+__export(static_builder_exports, {
+  build: () => build,
+  shouldServe: () => shouldServe,
+  version: () => version
+});
+var import_static_builder = __toESM(require_static_builder(), 1);
+var { version, build, shouldServe } = (0, import_static_builder.createStaticBuilder)(
+  VERCEL_CONFIG_EXTENSIONS
+);
+
+// src/builders/install-builders.ts
+var import_install_builders = __toESM(require_install_builders(), 1);
+var import_execa = __toESM(require_execa(), 1);
+var installBuilders = (0, import_install_builders.createInstallBuilders)({
+  buildUtilsVersion: pkg_default.dependencies?.["@vercel/build-utils"],
+  code,
+  cmd,
+  isCantParseJSONFile: (value) => value instanceof CantParseJSONFile,
+  output: output_manager_default,
+  readJSONFile,
+  run: import_execa.default
+});
+
+// src/builders/import-builders.ts
+import { createRequire } from "module";
+var require_ = createRequire(__filename);
+var importBuilders = (0, import_import_builders.createImportBuilders)({
+  builderPins: pkg_default.builders ?? {},
+  debug: (message) => output_manager_default.debug(message),
+  installBuilders,
+  isNativeBinaryInstall,
+  require: require_,
+  staticBuilder: static_builder_exports,
+  vercelDir: VERCEL_DIR
+});
 
 export {
   require_npa,
-  formatResolvedBuilders,
-  getBuildersDir,
+  import_import_builders,
   importBuilders
 };