@serve.zone/interfaces 32.2.0 → 32.4.0

package/dist_ts/data/clustervpn.d.ts

@@ -0,0 +1,135 @@
+/**
+ * One workload prefix a node owns inside its cluster's managed VPN, and the policy domain that
+ * names it in a grant. Both are Cloudly's words: the relay matches them, it never invents one.
+ */
+export interface IClusterVpnNetworkPrefix {
+    cidr: string;
+    policyDomain: string;
+}
+/**
+ * One member of a cluster's managed VPN.
+ *
+ * Membership is presence: a node the network does not list is not a member, so there is no
+ * disabled state to carry. `publicKey` is the node's own Noise public key, the one Cloudly issued
+ * the node's credential for, and `expiresAt` is that credential's expiry in Unix milliseconds — the
+ * hub stops relaying for a member whose window ended even if nothing pushes a new network.
+ */
+export interface IClusterVpnNetworkNode {
+    nodeId: string;
+    publicKey: string;
+    controlAddress: string;
+    expiresAt: number;
+    workloadPrefixes: IClusterVpnNetworkPrefix[];
+}
+/** One directed relay permission between two workload policy domains of two different nodes. */
+export interface IClusterVpnNetworkGrant {
+    sourceDomain: string;
+    destinationDomain: string;
+}
+/**
+ * The complete managed VPN of one cluster, as Cloudly states it to that cluster's relay.
+ *
+ * Complete, never a patch: a relay applies it as the whole authority its hub serves, so a member or
+ * a grant that is missing is withdrawn. `revision` is Cloudly's own counter for this authority and
+ * only ever rises; `authorityId` names the authority the hub is bound to, so a network compiled for
+ * another cluster is refused rather than applied.
+ */
+export interface IClusterVpnNetwork {
+    authorityId: string;
+    revision: number;
+    nodes: IClusterVpnNetworkNode[];
+    grants: IClusterVpnNetworkGrant[];
+}
+export declare const clusterVpnNetworkContract: Readonly<{
+    /** The policy domain of a node's control address; the hub relays no grant between control domains. */
+    readonly controlPolicyDomainPrefix: "control:";
+    /** The policy domain of one workload lease, named by that lease's digest. */
+    readonly workloadPolicyDomainPrefix: "workload:";
+    readonly maximumNodes: 256;
+    /** Per node; one workload lease the node's signed projection carries. */
+    readonly maximumWorkloadPrefixes: 128;
+    readonly maximumGrants: 4096;
+    readonly maximumCanonicalBytes: 917504;
+    readonly completeness: "whole-authority-never-a-patch";
+    readonly membership: "presence-only-an-absent-node-is-withdrawn";
+}>;
+/**
+ * Every reason a relay refuses a pushed network, in the words the refusal leads with.
+ *
+ * A push is applied to a daemon whose lifetime Cloudly cannot see, so the refusal is the only
+ * statement about whether the cluster's hub carries this authority. The relay writes
+ * `<name>: <reason>` and Cloudly matches the name, which is why the names are stated here instead
+ * of being spelled out on both sides.
+ */
+export declare const applyClusterVpnNetworkRefusals: readonly ["vpn-network-authority-foreign", "vpn-network-revision-stale"];
+/** One of the reasons a relay states that its hub did not take a network over. */
+export type TApplyClusterVpnNetworkRefusal = typeof applyClusterVpnNetworkRefusals[number];
+/**
+ * Every reason Cloudly states that a cluster has no managed VPN to push.
+ *
+ * Both are Cloudly reading its own records: a hub it cannot select, and a grant it cannot compile
+ * because hubs are per cluster and a grant whose two ends sit in different clusters has no path
+ * through any one of them.
+ */
+export declare const clusterVpnNetworkSelectionRefusals: readonly ["relay-vpn-hub-absent", "grant-cross-cluster-unsupported"];
+/** One of the reasons Cloudly states that it compiled no managed VPN for a cluster. */
+export type TClusterVpnNetworkSelectionRefusal = typeof clusterVpnNetworkSelectionRefusals[number];
+/** What a pushed network did to the cluster's hub, in the hub's own words. */
+export type TClusterVpnNetworkState = 'idle' | 'applying' | 'failed';
+export interface IApplyClusterVpnNetworkRequest {
+    network: IClusterVpnNetwork;
+}
+/**
+ * What the relay answers: the revision its hub has applied, or `null` while it has applied none,
+ * and what the hub is doing. `idle` means the pushed revision is the applied one.
+ */
+export interface IApplyClusterVpnNetworkResponse {
+    appliedRevision: number | null;
+    state: TClusterVpnNetworkState;
+}
+/**
+ * The pull carries no body. The relay's own socket names the cluster, and a hub daemon that just
+ * started holds nothing it could state about what it is missing.
+ */
+export type TGetClusterVpnNetworkRequest = Record<string, never>;
+/** `null` while the cluster has no managed VPN: no address plan, or no hub selected for it yet. */
+export interface IGetClusterVpnNetworkResponse {
+    network: IClusterVpnNetwork | null;
+}
+/** The policy domain of one node's control address. One rule, so both sides name it identically. */
+export declare const clusterVpnControlPolicyDomain: (addressValue: unknown) => string;
+/** The policy domain of one workload lease, from that lease's canonical digest. */
+export declare const clusterVpnWorkloadPolicyDomain: (digestValue: unknown) => string;
+/**
+ * Structural snapshot of a complete cluster network.
+ *
+ * Every node, prefix and grant is stated once and in canonical order, and every grant names a
+ * workload domain this network itself carries, on two different nodes. That last rule is what a
+ * per-cluster hub means: a grant whose other end sits on another cluster's hub cannot be expressed
+ * here at all, which is why Cloudly refuses it by name while it compiles instead of pushing it.
+ */
+export declare const snapshotClusterVpnNetwork: (value: unknown) => IClusterVpnNetwork;
+export type TClusterVpnNetworkAdmission = {
+    status: 'accepted';
+} | {
+    status: 'replay';
+} | {
+    status: 'refused';
+    reason: TApplyClusterVpnNetworkRefusal;
+};
+/**
+ * The pure decision a relay makes about a pushed network against the one its hub holds, or null
+ * when the hub holds none — which is every hub that just started, because a daemon restart starts
+ * empty. A repeat of the held network is a replay the relay may apply again without effect; a lower
+ * revision, or the same revision with different content, is stale and refused by name.
+ */
+export declare const admitClusterVpnNetwork: (heldValue: unknown | null, nextValue: unknown) => TClusterVpnNetworkAdmission;
+export declare const snapshotApplyClusterVpnNetworkRequest: (value: unknown) => IApplyClusterVpnNetworkRequest;
+export declare const snapshotApplyClusterVpnNetworkResponse: (value: unknown) => IApplyClusterVpnNetworkResponse;
+/**
+ * Compare the answer with the exact SENT network: a hub that reports itself idle has applied the
+ * revision it was sent, and no hub can report having applied a later one than exists.
+ */
+export declare const bindApplyClusterVpnNetworkResponse: (value: unknown, sentRequestValue: unknown) => IApplyClusterVpnNetworkResponse;
+export declare const snapshotGetClusterVpnNetworkRequest: (value: unknown) => TGetClusterVpnNetworkRequest;
+export declare const snapshotGetClusterVpnNetworkResponse: (value: unknown) => IGetClusterVpnNetworkResponse;

package/dist_ts/data/clustervpn.js

@@ -0,0 +1,147 @@
+import { captureNetwork, failNetwork, networkCanonical, networkCounter, networkEqual, networkId, networkIpv4, networkList, networkNoiseKey, networkPrivatePrefix, networkRecord, networkSafe, networkSorted, requireNetwork } from '../private/networkcontract.js';
+export const clusterVpnNetworkContract = Object.freeze({
+    /** The policy domain of a node's control address; the hub relays no grant between control domains. */
+    controlPolicyDomainPrefix: 'control:',
+    /** The policy domain of one workload lease, named by that lease's digest. */
+    workloadPolicyDomainPrefix: 'workload:',
+    maximumNodes: 256,
+    /** Per node; one workload lease the node's signed projection carries. */
+    maximumWorkloadPrefixes: 128,
+    maximumGrants: 4096,
+    maximumCanonicalBytes: 917_504,
+    completeness: 'whole-authority-never-a-patch',
+    membership: 'presence-only-an-absent-node-is-withdrawn',
+});
+/**
+ * Every reason a relay refuses a pushed network, in the words the refusal leads with.
+ *
+ * A push is applied to a daemon whose lifetime Cloudly cannot see, so the refusal is the only
+ * statement about whether the cluster's hub carries this authority. The relay writes
+ * `<name>: <reason>` and Cloudly matches the name, which is why the names are stated here instead
+ * of being spelled out on both sides.
+ */
+export const applyClusterVpnNetworkRefusals = Object.freeze([
+    /** The network names another authority than the one this cluster's hub is bound to. */
+    'vpn-network-authority-foreign',
+    /** A revision the hub has already passed, or the same revision with different content. */
+    'vpn-network-revision-stale',
+]);
+/**
+ * Every reason Cloudly states that a cluster has no managed VPN to push.
+ *
+ * Both are Cloudly reading its own records: a hub it cannot select, and a grant it cannot compile
+ * because hubs are per cluster and a grant whose two ends sit in different clusters has no path
+ * through any one of them.
+ */
+export const clusterVpnNetworkSelectionRefusals = Object.freeze([
+    /** The cluster's relay registered no hub, so no node of it may be sent to one. */
+    'relay-vpn-hub-absent',
+    /** The grant's two workloads are placed on two clusters; hub federation is a later lane. */
+    'grant-cross-cluster-unsupported',
+]);
+/** The policy domain of one node's control address. One rule, so both sides name it identically. */
+export const clusterVpnControlPolicyDomain = (addressValue) => networkSafe(() => `${clusterVpnNetworkContract.controlPolicyDomainPrefix}${networkIpv4(addressValue)}`);
+/** The policy domain of one workload lease, from that lease's canonical digest. */
+export const clusterVpnWorkloadPolicyDomain = (digestValue) => networkSafe(() => {
+    requireNetwork(typeof digestValue === 'string' && /^sha256:[a-f0-9]{64}$/.test(digestValue));
+    return `${clusterVpnNetworkContract.workloadPolicyDomainPrefix}${digestValue.slice(7)}`;
+});
+const workloadPolicyDomain = (value) => {
+    requireNetwork(typeof value === 'string'
+        && value.startsWith(clusterVpnNetworkContract.workloadPolicyDomainPrefix)
+        && /^[a-f0-9]{64}$/.test(value.slice(clusterVpnNetworkContract.workloadPolicyDomainPrefix.length)));
+    return value;
+};
+const prefixOf = (value) => {
+    const item = networkRecord(value, ['cidr', 'policyDomain']);
+    return { cidr: networkPrivatePrefix(item.cidr), policyDomain: workloadPolicyDomain(item.policyDomain) };
+};
+const nodeOf = (value) => {
+    const item = networkRecord(value, ['nodeId', 'publicKey', 'controlAddress', 'expiresAt', 'workloadPrefixes']);
+    return { nodeId: networkId(item.nodeId), publicKey: networkNoiseKey(item.publicKey), controlAddress: networkIpv4(item.controlAddress),
+        expiresAt: networkCounter(item.expiresAt),
+        workloadPrefixes: networkSorted(networkList(item.workloadPrefixes, clusterVpnNetworkContract.maximumWorkloadPrefixes, prefixOf), prefix => prefix.cidr) };
+};
+const grantOf = (value) => {
+    const item = networkRecord(value, ['sourceDomain', 'destinationDomain']);
+    return { sourceDomain: workloadPolicyDomain(item.sourceDomain), destinationDomain: workloadPolicyDomain(item.destinationDomain) };
+};
+const grantKey = (grant) => `${grant.sourceDomain}\0${grant.destinationDomain}`;
+/**
+ * Structural snapshot of a complete cluster network.
+ *
+ * Every node, prefix and grant is stated once and in canonical order, and every grant names a
+ * workload domain this network itself carries, on two different nodes. That last rule is what a
+ * per-cluster hub means: a grant whose other end sits on another cluster's hub cannot be expressed
+ * here at all, which is why Cloudly refuses it by name while it compiles instead of pushing it.
+ */
+export const snapshotClusterVpnNetwork = (value) => networkSafe(() => {
+    const captured = captureNetwork(value);
+    requireNetwork(new TextEncoder().encode(networkCanonical(captured)).length <= clusterVpnNetworkContract.maximumCanonicalBytes);
+    const item = networkRecord(captured, ['authorityId', 'revision', 'nodes', 'grants']);
+    const nodes = networkSorted(networkList(item.nodes, clusterVpnNetworkContract.maximumNodes, nodeOf), node => node.nodeId);
+    const grants = networkSorted(networkList(item.grants, clusterVpnNetworkContract.maximumGrants, grantOf), grantKey);
+    const domainOwners = new Map();
+    const addresses = new Set(), keys = new Set(), cidrs = new Set();
+    for (const node of nodes) {
+        requireNetwork(!keys.has(node.publicKey) && !addresses.has(node.controlAddress));
+        keys.add(node.publicKey);
+        addresses.add(node.controlAddress);
+        for (const prefix of node.workloadPrefixes) {
+            requireNetwork(!cidrs.has(prefix.cidr) && !domainOwners.has(prefix.policyDomain));
+            cidrs.add(prefix.cidr);
+            domainOwners.set(prefix.policyDomain, node.nodeId);
+        }
+    }
+    for (const grant of grants) {
+        const source = domainOwners.get(grant.sourceDomain), destination = domainOwners.get(grant.destinationDomain);
+        requireNetwork(source && destination && source !== destination);
+    }
+    return { authorityId: networkId(item.authorityId), revision: networkCounter(item.revision), nodes, grants };
+});
+/**
+ * The pure decision a relay makes about a pushed network against the one its hub holds, or null
+ * when the hub holds none — which is every hub that just started, because a daemon restart starts
+ * empty. A repeat of the held network is a replay the relay may apply again without effect; a lower
+ * revision, or the same revision with different content, is stale and refused by name.
+ */
+export const admitClusterVpnNetwork = (heldValue, nextValue) => networkSafe(() => {
+    const next = snapshotClusterVpnNetwork(nextValue);
+    if (heldValue === null)
+        return { status: 'accepted' };
+    const held = snapshotClusterVpnNetwork(heldValue);
+    if (held.authorityId !== next.authorityId)
+        return { status: 'refused', reason: 'vpn-network-authority-foreign' };
+    if (next.revision > held.revision)
+        return { status: 'accepted' };
+    return networkEqual(held, next) ? { status: 'replay' } : { status: 'refused', reason: 'vpn-network-revision-stale' };
+});
+export const snapshotApplyClusterVpnNetworkRequest = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['network']);
+    return { network: snapshotClusterVpnNetwork(item.network) };
+});
+export const snapshotApplyClusterVpnNetworkResponse = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['appliedRevision', 'state']);
+    requireNetwork(item.state === 'idle' || item.state === 'applying' || item.state === 'failed');
+    return { appliedRevision: item.appliedRevision === null ? null : networkCounter(item.appliedRevision), state: item.state };
+});
+/**
+ * Compare the answer with the exact SENT network: a hub that reports itself idle has applied the
+ * revision it was sent, and no hub can report having applied a later one than exists.
+ */
+export const bindApplyClusterVpnNetworkResponse = (value, sentRequestValue) => networkSafe(() => {
+    const response = snapshotApplyClusterVpnNetworkResponse(value);
+    const sent = snapshotApplyClusterVpnNetworkRequest(sentRequestValue);
+    requireNetwork(response.appliedRevision === null || response.appliedRevision <= sent.network.revision);
+    requireNetwork(response.state !== 'idle' || response.appliedRevision === sent.network.revision);
+    return response;
+});
+export const snapshotGetClusterVpnNetworkRequest = (value) => networkSafe(() => {
+    networkRecord(captureNetwork(value), []);
+    return {};
+});
+export const snapshotGetClusterVpnNetworkResponse = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['network']);
+    return { network: item.network === null ? null : snapshotClusterVpnNetwork(item.network) };
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clustervpn.js","sourceRoot":"","sources":["../../ts/data/clustervpn.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/index.d.ts

@@ -1,6 +1,7 @@
 export * from './cloudlyconfig.js';
 export * from './cluster.js';
 export * from './clusterruntime.js';
+export * from './clustervpn.js';
 export * from './clusteringress.js';
 export * from './config.js';
 export * from './corestore.js';

package/dist_ts/data/index.js

@@ -1,6 +1,7 @@
 export * from './cloudlyconfig.js';
 export * from './cluster.js';
 export * from './clusterruntime.js';
+export * from './clustervpn.js';
 export * from './clusteringress.js';
 export * from './config.js';
 export * from './corestore.js';
@@ -58,4 +59,4 @@ export * from './traffic.js';
 export * from './user.js';
 export * from './version.js';
 export * from './webpush.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsY0FBYyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUMifQ==

package/dist_ts/data/networkaddressplan.d.ts

@@ -1,5 +1,4 @@
 import type { IRuntimeNetworkProtectedAuthority } from './networkauthority.js';
-import type { IGetRuntimeManagedVpnCredentialResponse } from './networkcredential.js';
 /**
  * The address space an administrator gives the runtime network, and the one input the protected
  * authority is composed from. Cloudly keeps a single plan; pools and prefixes only grow, and the
@@ -13,15 +12,34 @@ export interface IRuntimeNetworkAddressPlan {
     prefixes: string[];
     pools: IRuntimeNetworkProtectedAuthority['pools'];
     resolvers: IRuntimeNetworkProtectedAuthority['resolvers'];
-    /** Without the VPN relay, which the composed authority adds as a UDP platform endpoint. */
+    /** Without the cluster hubs, which the composed authority adds from the hubs it is given. */
     platformEndpoints: IRuntimeNetworkProtectedAuthority['platformEndpoints'];
     vpn: {
         /** The private prefix VPN control addresses are allocated from. */
         controlPrefix: string;
-        /** The endpoint every node dials for the managed VPN. */
-        relay: IGetRuntimeManagedVpnCredentialResponse['relay'];
+        /**
+         * The protected prefix every cluster hub binds inside.
+         *
+         * The endpoints themselves are no administrator's input: a cluster's relay reports the one it
+         * bound and the composition turns it into platform endpoints, so this prefix is what an
+         * administrator reserves for them.
+         */
+        hubPrefix: string;
     };
 }
+/**
+ * One cluster's managed VPN hub, as the cluster's relay bound it.
+ *
+ * The hub is its cluster's own packet relay, so `clusterId` names both the hub and the authority
+ * that may select it, and `address` is an underlay address inside the plan's `vpn.hubPrefix`. A hub
+ * offers at least one transport; the port of a transport it did not bind is `null`.
+ */
+export interface IRuntimeNetworkVpnHub {
+    clusterId: string;
+    address: string;
+    quicPort: number | null;
+    websocketPort: number | null;
+}
 /** What an administrator writes; Cloudly supplies the id and the revision. */
 export type TRuntimeNetworkAddressPlanWritableData = Omit<IRuntimeNetworkAddressPlan, 'id' | 'revision'>;
 /** What a protection producer fixes around a plan: the authority's identity, revision chain and egress. */
@@ -54,20 +72,45 @@ export declare const runtimeNetworkAddressPlanContract: Readonly<{
      * is stated: the private-range rule already keeps the control prefix at /8 or longer.
      */
     readonly maximumControlPrefixLength: 30;
-    readonly relayProtocol: "udp";
+    /**
+     * Every transport a hub may offer, in the order a node prefers them.
+     *
+     * One row states all three facts that belong together: the transport a credential names, the
+     * suffix its platform endpoint id carries, and the protocol the endpoint is composed with. A hub
+     * that bound both transports therefore contributes exactly two endpoints of one address.
+     */
+    readonly hubTransports: readonly (Readonly<{
+        transport: "quic";
+        endpointSuffix: "quic";
+        protocol: "udp";
+    }> | Readonly<{
+        transport: "websocket";
+        endpointSuffix: "ws";
+        protocol: "tcp";
+    }>)[];
 }>;
+/** How a node reaches its cluster's hub, read off the one table that states the transports. */
+export type TRuntimeNetworkVpnTransport = typeof runtimeNetworkAddressPlanContract.hubTransports[number]['transport'];
+/**
+ * The platform endpoints one hub contributes to a protected authority: one per transport it bound,
+ * in id order. Every reader derives the same ids from this one function — the composition that seals
+ * the authority, and the router selection that names which of them a node may dial.
+ */
+export declare const runtimeNetworkVpnHubEndpoints: (hubValue: unknown) => IRuntimeNetworkProtectedAuthority["platformEndpoints"];
 /**
- * Structural snapshot for exact persistence and for a plan write. A plan passes only when both
- * authorities it can describe pass the protected authority's own validator: its sets alone, and
- * its sets with the relay added, so no plan can compose an authority that contract refuses.
+ * Structural snapshot for exact persistence and for a plan write. The plan's own sets pass the
+ * protected authority's own validator, so no plan can describe an authority that contract refuses,
+ * and both VPN prefixes are reserved inside the protected space the plan states.
  */
 export declare const snapshotRuntimeNetworkAddressPlan: (value: unknown) => IRuntimeNetworkAddressPlan;
 /**
  * The protected authority a plan describes inside a producer's frame, digest included: the plan's
- * sets with the VPN relay as the UDP platform endpoint every node dials. Both inputs are read before
- * the digest is computed.
+ * sets plus the endpoints of every cluster hub it is given, each bound inside `vpn.hubPrefix`. One
+ * cluster contributes one hub, so `hubs` never names a cluster twice. All inputs are read before the
+ * digest is computed; an empty `hubs` composes the authority of a runtime network whose clusters
+ * have not registered a hub yet.
  */
-export declare const composeRuntimeNetworkProtectedAuthority: (planValue: unknown, frameValue: unknown) => Promise<IRuntimeNetworkProtectedAuthority>;
+export declare const composeRuntimeNetworkProtectedAuthority: (planValue: unknown, frameValue: unknown, hubsValue: unknown) => Promise<IRuntimeNetworkProtectedAuthority>;
 /**
  * The pure decision for replacing `previousValue`, the stored plan or null, with `nextValue` at the
  * following revision. Leases and the managed VPN outlive a plan revision, so every pool stays exactly

package/dist_ts/data/networkaddressplan.js

@@ -1,5 +1,5 @@
-import { computeRuntimeNetworkProtectedAuthorityDigest, snapshotRuntimeNetworkProtectedAuthority } from './networkauthority.js';
-import { captureNetwork, failNetwork, networkContains, networkCounter, networkEqual, networkId, networkIpv4, networkOverlaps, networkPrefixBounds, networkPrivatePrefix, networkRecord, networkSafe, requireNetwork } from '../private/networkcontract.js';
+import { computeRuntimeNetworkProtectedAuthorityDigest, runtimeNetworkAuthorityContract, snapshotRuntimeNetworkProtectedAuthority } from './networkauthority.js';
+import { captureNetwork, failNetwork, networkContains, networkCounter, networkEqual, networkId, networkIpv4, networkList, networkOverlaps, networkPrefix, networkPrefixBounds, networkPrivatePrefix, networkRecord, networkSafe, requireNetwork } from '../private/networkcontract.js';
 export const runtimeNetworkAddressPlanContract = Object.freeze({
     id: 'address-plan',
     /**
@@ -7,7 +7,42 @@ export const runtimeNetworkAddressPlanContract = Object.freeze({
      * is stated: the private-range rule already keeps the control prefix at /8 or longer.
      */
     maximumControlPrefixLength: 30,
-    relayProtocol: 'udp',
+    /**
+     * Every transport a hub may offer, in the order a node prefers them.
+     *
+     * One row states all three facts that belong together: the transport a credential names, the
+     * suffix its platform endpoint id carries, and the protocol the endpoint is composed with. A hub
+     * that bound both transports therefore contributes exactly two endpoints of one address.
+     */
+    hubTransports: Object.freeze([
+        Object.freeze({ transport: 'quic', endpointSuffix: 'quic', protocol: 'udp' }),
+        Object.freeze({ transport: 'websocket', endpointSuffix: 'ws', protocol: 'tcp' }),
+    ]),
+});
+/** The port a hub bound for one transport, or null when it did not bind that transport. */
+const hubPort = (hub, transport) => transport === 'quic' ? hub.quicPort : hub.websocketPort;
+const byEndpointId = (left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+const hubOf = (value) => {
+    const item = networkRecord(value, ['clusterId', 'address', 'quicPort', 'websocketPort']);
+    const port = (value) => value === null ? null : networkCounter(value, 65535);
+    const hub = { clusterId: networkId(item.clusterId), address: networkIpv4(item.address),
+        quicPort: port(item.quicPort), websocketPort: port(item.websocketPort) };
+    // A hub that bound no transport is not reachable, so it is not a hub a node could be sent to.
+    requireNetwork(runtimeNetworkAddressPlanContract.hubTransports.some(row => hubPort(hub, row.transport) !== null));
+    return hub;
+};
+/**
+ * The platform endpoints one hub contributes to a protected authority: one per transport it bound,
+ * in id order. Every reader derives the same ids from this one function — the composition that seals
+ * the authority, and the router selection that names which of them a node may dial.
+ */
+export const runtimeNetworkVpnHubEndpoints = (hubValue) => networkSafe(() => {
+    const hub = hubOf(captureNetwork(hubValue));
+    return runtimeNetworkAddressPlanContract.hubTransports
+        .filter(row => hubPort(hub, row.transport) !== null)
+        .map(row => ({ id: `${hub.clusterId}:${row.endpointSuffix}`, address: hub.address,
+        protocol: row.protocol, port: hubPort(hub, row.transport) }))
+        .sort(byEndpointId);
 });
 /**
  * The structural authority validator reads a frame's shape and nothing else, and a plan fixes none of
@@ -23,28 +58,32 @@ const unsealedDigest = `sha256:${'0'.repeat(64)}`;
 const authorityOf = (sets, frame) => snapshotRuntimeNetworkProtectedAuthority({ id: frame.id,
     generation: frame.generation, controller: frame.controller, previous: frame.previous, egressAuthorities: frame.egressAuthorities,
     prefixes: sets.prefixes, pools: sets.pools, resolvers: sets.resolvers, platformEndpoints: sets.platformEndpoints, digest: unsealedDigest });
-const setsWithRelay = (plan) => ({
+const setsWithHubs = (plan, hubs) => ({
     prefixes: plan.prefixes, pools: plan.pools, resolvers: plan.resolvers,
-    platformEndpoints: [...plan.platformEndpoints, { ...plan.vpn.relay, protocol: runtimeNetworkAddressPlanContract.relayProtocol }]
-        .sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0),
+    platformEndpoints: [...plan.platformEndpoints, ...hubs.flatMap(runtimeNetworkVpnHubEndpoints)].sort(byEndpointId),
 });
 const vpnOf = (value) => {
-    const item = networkRecord(value, ['controlPrefix', 'relay']);
-    const relay = networkRecord(item.relay, ['id', 'address', 'port']);
+    const item = networkRecord(value, ['controlPrefix', 'hubPrefix']);
     const controlPrefix = networkPrivatePrefix(item.controlPrefix);
     requireNetwork(Number(controlPrefix.split('/')[1]) <= runtimeNetworkAddressPlanContract.maximumControlPrefixLength);
-    return { controlPrefix, relay: { id: networkId(relay.id), address: networkIpv4(relay.address), port: networkCounter(relay.port, 65535) } };
+    return { controlPrefix, hubPrefix: networkPrefix(item.hubPrefix) };
 };
-/** The control prefix is protected, and no pool, resolver or platform endpoint, the relay included, sits inside it. */
-const requireVpnProtected = (authority, controlPrefix) => {
-    requireNetwork(authority.prefixes.some(prefix => networkContains(prefix, controlPrefix))
-        && authority.pools.every(pool => !networkOverlaps(pool.prefix, controlPrefix))
-        && [...authority.resolvers, ...authority.platformEndpoints].every(endpoint => !networkContains(controlPrefix, `${endpoint.address}/32`)));
+/**
+ * Both VPN prefixes are protected, they hold none of the plan's own pools, resolvers or platform
+ * endpoints, and they do not overlap each other: control addresses live inside the tunnel and hub
+ * endpoints on the underlay, so one prefix can never contain the other's addresses.
+ */
+const requireVpnProtected = (authority, vpn) => {
+    const endpoints = [...authority.resolvers, ...authority.platformEndpoints];
+    requireNetwork([vpn.controlPrefix, vpn.hubPrefix].every(prefix => authority.prefixes.some(range => networkContains(range, prefix))
+        && authority.pools.every(pool => !networkOverlaps(pool.prefix, prefix))
+        && endpoints.every(endpoint => !networkContains(prefix, `${endpoint.address}/32`)))
+        && !networkOverlaps(vpn.controlPrefix, vpn.hubPrefix));
 };
 /**
- * Structural snapshot for exact persistence and for a plan write. A plan passes only when both
- * authorities it can describe pass the protected authority's own validator: its sets alone, and
- * its sets with the relay added, so no plan can compose an authority that contract refuses.
+ * Structural snapshot for exact persistence and for a plan write. The plan's own sets pass the
+ * protected authority's own validator, so no plan can describe an authority that contract refuses,
+ * and both VPN prefixes are reserved inside the protected space the plan states.
  */
 export const snapshotRuntimeNetworkAddressPlan = (value) => networkSafe(() => {
     const item = networkRecord(captureNetwork(value), ['id', 'revision', 'prefixes', 'pools', 'resolvers', 'platformEndpoints', 'vpn']);
@@ -53,19 +92,24 @@ export const snapshotRuntimeNetworkAddressPlan = (value) => networkSafe(() => {
         platformEndpoints: item.platformEndpoints }, validationFrame);
     const plan = { id: runtimeNetworkAddressPlanContract.id, revision: networkCounter(item.revision),
         prefixes: own.prefixes, pools: own.pools, resolvers: own.resolvers, platformEndpoints: own.platformEndpoints, vpn: vpnOf(item.vpn) };
-    requireVpnProtected(authorityOf(setsWithRelay(plan), validationFrame), plan.vpn.controlPrefix);
+    requireVpnProtected(own, plan.vpn);
     return plan;
 });
 /**
  * The protected authority a plan describes inside a producer's frame, digest included: the plan's
- * sets with the VPN relay as the UDP platform endpoint every node dials. Both inputs are read before
- * the digest is computed.
+ * sets plus the endpoints of every cluster hub it is given, each bound inside `vpn.hubPrefix`. One
+ * cluster contributes one hub, so `hubs` never names a cluster twice. All inputs are read before the
+ * digest is computed; an empty `hubs` composes the authority of a runtime network whose clusters
+ * have not registered a hub yet.
  */
-export const composeRuntimeNetworkProtectedAuthority = async (planValue, frameValue) => {
+export const composeRuntimeNetworkProtectedAuthority = async (planValue, frameValue, hubsValue) => {
     try {
         const plan = snapshotRuntimeNetworkAddressPlan(planValue);
         const frame = networkRecord(captureNetwork(frameValue), ['id', 'generation', 'controller', 'previous', 'egressAuthorities']);
-        const authority = authorityOf(setsWithRelay(plan), frame);
+        const hubs = networkList(captureNetwork(hubsValue), runtimeNetworkAuthorityContract.maximumPlatformEndpoints, hubOf);
+        requireNetwork(new Set(hubs.map(hub => hub.clusterId)).size === hubs.length
+            && hubs.every(hub => networkContains(plan.vpn.hubPrefix, `${hub.address}/32`)));
+        const authority = authorityOf(setsWithHubs(plan, hubs), frame);
         return { ...authority, digest: await computeRuntimeNetworkProtectedAuthorityDigest(authority) };
     }
     catch {
@@ -111,4 +155,4 @@ export const admitRuntimeNetworkAddressPlanChange = (previousValue, nextValue) =
     return { status: 'accepted', removed: { resolverIds: idsOf(removedOrChanged(previous.resolvers, next.resolvers)),
             platformEndpointIds: idsOf(removedOrChanged(previous.platformEndpoints, next.platformEndpoints)) } };
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkaddressplan.js","sourceRoot":"","sources":["../../ts/data/networkaddressplan.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networkaddressplan.js","sourceRoot":"","sources":["../../ts/data/networkaddressplan.ts"],"names":[],"mappings":"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"}