@vercel/fs-detectors 7.2.5 → 7.3.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

@@ -49,6 +49,7 @@ var import_frameworks = require("@vercel/frameworks");
 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/**",
@@ -588,6 +589,17 @@ function detectFrontBuilder(pkg, files, usedFunctions, fallbackEntrypoint, optio
   }
   const f = slugToFramework.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;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "7.2.5",
+  "version": "7.3.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/error-utils": "2.2.1",
     "@vercel/python-analysis": "0.14.0",
-    "@vercel/routing-utils": "6.6.0"
+    "@vercel/routing-utils": "6.6.0",
+    "@vercel/build-utils": "14.10.1"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",