@serve.zone/interfaces 31.3.0 → 31.4.0

package/changelog.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 2026-09-16 - 31.4.0
+
+### Features
+
+- Add the cluster ingress contracts, the first under the rule that a contract carries no version
+  suffix and no schema field: the protocol version is the installed package version.
+  `IClusterRouteTable { revision, issuedAt, routes, portRoutes }` is the whole table a cluster's
+  ingress serves, with `IClusterHttpRoute` (hostname, unicast destinations, the certificate that
+  terminates it, optional Basic authentication) and `IClusterPortRoute` (a TCP or UDP listen port
+  forwarded untouched). `revision` is the feed's only idempotency: a relay and an ingress apply a
+  greater revision and ignore anything else, so a repeated, replayed or crossed push settles the
+  same way. `validateClusterRouteTable` returns one named reason per violation, refuses a second
+  route for one hostname and a second port route for one transport and port, and never quotes
+  certificate material or a password in a reason — a reason travels into logs, and this table
+  carries the private key of every hostname the ingress serves.
+- Add the five methods the feed and its counters travel on: `pushClusterRouteTable` (Cloudly →
+  relay), `getClusterRouteTable` (relay → Cloudly), `getClusterIngressRouteTable` (ingress →
+  relay), `registerClusterIngress` and `getClusterTrafficStatistics` (both one body for two hops:
+  ingress → relay → Cloudly, and Cloudly → relay → ingress). An ingress announces itself through a
+  method rather than a connection tag, so what a relay knows about its ingress is what a server
+  owns. A `null` table means Cloudly has computed none yet — a fact, not an empty table.
+- Authorize the ingress where the authority is. The ingress shares the relay's node listener, so
+  anything reaching it could ask to register and a relay cannot tell an ingress from anything
+  else: `registerClusterIngress` carries the `bearer` Cloudly minted into the ingress workload's
+  assignment environment, the relay forwards it untouched, and Cloudly verifies it and derives the
+  cluster from the identity tag on the relay's own session. The bearer is sensitive ephemeral
+  input on every hop and is never quoted in a reason. Isolation on the shared listener is by
+  authorization, not routing: only the connection whose registration Cloudly accepted is the
+  ingress, and every other connection is refused by name.
+  `validateClusterIngressRegistration` checks shape only.
+- Add `IClusterTrafficStatistics`: one UTC day of one hostname's traffic on one node — requests,
+  bytes in and out, connections and the backend connect, handshake and request failures the proxy
+  can observe — paged exactly like CoreMail's mail statistics, down to the `{ statistics,
+  nextCursor? }` response and the `fromDayUtc`/`toDayUtc`/`cursor`/`limit` request, with `dayUtc`
+  checked against the real calendar through the now-shared UTC calendar-day rule (`2026-13-45` is
+  refused rather than stored; CoreMail's own day check consumes the same helper). Day buckets survive a restart, a
+  poll across midnight and a Cloudly outage, which a rate does not. HTTP status classes are
+  deliberately absent: the proxy exposes no status counters today, and a number the contract
+  cannot source would be a guess.
+- Carry the node's own uplink address on the network report it already sends:
+  `IReportRuntimeNetworkProtectionRequestV1` gains the optional `uplinkAddress`, validated by
+  `runtimeNodeUplinkAddress` as a unicast IPv4 literal that is neither loopback nor link-local.
+  A route to that node's published ports uses exactly this address, and only the node can prove
+  it. Absence stays absent, so a node that states none is told apart from one that states a value,
+  and nothing downstream defaults or infers one. Additive: `networkRecord` now admits declared
+  optional keys, and every existing caller passes none.
+
 ## 2026-09-16 - 31.3.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/interfaces',
-    version: '31.3.0',
+    version: '31.4.0',
     description: 'Shared TypeScript interfaces and TypedRequest contracts for the serve.zone ecosystem.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHVGQUF1RjtDQUNyRyxDQUFBIn0=

package/dist_ts/data/clusteringress.d.ts

@@ -0,0 +1,137 @@
+/**
+ * The cluster ingress contracts.
+ *
+ * A cluster's ingress terminates TLS for the hostnames its services publish and
+ * forwards to the host ports Pallet published for the workloads behind them.
+ * Cloudly computes the table — it is the only party that knows every service,
+ * every ready endpoint and every certificate — and the relay carries it to the
+ * ingress and the ingress's counters back.
+ *
+ * Names here carry no version suffix and no schema field: the protocol version
+ * is the installed `@serve.zone/interfaces` version.
+ */
+export declare const clusterIngressLimits: Readonly<{
+    minimumIngressBearerLength: 16;
+    maximumIngressBearerLength: 4096;
+    maximumHostNameLength: 253;
+    maximumRoutes: 4096;
+    maximumPortRoutes: 1024;
+    maximumDestinationsPerRoute: 64;
+    maximumStatisticsPageSize: 1000;
+    maximumCursorLength: 512;
+    maximumIdentifierLength: 200;
+    maximumIngressCapabilities: 32;
+}>;
+/** One backend a route forwards to: an address a node answers on, and its port. */
+export interface IClusterRouteDestination {
+    address: string;
+    port: number;
+}
+/** Basic authentication for a route, as the proxy has always expressed it. */
+export interface IClusterRouteAuthentication {
+    type: 'Basic';
+    user: string;
+    pass: string;
+}
+/**
+ * One hostname the ingress serves.
+ *
+ * `certificate` carries the private key the ingress needs to terminate TLS for
+ * `hostName`. A route table is therefore secret-bearing end to end: it is never
+ * logged, never journaled, never written to disk, and no validation reason
+ * derived from it ever quotes it.
+ */
+export interface IClusterHttpRoute {
+    hostName: string;
+    destinations: IClusterRouteDestination[];
+    certificate: {
+        publicKey: string;
+        privateKey: string;
+    };
+    authentication?: IClusterRouteAuthentication;
+}
+/** One TCP or UDP port the ingress forwards without terminating anything. */
+export interface IClusterPortRoute {
+    name: string;
+    listenPort: number;
+    transport: 'tcp' | 'udp';
+    destinations: IClusterRouteDestination[];
+}
+/**
+ * Everything a cluster's ingress serves, as one table.
+ *
+ * `revision` is the only idempotency the feed has: an ingress and a relay apply
+ * a table whose revision is greater than the one they hold and ignore anything
+ * else, so a repeated push, a replayed push and a push that crossed a newer one
+ * all settle the same way.
+ */
+export interface IClusterRouteTable {
+    revision: number;
+    issuedAt: number;
+    routes: IClusterHttpRoute[];
+    portRoutes: IClusterPortRoute[];
+}
+/**
+ * One day of one hostname's traffic on one node, as the ingress counted it.
+ *
+ * Day buckets rather than rates: a rate answers "how busy is it now", which the
+ * live proxy already answers, while a bucket survives a restart, a poll that
+ * straddles midnight and a Cloudly outage.
+ */
+export interface IClusterTrafficStatistics {
+    serviceId: string;
+    hostName: string;
+    nodeId: string;
+    /** UTC calendar day, `YYYY-MM-DD`. */
+    dayUtc: string;
+    requests: number;
+    bytesIn: number;
+    bytesOut: number;
+    connections: number;
+    /**
+     * What the proxy could observe about its backends. HTTP status classes are
+     * deliberately absent: the proxy exposes no status counters today, and a
+     * number this contract cannot source would be a guess.
+     */
+    backendErrors: {
+        connect: number;
+        handshake: number;
+        request: number;
+    };
+    updatedAt: number;
+}
+/**
+ * A hostname a certificate can be issued for and a browser can present.
+ *
+ * Lowercase labels only, because a certificate names the lowercase form and a
+ * table that carried both would serve one of them without a certificate.
+ */
+export declare const isClusterIngressHostName: (valueArg: unknown) => valueArg is string;
+/**
+ * Validates one route table and names every reason it is refused.
+ *
+ * Shape only. Whether a hostname belongs to the cluster, whether a certificate
+ * matches it, and whether a destination is a node of this cluster are decisions
+ * for the party that computed the table; a table that passes here has claimed
+ * none of them. No reason ever quotes certificate material.
+ */
+export declare const validateClusterRouteTable: (valueArg: unknown, pathArg?: string) => string[];
+/** Validates one day bucket of ingress counters. */
+export declare const validateClusterTrafficStatistics: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * Validates one page of ingress counters, as a reader receives it.
+ *
+ * The cursor is opaque to everyone but the ingress that issued it: bounded and
+ * printable here, meaningful only there.
+ */
+export declare const validateClusterTrafficStatisticsPage: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * Validates one cluster ingress registration and names every reason it is refused.
+ *
+ * Shape only, and deliberately so: whether the bearer is the one Cloudly minted
+ * for this cluster's ingress is Cloudly's to verify against its own records, and
+ * which cluster is speaking comes from the identity tag on the relay's session.
+ * A registration that passes here has proven nothing — and no reason it returns
+ * ever quotes the bearer, because a reason travels into logs.
+ */
+export declare const validateClusterIngressRegistration: (valueArg: unknown, pathArg?: string) => string[];

package/dist_ts/data/clusteringress.js

@@ -0,0 +1,302 @@
+import { isPlausibleUnicastIpv4 } from '../private/ipv4.js';
+import { isUtcCalendarDay } from '../private/utccalendarday.js';
+/**
+ * The cluster ingress contracts.
+ *
+ * A cluster's ingress terminates TLS for the hostnames its services publish and
+ * forwards to the host ports Pallet published for the workloads behind them.
+ * Cloudly computes the table — it is the only party that knows every service,
+ * every ready endpoint and every certificate — and the relay carries it to the
+ * ingress and the ingress's counters back.
+ *
+ * Names here carry no version suffix and no schema field: the protocol version
+ * is the installed `@serve.zone/interfaces` version.
+ */
+export const clusterIngressLimits = Object.freeze({
+    minimumIngressBearerLength: 16,
+    maximumIngressBearerLength: 4096,
+    maximumHostNameLength: 253,
+    maximumRoutes: 4096,
+    maximumPortRoutes: 1024,
+    maximumDestinationsPerRoute: 64,
+    maximumStatisticsPageSize: 1000,
+    maximumCursorLength: 512,
+    maximumIdentifierLength: 200,
+    maximumIngressCapabilities: 32,
+});
+const isRecord = (valueArg) => (Boolean(valueArg)
+    && typeof valueArg === 'object'
+    && !Array.isArray(valueArg)
+    && (Object.getPrototypeOf(valueArg) === Object.prototype
+        || Object.getPrototypeOf(valueArg) === null));
+const hasExactKeys = (valueArg, keysArg, optionalKeysArg = []) => {
+    const actualKeys = Object.keys(valueArg);
+    return keysArg.every((keyArg) => actualKeys.includes(keyArg))
+        && actualKeys.every((keyArg) => keysArg.includes(keyArg) || optionalKeysArg.includes(keyArg));
+};
+const isCounter = (valueArg) => (Number.isSafeInteger(valueArg) && valueArg >= 0);
+const isPort = (valueArg) => (Number.isSafeInteger(valueArg) && valueArg >= 1 && valueArg <= 65_535);
+const hostLabelPattern = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+// Built from the limit rather than beside it, so the two can never disagree.
+const identifierPattern = new RegExp(`^[A-Za-z0-9][A-Za-z0-9:._-]{0,${clusterIngressLimits.maximumIdentifierLength - 1}}$`);
+/**
+ * A hostname a certificate can be issued for and a browser can present.
+ *
+ * Lowercase labels only, because a certificate names the lowercase form and a
+ * table that carried both would serve one of them without a certificate.
+ */
+export const isClusterIngressHostName = (valueArg) => {
+    if (typeof valueArg !== 'string'
+        || valueArg.length === 0
+        || valueArg.length > clusterIngressLimits.maximumHostNameLength) {
+        return false;
+    }
+    const labels = valueArg.split('.');
+    return labels.length >= 2 && labels.every((labelArg) => hostLabelPattern.test(labelArg));
+};
+const validateDestinations = (valueArg, pathArg) => {
+    if (!Array.isArray(valueArg)
+        || valueArg.length === 0
+        || valueArg.length > clusterIngressLimits.maximumDestinationsPerRoute) {
+        return [`${pathArg} must list 1 to `
+                + `${clusterIngressLimits.maximumDestinationsPerRoute} destinations`];
+    }
+    const errors = [];
+    for (const [index, destination] of valueArg.entries()) {
+        const destinationPath = `${pathArg}[${index}]`;
+        if (!isRecord(destination) || !hasExactKeys(destination, ['address', 'port'])) {
+            errors.push(`${destinationPath} must use its exact schema`);
+            continue;
+        }
+        if (!isPlausibleUnicastIpv4(destination.address)) {
+            errors.push(`${destinationPath} address must be a unicast IPv4 literal`);
+        }
+        if (!isPort(destination.port)) {
+            errors.push(`${destinationPath} port must be an integer from 1 to 65535`);
+        }
+    }
+    return errors;
+};
+const validateCertificate = (valueArg, pathArg) => {
+    // Presence and shape only. The material itself is never described in a reason:
+    // a validation message travels into logs, and this one would carry a key.
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['publicKey', 'privateKey'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (typeof valueArg.publicKey !== 'string' || valueArg.publicKey.length === 0) {
+        errors.push(`${pathArg} publicKey must be a non-empty PEM string`);
+    }
+    if (typeof valueArg.privateKey !== 'string' || valueArg.privateKey.length === 0) {
+        errors.push(`${pathArg} privateKey must be a non-empty PEM string`);
+    }
+    return errors;
+};
+const validateAuthentication = (valueArg, pathArg) => {
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['type', 'user', 'pass'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    return valueArg.type === 'Basic'
+        && typeof valueArg.user === 'string' && valueArg.user.length > 0
+        && typeof valueArg.pass === 'string' && valueArg.pass.length > 0
+        ? []
+        : [`${pathArg} must be Basic authentication with a user and a pass`];
+};
+const validateHttpRoute = (valueArg, pathArg) => {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, ['hostName', 'destinations', 'certificate'], ['authentication'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (!isClusterIngressHostName(valueArg.hostName)) {
+        errors.push(`${pathArg} hostName must be a lowercase dotted hostname a certificate can name`);
+    }
+    errors.push(...validateDestinations(valueArg.destinations, `${pathArg} destinations`));
+    errors.push(...validateCertificate(valueArg.certificate, `${pathArg} certificate`));
+    if (valueArg.authentication !== undefined) {
+        errors.push(...validateAuthentication(valueArg.authentication, `${pathArg} authentication`));
+    }
+    return errors;
+};
+const validatePortRoute = (valueArg, pathArg) => {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, ['name', 'listenPort', 'transport', 'destinations'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (typeof valueArg.name !== 'string' || !identifierPattern.test(valueArg.name)) {
+        errors.push(`${pathArg} name must be a bounded identifier`);
+    }
+    if (!isPort(valueArg.listenPort)) {
+        errors.push(`${pathArg} listenPort must be an integer from 1 to 65535`);
+    }
+    if (valueArg.transport !== 'tcp' && valueArg.transport !== 'udp') {
+        errors.push(`${pathArg} transport must be tcp or udp`);
+    }
+    errors.push(...validateDestinations(valueArg.destinations, `${pathArg} destinations`));
+    return errors;
+};
+/**
+ * Validates one route table and names every reason it is refused.
+ *
+ * Shape only. Whether a hostname belongs to the cluster, whether a certificate
+ * matches it, and whether a destination is a node of this cluster are decisions
+ * for the party that computed the table; a table that passes here has claimed
+ * none of them. No reason ever quotes certificate material.
+ */
+export const validateClusterRouteTable = (valueArg, pathArg = 'cluster route table') => {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, ['revision', 'issuedAt', 'routes', 'portRoutes'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (!isCounter(valueArg.revision)) {
+        errors.push(`${pathArg} revision must be a non-negative safe integer`);
+    }
+    if (!Number.isSafeInteger(valueArg.issuedAt) || valueArg.issuedAt <= 0) {
+        errors.push(`${pathArg} issuedAt must be a positive epoch millisecond timestamp`);
+    }
+    if (!Array.isArray(valueArg.routes)
+        || valueArg.routes.length > clusterIngressLimits.maximumRoutes) {
+        errors.push(`${pathArg} routes must list at most ${clusterIngressLimits.maximumRoutes} routes`);
+    }
+    else {
+        const seenHostNames = new Set();
+        for (const [index, route] of valueArg.routes.entries()) {
+            errors.push(...validateHttpRoute(route, `${pathArg} routes[${index}]`));
+            const hostName = isRecord(route) ? route.hostName : undefined;
+            if (typeof hostName === 'string') {
+                if (seenHostNames.has(hostName)) {
+                    errors.push(`${pathArg} routes[${index}] repeats hostName ${hostName}`);
+                }
+                seenHostNames.add(hostName);
+            }
+        }
+    }
+    if (!Array.isArray(valueArg.portRoutes)
+        || valueArg.portRoutes.length > clusterIngressLimits.maximumPortRoutes) {
+        errors.push(`${pathArg} portRoutes must list at most `
+            + `${clusterIngressLimits.maximumPortRoutes} port routes`);
+    }
+    else {
+        const seenPorts = new Set();
+        for (const [index, portRoute] of valueArg.portRoutes.entries()) {
+            errors.push(...validatePortRoute(portRoute, `${pathArg} portRoutes[${index}]`));
+            if (!isRecord(portRoute)) {
+                continue;
+            }
+            const key = `${String(portRoute.transport)}:${String(portRoute.listenPort)}`;
+            if (seenPorts.has(key)) {
+                errors.push(`${pathArg} portRoutes[${index}] repeats ${key}`);
+            }
+            seenPorts.add(key);
+        }
+    }
+    return errors;
+};
+/** Validates one day bucket of ingress counters. */
+export const validateClusterTrafficStatistics = (valueArg, pathArg = 'cluster traffic statistics') => {
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, [
+        'serviceId', 'hostName', 'nodeId', 'dayUtc', 'requests', 'bytesIn', 'bytesOut',
+        'connections', 'backendErrors', 'updatedAt',
+    ])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    for (const key of ['serviceId', 'nodeId']) {
+        const value = valueArg[key];
+        if (typeof value !== 'string' || !identifierPattern.test(value)) {
+            errors.push(`${pathArg} ${key} must be a bounded identifier`);
+        }
+    }
+    if (!isClusterIngressHostName(valueArg.hostName)) {
+        errors.push(`${pathArg} hostName must be a lowercase dotted hostname`);
+    }
+    if (!isUtcCalendarDay(valueArg.dayUtc)) {
+        errors.push(`${pathArg} dayUtc must be a real YYYY-MM-DD UTC calendar day`);
+    }
+    for (const key of ['requests', 'bytesIn', 'bytesOut', 'connections']) {
+        if (!isCounter(valueArg[key])) {
+            errors.push(`${pathArg} ${key} must be a non-negative safe integer`);
+        }
+    }
+    const backendErrors = valueArg.backendErrors;
+    if (!isRecord(backendErrors)
+        || !hasExactKeys(backendErrors, ['connect', 'handshake', 'request'])
+        || !isCounter(backendErrors.connect)
+        || !isCounter(backendErrors.handshake)
+        || !isCounter(backendErrors.request)) {
+        errors.push(`${pathArg} backendErrors must count connect, handshake and request failures`);
+    }
+    if (!Number.isSafeInteger(valueArg.updatedAt) || valueArg.updatedAt <= 0) {
+        errors.push(`${pathArg} updatedAt must be a positive epoch millisecond timestamp`);
+    }
+    return errors;
+};
+/**
+ * Validates one page of ingress counters, as a reader receives it.
+ *
+ * The cursor is opaque to everyone but the ingress that issued it: bounded and
+ * printable here, meaningful only there.
+ */
+export const validateClusterTrafficStatisticsPage = (valueArg, pathArg = 'cluster traffic statistics page') => {
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['statistics'], ['nextCursor'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (!Array.isArray(valueArg.statistics)
+        || valueArg.statistics.length > clusterIngressLimits.maximumStatisticsPageSize) {
+        errors.push(`${pathArg} statistics must list at most `
+            + `${clusterIngressLimits.maximumStatisticsPageSize} entries`);
+    }
+    else {
+        for (const [index, item] of valueArg.statistics.entries()) {
+            errors.push(...validateClusterTrafficStatistics(item, `${pathArg} statistics[${index}]`));
+        }
+    }
+    if (valueArg.nextCursor !== undefined
+        && (typeof valueArg.nextCursor !== 'string'
+            || valueArg.nextCursor.length === 0
+            || valueArg.nextCursor.length > clusterIngressLimits.maximumCursorLength)) {
+        errors.push(`${pathArg} nextCursor must be 1 to `
+            + `${clusterIngressLimits.maximumCursorLength} characters when present`);
+    }
+    return errors;
+};
+/**
+ * Validates one cluster ingress registration and names every reason it is refused.
+ *
+ * Shape only, and deliberately so: whether the bearer is the one Cloudly minted
+ * for this cluster's ingress is Cloudly's to verify against its own records, and
+ * which cluster is speaking comes from the identity tag on the relay's session.
+ * A registration that passes here has proven nothing — and no reason it returns
+ * ever quotes the bearer, because a reason travels into logs.
+ */
+export const validateClusterIngressRegistration = (valueArg, pathArg = 'cluster ingress registration') => {
+    if (!isRecord(valueArg)
+        || !hasExactKeys(valueArg, ['bearer', 'version', 'nodeId'], ['capabilities'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (typeof valueArg.bearer !== 'string'
+        || valueArg.bearer.length < clusterIngressLimits.minimumIngressBearerLength
+        || valueArg.bearer.length > clusterIngressLimits.maximumIngressBearerLength) {
+        errors.push(`${pathArg} bearer must be ${clusterIngressLimits.minimumIngressBearerLength} to `
+            + `${clusterIngressLimits.maximumIngressBearerLength} characters`);
+    }
+    if (typeof valueArg.version !== 'string' || !identifierPattern.test(valueArg.version)) {
+        errors.push(`${pathArg} version must be a bounded identifier`);
+    }
+    if (typeof valueArg.nodeId !== 'string' || !identifierPattern.test(valueArg.nodeId)) {
+        errors.push(`${pathArg} nodeId must be a bounded identifier`);
+    }
+    if (valueArg.capabilities !== undefined
+        && (!Array.isArray(valueArg.capabilities)
+            || valueArg.capabilities.length > clusterIngressLimits.maximumIngressCapabilities
+            || !valueArg.capabilities.every((capabilityArg) => (typeof capabilityArg === 'string' && identifierPattern.test(capabilityArg))))) {
+        errors.push(`${pathArg} capabilities must be at most `
+            + `${clusterIngressLimits.maximumIngressCapabilities} bounded identifiers when present`);
+    }
+    return errors;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusteringress.js","sourceRoot":"","sources":["../../ts/data/clusteringress.ts"],"names":[],"mappings":"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"}