@vercel/static-build 2.8.39 → 2.8.41

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",
@@ -22383,6 +22437,9 @@ var require_utils4 = __commonJS({
       if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
         return config.runtime;
       }
+      if (config.framework && config.framework in import_types.RUNTIME_BUILDERS) {
+        return config.framework;
+      }
       if ((0, import_framework_helpers.isPythonFramework)(config.framework)) {
         return "python";
       }
@@ -22427,15 +22484,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,131 +22504,440 @@ 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;
+      }
+      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/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)
+        __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 resolve_exports = {};
+    __export2(resolve_exports, {
+      resolveAllConfiguredServices: () => resolveAllConfiguredServices,
+      resolveConfiguredService: () => resolveConfiguredService,
+      validateServiceConfig: () => validateServiceConfig,
+      validateServiceEntrypoint: () => validateServiceEntrypoint
+    });
+    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
+          }
+        };
+      }
+      return {
+        entrypoint: {
+          normalized,
+          isDirectory: !await fs5.isFile(normalized)
+        }
+      };
+    }
+    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);
+      }
+      const relativeEntrypoint = import_path7.posix.relative(
+        workspace,
+        normalizedEntrypoint
+      );
+      if (relativeEntrypoint === "" || relativeEntrypoint.startsWith("..")) {
+        return normalizedEntrypoint;
+      }
+      return relativeEntrypoint;
+    }
+    async function inferWorkspaceFromNearestManifest({
+      fs: fs5,
+      entrypoint,
+      runtime
+    }) {
+      if (!entrypoint || !runtime) {
+        return void 0;
+      }
+      const manifests = import_types.RUNTIME_MANIFESTS[runtime];
+      if (!manifests || manifests.length === 0) {
+        return void 0;
+      }
+      let dir = import_path7.posix.dirname(import_path7.posix.normalize(entrypoint)) || ".";
+      if (dir === "") {
+        dir = ".";
+      }
+      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 (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 {
+          error: {
+            code: "MULTIPLE_FRAMEWORKS_SERVICE",
+            message: `Multiple frameworks detected in ${workspace === "." ? "project root" : `${workspace}/`}: ${frameworkNames}. Specify "framework" explicitly in experimentalServices.`,
+            serviceName
+          }
+        };
+      }
+      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 {
@@ -22606,7 +22970,10 @@ var require_resolve = __commonJS({
           serviceName: name
         };
       }
-      if (hasEntrypoint && !hasBuilderOrRuntime && !hasFramework) {
+      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(", ");
@@ -22619,22 +22986,52 @@ var require_resolve = __commonJS({
       }
       return null;
     }
-    async function resolveConfiguredService(name, config, fs5, group) {
+    async function resolveConfiguredService(options) {
+      const {
+        name,
+        config,
+        fs: fs5,
+        group,
+        resolvedEntrypoint,
+        routePrefixSource = "configured"
+      } = options;
       const type = config.type || "web";
-      const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
-      let workspace = config.workspace || ".";
-      let resolvedEntrypoint = config.entrypoint;
-      if (!config.workspace) {
+      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: resolvedEntrypoint,
+          entrypoint: resolvedEntrypointFile,
           runtime: inferredRuntime
         });
         if (inferredWorkspace) {
           workspace = inferredWorkspace;
-          if (resolvedEntrypoint) {
-            resolvedEntrypoint = toWorkspaceRelativeEntrypoint(
-              resolvedEntrypoint,
+          if (resolvedEntrypointFile) {
+            resolvedEntrypointFile = toWorkspaceRelativeEntrypoint(
+              resolvedEntrypointFile,
               inferredWorkspace
             );
           }
@@ -22647,13 +23044,13 @@ var require_resolve = __commonJS({
       if (config.framework) {
         const framework = frameworksBySlug.get(config.framework);
         builderUse = framework?.useRuntime?.use || "@vercel/static-build";
-        builderSrc = resolvedEntrypoint || framework?.useRuntime?.src || "package.json";
+        builderSrc = resolvedEntrypointFile || framework?.useRuntime?.src || "package.json";
       } else if (config.builder) {
         builderUse = config.builder;
-        builderSrc = resolvedEntrypoint;
+        builderSrc = resolvedEntrypointFile;
       } else {
         builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
-        builderSrc = resolvedEntrypoint;
+        builderSrc = resolvedEntrypointFile;
       }
       const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
       const isRoot = workspace === ".";
@@ -22686,8 +23083,9 @@ var require_resolve = __commonJS({
         type,
         group,
         workspace,
-        entrypoint: resolvedEntrypoint,
+        entrypoint: resolvedEntrypointFile,
         routePrefix,
+        routePrefixSource: type === "web" && typeof routePrefix === "string" ? routePrefixSource : void 0,
         framework: config.framework,
         builder: {
           src: builderSrc,
@@ -22702,7 +23100,7 @@ var require_resolve = __commonJS({
         consumer
       };
     }
-    async function resolveAllConfiguredServices(services, fs5) {
+    async function resolveAllConfiguredServices(services, fs5, routePrefixSource = "configured") {
       const resolved = [];
       const errors = [];
       const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
@@ -22713,7 +23111,63 @@ var require_resolve = __commonJS({
           errors.push(validationError);
           continue;
         }
-        const service = await resolveConfiguredService(name, serviceConfig, fs5);
+        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;
+        }
+        if (resolvedEntrypoint) {
+          const entrypointError = validateServiceEntrypoint(
+            name,
+            serviceConfig,
+            resolvedEntrypoint
+          );
+          if (entrypointError) {
+            errors.push(entrypointError);
+            continue;
+          }
+        }
+        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;
+          }
+          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;
+          }
+          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(
@@ -22736,258 +23190,6 @@ 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) {
@@ -23031,6 +23233,9 @@ var require_auto_detect = __commonJS({
     var BACKEND_DIR = "backend";
     var SERVICES_DIR = "services";
     var FRONTEND_LOCATIONS = [FRONTEND_DIR, APPS_WEB_DIR];
+    var DETECTION_FRAMEWORKS = import_frameworks2.default.filter(
+      (framework) => !framework.experimental || framework.runtimeFramework
+    );
     async function autoDetectServices2(options) {
       const { fs: fs5 } = options;
       const rootFrameworks = await (0, import_detect_framework.detectFrameworks)({
@@ -23110,7 +23315,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);
@@ -23191,7 +23396,8 @@ var require_auto_detect = __commonJS({
       const serviceFs = fs5.chdir(dirPath);
       const frameworks2 = await (0, import_detect_framework.detectFrameworks)({
         fs: serviceFs,
-        frameworkList: import_frameworks2.default
+        frameworkList: DETECTION_FRAMEWORKS,
+        useExperimentalFrameworks: true
       });
       if (frameworks2.length > 1) {
         const frameworkNames = frameworks2.map((f) => f.name).join(", ");
@@ -23208,7 +23414,7 @@ var require_auto_detect = __commonJS({
         return {
           service: {
             framework: framework.slug ?? void 0,
-            workspace: dirPath,
+            entrypoint: dirPath,
             routePrefix: `/_/${serviceName}`
           }
         };
@@ -23276,7 +23482,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 +23507,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.39",
+  "version": "2.8.41",
   "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/static-config": "3.1.2",
-    "@vercel/gatsby-plugin-vercel-builder": "2.0.137"
+    "@vercel/gatsby-plugin-vercel-builder": "2.0.139",
+    "@vercel/static-config": "3.1.2"
   },
   "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.5.0",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/frameworks": "3.18.0",
-    "@vercel/build-utils": "13.4.2",
-    "@vercel/fs-detectors": "5.8.8",
+    "@vercel/frameworks": "3.19.0",
+    "@vercel/fs-detectors": "5.8.10",
     "@vercel/routing-utils": "5.3.3"
   },
   "scripts": {