@vercel/fs-detectors 6.4.0 → 6.6.0

package/dist/services/auto-detect.d.ts

@@ -1,11 +1,18 @@
+import type { DetectEntrypointFn } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { ExperimentalServices, ServiceDetectionError } from './types';
+import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
 export interface AutoDetectOptions {
     fs: DetectorFilesystem;
+    /**
+     * Optional callback used to enrich runtime services with a normalized
+     * entrypoint (file path or `module:attr` reference).
+     */
+    detectEntrypoint?: DetectEntrypointFn;
 }
 export interface AutoDetectResult {
     services: ExperimentalServices | null;
     errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
 }
 /**
  * Auto-detect services when services are not configured.

package/dist/services/auto-detect.js

@@ -23,16 +23,14 @@ __export(auto_detect_exports, {
 module.exports = __toCommonJS(auto_detect_exports);
 var import_detect_framework = require("../detect-framework");
 var import_frameworks = require("@vercel/frameworks");
+var import_utils = require("./utils");
 const FRONTEND_DIR = "frontend";
 const APPS_WEB_DIR = "apps/web";
 const BACKEND_DIR = "backend";
 const SERVICES_DIR = "services";
 const FRONTEND_LOCATIONS = [FRONTEND_DIR, APPS_WEB_DIR];
-const DETECTION_FRAMEWORKS = import_frameworks.frameworkList.filter(
-  (framework) => !framework.experimental || framework.runtimeFramework
-);
 async function autoDetectServices(options) {
-  const { fs } = options;
+  const { fs, detectEntrypoint } = options;
   const rootFrameworks = await (0, import_detect_framework.detectFrameworks)({
     fs,
     frameworkList: import_frameworks.frameworkList
@@ -41,6 +39,7 @@ async function autoDetectServices(options) {
     const frameworkNames = rootFrameworks.map((f) => f.name).join(", ");
     return {
       services: null,
+      warnings: [],
       errors: [
         {
           code: "MULTIPLE_FRAMEWORKS_ROOT",
@@ -50,7 +49,7 @@ async function autoDetectServices(options) {
     };
   }
   if (rootFrameworks.length === 1) {
-    return detectServicesAtRoot(fs, rootFrameworks[0]);
+    return detectServicesAtRoot(fs, rootFrameworks[0], detectEntrypoint);
   }
   for (const frontendLocation of FRONTEND_LOCATIONS) {
     const hasFrontendDir = await fs.hasPath(frontendLocation);
@@ -66,6 +65,7 @@ async function autoDetectServices(options) {
       const frameworkNames = frontendFrameworks.map((f) => f.name).join(", ");
       return {
         services: null,
+        warnings: [],
         errors: [
           {
             code: "MULTIPLE_FRAMEWORKS_SERVICE",
@@ -78,12 +78,14 @@ async function autoDetectServices(options) {
       return detectServicesFrontendSubdir(
         fs,
         frontendFrameworks[0],
-        frontendLocation
+        frontendLocation,
+        detectEntrypoint
       );
     }
   }
   return {
     services: null,
+    warnings: [],
     errors: [
       {
         code: "NO_SERVICES_CONFIGURED",
@@ -92,49 +94,54 @@ async function autoDetectServices(options) {
     ]
   };
 }
-async function detectServicesAtRoot(fs, rootFramework) {
+async function detectServicesAtRoot(fs, rootFramework, detectEntrypoint) {
   const services = {};
   services.frontend = {
     framework: rootFramework.slug ?? void 0,
     routePrefix: "/"
   };
-  const backendResult = await detectBackendServices(fs);
+  const backendResult = await detectBackendServices(fs, detectEntrypoint);
   if (backendResult.error) {
     return {
       services: null,
+      warnings: [],
       errors: [backendResult.error]
     };
   }
   if (Object.keys(backendResult.services).length === 0) {
     return {
       services: null,
+      warnings: [],
       errors: []
     };
   }
   Object.assign(services, backendResult.services);
   return {
     services,
+    warnings: [],
     errors: []
   };
 }
-async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocation) {
+async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocation, detectEntrypoint) {
   const services = {};
   const serviceName = frontendLocation.split("/").pop() || "frontend";
   services[serviceName] = {
     framework: frontendFramework.slug ?? void 0,
-    entrypoint: frontendLocation,
+    root: frontendLocation,
     routePrefix: "/"
   };
-  const backendResult = await detectBackendServices(fs);
+  const backendResult = await detectBackendServices(fs, detectEntrypoint);
   if (backendResult.error) {
     return {
       services: null,
+      warnings: [],
       errors: [backendResult.error]
     };
   }
   if (Object.keys(backendResult.services).length === 0) {
     return {
       services: null,
+      warnings: [],
       errors: [
         {
           code: "NO_BACKEND_SERVICES",
@@ -146,19 +153,28 @@ async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocat
   Object.assign(services, backendResult.services);
   return {
     services,
+    warnings: [],
     errors: []
   };
 }
-async function detectBackendServices(fs) {
+async function detectBackendServices(fs, detectEntrypoint) {
   const services = {};
-  const backendResult = await detectServiceInDir(fs, BACKEND_DIR, "backend");
+  const backendResult = await detectServiceInDir(
+    fs,
+    BACKEND_DIR,
+    "backend",
+    detectEntrypoint
+  );
   if (backendResult.error) {
     return { services: {}, error: backendResult.error };
   }
   if (backendResult.service) {
     services.backend = backendResult.service;
   }
-  const multiServicesResult = await detectServicesDirectory(fs);
+  const multiServicesResult = await detectServicesDirectory(
+    fs,
+    detectEntrypoint
+  );
   if (multiServicesResult.error) {
     return { services: {}, error: multiServicesResult.error };
   }
@@ -177,7 +193,7 @@ async function detectBackendServices(fs) {
   Object.assign(services, multiServicesResult.services);
   return { services };
 }
-async function detectServicesDirectory(fs) {
+async function detectServicesDirectory(fs, detectEntrypoint) {
   const services = {};
   const hasServicesDir = await fs.hasPath(SERVICES_DIR);
   if (!hasServicesDir) {
@@ -191,7 +207,12 @@ async function detectServicesDirectory(fs) {
     }
     const serviceName = entry.name;
     const serviceDir = `${SERVICES_DIR}/${serviceName}`;
-    const result = await detectServiceInDir(fs, serviceDir, serviceName);
+    const result = await detectServiceInDir(
+      fs,
+      serviceDir,
+      serviceName,
+      detectEntrypoint
+    );
     if (result.error) {
       return { services: {}, error: result.error };
     }
@@ -201,7 +222,7 @@ async function detectServicesDirectory(fs) {
   }
   return { services };
 }
-async function detectServiceInDir(fs, dirPath, serviceName) {
+async function detectServiceInDir(fs, dirPath, serviceName, detectEntrypoint) {
   const hasDirPath = await fs.hasPath(dirPath);
   if (!hasDirPath) {
     return {};
@@ -209,7 +230,7 @@ async function detectServiceInDir(fs, dirPath, serviceName) {
   const serviceFs = fs.chdir(dirPath);
   const frameworks = await (0, import_detect_framework.detectFrameworks)({
     fs: serviceFs,
-    frameworkList: DETECTION_FRAMEWORKS,
+    frameworkList: import_utils.DETECTION_FRAMEWORKS,
     useExperimentalFrameworks: true
   });
   if (frameworks.length > 1) {
@@ -222,17 +243,21 @@ async function detectServiceInDir(fs, dirPath, serviceName) {
       }
     };
   }
-  if (frameworks.length === 1) {
-    const framework = frameworks[0];
-    return {
-      service: {
-        framework: framework.slug ?? void 0,
-        entrypoint: dirPath,
-        routePrefix: `/_/${serviceName}`
-      }
-    };
+  if (frameworks.length !== 1) {
+    return {};
   }
-  return {};
+  const framework = frameworks[0];
+  const slug = framework.slug ?? void 0;
+  const routePrefix = `/_/${serviceName}`;
+  const detected = detectEntrypoint && !(0, import_utils.isFrontendFramework)(slug) ? await detectEntrypoint({ workPath: dirPath, framework: slug }) : null;
+  return {
+    service: {
+      framework: slug,
+      root: dirPath,
+      ...detected ? { entrypoint: detected.entrypoint } : {},
+      routePrefix
+    }
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/services/detect-procfile.d.ts

@@ -0,0 +1,22 @@
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
+export interface ProcfileDetectResult {
+    services: ExperimentalServices | null;
+    errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
+}
+/**
+ * Detect service configurations from a Procfile.
+ *
+ * We infer runtime and entrypoint from the start command where possible,
+ * then run framework detection from the project root to fill in the framework.
+ *
+ * Process type mapping:
+ * - `web`: web service
+ * - `release`: embeded into one of web service's buildCommand
+ * - `worker`-like process name: try to infer entrypoint for support Python worker or produce a hint
+ * - everything else is tried to be inferred as `web` or produces a hint
+ */
+export declare function detectProcfileServices(options: {
+    fs: DetectorFilesystem;
+}): Promise<ProcfileDetectResult>;

package/dist/services/detect-procfile.js

@@ -0,0 +1,248 @@
+"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 detect_procfile_exports = {};
+__export(detect_procfile_exports, {
+  detectProcfileServices: () => detectProcfileServices
+});
+module.exports = __toCommonJS(detect_procfile_exports);
+var import_detect_framework = require("../detect-framework");
+var import_utils = require("./utils");
+const PROCFILE = "Procfile";
+const PROCFILE_LINE_RE = /^\s*([A-Za-z_][A-Za-z0-9_-]*):\s*(.+)/;
+const PY_IDENT = "[A-Za-z_][A-Za-z0-9_]*";
+const PY_MODULE_RE = new RegExp(
+  `^${PY_IDENT}(?:\\.${PY_IDENT})*(?::${PY_IDENT})?$`
+);
+const SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".cjs",
+  ".mjs",
+  ".ts",
+  ".cts",
+  ".mts",
+  ".py",
+  ".go",
+  ".rs",
+  ".rb",
+  ".ru"
+]);
+const SUPPORTED_WORKER_COMMANDS = /* @__PURE__ */ new Set(["celery", "dramatiq"]);
+async function detectProcfileServices(options) {
+  const { fs } = options;
+  const raw = await readProcfile(fs);
+  if (raw.warning) {
+    return { services: null, errors: [], warnings: [raw.warning] };
+  }
+  if (!raw.content) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const entries = parseProcfile(raw.content);
+  if (entries.length === 0) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const services = {};
+  const errors = [];
+  const warnings = [];
+  let releaseCommand;
+  const serviceEntries = [];
+  for (const entry of entries) {
+    if (entry.processType === "release") {
+      releaseCommand = entry.command;
+    } else {
+      serviceEntries.push(entry);
+    }
+  }
+  if (serviceEntries.length === 0 && releaseCommand) {
+    warnings.push({
+      code: "PROCFILE_RELEASE_ONLY",
+      message: `Found only a release process in Procfile (command: "${releaseCommand}"). The release command can be used as a build step. You can add it as part of a web service if you add it to "buildCommand".`
+    });
+    return { services: null, errors: [], warnings };
+  }
+  if (serviceEntries.length === 0) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const frameworks = await (0, import_detect_framework.detectFrameworks)({
+    fs,
+    frameworkList: import_utils.DETECTION_FRAMEWORKS,
+    useExperimentalFrameworks: true
+  });
+  if (frameworks.length > 1) {
+    const names = frameworks.map((f) => f.name).join(", ");
+    return {
+      services: null,
+      errors: [
+        {
+          code: "MULTIPLE_FRAMEWORKS_SERVICE",
+          message: `Multiple frameworks detected: ${names}. Use explicit experimentalServices config.`
+        }
+      ],
+      warnings
+    };
+  }
+  const detectedFramework = frameworks.length === 1 ? frameworks[0] : null;
+  const serviceNames = /* @__PURE__ */ new Set();
+  for (const entry of serviceEntries) {
+    const { processType, command } = entry;
+    const tokens = command.split(/\s+/).filter(Boolean);
+    const entrypoint = await extractEntrypoint(tokens, fs);
+    const isWorkerLikeProcess = processType.includes("worker") || hasSupportedWorkerCommand(tokens);
+    if (serviceNames.has(processType)) {
+      errors.push({
+        code: "DUPLICATE_SERVICE",
+        message: `Duplicate process type "${processType}" in Procfile.`,
+        serviceName: processType
+      });
+      continue;
+    }
+    serviceNames.add(processType);
+    if (isWorkerLikeProcess) {
+      if (hasSupportedWorkerCommand(tokens) && entrypoint?.endsWith(".py")) {
+        services[processType] = {
+          type: "worker",
+          entrypoint,
+          runtime: "python"
+        };
+      } else {
+        emitWorkerHint(processType, command, entrypoint, warnings);
+      }
+      continue;
+    }
+    if (!detectedFramework && !entrypoint) {
+      warnings.push({
+        code: "SERVICE_SKIPPED",
+        message: `Skipped Procfile process "${processType}": no framework detected and could not infer entrypoint from command "${command}". Configure it manually in experimentalServices.`
+      });
+      continue;
+    }
+    const serviceConfig = { type: "web" };
+    if (detectedFramework) {
+      serviceConfig.framework = detectedFramework.slug ?? void 0;
+    }
+    serviceConfig.entrypoint = entrypoint ?? ".";
+    services[processType] = serviceConfig;
+  }
+  if (errors.length > 0) {
+    return { services: null, errors, warnings };
+  }
+  if (Object.keys(services).length === 0) {
+    return { services: null, errors: [], warnings };
+  }
+  if (releaseCommand && services.web) {
+    services.web.buildCommand = releaseCommand;
+  } else if (releaseCommand) {
+    const firstService = Object.values(services)[0];
+    if (firstService) {
+      firstService.buildCommand = releaseCommand;
+    }
+  }
+  warnings.push(...(0, import_utils.assignRoutePrefixes)(services));
+  return { services, errors: [], warnings };
+}
+function parseProcfile(content) {
+  const entries = [];
+  for (const rawLine of content.split("\n")) {
+    const match = rawLine.match(PROCFILE_LINE_RE);
+    if (match) {
+      entries.push({ processType: match[1], command: match[2].trim() });
+    }
+  }
+  return entries;
+}
+async function extractEntrypoint(tokens, fs) {
+  let firstModulePath;
+  let lastFilePath;
+  for (const token of tokens) {
+    if (!firstModulePath && PY_MODULE_RE.test(token)) {
+      const resolved = await resolvePythonModule(token, fs);
+      if (resolved)
+        firstModulePath = resolved;
+    }
+    if (hasSupportedExtension(token)) {
+      lastFilePath = token;
+    }
+  }
+  return firstModulePath ?? lastFilePath;
+}
+async function resolvePythonModule(spec, fs) {
+  const [modulePart] = spec.split(":");
+  const filePath = `${modulePart.replace(/\./g, "/")}.py`;
+  const initPath = `${modulePart.replace(/\./g, "/")}/__init__.py`;
+  try {
+    if (await fs.isFile(filePath))
+      return filePath;
+    if (await fs.isFile(initPath))
+      return initPath;
+  } catch {
+  }
+  return void 0;
+}
+function hasSupportedExtension(token) {
+  const dot = token.lastIndexOf(".");
+  return dot > 0 && SUPPORTED_EXTENSIONS.has(token.slice(dot));
+}
+function hasSupportedWorkerCommand(tokens) {
+  return tokens.some((t) => SUPPORTED_WORKER_COMMANDS.has(baseCommand(t)));
+}
+function emitWorkerHint(processType, command, entrypoint, warnings) {
+  const hint = {
+    type: "worker",
+    entrypoint: entrypoint ?? "<path-to-handler>",
+    runtime: "python"
+  };
+  if (entrypoint?.endsWith(".py")) {
+    warnings.push({
+      code: "PROCFILE_WORKER_HINT",
+      message: `Found Procfile worker process "${processType}". Python workers that use Celery, Dramatiq and Django tasks are supported. You can add the following to define this worker:
+"${processType}": ${JSON.stringify(hint, null, 2)}`
+    });
+    return;
+  }
+  warnings.push({
+    code: "PROCFILE_WORKER_HINT",
+    message: `Found Procfile worker process "${processType}" (command: "${command}"). Could not determine runtime. Only Python workers are currently supported.`
+  });
+}
+function baseCommand(token) {
+  if (!token)
+    return "";
+  const parts = token.split("/");
+  return parts[parts.length - 1];
+}
+async function readProcfile(fs) {
+  try {
+    const exists = await fs.isFile(PROCFILE);
+    if (!exists)
+      return { content: null };
+    const buf = await fs.readFile(PROCFILE);
+    return { content: buf.toString("utf-8") };
+  } catch (err) {
+    return {
+      content: null,
+      warning: {
+        code: "PROCFILE_READ_ERROR",
+        message: `Failed to read ${PROCFILE}: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectProcfileServices
+});

package/dist/services/detect-railway.d.ts

@@ -1,3 +1,4 @@
+import type { DetectEntrypointFn } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
 import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
 export interface RailwayDetectResult {
@@ -17,4 +18,5 @@ export interface RailwayDetectResult {
  */
 export declare function detectRailwayServices(options: {
     fs: DetectorFilesystem;
+    detectEntrypoint?: DetectEntrypointFn;
 }): Promise<RailwayDetectResult>;

package/dist/services/detect-railway.js

@@ -33,7 +33,6 @@ __export(detect_railway_exports, {
 module.exports = __toCommonJS(detect_railway_exports);
 var import_path = require("path");
 var import_smol_toml = __toESM(require("smol-toml"));
-var import_frameworks = require("@vercel/frameworks");
 var import_detect_framework = require("../detect-framework");
 var import_utils = require("./utils");
 const RAILWAY_JSON = "railway.json";
@@ -56,11 +55,8 @@ const SKIP_DIRS = /* @__PURE__ */ new Set([
   "venv",
   "CVS"
 ]);
-const DETECTION_FRAMEWORKS = import_frameworks.frameworkList.filter(
-  (framework) => !framework.experimental || framework.runtimeFramework
-);
 async function detectRailwayServices(options) {
-  const { fs } = options;
+  const { fs, detectEntrypoint } = options;
   const { configs, warnings } = await findRailwayConfigs(fs);
   if (configs.length === 0) {
     return { services: null, errors: [], warnings };
@@ -73,7 +69,7 @@ async function detectRailwayServices(options) {
     const dirLabel = cf.dirPath === "." ? "root" : cf.dirPath;
     const frameworks = await (0, import_detect_framework.detectFrameworks)({
       fs: serviceFs,
-      frameworkList: DETECTION_FRAMEWORKS,
+      frameworkList: import_utils.DETECTION_FRAMEWORKS,
       useExperimentalFrameworks: true
     });
     if (cf.config.deploy?.cronSchedule) {
@@ -123,10 +119,20 @@ async function detectRailwayServices(options) {
       continue;
     }
     const framework = frameworks[0];
+    const slug = framework.slug ?? void 0;
     let serviceConfig = {};
-    serviceConfig.framework = framework.slug ?? void 0;
+    serviceConfig.framework = slug;
     if (cf.dirPath !== ".") {
-      serviceConfig.entrypoint = cf.dirPath;
+      serviceConfig.root = cf.dirPath;
+      if (detectEntrypoint && !(0, import_utils.isFrontendFramework)(slug)) {
+        const detected = await detectEntrypoint({
+          workPath: cf.dirPath,
+          framework: slug
+        });
+        if (detected) {
+          serviceConfig.entrypoint = detected.entrypoint;
+        }
+      }
     }
     if (cf.config.build?.buildCommand) {
       serviceConfig.buildCommand = cf.config.build.buildCommand;
@@ -144,7 +150,7 @@ async function detectRailwayServices(options) {
   if (serviceNames.length === 0) {
     return { services: null, errors: [], warnings };
   }
-  warnings.push(...assignRoutePrefixes(services));
+  warnings.push(...(0, import_utils.assignRoutePrefixes)(services));
   return { services, errors: [], warnings };
 }
 async function findRailwayConfigs(fs, dirPath = ".", depth = 0) {
@@ -230,31 +236,6 @@ function deriveServiceName(dirPath) {
   const segments = dirPath.split("/");
   return segments[segments.length - 1];
 }
-function assignRoutePrefixes(services) {
-  const warnings = [];
-  const names = Object.keys(services);
-  if (names.length === 1) {
-    services[names[0]].routePrefix = "/";
-    return warnings;
-  }
-  const frontendNames = names.filter(
-    (name) => (0, import_utils.isFrontendFramework)(services[name].framework)
-  );
-  let rootName = null;
-  if (frontendNames.length === 1) {
-    rootName = frontendNames[0];
-  } else if (frontendNames.length > 1) {
-    rootName = frontendNames.find((n) => n === "frontend" || n === "web") ?? frontendNames.sort()[0];
-    warnings.push({
-      code: "MULTIPLE_FRONTENDS",
-      message: `Multiple frontend services detected (${frontendNames.join(", ")}). "${rootName}" was assigned routePrefix "/". Adjust manually if a different service should be the root.`
-    });
-  }
-  for (const name of names) {
-    services[name].routePrefix = name === rootName ? "/" : `/_/${name}`;
-  }
-  return warnings;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   detectRailwayServices

package/dist/services/detect-render.d.ts

@@ -0,0 +1,13 @@
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
+export interface RenderDetectResult {
+    services: ExperimentalServices | null;
+    errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
+}
+/**
+ * Detect Render service configurations from render.yaml.
+ */
+export declare function detectRenderServices(options: {
+    fs: DetectorFilesystem;
+}): Promise<RenderDetectResult>;

package/dist/services/detect-render.js

@@ -0,0 +1,222 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // 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 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detect_render_exports = {};
+__export(detect_render_exports, {
+  detectRenderServices: () => detectRenderServices
+});
+module.exports = __toCommonJS(detect_render_exports);
+var import_js_yaml = __toESM(require("js-yaml"));
+var import_detect_framework = require("../detect-framework");
+var import_types = require("./types");
+var import_utils = require("./utils");
+const RENDER_YAML = "render.yaml";
+const SERVICE_TYPE_MAP = {
+  web: "web",
+  static: "web"
+};
+async function detectRenderServices(options) {
+  const { fs } = options;
+  const raw = await readRenderYaml(fs);
+  if (raw.warning) {
+    return { services: null, errors: [], warnings: [raw.warning] };
+  } else if (!raw.content) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const parsed = tryParseRenderConfig(raw.content);
+  if (parsed.warning) {
+    return { services: null, errors: [], warnings: [parsed.warning] };
+  } else if (!parsed.config) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const renderServices = parsed.config.services;
+  if (!Array.isArray(renderServices) || renderServices.length === 0) {
+    return { services: null, errors: [], warnings: [] };
+  }
+  const services = {};
+  const serviceNames = /* @__PURE__ */ new Set();
+  const errors = [];
+  const warnings = [];
+  for (const rs of renderServices) {
+    const serviceType = rs.type;
+    if (serviceType === "cron") {
+      const name = rs.name ?? "unnamed";
+      const schedule = rs.schedule;
+      const runtime = rs.runtime && rs.runtime in import_types.RUNTIME_BUILDERS ? rs.runtime : void 0;
+      const hint = {
+        type: "cron",
+        ...schedule ? { schedule } : {},
+        entrypoint: "<path-to-handler>",
+        ...runtime ? { runtime } : {}
+      };
+      warnings.push({
+        code: "RENDER_CRON_HINT",
+        message: `Found Render cron service "${name}"` + (schedule ? ` (schedule: "${schedule}")` : "") + `. Vercel crons work with a file entrypoint. You can add the following to define this cron service:
+"${name}": ${JSON.stringify(hint, null, 2)}`
+      });
+      continue;
+    }
+    if (serviceType === "worker") {
+      const name = rs.name ?? "unnamed";
+      const runtime = rs.runtime ?? "unknown";
+      if (runtime === "python") {
+        const hint = {
+          type: "worker",
+          entrypoint: "<path-to-celery-app>",
+          runtime: "python"
+        };
+        warnings.push({
+          code: "RENDER_WORKER_HINT",
+          message: `Found Render worker service "${name}". Python workers using Celery are supported. You can add the following to define this worker:
+"${name}": ${JSON.stringify(hint, null, 2)}`
+        });
+      } else {
+        warnings.push({
+          code: "RENDER_WORKER_HINT",
+          message: `Found Render worker service "${name}" with runtime "${runtime}". Only Python workers are currently supported.`
+        });
+      }
+      continue;
+    }
+    if (serviceType === "pserv") {
+      const name = rs.name ?? "unnamed";
+      const hint = {
+        entrypoint: rs.rootDir ?? "<path-to-entrypoint>",
+        routePrefix: `/_/${name}`
+      };
+      warnings.push({
+        code: "RENDER_PSERV_HINT",
+        message: `Found Render private service "${name}". Private services are not yet supported. If you'd like to deploy it as a regular web service, you can add the following:
+"${name}": ${JSON.stringify(hint, null, 2)}`
+      });
+      continue;
+    }
+    if (!serviceType || !(serviceType in SERVICE_TYPE_MAP)) {
+      continue;
+    }
+    const serviceName = rs.name;
+    if (!serviceName) {
+      warnings.push({
+        code: "RENDER_CONFIG_ERROR",
+        message: "Skipped a Render service with no name. Each service in render.yaml must have a name."
+      });
+      continue;
+    }
+    if (serviceNames.has(serviceName)) {
+      errors.push({
+        code: "DUPLICATE_SERVICE",
+        message: `Duplicate service name "${serviceName}" in render.yaml.`,
+        serviceName
+      });
+      continue;
+    }
+    serviceNames.add(serviceName);
+    const rootDir = rs.rootDir || ".";
+    const serviceFs = rootDir === "." ? fs : fs.chdir(rootDir);
+    const frameworks = await (0, import_detect_framework.detectFrameworks)({
+      fs: serviceFs,
+      frameworkList: import_utils.DETECTION_FRAMEWORKS,
+      useExperimentalFrameworks: true
+    });
+    if (frameworks.length === 0) {
+      warnings.push({
+        code: "SERVICE_SKIPPED",
+        message: `Skipped Render service "${serviceName}": no framework detected. Configure it manually in experimentalServices.`
+      });
+      continue;
+    }
+    if (frameworks.length > 1) {
+      const names = frameworks.map((f) => f.name).join(", ");
+      errors.push({
+        code: "MULTIPLE_FRAMEWORKS_SERVICE",
+        message: `Multiple frameworks detected for Render service "${serviceName}": ${names}. Use explicit experimentalServices config.`,
+        serviceName
+      });
+      continue;
+    }
+    const framework = frameworks[0];
+    const vercelType = SERVICE_TYPE_MAP[serviceType];
+    const serviceConfig = {};
+    serviceConfig.type = vercelType;
+    serviceConfig.framework = framework.slug ?? void 0;
+    if (rootDir !== ".") {
+      serviceConfig.entrypoint = rootDir;
+    }
+    const buildCommand = (0, import_utils.combineBuildCommand)(
+      rs.buildCommand,
+      rs.preDeployCommand
+    );
+    if (buildCommand) {
+      serviceConfig.buildCommand = buildCommand;
+    }
+    services[serviceName] = serviceConfig;
+  }
+  if (errors.length > 0) {
+    return { services: null, errors, warnings };
+  }
+  if (Object.keys(services).length === 0) {
+    return { services: null, errors: [], warnings };
+  }
+  warnings.push(...(0, import_utils.assignRoutePrefixes)(services));
+  return { services, errors: [], warnings };
+}
+async function readRenderYaml(fs) {
+  try {
+    const exists = await fs.isFile(RENDER_YAML);
+    if (!exists)
+      return { content: null };
+    const buf = await fs.readFile(RENDER_YAML);
+    return { content: buf.toString("utf-8") };
+  } catch (err) {
+    return {
+      content: null,
+      warning: {
+        code: "RENDER_CONFIG_ERROR",
+        message: `Failed to read ${RENDER_YAML}: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+}
+function tryParseRenderConfig(content) {
+  try {
+    const config = import_js_yaml.default.load(content);
+    return { config };
+  } catch (err) {
+    return {
+      config: null,
+      warning: {
+        code: "RENDER_PARSE_ERROR",
+        message: `Failed to parse ${RENDER_YAML}: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectRenderServices
+});

package/dist/services/detect-services.d.ts

@@ -1,4 +1,4 @@
-import { type DetectServicesOptions, type DetectServicesResult, type Service, type ServicesRoutes } from './types';
+import type { DetectServicesOptions, DetectServicesResult, Service, ServicesRoutes } from './types';
 /**
  * Detect and resolve services within a project.
  *

package/dist/services/detect-services.js

@@ -28,6 +28,8 @@ var import_utils = require("./utils");
 var import_resolve = require("./resolve");
 var import_auto_detect = require("./auto-detect");
 var import_detect_railway = require("./detect-railway");
+var import_detect_render = require("./detect-render");
+var import_detect_procfile = require("./detect-procfile");
 const PREVIEW_DOMAIN_MISSING = [
   { type: "host", value: { suf: ".vercel.app" } },
   { type: "host", value: { suf: ".vercel.dev" } }
@@ -64,6 +66,12 @@ function toInferredLayoutConfig(services) {
   const inferredConfig = {};
   for (const [name, service] of Object.entries(services)) {
     const serviceConfig = {};
+    if (service.type) {
+      serviceConfig.type = service.type;
+    }
+    if (typeof service.root === "string") {
+      serviceConfig.root = service.root;
+    }
     if (typeof service.entrypoint === "string") {
       serviceConfig.entrypoint = service.entrypoint;
     }
@@ -76,12 +84,15 @@ function toInferredLayoutConfig(services) {
     if (typeof service.buildCommand === "string") {
       serviceConfig.buildCommand = service.buildCommand;
     }
+    if (typeof service.runtime === "string") {
+      serviceConfig.runtime = service.runtime;
+    }
     inferredConfig[name] = serviceConfig;
   }
   return inferredConfig;
 }
 async function detectServices(options) {
-  const { fs, workPath } = options;
+  const { fs, workPath, detectEntrypoint } = options;
   const scopedFs = workPath ? fs.chdir(workPath) : fs;
   const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
   if (configError) {
@@ -98,76 +109,17 @@ async function detectServices(options) {
   const configuredServices = hasNonEmptyPublicServicesConfig ? vercelConfig.services : vercelConfig?.experimentalServices;
   const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
   if (!hasConfiguredServices) {
-    const railwayResult = await (0, import_detect_railway.detectRailwayServices)({ fs: scopedFs });
-    if (railwayResult.errors.length > 0) {
-      return withResolvedResult({
-        services: [],
-        source: "auto-detected",
-        useImplicitEnvInjection: true,
-        routes: emptyRoutes(),
-        errors: railwayResult.errors,
-        warnings: railwayResult.warnings
-      });
-    }
-    if (railwayResult.services) {
-      const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
-        railwayResult.services,
-        scopedFs,
-        "generated"
-      );
-      const inferred = result2.errors.length === 0 && result2.services.length > 0 ? {
-        source: "railway",
-        config: toInferredLayoutConfig(railwayResult.services),
-        services: result2.services,
-        warnings: railwayResult.warnings
-      } : null;
-      return withResolvedResult(
-        {
-          services: [],
-          source: "auto-detected",
-          useImplicitEnvInjection: true,
-          routes: emptyRoutes(),
-          errors: result2.errors,
-          warnings: railwayResult.warnings
-        },
-        inferred
-      );
-    }
-    const autoResult = await (0, import_auto_detect.autoDetectServices)({ fs: scopedFs });
-    if (autoResult.services && autoResult.errors.length === 0) {
-      const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
-        autoResult.services,
-        scopedFs,
-        "generated"
-      );
-      const routes2 = generateServicesRoutes(result2.services);
-      const resolved = {
-        services: result2.services,
-        source: "auto-detected",
-        useImplicitEnvInjection: true,
-        routes: routes2,
-        errors: result2.errors,
-        warnings: []
-      };
-      const rootWebFrameworkServices = result2.services.filter(
-        (service) => service.type === "web" && service.routePrefix === "/" && typeof service.framework === "string"
-      );
-      const inferred = result2.errors.length === 0 && rootWebFrameworkServices.length === 1 && result2.services.length > 1 ? {
-        source: "layout",
-        config: toInferredLayoutConfig(autoResult.services),
-        services: result2.services,
-        warnings: []
-      } : null;
-      return withResolvedResult(resolved, inferred);
-    } else if (autoResult.errors.length > 0) {
-      return withResolvedResult({
-        services: [],
-        source: "auto-detected",
-        useImplicitEnvInjection: true,
-        routes: emptyRoutes(),
-        errors: autoResult.errors,
-        warnings: []
-      });
+    const detectors = [
+      { detect: import_detect_railway.detectRailwayServices, source: "railway" },
+      { detect: import_detect_render.detectRenderServices, source: "render" },
+      { detect: import_detect_procfile.detectProcfileServices, source: "procfile" },
+      { detect: import_auto_detect.autoDetectServices, source: "layout" }
+    ];
+    for (const { detect, source } of detectors) {
+      const detectResult = await detect({ fs: scopedFs, detectEntrypoint });
+      const match = await tryResolveInferred(detectResult, source, scopedFs);
+      if (match)
+        return match;
     }
     return withResolvedResult({
       services: [],
@@ -206,6 +158,66 @@ async function detectServices(options) {
     warnings: []
   });
 }
+async function tryResolveInferred(detectResult, source, scopedFs) {
+  if (detectResult.errors.length > 0) {
+    return withResolvedResult({
+      services: [],
+      source: "auto-detected",
+      useImplicitEnvInjection: true,
+      routes: emptyRoutes(),
+      errors: detectResult.errors,
+      warnings: detectResult.warnings
+    });
+  }
+  if (!detectResult.services) {
+    return null;
+  }
+  const result = await (0, import_resolve.resolveAllConfiguredServices)(
+    detectResult.services,
+    scopedFs,
+    "generated"
+  );
+  let shouldInfer;
+  if (source === "layout") {
+    const rootWebFrameworkServices = result.services.filter(
+      (service) => service.type === "web" && service.routePrefix === "/" && typeof service.framework === "string"
+    );
+    shouldInfer = result.errors.length === 0 && rootWebFrameworkServices.length === 1 && result.services.length > 1;
+  } else {
+    shouldInfer = result.errors.length === 0 && result.services.length > 0;
+  }
+  const inferred = shouldInfer ? {
+    source,
+    config: toInferredLayoutConfig(detectResult.services),
+    services: result.services,
+    warnings: detectResult.warnings
+  } : null;
+  if (source === "layout" && shouldInfer) {
+    const routes = generateServicesRoutes(result.services);
+    return withResolvedResult(
+      {
+        services: result.services,
+        source: "auto-detected",
+        useImplicitEnvInjection: true,
+        routes,
+        errors: result.errors,
+        warnings: detectResult.warnings
+      },
+      inferred
+    );
+  }
+  return withResolvedResult(
+    {
+      services: [],
+      source: "auto-detected",
+      useImplicitEnvInjection: true,
+      routes: emptyRoutes(),
+      errors: result.errors,
+      warnings: detectResult.warnings
+    },
+    inferred
+  );
+}
 function generateServicesRoutes(services) {
   const hostRewrites = [];
   const rewrites = [];

package/dist/services/types.d.ts

@@ -1,7 +1,7 @@
 import type { Route } from '@vercel/routing-utils';
-import type { EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
+import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-export type { EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
+export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceConfig, Services, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
 /**
  * @deprecated Use `Service` instead
  */
@@ -13,6 +13,12 @@ export interface DetectServicesOptions {
      * If provided, vercel.json is read from this path.
      */
     workPath?: string;
+    /**
+     * Optional callback that, given a candidate service directory and its
+     * detected framework, returns a normalized entrypoint (file path or
+     * `module:attr` reference). Used to suggested service configs.
+     */
+    detectEntrypoint?: DetectEntrypointFn;
 }
 export interface ServicesRoutes {
     /** Host-based rewrite routes for subdomain-mounted web services */
@@ -45,7 +51,7 @@ export interface ResolvedServicesResult {
     warnings: ServiceDetectionWarning[];
 }
 export interface InferredServicesResult {
-    source: 'layout' | 'procfile' | 'railway';
+    source: 'layout' | 'procfile' | 'railway' | 'render';
     config: InferredServicesConfig;
     services: Service[];
     warnings: ServiceDetectionWarning[];

package/dist/services/utils.d.ts

@@ -1,6 +1,8 @@
 import { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath } from '@vercel/build-utils';
+import type { Framework } from '@vercel/frameworks';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { EnvVars, ServiceRuntime, ExperimentalServices, Services, ServiceDetectionError, ResolvedService } from './types';
+import type { EnvVars, ServiceRuntime, ExperimentalServices, Services, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
+export declare const DETECTION_FRAMEWORKS: Framework[];
 export { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, };
 export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promise<boolean>;
 export declare function isPublicServicesEnabled(): boolean;
@@ -68,3 +70,14 @@ export interface ReadVercelConfigResult {
  * Returns the parsed config or an error if the file exists but is invalid.
  */
 export declare function readVercelConfig(fs: DetectorFilesystem): Promise<ReadVercelConfigResult>;
+/**
+ * Assign route prefixes to inferred services.
+ *
+ * A frontend service gets `/`, the rest get `/_/{name}`.
+ * A single non-frontend service would also get `/`.
+ * If no frontend service found, then multiple services get `/_/{name}`.
+ *
+ * Priority for `/`: single service or frontend > name "frontend" or "web" > alphabetical.
+ */
+export declare function assignRoutePrefixes(services: ExperimentalServices): ServiceDetectionWarning[];
+export declare function combineBuildCommand(buildCommand: string | undefined, preDeployCommand: string | string[] | undefined): string | undefined;

package/dist/services/utils.js

@@ -28,8 +28,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  DETECTION_FRAMEWORKS: () => DETECTION_FRAMEWORKS,
   INTERNAL_QUEUES_PREFIX: () => INTERNAL_QUEUES_PREFIX,
   INTERNAL_SERVICE_PREFIX: () => import_build_utils.INTERNAL_SERVICE_PREFIX,
+  assignRoutePrefixes: () => assignRoutePrefixes,
+  combineBuildCommand: () => combineBuildCommand,
   filterFrameworksByRuntime: () => filterFrameworksByRuntime,
   getBuilderForRuntime: () => getBuilderForRuntime,
   getInternalServiceCronPath: () => import_build_utils.getInternalServiceCronPath,
@@ -50,7 +53,11 @@ __export(utils_exports, {
 module.exports = __toCommonJS(utils_exports);
 var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
 var import_build_utils = require("@vercel/build-utils");
+var import_frameworks = require("@vercel/frameworks");
 var import_types = require("./types");
+const DETECTION_FRAMEWORKS = import_frameworks.frameworkList.filter(
+  (framework) => !framework.experimental || framework.runtimeFramework
+);
 async function hasFile(fs, filePath) {
   try {
     return await fs.isFile(filePath);
@@ -192,10 +199,48 @@ async function readVercelConfig(fs) {
   }
   return { config: null, error: null };
 }
+function assignRoutePrefixes(services) {
+  const warnings = [];
+  const names = Object.keys(services);
+  if (names.length === 1) {
+    services[names[0]].routePrefix = "/";
+    return warnings;
+  }
+  const frontendNames = names.filter(
+    (name) => isFrontendFramework(services[name].framework)
+  );
+  let rootName = null;
+  if (frontendNames.length === 1) {
+    rootName = frontendNames[0];
+  } else if (frontendNames.length > 1) {
+    rootName = frontendNames.find((n) => n === "frontend" || n === "web") ?? frontendNames.sort()[0];
+    warnings.push({
+      code: "MULTIPLE_FRONTENDS",
+      message: `Multiple frontend services detected (${frontendNames.join(", ")}). "${rootName}" was assigned routePrefix "/". Adjust manually if a different service should be the root.`
+    });
+  }
+  for (const name of names) {
+    services[name].routePrefix = name === rootName ? "/" : `/_/${name}`;
+  }
+  return warnings;
+}
+function combineBuildCommand(buildCommand, preDeployCommand) {
+  const preDeploy = Array.isArray(preDeployCommand) ? preDeployCommand.join(" && ") : preDeployCommand;
+  if (preDeploy && buildCommand) {
+    return `${buildCommand} && ${preDeploy}`;
+  } else if (preDeploy) {
+    return preDeploy;
+  } else {
+    return buildCommand;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DETECTION_FRAMEWORKS,
   INTERNAL_QUEUES_PREFIX,
   INTERNAL_SERVICE_PREFIX,
+  assignRoutePrefixes,
+  combineBuildCommand,
   filterFrameworksByRuntime,
   getBuilderForRuntime,
   getInternalServiceCronPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "6.4.0",
+  "version": "6.6.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,9 +20,9 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "@vercel/build-utils": "13.25.0",
-    "@vercel/frameworks": "3.26.1",
+    "@vercel/build-utils": "13.26.0",
     "@vercel/error-utils": "2.1.0",
+    "@vercel/frameworks": "3.26.1",
     "@vercel/routing-utils": "6.2.0"
   },
   "devDependencies": {