@vercel/fs-detectors 6.15.8 → 7.0.0

package/dist/services/resolve.js

@@ -1,914 +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_exports = {};
-__export(resolve_exports, {
-  detectFrameworkFromWorkspace: () => detectFrameworkFromWorkspace,
-  getServiceFs: () => getServiceFs,
-  inferWorkspaceFromNearestManifest: () => inferWorkspaceFromNearestManifest,
-  parsePyModuleAttrEntrypoint: () => parsePyModuleAttrEntrypoint,
-  resolveAllConfiguredServices: () => resolveAllConfiguredServices,
-  resolveConfiguredService: () => resolveConfiguredService,
-  resolveEntrypointPath: () => resolveEntrypointPath,
-  validateServiceConfig: () => validateServiceConfig,
-  validateServiceEntrypoint: () => validateServiceEntrypoint
-});
-module.exports = __toCommonJS(resolve_exports);
-var import_path = require("path");
-var import_build_utils = require("@vercel/build-utils");
-var import_types = require("./types");
-var import_utils = require("./utils");
-var import_frameworks = require("@vercel/frameworks");
-var import_detect_framework = require("../detect-framework");
-var import_routing_utils = require("@vercel/routing-utils");
-var import_build_utils2 = require("@vercel/build-utils");
-const frameworksBySlug = new Map(import_frameworks.frameworkList.map((f) => [f.slug, f]));
-const PYTHON_MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
-function parsePyModuleAttrEntrypoint(entrypoint) {
-  const match = PYTHON_MODULE_ATTR_RE.exec(entrypoint);
-  if (!match)
-    return null;
-  return {
-    attrName: match[2],
-    filePath: match[1].replace(/\./g, "/") + ".py"
-  };
-}
-const SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
-const DNS_LABEL_RE = /^(?!-)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;
-const ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-const ENTRYPOINT_REQUIRED_RUNTIMES = /* @__PURE__ */ new Set([
-  "node",
-  "python",
-  "go"
-]);
-function isContainerRuntime(config) {
-  return config.runtime === "container";
-}
-function normalizeContainerCommand(command) {
-  return Array.isArray(command) ? command : [command];
-}
-async function getServiceFs(fs, serviceName, root) {
-  if (!root) {
-    return { fs };
-  }
-  const normalizedRoot = (0, import_utils.stripTrailingSlash)(import_path.posix.normalize(root));
-  if (!await fs.hasPath(normalizedRoot)) {
-    return {
-      fs,
-      error: {
-        code: "ROOT_NOT_FOUND",
-        message: `Service "${serviceName}" has root "${root}" but that directory does not exist.`,
-        serviceName
-      }
-    };
-  }
-  if (await fs.isFile(normalizedRoot)) {
-    return {
-      fs,
-      error: {
-        code: "ROOT_NOT_DIRECTORY",
-        message: `Service "${serviceName}" has root "${root}" but that path is a file, not a directory.`,
-        serviceName
-      }
-    };
-  }
-  return { fs: fs.chdir(normalizedRoot) };
-}
-function normalizeServiceEntrypoint(entrypoint) {
-  const normalized = import_path.posix.normalize(entrypoint);
-  return normalized === "" ? "." : normalized;
-}
-function getEffectiveServiceTrigger(config) {
-  if (config.type === "cron") {
-    return "schedule";
-  }
-  if (config.type === "worker") {
-    return "queue";
-  }
-  if (config.type !== "job") {
-    return void 0;
-  }
-  return config.trigger;
-}
-function getEntrypointRequiredRuntime(config) {
-  if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
-    return config.runtime;
-  }
-  return (0, import_utils.inferRuntimeFromFramework)(config.framework);
-}
-function validateBackendFileEntrypoint(name, config, resolvedEntrypoint, options) {
-  if (!options.requireFileEntrypointForBackendRuntimes || !resolvedEntrypoint?.isDirectory) {
-    return null;
-  }
-  const runtime = getEntrypointRequiredRuntime(config);
-  if (!runtime || !ENTRYPOINT_REQUIRED_RUNTIMES.has(runtime)) {
-    return null;
-  }
-  return {
-    code: "INVALID_ENTRYPOINT",
-    message: `Service "${name}" must specify a file "entrypoint" when using "${config.runtime ? "runtime" : "framework"}" "${config.runtime || config.framework}".`,
-    serviceName: name
-  };
-}
-async function resolveEntrypointPath({
-  fs,
-  serviceName,
-  entrypoint
-}) {
-  const normalized = normalizeServiceEntrypoint(entrypoint);
-  if (!await fs.hasPath(normalized)) {
-    return {
-      error: {
-        code: "ENTRYPOINT_NOT_FOUND",
-        message: `Service "${serviceName}" has entrypoint "${entrypoint}" but that path does not exist.`,
-        serviceName
-      }
-    };
-  }
-  return {
-    entrypoint: {
-      normalized,
-      isDirectory: !await fs.isFile(normalized)
-    }
-  };
-}
-function isDockerfileEntrypoint(entrypoint) {
-  const base = import_path.posix.basename(entrypoint).toLowerCase();
-  return base === "dockerfile" || base === "containerfile" || base.endsWith(".dockerfile");
-}
-function toWorkspaceRelativeEntrypoint(entrypoint, workspace) {
-  const normalizedEntrypoint = import_path.posix.normalize(entrypoint);
-  if (workspace === ".") {
-    return normalizedEntrypoint;
-  }
-  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;
-}
-async function detectFrameworkFromWorkspace({
-  fs,
-  workspace,
-  serviceName,
-  runtime
-}) {
-  const serviceFs = workspace === "." ? fs : fs.chdir(workspace);
-  const frameworkCandidates = (0, import_utils.filterFrameworksByRuntime)(import_frameworks.frameworkList, runtime);
-  const frameworks = await (0, import_detect_framework.detectFrameworks)({
-    fs: serviceFs,
-    frameworkList: frameworkCandidates
-  });
-  if (frameworks.length > 1) {
-    const frameworkNames = frameworks.map((f) => f.name).join(", ");
-    return {
-      error: {
-        code: "MULTIPLE_FRAMEWORKS_SERVICE",
-        message: `Multiple frameworks detected in ${workspace === "." ? "project root" : `${workspace}/`}: ${frameworkNames}. Specify "framework" explicitly in services.`,
-        serviceName
-      }
-    };
-  }
-  if (frameworks.length === 1) {
-    return {
-      framework: frameworks[0].slug ?? void 0
-    };
-  }
-  return {};
-}
-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 resolveServiceRoutingConfig(name, config) {
-  const hasLegacyRoutePrefix = typeof config.routePrefix === "string";
-  const hasLegacySubdomain = typeof config.subdomain === "string";
-  if (config.mount === void 0) {
-    return {
-      routing: {
-        routePrefix: config.routePrefix,
-        subdomain: config.subdomain,
-        routePrefixConfigured: hasLegacyRoutePrefix
-      }
-    };
-  }
-  if (hasLegacyRoutePrefix || hasLegacySubdomain) {
-    return {
-      error: {
-        code: "CONFLICTING_MOUNT_CONFIG",
-        message: `Service "${name}" cannot mix "mount" with "routePrefix" or "subdomain". Use only one routing configuration style.`,
-        serviceName: name
-      }
-    };
-  }
-  if (typeof config.mount === "string") {
-    return {
-      routing: {
-        routePrefix: config.mount,
-        routePrefixConfigured: true
-      }
-    };
-  }
-  if (!config.mount || typeof config.mount !== "object" || Array.isArray(config.mount)) {
-    return {
-      error: {
-        code: "INVALID_MOUNT",
-        message: `Service "${name}" has invalid "mount" config. Use a string path such as "/api" or an object like { path: "/api", subdomain: "api" }.`,
-        serviceName: name
-      }
-    };
-  }
-  const hasInvalidMountKeys = Object.keys(config.mount).some(
-    (key) => key !== "path" && key !== "subdomain"
-  );
-  if (hasInvalidMountKeys) {
-    return {
-      error: {
-        code: "INVALID_MOUNT",
-        message: `Service "${name}" has invalid "mount" config. Only "path" and "subdomain" are supported.`,
-        serviceName: name
-      }
-    };
-  }
-  const mountPath = config.mount.path;
-  const mountSubdomain = config.mount.subdomain;
-  if (mountPath !== void 0 && typeof mountPath !== "string" || mountSubdomain !== void 0 && typeof mountSubdomain !== "string") {
-    return {
-      error: {
-        code: "INVALID_MOUNT",
-        message: `Service "${name}" has invalid "mount" config. "path" and "subdomain" must be strings when provided.`,
-        serviceName: name
-      }
-    };
-  }
-  if (typeof mountPath !== "string" && typeof mountSubdomain !== "string") {
-    return {
-      error: {
-        code: "INVALID_MOUNT",
-        message: `Service "${name}" has invalid "mount" config. Specify at least one of "mount.path" or "mount.subdomain".`,
-        serviceName: name
-      }
-    };
-  }
-  return {
-    routing: {
-      routePrefix: mountPath,
-      subdomain: mountSubdomain,
-      routePrefixConfigured: typeof mountPath === "string"
-    }
-  };
-}
-function validateServiceConfig(name, config, options = {}) {
-  if (!SERVICE_NAME_REGEX.test(name)) {
-    return {
-      code: "INVALID_SERVICE_NAME",
-      message: `Service name "${name}" is invalid. Names must start with a letter, end with an alphanumeric character, and contain only alphanumeric characters, hyphens, and underscores.`,
-      serviceName: name
-    };
-  }
-  if (!config || typeof config !== "object") {
-    return {
-      code: "INVALID_SERVICE_CONFIG",
-      message: `Service "${name}" has an invalid configuration. Expected an object.`,
-      serviceName: name
-    };
-  }
-  const serviceType = config.type || "web";
-  const effectiveTrigger = getEffectiveServiceTrigger(config);
-  const effectiveService = {
-    type: serviceType,
-    trigger: effectiveTrigger
-  };
-  const isJobService = serviceType === "job" || serviceType === "cron";
-  const isScheduleJobService = (0, import_build_utils.isScheduleTriggeredService)(effectiveService);
-  const isQueueJobService = serviceType === "job" && (0, import_build_utils.isQueueTriggeredService)(effectiveService);
-  const isWorkflowService = serviceType === "job" && effectiveTrigger === "workflow";
-  const isNonWebService = serviceType === "worker" || isJobService;
-  const serviceTypeLabel = isJobService ? "Job" : serviceType === "worker" ? "Worker" : "Web";
-  const routingResult = resolveServiceRoutingConfig(name, config);
-  if (routingResult.error) {
-    return routingResult.error;
-  }
-  const configuredRoutePrefix = routingResult.routing?.routePrefix;
-  const configuredSubdomain = routingResult.routing?.subdomain;
-  const hasRoutePrefix = typeof configuredRoutePrefix === "string";
-  const hasSubdomain = typeof configuredSubdomain === "string";
-  if (hasSubdomain && !DNS_LABEL_RE.test(configuredSubdomain)) {
-    return {
-      code: "INVALID_SUBDOMAIN",
-      message: `Web service "${name}" has invalid subdomain "${configuredSubdomain}". Use a single DNS label such as "api".`,
-      serviceName: name
-    };
-  }
-  if (serviceType === "web" && !hasRoutePrefix && !hasSubdomain) {
-    return {
-      code: "MISSING_ROUTE_PREFIX",
-      message: `Web service "${name}" must specify at least one of "mount", "routePrefix", or "subdomain".`,
-      serviceName: name
-    };
-  }
-  if (serviceType === "web" && configuredRoutePrefix && isReservedServiceRoutePrefix(configuredRoutePrefix)) {
-    return {
-      code: "RESERVED_ROUTE_PREFIX",
-      message: `Web service "${name}" cannot use routePrefix "${configuredRoutePrefix}". The "${import_utils.INTERNAL_SERVICE_PREFIX}" prefix is reserved for internal services routing.`,
-      serviceName: name
-    };
-  }
-  if (isNonWebService && configuredRoutePrefix) {
-    return {
-      code: "INVALID_ROUTE_PREFIX",
-      message: `${serviceTypeLabel} service "${name}" cannot have "routePrefix" or "mount". Only web services should specify path-based routing.`,
-      serviceName: name
-    };
-  }
-  if (isNonWebService && hasSubdomain) {
-    return {
-      code: "INVALID_HOST_ROUTING_CONFIG",
-      message: `${serviceTypeLabel} service "${name}" cannot have "subdomain" or "mount.subdomain". Only web services should specify subdomain routing.`,
-      serviceName: name
-    };
-  }
-  if (serviceType === "job" && effectiveTrigger === void 0) {
-    return {
-      code: "MISSING_JOB_TRIGGER",
-      message: `Job service "${name}" is missing required "trigger" field.`,
-      serviceName: name
-    };
-  }
-  if (serviceType === "job" && effectiveTrigger && !import_build_utils.JOB_TRIGGERS.includes(effectiveTrigger)) {
-    return {
-      code: "INVALID_JOB_TRIGGER",
-      message: `Job service "${name}" has invalid trigger "${effectiveTrigger}". Expected ${import_build_utils.JOB_TRIGGERS.map((t) => `"${t}"`).join(", ")}.`,
-      serviceName: name
-    };
-  }
-  if (isScheduleJobService && !config.schedule) {
-    return {
-      code: serviceType === "cron" ? "MISSING_CRON_SCHEDULE" : "MISSING_JOB_SCHEDULE",
-      message: `${serviceTypeLabel} service "${name}" is missing required "schedule" field.`,
-      serviceName: name
-    };
-  }
-  if (isQueueJobService && (!Array.isArray(config.topics) || config.topics.length === 0)) {
-    return {
-      code: "MISSING_QUEUE_TOPICS",
-      message: `${serviceTypeLabel} service "${name}" is missing required "topics" field.`,
-      serviceName: name
-    };
-  }
-  if (isWorkflowService && typeof config.entrypoint !== "string") {
-    return {
-      code: "MISSING_ENTRYPOINT",
-      message: `Job service "${name}" with "workflow" trigger must specify "entrypoint".`,
-      serviceName: name
-    };
-  }
-  if (config.root !== void 0) {
-    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.env !== void 0) {
-    if (typeof config.env !== "object" || Array.isArray(config.env)) {
-      return {
-        code: "INVALID_ENV_VARS",
-        message: `Service "${name}" has invalid "env". Must be an object keyed by environment variable name.`,
-        serviceName: name
-      };
-    }
-    for (const [envVarName, envVar] of Object.entries(config.env)) {
-      if (!ENV_VAR_NAME_RE.test(envVarName)) {
-        return {
-          code: "INVALID_ENV_VAR_NAME",
-          message: `Service "${name}" has invalid env key "${envVarName}". Must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,
-          serviceName: name
-        };
-      }
-      if (!envVar || typeof envVar !== "object" || Array.isArray(envVar)) {
-        return {
-          code: "INVALID_ENV_VAR",
-          message: `Service "${name}" has invalid env["${envVarName}"]. Must be an object with a "type" discriminator.`,
-          serviceName: name
-        };
-      }
-      const envVarType = envVar.type;
-      if (envVarType !== "service-ref") {
-        return {
-          code: "INVALID_ENV_VAR_TYPE",
-          message: `Service "${name}" env["${envVarName}"] has unknown type "${envVarType}".`,
-          serviceName: name
-        };
-      }
-      const refService = envVar.service;
-      if (typeof refService !== "string" || refService.length === 0) {
-        return {
-          code: "INVALID_ENV_VAR_REF",
-          message: `Service "${name}" env["${envVarName}"] must specify "service" as a non-empty string.`,
-          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
-      };
-    }
-  }
-  const hasFramework = Boolean(config.framework);
-  const hasBuilderOrRuntime = Boolean(config.builder || config.runtime);
-  const hasEntrypoint = Boolean(config.entrypoint);
-  const entrypointRequiredRuntime = getEntrypointRequiredRuntime(config);
-  if (!hasFramework && !hasBuilderOrRuntime && !hasEntrypoint) {
-    return {
-      code: "MISSING_SERVICE_CONFIG",
-      message: `Service "${name}" must specify "framework", "entrypoint", or both "builder"/"runtime" with "entrypoint".`,
-      serviceName: name
-    };
-  }
-  if (options.requireFileEntrypointForBackendRuntimes && !hasEntrypoint && entrypointRequiredRuntime && ENTRYPOINT_REQUIRED_RUNTIMES.has(entrypointRequiredRuntime)) {
-    return {
-      code: "MISSING_ENTRYPOINT",
-      message: `Service "${name}" must specify "entrypoint" when using "${config.runtime ? "runtime" : "framework"}" "${config.runtime || config.framework}".`,
-      serviceName: name
-    };
-  }
-  if (hasBuilderOrRuntime && !hasFramework && !hasEntrypoint) {
-    return {
-      code: "MISSING_ENTRYPOINT",
-      message: `Service "${name}" must specify "entrypoint" when using "${config.builder ? "builder" : "runtime"}".`,
-      serviceName: name
-    };
-  }
-  if (config.command !== void 0 && !isContainerRuntime(config)) {
-    return {
-      code: "INVALID_COMMAND",
-      message: `Service "${name}" can only specify "command" when using runtime "container".`,
-      serviceName: name
-    };
-  }
-  return null;
-}
-function validateServiceEntrypoint(name, config, resolvedEntrypoint) {
-  if (!resolvedEntrypoint.isDirectory && !config.builder && !config.runtime && !config.framework) {
-    const runtime = (0, import_utils.inferServiceRuntime)({
-      ...config,
-      entrypoint: resolvedEntrypoint.normalized
-    });
-    if (!runtime) {
-      const supported = Object.keys(import_types.ENTRYPOINT_EXTENSIONS).join(", ");
-      return {
-        code: "UNSUPPORTED_ENTRYPOINT",
-        message: `Service "${name}" has unsupported entrypoint "${config.entrypoint}". Use a supported extension (${supported}) or specify "builder", "framework", or "runtime".`,
-        serviceName: name
-      };
-    }
-  }
-  return null;
-}
-async function resolveConfiguredService(options) {
-  const {
-    name,
-    config,
-    serviceFs,
-    root,
-    group,
-    resolvedEntrypoint,
-    routePrefixSource = "configured"
-  } = options;
-  const type = config.type || "web";
-  const trigger = getEffectiveServiceTrigger(config);
-  const rawEntrypoint = config.entrypoint;
-  const moduleAttrParsed = typeof rawEntrypoint === "string" ? parsePyModuleAttrEntrypoint(rawEntrypoint) : null;
-  const routingResult = resolveServiceRoutingConfig(name, config);
-  if (routingResult.error) {
-    throw new Error(routingResult.error.message);
-  }
-  const configuredRoutePrefix = routingResult.routing?.routePrefix;
-  const configuredSubdomain = routingResult.routing?.subdomain;
-  const routePrefixWasConfigured = routingResult.routing?.routePrefixConfigured ?? false;
-  const containerEntrypoint = isContainerRuntime(config) && typeof rawEntrypoint === "string" ? rawEntrypoint : void 0;
-  const containerDockerfile = containerEntrypoint && isDockerfileEntrypoint(containerEntrypoint) ? import_path.posix.normalize(containerEntrypoint) : void 0;
-  const containerImage = containerEntrypoint && !containerDockerfile ? containerEntrypoint : void 0;
-  let resolvedEntrypointPath = resolvedEntrypoint;
-  if (!containerEntrypoint && !resolvedEntrypointPath && typeof rawEntrypoint === "string") {
-    const entrypointToResolve = moduleAttrParsed ? moduleAttrParsed.filePath : rawEntrypoint;
-    const resolved = await resolveEntrypointPath({
-      fs: serviceFs,
-      serviceName: name,
-      entrypoint: entrypointToResolve
-    });
-    resolvedEntrypointPath = resolved.entrypoint;
-  }
-  if (!containerEntrypoint && typeof rawEntrypoint === "string" && !resolvedEntrypointPath) {
-    throw new Error(
-      `Failed to resolve entrypoint "${rawEntrypoint}" for service "${name}".`
-    );
-  }
-  const normalizedEntrypoint = resolvedEntrypointPath?.normalized;
-  const entrypointIsDirectory = Boolean(resolvedEntrypointPath?.isDirectory);
-  const inferredRuntime = (0, import_utils.inferServiceRuntime)({
-    ...config,
-    entrypoint: entrypointIsDirectory ? void 0 : normalizedEntrypoint
-  });
-  let workspace = ".";
-  let resolvedEntrypointFile = entrypointIsDirectory || !normalizedEntrypoint ? void 0 : normalizedEntrypoint;
-  if (entrypointIsDirectory && normalizedEntrypoint) {
-    workspace = normalizedEntrypoint;
-  } else {
-    const inferredWorkspace = await inferWorkspaceFromNearestManifest({
-      fs: serviceFs,
-      entrypoint: resolvedEntrypointFile,
-      runtime: inferredRuntime
-    });
-    if (inferredWorkspace) {
-      workspace = inferredWorkspace;
-      if (resolvedEntrypointFile) {
-        resolvedEntrypointFile = toWorkspaceRelativeEntrypoint(
-          resolvedEntrypointFile,
-          inferredWorkspace
-        );
-      }
-    }
-  }
-  if (root) {
-    const normalizedRoot = import_path.posix.normalize(root);
-    if (normalizedRoot !== ".") {
-      workspace = workspace === "." ? normalizedRoot : import_path.posix.join(normalizedRoot, workspace);
-    }
-  }
-  const topics = type === "worker" ? (0, import_build_utils.getServiceQueueTopics)({ type, topics: config.topics }) : trigger === "queue" ? config.topics : trigger === "workflow" ? ["__wkf_*"] : void 0;
-  let builderUse;
-  let builderSrc;
-  const frameworkDefinition = config.framework ? frameworksBySlug.get(config.framework) : void 0;
-  if (config.builder) {
-    builderUse = config.builder;
-    builderSrc = resolvedEntrypointFile || frameworkDefinition?.useRuntime?.src || "package.json";
-  } else if (config.framework) {
-    const isCronService = (0, import_build_utils.isScheduleTriggeredService)({ type, trigger });
-    if ((0, import_build_utils2.isNodeBackendFramework)(config.framework) && (type === "web" || isCronService)) {
-      builderUse = "@vercel/backends";
-    } else {
-      builderUse = frameworkDefinition?.useRuntime?.use || "@vercel/static-build";
-    }
-    builderSrc = resolvedEntrypointFile || frameworkDefinition?.useRuntime?.src || "package.json";
-  } else {
-    if (!inferredRuntime) {
-      throw new Error(
-        `Could not infer runtime for service "${name}" and no builder or framework were provided.`
-      );
-    }
-    if (inferredRuntime === "node") {
-      const isCronService = (0, import_build_utils.isScheduleTriggeredService)({ type, trigger });
-      builderUse = type === "web" || isCronService ? "@vercel/backends" : "@vercel/node";
-    } else {
-      builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
-    }
-    builderSrc = inferredRuntime === "container" && typeof containerEntrypoint === "string" ? containerEntrypoint : resolvedEntrypointFile;
-  }
-  const normalizedSubdomain = type === "web" && typeof configuredSubdomain === "string" ? configuredSubdomain.toLowerCase() : void 0;
-  const defaultRoutePrefix = type === "web" && normalizedSubdomain ? `/_/${name}` : void 0;
-  const routePrefix = type === "web" && (configuredRoutePrefix || defaultRoutePrefix) ? (configuredRoutePrefix || defaultRoutePrefix).startsWith("/") ? configuredRoutePrefix || defaultRoutePrefix : `/${configuredRoutePrefix || defaultRoutePrefix}` : void 0;
-  const resolvedRoutePrefixSource = type === "web" && typeof routePrefix === "string" ? routePrefixWasConfigured ? routePrefixSource : "generated" : void 0;
-  const isRoot = workspace === ".";
-  if (!isRoot) {
-    builderSrc = import_path.posix.join(workspace, builderSrc);
-  }
-  const builderConfig = { zeroConfig: true };
-  if (builderUse === "@vercel/backends") {
-    builderConfig.serviceName = name;
-  }
-  if (config.memory)
-    builderConfig.memory = config.memory;
-  if (config.maxDuration)
-    builderConfig.maxDuration = config.maxDuration;
-  if (config.includeFiles)
-    builderConfig.includeFiles = config.includeFiles;
-  if (config.excludeFiles)
-    builderConfig.excludeFiles = config.excludeFiles;
-  const isStaticBuild = import_types.STATIC_BUILDERS.has(builderUse);
-  const runtime = isStaticBuild ? void 0 : inferredRuntime;
-  if (routePrefix) {
-    const stripped = routePrefix.startsWith("/") ? routePrefix.slice(1) : routePrefix;
-    builderConfig.routePrefix = stripped || ".";
-  }
-  if (workspace && workspace !== ".") {
-    builderConfig.workspace = workspace;
-  }
-  if (config.framework) {
-    builderConfig.framework = config.framework;
-  }
-  if (containerImage) {
-    builderConfig.handler = containerImage;
-  }
-  if (config.command !== void 0) {
-    builderConfig.command = normalizeContainerCommand(config.command);
-  }
-  if (moduleAttrParsed) {
-    builderConfig.handlerFunction = moduleAttrParsed.attrName;
-  }
-  return {
-    schema: "experimentalServices",
-    name,
-    type,
-    trigger,
-    group,
-    workspace,
-    entrypoint: containerImage ?? containerDockerfile ?? resolvedEntrypointFile,
-    routePrefix,
-    routePrefixSource: resolvedRoutePrefixSource,
-    subdomain: normalizedSubdomain,
-    framework: config.framework,
-    builder: {
-      src: builderSrc,
-      use: builderUse,
-      config: Object.keys(builderConfig).length > 0 ? builderConfig : void 0
-    },
-    runtime,
-    buildCommand: config.buildCommand,
-    installCommand: config.installCommand,
-    preDeployCommand: config.preDeployCommand,
-    schedule: config.schedule,
-    handlerFunction: moduleAttrParsed?.attrName,
-    topics,
-    env: config.env
-  };
-}
-async function resolveAllConfiguredServices(services, fs, routePrefixSource = "configured", options = {}) {
-  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, options);
-    if (validationError) {
-      errors.push(validationError);
-      continue;
-    }
-    const root = serviceConfig.root;
-    const serviceFsResult = await getServiceFs(fs, name, root);
-    if (serviceFsResult.error) {
-      errors.push(serviceFsResult.error);
-      continue;
-    }
-    const serviceFs = serviceFsResult.fs;
-    let resolvedEntrypoint;
-    if (typeof serviceConfig.entrypoint === "string" && !isContainerRuntime(serviceConfig)) {
-      const moduleAttr = parsePyModuleAttrEntrypoint(serviceConfig.entrypoint);
-      const entrypointToResolve = moduleAttr?.filePath ?? serviceConfig.entrypoint;
-      const resolvedPath = await resolveEntrypointPath({
-        fs: serviceFs,
-        serviceName: name,
-        entrypoint: entrypointToResolve
-      });
-      if (resolvedPath.error) {
-        errors.push(resolvedPath.error);
-        continue;
-      }
-      resolvedEntrypoint = resolvedPath.entrypoint;
-    }
-    if (resolvedEntrypoint) {
-      const entrypointError = validateServiceEntrypoint(
-        name,
-        serviceConfig,
-        resolvedEntrypoint
-      );
-      if (entrypointError) {
-        errors.push(entrypointError);
-        continue;
-      }
-    }
-    const explicitBackendEntrypointError = validateBackendFileEntrypoint(
-      name,
-      serviceConfig,
-      resolvedEntrypoint,
-      options
-    );
-    if (explicitBackendEntrypointError) {
-      errors.push(explicitBackendEntrypointError);
-      continue;
-    }
-    let resolvedConfig = serviceConfig;
-    if (!serviceConfig.framework && resolvedEntrypoint) {
-      if (resolvedEntrypoint.isDirectory) {
-        const inferredRuntime = (0, import_utils.inferServiceRuntime)({
-          ...serviceConfig
-        });
-        const workspace = resolvedEntrypoint.normalized;
-        const { framework, error } = await detectFrameworkFromWorkspace({
-          fs: serviceFs,
-          workspace,
-          runtime: inferredRuntime,
-          serviceName: name
-        });
-        if (error) {
-          errors.push(error);
-          continue;
-        }
-        if (!framework) {
-          errors.push({
-            code: "MISSING_SERVICE_FRAMEWORK",
-            message: `Service "${name}" uses directory entrypoint "${serviceConfig.entrypoint}" but no framework could be detected in "${workspace}". Specify "framework" explicitly or use a file entrypoint.`,
-            serviceName: name
-          });
-          continue;
-        }
-        resolvedConfig = {
-          ...resolvedConfig,
-          framework
-        };
-      } else {
-        const inferredRuntime = (0, import_utils.inferServiceRuntime)({
-          ...serviceConfig,
-          entrypoint: resolvedEntrypoint.normalized
-        });
-        if (inferredRuntime) {
-          const inferredWorkspace = await inferWorkspaceFromNearestManifest({
-            fs: serviceFs,
-            entrypoint: resolvedEntrypoint.normalized,
-            runtime: inferredRuntime
-          });
-          const workspace = inferredWorkspace ?? import_path.posix.dirname(resolvedEntrypoint.normalized);
-          const detection = await detectFrameworkFromWorkspace({
-            fs: serviceFs,
-            workspace,
-            serviceName: name,
-            runtime: inferredRuntime
-          });
-          if (!detection.error && detection.framework) {
-            resolvedConfig = {
-              ...resolvedConfig,
-              framework: detection.framework
-            };
-          }
-        }
-      }
-    }
-    const backendEntrypointError = validateBackendFileEntrypoint(
-      name,
-      resolvedConfig,
-      resolvedEntrypoint,
-      options
-    );
-    if (backendEntrypointError) {
-      errors.push(backendEntrypointError);
-      continue;
-    }
-    const service = await resolveConfiguredService({
-      name,
-      config: resolvedConfig,
-      serviceFs,
-      root,
-      resolvedEntrypoint,
-      routePrefixSource
-    });
-    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);
-  }
-  const servicesByName = new Map(resolved.map((s) => [s.name, s]));
-  for (const service of resolved) {
-    if (!service.env)
-      continue;
-    validateEnvRefs(service.env, service.name, servicesByName, errors);
-  }
-  return { services: resolved, errors };
-}
-function validateEnvRefs(env, serviceName, servicesByName, errors) {
-  const pathPrefix = `Service "${serviceName}" env`;
-  for (const [envVarName, envVar] of Object.entries(env)) {
-    if (envVar.type !== "service-ref")
-      continue;
-    const refName = envVar.service;
-    const target = servicesByName.get(refName);
-    if (!target) {
-      errors.push({
-        code: "UNKNOWN_SERVICE_REF",
-        message: `${pathPrefix}["${envVarName}"] references unknown service "${refName}".`,
-        serviceName
-      });
-      continue;
-    }
-    if (target.type !== "web") {
-      errors.push({
-        code: "INVALID_SERVICE_REF_TYPE",
-        message: `${pathPrefix}["${envVarName}"] references service "${refName}" which is a ${target.type} service and has no URL. Only web services can be referenced.`,
-        serviceName
-      });
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  detectFrameworkFromWorkspace,
-  getServiceFs,
-  inferWorkspaceFromNearestManifest,
-  parsePyModuleAttrEntrypoint,
-  resolveAllConfiguredServices,
-  resolveConfiguredService,
-  resolveEntrypointPath,
-  validateServiceConfig,
-  validateServiceEntrypoint
-});