@vercel/fs-detectors 5.8.4 → 5.8.6

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExt
 export { detectServices, generateServicesRoutes, } from './services/detect-services';
 export { autoDetectServices } from './services/auto-detect';
 export type { AutoDetectOptions, AutoDetectResult, } from './services/auto-detect';
-export { isStaticBuild } from './services/utils';
+export { isStaticBuild, isRouteOwningBuilder, INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, } from './services/utils';
 export { getServicesBuilders } from './services/get-services-builders';
 export type { DetectServicesOptions, DetectServicesResult, ResolvedService, Service, ServicesRoutes, ServiceDetectionError, } from './services/types';
 export { detectFileSystemAPI } from './detect-file-system-api';

package/dist/index.js

@@ -22,6 +22,7 @@ __export(src_exports, {
   DetectorFilesystem: () => import_filesystem.DetectorFilesystem,
   GetWorkspaceOptions: () => import_get_workspaces.GetWorkspaceOptions,
   GetWorkspacePackagePathsOptions: () => import_get_workspace_package_paths.GetWorkspacePackagePathsOptions,
+  INTERNAL_SERVICE_PREFIX: () => import_utils.INTERNAL_SERVICE_PREFIX,
   LocalFileSystemDetector: () => import_local_file_system_detector.LocalFileSystemDetector,
   REGEX_NON_VERCEL_PLATFORM_FILES: () => import_detect_builders2.REGEX_NON_VERCEL_PLATFORM_FILES,
   Workspace: () => import_get_workspaces.Workspace,
@@ -39,11 +40,13 @@ __export(src_exports, {
   detectOutputDirectory: () => import_detect_builders.detectOutputDirectory,
   detectServices: () => import_detect_services.detectServices,
   generateServicesRoutes: () => import_detect_services.generateServicesRoutes,
+  getInternalServiceFunctionPath: () => import_utils.getInternalServiceFunctionPath,
   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,
+  isRouteOwningBuilder: () => import_utils.isRouteOwningBuilder,
   isStaticBuild: () => import_utils.isStaticBuild,
   isStaticRuntime: () => import_is_official_runtime.isStaticRuntime,
   monorepoManagers: () => import_monorepo_managers.monorepoManagers,
@@ -75,6 +78,7 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   DetectorFilesystem,
   GetWorkspaceOptions,
   GetWorkspacePackagePathsOptions,
+  INTERNAL_SERVICE_PREFIX,
   LocalFileSystemDetector,
   REGEX_NON_VERCEL_PLATFORM_FILES,
   Workspace,
@@ -92,11 +96,13 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   detectOutputDirectory,
   detectServices,
   generateServicesRoutes,
+  getInternalServiceFunctionPath,
   getProjectPaths,
   getServicesBuilders,
   getWorkspacePackagePaths,
   getWorkspaces,
   isOfficialRuntime,
+  isRouteOwningBuilder,
   isStaticBuild,
   isStaticRuntime,
   monorepoManagers,

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

@@ -1,4 +1,4 @@
-import type { DetectServicesOptions, DetectServicesResult, ResolvedService, ServicesRoutes } from './types';
+import { type DetectServicesOptions, type DetectServicesResult, type ResolvedService, type ServicesRoutes } from './types';
 /**
  * Detect and resolve services within a project.
  *
@@ -13,8 +13,19 @@ export declare function detectServices(options: DetectServicesOptions): Promise<
  * routes match before broader ones. For example, `/api/users` must be checked
  * before `/api`, which must be checked before the catch-all `/`.
  *
- * - Static/SPA services: SPA fallback routes to index.html
- * - Serverless services: Rewrite to the function entrypoint
+ * Services routing only generates *synthetic* routes for builders that do not
+ * provide their own route tables:
+ *
+ * - **Static/SPA services** (`@vercel/static-build`, `@vercel/static`):
+ *   SPA fallback routes to index.html under the service prefix.
+ *
+ * - **Runtime services** (`@vercel/python`, `@vercel/go`, `@vercel/ruby`, etc.):
+ *   Prefix rewrites to an internal runtime destination (`/_svc/{name}/index`)
+ *   with `check: true`.
+ *
+ * Builders that provide their own routing (`@vercel/next`, `@vercel/backends`,
+ * Build Output API builders, etc.) are not given synthetic routes here.
+ *
  * - Cron/Worker services: TODO - internal routes under `/_svc/`
  */
 export declare function generateServicesRoutes(services: ResolvedService[]): ServicesRoutes;

package/dist/services/detect-services.js

@@ -22,6 +22,7 @@ __export(detect_services_exports, {
   generateServicesRoutes: () => generateServicesRoutes
 });
 module.exports = __toCommonJS(detect_services_exports);
+var import_routing_utils = require("@vercel/routing-utils");
 var import_utils = require("./utils");
 var import_resolve = require("./resolve");
 var import_auto_detect = require("./auto-detect");
@@ -88,35 +89,64 @@ function generateServicesRoutes(services) {
   const sortedWebServices = services.filter(
     (s) => s.type === "web" && typeof s.routePrefix === "string"
   ).sort((a, b) => b.routePrefix.length - a.routePrefix.length);
+  const allWebPrefixes = getWebRoutePrefixes(sortedWebServices);
   for (const service of sortedWebServices) {
     const { routePrefix } = service;
     const normalizedPrefix = routePrefix.slice(1);
+    const ownershipGuard = (0, import_routing_utils.getOwnershipGuard)(routePrefix, allWebPrefixes);
+    if ((0, import_utils.isRouteOwningBuilder)(service)) {
+      continue;
+    }
     if ((0, import_utils.isStaticBuild)(service)) {
       if (routePrefix === "/") {
         defaults.push({ handle: "filesystem" });
-        defaults.push({ src: "/(.*)", dest: "/index.html" });
+        defaults.push({
+          src: (0, import_routing_utils.scopeRouteSourceToOwnership)("/(.*)", ownershipGuard),
+          dest: "/index.html"
+        });
       } else {
         rewrites.push({
-          src: `^/${normalizedPrefix}(?:/.*)?$`,
+          src: (0, import_routing_utils.scopeRouteSourceToOwnership)(
+            `^/${normalizedPrefix}(?:/.*)?$`,
+            ownershipGuard
+          ),
           dest: `/${normalizedPrefix}/index.html`
         });
       }
-    } else {
-      const builderSrc = service.builder.src || routePrefix;
-      const functionPath = builderSrc.startsWith("/") ? builderSrc : `/${builderSrc}`;
+    } else if (service.runtime) {
+      const functionPath = (0, import_utils.getInternalServiceFunctionPath)(service.name);
       if (routePrefix === "/") {
-        defaults.push({ src: "^/(.*)$", dest: functionPath, check: true });
+        defaults.push({
+          src: (0, import_routing_utils.scopeRouteSourceToOwnership)("^/(.*)$", ownershipGuard),
+          dest: functionPath,
+          check: true
+        });
       } else {
         rewrites.push({
-          src: `^/${normalizedPrefix}(?:/.*)?$`,
+          src: (0, import_routing_utils.scopeRouteSourceToOwnership)(
+            `^/${normalizedPrefix}(?:/.*)?$`,
+            ownershipGuard
+          ),
           dest: functionPath,
           check: true
         });
       }
+    } else {
+      continue;
     }
   }
   return { rewrites, defaults, crons, workers };
 }
+function getWebRoutePrefixes(services) {
+  const unique = /* @__PURE__ */ new Set();
+  for (const service of services) {
+    if (service.type !== "web" || typeof service.routePrefix !== "string") {
+      continue;
+    }
+    unique.add((0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix));
+  }
+  return Array.from(unique);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   detectServices,

package/dist/services/resolve.js

@@ -37,8 +37,13 @@ var import_path = require("path");
 var import_types = require("./types");
 var import_utils = require("./utils");
 var import_frameworks = __toESM(require("@vercel/frameworks"));
+var import_routing_utils = require("@vercel/routing-utils");
 const frameworksBySlug = new Map(import_frameworks.default.map((f) => [f.slug, f]));
 const SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
+function isReservedServiceRoutePrefix(routePrefix) {
+  const normalized = (0, import_routing_utils.normalizeRoutePrefix)(routePrefix);
+  return normalized === import_utils.INTERNAL_SERVICE_PREFIX || normalized.startsWith(`${import_utils.INTERNAL_SERVICE_PREFIX}/`);
+}
 function validateServiceConfig(name, config) {
   if (!SERVICE_NAME_REGEX.test(name)) {
     return {
@@ -62,6 +67,13 @@ function validateServiceConfig(name, config) {
       serviceName: name
     };
   }
+  if (serviceType === "web" && config.routePrefix && isReservedServiceRoutePrefix(config.routePrefix)) {
+    return {
+      code: "RESERVED_ROUTE_PREFIX",
+      message: `Web service "${name}" cannot use routePrefix "${config.routePrefix}". The "${import_utils.INTERNAL_SERVICE_PREFIX}" prefix is reserved for internal services routing.`,
+      serviceName: name
+    };
+  }
   if ((serviceType === "worker" || serviceType === "cron") && config.routePrefix) {
     return {
       code: "INVALID_ROUTE_PREFIX",
@@ -141,10 +153,10 @@ function resolveConfiguredService(name, config, group) {
   }
   const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
   const isRoot = workspace === ".";
-  if (!isRoot && !builderSrc.startsWith(workspace + "/")) {
+  if (!isRoot) {
     builderSrc = import_path.posix.join(workspace, builderSrc);
   }
-  const builderConfig = {};
+  const builderConfig = { zeroConfig: true };
   if (config.memory)
     builderConfig.memory = config.memory;
   if (config.maxDuration)
@@ -159,6 +171,9 @@ function resolveConfiguredService(name, config, group) {
     const stripped = routePrefix.startsWith("/") ? routePrefix.slice(1) : routePrefix;
     builderConfig.routePrefix = stripped || ".";
   }
+  if (workspace && workspace !== ".") {
+    builderConfig.workspace = workspace;
+  }
   if (config.framework) {
     builderConfig.framework = config.framework;
   }
@@ -186,6 +201,7 @@ function resolveConfiguredService(name, config, group) {
 function resolveAllConfiguredServices(services) {
   const resolved = [];
   const errors = [];
+  const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
   for (const name of Object.keys(services)) {
     const serviceConfig = services[name];
     const validationError = validateServiceConfig(name, serviceConfig);
@@ -194,6 +210,21 @@ function resolveAllConfiguredServices(services) {
       continue;
     }
     const service = resolveConfiguredService(name, serviceConfig);
+    if (service.type === "web" && typeof service.routePrefix === "string") {
+      const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix);
+      const existingServiceName = webServicesByRoutePrefix.get(
+        normalizedRoutePrefix
+      );
+      if (existingServiceName) {
+        errors.push({
+          code: "DUPLICATE_ROUTE_PREFIX",
+          message: `Web services "${existingServiceName}" and "${name}" cannot share routePrefix "${normalizedRoutePrefix}".`,
+          serviceName: name
+        });
+        continue;
+      }
+      webServicesByRoutePrefix.set(normalizedRoutePrefix, name);
+    }
     resolved.push(service);
   }
   return { services: resolved, errors };

package/dist/services/types.d.ts

@@ -56,3 +56,16 @@ export declare const ENTRYPOINT_EXTENSIONS: Record<string, ServiceRuntime>;
  * These don't have a "runtime" - they just build to static files.
  */
 export declare const STATIC_BUILDERS: Set<string>;
+/**
+ * Builders that produce their own full route table with handle phases
+ * (filesystem, miss, rewrite, hit, error).
+ *
+ * In services mode we generally avoid generating synthetic catch-all routes
+ * for builders that provide their own routing. At service-detection time we
+ * only have the builder "use" string (not the loaded module), so this is an
+ * explicit allow-list for known route-table builders.
+ *
+ * NOTE: This is an explicit positive set because we can't check
+ * `builder.version` at service detection time.
+ */
+export declare const ROUTE_OWNING_BUILDERS: Set<string>;

package/dist/services/types.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var types_exports = {};
 __export(types_exports, {
   ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
+  ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
   RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
   STATIC_BUILDERS: () => STATIC_BUILDERS
 });
@@ -46,9 +47,14 @@ const STATIC_BUILDERS = /* @__PURE__ */ new Set([
   "@vercel/static-build",
   "@vercel/static"
 ]);
+const ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
+  "@vercel/next",
+  "@vercel/backends"
+]);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ENTRYPOINT_EXTENSIONS,
+  ROUTE_OWNING_BUILDERS,
   RUNTIME_BUILDERS,
   STATIC_BUILDERS
 });

package/dist/services/utils.d.ts

@@ -1,7 +1,21 @@
 import type { DetectorFilesystem } from '../detectors/filesystem';
 import type { ServiceRuntime, ExperimentalServices, ServiceDetectionError, ResolvedService } from './types';
+/**
+ * Reserved internal namespace used by services routing/runtime plumbing.
+ */
+export declare const INTERNAL_SERVICE_PREFIX = "/_svc";
+export declare function getInternalServiceFunctionPath(serviceName: string): string;
 export declare function getBuilderForRuntime(runtime: ServiceRuntime): string;
 export declare function isStaticBuild(service: ResolvedService): boolean;
+/**
+ * Determines if a service uses a "route-owning" builder.
+ *
+ * Route-owning builders (e.g., `@vercel/next`, `@vercel/backends`) produce
+ * their own full route table with handle phases (filesystem, miss, rewrite,
+ * hit, error). The services system should NOT generate synthetic catch-all
+ * rewrites for them — instead, we rely on the builder's own `routes[]`.
+ */
+export declare function isRouteOwningBuilder(service: ResolvedService): boolean;
 /**
  * Infer runtime from available service configuration.
  *

package/dist/services/utils.js

@@ -18,14 +18,21 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  INTERNAL_SERVICE_PREFIX: () => INTERNAL_SERVICE_PREFIX,
   getBuilderForRuntime: () => getBuilderForRuntime,
+  getInternalServiceFunctionPath: () => getInternalServiceFunctionPath,
   inferServiceRuntime: () => inferServiceRuntime,
+  isRouteOwningBuilder: () => isRouteOwningBuilder,
   isStaticBuild: () => isStaticBuild,
   readVercelConfig: () => readVercelConfig
 });
 module.exports = __toCommonJS(utils_exports);
 var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
 var import_types = require("./types");
+const INTERNAL_SERVICE_PREFIX = "/_svc";
+function getInternalServiceFunctionPath(serviceName) {
+  return `${INTERNAL_SERVICE_PREFIX}/${serviceName}/index`;
+}
 function getBuilderForRuntime(runtime) {
   const builder = import_types.RUNTIME_BUILDERS[runtime];
   if (!builder) {
@@ -36,6 +43,9 @@ function getBuilderForRuntime(runtime) {
 function isStaticBuild(service) {
   return import_types.STATIC_BUILDERS.has(service.builder.use);
 }
+function isRouteOwningBuilder(service) {
+  return import_types.ROUTE_OWNING_BUILDERS.has(service.builder.use);
+}
 function inferServiceRuntime(config) {
   if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
     return config.runtime;
@@ -83,8 +93,11 @@ async function readVercelConfig(fs) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  INTERNAL_SERVICE_PREFIX,
   getBuilderForRuntime,
+  getInternalServiceFunctionPath,
   inferServiceRuntime,
+  isRouteOwningBuilder,
   isStaticBuild,
   readVercelConfig
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.8.4",
+  "version": "5.8.6",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,9 +19,9 @@
     "json5": "2.2.2",
     "minimatch": "3.1.2",
     "semver": "6.3.1",
-    "@vercel/error-utils": "2.0.3",
-    "@vercel/routing-utils": "5.3.2",
-    "@vercel/frameworks": "3.17.1"
+    "@vercel/routing-utils": "5.3.3",
+    "@vercel/frameworks": "3.17.1",
+    "@vercel/error-utils": "2.0.3"
   },
   "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.3.4"
+    "@vercel/build-utils": "13.4.0"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",