vercel 59.11.7 → 59.12.0

package/dist/chunks/chunk-HR2MP4XF.js

@@ -0,0 +1,324 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  emitAlertsScopeError,
+  resolveAlertsScope
+} from "./chunk-3BB2HOO2.js";
+import {
+  handleValidationError,
+  validateAllProjectMutualExclusivity
+} from "./chunk-KFWQ3EFH.js";
+import {
+  isJSONObject
+} from "./chunk-WT2Y7FRD.js";
+import {
+  AGENT_REASON
+} from "./chunk-VUS2JQB2.js";
+import {
+  getScope
+} from "./chunk-ABSZNJQO.js";
+import {
+  getProjectByNameOrId
+} from "./chunk-MADFAH3O.js";
+import {
+  buildCommandWithGlobalFlags,
+  outputAgentError
+} from "./chunk-26CU4Q3C.js";
+import {
+  ProjectNotFound,
+  isAPIError
+} from "./chunk-CV5YC2EN.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+
+// src/commands/alerts/rules/parse-scope.ts
+async function resolveRulesTeam(client, jsonOutput) {
+  const { team } = await getScope(client, { resolveLocalScope: true });
+  if (team) {
+    return { teamId: team.id };
+  }
+  const message = "No team context found. Run `vercel switch` to select a team, use `--scope <team>`, or link a team project.";
+  return emitAlertsScopeError(client, jsonOutput, "NO_TEAM", message, {
+    reason: AGENT_REASON.MISSING_SCOPE,
+    hint: "Alert rules belong to a team. Select the team before retrying.",
+    next: [
+      {
+        command: buildCommandWithGlobalFlags(client.argv, "teams switch"),
+        when: "Select a team"
+      },
+      {
+        command: buildCommandWithGlobalFlags(client.argv, "whoami"),
+        when: "Inspect the current scope"
+      }
+    ]
+  });
+}
+async function resolveRulesProject(client, projectNameOrId, jsonOutput, command) {
+  const teamScope = await resolveRulesTeam(client, jsonOutput);
+  if (typeof teamScope === "number") {
+    return teamScope;
+  }
+  try {
+    const project = await getProjectByNameOrId(
+      client,
+      projectNameOrId,
+      teamScope.teamId
+    );
+    if (project instanceof ProjectNotFound) {
+      return emitAlertsScopeError(
+        client,
+        jsonOutput,
+        "PROJECT_NOT_FOUND",
+        `Project "${projectNameOrId}" was not found in the selected team.`,
+        {
+          reason: AGENT_REASON.NOT_FOUND,
+          next: [
+            {
+              command: buildCommandWithGlobalFlags(
+                client.argv,
+                `${command} --project <name_or_id>`
+              ),
+              when: "Retry with a valid project"
+            }
+          ]
+        }
+      );
+    }
+    return {
+      ...teamScope,
+      projectId: project.id,
+      projectName: project.name
+    };
+  } catch (error) {
+    if (!isAPIError(error)) {
+      throw error;
+    }
+    return emitAlertsScopeError(
+      client,
+      jsonOutput,
+      error.code || "API_ERROR",
+      error.serverMessage || `API error (${error.status}).`,
+      {
+        reason: error.status === 401 ? "not_authorized" : error.status === 403 ? "forbidden" : AGENT_REASON.API_ERROR
+      }
+    );
+  }
+}
+async function parseRulesFlagsAndScope(client, flags, jsonOutput, command = "alerts rules ls") {
+  const mutual = validateAllProjectMutualExclusivity(
+    flags["--all"],
+    flags["--project"]
+  );
+  if (!mutual.valid) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: mutual.message,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts rules --help"
+            ),
+            when: "Use either `--project` or `--all`, not both"
+          }
+        ]
+      },
+      1
+    );
+    return handleValidationError(mutual, jsonOutput, client);
+  }
+  if (flags["--all"]) {
+    return resolveRulesTeam(client, jsonOutput);
+  }
+  if (flags["--project"]) {
+    return resolveRulesProject(client, flags["--project"], jsonOutput, command);
+  }
+  const linkedScope = await resolveAlertsScope(client, {
+    jsonOutput,
+    command
+  });
+  if (typeof linkedScope === "number")
+    return linkedScope;
+  const teamScope = await resolveRulesTeam(client, jsonOutput);
+  if (typeof teamScope === "number")
+    return teamScope;
+  return linkedScope.teamId === teamScope.teamId ? linkedScope : teamScope;
+}
+
+// src/commands/alerts/rules/util.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function rulesCollectionPath(teamId, options = {}) {
+  const query = new URLSearchParams({ teamId });
+  if (options.limit !== void 0)
+    query.set("limit", String(options.limit));
+  if (options.cursor)
+    query.set("cursor", options.cursor);
+  if (options.projectId)
+    query.set("projectId", options.projectId);
+  if (options.type)
+    query.set("type", options.type);
+  return `/alerts/v3/alert-rules?${query.toString()}`;
+}
+function rulesItemPath(teamId, ruleId) {
+  const query = new URLSearchParams({ teamId });
+  return `/alerts/v3/alert-rules/${encodeURIComponent(ruleId)}?${query.toString()}`;
+}
+function rulesSchemaPath(teamId, type) {
+  const query = new URLSearchParams({ teamId });
+  if (type)
+    query.set("type", type);
+  return `/alerts/v3/alert-rules/schema?${query.toString()}`;
+}
+async function fetchRule(client, scope, ruleId) {
+  const response = await client.fetch(
+    rulesItemPath(scope.teamId, ruleId)
+  );
+  return response.rule;
+}
+function getIssues(error) {
+  if (!Array.isArray(error.issues))
+    return [];
+  return error.issues.filter(
+    (issue) => isJSONObject(issue) && typeof issue.path === "string" && typeof issue.message === "string"
+  );
+}
+function outputRulesError(client, jsonOutput, code, message, options = {}) {
+  const issues = options.issues ?? [];
+  const issueSummary = issues.slice(0, 5).map((issue) => `${issue.path || "body"}: ${issue.message}`).join("; ");
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: options.reason ?? AGENT_REASON.INVALID_ARGUMENTS,
+      message,
+      hint: options.hint ?? (issueSummary || void 0)
+    },
+    1
+  );
+  if (jsonOutput) {
+    client.stdout.write(
+      `${JSON.stringify(
+        { error: { code, message, ...issues.length ? { issues } : {} } },
+        null,
+        2
+      )}
+`
+    );
+  } else {
+    output_manager_default.fatal(
+      [
+        message,
+        ...issues.map((issue) => `  ${issue.path}: ${issue.message}`)
+      ].join("\n")
+    );
+  }
+  return 1;
+}
+function handleRulesApiError(client, err, jsonOutput) {
+  const message = err.status === 401 ? "You do not have access to alert rules in this team. Ensure your role can manage Alert Rules, or pass --token and --scope." : err.status === 403 ? err.serverMessage || "You do not have permission to manage alert rules in this team." : err.status >= 500 ? `The alert rules endpoint failed (${err.status}). Re-run with --debug and share the x-vercel-id from the failed request.` : err.serverMessage || `API error (${err.status}).`;
+  return outputRulesError(
+    client,
+    jsonOutput,
+    err.code || "API_ERROR",
+    message,
+    {
+      reason: err.status === 401 ? "not_authorized" : err.status === 403 ? "forbidden" : err.status === 404 ? AGENT_REASON.NOT_FOUND : err.status === 429 ? "rate_limited" : AGENT_REASON.API_ERROR,
+      issues: getIssues(err),
+      hint: err.status === 401 || err.status === 403 ? "Confirm the team with `vercel whoami`; use --scope <team-slug> if the rule belongs to another team." : void 0
+    }
+  );
+}
+var LEGACY_BODY_FIELDS = ["alertTypes", "customAlert", "queryJsonString"];
+function readRuleBody(client, bodyPath, jsonOutput) {
+  let raw;
+  try {
+    raw = readFileSync(resolve(client.cwd, bodyPath), "utf8");
+  } catch {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "INVALID_ARGUMENTS",
+      `Could not read --body file: ${bodyPath}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "INVALID_ARGUMENTS",
+      "Invalid JSON in --body file."
+    );
+  }
+  if (!isJSONObject(parsed)) {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "INVALID_ARGUMENTS",
+      "The --body file must contain a JSON object."
+    );
+  }
+  if (LEGACY_BODY_FIELDS.some((field) => Object.hasOwn(parsed, field))) {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "LEGACY_ALERT_RULE_BODY",
+      "This body uses the previous alert-rules shape. Rewrite it using the built-in or custom schema.",
+      {
+        hint: "Run `vercel alerts rules schema --type built-in` or `vercel alerts rules schema --type custom` for examples."
+      }
+    );
+  }
+  return parsed;
+}
+function getBodyType(body) {
+  return body.type === "built-in" || body.type === "custom" ? body.type : void 0;
+}
+function emitRulesArgParseError(client, err, recoverWithProjectFlag) {
+  const message = err instanceof Error ? err.message : String(err);
+  const projectFlagMissingArg = message.includes("--project") && message.includes("requires argument");
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: AGENT_REASON.INVALID_ARGUMENTS,
+      message: projectFlagMissingArg ? "`--project` requires a project name or id (for example `--project my-app`)." : message,
+      next: [
+        {
+          command: buildCommandWithGlobalFlags(
+            client.argv,
+            projectFlagMissingArg ? recoverWithProjectFlag : "alerts rules --help"
+          ),
+          when: projectFlagMissingArg ? "Retry with a project name or id" : "See valid `alerts rules` subcommands"
+        }
+      ]
+    },
+    1
+  );
+}
+
+export {
+  resolveRulesTeam,
+  resolveRulesProject,
+  parseRulesFlagsAndScope,
+  rulesCollectionPath,
+  rulesItemPath,
+  rulesSchemaPath,
+  fetchRule,
+  outputRulesError,
+  handleRulesApiError,
+  readRuleBody,
+  getBodyType,
+  emitRulesArgParseError
+};

package/dist/chunks/{chunk-EZQDYIVB.js → chunk-JOXNBQ7W.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   resolveProjectContext
-} from "./chunk-7KROIXQM.js";
+} from "./chunk-X6TGUHFD.js";
 import {
   AGENT_REASON,
   AGENT_STATUS

package/dist/chunks/{chunk-DBYHS3CK.js → chunk-KAF4WFF3.js}

@@ -13,7 +13,7 @@ import {
   isOAuthError,
   processDeviceAuthorizationResponse,
   processTokenResponse
-} from "./chunk-4IVSM24H.js";
+} from "./chunk-ABSZNJQO.js";
 import {
   printError
 } from "./chunk-3VM7HWF6.js";
@@ -21,7 +21,7 @@ import {
   getTeams,
   getUser,
   humanizePath
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-MADFAH3O.js";
 import {
   getCommandName
 } from "./chunk-Q2DGFCO7.js";

package/dist/chunks/{chunk-VYC45Q4Z.js → chunk-KNO327AW.js}

@@ -8,7 +8,7 @@ import {
   formatCondition,
   formatTransform,
   isTargetTransform
-} from "./chunk-EZQDYIVB.js";
+} from "./chunk-JOXNBQ7W.js";
 import {
   output_manager_default
 } from "./chunk-2JIX6UMI.js";

package/dist/chunks/{chunk-XD4DCYMX.js → chunk-L6B6BRHH.js}

@@ -7,7 +7,7 @@ const __dirname = __dirname_(__filename);
 import {
   login,
   require_ci_info
-} from "./chunk-FL4JLNT2.js";
+} from "./chunk-E47NARDE.js";
 import {
   getGlobalPathConfig
 } from "./chunk-AINIBIP4.js";
@@ -17,7 +17,7 @@ import {
 import {
   humanizePath,
   param
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-MADFAH3O.js";
 import {
   getCommandName
 } from "./chunk-Q2DGFCO7.js";

package/dist/chunks/{chunk-X7DBBZQD.js → chunk-LDV2R4P4.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-GGP5R3FU.js";
 import {
   ALIGNED_LABEL_WIDTH
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-MADFAH3O.js";
 import {
   require_source
 } from "./chunk-S7KYDPEM.js";

package/dist/chunks/{chunk-2TSBB22D.js → chunk-MADFAH3O.js}

@@ -13476,7 +13476,7 @@ async function resolveProjectCwd(cwd) {
   const projectRoot = await findProjectRoot(cwd);
   if (!projectRoot || projectRoot === cwd)
     return cwd;
-  const { isExperimentalServicesEnabled, tryDetectServices } = await import("./detect-services-TESZCQWG.js");
+  const { isExperimentalServicesEnabled, tryDetectServices } = await import("./detect-services-UPY4LTBZ.js");
   const isServicesEnabled = await isExperimentalServicesEnabled(projectRoot);
   if (!isServicesEnabled) {
     return cwd;
@@ -13946,7 +13946,7 @@ async function linkFolderToProject(client, path, projectLink, projectName, orgSl
     try {
       client.cwd = path;
       const args = autoConfirm ? ["--yes"] : [];
-      const { default: pull } = await import("./pull-646WEVDE.js");
+      const { default: pull } = await import("./pull-WUT3XTZX.js");
       const exitCode = await pull(client, args, "vercel-cli:link");
       if (exitCode !== 0) {
         output_manager_default.error(

package/dist/chunks/{chunk-TGNEG57M.js → chunk-MDGPZHSM.js}

@@ -13,10 +13,10 @@ import {
 } from "./chunk-IB5L4LKZ.js";
 import {
   readJSONFile
-} from "./chunk-SHFNEZVI.js";
+} from "./chunk-32XSMM3W.js";
 import {
   VERCEL_CONFIG_EXTENSIONS
-} from "./chunk-QOPTXV4G.js";
+} from "./chunk-YPMFZRTN.js";
 import {
   require_execa
 } from "./chunk-5NF5HOBJ.js";
@@ -27,7 +27,7 @@ import {
   VERCEL_DIR,
   require_lib,
   require_pluralize
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-MADFAH3O.js";
 import {
   CantParseJSONFile,
   code
@@ -639,7 +639,7 @@ 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 = npa;
+    module.exports = npa2;
     module.exports.resolve = resolve;
     module.exports.Result = Result;
     var url;
@@ -652,16 +652,16 @@ var require_npa = __commonJS({
     var hasSlashes = isWindows ? /\\|[/]/ : /[/]/;
     var isURL = /^(?:git[+])?[a-z]+:/i;
     var isFilename = /[.](?:tgz|tar.gz|tar)$/i;
-    function npa(arg, where) {
+    function npa2(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 npa.resolve(arg.name, arg.rawSpec, where || arg.where);
+          return npa2.resolve(arg.name, arg.rawSpec, where || arg.where);
         } else {
-          return npa(arg.raw, where || arg.where);
+          return npa2(arg.raw, where || arg.where);
         }
       }
       const nameEndsAt = arg[0] === "@" ? arg.slice(1).indexOf("@") + 1 : arg.indexOf("@");
@@ -873,7 +873,7 @@ var require_npa = __commonJS({
       return res;
     }
     function fromAlias(res, where) {
-      const subSpec = npa(res.rawSpec.substr(4), where);
+      const subSpec = npa2(res.rawSpec.substr(4), where);
       if (subSpec.type === "alias") {
         throw new Error("nested aliases not supported");
       }
@@ -949,7 +949,7 @@ var require_import_builders = __commonJS({
       getBuildersDir: () => getBuildersDir2
     });
     module.exports = __toCommonJS(import_builders_exports);
-    var import_npm_package_arg = __toESM2(require_npa());
+    var import_npm_package_arg2 = __toESM2(require_npa());
     var import_semver = require_semver();
     var import_path = __require("path");
     var import_fs_extra = require_lib();
@@ -970,7 +970,7 @@ var require_import_builders = __commonJS({
     function pinBuilderSpecs(specs, pins) {
       const pinnedSpecs = /* @__PURE__ */ new Map();
       for (const spec of specs) {
-        const parsed = (0, import_npm_package_arg.default)(spec);
+        const parsed = (0, import_npm_package_arg2.default)(spec);
         if (parsed.name && isBareSpec(parsed)) {
           const version2 = pins.get(parsed.name);
           if (version2) {
@@ -1083,7 +1083,7 @@ var require_import_builders = __commonJS({
       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 parsed = (0, import_npm_package_arg2.default)(resolvedSpec);
         const { name } = parsed;
         if (!name) {
           buildersToAdd.add(spec);
@@ -1384,7 +1384,7 @@ var require_install_builders = __commonJS({
     var import_url = __require("url");
     var import_pluralize = __toESM2(require_pluralize());
     var import_path = __require("path");
-    var import_npm_package_arg = __toESM2(require_npa());
+    var import_npm_package_arg2 = __toESM2(require_npa());
     var import_semver = require_semver();
     var import_fs_extra = require_lib();
     var import_error_utils = require_dist();
@@ -1395,7 +1395,7 @@ var require_install_builders = __commonJS({
         return `@vercel/build-utils@${buildUtilsVersion}`;
       }
       try {
-        if ((0, import_npm_package_arg.default)(buildUtilsVersion).type === "remote") {
+        if ((0, import_npm_package_arg2.default)(buildUtilsVersion).type === "remote") {
           return `@vercel/build-utils@${buildUtilsVersion}`;
         }
       } catch {
@@ -1594,8 +1594,74 @@ var installBuilders = (0, import_install_builders.createInstallBuilders)({
 
 // src/builders/import-builders.ts
 import { createRequire } from "module";
+
+// src/builders/vlt-builder-graph.ts
+import { brotliDecompress } from "zlib";
+import { promisify } from "util";
+import { readFile } from "fs/promises";
+import { join } from "path";
+var decompress = promisify(brotliDecompress);
+var embeddedGraphs;
+function defaultGraphPaths() {
+  return [
+    join(__dirname, "builder-graph.json.br"),
+    join(__dirname, "..", "builders", "builder-graph.json.br")
+  ];
+}
+async function readDefaultGraph() {
+  let lastError;
+  for (const path of defaultGraphPaths()) {
+    try {
+      return await readFile(path);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError;
+}
+function loadEmbeddedBuilderGraphs(readGraph = readDefaultGraph) {
+  embeddedGraphs ??= (async () => {
+    try {
+      const compressed = await readGraph();
+      const graphs = JSON.parse(
+        (await decompress(new Uint8Array(compressed))).toString("utf8")
+      );
+      if (graphs.schemaVersion !== 1 || !graphs.builders || typeof graphs.builders !== "object") {
+        throw new Error("invalid schema");
+      }
+      return graphs;
+    } catch (error) {
+      embeddedGraphs = void 0;
+      throw new Error("Could not load the embedded vlt Builder graphs.", {
+        cause: error
+      });
+    }
+  })();
+  return embeddedGraphs;
+}
+
+// src/builders/vlt-builder-routing.ts
+var import_npm_package_arg = __toESM(require_npa(), 1);
+function isManagedSpec(spec, managedNames) {
+  const parsed = (0, import_npm_package_arg.default)(spec);
+  return !!parsed.name && managedNames.has(parsed.name) && parsed.type === "tag" && (parsed.rawSpec === "" || parsed.rawSpec === "latest");
+}
+function partitionBuilderSpecs(specs, managedNames) {
+  const managed = /* @__PURE__ */ new Map();
+  const legacy = /* @__PURE__ */ new Set();
+  for (const spec of specs) {
+    if (isManagedSpec(spec, managedNames)) {
+      managed.set(spec, (0, import_npm_package_arg.default)(spec).name);
+    } else {
+      legacy.add(spec);
+    }
+  }
+  return { managed, legacy };
+}
+
+// src/builders/import-builders.ts
 var require_ = createRequire(__filename);
-var importBuilders = (0, import_import_builders.createImportBuilders)({
+var legacyImportBuilders = (0, import_import_builders.createImportBuilders)({
   builderPins: pkg_default.builders ?? {},
   debug: (message) => output_manager_default.debug(message),
   installBuilders,
@@ -1604,6 +1670,36 @@ var importBuilders = (0, import_import_builders.createImportBuilders)({
   staticBuilder: static_builder_exports,
   vercelDir: VERCEL_DIR
 });
+var managedBuilderNames = new Set(Object.keys(pkg_default.builders ?? {}));
+async function importBuilders(builderSpecs, cwd, span) {
+  if (!isNativeBinaryInstall() || process.env.VERCEL_EXPERIMENTAL_VLT_BUILDERS !== "1") {
+    return legacyImportBuilders(builderSpecs, cwd, span);
+  }
+  const { managed, legacy } = partitionBuilderSpecs(
+    builderSpecs,
+    managedBuilderNames
+  );
+  output_manager_default.debug(
+    `Builder import routing: vlt=[${[...managed].map(([spec]) => spec).join(", ")}], legacy=[${[...legacy].join(", ")}]`
+  );
+  if (managed.size === 0) {
+    return legacyImportBuilders(legacy, cwd, span);
+  }
+  const [{ createVltBuilderImporter }, graphs] = await Promise.all([
+    import("./vlt-builder-importer-USCFHWPL.js"),
+    loadEmbeddedBuilderGraphs()
+  ]);
+  const vltImportBuilders = createVltBuilderImporter({
+    loadGraphs: async () => graphs,
+    require: require_,
+    debug: (message) => output_manager_default.debug(message)
+  });
+  const [vltBuilders, legacyBuilders] = await Promise.all([
+    vltImportBuilders(managed),
+    legacy.size ? legacyImportBuilders(legacy, cwd, span) : Promise.resolve(/* @__PURE__ */ new Map())
+  ]);
+  return new Map([...vltBuilders, ...legacyBuilders]);
+}
 
 export {
   require_npa,

package/dist/chunks/{chunk-XIFATBH5.js → chunk-NDY3JDOU.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   writeProjectSettings
-} from "./chunk-EPOLDWRA.js";
+} from "./chunk-TDGK45FB.js";
 import {
   autoInstallVercelPlugin
 } from "./chunk-K3RED3VO.js";
@@ -15,10 +15,10 @@ import {
 } from "./chunk-64IF634X.js";
 import {
   envPullCommandLogic
-} from "./chunk-GHKJAK5V.js";
+} from "./chunk-RNK3LXLR.js";
 import {
   ensureLink
-} from "./chunk-C762AAVU.js";
+} from "./chunk-PP5GKSIX.js";
 import {
   pullCommand
 } from "./chunk-UG2WOB5L.js";
@@ -41,7 +41,7 @@ import {
   VERCEL_DIR,
   VERCEL_DIR_PROJECT,
   humanizePath
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-MADFAH3O.js";
 import {
   getFlagsSpecification
 } from "./chunk-Q2DGFCO7.js";