@vercel/static-build 2.8.38 → 2.8.40

package/dist/index.js

@@ -10383,6 +10383,60 @@ var require_frameworks = __commonJS({
           }
         ]
       },
+      {
+        name: "Django",
+        slug: "django",
+        experimental: true,
+        logo: "https://api-frameworks.vercel.sh/framework-logos/django.svg",
+        tagline: "Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. ",
+        description: "A Django project served via the Python Runtime.",
+        website: "https://www.djangoproject.com",
+        supersedes: ["python"],
+        useRuntime: { src: "index.py", use: "@vercel/python" },
+        ignoreRuntimes: ["@vercel/python"],
+        detectors: {
+          some: [
+            {
+              path: "requirements.txt",
+              matchContent: "[Dd]jango"
+            },
+            {
+              path: "pyproject.toml",
+              matchContent: "[Dd]jango"
+            },
+            {
+              path: "Pipfile",
+              matchContent: "[Dd]jango"
+            }
+          ]
+        },
+        settings: {
+          installCommand: {
+            placeholder: "`pip install -r requirements.txt`"
+          },
+          buildCommand: {
+            placeholder: "None",
+            value: null
+          },
+          devCommand: {
+            placeholder: "None",
+            value: null
+          },
+          outputDirectory: {
+            value: "N/A"
+          }
+        },
+        getOutputDirName: async () => "public",
+        defaultRoutes: [
+          {
+            handle: "filesystem"
+          },
+          {
+            src: "/(.*)",
+            dest: "/"
+          }
+        ]
+      },
       {
         name: "Sanity (v3)",
         slug: "sanity-v3",
@@ -22427,15 +22481,13 @@ var require_utils4 = __commonJS({
   }
 });
 
-// ../fs-detectors/dist/services/resolve.js
-var require_resolve = __commonJS({
-  "../fs-detectors/dist/services/resolve.js"(exports2, module2) {
+// ../fs-detectors/dist/detect-framework.js
+var require_detect_framework = __commonJS({
+  "../fs-detectors/dist/detect-framework.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)
@@ -22449,300 +22501,247 @@ var require_resolve = __commonJS({
       }
       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 resolve_exports = {};
-    __export2(resolve_exports, {
-      resolveAllConfiguredServices: () => resolveAllConfiguredServices,
-      resolveConfiguredService: () => resolveConfiguredService,
-      validateServiceConfig: () => validateServiceConfig
+    var detect_framework_exports = {};
+    __export2(detect_framework_exports, {
+      detectFramework: () => detectFramework2,
+      detectFrameworkRecord: () => detectFrameworkRecord3,
+      detectFrameworkVersion: () => detectFrameworkVersion2,
+      detectFrameworks: () => detectFrameworks2,
+      removeSupersededFrameworks: () => removeSupersededFrameworks
     });
-    module2.exports = __toCommonJS2(resolve_exports);
-    var import_path7 = require("path");
-    var import_types = require_types3();
-    var import_utils = require_utils4();
-    var import_frameworks2 = __toESM2(require_frameworks());
-    var import_routing_utils = require_dist6();
-    var frameworksBySlug = new Map(import_frameworks2.default.map((f) => [f.slug, f]));
-    var SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
-    function toWorkspaceRelativeEntrypoint(entrypoint, workspace) {
-      const normalizedEntrypoint = import_path7.posix.normalize(entrypoint);
-      if (workspace === ".") {
-        return normalizedEntrypoint;
-      }
-      const workspacePrefix = `${workspace}/`;
-      if (normalizedEntrypoint.startsWith(workspacePrefix)) {
-        return normalizedEntrypoint.slice(workspacePrefix.length);
+    module2.exports = __toCommonJS2(detect_framework_exports);
+    var import_child_process2 = require("child_process");
+    function shouldIncludeExperimentalFrameworks(useExperimentalFrameworks) {
+      if (typeof useExperimentalFrameworks === "boolean") {
+        return useExperimentalFrameworks;
       }
-      const relativeEntrypoint = import_path7.posix.relative(
-        workspace,
-        normalizedEntrypoint
-      );
-      if (relativeEntrypoint === "" || relativeEntrypoint.startsWith("..")) {
-        return normalizedEntrypoint;
+      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 relativeEntrypoint;
+      return frameworkList.filter((f) => {
+        const experimental = f.experimental;
+        return !experimental;
+      });
     }
-    async function inferWorkspaceFromNearestManifest({
-      fs: fs5,
-      entrypoint,
-      runtime
-    }) {
-      if (!entrypoint || !runtime) {
-        return void 0;
+    async function matches(fs5, framework) {
+      const { detectors } = framework;
+      if (!detectors) {
+        return;
       }
-      const manifests = import_types.RUNTIME_MANIFESTS[runtime];
-      if (!manifests || manifests.length === 0) {
-        return void 0;
+      const { every, some } = detectors;
+      if (every !== void 0 && !Array.isArray(every)) {
+        return;
       }
-      let dir = import_path7.posix.dirname(import_path7.posix.normalize(entrypoint)) || ".";
-      if (dir === "") {
-        dir = ".";
+      if (some !== void 0 && !Array.isArray(some)) {
+        return;
       }
-      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)) {
-            return dir;
-          }
+      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 (dir === "." || dir === "/") {
-          reachedRoot = true;
-        } else {
-          const parent = import_path7.posix.dirname(dir);
-          if (!parent || parent === dir) {
-            reachedRoot = true;
-          } else {
-            dir = parent;
+        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 void 0;
-    }
-    function isReservedServiceRoutePrefix(routePrefix) {
-      const normalized = (0, import_routing_utils.normalizeRoutePrefix)(routePrefix);
-      return normalized === import_utils.INTERNAL_SERVICE_PREFIX || normalized.startsWith(`${import_utils.INTERNAL_SERVICE_PREFIX}/`);
-    }
-    function validateServiceConfig(name, config) {
-      if (!SERVICE_NAME_REGEX.test(name)) {
-        return {
-          code: "INVALID_SERVICE_NAME",
-          message: `Service name "${name}" is invalid. Names must start with a letter, end with an alphanumeric character, and contain only alphanumeric characters, hyphens, and underscores.`,
-          serviceName: name
-        };
-      }
-      if (!config || typeof config !== "object") {
-        return {
-          code: "INVALID_SERVICE_CONFIG",
-          message: `Service "${name}" has an invalid configuration. Expected an object.`,
-          serviceName: name
-        };
-      }
-      const serviceType = config.type || "web";
-      if (serviceType === "web" && !config.routePrefix) {
-        return {
-          code: "MISSING_ROUTE_PREFIX",
-          message: `Web service "${name}" must specify "routePrefix".`,
-          serviceName: name
-        };
-      }
-      if (serviceType === "web" && config.routePrefix && isReservedServiceRoutePrefix(config.routePrefix)) {
         return {
-          code: "RESERVED_ROUTE_PREFIX",
-          message: `Web service "${name}" cannot use routePrefix "${config.routePrefix}". The "${import_utils.INTERNAL_SERVICE_PREFIX}" prefix is reserved for internal services routing.`,
-          serviceName: name
+          framework
         };
+      };
+      const result = [];
+      if (every) {
+        const everyResult = await Promise.all(every.map((item) => check(item)));
+        result.push(...everyResult);
       }
-      if ((serviceType === "worker" || serviceType === "cron") && config.routePrefix) {
-        return {
-          code: "INVALID_ROUTE_PREFIX",
-          message: `${serviceType === "worker" ? "Worker" : "Cron"} service "${name}" cannot have "routePrefix". Only web services should specify "routePrefix".`,
-          serviceName: name
-        };
+      if (some) {
+        let someResult;
+        for (const item of some) {
+          const itemResult = await check(item);
+          if (itemResult) {
+            someResult = itemResult;
+            break;
+          }
+        }
+        result.push(someResult);
       }
-      if (serviceType === "cron" && !config.schedule) {
-        return {
-          code: "MISSING_CRON_SCHEDULE",
-          message: `Cron service "${name}" is missing required "schedule" field.`,
-          serviceName: name
-        };
+      if (!result.every((res) => !!res)) {
+        return;
       }
-      if (config.runtime && !(config.runtime in import_types.RUNTIME_BUILDERS)) {
-        return {
-          code: "INVALID_RUNTIME",
-          message: `Service "${name}" has invalid runtime "${config.runtime}".`,
-          serviceName: name
-        };
-      }
-      if (config.framework && !frameworksBySlug.has(config.framework)) {
-        return {
-          code: "INVALID_FRAMEWORK",
-          message: `Service "${name}" has invalid framework "${config.framework}".`,
-          serviceName: name
-        };
-      }
-      const hasFramework = Boolean(config.framework);
-      const hasBuilderOrRuntime = Boolean(config.builder || config.runtime);
-      const hasEntrypoint = Boolean(config.entrypoint);
-      if (!hasFramework && !hasBuilderOrRuntime && !hasEntrypoint) {
-        return {
-          code: "MISSING_SERVICE_CONFIG",
-          message: `Service "${name}" must specify "framework", "entrypoint", or both "builder"/"runtime" with "entrypoint".`,
-          serviceName: name
-        };
-      }
-      if (hasBuilderOrRuntime && !hasFramework && !hasEntrypoint) {
-        return {
-          code: "MISSING_ENTRYPOINT",
-          message: `Service "${name}" must specify "entrypoint" when using "${config.builder ? "builder" : "runtime"}".`,
-          serviceName: name
-        };
-      }
-      if (hasEntrypoint && !hasBuilderOrRuntime && !hasFramework) {
-        const runtime = (0, import_utils.inferServiceRuntime)({ entrypoint: config.entrypoint });
-        if (!runtime) {
-          const supported = Object.keys(import_types.ENTRYPOINT_EXTENSIONS).join(", ");
-          return {
-            code: "UNSUPPORTED_ENTRYPOINT",
-            message: `Service "${name}" has unsupported entrypoint "${config.entrypoint}". Use a supported extension (${supported}) or specify "builder", "framework", or "runtime".`,
-            serviceName: name
-          };
+      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);
       }
-      return null;
     }
-    async function resolveConfiguredService(name, config, fs5, group) {
-      const type = config.type || "web";
-      const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
-      let workspace = config.workspace || ".";
-      let resolvedEntrypoint = config.entrypoint;
-      if (!config.workspace) {
-        const inferredWorkspace = await inferWorkspaceFromNearestManifest({
-          fs: fs5,
-          entrypoint: resolvedEntrypoint,
-          runtime: inferredRuntime
-        });
-        if (inferredWorkspace) {
-          workspace = inferredWorkspace;
-          if (resolvedEntrypoint) {
-            resolvedEntrypoint = toWorkspaceRelativeEntrypoint(
-              resolvedEntrypoint,
-              inferredWorkspace
-            );
+    function removeSupersededFrameworks(matches2) {
+      for (const match of matches2.slice()) {
+        if (match?.supersedes) {
+          for (const slug of match.supersedes) {
+            removeSupersededFramework(matches2, slug);
           }
         }
       }
-      const topic = type === "worker" ? config.topic || "default" : config.topic;
-      const consumer = type === "worker" ? config.consumer || "default" : config.consumer;
-      let builderUse;
-      let builderSrc;
-      if (config.framework) {
-        const framework = frameworksBySlug.get(config.framework);
-        builderUse = framework?.useRuntime?.use || "@vercel/static-build";
-        builderSrc = resolvedEntrypoint || framework?.useRuntime?.src || "package.json";
-      } else if (config.builder) {
-        builderUse = config.builder;
-        builderSrc = resolvedEntrypoint;
-      } else {
-        builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
-        builderSrc = resolvedEntrypoint;
-      }
-      const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
-      const isRoot = workspace === ".";
-      if (!isRoot) {
-        builderSrc = import_path7.posix.join(workspace, builderSrc);
-      }
-      const builderConfig = { zeroConfig: true };
-      if (config.memory)
-        builderConfig.memory = config.memory;
-      if (config.maxDuration)
-        builderConfig.maxDuration = config.maxDuration;
-      if (config.includeFiles)
-        builderConfig.includeFiles = config.includeFiles;
-      if (config.excludeFiles)
-        builderConfig.excludeFiles = config.excludeFiles;
-      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 (workspace && workspace !== ".") {
-        builderConfig.workspace = workspace;
-      }
-      if (config.framework) {
-        builderConfig.framework = config.framework;
-      }
-      return {
-        name,
-        type,
-        group,
-        workspace,
-        entrypoint: resolvedEntrypoint,
-        routePrefix,
-        framework: config.framework,
-        builder: {
-          src: builderSrc,
-          use: builderUse,
-          config: Object.keys(builderConfig).length > 0 ? builderConfig : void 0
-        },
-        runtime,
-        buildCommand: config.buildCommand,
-        installCommand: config.installCommand,
-        schedule: config.schedule,
-        topic,
-        consumer
-      };
     }
-    async function resolveAllConfiguredServices(services, fs5) {
-      const resolved = [];
-      const errors = [];
-      const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
-      for (const name of Object.keys(services)) {
-        const serviceConfig = services[name];
-        const validationError = validateServiceConfig(name, serviceConfig);
-        if (validationError) {
-          errors.push(validationError);
-          continue;
-        }
-        const service = await resolveConfiguredService(name, serviceConfig, fs5);
-        if (service.type === "web" && typeof service.routePrefix === "string") {
-          const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix);
-          const existingServiceName = webServicesByRoutePrefix.get(
-            normalizedRoutePrefix
-          );
-          if (existingServiceName) {
-            errors.push({
-              code: "DUPLICATE_ROUTE_PREFIX",
-              message: `Web services "${existingServiceName}" and "${name}" cannot share routePrefix "${normalizedRoutePrefix}".`,
-              serviceName: name
-            });
-            continue;
+    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;
           }
-          webServicesByRoutePrefix.set(normalizedRoutePrefix, name);
-        }
-        resolved.push(service);
+          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 { services: resolved, errors };
+      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/detect-framework.js
-var require_detect_framework = __commonJS({
-  "../fs-detectors/dist/detect-framework.js"(exports2, module2) {
+// ../fs-detectors/dist/services/resolve.js
+var require_resolve = __commonJS({
+  "../fs-detectors/dist/services/resolve.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)
@@ -22756,234 +22755,434 @@ var require_detect_framework = __commonJS({
       }
       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
+    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 resolve_exports = {};
+    __export2(resolve_exports, {
+      resolveAllConfiguredServices: () => resolveAllConfiguredServices,
+      resolveConfiguredService: () => resolveConfiguredService,
+      validateServiceConfig: () => validateServiceConfig,
+      validateServiceEntrypoint: () => validateServiceEntrypoint
     });
-    module2.exports = __toCommonJS2(detect_framework_exports);
-    var import_child_process2 = require("child_process");
-    function shouldIncludeExperimentalFrameworks(useExperimentalFrameworks) {
-      if (typeof useExperimentalFrameworks === "boolean") {
-        return useExperimentalFrameworks;
+    module2.exports = __toCommonJS2(resolve_exports);
+    var import_path7 = require("path");
+    var import_types = require_types3();
+    var import_utils = require_utils4();
+    var import_frameworks2 = __toESM2(require_frameworks());
+    var import_detect_framework = require_detect_framework();
+    var import_routing_utils = require_dist6();
+    var frameworksBySlug = new Map(import_frameworks2.default.map((f) => [f.slug, f]));
+    var SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+    function normalizeServiceEntrypoint(entrypoint) {
+      const normalized = import_path7.posix.normalize(entrypoint);
+      return normalized === "" ? "." : normalized;
+    }
+    async function resolveEntrypointPath({
+      fs: fs5,
+      serviceName,
+      entrypoint
+    }) {
+      const normalized = normalizeServiceEntrypoint(entrypoint);
+      if (!await fs5.hasPath(normalized)) {
+        return {
+          error: {
+            code: "ENTRYPOINT_NOT_FOUND",
+            message: `Service "${serviceName}" has entrypoint "${entrypoint}" but that path does not exist.`,
+            serviceName
+          }
+        };
       }
-      const experimentalEnv = process.env.VERCEL_USE_EXPERIMENTAL_FRAMEWORKS;
-      const isEnabled = (val) => val === "1" || typeof val === "string" && val.toLowerCase() === "true";
-      return isEnabled(experimentalEnv);
+      return {
+        entrypoint: {
+          normalized,
+          isDirectory: !await fs5.isFile(normalized)
+        }
+      };
     }
-    function filterFrameworkList(frameworkList, useExperimentalFrameworks) {
-      if (shouldIncludeExperimentalFrameworks(useExperimentalFrameworks)) {
-        return frameworkList;
+    function toWorkspaceRelativeEntrypoint(entrypoint, workspace) {
+      const normalizedEntrypoint = import_path7.posix.normalize(entrypoint);
+      if (workspace === ".") {
+        return normalizedEntrypoint;
       }
-      return frameworkList.filter((f) => {
-        const experimental = f.experimental;
-        return !experimental;
-      });
+      const workspacePrefix = `${workspace}/`;
+      if (normalizedEntrypoint.startsWith(workspacePrefix)) {
+        return normalizedEntrypoint.slice(workspacePrefix.length);
+      }
+      const relativeEntrypoint = import_path7.posix.relative(
+        workspace,
+        normalizedEntrypoint
+      );
+      if (relativeEntrypoint === "" || relativeEntrypoint.startsWith("..")) {
+        return normalizedEntrypoint;
+      }
+      return relativeEntrypoint;
     }
-    async function matches(fs5, framework) {
-      const { detectors } = framework;
-      if (!detectors) {
-        return;
+    async function inferWorkspaceFromNearestManifest({
+      fs: fs5,
+      entrypoint,
+      runtime
+    }) {
+      if (!entrypoint || !runtime) {
+        return void 0;
       }
-      const { every, some } = detectors;
-      if (every !== void 0 && !Array.isArray(every)) {
-        return;
+      const manifests = import_types.RUNTIME_MANIFESTS[runtime];
+      if (!manifests || manifests.length === 0) {
+        return void 0;
       }
-      if (some !== void 0 && !Array.isArray(some)) {
-        return;
+      let dir = import_path7.posix.dirname(import_path7.posix.normalize(entrypoint)) || ".";
+      if (dir === "") {
+        dir = ".";
       }
-      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;
+      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)) {
+            return dir;
           }
-          if (matchPackage && match[3]) {
-            return {
-              framework,
-              detectedVersion: match[3]
-            };
+        }
+        if (dir === "." || dir === "/") {
+          reachedRoot = true;
+        } else {
+          const parent = import_path7.posix.dirname(dir);
+          if (!parent || parent === dir) {
+            reachedRoot = true;
+          } else {
+            dir = parent;
           }
         }
+      }
+      return void 0;
+    }
+    async function detectFrameworkFromWorkspace({
+      fs: fs5,
+      workspace,
+      serviceName
+    }) {
+      const serviceFs = workspace === "." ? fs5 : fs5.chdir(workspace);
+      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 {
-          framework
+          error: {
+            code: "MULTIPLE_FRAMEWORKS_SERVICE",
+            message: `Multiple frameworks detected in ${workspace === "." ? "project root" : `${workspace}/`}: ${frameworkNames}. Specify "framework" explicitly in experimentalServices.`,
+            serviceName
+          }
         };
-      };
-      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;
+      if (frameworks2.length === 1) {
+        return {
+          framework: frameworks2[0].slug ?? void 0
+        };
+      }
+      return {};
+    }
+    function isReservedServiceRoutePrefix(routePrefix) {
+      const normalized = (0, import_routing_utils.normalizeRoutePrefix)(routePrefix);
+      return normalized === import_utils.INTERNAL_SERVICE_PREFIX || normalized.startsWith(`${import_utils.INTERNAL_SERVICE_PREFIX}/`);
+    }
+    function validateServiceConfig(name, config) {
+      if (!SERVICE_NAME_REGEX.test(name)) {
+        return {
+          code: "INVALID_SERVICE_NAME",
+          message: `Service name "${name}" is invalid. Names must start with a letter, end with an alphanumeric character, and contain only alphanumeric characters, hyphens, and underscores.`,
+          serviceName: name
+        };
+      }
+      if (!config || typeof config !== "object") {
+        return {
+          code: "INVALID_SERVICE_CONFIG",
+          message: `Service "${name}" has an invalid configuration. Expected an object.`,
+          serviceName: name
+        };
+      }
+      const serviceType = config.type || "web";
+      if (serviceType === "web" && !config.routePrefix) {
+        return {
+          code: "MISSING_ROUTE_PREFIX",
+          message: `Web service "${name}" must specify "routePrefix".`,
+          serviceName: name
+        };
+      }
+      if (serviceType === "web" && config.routePrefix && isReservedServiceRoutePrefix(config.routePrefix)) {
+        return {
+          code: "RESERVED_ROUTE_PREFIX",
+          message: `Web service "${name}" cannot use routePrefix "${config.routePrefix}". The "${import_utils.INTERNAL_SERVICE_PREFIX}" prefix is reserved for internal services routing.`,
+          serviceName: name
+        };
+      }
+      if ((serviceType === "worker" || serviceType === "cron") && config.routePrefix) {
+        return {
+          code: "INVALID_ROUTE_PREFIX",
+          message: `${serviceType === "worker" ? "Worker" : "Cron"} service "${name}" cannot have "routePrefix". Only web services should specify "routePrefix".`,
+          serviceName: name
+        };
+      }
+      if (serviceType === "cron" && !config.schedule) {
+        return {
+          code: "MISSING_CRON_SCHEDULE",
+          message: `Cron service "${name}" is missing required "schedule" field.`,
+          serviceName: name
+        };
+      }
+      if (config.runtime && !(config.runtime in import_types.RUNTIME_BUILDERS)) {
+        return {
+          code: "INVALID_RUNTIME",
+          message: `Service "${name}" has invalid runtime "${config.runtime}".`,
+          serviceName: name
+        };
+      }
+      if (config.framework && !frameworksBySlug.has(config.framework)) {
+        return {
+          code: "INVALID_FRAMEWORK",
+          message: `Service "${name}" has invalid framework "${config.framework}".`,
+          serviceName: name
+        };
+      }
+      const hasFramework = Boolean(config.framework);
+      const hasBuilderOrRuntime = Boolean(config.builder || config.runtime);
+      const hasEntrypoint = Boolean(config.entrypoint);
+      if (!hasFramework && !hasBuilderOrRuntime && !hasEntrypoint) {
+        return {
+          code: "MISSING_SERVICE_CONFIG",
+          message: `Service "${name}" must specify "framework", "entrypoint", or both "builder"/"runtime" with "entrypoint".`,
+          serviceName: name
+        };
+      }
+      if (hasBuilderOrRuntime && !hasFramework && !hasEntrypoint) {
+        return {
+          code: "MISSING_ENTRYPOINT",
+          message: `Service "${name}" must specify "entrypoint" when using "${config.builder ? "builder" : "runtime"}".`,
+          serviceName: name
+        };
+      }
+      return null;
+    }
+    function validateServiceEntrypoint(name, config, resolvedEntrypoint) {
+      if (!resolvedEntrypoint.isDirectory && !config.builder && !config.runtime && !config.framework) {
+        const runtime = (0, import_utils.inferServiceRuntime)({ entrypoint: config.entrypoint });
+        if (!runtime) {
+          const supported = Object.keys(import_types.ENTRYPOINT_EXTENSIONS).join(", ");
+          return {
+            code: "UNSUPPORTED_ENTRYPOINT",
+            message: `Service "${name}" has unsupported entrypoint "${config.entrypoint}". Use a supported extension (${supported}) or specify "builder", "framework", or "runtime".`,
+            serviceName: name
+          };
+        }
+      }
+      return null;
+    }
+    async function resolveConfiguredService(options) {
+      const {
+        name,
+        config,
+        fs: fs5,
+        group,
+        resolvedEntrypoint,
+        routePrefixSource = "configured"
+      } = options;
+      const type = config.type || "web";
+      const rawEntrypoint = config.entrypoint;
+      let resolvedEntrypointPath = resolvedEntrypoint;
+      if (!resolvedEntrypointPath && typeof rawEntrypoint === "string") {
+        const resolved = await resolveEntrypointPath({
+          fs: fs5,
+          serviceName: name,
+          entrypoint: rawEntrypoint
+        });
+        resolvedEntrypointPath = resolved.entrypoint;
+      }
+      if (typeof rawEntrypoint === "string" && !resolvedEntrypointPath) {
+        throw new Error(
+          `Failed to resolve entrypoint "${rawEntrypoint}" for service "${name}".`
+        );
+      }
+      const normalizedEntrypoint = resolvedEntrypointPath?.normalized;
+      const entrypointIsDirectory = Boolean(resolvedEntrypointPath?.isDirectory);
+      const inferredRuntime = (0, import_utils.inferServiceRuntime)({
+        ...config,
+        entrypoint: entrypointIsDirectory ? void 0 : normalizedEntrypoint
+      });
+      let workspace = ".";
+      let resolvedEntrypointFile = entrypointIsDirectory || !normalizedEntrypoint ? void 0 : normalizedEntrypoint;
+      if (entrypointIsDirectory && normalizedEntrypoint) {
+        workspace = normalizedEntrypoint;
+      } else {
+        const inferredWorkspace = await inferWorkspaceFromNearestManifest({
+          fs: fs5,
+          entrypoint: resolvedEntrypointFile,
+          runtime: inferredRuntime
+        });
+        if (inferredWorkspace) {
+          workspace = inferredWorkspace;
+          if (resolvedEntrypointFile) {
+            resolvedEntrypointFile = toWorkspaceRelativeEntrypoint(
+              resolvedEntrypointFile,
+              inferredWorkspace
+            );
           }
         }
-        result.push(someResult);
       }
-      if (!result.every((res) => !!res)) {
-        return;
+      const topic = type === "worker" ? config.topic || "default" : config.topic;
+      const consumer = type === "worker" ? config.consumer || "default" : config.consumer;
+      let builderUse;
+      let builderSrc;
+      if (config.framework) {
+        const framework = frameworksBySlug.get(config.framework);
+        builderUse = framework?.useRuntime?.use || "@vercel/static-build";
+        builderSrc = resolvedEntrypointFile || framework?.useRuntime?.src || "package.json";
+      } else if (config.builder) {
+        builderUse = config.builder;
+        builderSrc = resolvedEntrypointFile;
+      } else {
+        builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
+        builderSrc = resolvedEntrypointFile;
+      }
+      const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
+      const isRoot = workspace === ".";
+      if (!isRoot) {
+        builderSrc = import_path7.posix.join(workspace, builderSrc);
+      }
+      const builderConfig = { zeroConfig: true };
+      if (config.memory)
+        builderConfig.memory = config.memory;
+      if (config.maxDuration)
+        builderConfig.maxDuration = config.maxDuration;
+      if (config.includeFiles)
+        builderConfig.includeFiles = config.includeFiles;
+      if (config.excludeFiles)
+        builderConfig.excludeFiles = config.excludeFiles;
+      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 (workspace && workspace !== ".") {
+        builderConfig.workspace = workspace;
+      }
+      if (config.framework) {
+        builderConfig.framework = config.framework;
       }
-      const detectedVersion = result.find(
-        (r) => typeof r === "object" && r.detectedVersion
-      )?.detectedVersion;
       return {
-        framework,
-        detectedVersion
+        name,
+        type,
+        group,
+        workspace,
+        entrypoint: resolvedEntrypointFile,
+        routePrefix,
+        routePrefixSource: type === "web" && typeof routePrefix === "string" ? routePrefixSource : void 0,
+        framework: config.framework,
+        builder: {
+          src: builderSrc,
+          use: builderUse,
+          config: Object.keys(builderConfig).length > 0 ? builderConfig : void 0
+        },
+        runtime,
+        buildCommand: config.buildCommand,
+        installCommand: config.installCommand,
+        schedule: config.schedule,
+        topic,
+        consumer
       };
     }
-    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);
+    async function resolveAllConfiguredServices(services, fs5, routePrefixSource = "configured") {
+      const resolved = [];
+      const errors = [];
+      const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
+      for (const name of Object.keys(services)) {
+        const serviceConfig = services[name];
+        const validationError = validateServiceConfig(name, serviceConfig);
+        if (validationError) {
+          errors.push(validationError);
+          continue;
+        }
+        let resolvedEntrypoint;
+        if (typeof serviceConfig.entrypoint === "string") {
+          const resolvedPath = await resolveEntrypointPath({
+            fs: fs5,
+            serviceName: name,
+            entrypoint: serviceConfig.entrypoint
+          });
+          if (resolvedPath.error) {
+            errors.push(resolvedPath.error);
+            continue;
           }
+          resolvedEntrypoint = resolvedPath.entrypoint;
         }
-        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);
+        if (resolvedEntrypoint) {
+          const entrypointError = validateServiceEntrypoint(
+            name,
+            serviceConfig,
+            resolvedEntrypoint
+          );
+          if (entrypointError) {
+            errors.push(entrypointError);
+            continue;
           }
         }
-      }
-    }
-    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;
+        let resolvedConfig = serviceConfig;
+        const shouldDetectFramework = !serviceConfig.framework && Boolean(resolvedEntrypoint?.isDirectory);
+        if (shouldDetectFramework) {
+          const workspace = resolvedEntrypoint.normalized;
+          const { framework, error } = await detectFrameworkFromWorkspace({
+            fs: fs5,
+            workspace,
+            serviceName: name
+          });
+          if (error) {
+            errors.push(error);
+            continue;
           }
-          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;
+          if (!framework) {
+            errors.push({
+              code: "MISSING_SERVICE_FRAMEWORK",
+              message: `Service "${name}" uses directory entrypoint "${serviceConfig.entrypoint}" but no framework could be detected in "${workspace}". Specify "framework" explicitly or use a file entrypoint.`,
+              serviceName: name
+            });
+            continue;
           }
-          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
-            };
+          resolvedConfig = {
+            ...serviceConfig,
+            framework
+          };
+        }
+        const service = await resolveConfiguredService({
+          name,
+          config: resolvedConfig,
+          fs: fs5,
+          resolvedEntrypoint,
+          routePrefixSource
+        });
+        if (service.type === "web" && typeof service.routePrefix === "string") {
+          const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix);
+          const existingServiceName = webServicesByRoutePrefix.get(
+            normalizedRoutePrefix
+          );
+          if (existingServiceName) {
+            errors.push({
+              code: "DUPLICATE_ROUTE_PREFIX",
+              message: `Web services "${existingServiceName}" and "${name}" cannot share routePrefix "${normalizedRoutePrefix}".`,
+              serviceName: name
+            });
+            continue;
           }
-          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}`
-        );
+          webServicesByRoutePrefix.set(normalizedRoutePrefix, name);
+        }
+        resolved.push(service);
       }
-      return;
+      return { services: resolved, errors };
     }
   }
 });
@@ -23110,7 +23309,7 @@ var require_auto_detect = __commonJS({
       const serviceName = frontendLocation.split("/").pop() || "frontend";
       services[serviceName] = {
         framework: frontendFramework.slug ?? void 0,
-        workspace: frontendLocation,
+        entrypoint: frontendLocation,
         routePrefix: "/"
       };
       const backendResult = await detectBackendServices(fs5);
@@ -23208,7 +23407,7 @@ var require_auto_detect = __commonJS({
         return {
           service: {
             framework: framework.slug ?? void 0,
-            workspace: dirPath,
+            entrypoint: dirPath,
             routePrefix: `/_/${serviceName}`
           }
         };
@@ -23276,7 +23475,8 @@ var require_detect_services = __commonJS({
         if (autoResult.services) {
           const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
             autoResult.services,
-            scopedFs
+            scopedFs,
+            "generated"
           );
           const routes2 = generateServicesRoutes2(result2.services);
           return {
@@ -23300,7 +23500,8 @@ var require_detect_services = __commonJS({
       }
       const result = await (0, import_resolve.resolveAllConfiguredServices)(
         configuredServices,
-        scopedFs
+        scopedFs,
+        "configured"
       );
       const routes = generateServicesRoutes2(result.services);
       return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-build",
-  "version": "2.8.38",
+  "version": "2.8.40",
   "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-analytics": "1.0.11",
+    "@vercel/gatsby-plugin-vercel-builder": "2.0.138",
     "@vercel/static-config": "3.1.2",
-    "@vercel/gatsby-plugin-vercel-builder": "2.0.136"
+    "@vercel/gatsby-plugin-vercel-analytics": "1.0.11"
   },
   "devDependencies": {
     "@types/aws-lambda": "8.10.64",
@@ -38,11 +38,11 @@
     "rc9": "1.2.0",
     "semver": "7.5.2",
     "tree-kill": "1.2.2",
-    "@vercel/build-utils": "13.4.1",
-    "@vercel/error-utils": "2.0.3",
+    "@vercel/frameworks": "3.18.0",
     "@vercel/routing-utils": "5.3.3",
-    "@vercel/fs-detectors": "5.8.8",
-    "@vercel/frameworks": "3.18.0"
+    "@vercel/build-utils": "13.4.3",
+    "@vercel/fs-detectors": "5.8.9",
+    "@vercel/error-utils": "2.0.3"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",