@vercel/fs-detectors 6.7.7 → 6.8.0

package/dist/detect-builders.d.ts

@@ -1,5 +1,5 @@
 import type { Route } from '@vercel/routing-utils';
-import type { PackageJson, Builder, BuilderFunctions, ExperimentalServices, ProjectSettings, Service } from '@vercel/build-utils';
+import type { PackageJson, Builder, BuilderFunctions, ExperimentalServices, ExperimentalServicesV2, ProjectSettings, Service } from '@vercel/build-utils';
 /**
  * Pattern for finding all supported middleware files.
  */
@@ -23,6 +23,7 @@ export interface Options {
     tag?: string;
     functions?: BuilderFunctions;
     experimentalServices?: ExperimentalServices;
+    experimentalServicesV2?: ExperimentalServicesV2;
     ignoreBuildScript?: boolean;
     projectSettings?: ProjectSettings;
     cleanUrls?: boolean;

package/dist/detect-builders.js

@@ -92,18 +92,28 @@ function detectOutputDirectory(builders) {
   return publicBuilder ? publicBuilder.src.replace("/**/*", "") : null;
 }
 async function detectBuilders(files, pkg, options = {}) {
-  const { experimentalServices, projectSettings = {} } = options;
+  const {
+    experimentalServices: experimentalServicesV1,
+    experimentalServicesV2,
+    projectSettings = {}
+  } = options;
   const { framework } = projectSettings;
-  const configuredServices = experimentalServices;
-  const configuredServicesType = "experimentalServices";
+  const configuredServices = experimentalServicesV2 ?? experimentalServicesV1;
+  const configuredServicesType = experimentalServicesV2 ? "experimentalServicesV2" : "experimentalServices";
   const hasServicesConfig = configuredServices != null && typeof configuredServices === "object";
   if (hasServicesConfig || framework === "services") {
-    return (0, import_get_services_builders.getServicesBuilders)({
+    const result = await (0, import_get_services_builders.getServicesBuilders)({
       workPath: options.workPath,
       configuredServices,
       configuredServicesType,
       projectFramework: framework
     });
+    if (configuredServices != null) {
+      result.warnings.push(
+        ...(0, import_get_services_builders.warnIgnoredDirectories)(files, configuredServices)
+      );
+    }
+    return result;
   }
   const errors = [];
   const warnings = [];
@@ -486,10 +496,11 @@ function validateFunctions({ functions = {} }) {
         message: "Function must contain at least one property."
       };
     }
-    if (func.maxDuration !== void 0 && func.maxDuration !== "max" && (func.maxDuration < 1 || func.maxDuration > 900 || !Number.isInteger(func.maxDuration))) {
+    const maxDurationLimit = (0, import_build_utils.getMaxDurationLimit)();
+    if (func.maxDuration !== void 0 && func.maxDuration !== "max" && (func.maxDuration < 1 || maxDurationLimit !== void 0 && func.maxDuration > maxDurationLimit || !Number.isInteger(func.maxDuration))) {
       return {
         code: "invalid_function_duration",
-        message: 'Functions must have a maxDuration between 1 and 900, or "max".'
+        message: maxDurationLimit !== void 0 ? `Functions must have a maxDuration between 1 and ${maxDurationLimit}, or "max".` : 'Functions must have a positive integer maxDuration, or "max".'
       };
     }
     if (func.memory !== void 0 && (func.memory < 128 || func.memory > 10240)) {

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 export { detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExtensions, type Options as DetectBuildersOptions, } from './detect-builders';
 export { detectServices, 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 { getServicesBuilders } from './services/get-services-builders';
-export type { DetectServicesOptions, DetectServicesResult, DetectServicesSource, InferredServicesConfig, ResolvedServicesResult, InferredServicesResult, ResolvedService, Service, ServicesRoutes, ServiceDetectionError, } from './services/types';
+export type { DetectServicesOptions, DetectServicesResult, DetectServicesSource, InferredServicesConfig, ResolvedServicesResult, InferredServicesResult, ResolvedService, Service, ExperimentalService, ExperimentalServiceV2, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServicesRoutes, ServiceDetectionError, } 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

@@ -49,17 +49,24 @@ __export(src_exports, {
   getServicesBuilders: () => import_get_services_builders.getServicesBuilders,
   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,
+  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_get_services_builders = require("./services/get-services-builders");
@@ -109,12 +116,17 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   getServicesBuilders,
   getWorkspacePackagePaths,
   getWorkspaces,
+  isExperimentalService,
+  isExperimentalServiceV2,
   isOfficialRuntime,
   isRouteOwningBuilder,
   isStaticBuild,
   isStaticRuntime,
   monorepoManagers,
   packageManagers,
+  resolveAllConfiguredServicesV2,
+  resolveConfiguredServiceV2,
+  validateServiceConfigV2,
   workspaceManagers,
   ...require("./monorepos/get-monorepo-default-settings")
 });

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

@@ -33,4 +33,4 @@ export declare function detectServices(options: DetectServicesOptions): Promise<
  *   Internal cron callback routes under `/_svc/{serviceName}/crons/{entry}/{handler}`
  *   that rewrite to `/_svc/{serviceName}/index`.
  */
-export declare function generateServicesRoutes(services: Service[]): ServicesRoutes;
+export declare function generateServicesRoutes(allServices: Service[]): ServicesRoutes;

package/dist/services/detect-services.js

@@ -26,6 +26,7 @@ var import_build_utils = require("@vercel/build-utils");
 var import_routing_utils = require("@vercel/routing-utils");
 var import_utils = require("./utils");
 var import_resolve = require("./resolve");
+var import_resolve_v2 = require("./resolve-v2");
 var import_auto_detect = require("./auto-detect");
 var import_detect_railway = require("./detect-railway");
 var import_detect_render = require("./detect-render");
@@ -90,7 +91,8 @@ async function detectServices(options) {
     fs,
     workPath,
     detectEntrypoint,
-    configuredServices: providedConfiguredServices
+    configuredServices: providedConfiguredServices,
+    configuredServicesType: providedConfiguredServicesType
   } = options;
   const scopedFs = workPath ? fs.chdir(workPath) : fs;
   const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
@@ -105,9 +107,26 @@ async function detectServices(options) {
     });
   }
   const hasProvidedConfiguredServices = providedConfiguredServices && Object.keys(providedConfiguredServices).length > 0;
-  const configuredServices = hasProvidedConfiguredServices ? providedConfiguredServices : vercelConfig?.experimentalServices;
-  const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
-  if (!hasConfiguredServices) {
+  const experimentalServicesV2 = hasProvidedConfiguredServices && providedConfiguredServicesType === "experimentalServicesV2" ? providedConfiguredServices : hasProvidedConfiguredServices ? void 0 : vercelConfig?.experimentalServicesV2;
+  if (experimentalServicesV2 && Object.keys(experimentalServicesV2).length > 0) {
+    const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(
+      experimentalServicesV2,
+      scopedFs
+    );
+    return withResolvedResult({
+      services: result2.services,
+      source: "configured",
+      // V2 uses explicit `bindings`, so no implicit `{NAME}_URL` injection.
+      useImplicitEnvInjection: false,
+      // V2 routes are explicitly carried per-service to output them separately.
+      routes: emptyRoutes(),
+      errors: result2.errors,
+      warnings: []
+    });
+  }
+  const experimentalServicesV1 = hasProvidedConfiguredServices ? providedConfiguredServices : vercelConfig?.experimentalServices;
+  const hasExperimentalServicesV1 = experimentalServicesV1 && Object.keys(experimentalServicesV1).length > 0;
+  if (!hasExperimentalServicesV1) {
     const detectors = [
       { detect: import_detect_railway.detectRailwayServices, source: "railway" },
       { detect: import_detect_render.detectRenderServices, source: "render" },
@@ -135,7 +154,7 @@ async function detectServices(options) {
     });
   }
   const result = await (0, import_resolve.resolveAllConfiguredServices)(
-    configuredServices,
+    experimentalServicesV1,
     scopedFs,
     "configured"
   );
@@ -210,7 +229,8 @@ async function tryResolveInferred(detectResult, source, scopedFs) {
     inferred
   );
 }
-function generateServicesRoutes(services) {
+function generateServicesRoutes(allServices) {
+  const services = allServices.filter(import_build_utils.isExperimentalService);
   const hostRewrites = [];
   const rewrites = [];
   const defaults = [];

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

@@ -1,6 +1,6 @@
 import type { Route } from '@vercel/routing-utils';
 import type { Builder } from '@vercel/build-utils';
-import type { ConfiguredServices, ResolvedService } from './types';
+import type { ConfiguredServices, ConfiguredServicesType, Service } from './types';
 export interface ErrorResponse {
     code: string;
     message: string;
@@ -10,7 +10,7 @@ export interface ErrorResponse {
 export interface GetServicesBuildersOptions {
     workPath?: string;
     configuredServices?: ConfiguredServices;
-    configuredServicesType?: 'experimentalServices';
+    configuredServicesType?: ConfiguredServicesType;
     projectFramework?: string | null;
 }
 export interface ServicesBuildersResult {
@@ -23,7 +23,7 @@ export interface ServicesBuildersResult {
     redirectRoutes: Route[] | null;
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
-    services?: ResolvedService[];
+    services?: Service[];
     useImplicitEnvInjection?: boolean;
 }
 /**
@@ -33,3 +33,7 @@ export interface ServicesBuildersResult {
  * the shape expected by `detectBuilders` when `framework === 'services'`.
  */
 export declare function getServicesBuilders(options: GetServicesBuildersOptions): Promise<ServicesBuildersResult>;
+/**
+ * Returns warnings for ignored directories that are not covered by services
+ */
+export declare function warnIgnoredDirectories(files: string[], configuredServices: ConfiguredServices): ErrorResponse[];

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

@@ -18,7 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var get_services_builders_exports = {};
 __export(get_services_builders_exports, {
-  getServicesBuilders: () => getServicesBuilders
+  getServicesBuilders: () => getServicesBuilders,
+  warnIgnoredDirectories: () => warnIgnoredDirectories
 });
 module.exports = __toCommonJS(get_services_builders_exports);
 var import_detect_services = require("./detect-services");
@@ -134,7 +135,25 @@ async function getServicesBuilders(options) {
     useImplicitEnvInjection: result.useImplicitEnvInjection
   };
 }
+function warnIgnoredDirectories(files, configuredServices) {
+  const warnings = [];
+  if (files.some((f) => f.startsWith("api/"))) {
+    const serviceCoversApi = Object.values(configuredServices).some((service) => {
+      const root = service.root ?? ".";
+      const entrypoint = service.entrypoint ?? "";
+      return root === "api" || root.startsWith("api/") || root === "." && entrypoint.startsWith("api/");
+    });
+    if (!serviceCoversApi) {
+      warnings.push({
+        code: "api_dir_ignored",
+        message: "The `api/` directory will not be built because `experimentalServices` is configured. To serve these files, declare them as a service in your `vercel.json`."
+      });
+    }
+  }
+  return warnings;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getServicesBuilders
+  getServicesBuilders,
+  warnIgnoredDirectories
 });

package/dist/services/resolve-v2.d.ts

@@ -0,0 +1,11 @@
+import type { ExperimentalServiceV2, ExperimentalServiceV2Config, ExperimentalServicesV2, ServiceDetectionError } from './types';
+import type { DetectorFilesystem } from '../detectors/filesystem';
+export declare function validateServiceConfigV2(name: string, config: ExperimentalServiceV2Config): ServiceDetectionError | null;
+export declare function resolveConfiguredServiceV2(name: string, config: ExperimentalServiceV2Config, fs: DetectorFilesystem): Promise<{
+    service?: ExperimentalServiceV2;
+    error?: ServiceDetectionError;
+}>;
+export declare function resolveAllConfiguredServicesV2(services: ExperimentalServicesV2, fs: DetectorFilesystem): Promise<{
+    services: ExperimentalServiceV2[];
+    errors: ServiceDetectionError[];
+}>;

package/dist/services/resolve-v2.js

@@ -0,0 +1,264 @@
+"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 resolve_v2_exports = {};
+__export(resolve_v2_exports, {
+  resolveAllConfiguredServicesV2: () => resolveAllConfiguredServicesV2,
+  resolveConfiguredServiceV2: () => resolveConfiguredServiceV2,
+  validateServiceConfigV2: () => validateServiceConfigV2
+});
+module.exports = __toCommonJS(resolve_v2_exports);
+var import_path = require("path");
+var import_build_utils = require("@vercel/build-utils");
+var import_frameworks = require("@vercel/frameworks");
+var import_types = require("./types");
+var import_resolve = require("./resolve");
+var import_utils = require("./utils");
+const frameworksBySlug = new Map(import_frameworks.frameworkList.map((f) => [f.slug, f]));
+const SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+function validateServiceConfigV2(name, config) {
+  if (!SERVICE_NAME_REGEX.test(name)) {
+    return {
+      code: "INVALID_SERVICE_NAME",
+      message: `Service name "${name}" is invalid. Names must start with a letter, end with an alphanumeric character, and contain only alphanumeric characters, hyphens, and underscores.`,
+      serviceName: name
+    };
+  }
+  if (!config || typeof config !== "object") {
+    return {
+      code: "INVALID_SERVICE_CONFIG",
+      message: `Service "${name}" has an invalid configuration. Expected an object.`,
+      serviceName: name
+    };
+  }
+  if (typeof config.root !== "string" || config.root.length === 0) {
+    return {
+      code: "MISSING_ROOT",
+      message: `Service "${name}" must specify a "root".`,
+      serviceName: name
+    };
+  }
+  const normalizedRoot = import_path.posix.normalize(config.root);
+  if (normalizedRoot.startsWith("/")) {
+    return {
+      code: "INVALID_ROOT",
+      message: `Service "${name}" has invalid "root" "${config.root}". Must be a relative path.`,
+      serviceName: name
+    };
+  }
+  if (normalizedRoot === ".." || normalizedRoot.startsWith("../")) {
+    return {
+      code: "INVALID_ROOT",
+      message: `Service "${name}" has invalid "root" "${config.root}". Must not escape the project root.`,
+      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
+    };
+  }
+  if (config.runtime && config.framework) {
+    const frameworkRuntime = (0, import_utils.inferRuntimeFromFramework)(config.framework);
+    if (frameworkRuntime && frameworkRuntime !== config.runtime) {
+      return {
+        code: "RUNTIME_FRAMEWORK_MISMATCH",
+        message: `Service "${name}" has conflicting runtime/framework: runtime "${config.runtime}" is incompatible with framework "${config.framework}" (runtime "${frameworkRuntime}").`,
+        serviceName: name
+      };
+    }
+  }
+  if (!config.framework && !config.entrypoint) {
+    return {
+      code: "MISSING_SERVICE_CONFIG",
+      message: `Service "${name}" must specify "framework" or "entrypoint".`,
+      serviceName: name
+    };
+  }
+  return null;
+}
+async function resolveConfiguredServiceV2(name, config, fs) {
+  const root = config.root;
+  const normalizedRoot = import_path.posix.normalize(root);
+  const serviceFsResult = normalizedRoot === "." ? { fs } : await (0, import_resolve.getServiceFs)(fs, name, root);
+  if (serviceFsResult.error) {
+    return { error: serviceFsResult.error };
+  }
+  const serviceFs = serviceFsResult.fs;
+  const rawEntrypoint = config.entrypoint;
+  const moduleAttr = typeof rawEntrypoint === "string" ? (0, import_resolve.parsePyModuleAttrEntrypoint)(rawEntrypoint) : null;
+  let normalizedEntrypoint;
+  let entrypointIsDirectory = false;
+  if (typeof rawEntrypoint === "string") {
+    const entrypointToResolve = moduleAttr ? moduleAttr.filePath : rawEntrypoint;
+    const resolved = await (0, import_resolve.resolveEntrypointPath)({
+      fs: serviceFs,
+      serviceName: name,
+      entrypoint: entrypointToResolve
+    });
+    if (resolved.error) {
+      return { error: resolved.error };
+    }
+    normalizedEntrypoint = resolved.entrypoint?.normalized;
+    entrypointIsDirectory = Boolean(resolved.entrypoint?.isDirectory);
+  }
+  const entrypointFile = entrypointIsDirectory || !normalizedEntrypoint ? void 0 : normalizedEntrypoint;
+  const inferredRuntime = (0, import_utils.inferServiceRuntime)({
+    runtime: config.runtime,
+    framework: config.framework,
+    entrypoint: entrypointFile
+  });
+  let framework = config.framework;
+  if (!framework && normalizedEntrypoint) {
+    const workspace = entrypointIsDirectory ? normalizedEntrypoint : import_path.posix.dirname(normalizedEntrypoint) || ".";
+    const detection = await (0, import_resolve.detectFrameworkFromWorkspace)({
+      fs: serviceFs,
+      workspace,
+      serviceName: name,
+      runtime: inferredRuntime
+    });
+    if (detection.error) {
+      return { error: detection.error };
+    }
+    framework = detection.framework;
+  }
+  if (entrypointIsDirectory && !framework) {
+    return {
+      error: {
+        code: "MISSING_SERVICE_FRAMEWORK",
+        message: `Service "${name}" uses directory entrypoint "${config.entrypoint}" but no framework could be detected. Specify "framework" explicitly or use a file entrypoint.`,
+        serviceName: name
+      }
+    };
+  }
+  const frameworkDefinition = framework ? frameworksBySlug.get(framework) : void 0;
+  let builderUse;
+  let builderSrc;
+  if (framework) {
+    builderUse = (0, import_build_utils.isNodeBackendFramework)(framework) ? "@vercel/backends" : frameworkDefinition?.useRuntime?.use || "@vercel/static-build";
+    builderSrc = entrypointFile || frameworkDefinition?.useRuntime?.src || "package.json";
+  } else {
+    if (!inferredRuntime) {
+      return {
+        error: {
+          code: "MISSING_SERVICE_CONFIG",
+          message: `Service "${name}" must specify "framework" or a runtime-resolvable "entrypoint".`,
+          serviceName: name
+        }
+      };
+    }
+    builderUse = inferredRuntime === "node" ? "@vercel/backends" : (0, import_utils.getBuilderForRuntime)(inferredRuntime);
+    builderSrc = entrypointFile;
+  }
+  const isRoot = normalizedRoot === ".";
+  const projectRelativeSrc = isRoot ? builderSrc : import_path.posix.join(normalizedRoot, builderSrc);
+  const builderConfig = { zeroConfig: true };
+  if (builderUse === "@vercel/backends") {
+    builderConfig.serviceName = name;
+  }
+  if (framework) {
+    builderConfig.framework = framework;
+  }
+  if (!isRoot) {
+    builderConfig.workspace = normalizedRoot;
+  }
+  if (moduleAttr) {
+    builderConfig.handlerFunction = moduleAttr.attrName;
+  }
+  const runtime = import_types.STATIC_BUILDERS.has(builderUse) ? void 0 : inferredRuntime;
+  return {
+    service: {
+      schema: "experimentalServicesV2",
+      name,
+      root,
+      framework,
+      runtime,
+      entrypoint: entrypointFile,
+      builder: {
+        src: projectRelativeSrc,
+        use: builderUse,
+        config: builderConfig
+      },
+      installCommand: config.installCommand,
+      buildCommand: config.buildCommand,
+      devCommand: config.devCommand,
+      ignoreCommand: config.ignoreCommand,
+      outputDirectory: config.outputDirectory,
+      bindings: config.bindings,
+      functions: config.functions,
+      headers: config.headers,
+      redirects: config.redirects,
+      rewrites: config.rewrites,
+      routes: config.routes,
+      cleanUrls: config.cleanUrls,
+      trailingSlash: config.trailingSlash
+    }
+  };
+}
+async function resolveAllConfiguredServicesV2(services, fs) {
+  const resolved = [];
+  const errors = [];
+  for (const name of Object.keys(services)) {
+    const config = services[name];
+    const validationError = validateServiceConfigV2(name, config);
+    if (validationError) {
+      errors.push(validationError);
+      continue;
+    }
+    const { service, error } = await resolveConfiguredServiceV2(
+      name,
+      config,
+      fs
+    );
+    if (error) {
+      errors.push(error);
+      continue;
+    }
+    if (service) {
+      resolved.push(service);
+    }
+  }
+  const serviceNames = new Set(Object.keys(services));
+  for (const service of resolved) {
+    for (const binding of service.bindings ?? []) {
+      if (!serviceNames.has(binding.service)) {
+        errors.push({
+          code: "UNKNOWN_SERVICE_BINDING",
+          message: `Service "${service.name}" declares a binding to unknown service "${binding.service}".`,
+          serviceName: service.name
+        });
+      }
+    }
+  }
+  return { services: resolved, errors };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveAllConfiguredServicesV2,
+  resolveConfiguredServiceV2,
+  validateServiceConfigV2
+});

package/dist/services/resolve.d.ts

@@ -1,10 +1,26 @@
-import type { Service, ConfiguredServices, ExperimentalServiceConfig, ServiceDetectionError } from './types';
+import type { ExperimentalService, ConfiguredServices, ExperimentalServiceConfig, ServiceDetectionError, ServiceRuntime } from './types';
 import type { DetectorFilesystem } from '../detectors/filesystem';
+export declare function parsePyModuleAttrEntrypoint(entrypoint: string): {
+    attrName: string;
+    filePath: string;
+} | null;
 type ConfiguredServiceConfig = ExperimentalServiceConfig;
 interface ResolvedEntrypointPath {
     normalized: string;
     isDirectory: boolean;
 }
+export declare function getServiceFs(fs: DetectorFilesystem, serviceName: string, root?: string): Promise<{
+    fs: DetectorFilesystem;
+    error?: ServiceDetectionError;
+}>;
+export declare function resolveEntrypointPath({ fs, serviceName, entrypoint, }: {
+    fs: DetectorFilesystem;
+    serviceName: string;
+    entrypoint: string;
+}): Promise<{
+    entrypoint?: ResolvedEntrypointPath;
+    error?: ServiceDetectionError;
+}>;
 type RoutePrefixSource = 'configured' | 'generated';
 interface ResolveConfiguredServiceOptions {
     name: string;
@@ -19,6 +35,20 @@ interface ResolveConfiguredServiceOptions {
 interface ResolveAllConfiguredServicesOptions {
     requireFileEntrypointForBackendRuntimes?: boolean;
 }
+export declare function inferWorkspaceFromNearestManifest({ fs, entrypoint, runtime, }: {
+    fs: DetectorFilesystem;
+    entrypoint?: string;
+    runtime?: ServiceRuntime;
+}): Promise<string | undefined>;
+export declare function detectFrameworkFromWorkspace({ fs, workspace, serviceName, runtime, }: {
+    fs: DetectorFilesystem;
+    workspace: string;
+    serviceName: string;
+    runtime?: ServiceRuntime;
+}): Promise<{
+    framework?: string;
+    error?: ServiceDetectionError;
+}>;
 /**
  * Validate a service configuration from vercel.json services.
  */
@@ -27,13 +57,13 @@ export declare function validateServiceEntrypoint(name: string, config: Configur
 /**
  * Resolve a single service from user configuration.
  */
-export declare function resolveConfiguredService(options: ResolveConfiguredServiceOptions): Promise<Service>;
+export declare function resolveConfiguredService(options: ResolveConfiguredServiceOptions): Promise<ExperimentalService>;
 /**
  * Resolve all services from vercel.json services.
  * Validates each service configuration.
  */
 export declare function resolveAllConfiguredServices(services: ConfiguredServices, fs: DetectorFilesystem, routePrefixSource?: RoutePrefixSource, options?: ResolveAllConfiguredServicesOptions): Promise<{
-    services: Service[];
+    services: ExperimentalService[];
     errors: ServiceDetectionError[];
 }>;
 export {};

package/dist/services/resolve.js

@@ -18,8 +18,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var resolve_exports = {};
 __export(resolve_exports, {
+  detectFrameworkFromWorkspace: () => detectFrameworkFromWorkspace,
+  getServiceFs: () => getServiceFs,
+  inferWorkspaceFromNearestManifest: () => inferWorkspaceFromNearestManifest,
+  parsePyModuleAttrEntrypoint: () => parsePyModuleAttrEntrypoint,
   resolveAllConfiguredServices: () => resolveAllConfiguredServices,
   resolveConfiguredService: () => resolveConfiguredService,
+  resolveEntrypointPath: () => resolveEntrypointPath,
   validateServiceConfig: () => validateServiceConfig,
   validateServiceEntrypoint: () => validateServiceEntrypoint
 });
@@ -666,6 +671,7 @@ async function resolveConfiguredService(options) {
     builderConfig.handlerFunction = moduleAttrParsed.attrName;
   }
   return {
+    schema: "experimentalServices",
     name,
     type,
     trigger,
@@ -870,8 +876,13 @@ function validateEnvRefs(env, serviceName, servicesByName, errors) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  detectFrameworkFromWorkspace,
+  getServiceFs,
+  inferWorkspaceFromNearestManifest,
+  parsePyModuleAttrEntrypoint,
   resolveAllConfiguredServices,
   resolveConfiguredService,
+  resolveEntrypointPath,
   validateServiceConfig,
   validateServiceEntrypoint
 });

package/dist/services/types.d.ts

@@ -1,7 +1,7 @@
 import type { Route } from '@vercel/routing-utils';
-import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
+import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceV2Config, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServicesV2, ExperimentalServiceV2Binding, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
+export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
 /**
  * @deprecated Use `Service` instead
  */
@@ -9,7 +9,7 @@ export type ResolvedService = Service;
 export interface DetectServicesOptions {
     fs: DetectorFilesystem;
     configuredServices?: ConfiguredServices;
-    configuredServicesType?: 'experimentalServices';
+    configuredServicesType?: ConfiguredServicesType;
     /**
      * Working directory path (relative to fs root).
      * If provided, vercel.json is read from this path.
@@ -42,7 +42,8 @@ export interface ServicesRoutes {
      */
     workers: Route[];
 }
-export type ConfiguredServices = ExperimentalServices;
+export type ConfiguredServicesType = 'experimentalServices' | 'experimentalServicesV2';
+export type ConfiguredServices = ExperimentalServices | ExperimentalServicesV2;
 export type InferredServicesConfig = ExperimentalServices;
 export interface ResolvedServicesResult {
     services: Service[];
@@ -55,13 +56,13 @@ export interface ResolvedServicesResult {
 export interface InferredServicesResult {
     source: 'layout' | 'procfile' | 'railway' | 'render';
     config: InferredServicesConfig;
-    services: Service[];
+    services: ExperimentalService[];
     warnings: ServiceDetectionWarning[];
 }
 export interface DetectServicesResult extends ResolvedServicesResult {
     /**
      * Source of service definitions:
-     * - `configured`: loaded from explicit project configuration (`vercel.json#experimentalServices`)
+     * - `configured`: loaded from explicit project configuration (`vercel.json#experimentalServices` or `vercel.json#experimentalServicesV2`)
      * - `auto-detected`: inferred from project structure
      */
     resolved: ResolvedServicesResult;

package/dist/services/utils.d.ts

@@ -1,7 +1,7 @@
 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 { ServiceRuntime, ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
+import type { ServiceRuntime, ExperimentalServices, ExperimentalServicesV2, 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>;
@@ -56,6 +56,7 @@ export declare function inferServiceRuntime(config: {
 export interface ReadVercelConfigResult {
     config: {
         experimentalServices?: ExperimentalServices;
+        experimentalServicesV2?: ExperimentalServicesV2;
     } | null;
     error: ServiceDetectionError | null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "6.7.7",
+  "version": "6.8.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,10 +20,10 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "@vercel/build-utils": "13.27.0",
-    "@vercel/routing-utils": "6.2.0",
-    "@vercel/frameworks": "3.27.0",
-    "@vercel/error-utils": "2.2.0"
+    "@vercel/error-utils": "2.2.0",
+    "@vercel/build-utils": "13.27.2",
+    "@vercel/frameworks": "3.28.0",
+    "@vercel/routing-utils": "6.2.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",