@vercel/fs-detectors 7.2.5 → 7.4.0

package/dist/buildpack-runtimes.d.ts

@@ -0,0 +1,23 @@
+import type { ServiceRuntime } from '@vercel/build-utils';
+/**
+ * Runtimes that can build container images with Cloud Native Buildpacks,
+ * with the files (any one of them, at the build root) that mark a project
+ * the buildpack can build. Keep this in sync with `@vercel/container`'s
+ * buildpack registry (`BUILDPACKS[].projectMarkers`).
+ *
+ * Routing is per runtime on purpose: the platform decides which buildpack to
+ * run from the language markers, and the buildpack classifies the application
+ * (for example Rails versus a plain Rack app) from its resolved bundle. There
+ * are no framework-level presets for buildpack runtimes.
+ */
+export declare const BUILDPACK_PROJECT_MARKERS: ReadonlyMap<ServiceRuntime, readonly string[]>;
+export declare function isBuildpackRuntimeEnabled(runtime: string): boolean;
+/** The runtime's buildpack, when one exists and its flag is on. */
+export declare function toBuildpackRuntime(runtime: string | null | undefined): ServiceRuntime | undefined;
+/**
+ * Whether the build root carries one of the buildpack's project markers.
+ * `hasFile` is checked against exact root-relative names, never ancestors or
+ * nested directories: the buildpack stages the root as-is, and the legacy
+ * runtime keeps building projects that lack the marker.
+ */
+export declare function hasBuildpackProjectMarker(runtime: ServiceRuntime, hasFile: (name: string) => Promise<boolean> | boolean): Promise<boolean>;

package/dist/buildpack-runtimes.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var buildpack_runtimes_exports = {};
+__export(buildpack_runtimes_exports, {
+  BUILDPACK_PROJECT_MARKERS: () => BUILDPACK_PROJECT_MARKERS,
+  hasBuildpackProjectMarker: () => hasBuildpackProjectMarker,
+  isBuildpackRuntimeEnabled: () => isBuildpackRuntimeEnabled,
+  toBuildpackRuntime: () => toBuildpackRuntime
+});
+module.exports = __toCommonJS(buildpack_runtimes_exports);
+const BUILDPACK_PROJECT_MARKERS = /* @__PURE__ */ new Map([["ruby", ["Gemfile"]]]);
+function isBuildpackRuntimeEnabled(runtime) {
+  return process.env[`VERCEL_EXPERIMENTAL_BUILDPACK_${runtime.toUpperCase()}`] === "1";
+}
+function toBuildpackRuntime(runtime) {
+  if (!runtime || !BUILDPACK_PROJECT_MARKERS.has(runtime) || !isBuildpackRuntimeEnabled(runtime)) {
+    return void 0;
+  }
+  return runtime;
+}
+async function hasBuildpackProjectMarker(runtime, hasFile) {
+  for (const marker of BUILDPACK_PROJECT_MARKERS.get(runtime) ?? []) {
+    if (await hasFile(marker)) {
+      return true;
+    }
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILDPACK_PROJECT_MARKERS,
+  hasBuildpackProjectMarker,
+  isBuildpackRuntimeEnabled,
+  toBuildpackRuntime
+});

package/dist/detect-builders.js

@@ -46,9 +46,12 @@ var import_minimatch = __toESM(require("minimatch"));
 var import_semver = require("semver");
 var import_path = require("path");
 var import_frameworks = require("@vercel/frameworks");
+var import_framework = require("./services/runtimes/framework");
+var import_constants = require("./services/runtimes/constants");
 var import_is_official_runtime = require("./is-official-runtime");
 var import_build_utils = require("@vercel/build-utils");
 var import_python = require("./python");
+var import_buildpack_runtimes = require("./buildpack-runtimes");
 const REGEX_MIDDLEWARE_FILES = "middleware.[jt]s";
 const VERCEL_PLATFORM_FILES = [
   "api/**",
@@ -74,9 +77,6 @@ function getStaticFilesPattern(additionalExclusions = []) {
   ].join(",")}}`;
 }
 const REGEX_NON_VERCEL_PLATFORM_FILES = getStaticFilesPattern();
-const slugToFramework = new Map(
-  import_frameworks.frameworkList.map((f) => [f.slug, f])
-);
 const builderToFrameworks = (() => {
   const map = /* @__PURE__ */ new Map();
   for (const f of import_frameworks.frameworkList) {
@@ -161,7 +161,7 @@ async function detectBuilders(files, pkg, options = {}) {
   };
   const absolutePathCache = /* @__PURE__ */ new Map();
   const { buildCommand, outputDirectory } = projectSettings;
-  const frameworkConfig = slugToFramework.get(framework || "");
+  const frameworkConfig = import_framework.frameworksBySlug.get(framework || "");
   const rustStaticOutput = isRustStaticOutput(framework, projectSettings);
   const ignoreRuntimes = new Set(
     rustStaticOutput ? void 0 : frameworkConfig?.ignoreRuntimes
@@ -532,6 +532,14 @@ function validateProxy(options, files, framework) {
       message: `The \`proxy\` property cannot be used with ${framework === "nextjs" ? "Next.js" : "Astro"} because the framework builds its own routing middleware.`
     };
   }
+  const appRuntime = (0, import_framework.inferBuilderRuntimeFromFramework)(framework);
+  const proxyRuntime = import_constants.ENTRYPOINT_EXTENSIONS[(0, import_path.extname)(proxy.entrypoint)];
+  if (appRuntime !== void 0 && proxyRuntime !== void 0 && appRuntime !== proxyRuntime) {
+    return {
+      code: "proxy_runtime_mismatch",
+      message: `The proxy entrypoint \`${proxy.entrypoint}\` uses the ${proxyRuntime} runtime, but the app uses the ${appRuntime} runtime. The proxy and app must use the same runtime.`
+    };
+  }
   return null;
 }
 function hasBuildScript(pkg) {
@@ -586,8 +594,19 @@ function detectFrontBuilder(pkg, files, usedFunctions, fallbackEntrypoint, optio
       }
     });
   }
-  const f = slugToFramework.get(framework || "");
+  const f = import_framework.frameworksBySlug.get(framework || "");
   if (f && f.useRuntime && !isRustStaticOutput(framework, projectSettings)) {
+    const buildpackRuntime = (0, import_buildpack_runtimes.toBuildpackRuntime)(framework);
+    if (buildpackRuntime && (import_buildpack_runtimes.BUILDPACK_PROJECT_MARKERS.get(buildpackRuntime) ?? []).some(
+      (marker) => files.includes(marker)
+    )) {
+      config.buildpack = buildpackRuntime;
+      return {
+        src: "<detect>",
+        use: `@vercel/container${withTag}`,
+        config
+      };
+    }
     const { src, use } = f.useRuntime;
     const shouldUseUnifiedBackend = (0, import_build_utils.isExperimentalBackendsEnabled)() && import_build_utils.BACKEND_BUILDERS.includes(use);
     const finalUse = shouldUseUnifiedBackend ? import_build_utils.UNIFIED_BACKEND_BUILDER : use;
@@ -894,7 +913,7 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
   const framework = frontendBuilder?.config?.framework || "";
   const isGatsby = framework === "gatsby";
   const isNextjs = framework === "nextjs" || (0, import_is_official_runtime.isOfficialRuntime)("next", frontendBuilder?.use);
-  const ignoreRuntimes = slugToFramework.get(framework)?.ignoreRuntimes;
+  const ignoreRuntimes = import_framework.frameworksBySlug.get(framework)?.ignoreRuntimes;
   if (apiRoutes && apiRoutes.length > 0) {
     if (options.featHandleMiss) {
       const extSet = detectApiExtensions(apiBuilders);

package/dist/detect-framework.js

@@ -27,6 +27,7 @@ __export(detect_framework_exports, {
 module.exports = __toCommonJS(detect_framework_exports);
 var import_build_utils = require("@vercel/build-utils");
 var import_child_process = require("child_process");
+var import_buildpack_runtimes = require("./buildpack-runtimes");
 function shouldIncludeExperimentalFrameworks(useExperimentalFrameworks) {
   if (typeof useExperimentalFrameworks === "boolean") {
     return useExperimentalFrameworks;
@@ -41,7 +42,10 @@ function filterFrameworkList(frameworkList, useExperimentalFrameworks) {
   }
   return frameworkList.filter((f) => {
     const experimental = f.experimental;
-    return !experimental;
+    if (!experimental) {
+      return true;
+    }
+    return (0, import_buildpack_runtimes.toBuildpackRuntime)(f.slug) !== void 0;
   });
 }
 async function matches(fs, framework) {

package/dist/services/detect-services.js

@@ -25,6 +25,7 @@ __export(detect_services_exports, {
 module.exports = __toCommonJS(detect_services_exports);
 var import_build_utils = require("@vercel/build-utils");
 var import_routing_utils = require("@vercel/routing-utils");
+var import_buildpack_runtimes = require("../buildpack-runtimes");
 var import_framework = require("./runtimes/framework");
 var import_utils = require("./utils");
 var import_resolve = require("./resolve");
@@ -60,6 +61,11 @@ function withResolvedResult(resolved, inferred = null) {
     inferred
   };
 }
+function isBuildpackInferredService(svc) {
+  return (0, import_buildpack_runtimes.toBuildpackRuntime)(
+    svc.runtime ?? (0, import_framework.inferRuntimeFromFramework)(svc.framework)
+  ) !== void 0;
+}
 function toInferredLayoutConfig(services) {
   const inferredConfig = {};
   for (const [name, service] of Object.entries(services)) {
@@ -69,7 +75,7 @@ function toInferredLayoutConfig(services) {
     if (service.type) {
       serviceConfig.type = service.type;
     }
-    if (typeof service.entrypoint === "string") {
+    if (typeof service.entrypoint === "string" && !isBuildpackInferredService(service)) {
       serviceConfig.entrypoint = service.entrypoint;
     }
     if (typeof service.mountPath === "string") {
@@ -212,7 +218,7 @@ async function tryResolveInferred(detectResult, source, scopedFs) {
       v2Services[name] = {
         root: svc.root,
         ...svc.framework ? { framework: svc.framework } : {},
-        ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {}
+        ...svc.entrypoint && !isBuildpackInferredService(svc) ? { entrypoint: svc.entrypoint } : {}
       };
     }
     const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(v2Services, scopedFs);
@@ -245,7 +251,7 @@ async function tryResolveInferred(detectResult, source, scopedFs) {
     v1Services[name] = {
       root: svc.root === "." ? void 0 : svc.root,
       ...svc.framework ? { framework: svc.framework } : {},
-      ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {},
+      ...svc.entrypoint && !isBuildpackInferredService(svc) ? { entrypoint: svc.entrypoint } : {},
       ...svc.type ? { type: svc.type } : {},
       ...svc.buildCommand ? { buildCommand: svc.buildCommand } : {},
       ...svc.preDeployCommand ? { preDeployCommand: svc.preDeployCommand } : {},

package/dist/services/resolve-v2.js

@@ -30,7 +30,9 @@ var import_constants = require("./runtimes/constants");
 var import_framework = require("./runtimes/framework");
 var import_runtime = require("./runtimes/runtime");
 var import_entrypoint = require("./runtimes/entrypoint");
+var import_buildpack_runtimes = require("../buildpack-runtimes");
 var import_resolve = require("./resolve");
+var import_utils = require("./utils");
 const frameworksBySlug = new Map(import_frameworks.frameworkList.map((f) => [f.slug, f]));
 const MAX_SERVICE_NAME_LENGTH = 64;
 const SERVICE_NAME_REGEX = /^[a-z]([a-z_-]*[a-z])?$/;
@@ -234,7 +236,23 @@ async function resolveConfiguredServiceV2(name, config, fs) {
       entrypoint: entrypointFile
     });
   }
-  if (entrypointIsDirectory && !framework) {
+  const flaggedBuildpackRuntime = (0, import_buildpack_runtimes.toBuildpackRuntime)(
+    inferredRuntime
+  );
+  if (flaggedBuildpackRuntime && config.command !== void 0) {
+    return {
+      error: {
+        code: "INVALID_COMMAND",
+        message: `Service "${name}" can only specify "command" when using runtime "container".`,
+        serviceName: name
+      }
+    };
+  }
+  const buildpackRuntime = flaggedBuildpackRuntime && !entrypointFile && !(0, import_framework.isFrontendFramework)(framework) && await (0, import_buildpack_runtimes.hasBuildpackProjectMarker)(
+    flaggedBuildpackRuntime,
+    (marker) => (0, import_utils.hasFile)(serviceFs, marker)
+  ) ? flaggedBuildpackRuntime : void 0;
+  if (entrypointIsDirectory && !framework && !buildpackRuntime) {
     return {
       error: {
         code: "MISSING_SERVICE_FRAMEWORK",
@@ -244,7 +262,7 @@ async function resolveConfiguredServiceV2(name, config, fs) {
     };
   }
   const frameworkRuntime = (0, import_framework.inferRuntimeFromFramework)(framework);
-  if (detectedFramework && frameworkRuntime && !entrypointFile) {
+  if (detectedFramework && frameworkRuntime && !entrypointFile && !buildpackRuntime) {
     return {
       error: {
         code: "MISSING_SERVICE_CONFIG",
@@ -256,7 +274,10 @@ async function resolveConfiguredServiceV2(name, config, fs) {
   const frameworkDefinition = framework ? frameworksBySlug.get(framework) : void 0;
   let builderUse;
   let builderSrc;
-  if (framework) {
+  if (buildpackRuntime) {
+    builderUse = "@vercel/container";
+    builderSrc = "<detect>";
+  } else if (framework) {
     builderUse = (0, import_build_utils.isNodeBackendFramework)(framework) ? "@vercel/backends" : frameworkDefinition?.useRuntime?.use || "@vercel/static-build";
     builderSrc = entrypointFile || frameworkDefinition?.useRuntime?.src || "package.json";
   } else {
@@ -291,6 +312,9 @@ async function resolveConfiguredServiceV2(name, config, fs) {
   if (framework) {
     builderConfig.framework = framework;
   }
+  if (buildpackRuntime) {
+    builderConfig.buildpack = buildpackRuntime;
+  }
   if (config.outputDirectory) {
     builderConfig.outputDirectory = config.outputDirectory;
   }

package/dist/services/resolve.js

@@ -31,6 +31,7 @@ module.exports = __toCommonJS(resolve_exports);
 var import_path = require("path");
 var import_build_utils = require("@vercel/build-utils");
 var import_constants = require("./runtimes/constants");
+var import_buildpack_runtimes = require("../buildpack-runtimes");
 var import_framework = require("./runtimes/framework");
 var import_runtime = require("./runtimes/runtime");
 var import_entrypoint = require("./runtimes/entrypoint");
@@ -511,6 +512,15 @@ function validateServiceConfig(name, config, options = {}) {
     };
   }
   if (hasBuilderOrRuntime && !hasFramework && !hasEntrypoint) {
+    const buildpackRuntime = config.builder ? void 0 : (0, import_buildpack_runtimes.toBuildpackRuntime)(config.runtime);
+    if (buildpackRuntime) {
+      const markers = import_buildpack_runtimes.BUILDPACK_PROJECT_MARKERS.get(buildpackRuntime) ?? [];
+      return {
+        code: "BUILDPACK_REQUIRES_SERVICES",
+        message: `Service "${name}" must specify "entrypoint" when using "runtime" with "experimentalServices". Move it to "services" to build without an "entrypoint" from a ${markers.join(" or ")} at the service root.`,
+        serviceName: name
+      };
+    }
     return {
       code: "MISSING_ENTRYPOINT",
       message: `Service "${name}" must specify "entrypoint" when using "${config.builder ? "builder" : "runtime"}".`,

package/dist/services/runtimes/constants.d.ts

@@ -2,6 +2,10 @@ import type { ServiceRuntime } from '@vercel/build-utils';
 export declare const RUNTIME_BUILDERS: Record<ServiceRuntime, string>;
 export declare const RUNTIME_MANIFESTS: Partial<Record<ServiceRuntime, string[]>>;
 export declare const ENTRYPOINT_EXTENSIONS: Record<string, ServiceRuntime>;
+/**
+ * The inverse of RUNTIME_BUILDERS. Maps each builder to its runtime.
+ */
+export declare const BUILDER_RUNTIMES: Record<string, ServiceRuntime>;
 /**
  * Builders that produce static output (SPAs, static sites) with no runtime.
  */

package/dist/services/runtimes/constants.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var constants_exports = {};
 __export(constants_exports, {
+  BUILDER_RUNTIMES: () => BUILDER_RUNTIMES,
   CONTAINER_ENTRYPOINT_CANDIDATES: () => CONTAINER_ENTRYPOINT_CANDIDATES,
   ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
   ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
@@ -60,6 +61,12 @@ const ENTRYPOINT_EXTENSIONS = {
   ".rb": "ruby",
   ".ru": "ruby"
 };
+const BUILDER_RUNTIMES = Object.fromEntries(
+  Object.entries(RUNTIME_BUILDERS).map(([runtime, builder]) => [
+    builder,
+    runtime
+  ])
+);
 const STATIC_BUILDERS = /* @__PURE__ */ new Set([
   "@vercel/static-build",
   "@vercel/static"
@@ -76,6 +83,7 @@ const CONTAINER_ENTRYPOINT_CANDIDATES = [
 ];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BUILDER_RUNTIMES,
   CONTAINER_ENTRYPOINT_CANDIDATES,
   ENTRYPOINT_EXTENSIONS,
   ROUTE_OWNING_BUILDERS,

package/dist/services/runtimes/framework.d.ts

@@ -1,5 +1,6 @@
 import type { ServiceRuntime } from '@vercel/build-utils';
 import type { Framework } from '@vercel/frameworks';
+export declare const frameworksBySlug: Map<string, Framework>;
 /**
  * Framework list filtered to entries eligible for auto-detection.
  * Includes non-experimental frameworks and runtime frameworks (Python, Node, etc.)
@@ -15,6 +16,12 @@ export declare const DETECTION_FRAMEWORKS: Framework[];
  * - `express` → `node`
  */
 export declare function inferRuntimeFromFramework(framework: string | null | undefined): ServiceRuntime | undefined;
+/**
+ * Infer the runtime used by a framework's builder.
+ *
+ * A builder may not necessarily produce a function with a runtime, e.g. @vercel/static-build.
+ */
+export declare function inferBuilderRuntimeFromFramework(framework: string | null | undefined): ServiceRuntime | undefined;
 /**
  * Returns true if the framework is a client-only frontend (no server runtime).
  */

package/dist/services/runtimes/framework.js

@@ -20,6 +20,8 @@ var framework_exports = {};
 __export(framework_exports, {
   DETECTION_FRAMEWORKS: () => DETECTION_FRAMEWORKS,
   filterFrameworksByRuntime: () => filterFrameworksByRuntime,
+  frameworksBySlug: () => frameworksBySlug,
+  inferBuilderRuntimeFromFramework: () => inferBuilderRuntimeFromFramework,
   inferRuntimeFromFramework: () => inferRuntimeFromFramework,
   isBFFFramework: () => isBFFFramework,
   isFrontendFramework: () => isFrontendFramework
@@ -28,6 +30,9 @@ module.exports = __toCommonJS(framework_exports);
 var import_build_utils = require("@vercel/build-utils");
 var import_frameworks = require("@vercel/frameworks");
 var import_constants = require("./constants");
+const frameworksBySlug = new Map(
+  import_frameworks.frameworkList.flatMap((f) => typeof f.slug === "string" ? [[f.slug, f]] : [])
+);
 const DETECTION_FRAMEWORKS = import_frameworks.frameworkList.filter(
   (framework) => !framework.experimental || framework.runtimeFramework
 );
@@ -42,6 +47,25 @@ function inferRuntimeFromFramework(framework) {
     return "node";
   return void 0;
 }
+const STATIC_BUILDER_RUNTIMES = {
+  hugo: "go",
+  jekyll: "ruby",
+  middleman: "ruby",
+  zola: "rust"
+};
+function inferBuilderRuntimeFromFramework(framework) {
+  if (!framework || framework === "container" || framework === "services")
+    return void 0;
+  const f = frameworksBySlug.get(framework);
+  const declaredBuilder = f?.useRuntime?.use;
+  if (declaredBuilder)
+    return import_constants.BUILDER_RUNTIMES[declaredBuilder];
+  const detectorItems = [
+    ...f?.detectors?.every ?? [],
+    ...f?.detectors?.some ?? []
+  ];
+  return STATIC_BUILDER_RUNTIMES[framework] ?? (detectorItems.some((d) => d.matchPackage !== void 0) ? "node" : void 0);
+}
 function isFrontendFramework(framework) {
   return !!framework && !inferRuntimeFromFramework(framework);
 }
@@ -64,6 +88,8 @@ function filterFrameworksByRuntime(frameworks, runtime) {
 0 && (module.exports = {
   DETECTION_FRAMEWORKS,
   filterFrameworksByRuntime,
+  frameworksBySlug,
+  inferBuilderRuntimeFromFramework,
   inferRuntimeFromFramework,
   isBFFFramework,
   isFrontendFramework

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "7.2.5",
+  "version": "7.4.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,11 +20,11 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "@vercel/build-utils": "14.10.1",
     "@vercel/error-utils": "2.2.1",
-    "@vercel/frameworks": "3.34.0",
+    "@vercel/build-utils": "14.10.1",
     "@vercel/python-analysis": "0.14.0",
-    "@vercel/routing-utils": "6.6.0"
+    "@vercel/routing-utils": "6.6.0",
+    "@vercel/frameworks": "3.34.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",