@vercel/fs-detectors 6.15.10 → 7.0.0

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

@@ -1,43 +0,0 @@
-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;
-    message: string;
-    action?: string;
-    link?: string;
-}
-export interface GetServicesBuildersOptions {
-    workPath?: string;
-    configuredServices?: ConfiguredServices;
-    configuredServicesType?: ConfiguredServicesType;
-    projectFramework?: string | null;
-}
-export interface ServicesBuildersResult {
-    builders: Builder[] | null;
-    errors: ErrorResponse[] | null;
-    warnings: ErrorResponse[];
-    hostRewriteRoutes: Route[] | null;
-    defaultRoutes: Route[] | null;
-    fallbackRoutes: Route[] | null;
-    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;
-}
-/**
- * Get builders for services - adapter for detectBuilders.
- *
- * This function wraps `detectServices` and transforms the result into
- * the shape expected by `detectBuilders` when `framework === 'services'`.
- */
-export declare function getServicesBuilders(options: GetServicesBuildersOptions): Promise<ServicesBuildersResult>;
-/**
- * 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

@@ -1,161 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var get_services_builders_exports = {};
-__export(get_services_builders_exports, {
-  getServicesBuilders: () => getServicesBuilders,
-  warnIgnoredDirectories: () => warnIgnoredDirectories
-});
-module.exports = __toCommonJS(get_services_builders_exports);
-var import_detect_services = require("./detect-services");
-var import_local_file_system_detector = require("../detectors/local-file-system-detector");
-function isExperimentalServicesAutoDetectionEnabled() {
-  const env = process.env.VERCEL_USE_EXPERIMENTAL_SERVICES;
-  return env === "1" || env?.toLowerCase() === "true";
-}
-async function getServicesBuilders(options) {
-  const {
-    workPath,
-    configuredServices,
-    configuredServicesType,
-    projectFramework
-  } = options;
-  const hasServiceDefinitions = configuredServices != null && Object.keys(configuredServices).length > 0;
-  if (projectFramework === "services" && !hasServiceDefinitions && !isExperimentalServicesAutoDetectionEnabled()) {
-    return {
-      builders: null,
-      errors: [
-        {
-          code: "MISSING_SERVICES",
-          message: 'Project framework is set to "services", but no services are declared. Add `services` to vercel.json with at least one service, or change the project framework setting.'
-        }
-      ],
-      warnings: [],
-      hostRewriteRoutes: null,
-      defaultRoutes: null,
-      fallbackRoutes: null,
-      redirectRoutes: null,
-      rewriteRoutes: null,
-      errorRoutes: null
-    };
-  }
-  if (!workPath) {
-    return {
-      builders: null,
-      errors: [
-        {
-          code: "MISSING_WORK_PATH",
-          message: "workPath is required for services detection."
-        }
-      ],
-      warnings: [],
-      hostRewriteRoutes: null,
-      defaultRoutes: null,
-      fallbackRoutes: null,
-      redirectRoutes: null,
-      rewriteRoutes: null,
-      errorRoutes: null
-    };
-  }
-  const fs = new import_local_file_system_detector.LocalFileSystemDetector(workPath);
-  const result = await (0, import_detect_services.detectServices)({
-    fs,
-    configuredServices,
-    configuredServicesType
-  });
-  const warningResponses = result.warnings.map((w) => ({
-    code: w.code,
-    message: w.message
-  }));
-  if (result.errors.length > 0) {
-    return {
-      builders: null,
-      errors: result.errors.map((e) => ({
-        code: e.code,
-        message: e.message
-      })),
-      warnings: warningResponses,
-      hostRewriteRoutes: null,
-      defaultRoutes: null,
-      fallbackRoutes: null,
-      redirectRoutes: null,
-      rewriteRoutes: null,
-      errorRoutes: null
-    };
-  }
-  if (result.services.length === 0) {
-    return {
-      builders: null,
-      errors: [
-        {
-          code: "NO_SERVICES_CONFIGURED",
-          message: "No services configured. Add `services` to vercel.json."
-        }
-      ],
-      warnings: warningResponses,
-      hostRewriteRoutes: null,
-      defaultRoutes: null,
-      fallbackRoutes: null,
-      redirectRoutes: null,
-      rewriteRoutes: null,
-      errorRoutes: null
-    };
-  }
-  const builders = result.services.map((service) => service.builder);
-  return {
-    builders: builders.length > 0 ? builders : null,
-    errors: null,
-    warnings: warningResponses,
-    hostRewriteRoutes: result.routes.hostRewrites.length > 0 ? result.routes.hostRewrites : null,
-    defaultRoutes: result.routes.defaults.length > 0 ? result.routes.defaults : null,
-    fallbackRoutes: result.routes.fallbacks.length > 0 ? result.routes.fallbacks : null,
-    redirectRoutes: [],
-    rewriteRoutes: result.routes.rewrites.length > 0 || result.routes.workers.length > 0 || result.routes.crons.length > 0 ? [
-      ...result.routes.rewrites,
-      ...result.routes.workers,
-      ...result.routes.crons
-    ] : null,
-    errorRoutes: [],
-    serviceRewrites: result.rewrites.length > 0 ? result.rewrites : void 0,
-    experimentalServicesV2: result.experimentalServicesV2,
-    services: result.services,
-    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 services are 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,
-  warnIgnoredDirectories
-});

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

@@ -1,11 +0,0 @@
-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

@@ -1,395 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __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 MAX_SERVICE_NAME_LENGTH = 64;
-const SERVICE_NAME_REGEX = /^[a-z]([a-z_-]*[a-z])?$/;
-function isValidServiceName(name) {
-  return name.length <= MAX_SERVICE_NAME_LENGTH && SERVICE_NAME_REGEX.test(name);
-}
-function getInvalidServiceNameMessage(name) {
-  return `Service name "${name}" is invalid. Names must be 1-${MAX_SERVICE_NAME_LENGTH} characters, start and end with a lowercase letter, and contain only lowercase letters, hyphens, and underscores.`;
-}
-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) {
-  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) {
-    return void 0;
-  }
-  return Array.isArray(command) ? command : [command];
-}
-async function resolveContainerServiceV2(name, config, normalizedRoot, serviceFs) {
-  const isRoot = normalizedRoot === ".";
-  const entrypoint = config.entrypoint;
-  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 builderSrc = isRoot ? dockerfile : import_path.posix.join(normalizedRoot, dockerfile);
-  const builderConfig = { zeroConfig: true };
-  if (!isRoot) {
-    builderConfig.workspace = normalizedRoot;
-  }
-  const command = normalizeContainerCommand(config.command);
-  if (command) {
-    builderConfig.command = command;
-  }
-  return {
-    service: {
-      schema: "experimentalServicesV2",
-      name,
-      root: normalizedRoot,
-      runtime: "container",
-      entrypoint: dockerfile,
-      command,
-      builder: {
-        src: builderSrc,
-        use: "@vercel/container",
-        config: builderConfig
-      },
-      bindings: config.bindings,
-      functions: config.functions,
-      headers: config.headers,
-      redirects: config.redirects,
-      rewrites: config.rewrites,
-      routes: config.routes,
-      cleanUrls: config.cleanUrls,
-      trailingSlash: config.trailingSlash
-    }
-  };
-}
-function validateServiceConfigV2(name, config) {
-  if (!isValidServiceName(name)) {
-    return {
-      code: "INVALID_SERVICE_NAME",
-      message: getInvalidServiceNameMessage(name),
-      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
-      };
-    }
-  }
-  return null;
-}
-async function resolveConfiguredServiceV2(name, config, fs) {
-  const normalizedRoot = (0, import_utils.stripTrailingSlash)(import_path.posix.normalize(config.root));
-  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;
-  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;
-  let inferredRuntime = (0, import_utils.inferServiceRuntime)({
-    runtime: config.runtime,
-    framework: config.framework,
-    entrypoint: entrypointFile
-  });
-  let framework = config.framework;
-  let detectedFramework = false;
-  if (!framework) {
-    const workspace = entrypointIsDirectory && normalizedEntrypoint ? 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;
-    detectedFramework = Boolean(framework);
-    inferredRuntime = (0, import_utils.inferServiceRuntime)({
-      runtime: config.runtime,
-      framework,
-      entrypoint: entrypointFile
-    });
-  }
-  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 frameworkRuntime = (0, import_utils.inferRuntimeFromFramework)(framework);
-  if (detectedFramework && frameworkRuntime && !entrypointFile) {
-    return {
-      error: {
-        code: "MISSING_SERVICE_CONFIG",
-        message: `Service "${name}" detected framework "${framework}" in "${normalizedRoot}" and must specify an "entrypoint" for runtime "${frameworkRuntime}".`,
-        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) {
-      if (config.buildCommand) {
-        builderUse = "@vercel/static-build";
-        builderSrc = "package.json";
-      } else {
-        builderUse = "@vercel/static";
-        builderSrc = config.outputDirectory ? import_path.posix.join(config.outputDirectory, "**") : "**";
-      }
-    } else {
-      if (!entrypointFile) {
-        return {
-          error: {
-            code: "MISSING_SERVICE_CONFIG",
-            message: `Service "${name}" must specify an "entrypoint" for runtime "${inferredRuntime}".`,
-            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 (config.outputDirectory) {
-    builderConfig.outputDirectory = config.outputDirectory;
-  }
-  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: normalizedRoot,
-      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 (!isValidServiceName(binding.service)) {
-        errors.push({
-          code: "INVALID_SERVICE_BINDING_NAME",
-          message: `Service "${service.name}" declares an invalid binding service name "${binding.service}". ${getInvalidServiceNameMessage(binding.service)}`,
-          serviceName: service.name
-        });
-        continue;
-      }
-      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,69 +0,0 @@
-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;
-    config: ConfiguredServiceConfig;
-    /** Filesystem scoped to the service root (via chdir) when root is set, otherwise the project-level fs. */
-    serviceFs: DetectorFilesystem;
-    root?: string;
-    group?: string;
-    resolvedEntrypoint?: ResolvedEntrypointPath;
-    routePrefixSource?: RoutePrefixSource;
-}
-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.
- */
-export declare function validateServiceConfig(name: string, config: ConfiguredServiceConfig, options?: ResolveAllConfiguredServicesOptions): ServiceDetectionError | null;
-export declare function validateServiceEntrypoint(name: string, config: ConfiguredServiceConfig, resolvedEntrypoint: ResolvedEntrypointPath): ServiceDetectionError | null;
-/**
- * Resolve a single service from user configuration.
- */
-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: ExperimentalService[];
-    errors: ServiceDetectionError[];
-}>;
-export {};