@vercel/static-build 2.10.2 → 2.11.0

package/dist/index.js

@@ -9346,12 +9346,12 @@ var require_frameworks = __commonJS({
         experimental: true
       },
       {
-        name: "Eve",
+        name: "eve",
         slug: "eve",
         logo: "https://api-frameworks.vercel.sh/framework-logos/eve.svg",
         darkModeLogo: "https://api-frameworks.vercel.sh/framework-logos/eve-dark.svg",
         tagline: "A filesystem-first framework for durable backend agents on Vercel.",
-        description: "An Eve app: agents authored as a directory of files, compiled and served on Vercel.",
+        description: "An eve app: agents authored as a directory of files, compiled and served on Vercel.",
         detectors: {
           every: [
             {
@@ -9376,8 +9376,7 @@ var require_frameworks = __commonJS({
             value: ".output"
           }
         },
-        getOutputDirName: async () => ".output",
-        experimental: true
+        getOutputDirName: async () => ".output"
       },
       {
         name: "Sanity",
@@ -11185,6 +11184,91 @@ var require_frameworks = __commonJS({
           }
         ]
       },
+      {
+        name: "Bun",
+        slug: "bun",
+        runtimeFramework: true,
+        experimental: true,
+        supersedes: ["node"],
+        logo: "https://api-frameworks.vercel.sh/framework-logos/bun.svg",
+        tagline: "Bun is a fast all-in-one JavaScript runtime, bundler, and package manager.",
+        description: "A Bun application deployed as a serverless function.",
+        website: "https://bun.com",
+        useRuntime: { src: "package.json", use: "@vercel/backends" },
+        ignoreRuntimes: ["@vercel/node"],
+        detectors: {
+          every: [
+            {
+              path: "bun.lock"
+            }
+          ],
+          some: [
+            {
+              path: "server.cjs"
+            },
+            {
+              path: "server.js"
+            },
+            {
+              path: "server.mjs"
+            },
+            {
+              path: "server.mts"
+            },
+            {
+              path: "server.ts"
+            },
+            {
+              path: "server.cts"
+            },
+            {
+              path: "src/server.cjs"
+            },
+            {
+              path: "src/server.js"
+            },
+            {
+              path: "src/server.mjs"
+            },
+            {
+              path: "src/server.mts"
+            },
+            {
+              path: "src/server.ts"
+            },
+            {
+              path: "src/server.cts"
+            }
+          ]
+        },
+        settings: {
+          installCommand: {
+            value: "bun install",
+            placeholder: "bun install"
+          },
+          buildCommand: {
+            placeholder: "None",
+            value: null
+          },
+          devCommand: {
+            placeholder: "`bun dev`, `bun run dev`, or `bun --hot server.ts`",
+            value: null
+          },
+          outputDirectory: {
+            value: "N/A"
+          }
+        },
+        getOutputDirName: async () => "public",
+        defaultRoutes: [
+          {
+            handle: "filesystem"
+          },
+          {
+            src: "/(.*)",
+            dest: "/"
+          }
+        ]
+      },
       {
         name: "Node",
         slug: "node",
@@ -11196,11 +11280,6 @@ var require_frameworks = __commonJS({
         useRuntime: { src: "package.json", use: "@vercel/backends" },
         ignoreRuntimes: ["@vercel/node"],
         detectors: {
-          every: [
-            {
-              path: "package.json"
-            }
-          ],
           some: [
             {
               path: "server.cjs"
@@ -19673,6 +19752,7 @@ var require_superstatic = __commonJS({
     var superstatic_exports = {};
     __export2(superstatic_exports, {
       collectHasSegments: () => collectHasSegments,
+      compilePathToRegexpTemplate: () => compilePathToRegexpTemplate2,
       convertCleanUrls: () => convertCleanUrls,
       convertHeaders: () => convertHeaders,
       convertRedirects: () => convertRedirects,
@@ -19816,6 +19896,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;
           }
@@ -19956,6 +20052,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 isEscaped2(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] !== ":" || isEscaped2(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] !== "$" || isEscaped2(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;
@@ -20357,7 +20528,8 @@ var require_schemas = __commonJS({
       redirectsSchema: () => redirectsSchema,
       rewritesSchema: () => rewritesSchema,
       routesSchema: () => routesSchema,
-      trailingSlashSchema: () => trailingSlashSchema
+      trailingSlashSchema: () => trailingSlashSchema,
+      transformsSchema: () => transformsSchema
     });
     module2.exports = __toCommonJS2(schemas_exports);
     var mitigateSchema = {
@@ -20522,18 +20694,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",
@@ -20719,10 +20896,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 routesSchema = {
       type: "array",
       description: "A list of routes objects used to rewrite paths to point towards other internal or external paths",
@@ -20902,6 +21159,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: {
@@ -21070,6 +21328,7 @@ var require_dist7 = __commonJS({
     var src_exports2 = {};
     __export2(src_exports2, {
       appendRoutesToPhase: () => import_append.appendRoutesToPhase,
+      compilePathToRegexpTemplate: () => import_superstatic2.compilePathToRegexpTemplate,
       getCleanUrls: () => import_superstatic2.getCleanUrls,
       getOwnershipGuard: () => import_service_route_ownership.getOwnershipGuard,
       getTransformedRoutes: () => getTransformedRoutes,
@@ -21243,7 +21502,8 @@ var require_dist7 = __commonJS({
     function checkPatternSyntax(type, index, {
       source,
       destination,
-      has
+      has,
+      transforms
     }) {
       let sourceSegments = /* @__PURE__ */ new Set();
       const destinationSegments = /* @__PURE__ */ new Set();
@@ -21283,6 +21543,19 @@ var require_dist7 = __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) {
@@ -22493,7 +22766,8 @@ var require_utils4 = __commonJS({
       isFrontendFramework: () => isFrontendFramework,
       isRouteOwningBuilder: () => isRouteOwningBuilder2,
       isStaticBuild: () => isStaticBuild2,
-      readVercelConfig: () => readVercelConfig
+      readVercelConfig: () => readVercelConfig,
+      stripTrailingSlash: () => stripTrailingSlash
     });
     module2.exports = __toCommonJS2(utils_exports);
     var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
@@ -22503,6 +22777,10 @@ var require_utils4 = __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);
@@ -22979,7 +23257,7 @@ var require_resolve = __commonJS({
       if (!root) {
         return { fs: fs5 };
       }
-      const normalizedRoot = import_path7.posix.normalize(root);
+      const normalizedRoot = (0, import_utils.stripTrailingSlash)(import_path7.posix.normalize(root));
       if (!await fs5.hasPath(normalizedRoot)) {
         return {
           fs: fs5,
@@ -23097,8 +23375,8 @@ var require_resolve = __commonJS({
       let reachedRoot = false;
       while (!reachedRoot) {
         for (const manifest of manifests) {
-          const manifestPath = dir === "." ? manifest : import_path7.posix.join(dir, manifest);
-          if (await (0, import_utils.hasFile)(fs5, manifestPath)) {
+          const manifestPath2 = dir === "." ? manifest : import_path7.posix.join(dir, manifest);
+          if (await (0, import_utils.hasFile)(fs5, manifestPath2)) {
             return dir;
           }
         }
@@ -23903,9 +24181,8 @@ var require_resolve_v2 = __commonJS({
       return null;
     }
     async function resolveConfiguredServiceV22(name, config, fs5) {
-      const root = config.root;
-      const normalizedRoot = import_path7.posix.normalize(root);
-      const serviceFsResult = normalizedRoot === "." ? { fs: fs5 } : await (0, import_resolve.getServiceFs)(fs5, name, root);
+      const normalizedRoot = (0, import_utils.stripTrailingSlash)(import_path7.posix.normalize(config.root));
+      const serviceFsResult = normalizedRoot === "." ? { fs: fs5 } : await (0, import_resolve.getServiceFs)(fs5, name, normalizedRoot);
       if (serviceFsResult.error) {
         return { error: serviceFsResult.error };
       }
@@ -23995,7 +24272,7 @@ var require_resolve_v2 = __commonJS({
         service: {
           schema: "experimentalServicesV2",
           name,
-          root,
+          root: normalizedRoot,
           framework,
           runtime,
           entrypoint: entrypointFile,
@@ -34438,13 +34715,13 @@ async function readBuildOutputDirectory2({
   return outputs;
 }
 async function getMiddleware(workPath) {
-  const manifestPath = import_path3.default.join(
+  const manifestPath2 = import_path3.default.join(
     workPath,
     BUILD_OUTPUT_DIR,
     "functions-manifest.json"
   );
   try {
-    const manifest = await (0, import_fs_extra.readJson)(manifestPath);
+    const manifest = await (0, import_fs_extra.readJson)(manifestPath2);
     if (manifest.pages["_middleware.js"].runtime !== "web") {
       return;
     }
@@ -35409,23 +35686,6 @@ var build = async ({
         }
       }
     }
-    if (framework?.slug) {
-      try {
-        await (0, import_build_utils4.generateProjectManifest)({
-          workPath: entrypointDir,
-          nodeVersion,
-          cliType,
-          lockfilePath,
-          lockfileVersion,
-          framework: framework.slug,
-          serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0
-        });
-      } catch (err) {
-        (0, import_build_utils4.debug)(
-          `Failed to write static-build manifest: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
     if (framework?.slug === "gatsby") {
       await createPluginSymlinks(entrypointDir);
     }
@@ -35479,6 +35739,15 @@ var build = async ({
         `Set PYTHONPATH="${pythonPath}" because a requirements.txt was found`
       );
     }
+    await generateStaticBuildManifest({
+      framework,
+      service,
+      entrypointDir,
+      nodeVersion,
+      cliType,
+      lockfilePath,
+      lockfileVersion
+    });
     const cliEnv = {
       ...process.env,
       PATH: pathList.join(import_path6.default.delimiter),
@@ -35682,7 +35951,116 @@ var prepareCache = async ({
   }
   return cacheFiles;
 };
-var diagnostics = (0, import_build_utils4.createDiagnostics)("node");
+var STATIC_BUILD_MANIFEST_RUNTIMES = ["node", "go", "rust", "ruby"];
+async function generateStaticBuildManifest({
+  framework,
+  service,
+  entrypointDir,
+  nodeVersion,
+  cliType,
+  lockfilePath,
+  lockfileVersion
+}) {
+  if (framework?.slug === "hugo") {
+    try {
+      const hugoVersionOut = (0, import_child_process.spawnSync)("hugo", ["version"], {
+        encoding: "utf8"
+      });
+      const hugoResolved = hugoVersionOut.status === 0 && typeof hugoVersionOut.stdout === "string" ? hugoVersionOut.stdout.match(/v(\d+(?:\.\d+)*)/)?.[1] ?? process.env.HUGO_VERSION ?? "0.58.2" : process.env.HUGO_VERSION || "0.58.2";
+      await (0, import_build_utils4.writeProjectManifest)(
+        {
+          version: import_build_utils4.MANIFEST_VERSION,
+          runtime: "go",
+          framework: framework.slug,
+          serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0,
+          dependencies: [
+            {
+              name: "hugo",
+              type: "direct",
+              scopes: ["prod"],
+              resolved: hugoResolved
+            }
+          ]
+        },
+        entrypointDir,
+        "go"
+      );
+    } catch (err) {
+      (0, import_build_utils4.debug)(
+        `Failed to write hugo manifest: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  } else if (framework?.slug === "zola") {
+    try {
+      const zolaVersionOut = (0, import_child_process.spawnSync)("zola", ["--version"], {
+        encoding: "utf8"
+      });
+      const zolaResolved = zolaVersionOut.status === 0 && typeof zolaVersionOut.stdout === "string" ? zolaVersionOut.stdout.trim().split(" ")[1] ?? process.env.ZOLA_VERSION ?? "" : process.env.ZOLA_VERSION ?? "";
+      await (0, import_build_utils4.writeProjectManifest)(
+        {
+          version: import_build_utils4.MANIFEST_VERSION,
+          runtime: "rust",
+          framework: framework.slug,
+          serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0,
+          dependencies: [
+            {
+              name: "zola",
+              type: "direct",
+              scopes: ["prod"],
+              resolved: zolaResolved
+            }
+          ]
+        },
+        entrypointDir,
+        "rust"
+      );
+    } catch (err) {
+      (0, import_build_utils4.debug)(
+        `Failed to write zola manifest: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  } else if (framework?.slug === "jekyll" || framework?.slug === "middleman") {
+    await (0, import_build_utils4.generateRubyProjectManifest)({
+      workPath: entrypointDir,
+      gemfileLockPath: import_path6.default.join(entrypointDir, "Gemfile.lock"),
+      framework: framework.slug,
+      serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0
+    });
+  } else if (framework?.slug) {
+    try {
+      await (0, import_build_utils4.generateProjectManifest)({
+        workPath: entrypointDir,
+        nodeVersion,
+        cliType,
+        lockfilePath,
+        lockfileVersion,
+        framework: framework.slug,
+        serviceType: service ? (0, import_build_utils4.getReportedServiceType)(service) : void 0
+      });
+    } catch (err) {
+      (0, import_build_utils4.debug)(
+        `Failed to write static-build manifest: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+}
+var diagnostics = async ({ workPath }) => {
+  const files = {};
+  await Promise.all(
+    STATIC_BUILD_MANIFEST_RUNTIMES.map(async (runtime) => {
+      const relPath = (0, import_build_utils4.manifestPath)(runtime);
+      try {
+        const data = await import_fs4.promises.readFile(
+          import_path6.default.join(workPath, relPath),
+          "utf-8"
+        );
+        files[relPath] = new import_build_utils4.FileBlob({ data });
+      } catch {
+      }
+    })
+  );
+  return files;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-build",
-  "version": "2.10.2",
+  "version": "2.11.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/build-step",
@@ -14,9 +14,9 @@
   },
   "dependencies": {
     "ts-morph": "12.0.0",
-    "@vercel/gatsby-plugin-vercel-builder": "2.2.18",
-    "@vercel/static-config": "3.4.0",
-    "@vercel/gatsby-plugin-vercel-analytics": "1.0.11"
+    "@vercel/gatsby-plugin-vercel-analytics": "1.0.11",
+    "@vercel/gatsby-plugin-vercel-builder": "2.2.20",
+    "@vercel/static-config": "3.4.0"
   },
   "devDependencies": {
     "@types/aws-lambda": "8.10.64",
@@ -37,11 +37,11 @@
     "semver": "7.5.2",
     "tree-kill": "1.2.2",
     "vitest": "2.0.3",
-    "@vercel/build-utils": "13.29.1",
-    "@vercel/frameworks": "3.28.0",
+    "@vercel/frameworks": "3.29.1",
     "@vercel/error-utils": "2.2.0",
-    "@vercel/fs-detectors": "6.8.3",
-    "@vercel/routing-utils": "6.3.0"
+    "@vercel/build-utils": "13.31.0",
+    "@vercel/fs-detectors": "6.9.2",
+    "@vercel/routing-utils": "6.3.1"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",