@zlink-systems/framework 0.29.1 → 0.30.1

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/channels/channel-transports.d.ts

@@ -11,7 +11,7 @@ import type { ZLinkSpotRoutedSendOptions, ZLinkSpotRoutedRequestOptions } from '
 import { type ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
 export interface ZLinkChannelClientTransport {
     send(channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
-    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     tryPublish?(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
 }
@@ -22,9 +22,9 @@ export interface ZLinkSpotPublisherClientTransport {
 }
 export interface ZLinkRouteClientTransport {
     submit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
-    request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     submitToChannel(meshName: string, channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
-    requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     sendToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
         readonly packetName?: string;
         readonly metadata?: ReadonlyMap<string, string>;
@@ -33,24 +33,25 @@ export interface ZLinkRouteClientTransport {
         readonly packetName?: string;
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<TReply>;
 }
 interface ZLinkChannelTransportRuntime {
     send(channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     tryPublish(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
     routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
-    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
-    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
-    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
+    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
+    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
+    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
 }
 export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     private readonly manager;
@@ -63,20 +64,20 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
     private readonly flowCreationEnabled;
     private readonly outboundFlow;
     constructor(manager: () => ZLinkChannelTransportRuntime | undefined, routeChannelPredicate?: ((routerChannelId: string) => boolean) | undefined, meshRuntime?: (() => {
-        readonly meshNode: (meshName: string) => ZLinkBackendMeshNode | undefined;
+        readonly meshNode?: (meshName: string) => ZLinkBackendMeshNode | undefined;
         readonly meshCompletionTable: (meshName: string) => ZLinkMeshCompletionTable | undefined;
     } | undefined) | undefined, codecs?: ZLinkChannelEnvelopeCodecRegistry | undefined, manualNodeTarget?: ((meshName: string, targetNodeRid: string) => boolean | undefined) | undefined, localNodeSubmit?: ((meshName: string, sourceNodeRid: string, parts: readonly MessageLike[]) => ZLinkSubmitResult) | undefined, metrics?: ZLinkRuntimeMetrics | undefined, flowCreationEnabled?: () => boolean, outboundFlow?: () => ZLinkMessageFlowTracer | undefined);
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
-    submit(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    submitInfrastructure(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    submit(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
+    submitInfrastructure(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
     private submitNode;
-    request<TReply>(meshName: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    request<TReply>(meshName: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     private requestScoped;
     private traceNodeRequest;
     submitToChannel(meshName: string, channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     private submitToChannelScoped;
-    requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     private requestToChannelScoped;
     private submitRequestOperation;
     sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: ZLinkSpotRoutedSendOptions): Promise<ZLinkSubmitResult>;
@@ -91,19 +92,21 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
         readonly packetName?: string;
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<TReply>;
     requestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
     requestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
     private requestRawToSpotScoped;
     private requireManager;
     private meshNode;
-    private isSelfNode;
     private isKnownBackendPeer;
     private submitLocalNode;
     private requireMeshNode;

package/dist/runtime/channels/channel-transports.js

@@ -19,6 +19,7 @@ const framework_errors_internal_1 = require("../framework-errors-internal");
 const submission_result_1 = require("../messaging/submission-result");
 const routing_id_1 = require("../routing-id");
 const channel_envelope_1 = require("./channel-envelope");
+const NON_BLOCKING_SEND_OPTIONS = Object.freeze({ flags: runtime_values_1.ZLINK_BACKEND_SEND_DONT_WAIT });
 class ZLinkRuntimeRouteTransport {
     manager;
     routeChannelPredicate;
@@ -52,15 +53,19 @@ class ZLinkRuntimeRouteTransport {
             this.routeChannelPredicate?.(routerChannelId) ??
             false);
     }
-    async submit(meshName, targetNodeRid, packetName, message, metadata) {
+    submit(meshName, targetNodeRid, packetName, message, metadata) {
         // Call-scoped flow (spec 27 §4): the envelope flow pair lives only for
         // the duration of this outbound call, never in the caller's context.
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, false));
+        if (!this.flowCreationEnabled())
+            return this.submitNode(meshName, targetNodeRid, packetName, message, metadata, false);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, false));
     }
-    async submitInfrastructure(meshName, targetNodeRid, packetName, message, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true));
+    submitInfrastructure(meshName, targetNodeRid, packetName, message, metadata) {
+        if (!this.flowCreationEnabled())
+            return this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true));
     }
-    async submitNode(meshName, targetNodeRid, packetName, message, metadata, allowObjectClientTarget) {
+    submitNode(meshName, targetNodeRid, packetName, message, metadata, allowObjectClientTarget) {
         const node = this.meshNode(meshName);
         if (node === undefined) {
             return this.requireManager().routeSubmit(meshName, targetNodeRid, packetName, message, metadata);
@@ -70,28 +75,35 @@ class ZLinkRuntimeRouteTransport {
             return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
         }
         const parts = this.encodeMessage(3 /* ZLinkChannelMessageKind.Command */, meshName, packetName, message, undefined, metadata);
-        const operation = `MeshNode '${meshName}' send to node '${targetNodeRid}'`;
-        if (this.isSelfNode(node, targetNodeRid)) {
-            return this.submitLocalNode(meshName, String(node.status().routingId), parts);
+        const sourceNodeRid = node.routingId ?? node.status().routingId;
+        if ((0, routing_id_1.routingIdsEqual)(sourceNodeRid, targetNodeRid)) {
+            return this.submitLocalNode(meshName, String(sourceNodeRid), parts);
         }
-        if (!this.isKnownBackendPeer(node, targetNodeRid) &&
-            this.manualNodeTarget?.(meshName, targetNodeRid) === false) {
+        if (this.manualNodeTarget?.(meshName, targetNodeRid) === false &&
+            !this.isKnownBackendPeer(node, targetNodeRid)) {
             return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
         }
         try {
-            return mapMeshSubmitResult(await node.sendToNode((0, routing_id_1.toBackendRoutingId)(targetNodeRid), parts, { flags: 1 }));
+            const submitted = node.sendToNode((0, routing_id_1.toBackendRoutingId)(targetNodeRid), parts, NON_BLOCKING_SEND_OPTIONS);
+            return submitted instanceof Promise
+                ? submitted.then(mapMeshSubmitResult, (error) => {
+                    throw mapMeshSubmissionError(error, `MeshNode '${meshName}' send to node '${targetNodeRid}'`);
+                })
+                : mapMeshSubmitResult(submitted);
         }
         catch (error) {
-            throw mapMeshSubmissionError(error, operation);
+            throw mapMeshSubmissionError(error, `MeshNode '${meshName}' send to node '${targetNodeRid}'`);
         }
     }
-    request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata));
+    request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        if (!this.flowCreationEnabled())
+            return this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted));
     }
-    async requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
+    async requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
         const node = this.meshNode(meshName);
         if (node === undefined) {
-            return this.requireManager().routeRequest(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata);
+            return this.requireManager().routeRequest(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted);
         }
         const correlationId = (0, channel_envelope_1.newChannelCorrelationId)();
         try {
@@ -103,6 +115,7 @@ class ZLinkRuntimeRouteTransport {
             const completion = await this.submitRequestOperation(meshName, timeoutMs, signal, `MeshNode '${meshName}' request to node '${targetNodeRid}'`, (remainingTimeoutMs) => {
                 const operationId = node.requestToNode((0, routing_id_1.toBackendRoutingId)(targetNodeRid), parts, {
                     flags: 1,
+                    onAdmitted,
                     timeoutMs: remainingTimeoutMs
                 });
                 this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, undefined, meshName, targetNodeRid, packetName, correlationId);
@@ -142,7 +155,7 @@ class ZLinkRuntimeRouteTransport {
         const parts = this.encodeMessage(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, metadata);
         const operation = `MeshNode '${meshName}' send to channel '${channelName}'`;
         try {
-            const result = mapMeshSubmitResult(await node.sendToChannel(channelName, parts, { flags: 1 }));
+            const result = mapMeshSubmitResult(await node.sendToChannel(channelName, parts, NON_BLOCKING_SEND_OPTIONS));
             if (result.status === submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
                 this.metrics?.recordChannelSelectionFailure(meshName, channelName, 'no_ready_target');
             }
@@ -152,16 +165,22 @@ class ZLinkRuntimeRouteTransport {
             throw mapMeshSubmissionError(error, operation);
         }
     }
-    requestToChannel(meshName, channelName, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata));
+    requestToChannel(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        if (!this.flowCreationEnabled())
+            return this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted));
     }
-    async requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata) {
+    async requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const node = this.requireMeshNode(meshName);
         const parts = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, metadata);
         const metric = this.metrics?.startRequest(meshName, 'channel');
         try {
-            const completion = await this.submitRequestOperation(meshName, timeoutMs, signal, `MeshNode '${meshName}' request to channel '${channelName}'`, (remainingTimeoutMs) => node.requestToChannel(channelName, parts, { flags: 1, timeoutMs: remainingTimeoutMs }));
+            const completion = await this.submitRequestOperation(meshName, timeoutMs, signal, `MeshNode '${meshName}' request to channel '${channelName}'`, (remainingTimeoutMs) => node.requestToChannel(channelName, parts, {
+                flags: 1,
+                timeoutMs: remainingTimeoutMs,
+                onAdmitted
+            }));
             const reply = this.decodeMeshReply(meshName, completion);
             metric?.complete('completed');
             return reply;
@@ -232,18 +251,19 @@ class ZLinkRuntimeRouteTransport {
             if (spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Instance) {
                 throw new configuration_1.ZLinkConfigurationException('Instance Spot routes require the MeshNode command 39 transport.');
             }
-            return this.requireManager().routeRequestToSpot(spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.metadata);
+            return this.requireManager().routeRequestToSpot(spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.metadata, options.onAdmitted);
         }
         (0, abort_1.throwIfAborted)(options.signal);
         let completionPromise;
         try {
             const encoded = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, meshName, options.packetName, request, options.timeoutMs, options.metadata);
             completionPromise = this.completionTable(meshName).submit(() => spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Instance
-                ? node.requestInstanceSpot(instanceSpotRouteFence(spotRouteTarget), encoded, options.timeoutMs, undefined, options.metadata, options.instanceSpot)
+                ? node.requestInstanceSpot(instanceSpotRouteFence(spotRouteTarget), encoded, options.timeoutMs, undefined, options.metadata, options.instanceSpot, options.onAdmitted)
                 : node
                     .entrySpot()
                     .requestToSpot((0, routing_id_1.toBackendRoutingId)(spotRouteTarget.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(spotRouteTarget.spotId), spotRouteTarget.targetSpotGeneration ?? 0n, encoded, {
                     flags: 1,
+                    onAdmitted: options.onAdmitted,
                     timeoutMs: options.timeoutMs,
                     routeFence: directSpotRouteFence(spotRouteTarget),
                     entrySpot: spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Entry
@@ -255,10 +275,10 @@ class ZLinkRuntimeRouteTransport {
         return this.waitForMeshReply(meshName, completionPromise);
     }
     async requestFromSpotToSpot(sourceSpot, spotRouteTarget, request, options) {
-        return this.requireManager().routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal);
+        return this.requireManager().routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.onAdmitted);
     }
     async requestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options) {
-        return this.requireManager().routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options.timeoutMs, options.signal);
+        return this.requireManager().routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options.timeoutMs, options.signal, options.onAdmitted);
     }
     requestRawToSpot(spotRouteTarget, request, options) {
         return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestRawToSpotScoped(spotRouteTarget, request, options));
@@ -277,6 +297,7 @@ class ZLinkRuntimeRouteTransport {
                     .entrySpot()
                     .requestToSpot((0, routing_id_1.toBackendRoutingId)(spotRouteTarget.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(spotRouteTarget.spotId), spotRouteTarget.targetSpotGeneration ?? 0n, parts, {
                     flags: 1,
+                    onAdmitted: options.onAdmitted,
                     timeoutMs: options.timeoutMs,
                     routeFence: directSpotRouteFence(spotRouteTarget),
                     entrySpot: spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Entry
@@ -302,7 +323,7 @@ class ZLinkRuntimeRouteTransport {
                 (0, mesh_completion_table_1.closeMeshCompletion)(completion);
             }
         }
-        return this.requireManager().routeRequestRawToSpot(spotRouteTarget, request, options.timeoutMs, options.signal);
+        return this.requireManager().routeRequestRawToSpot(spotRouteTarget, request, options.timeoutMs, options.signal, options.onAdmitted);
     }
     requireManager() {
         const manager = this.manager();
@@ -312,11 +333,7 @@ class ZLinkRuntimeRouteTransport {
         return manager;
     }
     meshNode(meshName) {
-        const runtime = this.meshRuntime?.();
-        return runtime?.meshNode?.(meshName);
-    }
-    isSelfNode(node, targetNodeRid) {
-        return (0, routing_id_1.routingIdsEqual)(node.status().routingId, targetNodeRid);
+        return this.meshRuntime?.()?.meshNode?.(meshName);
     }
     isKnownBackendPeer(node, targetNodeRid) {
         return node