@serve.zone/interfaces 32.20.1 → 32.22.0

package/changelog.md

@@ -1,5 +1,79 @@
 # Changelog
 
+## 2026-09-25 - 32.22.0
+
+### Features
+
+- Add local storage claims for node-local volumes on Pallet.
+  - `IRuntimeLocalStorageClaim` names one retained `ReadWriteOnce` volume of one service by
+    identity only: controller (`cloudly` or `onebox`), organization, cluster, node, runtime
+    namespace, service and `volumeId`. It states a `source` (`{ kind: 'directory' }`), an
+    `initialization` (`empty` or `import`), a `mount { mountPath, readOnly }` and a `lifecycle`
+    (`bound` or `purge`). It never carries a host path.
+  - An `empty` claim must state `initialOwnership { uid, gid, mode }`, and an `import` claim states
+    `null`. A purge always follows a bound generation.
+  - Add `snapshotRuntimeLocalStorageClaim`, `computeRuntimeLocalStorageClaimDigest`,
+    `validateRuntimeLocalStorageClaim`, `getRuntimeLocalStorageClaimReference` and
+    `bindRuntimeLocalStorageClaimToAssignment`.
+  - Add the push request `IReq_Controller_Pallet_ApplyRuntimeLocalStorageClaim`
+    (`applyRuntimeLocalStorageClaim`). It answers `{ status, state, claim }`, where `status` is
+    `accepted`, `replay` or `historical` and `state` is `ready`, `import-required`, `purged` or
+    `uncertain`. The request and the answer have their own binders.
+- Add the service runtime refusals `volume-driver-unsupported`, `volume-options-unsupported`,
+  `volume-shared-unsupported` and `volume-placement-unsupported`, and the waiting reasons
+  `storage-import-pending` and `bindings-pending`.
+- Add cluster ingress contracts.
+  - Registration refusals are now named: `IClusterIngressRegistrationRefusal` carries a `reason`
+    from `clusterIngressRegistrationRefusalReasons` and a bounded `retryAfterMs`, with
+    `validateClusterIngressRegistrationRefusal` and `readClusterIngressRegistrationRefusal`.
+  - Add the relay-to-ingress change hint `IReq_Relay_Ingress_PushClusterIngressRouteTableChanged`,
+    which carries only `{ revision }`.
+  - Add `clusterIngressEnvironmentNames`: `SERVEZONE_CLUSTER_INGRESS_BEARER`,
+    `SERVEZONE_CLUSTER_RELAY_ORIGIN` and `SERVEZONE_CLUSTER_NODE_ID`.
+  - Clusters born on Pallet get `IClusterIngressDesignation`, which has no cutover scope, census or
+    target set. It comes with its validator and digest and the admin requests
+    `IReq_Admin_Cloudly_DesignateClusterIngress` and
+    `IReq_Admin_Cloudly_GetClusterIngressDesignation`. A cluster holds only one kind of designation.
+- Add two optional members to the runtime network projection.
+  - `workloadIngress` is a signed, one-way, `cloudly`-only grant from the ingress workload to one
+    exact protocol and port of a target workload. It works across organizations and needs no
+    shared network. `getRuntimeNetworkProjectionWorkloadIngressPacketGrants` returns these grants,
+    and their withdrawals follow the host-grant rules.
+  - `hostPlatformEndpointIds` names the platform endpoints whose address the node's own host
+    carries.
+  - A projection without either member keeps its canonical bytes, digest and signature.
+- Every addition is optional or new, so no existing shape narrows. The added union members widen
+  `TServiceRuntimeRefusal` and `TServiceRuntimeWaitingReason`.
+
+## 2026-09-25 - 32.21.0
+
+### Features
+
+- Add gateway-client hostname records and certificates that need no gateway route.
+  - `syncGatewayClientDnsRecord` (`IReq_SyncGatewayClientDnsRecord`) publishes, replaces or
+    withdraws the one `A` or `AAAA` record a `IGatewayClientHostnameOwnership` (`appId`,
+    `hostname`) holds, at a value the client chooses. The value must lie inside the new
+    gateway-client policy field `allowedDnsRecordAddresses`, a list of canonical CIDR prefixes on
+    `IGatewayClient`, `IGatewayClientProvisioningSpec` and `IGatewayClientContext`. An absent or
+    empty list allows no record.
+  - `getGatewayClientCertificate` (`IReq_GetGatewayClientCertificate`) answers the exact
+    certificate for the owned hostname as `ready` (`IGatewayClientCertificate` with its PEM key
+    and `renewAfter`), `pending` or `refused` (`TGatewayClientCertificateRefusal`).
+    `releaseGatewayClientCertificate` (`IReq_ReleaseGatewayClientCertificate`) removes that
+    material.
+  - The three requests accept gateway-client credentials only and reuse the existing token
+    capabilities `syncDnsRecords`, `requestCertificates` and `readCertificates`.
+  - Gateways advertise support with the optional capability flags `dns.clientRecords` and
+    `certificates.exactIssuance`.
+  - `TGatewayClientDnsRecordStatus` reuses the route DNS vocabulary, and
+    `gatewayClientHostnameContract` states the TTL, allowance and length bounds.
+  - Add the shared validators `validateGatewayClientHostnameOwnership`,
+    `validateGatewayClientDnsRecord`, `validateGatewayAllowedDnsRecordAddresses`,
+    `isGatewayClientDnsRecordAllowed`, `isGatewayAddressPrefix` and `isGatewayClientHostname`.
+    They accept only the canonical spelling of each address: the dotted quad, or RFC 5952 text
+    for IPv6.
+  - Every addition is optional or new, so no existing shape narrows.
+
 ## 2026-09-24 - 32.20.1
 
 ### Maintenance

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/clusteringress.d.ts

@@ -143,3 +143,61 @@ export declare const validateClusterTrafficStatisticsPage: (valueArg: unknown, p
  * accessor a peer put on the body.
  */
 export declare const validateClusterIngressRegistration: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * The environment variable names of the cluster ingress workload.
+ *
+ * Cloudly writes them into the ingress workload's assignment environment and the ingress reads
+ * them, so both sides spell each name once, here. `bearer` is the credential the ingress presents
+ * to `registerClusterIngress`; it is a secret and is delivered as one. `relayOrigin` is the exact
+ * `IClusterRelay.origin` of the cluster's relay, and `nodeId` is the node the assignment runs on,
+ * which the registration's `nodeId` repeats.
+ */
+export declare const clusterIngressEnvironmentNames: Readonly<{
+    readonly bearer: "SERVEZONE_CLUSTER_INGRESS_BEARER";
+    readonly relayOrigin: "SERVEZONE_CLUSTER_RELAY_ORIGIN";
+    readonly nodeId: "SERVEZONE_CLUSTER_NODE_ID";
+}>;
+/**
+ * Every reason Cloudly refuses a cluster ingress registration, in the order it judges them.
+ *
+ * A protocol mismatch is not among them: it is refused first, as the `IProtocolRefusal` every
+ * TypedRequest hop already carries, and a second name for it would be a second answer to one fact.
+ */
+export declare const clusterIngressRegistrationRefusalReasons: readonly ["not-ready", "registration-invalid", "relay-not-connected", "ingress-not-designated", "node-mismatch", "assignment-not-running", "bearer-refused", "conflict"];
+export type TClusterIngressRegistrationRefusalReason = typeof clusterIngressRegistrationRefusalReasons[number];
+export declare const clusterIngressRegistrationContract: Readonly<{
+    readonly refusalCode: "cluster-ingress-registration-refused";
+    readonly minimumRetryAfterMs: 1000;
+    readonly maximumRetryAfterMs: 300000;
+}>;
+/**
+ * The named refusal of `registerClusterIngress`, carried as `TypedResponseError.errorData` from
+ * Cloudly and forwarded by the relay untouched. `retryAfterMs` is how long the ingress waits before
+ * it registers again; it never quotes the bearer or anything derived from it.
+ */
+export interface IClusterIngressRegistrationRefusal {
+    code: 'cluster-ingress-registration-refused';
+    reason: TClusterIngressRegistrationRefusalReason;
+    retryAfterMs: number;
+}
+/** Validates one registration refusal and names every reason it is refused. */
+export declare const validateClusterIngressRegistrationRefusal: (valueArg: unknown, pathArg?: string) => string[];
+/**
+ * The refusal inside an error payload, or `null` when the value is not one.
+ *
+ * It reads a value that survived serialization, the way `protocol.readProtocolRefusal` does, so an
+ * ingress tells a named registration refusal apart from a protocol refusal and every other error.
+ */
+export declare const readClusterIngressRegistrationRefusal: (valueArg: unknown) => IClusterIngressRegistrationRefusal | null;
+/**
+ * The relay's hint that it holds a newer route table.
+ *
+ * It carries the revision alone and no route, certificate or key, so it is safe to log; the
+ * ingress answers it by pulling `getClusterIngressRouteTable` with the revision it already applied,
+ * and ignores a hint whose revision is not greater than that one.
+ */
+export interface IClusterIngressRouteTableChange {
+    revision: number;
+}
+/** Validates one route-table change hint. */
+export declare const validateClusterIngressRouteTableChange: (valueArg: unknown, pathArg?: string) => string[];

package/dist_ts/data/clusteringress.js

@@ -1,7 +1,7 @@
 import { isPlausibleUnicastIpv4 } from '../private/ipv4.js';
 import { isUtcCalendarDay } from '../private/utccalendarday.js';
 import { validateProtocolOfferOn } from '../protocol.js';
-import { hasExactKeys } from '../private/dataproperties.js';
+import { hasExactKeys, readExactDataRecord } from '../private/dataproperties.js';
 import { isClusterNodeId } from '../private/nodeidentifier.js';
 /**
  * The cluster ingress contracts.
@@ -305,4 +305,98 @@ export const validateClusterIngressRegistration = (valueArg, pathArg = 'cluster
     }
     return errors;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusteringress.js","sourceRoot":"","sources":["../../ts/data/clusteringress.ts"],"names":[],"mappings":"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"}
+/**
+ * The environment variable names of the cluster ingress workload.
+ *
+ * Cloudly writes them into the ingress workload's assignment environment and the ingress reads
+ * them, so both sides spell each name once, here. `bearer` is the credential the ingress presents
+ * to `registerClusterIngress`; it is a secret and is delivered as one. `relayOrigin` is the exact
+ * `IClusterRelay.origin` of the cluster's relay, and `nodeId` is the node the assignment runs on,
+ * which the registration's `nodeId` repeats.
+ */
+export const clusterIngressEnvironmentNames = Object.freeze({
+    bearer: 'SERVEZONE_CLUSTER_INGRESS_BEARER',
+    relayOrigin: 'SERVEZONE_CLUSTER_RELAY_ORIGIN',
+    nodeId: 'SERVEZONE_CLUSTER_NODE_ID',
+});
+/**
+ * Every reason Cloudly refuses a cluster ingress registration, in the order it judges them.
+ *
+ * A protocol mismatch is not among them: it is refused first, as the `IProtocolRefusal` every
+ * TypedRequest hop already carries, and a second name for it would be a second answer to one fact.
+ */
+export const clusterIngressRegistrationRefusalReasons = Object.freeze([
+    /** Cloudly cannot judge registrations yet: it is starting, stopping or missing its environment. */
+    'not-ready',
+    /** The body fails `validateClusterIngressRegistration`. */
+    'registration-invalid',
+    /** The relay that forwarded the registration is not the connection Cloudly elected for its cluster. */
+    'relay-not-connected',
+    /** The cluster holds no current ingress designation. */
+    'ingress-not-designated',
+    /** The named node is not one the designation lets the ingress run on. */
+    'node-mismatch',
+    /**
+     * No ready assignment of the designated ingress service runs on the named node under that node's
+     * current session, or the one that runs does not carry the designation's current credential.
+     */
+    'assignment-not-running',
+    /** The bearer is not the designation's current credential. */
+    'bearer-refused',
+    /** The designation, the assignment or the session changed while the registration was judged. */
+    'conflict',
+]);
+export const clusterIngressRegistrationContract = Object.freeze({
+    refusalCode: 'cluster-ingress-registration-refused',
+    minimumRetryAfterMs: 1_000,
+    maximumRetryAfterMs: 300_000,
+});
+const isRetryAfterMs = (valueArg) => (Number.isSafeInteger(valueArg)
+    && valueArg >= clusterIngressRegistrationContract.minimumRetryAfterMs
+    && valueArg <= clusterIngressRegistrationContract.maximumRetryAfterMs);
+/** Validates one registration refusal and names every reason it is refused. */
+export const validateClusterIngressRegistrationRefusal = (valueArg, pathArg = 'cluster ingress registration refusal') => {
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['code', 'reason', 'retryAfterMs'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    const errors = [];
+    if (valueArg.code !== clusterIngressRegistrationContract.refusalCode) {
+        errors.push(`${pathArg} code must be ${clusterIngressRegistrationContract.refusalCode}`);
+    }
+    if (!clusterIngressRegistrationRefusalReasons.includes(valueArg.reason)) {
+        errors.push(`${pathArg} reason must be a cluster ingress registration refusal reason`);
+    }
+    if (!isRetryAfterMs(valueArg.retryAfterMs)) {
+        errors.push(`${pathArg} retryAfterMs must be an integer from `
+            + `${clusterIngressRegistrationContract.minimumRetryAfterMs} to `
+            + `${clusterIngressRegistrationContract.maximumRetryAfterMs}`);
+    }
+    return errors;
+};
+/**
+ * The refusal inside an error payload, or `null` when the value is not one.
+ *
+ * It reads a value that survived serialization, the way `protocol.readProtocolRefusal` does, so an
+ * ingress tells a named registration refusal apart from a protocol refusal and every other error.
+ */
+export const readClusterIngressRegistrationRefusal = (valueArg) => {
+    const refusal = readExactDataRecord(valueArg, ['code', 'reason', 'retryAfterMs']);
+    if (refusal === null || validateClusterIngressRegistrationRefusal(refusal).length > 0) {
+        return null;
+    }
+    return Object.freeze({
+        code: clusterIngressRegistrationContract.refusalCode,
+        reason: refusal.reason,
+        retryAfterMs: refusal.retryAfterMs,
+    });
+};
+/** Validates one route-table change hint. */
+export const validateClusterIngressRouteTableChange = (valueArg, pathArg = 'cluster ingress route table change') => {
+    if (!isRecord(valueArg) || !hasExactKeys(valueArg, ['revision'])) {
+        return [`${pathArg} must use its exact schema`];
+    }
+    return isCounter(valueArg.revision)
+        ? []
+        : [`${pathArg} revision must be a non-negative safe integer`];
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clusteringress.js","sourceRoot":"","sources":["../../ts/data/clusteringress.ts"],"names":[],"mappings":"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"}

package/dist_ts/data/clusteringressdesignation.d.ts

@@ -0,0 +1,64 @@
+import type { TSha256Digest } from './immutableimage.js';
+import type { IClusterRuntimeReference } from './clusterruntime.js';
+import type { IRuntimeAuthorityReference } from './runtimeassignment.js';
+import type { ISecretVersionReference } from './secret.js';
+/**
+ * The ingress designation of a cluster born on Pallet.
+ *
+ * A cluster that never ran Swarm has no cutover scope, census or target set, so its ingress is
+ * designated by this record instead of `IFleetCutoverIngressDesignation`. A cluster holds exactly
+ * one kind of designation at a time: Cloudly refuses to designate a cluster that holds the other
+ * kind. Which nodes the ingress runs on is the ingress service's runtime spec placement; the
+ * designation names the service and the credential, and nothing else.
+ */
+/** Public identity of the active ingress credential generation; it contains no credential value. */
+export interface IClusterIngressCredentialReference {
+    credentialId: string;
+    generation: number;
+    secretVersion: ISecretVersionReference;
+}
+/**
+ * Cloudly's accepted designation of one service as a Pallet cluster's ingress. It grants no
+ * assignment, session or registration: the ingress still registers with the credential it names.
+ */
+export interface IClusterIngressDesignation {
+    id: string;
+    generation: number;
+    previous: IRuntimeAuthorityReference | null;
+    clusterId: string;
+    runtime: IClusterRuntimeReference & {
+        phase: 'pallet';
+    };
+    ingressServiceId: string;
+    /** The ingress service's runtime spec revision the designation was accepted against. */
+    preparedSpecRevision: number;
+    credential: IClusterIngressCredentialReference;
+    actorId: string;
+    acceptedAt: number;
+    digest: TSha256Digest;
+}
+/**
+ * Administrator intent to designate one service as the cluster's ingress. The caller supplies only
+ * compare-and-swap inputs; Cloudly owns credential generation and acceptance.
+ */
+export interface IClusterIngressDesignationRequest {
+    mutationId: string;
+    clusterId: string;
+    ingressServiceId: string;
+    currentRuntime: IClusterRuntimeReference & {
+        phase: 'pallet';
+    };
+    expectedSpecRevision: number;
+    /** Null for creation; the exact current designation for rotation or a change of service. */
+    expectedDesignation: IRuntimeAuthorityReference | null;
+}
+export declare const clusterIngressDesignationContract: Readonly<{
+    readonly digestDomain: "serve.zone/cluster-ingress-designation";
+    readonly error: "Cluster ingress designation contract rejected.";
+}>;
+/** Detached exact-schema snapshot of a designation request. */
+export declare const snapshotClusterIngressDesignationRequest: (valueArg: unknown) => IClusterIngressDesignationRequest;
+/** Detached exact-schema snapshot. The digest is a separate check. */
+export declare const snapshotClusterIngressDesignation: (valueArg: unknown) => IClusterIngressDesignation;
+export declare const computeClusterIngressDesignationDigest: (valueArg: unknown) => Promise<TSha256Digest>;
+export declare const validateClusterIngressDesignation: (valueArg: unknown) => Promise<string[]>;

package/dist_ts/data/clusteringressdesignation.js

@@ -0,0 +1,84 @@
+import { snapshotClusterRuntimeReference } from './clusterruntime.js';
+import { captureNetwork, networkCounter, networkDigest, networkHash, networkId, networkRecord, networkReference, networkRevision, requireNetwork } from '../private/networkcontract.js';
+export const clusterIngressDesignationContract = Object.freeze({
+    digestDomain: 'serve.zone/cluster-ingress-designation',
+    error: 'Cluster ingress designation contract rejected.',
+});
+const fail = () => { throw new Error(clusterIngressDesignationContract.error); };
+const safe = (operationArg) => { try {
+    return operationArg();
+}
+catch {
+    return fail();
+} };
+const palletRuntime = (valueArg, clusterIdArg) => {
+    const runtime = snapshotClusterRuntimeReference(valueArg);
+    requireNetwork(runtime.id === clusterIdArg && runtime.phase === 'pallet');
+    return { id: runtime.id, phase: 'pallet', generation: runtime.generation };
+};
+const credentialOf = (valueArg) => {
+    const value = networkRecord(valueArg, ['credentialId', 'generation', 'secretVersion']);
+    const secretVersion = networkRecord(value.secretVersion, ['secretId', 'secretVersionId']);
+    return {
+        credentialId: networkId(value.credentialId),
+        generation: networkCounter(value.generation),
+        secretVersion: {
+            secretId: networkId(secretVersion.secretId),
+            secretVersionId: networkId(secretVersion.secretVersionId),
+        },
+    };
+};
+/** Detached exact-schema snapshot of a designation request. */
+export const snapshotClusterIngressDesignationRequest = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['mutationId', 'clusterId', 'ingressServiceId',
+        'currentRuntime', 'expectedSpecRevision', 'expectedDesignation']);
+    const clusterId = networkId(value.clusterId);
+    return {
+        mutationId: networkId(value.mutationId),
+        clusterId,
+        ingressServiceId: networkId(value.ingressServiceId),
+        currentRuntime: palletRuntime(value.currentRuntime, clusterId),
+        expectedSpecRevision: networkCounter(value.expectedSpecRevision),
+        expectedDesignation: value.expectedDesignation === null ? null : networkReference(value.expectedDesignation),
+    };
+});
+/** Detached exact-schema snapshot. The digest is a separate check. */
+export const snapshotClusterIngressDesignation = (valueArg) => safe(() => {
+    const value = networkRecord(captureNetwork(valueArg), ['id', 'generation', 'previous', 'clusterId', 'runtime',
+        'ingressServiceId', 'preparedSpecRevision', 'credential', 'actorId', 'acceptedAt', 'digest']);
+    const { id, generation, previous } = networkRevision(value);
+    const clusterId = networkId(value.clusterId);
+    return {
+        id,
+        generation,
+        previous,
+        clusterId,
+        runtime: palletRuntime(value.runtime, clusterId),
+        ingressServiceId: networkId(value.ingressServiceId),
+        preparedSpecRevision: networkCounter(value.preparedSpecRevision),
+        credential: credentialOf(value.credential),
+        actorId: networkId(value.actorId),
+        acceptedAt: networkCounter(value.acceptedAt),
+        digest: networkDigest(value.digest),
+    };
+});
+export const computeClusterIngressDesignationDigest = async (valueArg) => {
+    const designation = snapshotClusterIngressDesignation(valueArg);
+    try {
+        return await networkHash(clusterIngressDesignationContract.digestDomain, designation);
+    }
+    catch {
+        return fail();
+    }
+};
+export const validateClusterIngressDesignation = async (valueArg) => {
+    try {
+        const designation = snapshotClusterIngressDesignation(valueArg);
+        return designation.digest === await computeClusterIngressDesignationDigest(designation)
+            ? [] : ['cluster ingress designation digest does not match'];
+    }
+    catch {
+        return ['cluster ingress designation must use its exact canonical schema'];
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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