@vercel/fs-detectors 7.1.7 → 7.2.0

package/dist/services/resolve.js

@@ -0,0 +1,901 @@
+"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,
+  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_constants = require("./runtimes/constants");
+var import_framework = require("./runtimes/framework");
+var import_runtime = require("./runtimes/runtime");
+var import_entrypoint = require("./runtimes/entrypoint");
+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 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_entrypoint.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_constants.RUNTIME_BUILDERS) {
+    return config.runtime;
+  }
+  return (0, import_framework.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 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_constants.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_framework.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_constants.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_framework.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_runtime.inferRuntime)({
+      ...config,
+      entrypoint: resolvedEntrypoint.normalized
+    });
+    if (!runtime) {
+      const supported = Object.keys(import_constants.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" ? (0, import_entrypoint.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 && (0, import_entrypoint.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_runtime.inferRuntime)({
+    ...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_runtime.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_constants.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 = (0, import_entrypoint.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_runtime.inferRuntime)({
+          ...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_runtime.inferRuntime)({
+          ...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,
+  resolveAllConfiguredServices,
+  resolveConfiguredService,
+  resolveEntrypointPath,
+  validateServiceConfig,
+  validateServiceEntrypoint
+});