@vercel/fs-detectors 5.7.16 → 5.7.18

package/dist/detect-builders.js

@@ -44,6 +44,7 @@ var import_path = require("path");
 var import_frameworks = __toESM(require("@vercel/frameworks"));
 var import_is_official_runtime = require("./is-official-runtime");
 var import_build_utils = require("@vercel/build-utils");
+var import_get_services_builders = require("./services/get-services-builders");
 const REGEX_MIDDLEWARE_FILES = "middleware.[jt]s";
 const REGEX_VERCEL_PLATFORM_FILES = `api/**,package.json,${REGEX_MIDDLEWARE_FILES}`;
 const REGEX_NON_VERCEL_PLATFORM_FILES = `!{${REGEX_VERCEL_PLATFORM_FILES}}`;
@@ -79,6 +80,13 @@ function detectOutputDirectory(builders) {
   return publicBuilder ? publicBuilder.src.replace("/**/*", "") : null;
 }
 async function detectBuilders(files, pkg, options = {}) {
+  const { projectSettings = {} } = options;
+  const { framework } = projectSettings;
+  if (framework === "services") {
+    return (0, import_get_services_builders.getServicesBuilders)({
+      workPath: options.workPath
+    });
+  }
   const errors = [];
   const warnings = [];
   let apiBuilders = [];
@@ -104,8 +112,7 @@ async function detectBuilders(files, pkg, options = {}) {
       usedFunctions.add(key);
   };
   const absolutePathCache = /* @__PURE__ */ new Map();
-  const { projectSettings = {} } = options;
-  const { buildCommand, outputDirectory, framework } = projectSettings;
+  const { buildCommand, outputDirectory } = projectSettings;
   const frameworkConfig = slugToFramework.get(framework || "");
   const ignoreRuntimes = new Set(frameworkConfig?.ignoreRuntimes);
   const withTag = options.tag ? `@${options.tag}` : "";

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-export { detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExtensions, } from './detect-builders';
-export { detectServices, type DetectServicesOptions, type DetectServicesResult, type ResolvedService, } from './services';
+export { detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExtensions, type Options as DetectBuildersOptions, } from './detect-builders';
+export { detectServices, generateServicesRoutes, } from './services/detect-services';
+export { getServicesBuilders } from './services/get-services-builders';
+export type { DetectServicesOptions, DetectServicesResult, ResolvedService, ServicesRoutes, } 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

@@ -36,8 +36,10 @@ __export(src_exports, {
   detectFrameworks: () => import_detect_framework.detectFrameworks,
   detectInstrumentation: () => import_detect_instrumentation.detectInstrumentation,
   detectOutputDirectory: () => import_detect_builders.detectOutputDirectory,
-  detectServices: () => import_services.detectServices,
+  detectServices: () => import_detect_services.detectServices,
+  generateServicesRoutes: () => import_detect_services.generateServicesRoutes,
   getProjectPaths: () => import_get_project_paths.getProjectPaths,
+  getServicesBuilders: () => import_get_services_builders.getServicesBuilders,
   getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
   getWorkspaces: () => import_get_workspaces.getWorkspaces,
   isOfficialRuntime: () => import_is_official_runtime.isOfficialRuntime,
@@ -48,7 +50,8 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_detect_builders = require("./detect-builders");
-var import_services = require("./services");
+var import_detect_services = require("./services/detect-services");
+var import_get_services_builders = require("./services/get-services-builders");
 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");
@@ -83,7 +86,9 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   detectInstrumentation,
   detectOutputDirectory,
   detectServices,
+  generateServicesRoutes,
   getProjectPaths,
+  getServicesBuilders,
   getWorkspacePackagePaths,
   getWorkspaces,
   isOfficialRuntime,

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

@@ -0,0 +1,19 @@
+import type { DetectServicesOptions, DetectServicesResult, ResolvedService, ServicesRoutes } from './types';
+/**
+ * Detect and resolve services within a project.
+ *
+ * Reads vercel.json and resolves `experimentalServices` into ResolvedService objects.
+ * Returns an error if no services are configured.
+ */
+export declare function detectServices(options: DetectServicesOptions): Promise<DetectServicesResult>;
+/**
+ * Generate routing rules for services.
+ *
+ * Web services: Routes are ordered by prefix length (longest first) to ensure
+ * more specific routes match before broader ones. For example, `/api/users`
+ * must be checked before `/api`, which must be checked before the catch-all `/`.
+ *
+ * Cron/Worker services: TODO
+ * Use internal routes under `/_svc/crons` and `/_svc/workers`
+ */
+export declare function generateServicesRoutes(services: ResolvedService[]): ServicesRoutes;

package/dist/services/detect-services.js

@@ -0,0 +1,103 @@
+"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_services_exports = {};
+__export(detect_services_exports, {
+  detectServices: () => detectServices,
+  generateServicesRoutes: () => generateServicesRoutes
+});
+module.exports = __toCommonJS(detect_services_exports);
+var import_utils = require("./utils");
+var import_resolve = require("./resolve");
+async function detectServices(options) {
+  const { fs, workPath } = options;
+  const scopedFs = workPath ? fs.chdir(workPath) : fs;
+  const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
+  if (configError) {
+    return {
+      services: [],
+      routes: { rewrites: [], defaults: [], crons: [], workers: [] },
+      errors: [configError],
+      warnings: []
+    };
+  }
+  const configuredServices = vercelConfig?.experimentalServices;
+  const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
+  if (!hasConfiguredServices) {
+    return {
+      services: [],
+      routes: { rewrites: [], defaults: [], crons: [], workers: [] },
+      errors: [
+        {
+          code: "NO_SERVICES_CONFIGURED",
+          message: "No services configured. Add `experimentalServices` to vercel.json."
+        }
+      ],
+      warnings: []
+    };
+  }
+  const result = (0, import_resolve.resolveAllConfiguredServices)(configuredServices);
+  const routes = generateServicesRoutes(result.services);
+  return {
+    services: result.services,
+    routes,
+    errors: result.errors,
+    warnings: []
+  };
+}
+function generateServicesRoutes(services) {
+  const rewrites = [];
+  const defaults = [];
+  const crons = [];
+  const workers = [];
+  const webServices = services.filter(
+    (s) => s.type === "web" && typeof s.routePrefix === "string"
+  );
+  const sortedWebServices = [...webServices].sort((a, b) => {
+    if (a.routePrefix === "/")
+      return 1;
+    if (b.routePrefix === "/")
+      return -1;
+    return b.routePrefix.length - a.routePrefix.length;
+  });
+  for (const service of sortedWebServices) {
+    const { routePrefix, builder } = service;
+    const builderSrc = builder.src || routePrefix;
+    const functionPath = builderSrc.startsWith("/") ? builderSrc : `/${builderSrc}`;
+    if (routePrefix === "/") {
+      defaults.push({
+        src: "^/(.*)$",
+        dest: functionPath,
+        check: true
+      });
+    } else {
+      const normalizedPrefix = routePrefix.startsWith("/") ? routePrefix.slice(1) : routePrefix;
+      rewrites.push({
+        src: `^/${normalizedPrefix}(?:/.*)?$`,
+        dest: functionPath,
+        check: true
+      });
+    }
+  }
+  return { rewrites, defaults, crons, workers };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectServices,
+  generateServicesRoutes
+});

package/dist/services/get-services-builders.d.ts

@@ -0,0 +1,29 @@
+import type { Route } from '@vercel/routing-utils';
+import type { Builder } from '@vercel/build-utils';
+import type { ResolvedService } from './types';
+export interface ErrorResponse {
+    code: string;
+    message: string;
+    action?: string;
+    link?: string;
+}
+export interface GetServicesBuildersOptions {
+    workPath?: string;
+}
+export interface ServicesBuildersResult {
+    builders: Builder[] | null;
+    errors: ErrorResponse[] | null;
+    warnings: ErrorResponse[];
+    defaultRoutes: Route[] | null;
+    redirectRoutes: Route[] | null;
+    rewriteRoutes: Route[] | null;
+    errorRoutes: Route[] | null;
+    services?: ResolvedService[];
+}
+/**
+ * Get builders for services - adapter for detectBuilders.
+ *
+ * This function wraps `detectServices` and transforms the result into
+ * the shape expected by `detectBuilders` when `framework === 'services'`.
+ */
+export declare function getServicesBuilders(options: GetServicesBuildersOptions): Promise<ServicesBuildersResult>;

package/dist/services/get-services-builders.js

@@ -0,0 +1,95 @@
+"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 get_services_builders_exports = {};
+__export(get_services_builders_exports, {
+  getServicesBuilders: () => getServicesBuilders
+});
+module.exports = __toCommonJS(get_services_builders_exports);
+var import_detect_services = require("./detect-services");
+var import_local_file_system_detector = require("../detectors/local-file-system-detector");
+async function getServicesBuilders(options) {
+  const { workPath } = options;
+  if (!workPath) {
+    return {
+      builders: null,
+      errors: [
+        {
+          code: "MISSING_WORK_PATH",
+          message: "workPath is required for services detection."
+        }
+      ],
+      warnings: [],
+      defaultRoutes: null,
+      redirectRoutes: null,
+      rewriteRoutes: null,
+      errorRoutes: null
+    };
+  }
+  const fs = new import_local_file_system_detector.LocalFileSystemDetector(workPath);
+  const result = await (0, import_detect_services.detectServices)({ fs });
+  const warningResponses = result.warnings.map((w) => ({
+    code: w.code,
+    message: w.message
+  }));
+  if (result.errors.length > 0) {
+    return {
+      builders: null,
+      errors: result.errors.map((e) => ({
+        code: e.code,
+        message: e.message
+      })),
+      warnings: warningResponses,
+      defaultRoutes: null,
+      redirectRoutes: null,
+      rewriteRoutes: null,
+      errorRoutes: null
+    };
+  }
+  if (result.services.length === 0) {
+    return {
+      builders: null,
+      errors: [
+        {
+          code: "NO_SERVICES_CONFIGURED",
+          message: "No services configured. Add `experimentalServices` to vercel.json."
+        }
+      ],
+      warnings: warningResponses,
+      defaultRoutes: null,
+      redirectRoutes: null,
+      rewriteRoutes: null,
+      errorRoutes: null
+    };
+  }
+  const builders = result.services.map((service) => service.builder);
+  return {
+    builders: builders.length > 0 ? builders : null,
+    errors: null,
+    warnings: warningResponses,
+    defaultRoutes: result.routes.defaults.length > 0 ? result.routes.defaults : null,
+    redirectRoutes: [],
+    rewriteRoutes: result.routes.rewrites.length > 0 ? result.routes.rewrites : null,
+    errorRoutes: [],
+    services: result.services
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getServicesBuilders
+});

package/dist/services/resolve.d.ts

@@ -1,3 +1,17 @@
-import type { ResolvedService, ExperimentalServiceConfig, ServiceDetectionError } from './types';
+import type { ResolvedService, ExperimentalServiceConfig, ExperimentalServices, ServiceDetectionError } from './types';
+/**
+ * Validate a service configuration from vercel.json experimentalServices.
+ */
 export declare function validateServiceConfig(name: string, config: ExperimentalServiceConfig): ServiceDetectionError | null;
-export declare function resolveService(name: string, config: ExperimentalServiceConfig, group?: string): ResolvedService;
+/**
+ * Resolve a single service from user configuration.
+ */
+export declare function resolveConfiguredService(name: string, config: ExperimentalServiceConfig, group?: string): ResolvedService;
+/**
+ * Resolve all services from vercel.json experimentalServices.
+ * Validates each service configuration.
+ */
+export declare function resolveAllConfiguredServices(services: ExperimentalServices): {
+    services: ResolvedService[];
+    errors: ServiceDetectionError[];
+};

package/dist/services/resolve.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,51 +17,175 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 resolve_exports = {};
 __export(resolve_exports, {
-  resolveService: () => resolveService,
+  resolveAllConfiguredServices: () => resolveAllConfiguredServices,
+  resolveConfiguredService: () => resolveConfiguredService,
   validateServiceConfig: () => validateServiceConfig
 });
 module.exports = __toCommonJS(resolve_exports);
+var import_path = require("path");
+var import_types = require("./types");
+var import_utils = require("./utils");
+var import_frameworks = __toESM(require("@vercel/frameworks"));
+const frameworksBySlug = new Map(import_frameworks.default.map((f) => [f.slug, f]));
 function validateServiceConfig(name, config) {
-  if (config.type === "cron" && !config.schedule) {
+  if (!config || typeof config !== "object") {
+    return {
+      code: "INVALID_SERVICE_CONFIG",
+      message: `Service "${name}" has an invalid configuration. Expected an object.`,
+      serviceName: name
+    };
+  }
+  const serviceType = config.type || "web";
+  if (serviceType === "web" && !config.routePrefix) {
+    return {
+      code: "MISSING_ROUTE_PREFIX",
+      message: `Web service "${name}" must specify "routePrefix".`,
+      serviceName: name
+    };
+  }
+  if ((serviceType === "worker" || serviceType === "cron") && config.routePrefix) {
+    return {
+      code: "INVALID_ROUTE_PREFIX",
+      message: `${serviceType === "worker" ? "Worker" : "Cron"} service "${name}" cannot have "routePrefix". Only web services should specify "routePrefix".`,
+      serviceName: name
+    };
+  }
+  if (serviceType === "cron" && !config.schedule) {
     return {
       code: "MISSING_CRON_SCHEDULE",
-      message: `Cron service "${name}" is missing required "schedule" field`,
+      message: `Cron service "${name}" is missing required "schedule" field.`,
+      serviceName: name
+    };
+  }
+  if (config.runtime && !(config.runtime in import_types.RUNTIME_BUILDERS)) {
+    return {
+      code: "INVALID_RUNTIME",
+      message: `Service "${name}" has invalid runtime "${config.runtime}".`,
       serviceName: name
     };
   }
+  if (config.framework && !frameworksBySlug.has(config.framework)) {
+    return {
+      code: "INVALID_FRAMEWORK",
+      message: `Service "${name}" has invalid framework "${config.framework}".`,
+      serviceName: name
+    };
+  }
+  const hasFramework = Boolean(config.framework);
+  const hasBuilderOrRuntime = Boolean(config.builder || config.runtime);
+  const hasEntrypoint = Boolean(config.entrypoint);
+  if (!hasFramework && !hasBuilderOrRuntime && !hasEntrypoint) {
+    return {
+      code: "MISSING_SERVICE_CONFIG",
+      message: `Service "${name}" must specify "framework", "entrypoint", or both "builder"/"runtime" with "entrypoint".`,
+      serviceName: name
+    };
+  }
+  if (hasBuilderOrRuntime && !hasFramework && !hasEntrypoint) {
+    return {
+      code: "MISSING_ENTRYPOINT",
+      message: `Service "${name}" must specify "entrypoint" when using "${config.builder ? "builder" : "runtime"}".`,
+      serviceName: name
+    };
+  }
+  if (hasEntrypoint && !hasBuilderOrRuntime && !hasFramework) {
+    const runtime = (0, import_utils.inferServiceRuntime)({ entrypoint: config.entrypoint });
+    if (!runtime) {
+      const supported = Object.keys(import_types.ENTRYPOINT_EXTENSIONS).join(", ");
+      return {
+        code: "UNSUPPORTED_ENTRYPOINT",
+        message: `Service "${name}" has unsupported entrypoint "${config.entrypoint}". Use a supported extension (${supported}) or specify "builder", "framework", or "runtime".`,
+        serviceName: name
+      };
+    }
+  }
   return null;
 }
-function resolveService(name, config, group) {
+function resolveConfiguredService(name, config, group) {
   const type = config.type || "web";
   const workspace = config.workspace || ".";
   const topic = type === "worker" ? config.topic || "default" : config.topic;
   const consumer = type === "worker" ? config.consumer || "default" : config.consumer;
+  const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
+  let builderUse;
+  let builderSrc;
+  if (config.framework) {
+    const framework = frameworksBySlug.get(config.framework);
+    builderUse = framework?.useRuntime?.use || "@vercel/static-build";
+    builderSrc = config.entrypoint || framework?.useRuntime?.src || "package.json";
+  } else if (config.builder) {
+    builderUse = config.builder;
+    builderSrc = config.entrypoint;
+  } else {
+    builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
+    builderSrc = config.entrypoint;
+  }
+  const routePrefix = type === "web" ? config.routePrefix : void 0;
+  const isRoot = workspace === ".";
+  if (!isRoot && !builderSrc.startsWith(workspace + "/")) {
+    builderSrc = import_path.posix.join(workspace, builderSrc);
+  }
+  const builderConfig = {};
+  if (config.memory)
+    builderConfig.memory = config.memory;
+  if (config.maxDuration)
+    builderConfig.maxDuration = config.maxDuration;
+  if (config.includeFiles)
+    builderConfig.includeFiles = config.includeFiles;
+  if (config.excludeFiles)
+    builderConfig.excludeFiles = config.excludeFiles;
+  const isStaticBuild = import_types.STATIC_BUILDERS.has(builderUse);
+  const runtime = isStaticBuild ? void 0 : inferredRuntime;
   return {
     name,
     type,
     group,
     workspace,
     entrypoint: config.entrypoint,
-    routePrefix: config.routePrefix,
+    routePrefix,
     framework: config.framework,
-    builder: config.builder,
-    runtime: config.runtime,
+    builder: {
+      src: builderSrc,
+      use: builderUse,
+      config: Object.keys(builderConfig).length > 0 ? builderConfig : void 0
+    },
+    runtime,
     buildCommand: config.buildCommand,
     installCommand: config.installCommand,
-    memory: config.memory,
-    maxDuration: config.maxDuration,
-    includeFiles: config.includeFiles,
-    excludeFiles: config.excludeFiles,
     schedule: config.schedule,
     topic,
     consumer
   };
 }
+function resolveAllConfiguredServices(services) {
+  const resolved = [];
+  const errors = [];
+  for (const name of Object.keys(services)) {
+    const serviceConfig = services[name];
+    const validationError = validateServiceConfig(name, serviceConfig);
+    if (validationError) {
+      errors.push(validationError);
+      continue;
+    }
+    const service = resolveConfiguredService(name, serviceConfig);
+    resolved.push(service);
+  }
+  return { services: resolved, errors };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  resolveService,
+  resolveAllConfiguredServices,
+  resolveConfiguredService,
   validateServiceConfig
 });

package/dist/services/types.d.ts

@@ -1,6 +1,7 @@
-import type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType } from '@vercel/build-utils';
+import type { Route } from '@vercel/routing-utils';
+import type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, Builder } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-export type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, };
+export type { ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, Builder, };
 export interface ResolvedService {
     name: string;
     type: ServiceType;
@@ -9,14 +10,15 @@ export interface ResolvedService {
     workspace: string;
     entrypoint?: string;
     framework?: string;
-    builder?: string;
+    builder: Builder;
     buildCommand?: string;
     installCommand?: string;
     runtime?: string;
-    memory?: number;
-    maxDuration?: number;
-    includeFiles?: string | string[];
-    excludeFiles?: string | string[];
+    /**
+     * URL path prefix for routing requests to this service.
+     * Required for web services; requests matching this prefix are routed to this service.
+     * Root services use "/" as the catch-all.
+     */
     routePrefix?: string;
     schedule?: string;
     topic?: string;
@@ -24,11 +26,41 @@ export interface ResolvedService {
 }
 export interface DetectServicesOptions {
     fs: DetectorFilesystem;
+    /**
+     * Working directory path (relative to fs root).
+     * If provided, vercel.json is read from this path.
+     */
     workPath?: string;
 }
+export interface ServicesRoutes {
+    /** Rewrite routes for non-root web services (prefix-based) */
+    rewrites: Route[];
+    /** Default routes (catch-all for root web service) */
+    defaults: Route[];
+    /**
+     * Internal routes for cron services.
+     * These route `/_svc/{serviceName}/crons/{entry}/{handler}` to the cron function.
+     * TODO: Implement
+     */
+    crons: Route[];
+    /**
+     * Internal routes for worker services.
+     * These route `/_svc/{serviceName}/workers/{entry}/{handler}` to the worker function.
+     * TODO: Implement
+     */
+    workers: Route[];
+}
 export interface DetectServicesResult {
     services: ResolvedService[];
+    /** Routing rules derived from services */
+    routes: ServicesRoutes;
     errors: ServiceDetectionError[];
+    warnings: ServiceDetectionWarning[];
+}
+export interface ServiceDetectionWarning {
+    code: string;
+    message: string;
+    serviceName?: string;
 }
 export interface ServiceDetectionError {
     code: string;
@@ -36,3 +68,9 @@ export interface ServiceDetectionError {
     serviceName?: string;
 }
 export declare const RUNTIME_BUILDERS: Record<ServiceRuntime, string>;
+export declare const ENTRYPOINT_EXTENSIONS: Record<string, ServiceRuntime>;
+/**
+ * Builders that produce static output (SPAs, static sites).
+ * These don't have a "runtime" - they just build to static files.
+ */
+export declare const STATIC_BUILDERS: Set<string>;

package/dist/services/types.js

@@ -18,7 +18,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var types_exports = {};
 __export(types_exports, {
-  RUNTIME_BUILDERS: () => RUNTIME_BUILDERS
+  ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
+  RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
+  STATIC_BUILDERS: () => STATIC_BUILDERS
 });
 module.exports = __toCommonJS(types_exports);
 const RUNTIME_BUILDERS = {
@@ -28,7 +30,25 @@ const RUNTIME_BUILDERS = {
   rust: "@vercel/rust",
   ruby: "@vercel/ruby"
 };
+const ENTRYPOINT_EXTENSIONS = {
+  ".ts": "node",
+  ".mts": "node",
+  ".js": "node",
+  ".mjs": "node",
+  ".cjs": "node",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".rb": "ruby",
+  ".ru": "ruby"
+};
+const STATIC_BUILDERS = /* @__PURE__ */ new Set([
+  "@vercel/static-build",
+  "@vercel/static"
+]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RUNTIME_BUILDERS
+  ENTRYPOINT_EXTENSIONS,
+  RUNTIME_BUILDERS,
+  STATIC_BUILDERS
 });

package/dist/services/utils.d.ts

@@ -0,0 +1,31 @@
+import type { DetectorFilesystem } from '../detectors/filesystem';
+import type { ServiceRuntime, ExperimentalServices, ServiceDetectionError } from './types';
+export declare function getBuilderForRuntime(runtime: ServiceRuntime): string;
+/**
+ * Infer runtime from available service configuration.
+ *
+ * Priority (highest to lowest):
+ * 1. Explicit runtime (user specified in config)
+ * 2. Framework detection (fastapi → python, express → node)
+ * 3. Builder detection (@vercel/python → python)
+ * 4. Entrypoint extension (.py → python, .ts → node)
+ *
+ * @returns The inferred runtime, or undefined if none can be determined.
+ */
+export declare function inferServiceRuntime(config: {
+    runtime?: string;
+    framework?: string;
+    builder?: string;
+    entrypoint?: string;
+}): ServiceRuntime | undefined;
+export interface ReadVercelConfigResult {
+    config: {
+        experimentalServices?: ExperimentalServices;
+    } | null;
+    error: ServiceDetectionError | null;
+}
+/**
+ * Read and parse vercel.json from filesystem.
+ * Returns the parsed config or an error if the file exists but is invalid.
+ */
+export declare function readVercelConfig(fs: DetectorFilesystem): Promise<ReadVercelConfigResult>;

package/dist/services/utils.js

@@ -0,0 +1,85 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  getBuilderForRuntime: () => getBuilderForRuntime,
+  inferServiceRuntime: () => inferServiceRuntime,
+  readVercelConfig: () => readVercelConfig
+});
+module.exports = __toCommonJS(utils_exports);
+var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
+var import_types = require("./types");
+function getBuilderForRuntime(runtime) {
+  const builder = import_types.RUNTIME_BUILDERS[runtime];
+  if (!builder) {
+    throw new Error(`Unknown runtime: ${runtime}`);
+  }
+  return builder;
+}
+function inferServiceRuntime(config) {
+  if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
+    return config.runtime;
+  }
+  if ((0, import_framework_helpers.isPythonFramework)(config.framework)) {
+    return "python";
+  }
+  if ((0, import_framework_helpers.isBackendFramework)(config.framework)) {
+    return "node";
+  }
+  if (config.builder) {
+    for (const [runtime, builderName] of Object.entries(import_types.RUNTIME_BUILDERS)) {
+      if (config.builder === builderName) {
+        return runtime;
+      }
+    }
+  }
+  if (config.entrypoint) {
+    for (const [ext, runtime] of Object.entries(import_types.ENTRYPOINT_EXTENSIONS)) {
+      if (config.entrypoint.endsWith(ext)) {
+        return runtime;
+      }
+    }
+  }
+  return void 0;
+}
+async function readVercelConfig(fs) {
+  const hasVercelJson = await fs.hasPath("vercel.json");
+  if (!hasVercelJson) {
+    return { config: null, error: null };
+  }
+  try {
+    const content = await fs.readFile("vercel.json");
+    const config = JSON.parse(content.toString());
+    return { config, error: null };
+  } catch {
+    return {
+      config: null,
+      error: {
+        code: "INVALID_VERCEL_JSON",
+        message: "Failed to parse vercel.json. Ensure it contains valid JSON."
+      }
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBuilderForRuntime,
+  inferServiceRuntime,
+  readVercelConfig
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.7.16",
+  "version": "5.7.18",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,8 +20,8 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "@vercel/error-utils": "2.0.3",
-    "@vercel/routing-utils": "5.3.2",
-    "@vercel/frameworks": "3.15.7"
+    "@vercel/frameworks": "3.16.0",
+    "@vercel/routing-utils": "5.3.2"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",
@@ -32,7 +32,7 @@
     "@types/semver": "7.3.10",
     "jest-junit": "16.0.0",
     "typescript": "4.9.5",
-    "@vercel/build-utils": "13.2.14"
+    "@vercel/build-utils": "13.2.16"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",

package/dist/services/index.d.ts

@@ -1,10 +0,0 @@
-import type { DetectServicesOptions, DetectServicesResult } from './types';
-export * from './types';
-export * from './resolve';
-/**
- * Detect and resolve services within a project.
- *
- * Reads service configurations from vercel.json `experimentalServices`
- * and resolves them into ResolvedService objects.
- */
-export declare function detectServices(options: DetectServicesOptions): Promise<DetectServicesResult>;

package/dist/services/index.js

@@ -1,60 +0,0 @@
-"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var services_exports = {};
-__export(services_exports, {
-  detectServices: () => detectServices
-});
-module.exports = __toCommonJS(services_exports);
-var import_resolve = require("./resolve");
-__reExport(services_exports, require("./types"), module.exports);
-__reExport(services_exports, require("./resolve"), module.exports);
-async function detectServices(options) {
-  const { fs, workPath = "" } = options;
-  const services = [];
-  const errors = [];
-  const configPath = workPath ? `${workPath}/vercel.json` : "vercel.json";
-  let experimentalServices;
-  try {
-    const configBuffer = await fs.readFile(configPath);
-    const config = JSON.parse(configBuffer.toString("utf-8"));
-    experimentalServices = config.experimentalServices;
-  } catch {
-    return { services, errors };
-  }
-  if (experimentalServices && typeof experimentalServices === "object") {
-    for (const name of Object.keys(experimentalServices)) {
-      const serviceConfig = experimentalServices[name];
-      const validationError = (0, import_resolve.validateServiceConfig)(name, serviceConfig);
-      if (validationError) {
-        errors.push(validationError);
-        continue;
-      }
-      const resolved = (0, import_resolve.resolveService)(name, serviceConfig);
-      services.push(resolved);
-    }
-  }
-  return { services, errors };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  detectServices,
-  ...require("./types"),
-  ...require("./resolve")
-});