@zlink-systems/framework 0.29.1 → 0.30.1

package/dist/runtime/foundation/raw-service-mesh-runtime.js

@@ -6,6 +6,7 @@ const application_ingress_record_owner_1 = require("../application-jobs/applicat
 const submission_result_1 = require("../messaging/submission-result");
 const runtime_values_1 = require("../backend/runtime-values");
 const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
+const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
 const operation_registry_1 = require("./operation-registry");
 const service_liveness_registry_1 = require("./service-liveness-registry");
 const service_mailbox_1 = require("./service-mailbox");
@@ -17,6 +18,7 @@ const nativeErrnoValues = node_os_1.constants.errno;
 // Framework error code 13 (RequestTargetNotFound) is encoded as 14 on a
 // RequestResult.NotFound reply. Boundary transport results keep failureCode 0.
 const RAW_MESH_RECEIVE_RECORD_BUDGET = 64;
+const NODE_SEND_HEADER = (0, service_wire_m6a_codec_1.encodeNodeSendHeader)();
 const RAW_MESH_RECEIVE_BYTE_BUDGET = 4 * 1024 * 1024;
 exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS = 2;
 const REQUEST_TARGET_NOT_FOUND_FAILURE_CODE = service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestTargetNotFound;
@@ -37,6 +39,7 @@ class RawServiceMeshRuntime {
     expectedPeers = new Map();
     endpointOnlyPeers = new Set();
     peerConnectionIntentRemoved = new Set();
+    peerRouteChanged = new Set();
     /**
      * The last observed Core selected route of each RID (Core ROUTER §10.1):
      * RID -> route generation. Only `observeSelectedRoutes` replaces it.
@@ -44,8 +47,16 @@ class RawServiceMeshRuntime {
     selectedRoutes = new Map();
     bindingPort;
     applicationJobQueue;
+    nodeMailboxOwner;
     peerAdmissionSealed;
     applicationJobStop = new AbortController();
+    receiveAcquisition;
+    receivePermit;
+    receiveRotation;
+    controlSends = new Map();
+    infrastructureFailure;
+    onReceiveReady;
+    infrastructureTaskRunner;
     onPeerNotRequired;
     onPeerDisconnected;
     onProtocolError;
@@ -56,10 +67,14 @@ class RawServiceMeshRuntime {
     router;
     nextCorrelation = 1n;
     serviceIngress;
+    serviceIngressAccepts;
     closed = false;
     constructor(options) {
+        this.onReceiveReady = options.onReceiveReady;
+        this.infrastructureTaskRunner = options.infrastructureTaskRunner;
         this.operations = new operation_registry_1.OperationRegistry(undefined, options.onPendingOperationsChanged);
         this.descriptor = options.descriptor;
+        this.nodeMailboxOwner = `node:${options.descriptor.nodeRoutingId}`;
         this.topology = new service_topology_registry_1.ServiceTopologyRegistry(options.descriptor);
         this.mailbox = new service_mailbox_1.ServiceMailbox(options.onMailboxReady);
         this.liveness = new service_liveness_registry_1.ServiceLivenessRegistry(options.probeIntervalMs, options.peerTimeoutMs);
@@ -214,6 +229,30 @@ class RawServiceMeshRuntime {
             this.peerConnectionIntentRemoved.delete(listener);
         };
     }
+    observePeerRoute(nodeRoutingId) {
+        const selected = this.selectedRoutes.get(nodeRoutingId);
+        const admitted = this.topology.admittedPeer(nodeRoutingId)?.liveness?.connectionId;
+        return {
+            generation: selected ?? (typeof admitted === 'bigint' ? admitted : undefined),
+            ready: admitted !== undefined && (selected === undefined || admitted === selected)
+        };
+    }
+    get requestStopSignal() {
+        return this.applicationJobStop.signal;
+    }
+    observePeerRouteChanged(listener) {
+        this.peerRouteChanged.add(listener);
+        return () => {
+            this.peerRouteChanged.delete(listener);
+        };
+    }
+    hasSelectedPeerRoute(nodeRoutingId) {
+        return this.selectedRoutes.has(nodeRoutingId);
+    }
+    notifyPeerRouteChanged(nodeRoutingId) {
+        for (const listener of this.peerRouteChanged)
+            listener(nodeRoutingId);
+    }
     notifyPeerConnectionIntentRemoved(nodeRoutingId) {
         // Only the logical owner's removal publishes lifecycle termination.
         // A physical disconnect alone retains the connection expectation.
@@ -222,31 +261,35 @@ class RawServiceMeshRuntime {
         for (const listener of this.peerConnectionIntentRemoved)
             listener(nodeRoutingId);
     }
-    async announcePeer(nodeRoutingId) {
-        const expected = this.expectedPeers.get(nodeRoutingId);
+    announcePeer(nodeRoutingId) {
         const generation = this.selectedRoutes.get(nodeRoutingId);
-        if (expected === undefined ||
-            generation === undefined ||
-            expected.helloSubmittedGeneration === generation ||
-            this.peerAdmissionSealed?.() === true)
-            return false;
-        const accepted = await this.send(nodeRoutingId, [
-            (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.topology.localDescriptor())
-        ]);
-        if (accepted &&
-            this.expectedPeers.get(nodeRoutingId) === expected &&
-            this.selectedRoutes.get(nodeRoutingId) === generation)
-            expected.helloSubmittedGeneration = generation;
-        return accepted;
+        if (generation === undefined)
+            return Promise.resolve(false);
+        const current = () => {
+            const admission = this.topology.routeAdmission(nodeRoutingId);
+            return (this.selectedRoutes.get(nodeRoutingId) === generation &&
+                !(admission?.connectionId === routeConnectionId(generation) &&
+                    admission.remoteAdmitReceived === true) &&
+                this.peerAdmissionSealed?.() !== true);
+        };
+        const key = controlSendKey(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello);
+        if (!current()) {
+            this.controlSends.delete(key);
+            return Promise.resolve(false);
+        }
+        const existing = this.controlSends.get(key);
+        const hello = existing?.current?.() === true
+            ? existing.hello
+            : (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.topology.localDescriptor());
+        return Promise.resolve(this.startControlSend(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello, () => this.submitControl(nodeRoutingId, [hello]), current, hello));
     }
     isPeerRouteReady(nodeRoutingId, lifecycleGeneration) {
         // Admission is bound to the observed selected route: the route observer
         // removes the peer when that route ends or is replaced.
-        const peer = this.topology.peer(nodeRoutingId);
+        const peer = this.topology.admittedPeer(nodeRoutingId);
         return (peer !== undefined &&
             (lifecycleGeneration === undefined ||
-                peer.descriptor.lifecycleGeneration === lifecycleGeneration) &&
-            this.liveness.isReady(nodeRoutingId, peer.connectionId));
+                peer.descriptor.lifecycleGeneration === lifecycleGeneration));
     }
     async announceExpectedPeers() {
         let accepted = 0;
@@ -280,22 +323,22 @@ class RawServiceMeshRuntime {
         // placement and channel selectors therefore need the new mutable fields
         // on that same connection before the next request is selected; waiting for
         // a reconnect would leave a race where a drained node is selected again.
+        await this.publishLocalDescriptor(this.topology.peers().map((peer) => peer.descriptor.nodeRoutingId));
+    }
+    async publishLocalDescriptor(targets) {
         const update = (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.update, this.topology.localDescriptor());
-        for (const peer of this.topology.peers()) {
-            await this.send(peer.descriptor.nodeRoutingId, [update]);
+        for (const target of targets) {
+            await this.sendService(target, [update]);
         }
     }
     replaceDiscoveredNotRequired(descriptors) {
         this.topology.replaceDiscoveredNotRequired(descriptors);
     }
     isObjectClientNodeDirectTarget(nodeRoutingId) {
-        const descriptor = nodeRoutingId === this.descriptor.nodeRoutingId
-            ? this.topology.localDescriptor()
-            : this.topology.knownDescriptor(nodeRoutingId);
-        return descriptor?.objectRole === 'client';
+        return this.topology.isObjectClientNodeDirectTarget(nodeRoutingId);
     }
-    async sendToNode(targetNodeRoutingId, payload) {
-        return this.send(targetNodeRoutingId, [(0, service_wire_m6a_codec_1.encodeNodeSendHeader)(), this.applicationFrame(payload)]);
+    sendToNode(targetNodeRoutingId, payload) {
+        return this.send(targetNodeRoutingId, [NODE_SEND_HEADER, this.applicationFrame(payload)]);
     }
     async sendToChannel(channelName, payload) {
         const selection = this.selectChannelTarget(channelName);
@@ -310,17 +353,17 @@ class RawServiceMeshRuntime {
             ? runtime_values_1.SubmitResult.Ok
             : runtime_values_1.SubmitResult.NotConnected;
     }
-    requestToNode(targetNodeRoutingId, payload, timeoutMs) {
-        return this.requestToTarget(targetNodeRoutingId, payload, timeoutMs);
+    requestToNode(targetNodeRoutingId, payload, timeoutMs, onAdmitted) {
+        return this.requestToTarget(targetNodeRoutingId, payload, timeoutMs, undefined, onAdmitted);
     }
-    requestToChannel(channelName, payload, timeoutMs) {
+    requestToChannel(channelName, payload, timeoutMs, onAdmitted) {
         const selection = this.selectChannelTarget(channelName);
         if (selection.kind !== 'selected') {
             const pending = this.operations.register(timeoutMs);
             this.operations.complete(pending.id, selection.requestResult);
             return pending;
         }
-        return this.requestToTarget(selection.peer.descriptor.nodeRoutingId, payload, timeoutMs, channelName);
+        return this.requestToTarget(selection.peer.descriptor.nodeRoutingId, payload, timeoutMs, channelName, onAdmitted);
     }
     selectChannelTarget(channelName) {
         const selected = this.topology.selectChannel(channelName, (peer) => this.isPeerRouteReady(peer.descriptor.nodeRoutingId));
@@ -341,24 +384,32 @@ class RawServiceMeshRuntime {
                 }
             };
     }
-    setServiceIngress(handler) {
+    setServiceIngress(handler, accepts) {
         if (this.serviceIngress !== undefined && this.serviceIngress !== handler) {
             throw new Error('Raw service ingress is already registered.');
         }
         this.serviceIngress = handler;
+        this.serviceIngressAccepts = accepts;
     }
     async reserveLocalIngress(signal) {
         const waitSignal = signal === undefined
             ? this.applicationJobStop.signal
             : AbortSignal.any([this.applicationJobStop.signal, signal]);
-        const permit = await this.applicationJobQueue.acquire(waitSignal);
+        const permit = await this.applicationJobQueue.acquire(waitSignal, 'local');
         return application_ingress_record_owner_1.ApplicationIngressRecordOwner.create(this.applicationJobQueue, permit, { close() { } });
     }
     async sendService(targetNodeRoutingId, parts) {
-        return this.send(targetNodeRoutingId, parts);
+        try {
+            await this.requireStarted().send(targetNodeRoutingId, parts);
+            return true;
+        }
+        catch (error) {
+            return this.sendFailure(error);
+        }
     }
-    requestService(targetNodeRoutingId, parts, timeoutMs) {
-        return this.requireStarted().request(targetNodeRoutingId, parts, timeoutMs);
+    requestService(targetNodeRoutingId, parts, timeoutMs, onAdmitted) {
+        const admission = this.topology.admittedPeer(targetNodeRoutingId)?.liveness;
+        return this.requireStarted().request(targetNodeRoutingId, parts, timeoutMs, admission?.recordReceived, onAdmitted);
     }
     replyService(record, parts) {
         if (record.requestSequence === undefined) {
@@ -383,6 +434,22 @@ class RawServiceMeshRuntime {
         ]);
     }
     async pumpOne(nowMs = performance.now(), observe) {
+        const result = await this.receiveOne(nowMs, observe);
+        const acquisition = this.receiveAcquisition;
+        if (acquisition === undefined)
+            return result;
+        // A single receive operation may await its FIFO grant. Infrastructure
+        // rounds use receiveOne directly and end while that grant is pending.
+        try {
+            await acquisition;
+        }
+        catch (error) {
+            if (this.closed)
+                return 'noData';
+            throw error;
+        }
+        if (this.closed)
+            return 'noData';
         return this.receiveOne(nowMs, observe);
     }
     setReadableHandler(handler) {
@@ -390,6 +457,7 @@ class RawServiceMeshRuntime {
     }
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
     async pumpBatch(receiveReady = true, routeReady = false) {
+        this.observeInfrastructureFailure();
         if (routeReady)
             await this.observeSelectedRoutes();
         const startedAtMs = performance.now();
@@ -398,38 +466,72 @@ class RawServiceMeshRuntime {
         const observe = (_source, byteCount) => {
             bytes += byteCount;
         };
-        while (receiveReady && messages < RAW_MESH_RECEIVE_RECORD_BUDGET && !this.closed) {
-            const result = await this.receiveOne(performance.now(), observe);
-            if (result === 'noData') {
-                receiveReady = false;
-                break;
+        const rotation = (this.receiveRotation ??= this.applicationJobQueue.createReceiveRotation(RAW_MESH_RECEIVE_RECORD_BUDGET, 'remote'));
+        if (receiveReady)
+            rotation.reserve();
+        try {
+            while (receiveReady && messages < RAW_MESH_RECEIVE_RECORD_BUDGET && !this.closed) {
+                const received = this.receiveOne(performance.now(), observe, rotation);
+                const result = received instanceof Promise ? await received : received;
+                if (result === 'noData') {
+                    receiveReady = false;
+                    break;
+                }
+                messages += 1;
+                // Core owns the per-peer fair-queue cursor. The Framework limit bounds
+                // the entire round, so changing peers does not renew its byte/count budget.
+                if (bytes >= RAW_MESH_RECEIVE_BYTE_BUDGET ||
+                    performance.now() - startedAtMs >= exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS)
+                    break;
             }
-            messages += 1;
-            // Core owns the per-peer fair-queue cursor. The Framework limit bounds
-            // the entire round, so changing peers does not renew its byte/count budget.
-            if (bytes >= RAW_MESH_RECEIVE_BYTE_BUDGET ||
-                performance.now() - startedAtMs >= exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS)
-                break;
+        }
+        finally {
+            rotation.releaseUnused();
         }
         if (!this.closed) {
-            await this.announceExpectedPeers();
-            await this.tickLiveness();
+            this.tickLiveness();
         }
         return receiveReady && messages > 0;
     }
-    async receiveOne(nowMs, observe) {
+    receiveOne(nowMs, observe, rotation) {
         const router = this.requireStarted();
-        let permit;
-        try {
-            permit = await this.applicationJobQueue.acquire(this.applicationJobStop.signal);
-        }
-        catch (error) {
-            if (this.closed || this.applicationJobStop.signal.aborted)
-                return 'noData';
-            throw error;
+        this.observeInfrastructureFailure();
+        let permit = this.receivePermit;
+        this.receivePermit = undefined;
+        permit ??= rotation?.take();
+        if (permit === undefined && this.receiveAcquisition === undefined) {
+            let resolveAcquisition;
+            let rejectAcquisition;
+            permit = this.applicationJobQueue.acquireOrResume((permit) => {
+                this.receiveAcquisition = undefined;
+                if (this.closed) {
+                    permit.releaseAfterInternalProcessing();
+                    permit.releaseStorage?.();
+                }
+                else {
+                    this.receivePermit = permit;
+                    this.onReceiveReady?.();
+                }
+                resolveAcquisition?.(permit);
+            }, (error) => rejectAcquisition?.(error), this.applicationJobStop.signal, 'remote');
+            if (permit === undefined) {
+                const acquisition = new Promise((resolve, reject) => {
+                    resolveAcquisition = resolve;
+                    rejectAcquisition = reject;
+                });
+                this.receiveAcquisition = acquisition;
+                acquisition.catch((error) => {
+                    this.receiveAcquisition = undefined;
+                    if (!this.applicationJobStop.signal.aborted)
+                        this.reportInfrastructureFailure(error);
+                });
+            }
         }
+        if (permit === undefined)
+            return 'noData';
         if (this.closed) {
             permit.releaseAfterInternalProcessing();
+            permit.releaseStorage?.();
             return 'noData';
         }
         let received;
@@ -438,23 +540,44 @@ class RawServiceMeshRuntime {
         }
         catch (error) {
             permit.releaseAfterInternalProcessing();
+            permit.releaseStorage?.();
             throw error;
         }
         if (received === undefined) {
             permit.releaseAfterInternalProcessing();
+            permit.releaseStorage?.();
             return 'noData';
         }
         const applicationJobOwner = application_ingress_record_owner_1.ApplicationIngressRecordOwner.create(this.applicationJobQueue, permit, received);
+        let result;
+        try {
+            result = this.processReceived(received, nowMs, applicationJobOwner);
+        }
+        catch (error) {
+            applicationJobOwner.close();
+            throw error;
+        }
+        return result instanceof Promise
+            ? result.then((value) => this.finishReceive(received, applicationJobOwner, observe, value), (error) => {
+                applicationJobOwner.close();
+                throw error;
+            })
+            : this.finishReceive(received, applicationJobOwner, observe, result);
+    }
+    finishReceive(received, owner, observe, result) {
         try {
-            const result = await this.processReceived(received, nowMs, applicationJobOwner);
-            if (result === 'protocolError') {
+            if (result === 'protocolError')
                 this.reportProtocolError(received);
+            if (observe !== undefined) {
+                let bytes = 0;
+                for (const part of received.parts)
+                    bytes += part.byteLength;
+                observe(received.sourceRid, bytes);
             }
-            observe?.(received.sourceRid, received.parts.reduce((sum, part) => sum + part.byteLength, 0));
             return result;
         }
         finally {
-            applicationJobOwner.close();
+            owner.close();
         }
     }
     reportProtocolError(received) {
@@ -493,61 +616,19 @@ class RawServiceMeshRuntime {
             throw error;
         }
     }
-    async processReceived(received, nowMs, applicationJobOwner) {
-        if (received.parts.length === 0 ||
-            (received.parts.length === 1 && received.parts[0].byteLength === 0)) {
-            if (this.peerAdmissionSealed?.() === true)
-                return 'dropped';
-            return (await this.send(received.sourceRid, [
-                (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.topology.localDescriptor())
-            ]))
-                ? 'infrastructure'
-                : 'dropped';
-        }
+    processReceived(received, nowMs, applicationJobOwner) {
+        const peer = this.topology.admittedPeer(received.sourceRid);
+        const currentSource = peer?.liveness !== undefined && peer.liveness.connectionId === received.routeGeneration;
+        if (received.parts.length === 0)
+            return currentSource ? 'protocolError' : 'dropped';
         try {
             const header = (0, service_wire_m6a_codec_1.decodeHeader)(received.parts[0]);
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.hello && this.peerAdmissionSealed?.() === true) {
                 return 'dropped';
             }
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.hello ||
-                header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.admit ||
-                header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.update) {
-                if (received.parts.length !== 1)
-                    return 'protocolError';
-                const descriptor = (0, service_wire_m6a_codec_1.decodeRouteMeshAdmission)(received.parts[0], header.command, received.sourceRid);
-                const expected = this.expectedPeers.get(received.sourceRid);
-                if (expected !== undefined &&
-                    (expected.meshName !== descriptor.meshName ||
-                        expected.nodeRoutingId !== descriptor.nodeRoutingId)) {
-                    await this.send(received.sourceRid, [
-                        (0, service_wire_m6a_codec_1.encodeReject)((0, service_wire_codec_generated_1.enumWireRejectReason)('identityMismatch'))
-                    ]);
-                    return 'infrastructure';
-                }
-                const result = this.admitPeer(descriptor, routeConnectionId(received.routeGeneration), nowMs, expected);
-                if (result !== 'admitted' && result !== 'notRequired') {
-                    const detail = result === 'invalidDescriptor'
-                        ? describeInvalidAdmissionDescriptor(descriptor, expected, this.topology.peer(descriptor.nodeRoutingId)?.descriptor)
-                        : undefined;
-                    console.warn(`RouteMesh admission rejected peer '${received.sourceRid}' as ${result}` +
-                        (detail === undefined ? '.' : ` (${detail}).`));
-                    await this.send(received.sourceRid, [(0, service_wire_m6a_codec_1.encodeReject)(admissionReason(result))]);
-                    return 'infrastructure';
-                }
-                if (result === 'admitted')
-                    this.selectBilateralConnection(descriptor);
-                if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.hello) {
-                    // Hello supplies only the sender's descriptor. Even NotRequired
-                    // peers must receive ours before the intent owner closes transport;
-                    // submitting a response does not guarantee delivery before close.
-                    await this.send(received.sourceRid, [
-                        (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.admit, this.topology.localDescriptor())
-                    ]);
-                }
-                else if (result === 'notRequired') {
-                    this.retireNotRequiredExpectedPeer(received.sourceRid, descriptor.advertisedEndpoint);
-                }
-                return 'infrastructure';
+                header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.admit) {
+                return this.processAdmission(received, header, nowMs).catch((error) => this.receiveProtocolFailure(error));
             }
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.reject) {
                 if (received.parts.length !== 1)
@@ -555,45 +636,122 @@ class RawServiceMeshRuntime {
                 (0, service_wire_m6a_codec_1.decodeReject)(received.parts[0]);
                 return 'infrastructure';
             }
-            const peer = this.topology.peer(received.sourceRid);
-            if (peer === undefined)
-                return 'protocolError';
+            if (!currentSource)
+                return 'dropped';
+            this.liveness.recordReceived(peer.liveness, nowMs);
+            if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.update) {
+                return this.processAdmission(received, header, nowMs).catch((error) => this.receiveProtocolFailure(error));
+            }
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe ||
                 header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck) {
-                if (received.parts.length !== 1)
-                    return 'protocolError';
-                const record = livenessCodec.decodeLivenessRecord(received.parts[0]);
-                if (record.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe) {
-                    const ack = this.liveness.acknowledgeProbe(received.sourceRid, peer.connectionId, record.probeId);
-                    if (ack === undefined)
-                        return 'protocolError';
-                    const sent = await this.send(received.sourceRid, [
-                        livenessCodec.encodeLivenessRecord({
-                            command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck,
-                            probeId: record.probeId
-                        })
-                    ]);
-                    if (!sent)
-                        return 'dropped';
-                }
-                else {
-                    this.liveness.acknowledge(received.sourceRid, peer.connectionId, record.probeId, nowMs);
-                }
-                return 'infrastructure';
+                return this.processLiveness(received, nowMs).catch((error) => this.receiveProtocolFailure(error));
             }
-            const stateful = await this.serviceIngress?.({
-                command: header.command,
-                flags: header.flags,
-                sourceRoutingId: received.sourceRid,
-                sourceNodeGeneration: peer.descriptor.lifecycleGeneration,
-                sourceRoute: received.sourceRoute,
-                ...(received.reply === undefined ? {} : { reply: received.reply }),
-                ...(received.requestSeq === undefined ? {} : { requestSequence: received.requestSeq }),
-                parts: received.parts,
-                applicationJobOwner
-            });
+            const stateful = this.serviceIngress !== undefined && this.serviceIngressAccepts?.(header.command) !== false
+                ? this.serviceIngress({
+                    command: header.command,
+                    flags: header.flags,
+                    sourceRoutingId: received.sourceRid,
+                    sourceNodeGeneration: peer.descriptor.lifecycleGeneration,
+                    sourceRoute: received.sourceRoute,
+                    ...(received.reply === undefined ? {} : { reply: received.reply }),
+                    ...(received.requestSeq === undefined
+                        ? {}
+                        : { requestSequence: received.requestSeq }),
+                    parts: received.parts,
+                    applicationJobOwner
+                })
+                : undefined;
+            if (stateful instanceof Promise)
+                return stateful.then((result) => result ?? this.processApplicationReceived(received, header, applicationJobOwner), (error) => this.receiveProtocolFailure(error));
             if (stateful !== undefined)
                 return stateful;
+            return this.processApplicationReceived(received, header, applicationJobOwner);
+        }
+        catch (error) {
+            if (!currentSource && error instanceof service_wire_m6a_codec_1.ServiceWireProtocolError)
+                return 'dropped';
+            return this.receiveProtocolFailure(error);
+        }
+    }
+    receiveProtocolFailure(error) {
+        if (error instanceof service_wire_m6a_codec_1.ServiceWireProtocolError)
+            return 'protocolError';
+        throw error;
+    }
+    async processAdmission(received, header, nowMs) {
+        if (received.parts.length !== 1)
+            return 'protocolError';
+        const descriptor = (0, service_wire_m6a_codec_1.decodeRouteMeshAdmission)(received.parts[0], header.command, received.sourceRid);
+        const expected = this.expectedPeers.get(received.sourceRid);
+        if (expected !== undefined &&
+            (expected.meshName !== descriptor.meshName ||
+                expected.nodeRoutingId !== descriptor.nodeRoutingId)) {
+            await this.sendControl(received.sourceRid, [
+                (0, service_wire_m6a_codec_1.encodeReject)((0, service_wire_codec_generated_1.enumWireRejectReason)('identityMismatch'))
+            ]);
+            return 'infrastructure';
+        }
+        const helloKey = controlSendKey(received.sourceRid, service_wire_m6a_codec_1.M6aServiceWireCommand.hello);
+        const exchange = this.controlSends.get(helloKey);
+        const result = this.admitPeer(descriptor, received.routeGeneration, nowMs, expected, header.command, received.parts[0].subarray(service_wire_binary_primitives_1.SERVICE_WIRE_PREFIX_SIZE));
+        if (result !== 'admitted' && result !== 'notRequired') {
+            const detail = result === 'invalidDescriptor'
+                ? describeInvalidAdmissionDescriptor(descriptor, expected, this.topology.peer(descriptor.nodeRoutingId)?.descriptor)
+                : undefined;
+            console.warn(`RouteMesh admission rejected peer '${received.sourceRid}' as ${result}` +
+                (detail === undefined ? '.' : ` (${detail}).`));
+            await this.sendControl(received.sourceRid, [(0, service_wire_m6a_codec_1.encodeReject)(admissionReason(result))]);
+            return 'infrastructure';
+        }
+        if (result === 'admitted')
+            this.selectBilateralConnection(descriptor);
+        if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.hello) {
+            // Hello supplies only the sender's descriptor. Even NotRequired
+            // peers must receive ours before the intent owner closes transport;
+            // submitting a response does not guarantee delivery before close.
+            const local = exchange?.current?.() === true && exchange.hello !== undefined
+                ? (0, service_wire_m6a_codec_1.decodeRouteMeshAdmission)(exchange.hello, service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.descriptor.nodeRoutingId)
+                : this.topology.localDescriptor();
+            await this.sendControl(received.sourceRid, [
+                (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.admit, local)
+            ]);
+        }
+        else if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.admit) {
+            this.controlSends.delete(helloKey);
+            if (result === 'notRequired') {
+                this.retireNotRequiredExpectedPeer(received.sourceRid, descriptor.advertisedEndpoint);
+            }
+            else if (exchange?.hello !== undefined &&
+                (0, service_wire_m6a_codec_1.decodeRouteMeshAdmission)(exchange.hello, service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.descriptor.nodeRoutingId).descriptorRevision < this.descriptor.descriptorRevision) {
+                await this.publishLocalDescriptor([received.sourceRid]);
+            }
+        }
+        return 'infrastructure';
+    }
+    async processLiveness(received, nowMs) {
+        if (received.parts.length !== 1)
+            return 'protocolError';
+        const record = livenessCodec.decodeLivenessRecord(received.parts[0]);
+        if (record.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe) {
+            const ack = this.liveness.acknowledgeProbe(received.sourceRid, received.routeGeneration, record.probeId);
+            if (ack === undefined)
+                return 'protocolError';
+            const sent = await this.sendControl(received.sourceRid, [
+                livenessCodec.encodeLivenessRecord({
+                    command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck,
+                    probeId: record.probeId
+                })
+            ]);
+            if (!sent)
+                return 'dropped';
+        }
+        else {
+            this.liveness.acknowledge(received.sourceRid, received.routeGeneration, record.probeId, nowMs);
+        }
+        return 'infrastructure';
+    }
+    processApplicationReceived(received, header, applicationJobOwner) {
+        try {
             if (header.flags === 0 &&
                 // A bare infrastructure control is normally exactly one frame, but a
                 // relocation Prepare now rides its bound-session journal as
@@ -609,7 +767,7 @@ class RawServiceMeshRuntime {
                 received.parts.length >= 1 &&
                 isBareInfrastructureControl(header.command)) {
                 const accepted = this.mailbox.tryEnqueue({
-                    owner: `node:${this.descriptor.nodeRoutingId}`,
+                    owner: this.nodeMailboxOwner,
                     domain: 'infrastructure',
                     parts: received.parts,
                     sourceRoutingId: received.sourceRid,
@@ -632,51 +790,54 @@ class RawServiceMeshRuntime {
             let owner;
             let correlation;
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.nodeSend) {
-                owner = `node:${this.descriptor.nodeRoutingId}`;
+                owner = this.nodeMailboxOwner;
             }
             else if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.nodeRequest) {
-                owner = `node:${this.descriptor.nodeRoutingId}`;
-                correlation = (0, service_wire_m6a_codec_1.decodeNodeRequestHeader)(received.parts[0]);
+                owner = this.nodeMailboxOwner;
+                correlation = (0, service_wire_m6a_codec_1.decodeNodeRequestHeader)(received.parts[0], header);
             }
             else if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.channelSend) {
-                owner = `channel:${(0, service_wire_m6a_codec_1.decodeChannelSendHeader)(received.parts[0])}`;
+                owner = `channel:${(0, service_wire_m6a_codec_1.decodeChannelSendHeader)(received.parts[0], header)}`;
             }
             else {
-                const channel = (0, service_wire_m6a_codec_1.decodeChannelRequestHeader)(received.parts[0]);
+                const channel = (0, service_wire_m6a_codec_1.decodeChannelRequestHeader)(received.parts[0], header);
                 owner = `channel:${channel.channelName}`;
                 correlation = channel.correlation;
             }
-            const applicationJob = await applicationJobOwner.acquire('application');
-            const accepted = this.mailbox.tryEnqueue({
-                owner,
-                domain: 'application',
-                parts: received.parts,
+            const job = applicationJobOwner.acquire('application');
+            return job instanceof Promise
+                ? job.then((permit) => this.enqueueOrdinaryRecord(received, owner, correlation, permit))
+                : this.enqueueOrdinaryRecord(received, owner, correlation, job);
+        }
+        catch (error) {
+            return this.receiveProtocolFailure(error);
+        }
+    }
+    enqueueOrdinaryRecord(received, owner, correlation, applicationJob) {
+        const accepted = this.mailbox.tryEnqueue({
+            owner,
+            domain: 'application',
+            parts: received.parts,
+            sourceRoutingId: received.sourceRid,
+            sourceRoute: received.sourceRoute,
+            ...(received.reply === undefined ? {} : { reply: received.reply }),
+            requestSequence: received.requestSeq,
+            ...(correlation === undefined ? {} : { correlation }),
+            applicationJob
+        });
+        if (accepted)
+            return 'application';
+        applicationJob.close();
+        if (correlation !== undefined && received.requestSeq !== undefined) {
+            this.replyService({
                 sourceRoutingId: received.sourceRid,
                 sourceRoute: received.sourceRoute,
-                ...(received.reply === undefined ? {} : { reply: received.reply }),
                 requestSequence: received.requestSeq,
-                ...(correlation === undefined ? {} : { correlation }),
-                applicationJob
-            });
-            if (accepted)
-                return 'application';
-            applicationJob.close();
-            if (correlation !== undefined && received.requestSeq !== undefined) {
-                this.replyService({
-                    sourceRoutingId: received.sourceRid,
-                    sourceRoute: received.sourceRoute,
-                    requestSequence: received.requestSeq,
-                    ...(received.reply === undefined ? {} : { reply: received.reply })
-                }, [(0, service_wire_m6a_codec_1.encodeReplyHeader)(correlation, runtime_values_1.RequestResult.NotConnected, 0)]);
-                return 'infrastructure';
-            }
-            return 'dropped';
-        }
-        catch (error) {
-            if (error instanceof service_wire_m6a_codec_1.ServiceWireProtocolError)
-                return 'protocolError';
-            throw error;
+                ...(received.reply === undefined ? {} : { reply: received.reply })
+            }, [(0, service_wire_m6a_codec_1.encodeReplyHeader)(correlation, runtime_values_1.RequestResult.NotConnected, 0)]);
+            return 'infrastructure';
         }
+        return 'dropped';
     }
     expireOperations(nowMs, turnDeadlineMs) {
         return this.operations.expire(nowMs, turnDeadlineMs);
@@ -684,22 +845,25 @@ class RawServiceMeshRuntime {
     get pendingOperationCount() {
         return this.operations.size;
     }
-    async tickLiveness(nowMs = performance.now()) {
+    tickLiveness(nowMs = performance.now()) {
         const result = this.liveness.tick(nowMs);
         this.requireStarted();
+        for (const nodeRoutingId of this.selectedRoutes.keys())
+            void this.announcePeer(nodeRoutingId);
         for (const probe of result.probes) {
-            await this.send(probe.nodeRoutingId, [
+            const parts = [
                 livenessCodec.encodeLivenessRecord({
                     command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe,
                     probeId: probe.probeId
                 })
-            ]);
+            ];
+            this.startControlSend(probe.nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe, () => this.submitControl(probe.nodeRoutingId, parts));
         }
         for (const nodeRoutingId of result.timedOutNodes) {
             const peer = this.topology.peer(nodeRoutingId);
             if (peer === undefined)
                 continue;
-            // Liveness timeout is a semantic peer removal of the admitted route.
+            this.requireStarted().disconnectRid(nodeRoutingId);
             this.removePeer(peer);
         }
         return result;
@@ -722,12 +886,10 @@ class RawServiceMeshRuntime {
         for (const [nodeRoutingId, generation] of this.selectedRoutes) {
             if (observed.get(nodeRoutingId) === generation)
                 continue;
+            this.controlSends.delete(controlSendKey(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello));
             changes++;
-            const expected = this.expectedPeers.get(nodeRoutingId);
-            if (expected !== undefined)
-                delete expected.helloSubmittedGeneration;
             const peer = this.topology.peer(nodeRoutingId);
-            if (peer !== undefined && peer.connectionId === routeConnectionId(generation)) {
+            if (peer?.liveness?.connectionId === generation) {
                 this.removePeer(peer);
             }
         }
@@ -740,6 +902,8 @@ class RawServiceMeshRuntime {
             selected.push(nodeRoutingId);
         }
         this.selectedRoutes = observed;
+        for (const nodeRoutingId of selected)
+            this.notifyPeerRouteChanged(nodeRoutingId);
         // A new selected route admits only through a new handshake.
         for (const nodeRoutingId of selected)
             await this.announcePeer(nodeRoutingId);
@@ -748,7 +912,14 @@ class RawServiceMeshRuntime {
     close() {
         if (this.closed)
             return;
+        this.closed = true;
         this.applicationJobStop.abort(new Error('Raw service runtime application job admission stopped.'));
+        this.receivePermit?.releaseAfterInternalProcessing();
+        this.receivePermit?.releaseStorage?.();
+        this.receivePermit = undefined;
+        for (const send of this.controlSends.values())
+            delete send.next;
+        this.controlSends.clear();
         this.mailbox.close();
         this.operations.close('Raw service runtime closed.');
         this.serviceIngress = undefined;
@@ -761,9 +932,8 @@ class RawServiceMeshRuntime {
             host.close();
         this.router = undefined;
         this.host = undefined;
-        this.closed = true;
     }
-    requestToTarget(targetNodeRoutingId, payload, timeoutMs, channelName) {
+    requestToTarget(targetNodeRoutingId, payload, timeoutMs, channelName, onAdmitted) {
         const correlation = this.nextCorrelation++;
         const header = channelName === undefined
             ? (0, service_wire_m6a_codec_1.encodeNodeRequestHeader)(correlation)
@@ -829,6 +999,9 @@ class RawServiceMeshRuntime {
                             failureCode: 0
                         });
                     }
+                    else {
+                        onAdmitted?.();
+                    }
                 }
                 finally {
                     applicationJobOwner.close();
@@ -836,7 +1009,8 @@ class RawServiceMeshRuntime {
             })().catch((error) => this.operations.fail(pending.id, error));
             return pending;
         }
-        if (this.topology.peer(selectedTargetNodeRoutingId) === undefined) {
+        const selectedPeer = this.topology.admittedPeer(selectedTargetNodeRoutingId);
+        if (selectedPeer === undefined) {
             // Logical target selection is the requester's decision: an RID that is
             // not an admitted peer is not a target. Whether an admitted target's
             // route can carry the request is Core's REQUEST result.
@@ -847,11 +1021,9 @@ class RawServiceMeshRuntime {
             return pending;
         }
         const parts = [header, encodedPayload];
-        let router;
         let request;
         try {
-            router = this.requireStarted();
-            request = router.request(selectedTargetNodeRoutingId, parts, timeoutMs);
+            request = this.requireStarted().request(selectedTargetNodeRoutingId, parts, timeoutMs, selectedPeer.liveness?.recordReceived, onAdmitted);
         }
         catch (error) {
             this.operations.fail(pending.id, error);
@@ -900,23 +1072,22 @@ class RawServiceMeshRuntime {
     applicationPayload(payload) {
         return Buffer.isBuffer(payload) ? (0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(payload) : payload;
     }
-    admitPeer(descriptor, connectionId, nowMs, expected) {
+    admitPeer(descriptor, connectionId, nowMs, expected, command = service_wire_m6a_codec_1.M6aServiceWireCommand.hello, descriptorBytes) {
         const previous = this.topology.peer(descriptor.nodeRoutingId);
-        if (previous !== undefined &&
-            previous.descriptor.lifecycleGeneration === descriptor.lifecycleGeneration &&
-            (descriptor.descriptorRevision < previous.descriptor.descriptorRevision ||
-                (descriptor.descriptorRevision === previous.descriptor.descriptorRevision &&
-                    !(0, service_topology_registry_1.sameServiceNodeDescriptor)(previous.descriptor, descriptor)))) {
+        const topologyConnectionId = typeof connectionId === 'bigint' ? routeConnectionId(connectionId) : connectionId;
+        const result = this.topology.admit(descriptor, topologyConnectionId, expected, () => {
+            const admission = this.liveness.admit(descriptor.nodeRoutingId, connectionId, nowMs);
+            this.liveness.recordReceived(admission, nowMs);
+            return admission;
+        }, command, descriptorBytes);
+        if (result === 'staleDescriptor') {
             throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`RouteMesh peer '${descriptor.nodeRoutingId}' descriptor revision is stale or conflicting.`);
         }
-        const result = this.topology.admit(descriptor, connectionId, expected);
-        if (result === 'admitted') {
-            this.liveness.admit(descriptor.nodeRoutingId, connectionId, nowMs);
-            this.liveness.requestProbe(descriptor.nodeRoutingId, connectionId, nowMs);
-        }
-        else if (result === 'notRequired' && previous !== undefined) {
-            this.liveness.disconnect(descriptor.nodeRoutingId, previous.connectionId);
+        if (result === 'notRequired' && previous !== undefined) {
+            this.liveness.disconnect(descriptor.nodeRoutingId, previous.liveness?.connectionId ?? previous.connectionId);
         }
+        if (result === 'admitted')
+            this.notifyPeerRouteChanged(descriptor.nodeRoutingId);
         return result;
     }
     retireNotRequiredExpectedPeer(nodeRoutingId, advertisedEndpoint) {
@@ -950,7 +1121,7 @@ class RawServiceMeshRuntime {
     }
     removePeer(peer) {
         this.topology.disconnect(peer.descriptor.nodeRoutingId, peer.connectionId);
-        this.liveness.disconnect(peer.descriptor.nodeRoutingId, peer.connectionId);
+        this.liveness.disconnect(peer.descriptor.nodeRoutingId, peer.liveness?.connectionId ?? peer.connectionId);
         this.onPeerDisconnected?.(peer.descriptor.nodeRoutingId, peer.descriptor.advertisedEndpoint, peer.descriptor.lifecycleGeneration);
     }
     requireStarted() {
@@ -958,22 +1129,111 @@ class RawServiceMeshRuntime {
             throw new Error('Raw service runtime is not started.');
         return this.router;
     }
-    async send(targetNodeRoutingId, parts) {
+    async sendControl(targetNodeRoutingId, parts) {
+        return this.startControlSend(targetNodeRoutingId, (0, service_wire_m6a_codec_1.decodeHeader)(parts[0]).command, () => this.submitControl(targetNodeRoutingId, parts));
+    }
+    submitControl(target, parts) {
+        let submission;
         try {
-            await this.requireStarted().send(targetNodeRoutingId, parts);
-            return true;
+            submission = this.requireStarted().submitSend(target, parts);
         }
         catch (error) {
-            if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'submit') {
-                const terminal = (0, submission_result_1.submitToRequestResult)(error.result, error.phase);
-                if (terminal === runtime_values_1.RequestResult.NotConnected || terminal === runtime_values_1.RequestResult.NotFound)
-                    return false;
+            return this.sendFailure(error);
+        }
+        if (submission.result === runtime_values_1.SubmitResult.Ok)
+            return true;
+        return submission.admitted.then(() => true, (error) => this.sendFailure(error));
+    }
+    startControlSend(target, command, attempt, current, hello) {
+        const key = controlSendKey(target, command);
+        const existing = this.controlSends.get(key);
+        if (existing !== undefined &&
+            existing.task !== undefined &&
+            (command !== service_wire_m6a_codec_1.M6aServiceWireCommand.hello || existing.current?.() === true)) {
+            if (command !== service_wire_m6a_codec_1.M6aServiceWireCommand.hello) {
+                existing.next = attempt;
+                existing.current = current;
             }
-            throw error;
+            return true;
+        }
+        const first = attempt();
+        if (typeof first === 'boolean') {
+            if (hello !== undefined)
+                this.controlSends.set(key, { current, hello });
+            return first;
+        }
+        const owner = this;
+        const state = { current, hello };
+        const completeSend = () => {
+            if (owner.controlSends.get(key) !== state)
+                return;
+            if (hello !== undefined && current?.() === true)
+                delete state.task;
+            else
+                owner.controlSends.delete(key);
+        };
+        const task = first.then(function drain(accepted) {
+            if (!owner.closed && state.next !== undefined) {
+                const next = state.next;
+                delete state.next;
+                return Promise.resolve(next()).then(drain);
+            }
+            completeSend();
+            return accepted;
+        });
+        state.task = task;
+        this.controlSends.set(key, state);
+        task.then(() => { }, (error) => {
+            completeSend();
+            if (this.infrastructureTaskRunner === undefined)
+                this.reportInfrastructureFailure(error);
+        });
+        this.infrastructureTaskRunner?.runDetached('RouteMesh control SEND', async () => {
+            await task;
+        });
+        return true;
+    }
+    reportInfrastructureFailure(error) {
+        this.infrastructureFailure = {
+            error: this.infrastructureFailure === undefined
+                ? error
+                : new AggregateError([this.infrastructureFailure.error, error], 'RouteMesh infrastructure failed.')
+        };
+        this.onReceiveReady?.();
+    }
+    observeInfrastructureFailure() {
+        const failure = this.infrastructureFailure;
+        this.infrastructureFailure = undefined;
+        if (failure !== undefined)
+            throw failure.error;
+    }
+    send(targetNodeRoutingId, parts) {
+        try {
+            const submission = this.requireStarted().submitSend(targetNodeRoutingId, parts);
+            if (submission.result === runtime_values_1.SubmitResult.Ok)
+                return true;
+            return submission.admitted.then(() => true, (error) => this.sendFailure(error));
         }
+        catch (error) {
+            return this.sendFailure(error);
+        }
+    }
+    sendFailure(error) {
+        if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'submit') {
+            const terminal = (0, submission_result_1.submitToRequestResult)(error.result, error.phase);
+            if (terminal === runtime_values_1.RequestResult.NotConnected || terminal === runtime_values_1.RequestResult.NotFound)
+                return false;
+        }
+        throw error;
     }
 }
 exports.RawServiceMeshRuntime = RawServiceMeshRuntime;
+function controlSendKey(target, command) {
+    return JSON.stringify([target, command]);
+}
+function routeConnectionId(generation) {
+    return `route:${generation}`;
+}
 /**
  * Relocation and bound-Session controls are service-wire records themselves,
  * not application NodeSend(16) envelopes. Keep this list closed: a bare
@@ -1010,13 +1270,6 @@ function isAlreadyDisconnectedError(error) {
     }
     return error.nativeErrno === nativeErrnoValues.ENOENT;
 }
-/**
- * An admission belongs to one Core selected route. Its connection identity is
- * that route's generation, an opaque token compared only for equality.
- */
-function routeConnectionId(routeGeneration) {
-    return `route:${routeGeneration.toString()}`;
-}
 function describeInvalidAdmissionDescriptor(descriptor, expected, current) {
     try {
         (0, service_topology_registry_1.validateDescriptor)(descriptor);