@vercel/fs-detectors 6.10.3 → 6.11.1

package/dist/detect-builders.d.ts

@@ -48,5 +48,6 @@ export declare function detectBuilders(files: string[], pkg?: PackageJson | unde
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
     services?: Service[];
+    experimentalServicesV2?: Services;
     useImplicitEnvInjection?: boolean;
 }>;

package/dist/index.d.ts

@@ -6,7 +6,7 @@ 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, ExperimentalService, ExperimentalServiceV2, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ServicesRoutes, ServiceDetectionError, } from './services/types';
+export type { DetectServicesOptions, DetectServicesResult, DetectServicesSource, InferredServiceConfig, InferredServicesConfig, ResolvedServicesResult, InferredServicesResult, ResolvedService, Service, ExperimentalService, ExperimentalServiceV2, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, 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/services/auto-detect.d.ts

@@ -1,6 +1,6 @@
 import type { DetectEntrypointFn } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
+import type { InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
 export interface AutoDetectOptions {
     fs: DetectorFilesystem;
     /**
@@ -10,7 +10,7 @@ export interface AutoDetectOptions {
     detectEntrypoint?: DetectEntrypointFn;
 }
 export interface AutoDetectResult {
-    services: ExperimentalServices | null;
+    services: InferredServicesConfig | null;
     errors: ServiceDetectionError[];
     warnings: ServiceDetectionWarning[];
 }

package/dist/services/auto-detect.js

@@ -97,8 +97,9 @@ async function autoDetectServices(options) {
 async function detectServicesAtRoot(fs, rootFramework, detectEntrypoint) {
   const services = {};
   services.frontend = {
+    root: ".",
     framework: rootFramework.slug ?? void 0,
-    routePrefix: "/"
+    mountPath: "/"
   };
   const backendResult = await detectBackendServices(fs, detectEntrypoint);
   if (backendResult.error) {
@@ -116,9 +117,10 @@ async function detectServicesAtRoot(fs, rootFramework, detectEntrypoint) {
     };
   }
   Object.assign(services, backendResult.services);
+  const mountWarnings = (0, import_utils.assignMountPaths)(services);
   return {
     services,
-    warnings: [],
+    warnings: mountWarnings,
     errors: []
   };
 }
@@ -128,7 +130,7 @@ async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocat
   services[serviceName] = {
     framework: frontendFramework.slug ?? void 0,
     root: frontendLocation,
-    routePrefix: "/"
+    mountPath: "/"
   };
   const backendResult = await detectBackendServices(fs, detectEntrypoint);
   if (backendResult.error) {
@@ -151,9 +153,10 @@ async function detectServicesFrontendSubdir(fs, frontendFramework, frontendLocat
     };
   }
   Object.assign(services, backendResult.services);
+  const mountWarnings = (0, import_utils.assignMountPaths)(services);
   return {
     services,
-    warnings: [],
+    warnings: mountWarnings,
     errors: []
   };
 }
@@ -248,14 +251,14 @@ async function detectServiceInDir(fs, dirPath, serviceName, detectEntrypoint) {
   }
   const framework = frameworks[0];
   const slug = framework.slug ?? void 0;
-  const routePrefix = `/_/${serviceName}`;
+  const mountPath = `/${serviceName}`;
   const detected = detectEntrypoint && !(0, import_utils.isFrontendFramework)(slug) ? await detectEntrypoint({ workPath: dirPath, framework: slug }) : null;
   return {
     service: {
       framework: slug,
       root: dirPath,
       ...detected ? { entrypoint: detected.entrypoint } : {},
-      routePrefix
+      mountPath
     }
   };
 }

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

@@ -1,7 +1,7 @@
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
+import type { InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
 export interface ProcfileDetectResult {
-    services: ExperimentalServices | null;
+    services: InferredServicesConfig | null;
     errors: ServiceDetectionError[];
     warnings: ServiceDetectionWarning[];
 }

package/dist/services/detect-procfile.js

@@ -115,6 +115,7 @@ async function detectProcfileServices(options) {
     if (isWorkerLikeProcess) {
       if (hasSupportedWorkerCommand(tokens) && entrypoint?.endsWith(".py")) {
         services[processType] = {
+          root: ".",
           type: "worker",
           entrypoint,
           runtime: "python"
@@ -131,12 +132,12 @@ async function detectProcfileServices(options) {
       });
       continue;
     }
-    const serviceConfig = { type: "web" };
-    if (detectedFramework) {
-      serviceConfig.framework = detectedFramework.slug ?? void 0;
-    }
-    serviceConfig.entrypoint = entrypoint ?? ".";
-    services[processType] = serviceConfig;
+    services[processType] = {
+      root: ".",
+      type: "web",
+      ...detectedFramework?.slug ? { framework: detectedFramework.slug } : {},
+      entrypoint: entrypoint ?? "."
+    };
   }
   if (errors.length > 0) {
     return { services: null, errors, warnings };
@@ -152,7 +153,7 @@ async function detectProcfileServices(options) {
       firstService.buildCommand = releaseCommand;
     }
   }
-  warnings.push(...(0, import_utils.assignRoutePrefixes)(services));
+  warnings.push(...(0, import_utils.assignMountPaths)(services));
   return { services, errors: [], warnings };
 }
 function parseProcfile(content) {

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

@@ -1,8 +1,8 @@
 import type { DetectEntrypointFn } from '@vercel/build-utils';
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
+import type { InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
 export interface RailwayDetectResult {
-    services: ExperimentalServices | null;
+    services: InferredServicesConfig | null;
     errors: ServiceDetectionError[];
     warnings: ServiceDetectionWarning[];
 }

package/dist/services/detect-railway.js

@@ -120,18 +120,17 @@ async function detectRailwayServices(options) {
     }
     const framework = frameworks[0];
     const slug = framework.slug ?? void 0;
-    let serviceConfig = {};
-    serviceConfig.framework = slug;
-    if (cf.dirPath !== ".") {
-      serviceConfig.root = cf.dirPath;
-      if (detectEntrypoint && !(0, import_utils.isFrontendFramework)(slug)) {
-        const detected = await detectEntrypoint({
-          workPath: cf.dirPath,
-          framework: slug
-        });
-        if (detected) {
-          serviceConfig.entrypoint = detected.entrypoint;
-        }
+    const serviceConfig = {
+      root: cf.dirPath,
+      framework: slug
+    };
+    if (cf.dirPath !== "." && detectEntrypoint && !(0, import_utils.isFrontendFramework)(slug)) {
+      const detected = await detectEntrypoint({
+        workPath: cf.dirPath,
+        framework: slug
+      });
+      if (detected) {
+        serviceConfig.entrypoint = detected.entrypoint;
       }
     }
     if (cf.config.build?.buildCommand) {
@@ -150,7 +149,7 @@ async function detectRailwayServices(options) {
   if (serviceNames.length === 0) {
     return { services: null, errors: [], warnings };
   }
-  warnings.push(...(0, import_utils.assignRoutePrefixes)(services));
+  warnings.push(...(0, import_utils.assignMountPaths)(services));
   return { services, errors: [], warnings };
 }
 async function findRailwayConfigs(fs, dirPath = ".", depth = 0) {

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

@@ -1,7 +1,7 @@
 import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { DetectEntrypointFn, ExperimentalServices, ServiceDetectionError, ServiceDetectionWarning } from './types';
+import type { DetectEntrypointFn, InferredServicesConfig, ServiceDetectionError, ServiceDetectionWarning } from './types';
 export interface RenderDetectResult {
-    services: ExperimentalServices | null;
+    services: InferredServicesConfig | null;
     errors: ServiceDetectionError[];
     warnings: ServiceDetectionWarning[];
 }

package/dist/services/detect-render.js

@@ -107,7 +107,7 @@ async function detectRenderServices(options) {
       const name = rs.name ?? "unnamed";
       const hint = {
         entrypoint: rs.rootDir ?? "<path-to-entrypoint>",
-        routePrefix: `/_/${name}`
+        mountPath: `/api/${name}`
       };
       warnings.push({
         code: "RENDER_PSERV_HINT",
@@ -161,19 +161,18 @@ async function detectRenderServices(options) {
     }
     const framework = frameworks[0];
     const vercelType = SERVICE_TYPE_MAP[serviceType];
-    const serviceConfig = {};
-    serviceConfig.type = vercelType;
-    serviceConfig.framework = framework.slug ?? void 0;
-    if (rootDir !== ".") {
-      serviceConfig.root = rootDir;
-      if (detectEntrypoint && !(0, import_utils.isFrontendFramework)(serviceConfig.framework)) {
-        const detected = await detectEntrypoint({
-          workPath: rootDir,
-          framework: serviceConfig.framework
-        });
-        if (detected) {
-          serviceConfig.entrypoint = detected.entrypoint;
-        }
+    const serviceConfig = {
+      root: rootDir,
+      type: vercelType,
+      framework: framework.slug ?? void 0
+    };
+    if (rootDir !== "." && detectEntrypoint && !(0, import_utils.isFrontendFramework)(serviceConfig.framework)) {
+      const detected = await detectEntrypoint({
+        workPath: rootDir,
+        framework: serviceConfig.framework
+      });
+      if (detected) {
+        serviceConfig.entrypoint = detected.entrypoint;
       }
     }
     const buildCommand = (0, import_utils.combineBuildCommand)(
@@ -191,7 +190,7 @@ async function detectRenderServices(options) {
   if (Object.keys(services).length === 0) {
     return { services: null, errors: [], warnings };
   }
-  warnings.push(...(0, import_utils.assignRoutePrefixes)(services));
+  warnings.push(...(0, import_utils.assignMountPaths)(services));
   return { services, errors: [], warnings };
 }
 async function readRenderYaml(fs) {

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

@@ -1,4 +1,5 @@
-import type { DetectServicesOptions, DetectServicesResult, Service, ServicesRoutes } from './types';
+import type { Rewrite } from '@vercel/routing-utils';
+import type { DetectServicesOptions, DetectServicesResult, InferredServicesConfig, Service, ServicesRoutes } from './types';
 /**
  * Detect and resolve services within a project.
  *
@@ -6,6 +7,17 @@ import type { DetectServicesOptions, DetectServicesResult, Service, ServicesRout
  * Returns an error if no services are configured.
  */
 export declare function detectServices(options: DetectServicesOptions): Promise<DetectServicesResult>;
+/**
+ * Generate top-level service-targeted rewrites from inferred mount paths.
+ *
+ * Produces `Rewrite` objects (same format as vercel.json `rewrites`) that
+ * delegate public traffic into services based on their `mountPath`.
+ *
+ * Rewrites are ordered by mount path length (longest first) so more
+ * specific paths match before broader ones. The root service (`/`) is
+ * always last as a catch-all.
+ */
+export declare function generateServiceRewrites(services: InferredServicesConfig): Rewrite[];
 /**
  * Generate routing rules for services.
  *

package/dist/services/detect-services.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var detect_services_exports = {};
 __export(detect_services_exports, {
   detectServices: () => detectServices,
+  generateServiceRewrites: () => generateServiceRewrites,
   generateServicesRoutes: () => generateServicesRoutes
 });
 module.exports = __toCommonJS(detect_services_exports);
@@ -51,6 +52,7 @@ function withResolvedResult(resolved, inferred = null) {
     source: resolved.source,
     useImplicitEnvInjection: resolved.useImplicitEnvInjection,
     routes: resolved.routes,
+    rewrites: resolved.rewrites,
     errors: resolved.errors,
     warnings: resolved.warnings,
     resolved,
@@ -60,18 +62,17 @@ function withResolvedResult(resolved, inferred = null) {
 function toInferredLayoutConfig(services) {
   const inferredConfig = {};
   for (const [name, service] of Object.entries(services)) {
-    const serviceConfig = {};
+    const serviceConfig = {
+      root: service.root
+    };
     if (service.type) {
       serviceConfig.type = service.type;
     }
-    if (typeof service.root === "string") {
-      serviceConfig.root = service.root;
-    }
     if (typeof service.entrypoint === "string") {
       serviceConfig.entrypoint = service.entrypoint;
     }
-    if (typeof service.routePrefix === "string") {
-      serviceConfig.routePrefix = service.routePrefix;
+    if (typeof service.mountPath === "string") {
+      serviceConfig.mountPath = service.mountPath;
     }
     if ((0, import_utils.isFrontendFramework)(service.framework)) {
       serviceConfig.framework = service.framework;
@@ -102,6 +103,7 @@ async function detectServices(options) {
       source: "configured",
       useImplicitEnvInjection: true,
       routes: emptyRoutes(),
+      rewrites: [],
       errors: [configError],
       warnings: []
     });
@@ -112,6 +114,7 @@ async function detectServices(options) {
       source: "configured",
       useImplicitEnvInjection: false,
       routes: emptyRoutes(),
+      rewrites: [],
       errors: [
         {
           code: "SERVICES_AND_EXPERIMENTAL_SERVICES_V2",
@@ -124,63 +127,66 @@ async function detectServices(options) {
   const hasProvidedConfiguredServices = providedConfiguredServices && Object.keys(providedConfiguredServices).length > 0;
   const experimentalServicesV2 = hasProvidedConfiguredServices && (providedConfiguredServicesType === "services" || providedConfiguredServicesType === "experimentalServicesV2") ? providedConfiguredServices : hasProvidedConfiguredServices ? void 0 : vercelConfig?.services ?? vercelConfig?.experimentalServicesV2;
   if (experimentalServicesV2 && Object.keys(experimentalServicesV2).length > 0) {
-    const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(
+    const result = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(
       experimentalServicesV2,
       scopedFs
     );
     return withResolvedResult({
-      services: result2.services,
+      services: result.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,
+      rewrites: [],
+      errors: result.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" },
-      { detect: import_detect_procfile.detectProcfileServices, source: "procfile" },
-      { detect: import_auto_detect.autoDetectServices, source: "layout" }
-    ];
-    for (const { detect, source } of detectors) {
-      const detectResult = await detect({ fs: scopedFs, detectEntrypoint });
-      const match = await tryResolveInferred(detectResult, source, scopedFs);
-      if (match)
-        return match;
-    }
+  if (hasExperimentalServicesV1) {
+    const result = await (0, import_resolve.resolveAllConfiguredServices)(
+      experimentalServicesV1,
+      scopedFs,
+      "configured"
+    );
+    const routes = generateServicesRoutes(result.services);
     return withResolvedResult({
-      services: [],
-      source: "auto-detected",
+      services: result.services,
+      source: "configured",
+      // experimentalServices uses the legacy `{NAME}_URL` injection.
       useImplicitEnvInjection: true,
-      routes: emptyRoutes(),
-      errors: [
-        {
-          code: "NO_EXPERIMENTAL_SERVICES_CONFIGURED",
-          message: "No services configured. Add `experimentalServices` to vercel.json."
-        }
-      ],
+      routes,
+      rewrites: [],
+      errors: result.errors,
       warnings: []
     });
   }
-  const result = await (0, import_resolve.resolveAllConfiguredServices)(
-    experimentalServicesV1,
-    scopedFs,
-    "configured"
-  );
-  const routes = generateServicesRoutes(result.services);
+  const detectors = [
+    { detect: import_detect_railway.detectRailwayServices, source: "railway" },
+    { detect: import_detect_render.detectRenderServices, source: "render" },
+    { detect: import_detect_procfile.detectProcfileServices, source: "procfile" },
+    { detect: import_auto_detect.autoDetectServices, source: "layout" }
+  ];
+  for (const { detect, source } of detectors) {
+    const detectResult = await detect({ fs: scopedFs, detectEntrypoint });
+    const match = await tryResolveInferred(detectResult, source, scopedFs);
+    if (match)
+      return match;
+  }
   return withResolvedResult({
-    services: result.services,
-    source: "configured",
-    // experimentalServices uses the legacy `{NAME}_URL` injection.
+    services: [],
+    source: "auto-detected",
     useImplicitEnvInjection: true,
-    routes,
-    errors: result.errors,
+    routes: emptyRoutes(),
+    rewrites: [],
+    errors: [
+      {
+        code: "NO_EXPERIMENTAL_SERVICES_CONFIGURED",
+        message: "No services configured. Add `experimentalServices` to vercel.json."
+      }
+    ],
     warnings: []
   });
 }
@@ -189,8 +195,9 @@ async function tryResolveInferred(detectResult, source, scopedFs) {
     return withResolvedResult({
       services: [],
       source: "auto-detected",
-      useImplicitEnvInjection: true,
+      useImplicitEnvInjection: source !== "layout",
       routes: emptyRoutes(),
+      rewrites: [],
       errors: detectResult.errors,
       warnings: detectResult.warnings
     });
@@ -198,52 +205,96 @@ async function tryResolveInferred(detectResult, source, scopedFs) {
   if (!detectResult.services) {
     return null;
   }
+  if (source === "layout") {
+    const v2Services = {};
+    for (const [name, svc] of Object.entries(detectResult.services)) {
+      v2Services[name] = {
+        root: svc.root,
+        ...svc.framework ? { framework: svc.framework } : {},
+        ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {}
+      };
+    }
+    const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(v2Services, scopedFs);
+    const rootServices = Object.values(detectResult.services).filter(
+      (svc) => svc.mountPath === "/" && typeof svc.framework === "string"
+    );
+    const shouldInfer2 = result2.errors.length === 0 && rootServices.length === 1 && result2.services.length > 1;
+    const inferred2 = shouldInfer2 ? {
+      source,
+      config: toInferredLayoutConfig(detectResult.services),
+      services: result2.services,
+      warnings: detectResult.warnings
+    } : null;
+    return withResolvedResult(
+      {
+        services: shouldInfer2 ? result2.services : [],
+        source: "auto-detected",
+        useImplicitEnvInjection: false,
+        routes: emptyRoutes(),
+        rewrites: shouldInfer2 ? generateServiceRewrites(detectResult.services) : [],
+        experimentalServicesV2: shouldInfer2 ? v2Services : void 0,
+        errors: result2.errors,
+        warnings: detectResult.warnings
+      },
+      inferred2
+    );
+  }
+  const v1Services = {};
+  for (const [name, svc] of Object.entries(detectResult.services)) {
+    v1Services[name] = {
+      root: svc.root === "." ? void 0 : svc.root,
+      ...svc.framework ? { framework: svc.framework } : {},
+      ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {},
+      ...svc.type ? { type: svc.type } : {},
+      ...svc.buildCommand ? { buildCommand: svc.buildCommand } : {},
+      ...svc.preDeployCommand ? { preDeployCommand: svc.preDeployCommand } : {},
+      ...svc.mountPath ? { routePrefix: svc.mountPath } : {}
+    };
+  }
   const result = await (0, import_resolve.resolveAllConfiguredServices)(
-    detectResult.services,
+    v1Services,
     scopedFs,
     "generated"
   );
-  let shouldInfer;
-  if (source === "layout") {
-    const rootWebFrameworkServices = result.services.filter(
-      (service) => service.type === "web" && service.routePrefix === "/" && typeof service.framework === "string"
-    );
-    shouldInfer = result.errors.length === 0 && rootWebFrameworkServices.length === 1 && result.services.length > 1;
-  } else {
-    shouldInfer = result.errors.length === 0 && result.services.length > 0;
-  }
+  const shouldInfer = result.errors.length === 0 && result.services.length > 0;
   const inferred = shouldInfer ? {
     source,
     config: toInferredLayoutConfig(detectResult.services),
     services: result.services,
     warnings: detectResult.warnings
   } : null;
-  if (source === "layout" && shouldInfer) {
-    const routes = generateServicesRoutes(result.services);
-    return withResolvedResult(
-      {
-        services: result.services,
-        source: "auto-detected",
-        useImplicitEnvInjection: true,
-        routes,
-        errors: result.errors,
-        warnings: detectResult.warnings
-      },
-      inferred
-    );
-  }
   return withResolvedResult(
     {
       services: [],
       source: "auto-detected",
       useImplicitEnvInjection: true,
       routes: emptyRoutes(),
+      rewrites: [],
       errors: result.errors,
       warnings: detectResult.warnings
     },
     inferred
   );
 }
+function generateServiceRewrites(services) {
+  const entries = Object.entries(services).filter(
+    ([, svc]) => typeof svc.mountPath === "string" && (!svc.type || svc.type === "web")
+  ).sort(([, a], [, b]) => b.mountPath.length - a.mountPath.length);
+  return entries.map(([name, svc]) => {
+    const mountPath = svc.mountPath;
+    if (mountPath === "/") {
+      return {
+        source: "/(.*)",
+        destination: { type: "service", service: name }
+      };
+    }
+    const prefix = mountPath.startsWith("/") ? mountPath.slice(1) : mountPath;
+    return {
+      source: `/${prefix}(/.*)?`,
+      destination: { type: "service", service: name }
+    };
+  });
+}
 function generateServicesRoutes(allServices) {
   const services = allServices.filter(import_build_utils.isExperimentalService);
   const hostRewrites = [];
@@ -367,5 +418,6 @@ function getHostCondition(service) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   detectServices,
+  generateServiceRewrites,
   generateServicesRoutes
 });

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

@@ -1,5 +1,5 @@
-import type { Route } from '@vercel/routing-utils';
-import type { Builder } from '@vercel/build-utils';
+import type { Rewrite, Route } from '@vercel/routing-utils';
+import type { Builder, Services } from '@vercel/build-utils';
 import type { ConfiguredServices, ConfiguredServicesType, Service } from './types';
 export interface ErrorResponse {
     code: string;
@@ -23,6 +23,10 @@ export interface ServicesBuildersResult {
     redirectRoutes: Route[] | null;
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
+    /** Top-level service-targeted rewrites generated by auto-detection. */
+    serviceRewrites?: Rewrite[];
+    /** V2 services config so the platform activates V2 routing. */
+    experimentalServicesV2?: Services;
     services?: Service[];
     useImplicitEnvInjection?: boolean;
 }

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

@@ -131,6 +131,8 @@ async function getServicesBuilders(options) {
       ...result.routes.crons
     ] : null,
     errorRoutes: [],
+    serviceRewrites: result.rewrites.length > 0 ? result.rewrites : void 0,
+    experimentalServicesV2: result.experimentalServicesV2,
     services: result.services,
     useImplicitEnvInjection: result.useImplicitEnvInjection
   };

package/dist/services/resolve-v2.js

@@ -31,9 +31,27 @@ 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])?$/;
+const CONTAINER_ENTRYPOINT_CANDIDATES = [
+  "Dockerfile.vercel",
+  "Containerfile.vercel",
+  "Dockerfile",
+  "Containerfile"
+];
+const CONTAINER_ENTRYPOINT_BASENAMES = new Set(
+  CONTAINER_ENTRYPOINT_CANDIDATES.map((name) => name.toLowerCase())
+);
 function isDockerfileEntrypoint(entrypoint) {
-  const base = import_path.posix.basename(entrypoint).toLowerCase();
-  return base === "dockerfile" || base === "containerfile" || base.endsWith(".dockerfile");
+  return CONTAINER_ENTRYPOINT_BASENAMES.has(
+    import_path.posix.basename(entrypoint).toLowerCase()
+  );
+}
+async function detectContainerEntrypoint(serviceFs) {
+  for (const candidate of CONTAINER_ENTRYPOINT_CANDIDATES) {
+    if (await serviceFs.hasPath(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
 }
 function normalizeContainerCommand(command) {
   if (command === void 0) {
@@ -41,29 +59,40 @@ function normalizeContainerCommand(command) {
   }
   return Array.isArray(command) ? command : [command];
 }
-function resolveContainerServiceV2(name, config, normalizedRoot) {
+async function resolveContainerServiceV2(name, config, normalizedRoot, serviceFs) {
   const isRoot = normalizedRoot === ".";
   const entrypoint = config.entrypoint;
-  const dockerfile = typeof entrypoint === "string" && isDockerfileEntrypoint(entrypoint) ? import_path.posix.normalize(entrypoint) : void 0;
-  const image = typeof entrypoint === "string" && !dockerfile ? entrypoint : void 0;
-  if (!dockerfile && !image) {
-    return {
-      error: {
-        code: "MISSING_SERVICE_CONFIG",
-        message: `Container service "${name}" must specify an "entrypoint": a Dockerfile path to build, or a prebuilt OCI image reference.`,
-        serviceName: name
-      }
-    };
+  let dockerfile;
+  if (typeof entrypoint === "string") {
+    if (!isDockerfileEntrypoint(entrypoint)) {
+      return {
+        error: {
+          code: "INVALID_SERVICE_CONFIG",
+          message: `Container service "${name}" has invalid "entrypoint" "${entrypoint}". It must name a Dockerfile or Containerfile.`,
+          serviceName: name
+        }
+      };
+    }
+    dockerfile = import_path.posix.normalize(entrypoint);
+  } else {
+    dockerfile = await detectContainerEntrypoint(serviceFs);
+    if (!dockerfile) {
+      return {
+        error: {
+          code: "MISSING_SERVICE_CONFIG",
+          message: `Container service "${name}" has no "entrypoint" and no ${CONTAINER_ENTRYPOINT_CANDIDATES.join(
+            ", "
+          )} was found in "${normalizedRoot}".`,
+          serviceName: name
+        }
+      };
+    }
   }
-  const localSrc = dockerfile ?? image ?? "Dockerfile";
-  const builderSrc = isRoot ? localSrc : import_path.posix.join(normalizedRoot, localSrc);
+  const builderSrc = isRoot ? dockerfile : import_path.posix.join(normalizedRoot, dockerfile);
   const builderConfig = { zeroConfig: true };
   if (!isRoot) {
     builderConfig.workspace = normalizedRoot;
   }
-  if (image) {
-    builderConfig.handler = image;
-  }
   const command = normalizeContainerCommand(config.command);
   if (command) {
     builderConfig.command = command;
@@ -74,7 +103,7 @@ function resolveContainerServiceV2(name, config, normalizedRoot) {
       name,
       root: normalizedRoot,
       runtime: "container",
-      entrypoint: image ?? dockerfile,
+      entrypoint: dockerfile,
       command,
       builder: {
         src: builderSrc,
@@ -165,15 +194,15 @@ function validateServiceConfigV2(name, config) {
 }
 async function resolveConfiguredServiceV2(name, config, fs) {
   const normalizedRoot = (0, import_utils.stripTrailingSlash)(import_path.posix.normalize(config.root));
-  const isContainer = config.runtime === "container" || typeof config.entrypoint === "string" && isDockerfileEntrypoint(config.entrypoint);
-  if (isContainer) {
-    return resolveContainerServiceV2(name, config, normalizedRoot);
-  }
   const serviceFsResult = normalizedRoot === "." ? { fs } : await (0, import_resolve.getServiceFs)(fs, name, normalizedRoot);
   if (serviceFsResult.error) {
     return { error: serviceFsResult.error };
   }
   const serviceFs = serviceFsResult.fs;
+  const isContainer = config.runtime === "container" || typeof config.entrypoint === "string" && isDockerfileEntrypoint(config.entrypoint);
+  if (isContainer) {
+    return resolveContainerServiceV2(name, config, normalizedRoot, serviceFs);
+  }
   const rawEntrypoint = config.entrypoint;
   const moduleAttr = typeof rawEntrypoint === "string" ? (0, import_resolve.parsePyModuleAttrEntrypoint)(rawEntrypoint) : null;
   let normalizedEntrypoint;

package/dist/services/types.d.ts

@@ -1,4 +1,4 @@
-import type { Route } from '@vercel/routing-utils';
+import type { Rewrite, Route } from '@vercel/routing-utils';
 import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceV2Config, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, 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, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
@@ -44,19 +44,51 @@ export interface ServicesRoutes {
 }
 export type ConfiguredServicesType = 'experimentalServices' | 'services' | 'experimentalServicesV2';
 export type ConfiguredServices = ExperimentalServices | Services;
-export type InferredServicesConfig = ExperimentalServices;
+/**
+ * A single service entry inferred from project structure.
+ *
+ * This is an intermediate format produced by auto-detection — it carries
+ * the detection results (including `mountPath`, the inferred route mount
+ * point) before they are converted into a concrete config format (V1 or V2).
+ */
+export interface InferredServiceConfig {
+    /** Service root directory relative to the project root. */
+    root: string;
+    /** Framework slug, if detected. */
+    framework?: string;
+    /** Service entrypoint (file path or `module:attr` reference). */
+    entrypoint?: string;
+    /** Runtime identifier (e.g. "python", "node"). */
+    runtime?: string;
+    /** Service type (e.g. "web", "cron", "worker"). */
+    type?: ServiceType;
+    /** Build command override. */
+    buildCommand?: string;
+    /** Pre-deploy command override. */
+    preDeployCommand?: string;
+    /**
+     * Inferred route mount path for this service.
+     * For example, `"/"` for the root frontend, `"/_/backend"` for a backend.
+     */
+    mountPath?: string;
+}
+export type InferredServicesConfig = Record<string, InferredServiceConfig>;
 export interface ResolvedServicesResult {
     services: Service[];
     source: DetectServicesSource;
     useImplicitEnvInjection: boolean;
     routes: ServicesRoutes;
+    /** Top-level service-targeted rewrites (V2). */
+    rewrites: Rewrite[];
+    /** V2 services config for the build output, so the platform activates V2 routing. */
+    experimentalServicesV2?: Services;
     errors: ServiceDetectionError[];
     warnings: ServiceDetectionWarning[];
 }
 export interface InferredServicesResult {
     source: 'layout' | 'procfile' | 'railway' | 'render';
     config: InferredServicesConfig;
-    services: ExperimentalService[];
+    services: Service[];
     warnings: ServiceDetectionWarning[];
 }
 export interface DetectServicesResult extends 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, ExperimentalServicesV2, Services, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
+import type { ServiceRuntime, ExperimentalServices, ExperimentalServicesV2, InferredServicesConfig, Services, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
 export declare const DETECTION_FRAMEWORKS: Framework[];
 export { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, };
 /**
@@ -42,6 +42,7 @@ export declare function isRouteOwningBuilder(service: ResolvedService): boolean;
  */
 export declare function inferRuntimeFromFramework(framework: string | null | undefined): ServiceRuntime | undefined;
 export declare function isFrontendFramework(framework: string | null | undefined): boolean;
+export declare function isBFFFramework(framework: string | null | undefined): boolean;
 export declare function filterFrameworksByRuntime<T extends {
     slug?: string | null;
 }>(frameworks: readonly T[], runtime?: ServiceRuntime): T[];
@@ -77,13 +78,18 @@ export interface ReadVercelConfigResult {
  */
 export declare function readVercelConfig(fs: DetectorFilesystem): Promise<ReadVercelConfigResult>;
 /**
- * Assign route prefixes to inferred services.
+ * Assign mount paths to inferred services.
  *
- * A frontend service gets `/`, the rest get `/_/{name}`.
- * A single non-frontend service would also get `/`.
- * If no frontend service found, then multiple services get `/_/{name}`.
+ * A frontend service gets `/`, backend services get `/api/...`:
+ * - If the frontend is a BFF (e.g. Next.js, has its own API routes):
+ *   backends get `/api/{name}/(.*)` to avoid shadowing the frontend's API routes.
+ * - If the frontend is client-only (e.g. Vite):
+ *   backends get `/api/(.*)`.
+ *
+ * A single non-frontend service gets `/`.
+ * If no frontend service found, multiple services get `/api/{name}`.
  *
  * Priority for `/`: single service or frontend > name "frontend" or "web" > alphabetical.
  */
-export declare function assignRoutePrefixes(services: ExperimentalServices): ServiceDetectionWarning[];
+export declare function assignMountPaths(services: InferredServicesConfig): ServiceDetectionWarning[];
 export declare function combineBuildCommand(buildCommand: string | undefined, preDeployCommand: string | string[] | undefined): string | undefined;

package/dist/services/utils.js

@@ -31,7 +31,7 @@ __export(utils_exports, {
   DETECTION_FRAMEWORKS: () => DETECTION_FRAMEWORKS,
   INTERNAL_QUEUES_PREFIX: () => INTERNAL_QUEUES_PREFIX,
   INTERNAL_SERVICE_PREFIX: () => import_build_utils.INTERNAL_SERVICE_PREFIX,
-  assignRoutePrefixes: () => assignRoutePrefixes,
+  assignMountPaths: () => assignMountPaths,
   combineBuildCommand: () => combineBuildCommand,
   filterFrameworksByRuntime: () => filterFrameworksByRuntime,
   getBuilderForRuntime: () => getBuilderForRuntime,
@@ -43,6 +43,7 @@ __export(utils_exports, {
   hasFile: () => hasFile,
   inferRuntimeFromFramework: () => inferRuntimeFromFramework,
   inferServiceRuntime: () => inferServiceRuntime,
+  isBFFFramework: () => isBFFFramework,
   isFrontendFramework: () => isFrontendFramework,
   isRouteOwningBuilder: () => isRouteOwningBuilder,
   isStaticBuild: () => isStaticBuild,
@@ -114,6 +115,16 @@ function isFrontendFramework(framework) {
   }
   return !inferRuntimeFromFramework(framework);
 }
+const BFF_FRAMEWORKS = /* @__PURE__ */ new Set([
+  "nextjs",
+  "nuxtjs",
+  "sveltekit",
+  "remix",
+  "solidstart"
+]);
+function isBFFFramework(framework) {
+  return !!framework && BFF_FRAMEWORKS.has(framework);
+}
 function filterFrameworksByRuntime(frameworks, runtime) {
   if (!runtime) {
     return [...frameworks];
@@ -182,11 +193,11 @@ async function readVercelConfig(fs) {
   }
   return { config: null, error: null };
 }
-function assignRoutePrefixes(services) {
+function assignMountPaths(services) {
   const warnings = [];
   const names = Object.keys(services);
   if (names.length === 1) {
-    services[names[0]].routePrefix = "/";
+    services[names[0]].mountPath = "/";
     return warnings;
   }
   const frontendNames = names.filter(
@@ -199,11 +210,19 @@ function assignRoutePrefixes(services) {
     rootName = frontendNames.find((n) => n === "frontend" || n === "web") ?? frontendNames.sort()[0];
     warnings.push({
       code: "MULTIPLE_FRONTENDS",
-      message: `Multiple frontend services detected (${frontendNames.join(", ")}). "${rootName}" was assigned routePrefix "/". Adjust manually if a different service should be the root.`
+      message: `Multiple frontend services detected (${frontendNames.join(", ")}). "${rootName}" was assigned mount path "/". Adjust manually if a different service should be the root.`
     });
   }
+  const rootFramework = rootName ? services[rootName].framework : void 0;
+  const isBFF = rootFramework ? isBFFFramework(rootFramework) : false;
+  const nonRootNames = names.filter((n) => n !== rootName);
+  const needsNamespace = isBFF || nonRootNames.length > 1;
   for (const name of names) {
-    services[name].routePrefix = name === rootName ? "/" : `/_/${name}`;
+    if (name === rootName) {
+      services[name].mountPath = "/";
+    } else {
+      services[name].mountPath = needsNamespace ? `/api/${name}` : "/api";
+    }
   }
   return warnings;
 }
@@ -222,7 +241,7 @@ function combineBuildCommand(buildCommand, preDeployCommand) {
   DETECTION_FRAMEWORKS,
   INTERNAL_QUEUES_PREFIX,
   INTERNAL_SERVICE_PREFIX,
-  assignRoutePrefixes,
+  assignMountPaths,
   combineBuildCommand,
   filterFrameworksByRuntime,
   getBuilderForRuntime,
@@ -234,6 +253,7 @@ function combineBuildCommand(buildCommand, preDeployCommand) {
   hasFile,
   inferRuntimeFromFramework,
   inferServiceRuntime,
+  isBFFFramework,
   isFrontendFramework,
   isRouteOwningBuilder,
   isStaticBuild,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "6.10.3",
+  "version": "6.11.1",
   "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.32.1",
     "@vercel/error-utils": "2.2.0",
-    "@vercel/routing-utils": "6.4.0",
-    "@vercel/frameworks": "3.30.0"
+    "@vercel/build-utils": "13.32.2",
+    "@vercel/frameworks": "3.30.1",
+    "@vercel/routing-utils": "6.4.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",