vercel 59.11.2 → 59.11.7

package/dist/chunks/chunk-UARGTFCT.js

@@ -0,0 +1,875 @@
+import { createRequire as __createRequire } from 'node:module';
+import { fileURLToPath as __fileURLToPath } from 'node:url';
+import { dirname as __dirname_ } from 'node:path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_(__filename);
+import {
+  require_dist as require_dist2,
+  require_dist2 as require_dist3
+} from "./chunk-332LMJLZ.js";
+import {
+  require_dist
+} from "./chunk-G3PXSXIB.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../internals/service-topology/dist/index.js
+var require_dist4 = __commonJS({
+  "../../internals/service-topology/dist/index.js"(exports, module) {
+    "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 src_exports = {};
+    __export(src_exports, {
+      INTERNAL_SERVICE_PREFIX: () => import_fs_detectors2.INTERNAL_SERVICE_PREFIX,
+      autoDetectServices: () => import_fs_detectors2.autoDetectServices,
+      detectServices: () => import_fs_detectors2.detectServices,
+      generateServiceRewrites: () => import_fs_detectors2.generateServiceRewrites,
+      generateServicesRoutes: () => import_fs_detectors2.generateServicesRoutes,
+      getInternalServiceCronPath: () => import_fs_detectors2.getInternalServiceCronPath,
+      getInternalServiceCronPathPrefix: () => import_fs_detectors2.getInternalServiceCronPathPrefix,
+      getInternalServiceFunctionPath: () => import_fs_detectors2.getInternalServiceFunctionPath,
+      getInternalServiceWorkerPath: () => import_fs_detectors2.getInternalServiceWorkerPath,
+      getInternalServiceWorkerPathPrefix: () => import_fs_detectors2.getInternalServiceWorkerPathPrefix,
+      isExperimentalService: () => import_fs_detectors2.isExperimentalService,
+      isExperimentalServiceV2: () => import_fs_detectors2.isExperimentalServiceV2,
+      isRouteOwningBuilder: () => import_fs_detectors2.isRouteOwningBuilder,
+      isStaticBuild: () => import_fs_detectors2.isStaticBuild,
+      resolveAllConfiguredServicesV2: () => import_fs_detectors2.resolveAllConfiguredServicesV2,
+      resolveConfiguredServiceV2: () => import_fs_detectors2.resolveConfiguredServiceV2,
+      validateServiceConfigV2: () => import_fs_detectors2.validateServiceConfigV2
+    });
+    module.exports = __toCommonJS(src_exports);
+    var import_fs_detectors2 = require_dist3();
+  }
+});
+
+// src/util/validate-config.ts
+var import_routing_utils = __toESM(require_dist2(), 1);
+var import_client = __toESM(require_dist(), 1);
+var import_fs_detectors = __toESM(require_dist3(), 1);
+import {
+  getFunctionsSchema,
+  buildsSchema,
+  getMaxDurationSchema,
+  NowBuildError,
+  getPrettyError
+} from "@vercel/build-utils";
+import { getConfigValidator } from "./config-validator.mjs";
+var imagesSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["sizes"],
+  properties: {
+    contentDispositionType: {
+      enum: ["inline", "attachment"]
+    },
+    contentSecurityPolicy: {
+      type: "string",
+      minLength: 1,
+      maxLength: 256
+    },
+    dangerouslyAllowSVG: {
+      type: "boolean"
+    },
+    domains: {
+      type: "array",
+      minItems: 0,
+      maxItems: 50,
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 256
+      }
+    },
+    formats: {
+      type: "array",
+      minItems: 1,
+      maxItems: 4,
+      items: {
+        enum: ["image/avif", "image/webp", "image/jpeg", "image/png"]
+      }
+    },
+    localPatterns: {
+      type: "array",
+      minItems: 0,
+      maxItems: 25,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          pathname: {
+            type: "string",
+            minLength: 1,
+            maxLength: 256
+          },
+          search: {
+            type: "string",
+            minLength: 0,
+            maxLength: 256
+          }
+        }
+      }
+    },
+    minimumCacheTTL: {
+      type: "integer",
+      minimum: 1,
+      maximum: 31536e4
+    },
+    qualities: {
+      type: "array",
+      minItems: 1,
+      maxItems: 20,
+      items: {
+        type: "integer",
+        minimum: 1,
+        maximum: 100
+      }
+    },
+    remotePatterns: {
+      type: "array",
+      minItems: 0,
+      maxItems: 50,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["hostname"],
+        properties: {
+          protocol: {
+            enum: ["http", "https"]
+          },
+          hostname: {
+            type: "string",
+            minLength: 1,
+            maxLength: 256
+          },
+          port: {
+            type: "string",
+            minLength: 0,
+            maxLength: 5
+          },
+          pathname: {
+            type: "string",
+            minLength: 1,
+            maxLength: 256
+          },
+          search: {
+            type: "string",
+            minLength: 0,
+            maxLength: 256
+          }
+        }
+      }
+    },
+    sizes: {
+      type: "array",
+      minItems: 1,
+      maxItems: 50,
+      items: {
+        type: "number"
+      }
+    }
+  }
+};
+var cronsSchema = {
+  type: "array",
+  minItems: 0,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["path", "schedule"],
+    properties: {
+      path: {
+        type: "string",
+        minLength: 1,
+        maxLength: 512,
+        pattern: "^/.*"
+      },
+      schedule: {
+        type: "string",
+        minLength: 9,
+        maxLength: 256
+      }
+    }
+  }
+};
+var schedulesSchema = {
+  type: "array",
+  minItems: 0,
+  maxItems: 100,
+  items: {
+    type: "object",
+    additionalProperties: false,
+    required: ["expression", "target", "name"],
+    properties: {
+      expression: {
+        type: "object",
+        additionalProperties: false,
+        required: ["cron"],
+        properties: {
+          cron: {
+            type: "string"
+          },
+          jitter: {
+            type: "string",
+            minLength: 1,
+            maxLength: 256
+          }
+        }
+      },
+      target: {
+        oneOf: [
+          {
+            type: "object",
+            additionalProperties: false,
+            required: ["function"],
+            properties: {
+              function: {
+                type: "string",
+                minLength: 1
+              }
+            }
+          },
+          {
+            type: "object",
+            additionalProperties: false,
+            required: ["topic"],
+            properties: {
+              topic: {
+                type: "string",
+                minLength: 1,
+                maxLength: 256
+              }
+            }
+          }
+        ]
+      },
+      name: {
+        type: "string",
+        minLength: 1,
+        maxLength: 256
+      },
+      payload: {}
+    }
+  }
+};
+var experimentalServicesMountSchema = {
+  oneOf: [
+    {
+      type: "string",
+      minLength: 1,
+      maxLength: 512
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        path: {
+          type: "string",
+          minLength: 1,
+          maxLength: 512
+        },
+        subdomain: {
+          type: "string",
+          minLength: 1,
+          maxLength: 63
+        }
+      },
+      anyOf: [{ required: ["path"] }, { required: ["subdomain"] }]
+    }
+  ]
+};
+var staticExperimentalServiceScheduleSchema = {
+  type: "string",
+  minLength: 9,
+  maxLength: 256,
+  not: { const: "<dynamic>" }
+};
+var experimentalServiceScheduleSchema = {
+  oneOf: [
+    {
+      type: "string",
+      minLength: 9,
+      maxLength: 256
+    },
+    {
+      type: "array",
+      minItems: 1,
+      items: staticExperimentalServiceScheduleSchema
+    }
+  ]
+};
+var experimentalServiceQueueTopicSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["topic"],
+  properties: {
+    topic: {
+      type: "string",
+      minLength: 1,
+      maxLength: 256
+    },
+    retryAfterSeconds: {
+      type: "integer",
+      minimum: 1,
+      maximum: 86400
+    },
+    initialDelaySeconds: {
+      type: "integer",
+      minimum: 0,
+      maximum: 86400
+    }
+  }
+};
+var experimentalServiceTopicsSchema = {
+  oneOf: [
+    {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "string",
+        minLength: 1,
+        maxLength: 256
+      }
+    },
+    {
+      type: "array",
+      minItems: 1,
+      items: experimentalServiceQueueTopicSchema
+    }
+  ]
+};
+var envVarNamesSchema = {
+  pattern: "^[A-Za-z_][A-Za-z0-9_]*$",
+  maxLength: 256
+};
+var getExperimentalServicesCommonProperties = () => ({
+  entrypoint: {
+    type: "string",
+    minLength: 1,
+    maxLength: 512
+  },
+  root: {
+    type: "string",
+    minLength: 1,
+    maxLength: 512
+  },
+  workspace: {
+    type: "string",
+    minLength: 1,
+    maxLength: 512
+  },
+  framework: {
+    type: "string",
+    minLength: 1,
+    maxLength: 256
+  },
+  builder: {
+    type: "string",
+    minLength: 1,
+    maxLength: 256
+  },
+  runtime: {
+    type: "string",
+    minLength: 1,
+    maxLength: 256
+  },
+  buildCommand: {
+    type: "string",
+    minLength: 1,
+    maxLength: 2048
+  },
+  installCommand: {
+    type: "string",
+    minLength: 1,
+    maxLength: 2048
+  },
+  preDeployCommand: {
+    type: "string",
+    minLength: 1,
+    maxLength: 2048
+  },
+  command: {
+    oneOf: [
+      { type: "string", minLength: 1, maxLength: 2048 },
+      {
+        type: "array",
+        minItems: 1,
+        items: { type: "string", minLength: 1, maxLength: 2048 }
+      }
+    ]
+  },
+  memory: {
+    type: "integer",
+    minimum: 128,
+    maximum: 10240
+  },
+  maxDuration: getMaxDurationSchema(),
+  includeFiles: {
+    oneOf: [
+      { type: "string", minLength: 1 },
+      {
+        type: "array",
+        items: { type: "string", minLength: 1 }
+      }
+    ]
+  },
+  excludeFiles: {
+    oneOf: [
+      { type: "string", minLength: 1 },
+      {
+        type: "array",
+        items: { type: "string", minLength: 1 }
+      }
+    ]
+  }
+});
+var experimentalServicesRoutableProperties = {
+  mount: experimentalServicesMountSchema,
+  routePrefix: {
+    type: "string",
+    minLength: 1,
+    maxLength: 512
+  },
+  subdomain: {
+    type: "string",
+    minLength: 1,
+    maxLength: 63
+  }
+};
+var getExperimentalServicesServiceConfigSchema = () => ({
+  oneOf: [
+    {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        ...getExperimentalServicesCommonProperties(),
+        ...experimentalServicesRoutableProperties,
+        type: {
+          enum: ["web"]
+        }
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["type", "trigger", "schedule"],
+      properties: {
+        ...getExperimentalServicesCommonProperties(),
+        type: {
+          const: "job"
+        },
+        trigger: {
+          const: "schedule"
+        },
+        schedule: experimentalServiceScheduleSchema
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["type", "trigger", "topics"],
+      properties: {
+        ...getExperimentalServicesCommonProperties(),
+        type: {
+          const: "job"
+        },
+        trigger: {
+          const: "queue"
+        },
+        topics: experimentalServiceTopicsSchema,
+        consumer: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256
+        }
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["type", "trigger", "entrypoint"],
+      properties: {
+        ...getExperimentalServicesCommonProperties(),
+        type: {
+          const: "job"
+        },
+        trigger: {
+          const: "workflow"
+        }
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["type"],
+      properties: {
+        ...getExperimentalServicesCommonProperties(),
+        type: {
+          const: "worker"
+        },
+        topics: {
+          type: "array",
+          items: {
+            type: "string",
+            minLength: 1,
+            maxLength: 256
+          },
+          minItems: 1
+        },
+        consumer: {
+          type: "string",
+          minLength: 1,
+          maxLength: 256
+        }
+      }
+    },
+    {
+      type: "object",
+      additionalProperties: false,
+      required: ["type", "schedule"],
+      properties: {
+        ...getExperimentalServicesCommonProperties(),
+        type: {
+          const: "cron"
+        },
+        schedule: experimentalServiceScheduleSchema
+      }
+    }
+  ]
+});
+var getExperimentalServicesSchema = () => ({
+  type: "object",
+  propertyNames: {
+    pattern: "^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$",
+    maxLength: 64
+  },
+  additionalProperties: getExperimentalServicesServiceConfigSchema()
+});
+var experimentalServiceGroupsSchema = {
+  type: "object",
+  propertyNames: {
+    pattern: "^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$",
+    maxLength: 64
+  },
+  additionalProperties: {
+    type: "array",
+    items: {
+      type: "string",
+      minLength: 1,
+      maxLength: 256
+    }
+  }
+};
+var servicesPathSchema = {
+  type: "string",
+  minLength: 1,
+  maxLength: 512
+};
+var servicesCommandSchema = {
+  type: "string",
+  minLength: 1,
+  maxLength: 2048
+};
+var servicesServiceNamePattern = "^[a-z]([a-z_-]*[a-z])?$";
+var servicesBindingSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["service", "format", "env"],
+  properties: {
+    type: {
+      description: "Optional binding type marker. Currently the only supported type is `service`. When present this must be `service`.",
+      const: "service"
+    },
+    service: {
+      type: "string",
+      minLength: 1,
+      maxLength: 64,
+      pattern: servicesServiceNamePattern
+    },
+    format: { const: "url" },
+    env: {
+      type: "string",
+      ...envVarNamesSchema
+    }
+  }
+};
+var servicesBindingsSchema = {
+  type: "array",
+  maxItems: 100,
+  items: servicesBindingSchema
+};
+var getServicesServiceConfigSchema = () => ({
+  type: "object",
+  additionalProperties: false,
+  required: ["root"],
+  properties: {
+    root: servicesPathSchema,
+    framework: {
+      type: "string",
+      minLength: 1,
+      maxLength: 256
+    },
+    runtime: {
+      type: "string",
+      minLength: 1,
+      maxLength: 256
+    },
+    entrypoint: servicesPathSchema,
+    command: {
+      oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+    },
+    installCommand: servicesCommandSchema,
+    buildCommand: servicesCommandSchema,
+    devCommand: servicesCommandSchema,
+    ignoreCommand: servicesCommandSchema,
+    outputDirectory: servicesPathSchema,
+    bindings: servicesBindingsSchema,
+    functions: getFunctionsSchema(),
+    headers: import_routing_utils.headersSchema,
+    redirects: import_routing_utils.redirectsSchema,
+    rewrites: import_routing_utils.rewritesSchema,
+    routes: import_routing_utils.routesSchema,
+    cleanUrls: import_routing_utils.cleanUrlsSchema,
+    trailingSlash: import_routing_utils.trailingSlashSchema
+  }
+});
+var getServicesSchema = () => ({
+  type: "object",
+  propertyNames: {
+    pattern: servicesServiceNamePattern,
+    maxLength: 64
+  },
+  additionalProperties: getServicesServiceConfigSchema()
+});
+var proxySchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["entrypoint"],
+  properties: {
+    entrypoint: {
+      type: "string",
+      minLength: 1
+    },
+    matcher: {
+      oneOf: [
+        {
+          type: "string",
+          minLength: 1
+        },
+        {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            minLength: 1
+          }
+        }
+      ]
+    }
+  }
+};
+function buildVercelConfigSchema() {
+  return {
+    type: "object",
+    // These are not all possibilities because `vc dev`
+    // doesn't need to know about `regions`, `public`, etc.
+    additionalProperties: true,
+    properties: {
+      builds: buildsSchema,
+      routes: import_routing_utils.routesSchema,
+      cleanUrls: import_routing_utils.cleanUrlsSchema,
+      headers: import_routing_utils.headersSchema,
+      redirects: import_routing_utils.redirectsSchema,
+      rewrites: import_routing_utils.rewritesSchema,
+      trailingSlash: import_routing_utils.trailingSlashSchema,
+      functions: getFunctionsSchema(),
+      images: imagesSchema,
+      crons: cronsSchema,
+      schedules: schedulesSchema,
+      bunVersion: { type: "string" },
+      proxy: proxySchema,
+      experimentalServices: getExperimentalServicesSchema(),
+      experimentalServiceGroups: experimentalServiceGroupsSchema,
+      services: getServicesSchema(),
+      experimentalServicesV2: getServicesSchema()
+    }
+  };
+}
+function validateConfig(config) {
+  const validate = getConfigValidator(buildVercelConfigSchema);
+  if (!validate(config)) {
+    if (validate.errors && validate.errors[0]) {
+      const error = validate.errors[0];
+      const fileName = config[import_client.fileNameSymbol] || "vercel.json";
+      const niceError = getPrettyError(error);
+      niceError.message = `Invalid ${fileName} - ${niceError.message}`;
+      return niceError;
+    }
+  }
+  for (const [pattern, fn] of Object.entries(config.functions ?? {})) {
+    if (fn.affinity !== void 0) {
+      return new NowBuildError({
+        code: "FUNCTION_AFFINITY_REQUIRES_SERVICE",
+        message: `Function affinity can only be configured under a service. Move functions[${JSON.stringify(
+          pattern
+        )}].affinity into the relevant service's functions configuration.`,
+        link: "https://vercel.com/docs/concepts/projects/project-configuration#functions"
+      });
+    }
+  }
+  const functionMaps = [
+    config.functions,
+    ...Object.values(config.services ?? {}).map((service) => service.functions),
+    ...Object.values(config.experimentalServicesV2 ?? {}).map(
+      (service) => service.functions
+    )
+  ];
+  for (const functions of functionMaps) {
+    for (const [pattern, fn] of Object.entries(functions ?? {})) {
+      const regions = [...new Set(fn.regions)];
+      if (fn.affinity?.mode === "strict" && (regions.includes("all") || regions.length > 1)) {
+        return new NowBuildError({
+          code: "INVALID_FUNCTION_AFFINITY_REGIONS",
+          message: `Function affinity mode "strict" requires at most one statically configured region. Update \`functions[${JSON.stringify(
+            pattern
+          )}].regions\` to contain a single region.`,
+          link: "https://vercel.com/docs/concepts/projects/project-configuration#functions"
+        });
+      }
+    }
+  }
+  if (config.proxy) {
+    const proxyError = (0, import_fs_detectors.validateProxyConfig)(config.proxy);
+    if (proxyError) {
+      return new NowBuildError({
+        code: proxyError.code.toUpperCase(),
+        message: proxyError.message
+      });
+    }
+  }
+  if (config.functions && config.builds) {
+    return new NowBuildError({
+      code: "FUNCTIONS_AND_BUILDS",
+      message: "The `functions` property cannot be used in conjunction with the `builds` property. Please remove one of them.",
+      link: "https://vercel.link/functions-and-builds"
+    });
+  }
+  if (config.proxy && config.builds) {
+    return new NowBuildError({
+      code: "PROXY_AND_BUILDS",
+      message: "The `proxy` property cannot be used with the `builds` property. Remove `builds` to use an explicit proxy entrypoint."
+    });
+  }
+  const hasExperimentalServices = Boolean(config.experimentalServices);
+  if (hasExperimentalServices && config.builds) {
+    return new NowBuildError({
+      code: "EXPERIMENTAL_SERVICES_AND_BUILDS",
+      message: "The `experimentalServices` property cannot be used in conjunction with the `builds` property. Please remove one of them."
+    });
+  }
+  if (hasExperimentalServices && config.functions) {
+    return new NowBuildError({
+      code: "EXPERIMENTAL_SERVICES_AND_FUNCTIONS",
+      message: "The `experimentalServices` property cannot be used in conjunction with the `functions` property. Please remove one of them."
+    });
+  }
+  if (config.experimentalServiceGroups && !config.experimentalServices) {
+    return new NowBuildError({
+      code: "SERVICE_GROUPS_WITHOUT_SERVICES",
+      message: "The `experimentalServiceGroups` property requires `experimentalServices` to be defined. Service groups reference services by name."
+    });
+  }
+  const hasServices = config.services != null;
+  const hasExperimentalServicesV2 = config.experimentalServicesV2 != null;
+  if (hasServices && hasExperimentalServicesV2) {
+    return new NowBuildError({
+      code: "SERVICES_AND_EXPERIMENTAL_SERVICES_V2",
+      message: "The `services` property cannot be used in conjunction with its deprecated alias `experimentalServicesV2`. Please use only `services`."
+    });
+  }
+  const servicesConfig = config.services ?? config.experimentalServicesV2;
+  const servicesConfigKey = hasServices ? "services" : "experimentalServicesV2";
+  const servicesErrorCodePrefix = hasServices ? "SERVICES" : "EXPERIMENTAL_SERVICES_V2";
+  if (servicesConfig && hasExperimentalServices) {
+    return new NowBuildError({
+      code: `${servicesErrorCodePrefix}_AND_EXPERIMENTAL_SERVICES`,
+      message: `The \`${servicesConfigKey}\` property cannot be used in conjunction with the \`experimentalServices\` property. Please use only one services configuration.`
+    });
+  }
+  if (servicesConfig && config.builds) {
+    return new NowBuildError({
+      code: `${servicesErrorCodePrefix}_AND_BUILDS`,
+      message: `The \`${servicesConfigKey}\` property cannot be used in conjunction with the \`builds\` property. Please remove one of them.`
+    });
+  }
+  if (servicesConfig) {
+    const ambiguousTopLevel = [];
+    if (config.functions != null) {
+      ambiguousTopLevel.push("functions");
+    }
+    if (config.installCommand != null) {
+      ambiguousTopLevel.push("installCommand");
+    }
+    if (config.buildCommand != null) {
+      ambiguousTopLevel.push("buildCommand");
+    }
+    if (config.devCommand != null) {
+      ambiguousTopLevel.push("devCommand");
+    }
+    if (config.ignoreCommand != null) {
+      ambiguousTopLevel.push("ignoreCommand");
+    }
+    if (config.outputDirectory != null) {
+      ambiguousTopLevel.push("outputDirectory");
+    }
+    if (config.framework != null) {
+      ambiguousTopLevel.push("framework");
+    }
+    if (ambiguousTopLevel.length > 0) {
+      const count = ambiguousTopLevel.length;
+      const fields = ambiguousTopLevel.map((field) => `\`${field}\``).join(", ");
+      return new NowBuildError({
+        code: `${servicesErrorCodePrefix}_AND_TOP_LEVEL_BUILD_SETTINGS`,
+        message: `The top-level ${count > 1 ? "properties" : "property"} ${fields} cannot be used with \`${servicesConfigKey}\` because the owning service is ambiguous. Move ${count > 1 ? "them" : "it"} under the relevant service in \`${servicesConfigKey}\`.`
+      });
+    }
+  }
+  if (servicesConfig) {
+    const serviceNames = new Set(Object.keys(servicesConfig));
+    for (const [serviceName, serviceConfig] of Object.entries(servicesConfig)) {
+      for (const binding of serviceConfig.bindings ?? []) {
+        if (!serviceNames.has(binding.service)) {
+          return new NowBuildError({
+            code: `${servicesErrorCodePrefix}_BINDING_UNKNOWN_SERVICE`,
+            message: `Service "${serviceName}" declares a binding to unknown service "${binding.service}". Add "${binding.service}" to \`${servicesConfigKey}\` or fix the binding.`
+          });
+        }
+      }
+    }
+  }
+  return null;
+}
+
+export {
+  require_dist4 as require_dist,
+  validateConfig
+};