@vercel/static-build 2.8.29 → 2.8.31

package/dist/index.js

@@ -19753,6 +19753,7 @@ var require_utils4 = __commonJS({
     __export2(utils_exports, {
       getBuilderForRuntime: () => getBuilderForRuntime,
       inferServiceRuntime: () => inferServiceRuntime,
+      isStaticBuild: () => isStaticBuild2,
       readVercelConfig: () => readVercelConfig
     });
     module2.exports = __toCommonJS2(utils_exports);
@@ -19765,6 +19766,9 @@ var require_utils4 = __commonJS({
       }
       return builder;
     }
+    function isStaticBuild2(service) {
+      return import_types.STATIC_BUILDERS.has(service.builder.use);
+    }
     function inferServiceRuntime(config) {
       if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
         return config.runtime;
@@ -19949,7 +19953,7 @@ var require_resolve = __commonJS({
         builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
         builderSrc = config.entrypoint;
       }
-      const routePrefix = type === "web" ? config.routePrefix : void 0;
+      const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
       const isRoot = workspace === ".";
       if (!isRoot && !builderSrc.startsWith(workspace + "/")) {
         builderSrc = import_path7.posix.join(workspace, builderSrc);
@@ -19963,8 +19967,15 @@ var require_resolve = __commonJS({
         builderConfig.includeFiles = config.includeFiles;
       if (config.excludeFiles)
         builderConfig.excludeFiles = config.excludeFiles;
-      const isStaticBuild = import_types.STATIC_BUILDERS.has(builderUse);
-      const runtime = isStaticBuild ? void 0 : inferredRuntime;
+      const isStaticBuild2 = import_types.STATIC_BUILDERS.has(builderUse);
+      const runtime = isStaticBuild2 ? void 0 : inferredRuntime;
+      if (routePrefix) {
+        const stripped = routePrefix.startsWith("/") ? routePrefix.slice(1) : routePrefix;
+        builderConfig.routePrefix = stripped || ".";
+      }
+      if (config.framework) {
+        builderConfig.framework = config.framework;
+      }
       return {
         name,
         type,
@@ -20004,6 +20015,488 @@ var require_resolve = __commonJS({
   }
 });
 
+// ../fs-detectors/dist/detect-framework.js
+var require_detect_framework = __commonJS({
+  "../fs-detectors/dist/detect-framework.js"(exports2, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var detect_framework_exports = {};
+    __export2(detect_framework_exports, {
+      detectFramework: () => detectFramework2,
+      detectFrameworkRecord: () => detectFrameworkRecord3,
+      detectFrameworkVersion: () => detectFrameworkVersion2,
+      detectFrameworks: () => detectFrameworks2,
+      removeSupersededFrameworks: () => removeSupersededFrameworks
+    });
+    module2.exports = __toCommonJS2(detect_framework_exports);
+    var import_child_process2 = require("child_process");
+    function shouldIncludeExperimentalFrameworks(useExperimentalFrameworks) {
+      if (typeof useExperimentalFrameworks === "boolean") {
+        return useExperimentalFrameworks;
+      }
+      const experimentalEnv = process.env.VERCEL_USE_EXPERIMENTAL_FRAMEWORKS;
+      const isEnabled = (val) => val === "1" || typeof val === "string" && val.toLowerCase() === "true";
+      return isEnabled(experimentalEnv);
+    }
+    function filterFrameworkList(frameworkList, useExperimentalFrameworks) {
+      if (shouldIncludeExperimentalFrameworks(useExperimentalFrameworks)) {
+        return frameworkList;
+      }
+      return frameworkList.filter((f) => {
+        const experimental = f.experimental;
+        return !experimental;
+      });
+    }
+    async function matches(fs5, framework) {
+      const { detectors } = framework;
+      if (!detectors) {
+        return;
+      }
+      const { every, some } = detectors;
+      if (every !== void 0 && !Array.isArray(every)) {
+        return;
+      }
+      if (some !== void 0 && !Array.isArray(some)) {
+        return;
+      }
+      const check = async ({
+        path: path6,
+        matchContent,
+        matchPackage
+      }) => {
+        if (matchPackage && matchContent) {
+          throw new Error(
+            `Cannot specify "matchPackage" and "matchContent" in the same detector for "${framework.slug}"`
+          );
+        }
+        if (matchPackage && path6) {
+          throw new Error(
+            `Cannot specify "matchPackage" and "path" in the same detector for "${framework.slug}" because "path" is assumed to be "package.json".`
+          );
+        }
+        if (!path6 && !matchPackage) {
+          throw new Error(
+            `Must specify either "path" or "matchPackage" in detector for "${framework.slug}".`
+          );
+        }
+        if (!path6) {
+          path6 = "package.json";
+        }
+        if (matchPackage) {
+          matchContent = `"(dev)?(d|D)ependencies":\\s*{[^}]*"${matchPackage}":\\s*"(.+?)"[^}]*}`;
+        }
+        if (await fs5.hasPath(path6) === false) {
+          return;
+        }
+        if (matchContent) {
+          if (await fs5.isFile(path6) === false) {
+            return;
+          }
+          const regex = new RegExp(matchContent, "m");
+          const content = await fs5.readFile(path6);
+          const match = content.toString().match(regex);
+          if (!match) {
+            return;
+          }
+          if (matchPackage && match[3]) {
+            return {
+              framework,
+              detectedVersion: match[3]
+            };
+          }
+        }
+        return {
+          framework
+        };
+      };
+      const result = [];
+      if (every) {
+        const everyResult = await Promise.all(every.map((item) => check(item)));
+        result.push(...everyResult);
+      }
+      if (some) {
+        let someResult;
+        for (const item of some) {
+          const itemResult = await check(item);
+          if (itemResult) {
+            someResult = itemResult;
+            break;
+          }
+        }
+        result.push(someResult);
+      }
+      if (!result.every((res) => !!res)) {
+        return;
+      }
+      const detectedVersion = result.find(
+        (r) => typeof r === "object" && r.detectedVersion
+      )?.detectedVersion;
+      return {
+        framework,
+        detectedVersion
+      };
+    }
+    function removeSupersededFramework(matches2, slug) {
+      const index = matches2.findIndex((f) => f?.slug === slug);
+      const framework = matches2[index];
+      if (framework) {
+        if (framework.supersedes) {
+          for (const slug2 of framework.supersedes) {
+            removeSupersededFramework(matches2, slug2);
+          }
+        }
+        matches2.splice(index, 1);
+      }
+    }
+    function removeSupersededFrameworks(matches2) {
+      for (const match of matches2.slice()) {
+        if (match?.supersedes) {
+          for (const slug of match.supersedes) {
+            removeSupersededFramework(matches2, slug);
+          }
+        }
+      }
+    }
+    async function detectFramework2({
+      fs: fs5,
+      frameworkList,
+      useExperimentalFrameworks
+    }) {
+      const filteredList = filterFrameworkList(
+        frameworkList,
+        useExperimentalFrameworks
+      );
+      const result = await Promise.all(
+        filteredList.map(async (frameworkMatch) => {
+          if (await matches(fs5, frameworkMatch)) {
+            return frameworkMatch;
+          }
+          return null;
+        })
+      );
+      removeSupersededFrameworks(result);
+      return result.find((res) => res !== null)?.slug ?? null;
+    }
+    async function detectFrameworks2({
+      fs: fs5,
+      frameworkList,
+      useExperimentalFrameworks
+    }) {
+      const filteredList = filterFrameworkList(
+        frameworkList,
+        useExperimentalFrameworks
+      );
+      const result = await Promise.all(
+        filteredList.map(async (frameworkMatch) => {
+          if (await matches(fs5, frameworkMatch)) {
+            return frameworkMatch;
+          }
+          return null;
+        })
+      );
+      removeSupersededFrameworks(result);
+      return result.filter((res) => res !== null);
+    }
+    async function detectFrameworkRecord3({
+      fs: fs5,
+      frameworkList,
+      useExperimentalFrameworks
+    }) {
+      const filteredList = filterFrameworkList(
+        frameworkList,
+        useExperimentalFrameworks
+      );
+      const result = await Promise.all(
+        filteredList.map(async (frameworkMatch) => {
+          const matchResult = await matches(fs5, frameworkMatch);
+          if (matchResult) {
+            return {
+              ...frameworkMatch,
+              detectedVersion: matchResult?.detectedVersion
+            };
+          }
+          return null;
+        })
+      );
+      removeSupersededFrameworks(result);
+      return result.find((res) => res !== null) ?? null;
+    }
+    function detectFrameworkVersion2(frameworkRecord) {
+      const allDetectors = [
+        ...frameworkRecord.detectors?.every || [],
+        ...frameworkRecord.detectors?.some || []
+      ];
+      const firstMatchPackage = allDetectors.find((d) => d.matchPackage);
+      if (!firstMatchPackage?.matchPackage) {
+        return;
+      }
+      return lookupInstalledVersion(
+        process.execPath,
+        firstMatchPackage.matchPackage
+      );
+    }
+    function lookupInstalledVersion(cwd, packageName) {
+      try {
+        const script = `require('${packageName}/package.json').version`;
+        return (0, import_child_process2.spawnSync)(cwd, ["-p", script], {
+          encoding: "utf-8"
+        }).stdout.trim();
+      } catch (error) {
+        console.debug(
+          `Error looking up version of installed package "${packageName}": ${error}`
+        );
+      }
+      return;
+    }
+  }
+});
+
+// ../fs-detectors/dist/services/auto-detect.js
+var require_auto_detect = __commonJS({
+  "../fs-detectors/dist/services/auto-detect.js"(exports2, module2) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // 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 ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var auto_detect_exports = {};
+    __export2(auto_detect_exports, {
+      autoDetectServices: () => autoDetectServices2
+    });
+    module2.exports = __toCommonJS2(auto_detect_exports);
+    var import_detect_framework = require_detect_framework();
+    var import_frameworks2 = __toESM2(require_frameworks());
+    var FRONTEND_DIR = "frontend";
+    var APPS_WEB_DIR = "apps/web";
+    var BACKEND_DIR = "backend";
+    var SERVICES_DIR = "services";
+    var FRONTEND_LOCATIONS = [FRONTEND_DIR, APPS_WEB_DIR];
+    async function autoDetectServices2(options) {
+      const { fs: fs5 } = options;
+      const rootFrameworks = await (0, import_detect_framework.detectFrameworks)({
+        fs: fs5,
+        frameworkList: import_frameworks2.default
+      });
+      if (rootFrameworks.length > 1) {
+        const frameworkNames = rootFrameworks.map((f) => f.name).join(", ");
+        return {
+          services: null,
+          errors: [
+            {
+              code: "MULTIPLE_FRAMEWORKS_ROOT",
+              message: `Multiple frameworks detected at root: ${frameworkNames}. Use explicit experimentalServices config.`
+            }
+          ]
+        };
+      }
+      if (rootFrameworks.length === 1) {
+        return detectServicesAtRoot(fs5, rootFrameworks[0]);
+      }
+      for (const frontendLocation of FRONTEND_LOCATIONS) {
+        const hasFrontendDir = await fs5.hasPath(frontendLocation);
+        if (!hasFrontendDir) {
+          continue;
+        }
+        const frontendFs = fs5.chdir(frontendLocation);
+        const frontendFrameworks = await (0, import_detect_framework.detectFrameworks)({
+          fs: frontendFs,
+          frameworkList: import_frameworks2.default
+        });
+        if (frontendFrameworks.length > 1) {
+          const frameworkNames = frontendFrameworks.map((f) => f.name).join(", ");
+          return {
+            services: null,
+            errors: [
+              {
+                code: "MULTIPLE_FRAMEWORKS_SERVICE",
+                message: `Multiple frameworks detected in ${frontendLocation}/: ${frameworkNames}. Use explicit experimentalServices config.`
+              }
+            ]
+          };
+        }
+        if (frontendFrameworks.length === 1) {
+          return detectServicesFrontendSubdir(
+            fs5,
+            frontendFrameworks[0],
+            frontendLocation
+          );
+        }
+      }
+      return {
+        services: null,
+        errors: [
+          {
+            code: "NO_SERVICES_CONFIGURED",
+            message: "No services detected. Configure experimentalServices in vercel.json or ensure a framework exists at project root, frontend/, or apps/web/."
+          }
+        ]
+      };
+    }
+    async function detectServicesAtRoot(fs5, rootFramework) {
+      const services = {};
+      services.frontend = {
+        framework: rootFramework.slug ?? void 0,
+        routePrefix: "/"
+      };
+      const backendResult = await detectBackendServices(fs5);
+      if (backendResult.error) {
+        return { services: null, errors: [backendResult.error] };
+      }
+      Object.assign(services, backendResult.services);
+      return { services, errors: [] };
+    }
+    async function detectServicesFrontendSubdir(fs5, frontendFramework, frontendLocation) {
+      const services = {};
+      const serviceName = frontendLocation.split("/").pop() || "frontend";
+      services[serviceName] = {
+        framework: frontendFramework.slug ?? void 0,
+        workspace: frontendLocation,
+        routePrefix: "/"
+      };
+      const backendResult = await detectBackendServices(fs5);
+      if (backendResult.error) {
+        return { services: null, errors: [backendResult.error] };
+      }
+      if (Object.keys(backendResult.services).length === 0) {
+        return {
+          services: null,
+          errors: [
+            {
+              code: "NO_BACKEND_SERVICES",
+              message: `Frontend detected in ${frontendLocation}/ but no backend services found. Add a backend/ or services/ directory with a supported framework.`
+            }
+          ]
+        };
+      }
+      Object.assign(services, backendResult.services);
+      return { services, errors: [] };
+    }
+    async function detectBackendServices(fs5) {
+      const services = {};
+      const backendResult = await detectServiceInDir(fs5, BACKEND_DIR, "backend");
+      if (backendResult.error) {
+        return { services: {}, error: backendResult.error };
+      }
+      if (backendResult.service) {
+        services.backend = backendResult.service;
+      }
+      const multiServicesResult = await detectServicesDirectory(fs5);
+      if (multiServicesResult.error) {
+        return { services: {}, error: multiServicesResult.error };
+      }
+      for (const serviceName of Object.keys(multiServicesResult.services)) {
+        if (services[serviceName]) {
+          return {
+            services: {},
+            error: {
+              code: "SERVICE_NAME_CONFLICT",
+              message: `Service name conflict: "${serviceName}" exists in both ${BACKEND_DIR}/ and ${SERVICES_DIR}/${serviceName}/. Rename one of the directories or use explicit experimentalServices config.`,
+              serviceName
+            }
+          };
+        }
+      }
+      Object.assign(services, multiServicesResult.services);
+      return { services };
+    }
+    async function detectServicesDirectory(fs5) {
+      const services = {};
+      const hasServicesDir = await fs5.hasPath(SERVICES_DIR);
+      if (!hasServicesDir) {
+        return { services };
+      }
+      const servicesFs = fs5.chdir(SERVICES_DIR);
+      const entries = await servicesFs.readdir("/");
+      for (const entry of entries) {
+        if (entry.type !== "dir") {
+          continue;
+        }
+        const serviceName = entry.name;
+        const serviceDir = `${SERVICES_DIR}/${serviceName}`;
+        const result = await detectServiceInDir(fs5, serviceDir, serviceName);
+        if (result.error) {
+          return { services: {}, error: result.error };
+        }
+        if (result.service) {
+          services[serviceName] = result.service;
+        }
+      }
+      return { services };
+    }
+    async function detectServiceInDir(fs5, dirPath, serviceName) {
+      const hasDirPath = await fs5.hasPath(dirPath);
+      if (!hasDirPath) {
+        return {};
+      }
+      const serviceFs = fs5.chdir(dirPath);
+      const frameworks2 = await (0, import_detect_framework.detectFrameworks)({
+        fs: serviceFs,
+        frameworkList: import_frameworks2.default
+      });
+      if (frameworks2.length > 1) {
+        const frameworkNames = frameworks2.map((f) => f.name).join(", ");
+        return {
+          error: {
+            code: "MULTIPLE_FRAMEWORKS_SERVICE",
+            message: `Multiple frameworks detected in ${dirPath}/: ${frameworkNames}. Use explicit experimentalServices config.`,
+            serviceName
+          }
+        };
+      }
+      if (frameworks2.length === 1) {
+        const framework = frameworks2[0];
+        return {
+          service: {
+            framework: framework.slug ?? void 0,
+            workspace: dirPath,
+            routePrefix: `/_/${serviceName}`
+          }
+        };
+      }
+      return {};
+    }
+  }
+});
+
 // ../fs-detectors/dist/services/detect-services.js
 var require_detect_services = __commonJS({
   "../fs-detectors/dist/services/detect-services.js"(exports2, module2) {
@@ -20033,6 +20526,7 @@ var require_detect_services = __commonJS({
     module2.exports = __toCommonJS2(detect_services_exports);
     var import_utils = require_utils4();
     var import_resolve = require_resolve();
+    var import_auto_detect = require_auto_detect();
     async function detectServices2(options) {
       const { fs: fs5, workPath } = options;
       const scopedFs = workPath ? fs5.chdir(workPath) : fs5;
@@ -20048,6 +20542,25 @@ var require_detect_services = __commonJS({
       const configuredServices = vercelConfig?.experimentalServices;
       const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
       if (!hasConfiguredServices) {
+        const autoResult = await (0, import_auto_detect.autoDetectServices)({ fs: scopedFs });
+        if (autoResult.errors.length > 0) {
+          return {
+            services: [],
+            routes: { rewrites: [], defaults: [], crons: [], workers: [] },
+            errors: autoResult.errors,
+            warnings: []
+          };
+        }
+        if (autoResult.services) {
+          const result2 = (0, import_resolve.resolveAllConfiguredServices)(autoResult.services);
+          const routes2 = generateServicesRoutes2(result2.services);
+          return {
+            services: result2.services,
+            routes: routes2,
+            errors: result2.errors,
+            warnings: []
+          };
+        }
         return {
           services: [],
           routes: { rewrites: [], defaults: [], crons: [], workers: [] },
@@ -20074,33 +20587,34 @@ var require_detect_services = __commonJS({
       const defaults = [];
       const crons = [];
       const workers = [];
-      const webServices = services.filter(
+      const sortedWebServices = services.filter(
         (s) => s.type === "web" && typeof s.routePrefix === "string"
-      );
-      const sortedWebServices = [...webServices].sort((a, b) => {
-        if (a.routePrefix === "/")
-          return 1;
-        if (b.routePrefix === "/")
-          return -1;
-        return b.routePrefix.length - a.routePrefix.length;
-      });
+      ).sort((a, b) => b.routePrefix.length - a.routePrefix.length);
       for (const service of sortedWebServices) {
-        const { routePrefix, builder } = service;
-        const builderSrc = builder.src || routePrefix;
-        const functionPath = builderSrc.startsWith("/") ? builderSrc : `/${builderSrc}`;
-        if (routePrefix === "/") {
-          defaults.push({
-            src: "^/(.*)$",
-            dest: functionPath,
-            check: true
-          });
+        const { routePrefix } = service;
+        const normalizedPrefix = routePrefix.slice(1);
+        if ((0, import_utils.isStaticBuild)(service)) {
+          if (routePrefix === "/") {
+            defaults.push({ handle: "filesystem" });
+            defaults.push({ src: "/(.*)", dest: "/index.html" });
+          } else {
+            rewrites.push({
+              src: `^/${normalizedPrefix}(?:/.*)?$`,
+              dest: `/${normalizedPrefix}/index.html`
+            });
+          }
         } else {
-          const normalizedPrefix = routePrefix.startsWith("/") ? routePrefix.slice(1) : routePrefix;
-          rewrites.push({
-            src: `^/${normalizedPrefix}(?:/.*)?$`,
-            dest: functionPath,
-            check: true
-          });
+          const builderSrc = service.builder.src || routePrefix;
+          const functionPath = builderSrc.startsWith("/") ? builderSrc : `/${builderSrc}`;
+          if (routePrefix === "/") {
+            defaults.push({ src: "^/(.*)$", dest: functionPath, check: true });
+          } else {
+            rewrites.push({
+              src: `^/${normalizedPrefix}(?:/.*)?$`,
+              dest: functionPath,
+              check: true
+            });
+          }
         }
       }
       return { rewrites, defaults, crons, workers };
@@ -21426,258 +21940,6 @@ var require_detect_file_system_api = __commonJS({
   }
 });
 
-// ../fs-detectors/dist/detect-framework.js
-var require_detect_framework = __commonJS({
-  "../fs-detectors/dist/detect-framework.js"(exports2, module2) {
-    "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-    var __export2 = (target, all) => {
-      for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
-    };
-    var __copyProps2 = (to, from, except, desc) => {
-      if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
-      }
-      return to;
-    };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var detect_framework_exports = {};
-    __export2(detect_framework_exports, {
-      detectFramework: () => detectFramework2,
-      detectFrameworkRecord: () => detectFrameworkRecord3,
-      detectFrameworkVersion: () => detectFrameworkVersion2,
-      detectFrameworks: () => detectFrameworks2,
-      removeSupersededFrameworks: () => removeSupersededFrameworks
-    });
-    module2.exports = __toCommonJS2(detect_framework_exports);
-    var import_child_process2 = require("child_process");
-    function shouldIncludeExperimentalFrameworks(useExperimentalFrameworks) {
-      if (typeof useExperimentalFrameworks === "boolean") {
-        return useExperimentalFrameworks;
-      }
-      const experimentalEnv = process.env.VERCEL_USE_EXPERIMENTAL_FRAMEWORKS;
-      const isEnabled = (val) => val === "1" || typeof val === "string" && val.toLowerCase() === "true";
-      return isEnabled(experimentalEnv);
-    }
-    function filterFrameworkList(frameworkList, useExperimentalFrameworks) {
-      if (shouldIncludeExperimentalFrameworks(useExperimentalFrameworks)) {
-        return frameworkList;
-      }
-      return frameworkList.filter((f) => {
-        const experimental = f.experimental;
-        return !experimental;
-      });
-    }
-    async function matches(fs5, framework) {
-      const { detectors } = framework;
-      if (!detectors) {
-        return;
-      }
-      const { every, some } = detectors;
-      if (every !== void 0 && !Array.isArray(every)) {
-        return;
-      }
-      if (some !== void 0 && !Array.isArray(some)) {
-        return;
-      }
-      const check = async ({
-        path: path6,
-        matchContent,
-        matchPackage
-      }) => {
-        if (matchPackage && matchContent) {
-          throw new Error(
-            `Cannot specify "matchPackage" and "matchContent" in the same detector for "${framework.slug}"`
-          );
-        }
-        if (matchPackage && path6) {
-          throw new Error(
-            `Cannot specify "matchPackage" and "path" in the same detector for "${framework.slug}" because "path" is assumed to be "package.json".`
-          );
-        }
-        if (!path6 && !matchPackage) {
-          throw new Error(
-            `Must specify either "path" or "matchPackage" in detector for "${framework.slug}".`
-          );
-        }
-        if (!path6) {
-          path6 = "package.json";
-        }
-        if (matchPackage) {
-          matchContent = `"(dev)?(d|D)ependencies":\\s*{[^}]*"${matchPackage}":\\s*"(.+?)"[^}]*}`;
-        }
-        if (await fs5.hasPath(path6) === false) {
-          return;
-        }
-        if (matchContent) {
-          if (await fs5.isFile(path6) === false) {
-            return;
-          }
-          const regex = new RegExp(matchContent, "m");
-          const content = await fs5.readFile(path6);
-          const match = content.toString().match(regex);
-          if (!match) {
-            return;
-          }
-          if (matchPackage && match[3]) {
-            return {
-              framework,
-              detectedVersion: match[3]
-            };
-          }
-        }
-        return {
-          framework
-        };
-      };
-      const result = [];
-      if (every) {
-        const everyResult = await Promise.all(every.map((item) => check(item)));
-        result.push(...everyResult);
-      }
-      if (some) {
-        let someResult;
-        for (const item of some) {
-          const itemResult = await check(item);
-          if (itemResult) {
-            someResult = itemResult;
-            break;
-          }
-        }
-        result.push(someResult);
-      }
-      if (!result.every((res) => !!res)) {
-        return;
-      }
-      const detectedVersion = result.find(
-        (r) => typeof r === "object" && r.detectedVersion
-      )?.detectedVersion;
-      return {
-        framework,
-        detectedVersion
-      };
-    }
-    function removeSupersededFramework(matches2, slug) {
-      const index = matches2.findIndex((f) => f?.slug === slug);
-      const framework = matches2[index];
-      if (framework) {
-        if (framework.supersedes) {
-          for (const slug2 of framework.supersedes) {
-            removeSupersededFramework(matches2, slug2);
-          }
-        }
-        matches2.splice(index, 1);
-      }
-    }
-    function removeSupersededFrameworks(matches2) {
-      for (const match of matches2.slice()) {
-        if (match?.supersedes) {
-          for (const slug of match.supersedes) {
-            removeSupersededFramework(matches2, slug);
-          }
-        }
-      }
-    }
-    async function detectFramework2({
-      fs: fs5,
-      frameworkList,
-      useExperimentalFrameworks
-    }) {
-      const filteredList = filterFrameworkList(
-        frameworkList,
-        useExperimentalFrameworks
-      );
-      const result = await Promise.all(
-        filteredList.map(async (frameworkMatch) => {
-          if (await matches(fs5, frameworkMatch)) {
-            return frameworkMatch;
-          }
-          return null;
-        })
-      );
-      removeSupersededFrameworks(result);
-      return result.find((res) => res !== null)?.slug ?? null;
-    }
-    async function detectFrameworks2({
-      fs: fs5,
-      frameworkList,
-      useExperimentalFrameworks
-    }) {
-      const filteredList = filterFrameworkList(
-        frameworkList,
-        useExperimentalFrameworks
-      );
-      const result = await Promise.all(
-        filteredList.map(async (frameworkMatch) => {
-          if (await matches(fs5, frameworkMatch)) {
-            return frameworkMatch;
-          }
-          return null;
-        })
-      );
-      removeSupersededFrameworks(result);
-      return result.filter((res) => res !== null);
-    }
-    async function detectFrameworkRecord3({
-      fs: fs5,
-      frameworkList,
-      useExperimentalFrameworks
-    }) {
-      const filteredList = filterFrameworkList(
-        frameworkList,
-        useExperimentalFrameworks
-      );
-      const result = await Promise.all(
-        filteredList.map(async (frameworkMatch) => {
-          const matchResult = await matches(fs5, frameworkMatch);
-          if (matchResult) {
-            return {
-              ...frameworkMatch,
-              detectedVersion: matchResult?.detectedVersion
-            };
-          }
-          return null;
-        })
-      );
-      removeSupersededFrameworks(result);
-      return result.find((res) => res !== null) ?? null;
-    }
-    function detectFrameworkVersion2(frameworkRecord) {
-      const allDetectors = [
-        ...frameworkRecord.detectors?.every || [],
-        ...frameworkRecord.detectors?.some || []
-      ];
-      const firstMatchPackage = allDetectors.find((d) => d.matchPackage);
-      if (!firstMatchPackage?.matchPackage) {
-        return;
-      }
-      return lookupInstalledVersion(
-        process.execPath,
-        firstMatchPackage.matchPackage
-      );
-    }
-    function lookupInstalledVersion(cwd, packageName) {
-      try {
-        const script = `require('${packageName}/package.json').version`;
-        return (0, import_child_process2.spawnSync)(cwd, ["-p", script], {
-          encoding: "utf-8"
-        }).stdout.trim();
-      } catch (error) {
-        console.debug(
-          `Error looking up version of installed package "${packageName}": ${error}`
-        );
-      }
-      return;
-    }
-  }
-});
-
 // ../fs-detectors/dist/get-project-paths.js
 var require_get_project_paths = __commonJS({
   "../fs-detectors/dist/get-project-paths.js"(exports2, module2) {
@@ -28914,6 +29176,7 @@ var require_dist4 = __commonJS({
       REGEX_NON_VERCEL_PLATFORM_FILES: () => import_detect_builders2.REGEX_NON_VERCEL_PLATFORM_FILES,
       Workspace: () => import_get_workspaces.Workspace,
       WorkspaceType: () => import_get_workspaces.WorkspaceType,
+      autoDetectServices: () => import_auto_detect.autoDetectServices,
       detectApiDirectory: () => import_detect_builders.detectApiDirectory,
       detectApiExtensions: () => import_detect_builders.detectApiExtensions,
       detectBuilders: () => import_detect_builders.detectBuilders,
@@ -28931,6 +29194,7 @@ var require_dist4 = __commonJS({
       getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
       getWorkspaces: () => import_get_workspaces.getWorkspaces,
       isOfficialRuntime: () => import_is_official_runtime.isOfficialRuntime,
+      isStaticBuild: () => import_utils.isStaticBuild,
       isStaticRuntime: () => import_is_official_runtime.isStaticRuntime,
       monorepoManagers: () => import_monorepo_managers.monorepoManagers,
       packageManagers: () => import_package_managers.packageManagers,
@@ -28939,6 +29203,8 @@ var require_dist4 = __commonJS({
     module2.exports = __toCommonJS2(src_exports2);
     var import_detect_builders = require_detect_builders();
     var import_detect_services = require_detect_services();
+    var import_auto_detect = require_auto_detect();
+    var import_utils = require_utils4();
     var import_get_services_builders = require_get_services_builders();
     var import_detect_file_system_api = require_detect_file_system_api();
     var import_detect_framework = require_detect_framework();
@@ -30044,8 +30310,9 @@ var build = async ({
   meta = {}
 }) => {
   await (0, import_build_utils4.download)(files, workPath, meta);
-  const mountpoint = import_path6.default.dirname(entrypoint);
-  const entrypointDir = import_path6.default.join(workPath, mountpoint);
+  const routePrefix = config.routePrefix;
+  const mountpoint = routePrefix ? routePrefix.replace(/^\//, "") || "." : import_path6.default.dirname(entrypoint);
+  const entrypointDir = import_path6.default.join(workPath, import_path6.default.dirname(entrypoint));
   let distPath = import_path6.default.join(
     workPath,
     import_path6.default.dirname(entrypoint),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-build",
-  "version": "2.8.29",
+  "version": "2.8.31",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/build-step",
@@ -15,8 +15,8 @@
   "dependencies": {
     "ts-morph": "12.0.0",
     "@vercel/gatsby-plugin-vercel-analytics": "1.0.11",
-    "@vercel/gatsby-plugin-vercel-builder": "2.0.128",
-    "@vercel/static-config": "3.1.2"
+    "@vercel/static-config": "3.1.2",
+    "@vercel/gatsby-plugin-vercel-builder": "2.0.129"
   },
   "devDependencies": {
     "@types/aws-lambda": "8.10.64",
@@ -38,10 +38,10 @@
     "rc9": "1.2.0",
     "semver": "7.5.2",
     "tree-kill": "1.2.2",
-    "@vercel/build-utils": "13.2.17",
     "@vercel/frameworks": "3.16.1",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/fs-detectors": "5.7.21",
+    "@vercel/build-utils": "13.3.0",
+    "@vercel/fs-detectors": "5.8.0",
     "@vercel/routing-utils": "5.3.2"
   },
   "scripts": {