@vercel/fs-detectors 7.1.7 → 7.2.0

package/dist/index.d.ts

@@ -1,4 +1,11 @@
 export { builderToFrameworks, detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExtensions, getProxyBuilder, validateProxyConfig, validateProxy, type Options as DetectBuildersOptions, type ProxyConfig, } from './detect-builders';
+export { detectServices, generateServiceRewrites, generateServicesRoutes, } from './services/detect-services';
+export { resolveAllConfiguredServicesV2, resolveConfiguredServiceV2, validateServiceConfigV2, } from './services/resolve-v2';
+export { isExperimentalService, isExperimentalServiceV2, } from '@vercel/build-utils';
+export { autoDetectServices } from './services/auto-detect';
+export type { AutoDetectOptions, AutoDetectResult, } from './services/auto-detect';
+export { isStaticBuild, isRouteOwningBuilder, INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPath, getInternalServiceCronPathPrefix, getInternalServiceWorkerPath, getInternalServiceWorkerPathPrefix, } from './services/utils';
+export type { DetectServicesOptions, DetectServicesResult, DetectServicesSource, InferredServiceConfig, InferredServicesConfig, ResolvedServicesResult, InferredServicesResult, ResolvedService, Service, ExperimentalService, ExperimentalServiceV2, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ServicesRoutes, ServiceDetectionError, ConfiguredServices, ConfiguredServicesType, } from './services/types';
 export { detectFileSystemAPI } from './detect-file-system-api';
 export { detectFramework, detectFrameworks, detectFrameworkRecord, detectFrameworkVersion, } from './detect-framework';
 export { getProjectPaths } from './get-project-paths';

package/dist/index.js

@@ -22,10 +22,12 @@ __export(src_exports, {
   DetectorFilesystem: () => import_filesystem.DetectorFilesystem,
   GetWorkspaceOptions: () => import_get_workspaces.GetWorkspaceOptions,
   GetWorkspacePackagePathsOptions: () => import_get_workspace_package_paths.GetWorkspacePackagePathsOptions,
+  INTERNAL_SERVICE_PREFIX: () => import_utils.INTERNAL_SERVICE_PREFIX,
   LocalFileSystemDetector: () => import_local_file_system_detector.LocalFileSystemDetector,
   REGEX_NON_VERCEL_PLATFORM_FILES: () => import_detect_builders2.REGEX_NON_VERCEL_PLATFORM_FILES,
   Workspace: () => import_get_workspaces.Workspace,
   WorkspaceType: () => import_get_workspaces.WorkspaceType,
+  autoDetectServices: () => import_auto_detect.autoDetectServices,
   builderToFrameworks: () => import_detect_builders.builderToFrameworks,
   detectApiDirectory: () => import_detect_builders.detectApiDirectory,
   detectApiExtensions: () => import_detect_builders.detectApiExtensions,
@@ -37,20 +39,40 @@ __export(src_exports, {
   detectFrameworks: () => import_detect_framework.detectFrameworks,
   detectInstrumentation: () => import_detect_instrumentation.detectInstrumentation,
   detectOutputDirectory: () => import_detect_builders.detectOutputDirectory,
+  detectServices: () => import_detect_services.detectServices,
+  generateServiceRewrites: () => import_detect_services.generateServiceRewrites,
+  generateServicesRoutes: () => import_detect_services.generateServicesRoutes,
+  getInternalServiceCronPath: () => import_utils.getInternalServiceCronPath,
+  getInternalServiceCronPathPrefix: () => import_utils.getInternalServiceCronPathPrefix,
+  getInternalServiceFunctionPath: () => import_utils.getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath: () => import_utils.getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix: () => import_utils.getInternalServiceWorkerPathPrefix,
   getProjectPaths: () => import_get_project_paths.getProjectPaths,
   getProxyBuilder: () => import_detect_builders.getProxyBuilder,
   getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
   getWorkspaces: () => import_get_workspaces.getWorkspaces,
+  isExperimentalService: () => import_build_utils.isExperimentalService,
+  isExperimentalServiceV2: () => import_build_utils.isExperimentalServiceV2,
   isOfficialRuntime: () => import_is_official_runtime.isOfficialRuntime,
+  isRouteOwningBuilder: () => import_utils.isRouteOwningBuilder,
+  isStaticBuild: () => import_utils.isStaticBuild,
   isStaticRuntime: () => import_is_official_runtime.isStaticRuntime,
   monorepoManagers: () => import_monorepo_managers.monorepoManagers,
   packageManagers: () => import_package_managers.packageManagers,
+  resolveAllConfiguredServicesV2: () => import_resolve_v2.resolveAllConfiguredServicesV2,
+  resolveConfiguredServiceV2: () => import_resolve_v2.resolveConfiguredServiceV2,
   validateProxy: () => import_detect_builders.validateProxy,
   validateProxyConfig: () => import_detect_builders.validateProxyConfig,
+  validateServiceConfigV2: () => import_resolve_v2.validateServiceConfigV2,
   workspaceManagers: () => import_workspace_managers.workspaceManagers
 });
 module.exports = __toCommonJS(src_exports);
 var import_detect_builders = require("./detect-builders");
+var import_detect_services = require("./services/detect-services");
+var import_resolve_v2 = require("./services/resolve-v2");
+var import_build_utils = require("@vercel/build-utils");
+var import_auto_detect = require("./services/auto-detect");
+var import_utils = require("./services/utils");
 var import_detect_file_system_api = require("./detect-file-system-api");
 var import_detect_framework = require("./detect-framework");
 var import_get_project_paths = require("./get-project-paths");
@@ -70,10 +92,12 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   DetectorFilesystem,
   GetWorkspaceOptions,
   GetWorkspacePackagePathsOptions,
+  INTERNAL_SERVICE_PREFIX,
   LocalFileSystemDetector,
   REGEX_NON_VERCEL_PLATFORM_FILES,
   Workspace,
   WorkspaceType,
+  autoDetectServices,
   builderToFrameworks,
   detectApiDirectory,
   detectApiExtensions,
@@ -85,16 +109,31 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   detectFrameworks,
   detectInstrumentation,
   detectOutputDirectory,
+  detectServices,
+  generateServiceRewrites,
+  generateServicesRoutes,
+  getInternalServiceCronPath,
+  getInternalServiceCronPathPrefix,
+  getInternalServiceFunctionPath,
+  getInternalServiceWorkerPath,
+  getInternalServiceWorkerPathPrefix,
   getProjectPaths,
   getProxyBuilder,
   getWorkspacePackagePaths,
   getWorkspaces,
+  isExperimentalService,
+  isExperimentalServiceV2,
   isOfficialRuntime,
+  isRouteOwningBuilder,
+  isStaticBuild,
   isStaticRuntime,
   monorepoManagers,
   packageManagers,
+  resolveAllConfiguredServicesV2,
+  resolveConfiguredServiceV2,
   validateProxy,
   validateProxyConfig,
+  validateServiceConfigV2,
   workspaceManagers,
   ...require("./monorepos/get-monorepo-default-settings")
 });

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

@@ -0,0 +1,46 @@
+import type { DetectEntrypointFn } from '@vercel/build-utils';
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { InferredServicesConfig, 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: InferredServicesConfig | null;
+    errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
+}
+/**
+ * Auto-detect services when services are not configured.
+ *
+ * Scans the project for frameworks, supporting multiple layouts:
+ *
+ * Frontend at root, backend in backend/:
+ *   project/
+ *   ├── package.json
+ *   └── backend/
+ *
+ * Frontend in frontend/, backend in backend/:
+ *   project/
+ *   ├── frontend/
+ *   └── backend/
+ *
+ * Frontend in frontend/, backend in services/{service-name}/:
+ *   project/
+ *   ├── frontend/
+ *   └── services/
+ *       ├── service-a/
+ *       └── service-b/
+ *
+ * Frontend in apps/web/ monorepo, backend in services/{service-name}/:
+ *   project/
+ *   ├── apps/web/
+ *   └── services/
+ *       ├── service-a/
+ *       └── service-b/
+ */
+export declare function autoDetectServices(options: AutoDetectOptions): Promise<AutoDetectResult>;

package/dist/services/auto-detect.js

@@ -0,0 +1,269 @@
+"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 auto_detect_exports = {};
+__export(auto_detect_exports, {
+  autoDetectServices: () => autoDetectServices
+});
+module.exports = __toCommonJS(auto_detect_exports);
+var import_detect_framework = require("../detect-framework");
+var import_frameworks = require("@vercel/frameworks");
+var import_framework = require("./runtimes/framework");
+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];
+async function autoDetectServices(options) {
+  const { fs, detectEntrypoint } = options;
+  const rootFrameworks = await (0, import_detect_framework.detectFrameworks)({
+    fs,
+    frameworkList: import_frameworks.frameworkList
+  });
+  if (rootFrameworks.length > 1) {
+    const frameworkNames = rootFrameworks.map((f) => f.name).join(", ");
+    return {
+      services: null,
+      warnings: [],
+      errors: [
+        {
+          code: "MULTIPLE_FRAMEWORKS_ROOT",
+          message: `Multiple frameworks detected at root: ${frameworkNames}. Use explicit services config.`
+        }
+      ]
+    };
+  }
+  if (rootFrameworks.length === 1) {
+    return detectServicesAtRoot(fs, rootFrameworks[0], detectEntrypoint);
+  }
+  for (const frontendLocation of FRONTEND_LOCATIONS) {
+    const hasFrontendDir = await fs.hasPath(frontendLocation);
+    if (!hasFrontendDir) {
+      continue;
+    }
+    const frontendFs = fs.chdir(frontendLocation);
+    const frontendFrameworks = await (0, import_detect_framework.detectFrameworks)({
+      fs: frontendFs,
+      frameworkList: import_frameworks.frameworkList
+    });
+    if (frontendFrameworks.length > 1) {
+      const frameworkNames = frontendFrameworks.map((f) => f.name).join(", ");
+      return {
+        services: null,
+        warnings: [],
+        errors: [
+          {
+            code: "MULTIPLE_FRAMEWORKS_SERVICE",
+            message: `Multiple frameworks detected in ${frontendLocation}/: ${frameworkNames}. Use explicit services config.`
+          }
+        ]
+      };
+    }
+    if (frontendFrameworks.length === 1) {
+      return detectServicesFrontendSubdir(
+        fs,
+        frontendFrameworks[0],
+        frontendLocation,
+        detectEntrypoint
+      );
+    }
+  }
+  return {
+    services: null,
+    warnings: [],
+    errors: [
+      {
+        code: "NO_SERVICES_CONFIGURED",
+        message: "No services detected. Configure `services` in vercel.json or ensure a framework exists at project root, frontend/, or apps/web/."
+      }
+    ]
+  };
+}
+async function detectServicesAtRoot(fs, rootFramework, detectEntrypoint) {
+  const services = {};
+  services.frontend = {
+    root: ".",
+    framework: rootFramework.slug ?? void 0,
+    mountPath: "/"
+  };
+  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);
+  const mountWarnings = (0, import_utils.assignMountPaths)(services);
+  return {
+    services,
+    warnings: mountWarnings,
+    errors: []
+  };
+}
+async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocation, detectEntrypoint) {
+  const services = {};
+  const serviceName = frontendLocation.split("/").pop() || "frontend";
+  services[serviceName] = {
+    framework: frontendFramework.slug ?? void 0,
+    root: frontendLocation,
+    mountPath: "/"
+  };
+  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",
+          message: `Frontend detected in ${frontendLocation}/ but no backend services found. Add a backend/ or services/ directory with a supported framework.`
+        }
+      ]
+    };
+  }
+  Object.assign(services, backendResult.services);
+  const mountWarnings = (0, import_utils.assignMountPaths)(services);
+  return {
+    services,
+    warnings: mountWarnings,
+    errors: []
+  };
+}
+async function detectBackendServices(fs, detectEntrypoint) {
+  const services = {};
+  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,
+    detectEntrypoint
+  );
+  if (multiServicesResult.error) {
+    return { services: {}, error: multiServicesResult.error };
+  }
+  for (const serviceName of Object.keys(multiServicesResult.services)) {
+    if (services[serviceName]) {
+      return {
+        services: {},
+        error: {
+          code: "SERVICE_NAME_CONFLICT",
+          message: `Service name conflict: "${serviceName}" exists in both ${BACKEND_DIR}/ and ${SERVICES_DIR}/${serviceName}/. Rename one of the directories or use explicit services config.`,
+          serviceName
+        }
+      };
+    }
+  }
+  Object.assign(services, multiServicesResult.services);
+  return { services };
+}
+async function detectServicesDirectory(fs, detectEntrypoint) {
+  const services = {};
+  const hasServicesDir = await fs.hasPath(SERVICES_DIR);
+  if (!hasServicesDir) {
+    return { services };
+  }
+  const servicesFs = fs.chdir(SERVICES_DIR);
+  const entries = await servicesFs.readdir("/");
+  for (const entry of entries) {
+    if (entry.type !== "dir") {
+      continue;
+    }
+    const serviceName = entry.name;
+    const serviceDir = `${SERVICES_DIR}/${serviceName}`;
+    const result = await detectServiceInDir(
+      fs,
+      serviceDir,
+      serviceName,
+      detectEntrypoint
+    );
+    if (result.error) {
+      return { services: {}, error: result.error };
+    }
+    if (result.service) {
+      services[serviceName] = result.service;
+    }
+  }
+  return { services };
+}
+async function detectServiceInDir(fs, dirPath, serviceName, detectEntrypoint) {
+  const hasDirPath = await fs.hasPath(dirPath);
+  if (!hasDirPath) {
+    return {};
+  }
+  const serviceFs = fs.chdir(dirPath);
+  const frameworks = await (0, import_detect_framework.detectFrameworks)({
+    fs: serviceFs,
+    frameworkList: import_framework.DETECTION_FRAMEWORKS,
+    useExperimentalFrameworks: true
+  });
+  if (frameworks.length > 1) {
+    const frameworkNames = frameworks.map((f) => f.name).join(", ");
+    return {
+      error: {
+        code: "MULTIPLE_FRAMEWORKS_SERVICE",
+        message: `Multiple frameworks detected in ${dirPath}/: ${frameworkNames}. Use explicit services config.`,
+        serviceName
+      }
+    };
+  }
+  if (frameworks.length !== 1) {
+    return {};
+  }
+  const framework = frameworks[0];
+  const slug = framework.slug ?? void 0;
+  const mountPath = `/${serviceName}`;
+  const detected = detectEntrypoint && !(0, import_framework.isFrontendFramework)(slug) ? await detectEntrypoint({ workPath: dirPath, framework: slug }) : null;
+  return {
+    service: {
+      framework: slug,
+      root: dirPath,
+      ...detected ? { entrypoint: detected.entrypoint } : {},
+      mountPath
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoDetectServices
+});

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

@@ -0,0 +1,22 @@
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
+export interface ProcfileDetectResult {
+    services: InferredServicesConfig | 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,250 @@
+"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_framework = require("./runtimes/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_framework.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 services 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] = {
+          root: ".",
+          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 services.`
+      });
+      continue;
+    }
+    services[processType] = {
+      root: ".",
+      type: "web",
+      ...detectedFramework?.slug ? { framework: detectedFramework.slug } : {},
+      entrypoint: entrypoint ?? "."
+    };
+  }
+  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.assignMountPaths)(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
+});