@vercel/fs-detectors 5.8.5 → 5.8.7

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, isRouteOwningBuilder } 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,6 +40,7 @@ __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,
@@ -76,6 +78,7 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   DetectorFilesystem,
   GetWorkspaceOptions,
   GetWorkspacePackagePathsOptions,
+  INTERNAL_SERVICE_PREFIX,
   LocalFileSystemDetector,
   REGEX_NON_VERCEL_PLATFORM_FILES,
   Workspace,
@@ -93,6 +96,7 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   detectOutputDirectory,
   detectServices,
   generateServicesRoutes,
+  getInternalServiceFunctionPath,
   getProjectPaths,
   getServicesBuilders,
   getWorkspacePackagePaths,

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.
  *
@@ -20,7 +20,8 @@ export declare function detectServices(options: DetectServicesOptions): Promise<
  *   SPA fallback routes to index.html under the service prefix.
  *
  * - **Runtime services** (`@vercel/python`, `@vercel/go`, `@vercel/ruby`, etc.):
- *   Prefix rewrites to the function entrypoint with `check: true`.
+ *   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.

package/dist/services/detect-services.js

@@ -22,7 +22,7 @@ __export(detect_services_exports, {
   generateServicesRoutes: () => generateServicesRoutes
 });
 module.exports = __toCommonJS(detect_services_exports);
-var import_types = require("./types");
+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");
@@ -51,7 +51,10 @@ async function detectServices(options) {
       };
     }
     if (autoResult.services) {
-      const result2 = (0, import_resolve.resolveAllConfiguredServices)(autoResult.services);
+      const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
+        autoResult.services,
+        scopedFs
+      );
       const routes2 = generateServicesRoutes(result2.services);
       return {
         services: result2.services,
@@ -72,7 +75,10 @@ async function detectServices(options) {
       warnings: []
     };
   }
-  const result = (0, import_resolve.resolveAllConfiguredServices)(configuredServices);
+  const result = await (0, import_resolve.resolveAllConfiguredServices)(
+    configuredServices,
+    scopedFs
+  );
   const routes = generateServicesRoutes(result.services);
   return {
     services: result.services,
@@ -86,45 +92,47 @@ function generateServicesRoutes(services) {
   const defaults = [];
   const crons = [];
   const workers = [];
-  const entrypointExtensions = Object.keys(import_types.ENTRYPOINT_EXTENSIONS).sort(
-    (a, b) => b.length - a.length
-  );
-  const stripEntrypointExtension = (entrypoint) => {
-    for (const ext of entrypointExtensions) {
-      if (entrypoint.endsWith(ext)) {
-        return entrypoint.slice(0, -ext.length);
-      }
-    }
-    return entrypoint;
-  };
   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 if (service.runtime) {
-      const builderSrc = service.builder.src || routePrefix;
-      const extensionless = stripEntrypointExtension(builderSrc);
-      const functionPath = extensionless.startsWith("/") ? extensionless : `/${extensionless}`;
+      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
         });
@@ -135,6 +143,16 @@ function generateServicesRoutes(services) {
   }
   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.d.ts

@@ -1,4 +1,5 @@
-import type { ResolvedService, ExperimentalServiceConfig, ExperimentalServices, ServiceDetectionError } from './types';
+import type { Service, ExperimentalServiceConfig, ExperimentalServices, ServiceDetectionError } from './types';
+import type { DetectorFilesystem } from '../detectors/filesystem';
 /**
  * Validate a service configuration from vercel.json experimentalServices.
  */
@@ -6,12 +7,12 @@ export declare function validateServiceConfig(name: string, config: Experimental
 /**
  * Resolve a single service from user configuration.
  */
-export declare function resolveConfiguredService(name: string, config: ExperimentalServiceConfig, group?: string): ResolvedService;
+export declare function resolveConfiguredService(name: string, config: ExperimentalServiceConfig, fs: DetectorFilesystem, group?: string): Promise<Service>;
 /**
  * Resolve all services from vercel.json experimentalServices.
  * Validates each service configuration.
  */
-export declare function resolveAllConfiguredServices(services: ExperimentalServices): {
-    services: ResolvedService[];
+export declare function resolveAllConfiguredServices(services: ExperimentalServices, fs: DetectorFilesystem): Promise<{
+    services: Service[];
     errors: ServiceDetectionError[];
-};
+}>;

package/dist/services/resolve.js

@@ -37,14 +37,67 @@ 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 normalizeRoutePrefix(routePrefix) {
-  let normalized = routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`;
-  if (normalized !== "/" && normalized.endsWith("/")) {
-    normalized = normalized.slice(0, -1);
+function toWorkspaceRelativeEntrypoint(entrypoint, workspace) {
+  const normalizedEntrypoint = import_path.posix.normalize(entrypoint);
+  if (workspace === ".") {
+    return normalizedEntrypoint;
   }
-  return normalized || "/";
+  const workspacePrefix = `${workspace}/`;
+  if (normalizedEntrypoint.startsWith(workspacePrefix)) {
+    return normalizedEntrypoint.slice(workspacePrefix.length);
+  }
+  const relativeEntrypoint = import_path.posix.relative(
+    workspace,
+    normalizedEntrypoint
+  );
+  if (relativeEntrypoint === "" || relativeEntrypoint.startsWith("..")) {
+    return normalizedEntrypoint;
+  }
+  return relativeEntrypoint;
+}
+async function inferWorkspaceFromNearestManifest({
+  fs,
+  entrypoint,
+  runtime
+}) {
+  if (!entrypoint || !runtime) {
+    return void 0;
+  }
+  const manifests = import_types.RUNTIME_MANIFESTS[runtime];
+  if (!manifests || manifests.length === 0) {
+    return void 0;
+  }
+  let dir = import_path.posix.dirname(import_path.posix.normalize(entrypoint)) || ".";
+  if (dir === "") {
+    dir = ".";
+  }
+  let reachedRoot = false;
+  while (!reachedRoot) {
+    for (const manifest of manifests) {
+      const manifestPath = dir === "." ? manifest : import_path.posix.join(dir, manifest);
+      if (await (0, import_utils.hasFile)(fs, manifestPath)) {
+        return dir;
+      }
+    }
+    if (dir === "." || dir === "/") {
+      reachedRoot = true;
+    } else {
+      const parent = import_path.posix.dirname(dir);
+      if (!parent || parent === dir) {
+        reachedRoot = true;
+      } else {
+        dir = parent;
+      }
+    }
+  }
+  return void 0;
+}
+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)) {
@@ -69,6 +122,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",
@@ -127,24 +187,41 @@ function validateServiceConfig(name, config) {
   }
   return null;
 }
-function resolveConfiguredService(name, config, group) {
+async function resolveConfiguredService(name, config, fs, group) {
   const type = config.type || "web";
-  const workspace = config.workspace || ".";
+  const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
+  let workspace = config.workspace || ".";
+  let resolvedEntrypoint = config.entrypoint;
+  if (!config.workspace) {
+    const inferredWorkspace = await inferWorkspaceFromNearestManifest({
+      fs,
+      entrypoint: resolvedEntrypoint,
+      runtime: inferredRuntime
+    });
+    if (inferredWorkspace) {
+      workspace = inferredWorkspace;
+      if (resolvedEntrypoint) {
+        resolvedEntrypoint = toWorkspaceRelativeEntrypoint(
+          resolvedEntrypoint,
+          inferredWorkspace
+        );
+      }
+    }
+  }
   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";
+    builderSrc = resolvedEntrypoint || framework?.useRuntime?.src || "package.json";
   } else if (config.builder) {
     builderUse = config.builder;
-    builderSrc = config.entrypoint;
+    builderSrc = resolvedEntrypoint;
   } else {
     builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
-    builderSrc = config.entrypoint;
+    builderSrc = resolvedEntrypoint;
   }
   const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
   const isRoot = workspace === ".";
@@ -177,7 +254,7 @@ function resolveConfiguredService(name, config, group) {
     type,
     group,
     workspace,
-    entrypoint: config.entrypoint,
+    entrypoint: resolvedEntrypoint,
     routePrefix,
     framework: config.framework,
     builder: {
@@ -193,7 +270,7 @@ function resolveConfiguredService(name, config, group) {
     consumer
   };
 }
-function resolveAllConfiguredServices(services) {
+async function resolveAllConfiguredServices(services, fs) {
   const resolved = [];
   const errors = [];
   const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
@@ -204,9 +281,9 @@ function resolveAllConfiguredServices(services) {
       errors.push(validationError);
       continue;
     }
-    const service = resolveConfiguredService(name, serviceConfig);
+    const service = await resolveConfiguredService(name, serviceConfig, fs);
     if (service.type === "web" && typeof service.routePrefix === "string") {
-      const normalizedRoutePrefix = normalizeRoutePrefix(service.routePrefix);
+      const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix);
       const existingServiceName = webServicesByRoutePrefix.get(
         normalizedRoutePrefix
       );

package/dist/services/types.d.ts

@@ -33,7 +33,7 @@ export interface ServicesRoutes {
     workers: Route[];
 }
 export interface DetectServicesResult {
-    services: ResolvedService[];
+    services: Service[];
     /** Routing rules derived from services */
     routes: ServicesRoutes;
     errors: ServiceDetectionError[];
@@ -50,6 +50,7 @@ export interface ServiceDetectionError {
     serviceName?: string;
 }
 export declare const RUNTIME_BUILDERS: Record<ServiceRuntime, string>;
+export declare const RUNTIME_MANIFESTS: Partial<Record<ServiceRuntime, string[]>>;
 export declare const ENTRYPOINT_EXTENSIONS: Record<string, ServiceRuntime>;
 /**
  * Builders that produce static output (SPAs, static sites).

package/dist/services/types.js

@@ -21,6 +21,7 @@ __export(types_exports, {
   ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
   ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
   RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
+  RUNTIME_MANIFESTS: () => RUNTIME_MANIFESTS,
   STATIC_BUILDERS: () => STATIC_BUILDERS
 });
 module.exports = __toCommonJS(types_exports);
@@ -31,6 +32,20 @@ const RUNTIME_BUILDERS = {
   rust: "@vercel/rust",
   ruby: "@vercel/ruby"
 };
+const RUNTIME_MANIFESTS = {
+  node: ["package.json"],
+  python: [
+    "pyproject.toml",
+    "requirements.txt",
+    "Pipfile",
+    "pylock.yml",
+    "uv.lock",
+    "setup.py"
+  ],
+  go: ["go.mod"],
+  ruby: ["Gemfile"],
+  rust: ["Cargo.toml"]
+};
 const ENTRYPOINT_EXTENSIONS = {
   ".ts": "node",
   ".mts": "node",
@@ -56,5 +71,6 @@ const ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
   ENTRYPOINT_EXTENSIONS,
   ROUTE_OWNING_BUILDERS,
   RUNTIME_BUILDERS,
+  RUNTIME_MANIFESTS,
   STATIC_BUILDERS
 });

package/dist/services/utils.d.ts

@@ -1,5 +1,11 @@
 import type { DetectorFilesystem } from '../detectors/filesystem';
 import type { ServiceRuntime, ExperimentalServices, ServiceDetectionError, ResolvedService } from './types';
+export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promise<boolean>;
+/**
+ * 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;
 /**

package/dist/services/utils.js

@@ -18,7 +18,10 @@ 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,
+  hasFile: () => hasFile,
   inferServiceRuntime: () => inferServiceRuntime,
   isRouteOwningBuilder: () => isRouteOwningBuilder,
   isStaticBuild: () => isStaticBuild,
@@ -27,6 +30,17 @@ __export(utils_exports, {
 module.exports = __toCommonJS(utils_exports);
 var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
 var import_types = require("./types");
+async function hasFile(fs, filePath) {
+  try {
+    return await fs.isFile(filePath);
+  } catch {
+    return false;
+  }
+}
+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) {
@@ -87,7 +101,10 @@ async function readVercelConfig(fs) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  INTERNAL_SERVICE_PREFIX,
   getBuilderForRuntime,
+  getInternalServiceFunctionPath,
+  hasFile,
   inferServiceRuntime,
   isRouteOwningBuilder,
   isStaticBuild,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "5.8.5",
+  "version": "5.8.7",
   "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/routing-utils": "5.3.2",
+    "@vercel/error-utils": "2.0.3",
     "@vercel/frameworks": "3.17.1",
-    "@vercel/error-utils": "2.0.3"
+    "@vercel/routing-utils": "5.3.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.5"
+    "@vercel/build-utils": "13.4.0"
   },
   "scripts": {
     "build": "node ../../utils/build.mjs",