vercel 54.14.5 → 54.15.1

package/dist/chunks/{chunk-YIAUEFUY.js → chunk-MABHXDYV.js}

@@ -20940,6 +20940,7 @@ var require_superstatic = __commonJS({
     var superstatic_exports = {};
     __export2(superstatic_exports, {
       collectHasSegments: () => collectHasSegments,
+      compilePathToRegexpTemplate: () => compilePathToRegexpTemplate2,
       convertCleanUrls: () => convertCleanUrls,
       convertHeaders: () => convertHeaders,
       convertRedirects: () => convertRedirects,
@@ -21083,6 +21084,22 @@ var require_superstatic = __commonJS({
             }
             route = { src, destination };
           }
+          if (r.transforms) {
+            route.transforms = r.transforms.map((transform) => {
+              if (transform.type !== "request.path") {
+                return { ...transform };
+              }
+              return {
+                ...transform,
+                args: compilePathToRegexpTemplateFromSegments(
+                  transform.args,
+                  segments,
+                  hasSegments,
+                  transform.env
+                )
+              };
+            });
+          }
           if (typeof r.env !== "undefined") {
             route.env = r.env;
           }
@@ -21223,6 +21240,81 @@ var require_superstatic = __commonJS({
     }
     var escapeSegment = (str, segmentName) => str.replace(new RegExp(`:${segmentName}`, "g"), `__ESC_COLON_${segmentName}`);
     var unescapeSegments = (str) => str.replace(/__ESC_COLON_/gi, ":");
+    var pathTemplateSegmentNameRegex = /^([a-zA-Z_][a-zA-Z0-9_]*)/;
+    function isEscaped(value, index) {
+      let backslashCount = 0;
+      for (let i = index - 1; i >= 0 && value[i] === "\\"; i--) {
+        backslashCount++;
+      }
+      return backslashCount % 2 === 1;
+    }
+    function collectPathTemplateSegments(template) {
+      const segments = [];
+      for (let i = 0; i < template.length; i++) {
+        if (template[i] !== ":" || isEscaped(template, i)) {
+          continue;
+        }
+        const match = template.slice(i + 1).match(pathTemplateSegmentNameRegex);
+        if (match) {
+          segments.push(match[1]);
+          i += match[1].length;
+        }
+      }
+      return segments;
+    }
+    function collectNamedDollarReferences(template) {
+      const references = [];
+      for (let i = 0; i < template.length; i++) {
+        if (template[i] !== "$" || isEscaped(template, i)) {
+          continue;
+        }
+        const remainder = template.slice(i + 1);
+        const bracedMatch = remainder.match(/^\{([a-zA-Z_][a-zA-Z0-9_]*)\}/);
+        const unbracedMatch = remainder.match(pathTemplateSegmentNameRegex);
+        const name = bracedMatch?.[1] || unbracedMatch?.[1];
+        if (name) {
+          references.push(name);
+        }
+      }
+      return references;
+    }
+    function compilePathToRegexpTemplateFromSegments(template, segments, hasItemSegments, env = []) {
+      const indexes = {};
+      segments.forEach((name, index) => {
+        indexes[name] = toSegmentDest(index);
+      });
+      hasItemSegments.forEach((name) => {
+        indexes[name] = `$${name}`;
+      });
+      for (const name of collectPathTemplateSegments(template)) {
+        if (!(name in indexes)) {
+          throw new Error(
+            `Path template references parameter ":${name}" that is not present in the source or has conditions.`
+          );
+        }
+      }
+      const routeParameters = /* @__PURE__ */ new Set([
+        ...segments.filter((name) => name !== UN_NAMED_SEGMENT),
+        ...hasItemSegments
+      ]);
+      for (const name of collectNamedDollarReferences(template)) {
+        if (routeParameters.has(name) && !env.includes(name)) {
+          throw new Error(
+            `Path template references route parameter "${name}" as \`$${name}\`. Use \`:${name}\` path-to-regexp syntax in high-level rewrites, or list "${name}" in the transform env allowlist if it is an environment variable.`
+          );
+        }
+      }
+      return safelyCompile(template, indexes, true);
+    }
+    function compilePathToRegexpTemplate2(source, template, has, env) {
+      const { segments } = sourceToRegex2(source);
+      return compilePathToRegexpTemplateFromSegments(
+        template,
+        segments,
+        collectHasSegments(has),
+        env
+      );
+    }
     function replaceSegments(segments, hasItemSegments, destination, isRedirect, internalParamNames) {
       const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
       const canNeedReplacing = destination.includes(":") && namedSegments.length > 0 || hasItemSegments.length > 0 || !isRedirect;
@@ -21624,7 +21716,8 @@ var require_schemas = __commonJS({
       redirectsSchema: () => redirectsSchema2,
       rewritesSchema: () => rewritesSchema2,
       routesSchema: () => routesSchema2,
-      trailingSlashSchema: () => trailingSlashSchema2
+      trailingSlashSchema: () => trailingSlashSchema2,
+      transformsSchema: () => transformsSchema
     });
     module.exports = __toCommonJS2(schemas_exports);
     var mitigateSchema = {
@@ -21789,18 +21882,23 @@ var require_schemas = __commonJS({
       }
     };
     var transformsSchema = {
-      description: "A list of transform rules to adjust the query parameters of a request or HTTP headers of request or response",
+      description: "A list of transform rules to adjust a request path, request query parameters, or request/response headers",
       type: "array",
       minItems: 1,
       items: {
         type: "object",
         additionalProperties: false,
-        required: ["type", "op", "target"],
+        required: ["type", "op"],
         properties: {
           type: {
             description: "The scope of the transform to apply",
             type: "string",
-            enum: ["request.headers", "request.query", "response.headers"]
+            enum: [
+              "request.headers",
+              "request.query",
+              "response.headers",
+              "request.path"
+            ]
           },
           op: {
             description: "The operation to perform on the target",
@@ -21986,10 +22084,90 @@ var require_schemas = __commonJS({
                 }
               }
             }
+          },
+          {
+            if: {
+              required: ["type"],
+              properties: {
+                type: {
+                  enum: ["request.headers", "request.query", "response.headers"]
+                }
+              }
+            },
+            // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+            then: {
+              required: ["target"]
+            }
+          },
+          {
+            if: {
+              required: ["type"],
+              properties: {
+                type: {
+                  enum: ["request.path"]
+                }
+              }
+            },
+            // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+            then: {
+              required: ["args"],
+              not: {
+                required: ["target"]
+              },
+              properties: {
+                op: {
+                  enum: ["set"]
+                },
+                args: {
+                  description: "The runtime-visible request path. Must be an origin-form path without query or fragment.",
+                  type: "string",
+                  maxLength: 2048,
+                  pattern: "^/(?!/)(?!.*[?#\\s\\x00-\\x1F\\x7F]).*$"
+                }
+              }
+            }
           }
         ]
       }
     };
+    var rewriteTransformsSchema = {
+      description: "A list of request path transforms using path-to-regexp parameters.",
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "op", "args"],
+        properties: {
+          type: {
+            description: "The request path to expose to the target runtime",
+            type: "string",
+            enum: ["request.path"]
+          },
+          op: {
+            description: "Replace the runtime-visible request path",
+            type: "string",
+            enum: ["set"]
+          },
+          args: {
+            description: "An origin-form request path. Route parameters use path-to-regexp syntax such as `/:path*`.",
+            type: "string",
+            maxLength: 2048,
+            pattern: "^/(?!/)(?!.*[?#\\s\\x00-\\x1F\\x7F]).*$"
+          },
+          env: {
+            description: "An array of environment variable names that should be replaced at runtime in the args value",
+            type: "array",
+            minItems: 1,
+            maxItems: 64,
+            items: {
+              type: "string",
+              maxLength: 256
+            }
+          }
+        }
+      }
+    };
     var routesSchema2 = {
       type: "array",
       description: "A list of routes objects used to rewrite paths to point towards other internal or external paths",
@@ -22169,6 +22347,7 @@ var require_schemas = __commonJS({
             description: "An absolute pathname to an existing resource, an external URL, or a service-targeted destination object.",
             anyOf: [{ type: "string", maxLength: 4096 }, serviceDestinationSchema]
           },
+          transforms: rewriteTransformsSchema,
           has: hasSchema,
           missing: hasSchema,
           statusCode: {
@@ -22337,6 +22516,7 @@ var require_dist5 = __commonJS({
     var src_exports = {};
     __export2(src_exports, {
       appendRoutesToPhase: () => import_append.appendRoutesToPhase,
+      compilePathToRegexpTemplate: () => import_superstatic2.compilePathToRegexpTemplate,
       getCleanUrls: () => import_superstatic2.getCleanUrls,
       getOwnershipGuard: () => import_service_route_ownership.getOwnershipGuard,
       getTransformedRoutes: () => getTransformedRoutes,
@@ -22510,7 +22690,8 @@ var require_dist5 = __commonJS({
     function checkPatternSyntax(type, index, {
       source,
       destination,
-      has
+      has,
+      transforms
     }) {
       let sourceSegments = /* @__PURE__ */ new Set();
       const destinationSegments = /* @__PURE__ */ new Set();
@@ -22550,6 +22731,19 @@ var require_dist5 = __commonJS({
           }
         }
       }
+      for (const transform of transforms || []) {
+        if (transform.type !== "request.path") {
+          continue;
+        }
+        try {
+          (0, import_superstatic.compilePathToRegexpTemplate)(source, transform.args, has, transform.env);
+        } catch (error) {
+          return {
+            message: `${type} at index ${index} has an invalid \`request.path\` transform: ${error instanceof Error ? error.message : String(error)}`,
+            link: "https://vercel.link/invalid-route-destination-segment"
+          };
+        }
+      }
       return null;
     }
     function checkRedirect(r, index) {
@@ -22841,7 +23035,8 @@ var require_utils3 = __commonJS({
       isFrontendFramework: () => isFrontendFramework,
       isRouteOwningBuilder: () => isRouteOwningBuilder2,
       isStaticBuild: () => isStaticBuild2,
-      readVercelConfig: () => readVercelConfig
+      readVercelConfig: () => readVercelConfig,
+      stripTrailingSlash: () => stripTrailingSlash
     });
     module.exports = __toCommonJS2(utils_exports);
     var import_framework_helpers = __require("@vercel/build-utils/dist/framework-helpers");
@@ -22851,6 +23046,10 @@ var require_utils3 = __commonJS({
     var DETECTION_FRAMEWORKS = import_frameworks2.frameworkList.filter(
       (framework) => !framework.experimental || framework.runtimeFramework
     );
+    function stripTrailingSlash(p) {
+      const stripped = p.replace(/\/+$/, "");
+      return stripped === "" ? "." : stripped;
+    }
     async function hasFile(fs5, filePath) {
       try {
         return await fs5.isFile(filePath);
@@ -23327,7 +23526,7 @@ var require_resolve2 = __commonJS({
       if (!root) {
         return { fs: fs5 };
       }
-      const normalizedRoot = import_path12.posix.normalize(root);
+      const normalizedRoot = (0, import_utils4.stripTrailingSlash)(import_path12.posix.normalize(root));
       if (!await fs5.hasPath(normalizedRoot)) {
         return {
           fs: fs5,
@@ -24251,9 +24450,8 @@ var require_resolve_v2 = __commonJS({
       return null;
     }
     async function resolveConfiguredServiceV22(name, config, fs5) {
-      const root = config.root;
-      const normalizedRoot = import_path12.posix.normalize(root);
-      const serviceFsResult = normalizedRoot === "." ? { fs: fs5 } : await (0, import_resolve.getServiceFs)(fs5, name, root);
+      const normalizedRoot = (0, import_utils4.stripTrailingSlash)(import_path12.posix.normalize(config.root));
+      const serviceFsResult = normalizedRoot === "." ? { fs: fs5 } : await (0, import_resolve.getServiceFs)(fs5, name, normalizedRoot);
       if (serviceFsResult.error) {
         return { error: serviceFsResult.error };
       }
@@ -24343,7 +24541,7 @@ var require_resolve_v2 = __commonJS({
         service: {
           schema: "experimentalServicesV2",
           name,
-          root,
+          root: normalizedRoot,
           framework,
           runtime,
           entrypoint: entrypointFile,
@@ -37408,7 +37606,7 @@ var require_package = __commonJS({
   "../client/package.json"(exports, module) {
     module.exports = {
       name: "@vercel/client",
-      version: "17.5.16",
+      version: "17.5.18",
       main: "dist/index.js",
       typings: "dist/index.d.ts",
       homepage: "https://vercel.com",

package/dist/chunks/{chunk-45S2Y3TD.js → chunk-OEFNWW5M.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   require_lib
-} from "./chunk-YIAUEFUY.js";
+} from "./chunk-MABHXDYV.js";
 import {
   isNativeBinaryInstall
 } from "./chunk-HIYWSGI7.js";

package/dist/chunks/{chunk-JLLN34XF.js → chunk-OOGTHUXU.js}

@@ -7,17 +7,17 @@ const __dirname = __dirname_(__filename);
 import {
   getUpdateCommandInfo,
   isGlobal
-} from "./chunk-45S2Y3TD.js";
+} from "./chunk-OEFNWW5M.js";
 import {
   getGlobalPathConfig,
   progress,
   writeToConfigFile
-} from "./chunk-ZR4XADWC.js";
+} from "./chunk-CBMMVXLH.js";
 import {
   apiCommand,
   listSubcommand2 as listSubcommand,
   loginCommand
-} from "./chunk-6R3YPU76.js";
+} from "./chunk-AQWK7XXE.js";
 import {
   require_semver
 } from "./chunk-IB5L4LKZ.js";
@@ -26,7 +26,7 @@ import {
 } from "./chunk-AWD3IGXU.js";
 import {
   login
-} from "./chunk-YIAUEFUY.js";
+} from "./chunk-MABHXDYV.js";
 import {
   TelemetryClient,
   isNativeBinaryInstall

package/dist/chunks/{chunk-LJ5WXXG6.js → chunk-QH7WYDEP.js}

@@ -22,7 +22,10 @@ var AGENT_REASON = {
   NOT_FOUND: "not_found",
   PROJECT_NOT_FOUND: "project_not_found",
   MISSING_SCOPE: "missing_scope",
+  SCOPE_NOT_ACCESSIBLE: "scope_not_accessible",
   API_ERROR: "api_error",
+  // Flags
+  SEGMENT_IN_USE: "segment_in_use",
   // Env
   MISSING_REQUIREMENTS: "missing_requirements",
   MISSING_NAME: "missing_name",
@@ -46,6 +49,14 @@ var AGENT_REASON = {
   INVALID_DNS_TYPE: "invalid_dns_type",
   DNS_ADD_FAILED: "dns_add_failed",
   INVALID_DOMAIN: "invalid_domain",
+  CONFIGURED_CORRECTLY: "configured_correctly",
+  VERIFICATION_NEEDED: "verification_needed",
+  INVALID_CONFIGURATION: "invalid_configuration",
+  DNS_CHANGE_REQUIRED: "dns_change_required",
+  DNS_CHANGE_RECOMMENDED: "dns_change_recommended",
+  DNSSEC_NEEDS_TO_BE_DISABLED: "dnssec_needs_to_be_disabled",
+  PROJECT_ATTACHMENT_RECOMMENDED: "project_attachment_recommended",
+  PROJECT_DOMAIN_MISSING: "project_domain_missing",
   /** User must accept marketplace integration terms in the browser before install can continue. */
   INTEGRATION_TERMS_ACCEPTANCE_REQUIRED: "integration_terms_acceptance_required",
   /** Integration uninstall blocked because team-scoped resources still exist. */