@serve.zone/interfaces 31.6.0 → 31.8.0

package/changelog.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 2026-09-17 - 31.8.0
+
+### Features
+
+- Add signed DNS lease renewals, so a node's private DNS can outlive a projection's
+  fifteen-minute window without a new projection. Re-issuing the projection would restart the
+  node's data plane, and during a Cloudly outage nothing could sign one.
+  `IRuntimeNetworkDnsLeaseRenewal` names the exact admitted projection by reference and carries
+  only a `sequence` and a fresh `dns` window, so it never joins the projection chain.
+  - `signRuntimeNetworkDnsLeaseRenewal` and `verifyRuntimeNetworkDnsLeaseRenewal` use the
+    controller's existing projection-signing authority under a separate signature domain. A
+    renewal verifies only under the exact revision that signed the projection it renews, so
+    rotation still needs a newly signed projection for DNS.
+  - `admitRuntimeNetworkDnsLeaseRenewal` admits a renewal only for the current projection and
+    scope, with a higher sequence and a window that does not move back, ends later and is current
+    by the caller's qualified clock. A byte-identical replay is answered `replay` at any time. A
+    successor projection refuses every renewal of its predecessor.
+  - `applyRuntimeNetworkDnsLeaseRenewal` delivers one renewal to a Pallet node, bound to the
+    node's own current session, and its ACK names the exact renewal it admitted.
+  - `holdRuntimeNetworkDnsLeaseRenewals` lets Cloudly hand the cluster relay a pre-signed run,
+    bounded by `maximumEscrowedRenewals` (32) and `maximumEscrowHorizonMs` (four hours). The
+    relay releases only the renewal whose window is current, only while it has no Cloudly
+    session, and holds no key.
+  - `getRuntimeNetworkEffectiveDnsWindow` returns the window a node may use: the admitted
+    renewal's, else the projection's. It takes the bare renewal admission returns, and so does
+    `bindGetRuntimeManagedVpnCredentialResponseV1` as an optional trailing argument, so a newly
+    issued managed-VPN credential can be bound inside the renewed window.
+  - No existing shape or signature changes: `bindGetRuntimeManagedVpnCredentialResponseV1` only
+    gains an optional trailing argument, without which its rule is unchanged, and the projection's
+    `dns` window is now named `IRuntimeNetworkDnsWindow`. The new shapes carry no `schemaVersion`
+    and no version suffix.
+
+## 2026-09-17 - 31.7.0
+
+### Features
+
+- Add `setClusterNodeCorestoreEndpoint { identity; nodeId; endpoint }`, the admin path for the
+  per-node Corestore endpoint the relay dials. `IClusterNode.data.corestore { endpoint }` has been
+  the contract since 31.6.0, with no request that sets it: an administrator had no way to state
+  where a node's Corestore answers, so a relay serving that cluster had nowhere to dial. Cloudly
+  answers with the node as it now stands, validates the endpoint with `validateClusterNodeCorestore`
+  before writing, fences the node inside the writing transaction so a concurrent deletion conflicts,
+  and pushes the cluster configuration afterwards so connected relays learn the change without
+  reconnecting; `endpoint: null` clears it and states the same fact as never having set one. One
+  field with one validator, deliberately not a node-wide update whose per-field authority nobody
+  defined.
+
 ## 2026-09-17 - 31.6.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

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

package/dist_ts/data/index.d.ts

@@ -27,6 +27,7 @@ export * from './nodeenrollment.js';
 export * from './networkauthority.js';
 export * from './networkcredential.js';
 export * from './networkdelivery.js';
+export * from './networklease.js';
 export * from './networkprojection.js';
 export type { IRuntimeNetworkRouterPacketGrantV1, IRuntimeNetworkRouterProjectionV1 } from './networkrouter.js';
 export * from './networkprotection.js';

package/dist_ts/data/index.js

@@ -27,6 +27,7 @@ export * from './nodeenrollment.js';
 export * from './networkauthority.js';
 export * from './networkcredential.js';
 export * from './networkdelivery.js';
+export * from './networklease.js';
 export * from './networkprojection.js';
 export * from './networkprotection.js';
 export * from './networksigning.js';
@@ -52,4 +53,4 @@ export * from './traffic.js';
 export * from './user.js';
 export * from './version.js';
 export * from './webpush.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsY0FBYyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9kYXRhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHdCQUF3QixDQUFDO0FBRXZDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUMifQ==

package/dist_ts/data/networkcredential.d.ts

@@ -18,7 +18,10 @@ export interface IGetRuntimeManagedVpnCredentialResponseV1 extends IGetRuntimeMa
     serverPublicKey: string;
     clientPublicKey: string;
     clientPrivateKey: string;
-    /** Unix milliseconds; cannot outlive the referenced projection's DNS lease. */
+    /**
+     * Unix milliseconds; cannot outlive the referenced projection's effective DNS window: its
+     * admitted lease renewal's, else its own.
+     */
     expiresAt: number;
 }
 export declare const snapshotGetRuntimeManagedVpnCredentialRequestV1: (value: unknown) => IGetRuntimeManagedVpnCredentialRequestV1;
@@ -27,6 +30,9 @@ export declare const snapshotGetRuntimeManagedVpnCredentialResponseV1: (value: u
  * and authenticate/fence the current physical peer before and after native work. */
 export declare const bindGetRuntimeManagedVpnCredentialRequestV1: (value: unknown, projectionValue: unknown, trustedSessionValue: unknown) => Promise<IGetRuntimeManagedVpnCredentialRequestV1>;
 /** Bind the secret response to the original request and exact selected router
- * UDP endpoint. Time is caller-qualified; this helper does not sample a clock,
- * authenticate a transport, admit policy or prove a running managed connection. */
-export declare const bindGetRuntimeManagedVpnCredentialResponseV1: (value: unknown, requestValue: unknown, projectionValue: unknown, trustedSessionValue: unknown, nowValue: unknown) => Promise<IGetRuntimeManagedVpnCredentialResponseV1>;
+ * UDP endpoint, inside the projection's effective DNS window. renewalValue is the
+ * bare lease renewal the caller already verified and admitted for this exact
+ * projection, or null; this helper verifies no signature. Time is caller-qualified;
+ * this helper does not sample a clock, authenticate a transport, admit policy or
+ * prove a running managed connection. */
+export declare const bindGetRuntimeManagedVpnCredentialResponseV1: (value: unknown, requestValue: unknown, projectionValue: unknown, trustedSessionValue: unknown, nowValue: unknown, renewalValue?: unknown | null) => Promise<IGetRuntimeManagedVpnCredentialResponseV1>;

package/dist_ts/data/networkcredential.js

@@ -1,6 +1,7 @@
 import { snapshotRuntimeSessionBindingV1 } from './runtimesession.js';
 import { validateRuntimeNetworkProjectionV1 } from './networkprojection.js';
-import { captureNetwork, failNetwork, networkCounter, networkEqual, networkId, networkIpv4, networkRecord, networkReference, networkReferenceOf, networkSafe, requireNetwork } from '../private/networkcontract.js';
+import { snapshotRuntimeNetworkDnsLeaseRenewal, validateRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
+import { captureNetwork, failNetwork, networkCounter, networkEffectiveDnsWindow, networkEqual, networkId, networkIpv4, networkRecord, networkReference, networkReferenceOf, networkSafe, networkSameScope, requireNetwork } from '../private/networkcontract.js';
 /** Canonical 32-byte key encoding only. Cryptographic key agreement and pair
  * validation belong to the native Noise implementation, not this JSON parser. */
 const key = (value) => {
@@ -25,8 +26,7 @@ export const snapshotGetRuntimeManagedVpnCredentialResponseV1 = (value) => netwo
 });
 const bindRequest = (request, projection, trusted) => {
     requireNetwork(networkEqual(request.session, trusted) && networkEqual(request.projection, networkReferenceOf(projection))
-        && networkEqual(projection.controller, trusted.controller) && projection.nodeId === trusted.nodeId
-        && projection.runtimeNamespace === trusted.runtimeNamespace && projection.handoff);
+        && networkSameScope(projection, trusted) && projection.handoff);
 };
 /** Content binding only. The caller must resolve the exact current projection
  * and authenticate/fence the current physical peer before and after native work. */
@@ -43,24 +43,30 @@ export const bindGetRuntimeManagedVpnCredentialRequestV1 = async (value, project
     }
 };
 /** Bind the secret response to the original request and exact selected router
- * UDP endpoint. Time is caller-qualified; this helper does not sample a clock,
- * authenticate a transport, admit policy or prove a running managed connection. */
-export const bindGetRuntimeManagedVpnCredentialResponseV1 = async (value, requestValue, projectionValue, trustedSessionValue, nowValue) => {
+ * UDP endpoint, inside the projection's effective DNS window. renewalValue is the
+ * bare lease renewal the caller already verified and admitted for this exact
+ * projection, or null; this helper verifies no signature. Time is caller-qualified;
+ * this helper does not sample a clock, authenticate a transport, admit policy or
+ * prove a running managed connection. */
+export const bindGetRuntimeManagedVpnCredentialResponseV1 = async (value, requestValue, projectionValue, trustedSessionValue, nowValue, renewalValue = null) => {
     try {
         const response = snapshotGetRuntimeManagedVpnCredentialResponseV1(value);
         const request = snapshotGetRuntimeManagedVpnCredentialRequestV1(requestValue);
         const trusted = snapshotRuntimeSessionBindingV1(trustedSessionValue), now = networkCounter(nowValue);
+        const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
         const projection = await validateRuntimeNetworkProjectionV1(projectionValue);
+        const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
+        const window = networkEffectiveDnsWindow(projection, renewal);
         bindRequest(request, projection, trusted);
         requireNetwork(networkEqual(response.session, request.session) && networkEqual(response.projection, request.projection));
         requireNetwork(projection.router?.platformEndpointIds.includes(response.relay.id));
         const endpoint = projection.protectedAuthority.platformEndpoints.find(item => item.id === response.relay.id);
         requireNetwork(endpoint && endpoint.protocol === 'udp' && endpoint.address === response.relay.address && endpoint.port === response.relay.port);
-        requireNetwork(projection.dns.notBefore <= now && now < response.expiresAt && response.expiresAt <= projection.dns.expiresAt);
+        requireNetwork(window.notBefore <= now && now < response.expiresAt && response.expiresAt <= window.expiresAt);
         return response;
     }
     catch {
         return failNetwork();
     }
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/data/networkdelivery.d.ts

@@ -1,6 +1,7 @@
 import type { IRuntimeAuthorityReferenceV1 } from './runtimeassignment.js';
 import type { IRuntimeSessionBindingV1 } from './runtimesession.js';
 import type { IRuntimeNetworkSigningAuthorityV1, ISignedRuntimeNetworkProjectionV1 } from './networksigning.js';
+import type { IRuntimeNetworkDnsLeaseRenewalReference, ISignedRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
 export interface IApplyRuntimeNetworkSigningAuthorityRequestV1 {
     session: IRuntimeSessionBindingV1;
     authority: IRuntimeNetworkSigningAuthorityV1;
@@ -14,12 +15,32 @@ export interface IApplyRuntimeNetworkAuthorityResponseV1 {
     status: 'accepted' | 'replay';
     authority: IRuntimeAuthorityReferenceV1;
 }
+export interface IApplyRuntimeNetworkDnsLeaseRenewalRequest {
+    session: IRuntimeSessionBindingV1;
+    signed: ISignedRuntimeNetworkDnsLeaseRenewal;
+}
+/** Durable admission only. It does not assert that the node converted the window or serves DNS. */
+export interface IApplyRuntimeNetworkDnsLeaseRenewalResponse {
+    status: 'accepted' | 'replay';
+    renewal: IRuntimeNetworkDnsLeaseRenewalReference;
+}
 export declare const snapshotApplyRuntimeNetworkSigningAuthorityRequestV1: (value: unknown) => IApplyRuntimeNetworkSigningAuthorityRequestV1;
 export declare const snapshotApplyRuntimeNetworkProjectionRequestV1: (value: unknown) => IApplyRuntimeNetworkProjectionRequestV1;
 export declare const snapshotApplyRuntimeNetworkAuthorityResponseV1: (value: unknown) => IApplyRuntimeNetworkAuthorityResponseV1;
+export declare const snapshotApplyRuntimeNetworkDnsLeaseRenewalRequest: (value: unknown) => IApplyRuntimeNetworkDnsLeaseRenewalRequest;
+export declare const snapshotApplyRuntimeNetworkDnsLeaseRenewalResponse: (value: unknown) => IApplyRuntimeNetworkDnsLeaseRenewalResponse;
 /** trustedSessionValue must come from the receiving CURRENT physical connection. */
 export declare const bindApplyRuntimeNetworkSigningAuthorityRequestV1: (value: unknown, trustedSessionValue: unknown) => IApplyRuntimeNetworkSigningAuthorityRequestV1;
 /** Content binding only. Verify signature with stored trust and atomically fence admission. */
 export declare const bindApplyRuntimeNetworkProjectionRequestV1: (value: unknown, trustedSessionValue: unknown) => IApplyRuntimeNetworkProjectionRequestV1;
 /** Compare ACK with the exact SENT key or projection reference, never with a response-derived value. */
 export declare const bindApplyRuntimeNetworkAuthorityResponseV1: (value: unknown, sentReferenceValue: unknown) => IApplyRuntimeNetworkAuthorityResponseV1;
+/**
+ * Content binding only; trustedSessionValue must come from the receiving CURRENT physical
+ * connection. A relay pushes a held renewal under the binding the node obtained itself, so this
+ * comparison is what makes the push admissible, never who sent it. Verify the signature with
+ * stored trust, then admit and fence atomically.
+ */
+export declare const bindApplyRuntimeNetworkDnsLeaseRenewalRequest: (value: unknown, trustedSessionValue: unknown) => IApplyRuntimeNetworkDnsLeaseRenewalRequest;
+/** Compare the ACK with the exact SENT renewal, never with a response-derived value. */
+export declare const bindApplyRuntimeNetworkDnsLeaseRenewalResponse: (value: unknown, sentRenewalValue: unknown) => IApplyRuntimeNetworkDnsLeaseRenewalResponse;

package/dist_ts/data/networkdelivery.js

@@ -1,6 +1,11 @@
 import { snapshotRuntimeSessionBindingV1 } from './runtimesession.js';
 import { snapshotRuntimeNetworkSigningAuthorityV1, snapshotSignedRuntimeNetworkProjectionV1 } from './networksigning.js';
-import { captureNetwork, networkEqual, networkRecord, networkReference, networkReferenceOf, networkSafe, requireNetwork } from '../private/networkcontract.js';
+import { getRuntimeNetworkDnsLeaseRenewalReference, snapshotRuntimeNetworkDnsLeaseRenewal, snapshotRuntimeNetworkDnsLeaseRenewalReference, snapshotSignedRuntimeNetworkDnsLeaseRenewal } from './networklease.js';
+import { captureNetwork, networkEqual, networkRecord, networkReference, networkReferenceOf, networkSafe, networkSameScope, requireNetwork } from '../private/networkcontract.js';
+const admissionStatus = (value) => {
+    requireNetwork(value === 'accepted' || value === 'replay');
+    return value;
+};
 export const snapshotApplyRuntimeNetworkSigningAuthorityRequestV1 = (value) => networkSafe(() => {
     const item = networkRecord(captureNetwork(value), ['session', 'authority']);
     return { session: snapshotRuntimeSessionBindingV1(item.session), authority: snapshotRuntimeNetworkSigningAuthorityV1(item.authority) };
@@ -11,8 +16,15 @@ export const snapshotApplyRuntimeNetworkProjectionRequestV1 = (value) => network
 });
 export const snapshotApplyRuntimeNetworkAuthorityResponseV1 = (value) => networkSafe(() => {
     const item = networkRecord(captureNetwork(value), ['status', 'authority']);
-    requireNetwork(item.status === 'accepted' || item.status === 'replay');
-    return { status: item.status, authority: networkReference(item.authority) };
+    return { status: admissionStatus(item.status), authority: networkReference(item.authority) };
+});
+export const snapshotApplyRuntimeNetworkDnsLeaseRenewalRequest = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['session', 'signed']);
+    return { session: snapshotRuntimeSessionBindingV1(item.session), signed: snapshotSignedRuntimeNetworkDnsLeaseRenewal(item.signed) };
+});
+export const snapshotApplyRuntimeNetworkDnsLeaseRenewalResponse = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['status', 'renewal']);
+    return { status: admissionStatus(item.status), renewal: snapshotRuntimeNetworkDnsLeaseRenewalReference(item.renewal) };
 });
 /** trustedSessionValue must come from the receiving CURRENT physical connection. */
 export const bindApplyRuntimeNetworkSigningAuthorityRequestV1 = (value, trustedSessionValue) => networkSafe(() => {
@@ -23,9 +35,7 @@ export const bindApplyRuntimeNetworkSigningAuthorityRequestV1 = (value, trustedS
 /** Content binding only. Verify signature with stored trust and atomically fence admission. */
 export const bindApplyRuntimeNetworkProjectionRequestV1 = (value, trustedSessionValue) => networkSafe(() => {
     const request = snapshotApplyRuntimeNetworkProjectionRequestV1(value), session = snapshotRuntimeSessionBindingV1(trustedSessionValue);
-    const projection = request.signed.projection;
-    requireNetwork(networkEqual(request.session, session) && networkEqual(projection.controller, session.controller)
-        && projection.nodeId === session.nodeId && projection.runtimeNamespace === session.runtimeNamespace);
+    requireNetwork(networkEqual(request.session, session) && networkSameScope(request.signed.projection, session));
     return request;
 });
 /** Compare ACK with the exact SENT key or projection reference, never with a response-derived value. */
@@ -35,4 +45,22 @@ export const bindApplyRuntimeNetworkAuthorityResponseV1 = (value, sentReferenceV
     requireNetwork(networkEqual(response.authority, networkReferenceOf(expected)));
     return response;
 });
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Content binding only; trustedSessionValue must come from the receiving CURRENT physical
+ * connection. A relay pushes a held renewal under the binding the node obtained itself, so this
+ * comparison is what makes the push admissible, never who sent it. Verify the signature with
+ * stored trust, then admit and fence atomically.
+ */
+export const bindApplyRuntimeNetworkDnsLeaseRenewalRequest = (value, trustedSessionValue) => networkSafe(() => {
+    const request = snapshotApplyRuntimeNetworkDnsLeaseRenewalRequest(value), session = snapshotRuntimeSessionBindingV1(trustedSessionValue);
+    requireNetwork(networkEqual(request.session, session) && networkSameScope(request.signed.renewal, session));
+    return request;
+});
+/** Compare the ACK with the exact SENT renewal, never with a response-derived value. */
+export const bindApplyRuntimeNetworkDnsLeaseRenewalResponse = (value, sentRenewalValue) => networkSafe(() => {
+    const response = snapshotApplyRuntimeNetworkDnsLeaseRenewalResponse(value);
+    const sent = getRuntimeNetworkDnsLeaseRenewalReference(snapshotRuntimeNetworkDnsLeaseRenewal(sentRenewalValue));
+    requireNetwork(networkEqual(response.renewal, sent));
+    return response;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/data/networklease.d.ts

@@ -0,0 +1,110 @@
+import type { TSha256Digest } from './immutableimage.js';
+import type { IRuntimeAuthorityReferenceV1 } from './runtimeassignment.js';
+import type { IRuntimeNetworkDnsWindow, IRuntimeNetworkNodeScopeV1 } from './networkprojection.js';
+/**
+ * A fresh DNS window for one exact admitted projection, and nothing else.
+ *
+ * A projection's window is signed content, so only a newly signed statement can extend it. A
+ * re-issued projection would do that too, but a receiver treats every new projection as new
+ * network state and applies it again; a renewal leaves the applied state alone. It names the
+ * projection by exact reference, so it never joins the projection chain and stops being
+ * admissible the moment a successor projection is admitted.
+ */
+export interface IRuntimeNetworkDnsLeaseRenewal extends IRuntimeNetworkNodeScopeV1 {
+    projection: IRuntimeAuthorityReferenceV1;
+    /** Orders the renewals of one projection. A receiver may skip sequences, never go back. */
+    sequence: number;
+    /**
+     * `issuedAt` is the start of the window's slot, not the signing instant: a controller signs a
+     * run of future windows ahead of time, and the fifteen-minute rule is measured from here.
+     */
+    dns: IRuntimeNetworkDnsWindow;
+    digest: TSha256Digest;
+}
+/** Names one renewal without its window: what a receiver records and what an ACK repeats. */
+export interface IRuntimeNetworkDnsLeaseRenewalReference {
+    projection: IRuntimeAuthorityReferenceV1;
+    sequence: number;
+    digest: TSha256Digest;
+}
+export interface ISignedRuntimeNetworkDnsLeaseRenewal {
+    /** The signing authority revision that also signs this controller's projections. */
+    authority: IRuntimeAuthorityReferenceV1;
+    renewal: IRuntimeNetworkDnsLeaseRenewal;
+    /** Ed25519 signature of the complete domain-separated envelope, lowercase hex. */
+    signature: string;
+}
+/**
+ * The renewals a cluster relay holds for one node it carries, replacing what it held before.
+ *
+ * The relay has no signing trust and verifies no signature: it holds signed statements and hands
+ * them to the node, which verifies each one against its own pinned authority.
+ */
+export interface IHoldRuntimeNetworkDnsLeaseRenewalsRequest {
+    /** The relay's own socket names the cluster; one relay carries every node of it, so the node is named here. */
+    nodeId: string;
+    projection: IRuntimeAuthorityReferenceV1;
+    /** Ascending by sequence. Empty holds nothing for this node. */
+    renewals: ISignedRuntimeNetworkDnsLeaseRenewal[];
+}
+export interface IHoldRuntimeNetworkDnsLeaseRenewalsResponse {
+    held: number;
+}
+export declare const runtimeNetworkDnsLeaseRenewalContract: Readonly<{
+    readonly renewalDigestDomain: "serve.zone/runtime-network-dns-lease-renewal";
+    readonly signatureDomain: "serve.zone/runtime-network-dns-lease-renewal-signature";
+    readonly maximumDnsLeaseMs: 900000;
+    readonly maximumEscrowedRenewals: 32;
+    /** From the first held window's `issuedAt` to the last one's `expiresAt`. */
+    readonly maximumEscrowHorizonMs: 14400000;
+    readonly binding: "exact-projection-reference";
+    readonly supersession: "a-successor-projection-refuses-every-renewal-of-its-predecessor";
+    readonly sequence: "strictly-increasing-per-projection-skipping-allowed";
+    readonly effect: "dns-window-only-never-applied-network-state";
+    readonly escrowRelease: "only-the-current-window-and-only-while-the-holder-has-no-controller-session";
+    readonly revocationLatency: "a-detached-cluster-keeps-dns-authority-until-its-last-held-window-ends";
+}>;
+export declare const snapshotRuntimeNetworkDnsLeaseRenewal: (value: unknown) => IRuntimeNetworkDnsLeaseRenewal;
+export declare const snapshotRuntimeNetworkDnsLeaseRenewalReference: (value: unknown) => IRuntimeNetworkDnsLeaseRenewalReference;
+export declare const getRuntimeNetworkDnsLeaseRenewalReference: (value: IRuntimeNetworkDnsLeaseRenewal) => IRuntimeNetworkDnsLeaseRenewalReference;
+export declare const snapshotSignedRuntimeNetworkDnsLeaseRenewal: (value: unknown) => ISignedRuntimeNetworkDnsLeaseRenewal;
+export declare const computeRuntimeNetworkDnsLeaseRenewalDigest: (value: IRuntimeNetworkDnsLeaseRenewal) => Promise<TSha256Digest>;
+/** Structure and digest only. A digest authenticates nothing: verify the signature with stored trust. */
+export declare const validateRuntimeNetworkDnsLeaseRenewal: (value: unknown) => Promise<IRuntimeNetworkDnsLeaseRenewal>;
+/**
+ * The DNS window a node may use under a projection: its admitted renewal's, else the projection's
+ * own. Controller and node derive every window-bounded fact, such as a VPN credential's expiry,
+ * from this one rule. renewalValue is the bare renewal `admitRuntimeNetworkDnsLeaseRenewal`
+ * admitted, or null; Cloudly passes `signed.renewal`. Both inputs are the caller's admitted state,
+ * so this checks structure, digests and that the renewal names exactly this projection; it
+ * verifies no signature and samples no clock.
+ */
+export declare const getRuntimeNetworkEffectiveDnsWindow: (projectionValue: unknown, renewalValue: unknown | null) => Promise<IRuntimeNetworkDnsWindow>;
+/**
+ * Pure admission decision for a renewal whose signature the caller has already verified.
+ *
+ * currentProjectionValue is the receiver's own admitted projection and previousValue the last
+ * renewal it admitted for that exact projection, or null when there is none; neither is ever
+ * taken from the incoming message. Without a previous renewal the projection's own window is the
+ * baseline. nowValue is the caller's qualified clock: a renewal is admitted only inside its own
+ * window, because storing a window that has not opened would displace the coverage the receiver
+ * has now. A sender therefore delivers a window once its slot has opened and never before, and
+ * simply delivers it again if it was refused. Re-delivering the renewal already admitted is
+ * answered `replay` whatever the time, so re-delivery stays idempotent. The caller commits the
+ * result atomically with its trust fence and discards the stored renewal in the transaction that
+ * admits a successor projection.
+ */
+export declare const admitRuntimeNetworkDnsLeaseRenewal: (value: unknown, currentProjectionValue: unknown, previousValue: unknown | null, trustedScopeValue: unknown, nowValue: unknown) => Promise<{
+    status: "accepted" | "replay";
+    renewal: IRuntimeNetworkDnsLeaseRenewal;
+}>;
+/**
+ * A held run is what one node could admit in order: one node, one projection, one authority,
+ * ascending sequences, each window extending the one before, inside both escrow maxima.
+ */
+export declare const snapshotHoldRuntimeNetworkDnsLeaseRenewalsRequest: (value: unknown) => IHoldRuntimeNetworkDnsLeaseRenewalsRequest;
+/** The run's rules plus every renewal's digest. It verifies no signature: a relay holds no trust. */
+export declare const validateHoldRuntimeNetworkDnsLeaseRenewalsRequest: (value: unknown) => Promise<IHoldRuntimeNetworkDnsLeaseRenewalsRequest>;
+export declare const snapshotHoldRuntimeNetworkDnsLeaseRenewalsResponse: (value: unknown) => IHoldRuntimeNetworkDnsLeaseRenewalsResponse;
+/** Compare the answer with the exact SENT run: a relay that held fewer did not take the run over. */
+export declare const bindHoldRuntimeNetworkDnsLeaseRenewalsResponse: (value: unknown, sentRequestValue: unknown) => IHoldRuntimeNetworkDnsLeaseRenewalsResponse;

package/dist_ts/data/networklease.js

@@ -0,0 +1,159 @@
+import { snapshotRuntimeNetworkNodeScopeV1, snapshotRuntimeNetworkProjectionV1, validateRuntimeNetworkProjectionV1 } from './networkprojection.js';
+import { captureNetwork, failNetwork, networkCounter, networkDigest, networkDnsWindow, networkEffectiveDnsWindow, networkEqual, networkHash, networkId, networkList, networkMaximumDnsLeaseMs, networkRecord, networkReference, networkReferenceOf, networkRenewsProjection, networkSafe, networkSameScope, networkScope, networkSignature, requireNetwork } from '../private/networkcontract.js';
+export const runtimeNetworkDnsLeaseRenewalContract = Object.freeze({
+    renewalDigestDomain: 'serve.zone/runtime-network-dns-lease-renewal',
+    signatureDomain: 'serve.zone/runtime-network-dns-lease-renewal-signature',
+    maximumDnsLeaseMs: networkMaximumDnsLeaseMs,
+    maximumEscrowedRenewals: 32,
+    /** From the first held window's `issuedAt` to the last one's `expiresAt`. */
+    maximumEscrowHorizonMs: 14_400_000,
+    binding: 'exact-projection-reference',
+    supersession: 'a-successor-projection-refuses-every-renewal-of-its-predecessor',
+    sequence: 'strictly-increasing-per-projection-skipping-allowed',
+    effect: 'dns-window-only-never-applied-network-state',
+    escrowRelease: 'only-the-current-window-and-only-while-the-holder-has-no-controller-session',
+    revocationLatency: 'a-detached-cluster-keeps-dns-authority-until-its-last-held-window-ends',
+});
+export const snapshotRuntimeNetworkDnsLeaseRenewal = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['controller', 'nodeId', 'runtimeNamespace', 'projection', 'sequence', 'dns', 'digest']);
+    return { ...networkScope(item), projection: networkReference(item.projection), sequence: networkCounter(item.sequence),
+        dns: networkDnsWindow(item.dns), digest: networkDigest(item.digest) };
+});
+export const snapshotRuntimeNetworkDnsLeaseRenewalReference = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['projection', 'sequence', 'digest']);
+    return { projection: networkReference(item.projection), sequence: networkCounter(item.sequence), digest: networkDigest(item.digest) };
+});
+export const getRuntimeNetworkDnsLeaseRenewalReference = (value) => ({ projection: networkReferenceOf(value.projection), sequence: value.sequence, digest: value.digest });
+export const snapshotSignedRuntimeNetworkDnsLeaseRenewal = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['authority', 'renewal', 'signature']);
+    return { authority: networkReference(item.authority), renewal: snapshotRuntimeNetworkDnsLeaseRenewal(item.renewal),
+        signature: networkSignature(item.signature) };
+});
+export const computeRuntimeNetworkDnsLeaseRenewalDigest = (value) => networkHash(runtimeNetworkDnsLeaseRenewalContract.renewalDigestDomain, snapshotRuntimeNetworkDnsLeaseRenewal(value));
+/** Structure and digest only. A digest authenticates nothing: verify the signature with stored trust. */
+export const validateRuntimeNetworkDnsLeaseRenewal = async (value) => {
+    try {
+        const renewal = snapshotRuntimeNetworkDnsLeaseRenewal(value);
+        requireNetwork(renewal.digest === await computeRuntimeNetworkDnsLeaseRenewalDigest(renewal));
+        return renewal;
+    }
+    catch {
+        return failNetwork();
+    }
+};
+/**
+ * A later window never moves its slot back and always ends later. Windows need not touch: a
+ * receiver that missed renewals while its lease lapsed must still be able to admit the next one.
+ */
+const extendsWindow = (next, baseline) => next.issuedAt >= baseline.issuedAt && next.expiresAt > baseline.expiresAt;
+/** A receiver admits only a window it can use at once: its slot has opened and it has not ended. */
+const isCurrentWindow = (window, now) => window.notBefore <= now && now < window.expiresAt;
+/**
+ * The DNS window a node may use under a projection: its admitted renewal's, else the projection's
+ * own. Controller and node derive every window-bounded fact, such as a VPN credential's expiry,
+ * from this one rule. renewalValue is the bare renewal `admitRuntimeNetworkDnsLeaseRenewal`
+ * admitted, or null; Cloudly passes `signed.renewal`. Both inputs are the caller's admitted state,
+ * so this checks structure, digests and that the renewal names exactly this projection; it
+ * verifies no signature and samples no clock.
+ */
+export const getRuntimeNetworkEffectiveDnsWindow = async (projectionValue, renewalValue) => {
+    try {
+        const projectionInput = snapshotRuntimeNetworkProjectionV1(projectionValue);
+        const renewalInput = renewalValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue);
+        const projection = await validateRuntimeNetworkProjectionV1(projectionInput);
+        const renewal = renewalInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(renewalInput);
+        return networkEffectiveDnsWindow(projection, renewal);
+    }
+    catch {
+        return failNetwork();
+    }
+};
+/**
+ * Pure admission decision for a renewal whose signature the caller has already verified.
+ *
+ * currentProjectionValue is the receiver's own admitted projection and previousValue the last
+ * renewal it admitted for that exact projection, or null when there is none; neither is ever
+ * taken from the incoming message. Without a previous renewal the projection's own window is the
+ * baseline. nowValue is the caller's qualified clock: a renewal is admitted only inside its own
+ * window, because storing a window that has not opened would displace the coverage the receiver
+ * has now. A sender therefore delivers a window once its slot has opened and never before, and
+ * simply delivers it again if it was refused. Re-delivering the renewal already admitted is
+ * answered `replay` whatever the time, so re-delivery stays idempotent. The caller commits the
+ * result atomically with its trust fence and discards the stored renewal in the transaction that
+ * admits a successor projection.
+ */
+export const admitRuntimeNetworkDnsLeaseRenewal = async (value, currentProjectionValue, previousValue, trustedScopeValue, nowValue) => {
+    try {
+        // Snapshot ALL caller-owned inputs before the first asynchronous operation.
+        const incoming = snapshotRuntimeNetworkDnsLeaseRenewal(value);
+        const projectionInput = snapshotRuntimeNetworkProjectionV1(currentProjectionValue);
+        const previousInput = previousValue === null ? null : snapshotRuntimeNetworkDnsLeaseRenewal(previousValue);
+        const trusted = snapshotRuntimeNetworkNodeScopeV1(trustedScopeValue);
+        const now = networkCounter(nowValue);
+        const renewal = await validateRuntimeNetworkDnsLeaseRenewal(incoming);
+        const projection = await validateRuntimeNetworkProjectionV1(projectionInput);
+        requireNetwork(networkSameScope(projection, trusted) && networkRenewsProjection(renewal, projection));
+        const previous = previousInput === null ? null : await validateRuntimeNetworkDnsLeaseRenewal(previousInput);
+        if (previous !== null) {
+            requireNetwork(networkRenewsProjection(previous, projection));
+            if (renewal.sequence === previous.sequence) {
+                requireNetwork(networkEqual(renewal, previous));
+                return { status: 'replay', renewal };
+            }
+            requireNetwork(renewal.sequence > previous.sequence);
+        }
+        requireNetwork(isCurrentWindow(renewal.dns, now));
+        requireNetwork(extendsWindow(renewal.dns, previous === null ? projection.dns : previous.dns));
+        return { status: 'accepted', renewal };
+    }
+    catch {
+        return failNetwork();
+    }
+};
+/** Consecutive held renewals: same signer and scope, a higher sequence, a window that extends the one before. */
+const followsInRun = (next, before) => networkEqual(next.authority, before.authority) && networkSameScope(next.renewal, before.renewal)
+    && next.renewal.sequence > before.renewal.sequence && extendsWindow(next.renewal.dns, before.renewal.dns);
+const heldHorizonMs = (renewals) => {
+    const first = renewals.at(0), last = renewals.at(-1);
+    return first === undefined || last === undefined ? 0 : last.renewal.dns.expiresAt - first.renewal.dns.issuedAt;
+};
+/**
+ * A held run is what one node could admit in order: one node, one projection, one authority,
+ * ascending sequences, each window extending the one before, inside both escrow maxima.
+ */
+export const snapshotHoldRuntimeNetworkDnsLeaseRenewalsRequest = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['nodeId', 'projection', 'renewals']);
+    const contract = runtimeNetworkDnsLeaseRenewalContract;
+    const request = { nodeId: networkId(item.nodeId), projection: networkReference(item.projection),
+        renewals: networkList(item.renewals, contract.maximumEscrowedRenewals, snapshotSignedRuntimeNetworkDnsLeaseRenewal) };
+    request.renewals.forEach((signed, index) => requireNetwork(signed.renewal.nodeId === request.nodeId
+        && networkEqual(signed.renewal.projection, request.projection)
+        && (index === 0 || followsInRun(signed, request.renewals[index - 1]))));
+    requireNetwork(heldHorizonMs(request.renewals) <= contract.maximumEscrowHorizonMs);
+    return request;
+});
+/** The run's rules plus every renewal's digest. It verifies no signature: a relay holds no trust. */
+export const validateHoldRuntimeNetworkDnsLeaseRenewalsRequest = async (value) => {
+    try {
+        const request = snapshotHoldRuntimeNetworkDnsLeaseRenewalsRequest(value);
+        for (const signed of request.renewals)
+            await validateRuntimeNetworkDnsLeaseRenewal(signed.renewal);
+        return request;
+    }
+    catch {
+        return failNetwork();
+    }
+};
+export const snapshotHoldRuntimeNetworkDnsLeaseRenewalsResponse = (value) => networkSafe(() => {
+    const item = networkRecord(captureNetwork(value), ['held']);
+    requireNetwork(typeof item.held === 'number' && Number.isSafeInteger(item.held) && item.held >= 0
+        && item.held <= runtimeNetworkDnsLeaseRenewalContract.maximumEscrowedRenewals);
+    return { held: item.held };
+});
+/** Compare the answer with the exact SENT run: a relay that held fewer did not take the run over. */
+export const bindHoldRuntimeNetworkDnsLeaseRenewalsResponse = (value, sentRequestValue) => networkSafe(() => {
+    const response = snapshotHoldRuntimeNetworkDnsLeaseRenewalsResponse(value);
+    requireNetwork(response.held === snapshotHoldRuntimeNetworkDnsLeaseRenewalsRequest(sentRequestValue).renewals.length);
+    return response;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networklease.js","sourceRoot":"","sources":["../../ts/data/networklease.ts"],"names":[],"mappings":"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"}