@zlink-systems/framework 0.29.0 → 0.30.0

package/dist/runtime/channels/channel-socket-registry.js

@@ -4,6 +4,7 @@ exports.ZLinkChannelSocketRegistry = void 0;
 const disposal_1 = require("../disposal");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
+const zlink_1 = require("@zlink-systems/zlink");
 const contracts_1 = require("../../contracts");
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
 const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
@@ -46,7 +47,6 @@ class ZLinkChannelSocketRegistry {
     clientServerServerDescriptors = new Map();
     clientServerPublicWeights = new Map();
     routeMeshPublicWeights = new Map();
-    clientServerAdmittedClients = new Map();
     clientServerServerPeers = new Map();
     disposal = new disposal_1.RuntimeDisposal();
     ownedResources = new Set();
@@ -83,8 +83,6 @@ class ZLinkChannelSocketRegistry {
             ...this.routeRouters.values()
         ];
         for (const socket of new Set([
-            ...this.clientDealers.values(),
-            ...clientServerConnections.map((value) => value.dealer),
             ...this.channelRouters.values(),
             ...this.routeRouters.values()
         ]))
@@ -93,7 +91,8 @@ class ZLinkChannelSocketRegistry {
         this.clientServerServerDescriptors.clear();
         this.clientServerPublicWeights.clear();
         this.routeMeshPublicWeights.clear();
-        this.clientServerAdmittedClients.clear();
+        for (const peers of this.clientServerServerPeers.values())
+            peers.clear();
         this.clientServerServerPeers.clear();
         this.clientServerMonitorHandlers.clear();
         this.fanoutMonitorHandlers.clear();
@@ -152,7 +151,6 @@ class ZLinkChannelSocketRegistry {
         }
         const dealer = this.adapter.createDealerSocket(this.context);
         this.clientDealers.set(channelName, dealer);
-        this.registerReceiveFlowSocket(dealer);
         dealer.setChannelName(channelName);
         if (channel?.routingId !== undefined && channel.routingId.length > 0) {
             dealer.setRoutingId(deriveRoutingId(channel.routingId, 'dealer'));
@@ -202,8 +200,7 @@ class ZLinkChannelSocketRegistry {
                     event.nativeEvent !== internal_event_contracts_1.ZLinkSocketNativeEventType.HandshakeFailedAuth)
                     return;
                 const routingId = String(event.routingId);
-                this.clientServerServerPeers.delete(clientServerServerPeerKey(channelName, routingId));
-                this.clientServerAdmittedClients.get(channelName)?.delete(routingId);
+                this.clientServerServerPeers.get(channelName)?.delete(routingId);
             });
         }
         const endpoint = advertisedEndpoint(router.lastEndpoint ?? channel.server.bind, channel.server.advertiseHost);
@@ -278,7 +275,6 @@ class ZLinkChannelSocketRegistry {
         const created = [dealer];
         try {
             this.clientServerConnections.set(connectionId, connection);
-            this.registerReceiveFlowSocket(dealer);
             dealer.setChannelName(channelName);
             dealer.setRoutingId(`cs-client-${(0, node_crypto_1.randomUUID)()}`);
             applySocketConfig(dealer, {
@@ -325,7 +321,6 @@ class ZLinkChannelSocketRegistry {
         }
         catch (error) {
             this.clientServerConnections.delete(connectionId);
-            this.unregisterReceiveFlowSocket(dealer);
             void Promise.allSettled(created.map(async (resource) => {
                 await resource.dispose();
                 this.ownedResources.delete(resource);
@@ -375,7 +370,6 @@ class ZLinkChannelSocketRegistry {
         catch {
             // The socket close below releases an endpoint that is already disconnected.
         }
-        this.unregisterReceiveFlowSocket(current.dealer);
         if (current.readablePoller !== undefined) {
             current.readablePoller.dispose();
             this.ownedResources.delete(current.readablePoller);
@@ -430,9 +424,8 @@ class ZLinkChannelSocketRegistry {
         const admitted = this.clientServerDiscovery.admitClientServer(descriptor, connectionId);
         if (admitted) {
             const now = performance.now();
-            connection.nextProbeAt = now + CLIENT_SERVER_PROBE_INTERVAL_MS;
-            connection.deadlineAt = now + CLIENT_SERVER_PEER_DEADLINE_MS;
-            connection.outstandingProbeId = undefined;
+            connection.liveness = new service_liveness_registry_1.ServiceLivenessConnection(connectionId, now);
+            connection.dealer.receiveAdmission = connection.liveness;
             this.clientServerReadyIdentities.set(connectionId, {
                 channelName: descriptor.channelName,
                 serverRoutingId: descriptor.serverRoutingId,
@@ -451,9 +444,8 @@ class ZLinkChannelSocketRegistry {
             const connection = this.clientServerConnections.get(connectionId);
             if (connection?.readyConnectionId === connectionId) {
                 connection.readyConnectionId = undefined;
-                connection.deadlineAt = undefined;
-                connection.nextProbeAt = undefined;
-                connection.outstandingProbeId = undefined;
+                connection.liveness = undefined;
+                connection.dealer.receiveAdmission = undefined;
             }
         }
         this.notifyClientServerTopology(channelName);
@@ -657,7 +649,18 @@ class ZLinkChannelSocketRegistry {
         for (const handler of this.clientServerMonitorHandlers.get(channelName) ?? [])
             handler();
     }
-    tryHandleClientServerControl(channelName, received, router) {
+    clientServerServerPeersForChannel(channelName) {
+        let peers = this.clientServerServerPeers.get(channelName);
+        if (peers === undefined) {
+            peers = new Map();
+            this.clientServerServerPeers.set(channelName, peers);
+        }
+        return peers;
+    }
+    tryHandleClientServerControl(channelName, received, router, peers = this.clientServerServerPeersForChannel(channelName)) {
+        const routingId = String(received.routingId);
+        const peer = peers.get(routingId);
+        peer?.liveness.recordReceived();
         if (received.parts.length === 0)
             return false;
         const first = received.parts[0];
@@ -674,8 +677,8 @@ class ZLinkChannelSocketRegistry {
             else if (record.kind === 'livenessAck' &&
                 received.parts.length === 1 &&
                 received.replyToken === null) {
-                if (!this.acceptClientServerServerLivenessAck(channelName, String(received.routingId), record.probeId)) {
-                    this.reportStaleClientServerLivenessAck(channelName, String(received.routingId), record.probeId);
+                if (!this.acceptClientServerServerLivenessAck(peer, record.probeId)) {
+                    this.reportStaleClientServerLivenessAck(channelName, routingId, record.probeId);
                 }
                 return true;
             }
@@ -694,7 +697,7 @@ class ZLinkChannelSocketRegistry {
                 else {
                     const normalizedEffectiveMaxMessageBytes = Math.min((0, client_server_service_wire_1.normalizeClientServerMessageLimit)(router.maxMessageSize), record.hello.normalizedEffectiveMaxMessageBytes);
                     reply = (0, client_server_service_wire_1.encodeClientServerAdmit)(descriptor, normalizedEffectiveMaxMessageBytes);
-                    this.admitClientServerServerPeer(channelName, String(received.routingId), normalizedEffectiveMaxMessageBytes);
+                    this.admitClientServerServerPeer(channelName, routingId, normalizedEffectiveMaxMessageBytes);
                 }
             }
         }
@@ -704,7 +707,7 @@ class ZLinkChannelSocketRegistry {
         if (received.replyToken !== null) {
             const message = runtime_message_1.ZLinkBufferMessage.from(reply);
             try {
-                router.reply(received.routingId, received.replyToken, message);
+                router.reply(routingId, received.replyToken, message);
             }
             finally {
                 message.close();
@@ -720,37 +723,33 @@ class ZLinkChannelSocketRegistry {
             if (connectionId === undefined)
                 continue;
             this.drainClientServerControl(connectionId, connection);
-            if (connection.deadlineAt === undefined)
+            if (connection.liveness === undefined)
                 continue;
-            if (nowMs >= connection.deadlineAt) {
+            if (connection.liveness.isExpired(nowMs)) {
                 this.restartClientServerAdmission(connectionId, connection);
                 continue;
             }
-            if (connection.nextProbeAt === undefined || nowMs < connection.nextProbeAt)
+            const probeId = connection.liveness.tryGetProbe(nowMs, () => this.allocateClientServerProbeId());
+            if (probeId === undefined)
                 continue;
-            connection.nextProbeAt = nowMs + CLIENT_SERVER_PROBE_INTERVAL_MS;
-            const probeId = connection.outstandingProbeId ?? this.allocateClientServerProbeId();
-            connection.outstandingProbeId = probeId;
             this.requestClientServerLiveness(connectionId, connection, probeId);
         }
-        for (const [key, peer] of [...this.clientServerServerPeers]) {
-            if (nowMs >= peer.deadlineAt) {
-                this.clientServerServerPeers.delete(key);
-                this.clientServerAdmittedClients.get(peer.channelName)?.delete(peer.routingId);
-                try {
-                    this.channelRouters.get(peer.channelName)?.disconnectPeer(peer.routingId);
-                }
-                catch (error) {
-                    this.oneWayFailureSink?.(error);
+        for (const peers of this.clientServerServerPeers.values()) {
+            for (const [routingId, peer] of peers) {
+                if (peer.liveness.isExpired(nowMs)) {
+                    peers.delete(routingId);
+                    try {
+                        this.channelRouters.get(peer.channelName)?.disconnectPeer(peer.routingId);
+                    }
+                    catch (error) {
+                        this.oneWayFailureSink?.(error);
+                    }
+                    continue;
                 }
-                continue;
+                const probeId = peer.liveness.tryGetProbe(nowMs, () => this.allocateClientServerProbeId());
+                if (probeId !== undefined)
+                    this.requestClientServerServerLiveness(peer, probeId);
             }
-            if (nowMs < peer.nextProbeAt)
-                continue;
-            peer.nextProbeAt = nowMs + CLIENT_SERVER_PROBE_INTERVAL_MS;
-            const probeId = peer.outstandingProbeId ?? this.allocateClientServerProbeId();
-            peer.outstandingProbeId = probeId;
-            this.requestClientServerServerLiveness(peer, probeId);
         }
         this.tickFanoutLiveness(nowMs);
     }
@@ -1040,6 +1039,7 @@ class ZLinkChannelSocketRegistry {
         }
     }
     drainClientServerControl(connectionId, connection) {
+        const admission = connection.liveness;
         for (;;) {
             if (connection.readablePoller === undefined || !connection.readablePoller.wait(0))
                 return;
@@ -1048,6 +1048,7 @@ class ZLinkChannelSocketRegistry {
                 connection.readablePoller.markDrained();
                 return;
             }
+            admission?.recordReceived();
             try {
                 if (received.parts.length !== 1 || !(0, client_server_service_wire_1.isClientServerControlFrame)(received.parts[0].data())) {
                     throw new configuration_1.ZLinkConfigurationException(`ClientServer '${connection.channelName}' received an unsolicited application frame.`);
@@ -1164,13 +1165,13 @@ class ZLinkChannelSocketRegistry {
             if (connection.readyConnectionId === connectionId) {
                 connection.readyConnectionId = undefined;
             }
-            connection.deadlineAt = undefined;
-            connection.nextProbeAt = undefined;
-            connection.outstandingProbeId = undefined;
+            connection.liveness = undefined;
+            connection.dealer.receiveAdmission = undefined;
         }
         this.notifyClientServerTopology(identity.channelName);
     }
     requestClientServerLiveness(connectionId, connection, probeId) {
+        const admission = connection.liveness;
         const message = runtime_message_1.ZLinkBufferMessage.from((0, client_server_service_wire_1.encodeClientServerLivenessProbe)(probeId));
         void connection.dealer
             .request(message, CLIENT_SERVER_PEER_DEADLINE_MS)
@@ -1179,17 +1180,17 @@ class ZLinkChannelSocketRegistry {
                 const current = this.clientServerConnections.get(connectionId);
                 if (current === undefined ||
                     current.physicalConnectionId !== connection.physicalConnectionId ||
+                    current.liveness !== admission ||
                     parts.length !== 1)
                     return;
                 const record = (0, client_server_service_wire_1.decodeClientServerControl)(parts[0].data());
                 if (record.kind !== 'livenessAck')
                     return;
-                if (current.outstandingProbeId !== probeId || record.probeId !== probeId) {
+                if (admission === undefined ||
+                    !admission.acknowledge(record.probeId, performance.now())) {
                     this.reportStaleClientServerLivenessAck(connection.channelName, connectionId, record.probeId);
                     return;
                 }
-                current.outstandingProbeId = undefined;
-                current.deadlineAt = performance.now() + CLIENT_SERVER_PEER_DEADLINE_MS;
             }
             finally {
                 closeMessages(parts);
@@ -1199,23 +1200,13 @@ class ZLinkChannelSocketRegistry {
             .finally(() => message.close());
     }
     admitClientServerServerPeer(channelName, routingId, normalizedEffectiveMaxMessageBytes) {
-        const key = clientServerServerPeerKey(channelName, routingId);
-        const now = performance.now();
         const peer = {
             channelName,
             routingId,
-            physicalConnectionId: Symbol(key),
             normalizedEffectiveMaxMessageBytes,
-            nextProbeAt: now + CLIENT_SERVER_PROBE_INTERVAL_MS,
-            deadlineAt: now + CLIENT_SERVER_PEER_DEADLINE_MS
+            liveness: new service_liveness_registry_1.ServiceLivenessConnection(clientServerServerPeerKey(channelName, routingId), performance.now())
         };
-        this.clientServerServerPeers.set(key, peer);
-        let clients = this.clientServerAdmittedClients.get(channelName);
-        if (clients === undefined) {
-            clients = new Set();
-            this.clientServerAdmittedClients.set(channelName, clients);
-        }
-        clients.add(routingId);
+        this.clientServerServerPeersForChannel(channelName).set(routingId, peer);
         this.ensureClientServerLivenessTimer();
     }
     requestClientServerServerLiveness(peer, probeId) {
@@ -1228,33 +1219,22 @@ class ZLinkChannelSocketRegistry {
             .catch((error) => this.oneWayFailureSink?.(error))
             .finally(() => message.close());
     }
-    acceptClientServerServerLivenessAck(channelName, routingId, probeId) {
-        const peer = this.clientServerServerPeers.get(clientServerServerPeerKey(channelName, routingId));
-        if (peer === undefined || peer.outstandingProbeId !== probeId)
-            return false;
-        peer.outstandingProbeId = undefined;
-        peer.deadlineAt = performance.now() + CLIENT_SERVER_PEER_DEADLINE_MS;
-        return true;
+    acceptClientServerServerLivenessAck(peer, probeId) {
+        return peer?.liveness.acknowledge(probeId, performance.now()) ?? false;
     }
     reportStaleClientServerLivenessAck(channelName, peer, probeId) {
         this.oneWayFailureSink?.((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestProtocolError, `ClientServer '${channelName}' ignored stale or duplicate liveness ACK '${probeId}' from '${peer}'.`, false));
     }
     pushClientServerDescriptorUpdate(channelName, descriptor) {
         const router = this.channelRouters.get(channelName);
-        const clients = this.clientServerAdmittedClients.get(channelName);
-        if (router === undefined || clients === undefined)
+        const peers = this.clientServerServerPeers.get(channelName);
+        if (router === undefined || peers === undefined)
             return;
-        for (const routingId of [...clients]) {
-            const peer = this.clientServerServerPeers.get(clientServerServerPeerKey(channelName, routingId));
-            if (peer === undefined) {
-                clients.delete(routingId);
-                continue;
-            }
+        for (const [routingId, peer] of peers) {
             const message = runtime_message_1.ZLinkBufferMessage.from((0, client_server_service_wire_1.encodeClientServerUpdate)(descriptor, peer.normalizedEffectiveMaxMessageBytes));
             void router
                 .send(routingId, message)
                 .catch((error) => {
-                clients.delete(routingId);
                 this.oneWayFailureSink?.(error);
             })
                 .finally(() => message.close());
@@ -1338,7 +1318,7 @@ class ZLinkChannelSocketRegistry {
         router.peerWeight = rawAvailabilityWeight(weight);
     }
     registerReceiveFlowSocket(socket) {
-        this.applicationJobQueue?.registerReceiveFlowTarget(socket, (state) => socket.setReceiveFlowState(state === 'paused' ? 1 : 0), this.oneWayFailureSink);
+        this.applicationJobQueue?.registerReceiveFlowTarget(socket, (state) => socket.setReceiveFlowState(state === 'paused' ? zlink_1.ReceiveFlowState.PAUSED : zlink_1.ReceiveFlowState.RUNNING), this.oneWayFailureSink);
     }
     unregisterReceiveFlowSocket(socket) {
         this.applicationJobQueue?.unregisterReceiveFlowTarget(socket);
@@ -1463,7 +1443,7 @@ function deriveRoutingId(baseRoutingId, suffix) {
 }
 function applyFanoutPublisherSocketOptions(publisher, channel) {
     publisher.noDrop = channel.noDrop ?? false;
-    publisher.sendTimeoutMs = configuredSendTimeoutMs(channel.publisher?.sendTimeoutMs);
+    publisher.sendTimeoutMs = channel.sendTimeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
 }
 function fanoutDiscoveryConnectionId(connectionId) {
     return `fanout:${connectionId.replaceAll('\0', '/')}`;
@@ -1506,6 +1486,3 @@ function applySocketConfig(socket, config) {
         socket.maxMessageSize = config.maxMessageSize;
     }
 }
-function configuredSendTimeoutMs(value) {
-    return value ?? DEFAULT_SEND_TIMEOUT_MS;
-}

package/dist/runtime/diagnostics/message-flow.d.ts

@@ -10,6 +10,7 @@ export interface ZLinkDiagnosticsContext {
     readonly sourceMeshGeneration: bigint;
 }
 export declare const DEFAULT_ZLINK_DIAGNOSTICS: ZLinkDiagnosticsOptions;
+export declare const telemetryLogger: import("@opentelemetry/api-logs").Logger;
 export declare function effectiveMessageFlow(ctx: ZLinkDiagnosticsContext): ZLinkMessageFlowLogMode;
 export declare function createMessageFlowModeCell(dispatch: {
     diagnostics?: ZLinkDiagnosticsOptions;

package/dist/runtime/diagnostics/message-flow.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkMessageFlowTracer = exports.DEFAULT_ZLINK_DIAGNOSTICS = void 0;
+exports.ZLinkMessageFlowTracer = exports.telemetryLogger = exports.DEFAULT_ZLINK_DIAGNOSTICS = void 0;
 exports.effectiveMessageFlow = effectiveMessageFlow;
 exports.createMessageFlowModeCell = createMessageFlowModeCell;
 exports.createDiagnosticsContext = createDiagnosticsContext;
@@ -18,7 +18,7 @@ exports.DEFAULT_ZLINK_DIAGNOSTICS = {
     sampleRate: 1,
     includeMessageSizes: false
 };
-const telemetryLogger = api_logs_1.logs.getLogger('@zlink-systems/framework');
+exports.telemetryLogger = api_logs_1.logs.getLogger('@zlink-systems/framework');
 const telemetryTracer = api_1.trace.getTracer('@zlink-systems/framework');
 let diagnosticsGeneration = 0n;
 function effectiveMessageFlow(ctx) {
@@ -165,7 +165,7 @@ class ZLinkMessageFlowTracer {
     publishToLogger(record) {
         try {
             const severityNumber = record.eventId === DISPATCH_ERROR_EVENT_ID ? api_logs_1.SeverityNumber.ERROR : api_logs_1.SeverityNumber.INFO;
-            telemetryLogger.emit({
+            exports.telemetryLogger.emit({
                 eventName: record.eventId,
                 timestamp: record.timestamp,
                 severityNumber,

package/dist/runtime/foundation/raw-service-mesh-runtime.d.ts

@@ -29,6 +29,8 @@ export interface RawServiceIngressRecord {
 }
 export type RawServiceIngressHandler = (record: RawServiceIngressRecord) => RawServicePumpResult | undefined | Promise<RawServicePumpResult | undefined>;
 export interface RawServiceMeshRuntimeOptions {
+    readonly onReceiveReady?: () => void;
+    readonly infrastructureTaskRunner?: import('../spots/spot-actor-join-dispatch').ZLinkDetachedTaskRunner;
     readonly onPendingOperationsChanged?: () => void;
     readonly descriptor: ServiceNodeDescriptor;
     readonly resolveAdvertisedEndpoint?: (boundEndpoint: string) => string;
@@ -70,6 +72,12 @@ export declare class RawServiceMeshRuntime {
     private readonly applicationJobQueue;
     private readonly peerAdmissionSealed?;
     private readonly applicationJobStop;
+    private receiveAcquisition?;
+    private receivePermit?;
+    private readonly controlSends;
+    private infrastructureFailure?;
+    private readonly onReceiveReady?;
+    private readonly infrastructureTaskRunner?;
     private readonly onPeerNotRequired?;
     private readonly onPeerDisconnected?;
     private readonly onProtocolError?;
@@ -123,7 +131,7 @@ export declare class RawServiceMeshRuntime {
     private processReceived;
     expireOperations(nowMs: number, turnDeadlineMs: number): number;
     get pendingOperationCount(): number;
-    tickLiveness(nowMs?: number): Promise<ServiceLivenessTick>;
+    tickLiveness(nowMs?: number): ServiceLivenessTick;
     /**
      * The socket's one route observer (Core ROUTER §10.1). It replaces the
      * observation with Core's selected-route snapshot, ends the admission of
@@ -144,6 +152,12 @@ export declare class RawServiceMeshRuntime {
     private selectBilateralConnection;
     private removePeer;
     private requireStarted;
+    private sendControl;
+    private submitControl;
+    private startControlSend;
+    private reportInfrastructureFailure;
+    private observeInfrastructureFailure;
     private send;
+    private sendFailure;
 }
 export {};