@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RawServiceMeshRuntime = exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS = void 0;
+const framework_errors_internal_1 = require("../framework-errors-internal");
+const durable_service_request_1 = require("./durable-service-request");
+const request_deadline_1 = require("../messaging/request-deadline");
+const internal_observation_1 = require("../internal-observation");
 const node_os_1 = require("node:os");
 const application_ingress_record_owner_1 = require("../application-jobs/application-ingress-record-owner");
 const submission_result_1 = require("../messaging/submission-result");
+const payload_slab_1 = require("../../contracts/Common/payload-slab");
 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");
@@ -32,9 +37,20 @@ const livenessCodec = (0, service_wire_codec_1.createServiceWireCodec)({
  * It owns protocol, admission, mailbox, request and liveness state.
  */
 class RawServiceMeshRuntime {
+    [internal_observation_1.inspectRuntime](nodeRoutingId) {
+        return Object.freeze({
+            pendingControlSends: this.controlSends.size,
+            selectedRouteGeneration: nodeRoutingId === undefined ? undefined : this.selectedRoutes.get(nodeRoutingId),
+            peerRouteObservers: this.peerRouteChanged.size,
+            peerConnectionIntentObservers: this.peerConnectionIntentRemoved.size,
+            expectedPeers: this.expectedPeers.size
+        });
+    }
     topology;
     mailbox;
     liveness;
+    requestOwner;
+    releaseOperations;
     operations;
     expectedPeers = new Map();
     endpointOnlyPeers = new Set();
@@ -45,6 +61,7 @@ class RawServiceMeshRuntime {
      * RID -> route generation. Only `observeSelectedRoutes` replaces it.
      */
     selectedRoutes = new Map();
+    connectionAttempts = [];
     bindingPort;
     applicationJobQueue;
     nodeMailboxOwner;
@@ -70,9 +87,16 @@ class RawServiceMeshRuntime {
     serviceIngressAccepts;
     closed = false;
     constructor(options) {
+        this.requestOwner = options.requests;
         this.onReceiveReady = options.onReceiveReady;
         this.infrastructureTaskRunner = options.infrastructureTaskRunner;
-        this.operations = new operation_registry_1.OperationRegistry(undefined, options.onPendingOperationsChanged);
+        this.operations =
+            options.requests?.operations() ??
+                new operation_registry_1.OperationRegistry(undefined, options.onPendingOperationsChanged, (reason) => (0, request_deadline_1.requestTerminalError)('Request', reason));
+        this.releaseOperations =
+            options.requests === undefined
+                ? () => this.operations.close('Raw service runtime closed.')
+                : () => { };
         this.descriptor = options.descriptor;
         this.nodeMailboxOwner = `node:${options.descriptor.nodeRoutingId}`;
         this.topology = new service_topology_registry_1.ServiceTopologyRegistry(options.descriptor);
@@ -132,6 +156,7 @@ class RawServiceMeshRuntime {
             securityIdentity: expected.securityIdentity,
             lifecycleGeneration: expected.lifecycleGeneration
         }));
+        this.notifyPeerRouteChanged(expected.nodeRoutingId);
     }
     connectPeerByRoutingId(endpoint, nodeRoutingId, securityIdentity, lifecycleGeneration) {
         this.requireStarted().connectToRoutingId(nodeRoutingId, endpoint);
@@ -142,6 +167,7 @@ class RawServiceMeshRuntime {
             securityIdentity,
             lifecycleGeneration
         }));
+        this.notifyPeerRouteChanged(nodeRoutingId);
     }
     expectPeerByRoutingId(endpoint, nodeRoutingId, securityIdentity, lifecycleGeneration) {
         this.expectedPeers.set(nodeRoutingId, Object.assign(this.expectedPeers.get(nodeRoutingId) ?? {}, {
@@ -151,6 +177,7 @@ class RawServiceMeshRuntime {
             securityIdentity,
             lifecycleGeneration
         }));
+        this.notifyPeerRouteChanged(nodeRoutingId);
     }
     connectPeerEndpoint(endpoint) {
         this.requireStarted().connect(endpoint);
@@ -233,12 +260,23 @@ class RawServiceMeshRuntime {
     }
     observePeerRoute(nodeRoutingId) {
         const selected = this.selectedRoutes.get(nodeRoutingId);
-        const admitted = this.topology.admittedPeer(nodeRoutingId)?.liveness?.connectionId;
+        const peer = this.topology.admittedPeer(nodeRoutingId);
+        const expected = this.expectedPeers.get(nodeRoutingId);
+        const admitted = peer?.liveness?.connectionId;
         return {
             generation: selected ?? (typeof admitted === 'bigint' ? admitted : undefined),
-            ready: admitted !== undefined && (selected === undefined || admitted === selected)
+            ready: peer?.remoteAdmitReceived === true,
+            selected: selected !== undefined,
+            lifecycleGeneration: expected?.lifecycleGeneration ?? peer?.descriptor.lifecycleGeneration,
+            endpoint: expected?.endpoint ?? peer?.descriptor.advertisedEndpoint,
+            // The immutable socket snapshot is borrowed; only waiting admission filters it.
+            connectionAttempts: this.connectionAttempts
         };
     }
+    peerLifecycleGeneration(nodeRoutingId) {
+        return (this.expectedPeers.get(nodeRoutingId)?.lifecycleGeneration ??
+            this.topology.admittedPeer(nodeRoutingId)?.descriptor.lifecycleGeneration);
+    }
     async waitForPeerRoute(nodeRoutingId, lifecycleGeneration, deadlineUnixMs, signal) {
         const remaining = deadlineUnixMs - BigInt(Date.now());
         if (remaining <= 0n)
@@ -246,14 +284,14 @@ class RawServiceMeshRuntime {
         const pending = this.operations.register(Number(remaining));
         const check = () => {
             if (this.isPeerRouteReady(nodeRoutingId, lifecycleGeneration)) {
-                this.operations.complete(pending.id, { terminalResult: runtime_values_1.RequestResult.Ok, failureCode: 0 });
+                pending.reply({ terminalResult: runtime_values_1.RequestResult.Ok, failureCode: 0 });
             }
         };
         const unsubscribe = this.observePeerRouteChanged((rid) => {
             if (rid === nodeRoutingId)
                 check();
         });
-        const abort = () => this.operations.fail(pending.id, signal?.reason);
+        const abort = () => pending.replyFailure(signal?.reason);
         signal?.addEventListener('abort', abort, { once: true });
         try {
             if (signal?.aborted === true)
@@ -299,27 +337,28 @@ class RawServiceMeshRuntime {
             return false;
         const key = controlSendKey(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello);
         if (!this.isPeerAnnouncementCurrent(nodeRoutingId, generation)) {
-            this.controlSends.delete(key);
             return false;
         }
-        const current = () => this.isPeerAnnouncementCurrent(nodeRoutingId, generation);
+        const current = () => this.isPeerAnnouncementCurrent(nodeRoutingId, generation) &&
+            this.peerAdmissionSealed?.() !== true;
         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());
+        if (!current()) {
+            if (existing === undefined)
+                this.controlSends.set(key, { current });
+            return false;
+        }
+        const hello = existing?.hello ??
+            (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.topology.localDescriptor());
         return this.startControlSend(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello, () => this.submitControl(nodeRoutingId, [hello]), current, hello);
     }
     isPeerAnnouncementCurrent(nodeRoutingId, generation) {
-        const admission = this.topology.routeAdmission(nodeRoutingId);
         return (this.selectedRoutes.get(nodeRoutingId) === generation &&
-            !(admission?.connectionId === routeConnectionId(generation) &&
-                admission.remoteAdmitReceived === true) &&
-            this.peerAdmissionSealed?.() !== true);
+            !this.topology.hasRemoteAdmit(nodeRoutingId, routeConnectionId(generation)));
     }
     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.admittedPeer(nodeRoutingId);
+        const peer = this.topology.readyPeer(nodeRoutingId);
         return (peer !== undefined &&
             (lifecycleGeneration === undefined ||
                 peer.descriptor.lifecycleGeneration === lifecycleGeneration));
@@ -373,58 +412,78 @@ class RawServiceMeshRuntime {
     sendToNode(targetNodeRoutingId, payload) {
         return this.send(targetNodeRoutingId, [NODE_SEND_HEADER, this.applicationFrame(payload)]);
     }
-    async sendToChannel(channelName, payload) {
+    sendToChannel(channelName, payload) {
         const selection = this.selectChannelTarget(channelName);
         if (selection.kind !== 'selected')
             return selection.submitResult;
         const selected = selection.peer;
         const applicationFrame = this.applicationFrame(payload);
-        return (await this.send(selected.descriptor.nodeRoutingId, [
+        const submitted = this.send(selected.descriptor.nodeRoutingId, [
             (0, service_wire_m6a_codec_1.encodeChannelSendHeader)(channelName),
             applicationFrame
-        ]))
-            ? runtime_values_1.SubmitResult.Ok
-            : runtime_values_1.SubmitResult.NotConnected;
+        ]);
+        return typeof submitted === 'boolean'
+            ? channelSendSubmitResult(submitted)
+            : submitted.then(channelSendSubmitResult);
     }
-    requestToNode(targetNodeRoutingId, payload, timeoutMs, onAdmitted, observer, operationKind) {
-        return this.requestToTarget(targetNodeRoutingId, payload, timeoutMs, undefined, onAdmitted, observer, operationKind);
+    requestToNode(targetNodeRoutingId, payload, timeoutMs, onAdmitted, observer, operationKind, requestOperation) {
+        return this.requestToTarget(targetNodeRoutingId, payload, timeoutMs, undefined, onAdmitted, observer, operationKind, requestOperation);
     }
-    requestToChannel(channelName, payload, timeoutMs, onAdmitted, observer, operationKind) {
+    requestToChannel(channelName, payload, timeoutMs, onAdmitted, observer, operationKind, requestOperation) {
         const selection = this.selectChannelTarget(channelName);
         if (selection.kind !== 'selected') {
-            const pending = this.registerRequest(timeoutMs, observer, operationKind);
-            this.completeRequest(pending, selection.requestResult);
+            const pending = this.registerRequest(timeoutMs, observer, operationKind, requestOperation);
+            this.completeRequest(pending, selection.requestResult, requestOperation === undefined ? undefined : observer, operationKind);
             return pending;
         }
         return this.requestToTarget(selection.peer.descriptor.nodeRoutingId, payload, timeoutMs, channelName, onAdmitted, observer, operationKind);
     }
+    beginInfrastructureRequest(timeoutMs, signal, absoluteDeadlineMs = performance.now() + timeoutMs) {
+        const pending = this.operations.register(timeoutMs, 'registry', undefined, absoluteDeadlineMs);
+        pending.setSignal(signal);
+        return pending;
+    }
     /**
      * One pending entry per request: an observed request reports its terminal
      * to the caller's observer; any other request keeps the Promise contract.
      */
-    registerRequest(timeoutMs, observer, operationKind) {
+    registerRequest(timeoutMs, observer, operationKind, requestOperation) {
+        if (requestOperation !== undefined) {
+            return requestOperation;
+        }
         return observer === undefined
             ? this.operations.register(timeoutMs)
-            : { id: this.operations.registerObserved(timeoutMs, observer, operationKind) };
+            : this.observedRequest(this.operations.registerObserved(timeoutMs, observer, operationKind));
+    }
+    observedRequest(id) {
+        return this.operations.handle(id);
     }
     /**
      * An observed caller learns the operation id only when the request call
      * returns, so a terminal decided inside that call is delivered after it.
      */
-    completeRequest(pending, result) {
-        if (pending.promise === undefined)
-            queueMicrotask(() => this.operations.complete(pending.id, result));
+    completeRequest(pending, result, observer, operationKind) {
+        if (observer !== undefined) {
+            queueMicrotask(() => observer.operationCompleted(pending.id, result, operationKind));
+            return;
+        }
+        if (pending.promise === undefined || pending.hasObserver())
+            queueMicrotask(() => pending.reply(result));
         else
-            this.operations.complete(pending.id, result);
+            pending.reply(result);
     }
-    failRequest(pending, error) {
+    failRequest(pending, error, observer, operationKind) {
+        if (observer !== undefined) {
+            queueMicrotask(() => observer.operationFailed(pending.id, error, operationKind));
+            return;
+        }
         if (pending.promise === undefined)
-            queueMicrotask(() => this.operations.fail(pending.id, error));
+            queueMicrotask(() => pending.replyFailure(error));
         else
-            this.operations.fail(pending.id, error);
+            pending.replyFailure(error);
     }
     selectChannelTarget(channelName) {
-        const selected = this.topology.selectChannel(channelName, (peer) => this.isPeerRouteReady(peer.descriptor.nodeRoutingId));
+        const selected = this.topology.selectChannel(channelName);
         if (selected !== undefined)
             return { kind: 'selected', peer: selected };
         return this.topology.hasKnownChannelTarget(channelName)
@@ -465,9 +524,27 @@ class RawServiceMeshRuntime {
             return this.sendFailure(error);
         }
     }
-    requestService(targetNodeRoutingId, parts, timeoutMs, onAdmitted) {
+    requestService(targetNodeRoutingId, parts, timeoutMs, onAdmitted, existing, receiver, onSubmitted) {
+        if (receiver !== undefined) {
+            try {
+                this.requireStarted().request(targetNodeRoutingId, parts, timeoutMs, (reply) => receiver.operationCompleted(existing?.id ?? 0n, reply, undefined), (error) => receiver.operationFailed(existing?.id ?? 0n, error, undefined), this.topology.admittedPeer(targetNodeRoutingId)?.liveness?.recordReceived, onAdmitted, existing);
+            }
+            catch (error) {
+                receiver.operationFailed(existing?.id ?? 0n, error, undefined);
+            }
+            return;
+        }
         const admission = this.topology.admittedPeer(targetNodeRoutingId)?.liveness;
-        return this.requireStarted().request(targetNodeRoutingId, parts, timeoutMs, admission?.recordReceived, onAdmitted);
+        try {
+            const reply = this.requireStarted().request(targetNodeRoutingId, parts, timeoutMs, (reply) => reply, (error) => {
+                throw error;
+            }, admission?.recordReceived, onAdmitted, existing);
+            onSubmitted?.();
+            return reply;
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
     }
     replyService(record, parts) {
         if (record.requestSequence === undefined) {
@@ -486,10 +563,8 @@ class RawServiceMeshRuntime {
         if (request.reply === undefined || request.correlation === undefined) {
             throw new TypeError('Reply requires a request mailbox record.');
         }
-        request.reply([
-            (0, service_wire_m6a_codec_1.encodeReplyHeader)(request.correlation, terminalResult, failureCode),
-            ...(terminalResult === 0 ? [this.applicationFrame(payload)] : [])
-        ]);
+        const header = (0, service_wire_m6a_codec_1.encodeReplyHeader)(request.correlation, terminalResult, failureCode);
+        request.reply(terminalResult === 0 ? [header, this.applicationFrame(payload)] : [header]);
     }
     async pumpOne(nowMs = performance.now(), observe) {
         const result = await this.receiveOne(nowMs, observe);
@@ -514,10 +589,35 @@ class RawServiceMeshRuntime {
         this.requireStarted().setReadableHandler(handler);
     }
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
-    async pumpBatch(receiveReady = true, routeReady = false) {
-        this.observeInfrastructureFailure();
+    pumpBatch(receiveReady = true, routeReady = false, connectReady = false) {
+        try {
+            this.observeInfrastructureFailure();
+            if (routeReady || connectReady) {
+                return this.receiveBatchAfterObservations(receiveReady, routeReady, connectReady);
+            }
+            return this.receiveBatch(receiveReady);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    async receiveBatchAfterObservations(receiveReady, routeReady, connectReady) {
+        // Both facts are applied before admission observers run in this socket turn.
+        if (connectReady)
+            this.connectionAttempts = this.requireStarted().connectionAttemptsSnapshot();
         if (routeReady)
             await this.observeSelectedRoutes();
+        if (connectReady) {
+            for (const target of this.expectedPeers.keys())
+                this.notifyPeerRouteChanged(target);
+            for (const peer of this.topology.peers()) {
+                if (!this.expectedPeers.has(peer.descriptor.nodeRoutingId))
+                    this.notifyPeerRouteChanged(peer.descriptor.nodeRoutingId);
+            }
+        }
+        return this.receiveBatch(receiveReady);
+    }
+    receiveBatch(receiveReady) {
         const startedAtMs = performance.now();
         let messages = 0;
         let bytes = 0;
@@ -527,29 +627,46 @@ class RawServiceMeshRuntime {
         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;
+        // The same loop owns both immediate receives and a suspended receive's
+        // continuation; only the latter needs a Promise and retains this frame.
+        const drain = (received) => {
+            try {
+                while (received !== undefined ||
+                    (receiveReady && messages < RAW_MESH_RECEIVE_RECORD_BUDGET && !this.closed)) {
+                    if (received === undefined) {
+                        const pending = this.receiveOne(performance.now(), observe, rotation);
+                        if (pending instanceof Promise) {
+                            return pending.then(drain, (error) => {
+                                rotation.releaseUnused();
+                                throw error;
+                            });
+                        }
+                        received = pending;
+                    }
+                    if (received === 'noData') {
+                        receiveReady = false;
+                        break;
+                    }
+                    messages += 1;
+                    received = undefined;
+                    // 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 {
+            catch (error) {
+                rotation.releaseUnused();
+                throw error;
+            }
             rotation.releaseUnused();
-        }
-        if (!this.closed) {
-            this.tickLiveness();
-        }
-        return receiveReady && messages > 0;
+            if (!this.closed) {
+                this.tickLiveness();
+            }
+            return receiveReady && messages > 0;
+        };
+        return drain();
     }
     receiveOne(nowMs, observe, rotation) {
         const router = this.requireStarted();
@@ -558,32 +675,7 @@ class RawServiceMeshRuntime {
         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);
-                });
-            }
+            permit = this.acquireReceivePermit();
         }
         if (permit === undefined)
             return 'noData';
@@ -616,20 +708,52 @@ class RawServiceMeshRuntime {
             throw error;
         }
         return result instanceof Promise
-            ? result.then((value) => this.finishReceive(received, applicationJobOwner, observe, value), (error) => {
-                applicationJobOwner.close();
-                throw error;
-            })
+            ? this.finishPendingReceive(result, received, applicationJobOwner, observe)
             : this.finishReceive(received, applicationJobOwner, observe, result);
     }
+    acquireReceivePermit() {
+        let resolveAcquisition;
+        let rejectAcquisition;
+        const 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);
+            });
+        }
+        return permit;
+    }
+    finishPendingReceive(result, received, owner, observe) {
+        return result.then((value) => this.finishReceive(received, owner, observe, value), (error) => {
+            owner.close();
+            throw error;
+        });
+    }
     finishReceive(received, owner, observe, result) {
         try {
             if (result === 'protocolError')
                 this.reportProtocolError(received);
             if (observe !== undefined) {
                 let bytes = 0;
-                for (const part of received.parts)
-                    bytes += part.byteLength;
+                for (let index = 0; index < received.parts.length; index += 1)
+                    bytes += received.parts[index].byteLength;
                 observe(received.sourceRid, bytes);
             }
             return result;
@@ -651,28 +775,13 @@ class RawServiceMeshRuntime {
     replyGenericProtocolError(received) {
         if (received.requestSeq === undefined || received.parts.length === 0)
             return false;
-        try {
-            const header = (0, service_wire_m6a_codec_1.decodeHeader)(received.parts[0]);
-            const correlation = header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.nodeRequest
-                ? (0, service_wire_m6a_codec_1.decodeNodeRequestHeader)(received.parts[0])
-                : header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.channelRequest
-                    ? (0, service_wire_m6a_codec_1.decodeChannelRequestHeader)(received.parts[0]).correlation
-                    : undefined;
-            if (correlation === undefined)
-                return false;
-            const reply = [
-                (0, service_wire_m6a_codec_1.encodeReplyHeader)(correlation, runtime_values_1.RequestResult.ProtocolError, service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestProtocolError)
-            ];
-            if (received.reply === undefined)
-                return false;
-            received.reply(reply);
-            return true;
-        }
-        catch (error) {
-            if (error instanceof service_wire_m6a_codec_1.ServiceWireProtocolError)
-                return false;
-            throw error;
-        }
+        const correlation = (0, service_wire_constants_generated_1.recoverRequestCorrelation)(received.parts[0]);
+        if (correlation === undefined || received.reply === undefined)
+            return false;
+        received.reply([
+            (0, service_wire_m6a_codec_1.encodeReplyHeader)(correlation, runtime_values_1.RequestResult.ProtocolError, service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestProtocolError)
+        ]);
+        return true;
     }
     processReceived(received, nowMs, applicationJobOwner) {
         const peer = this.topology.admittedPeer(received.sourceRid);
@@ -686,7 +795,7 @@ class RawServiceMeshRuntime {
             }
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.hello ||
                 header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.admit) {
-                return this.processAdmission(received, header, nowMs).catch((error) => this.receiveProtocolFailure(error));
+                return this.finishPendingProtocolReceive(this.processAdmission(received, header, nowMs));
             }
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.reject) {
                 if (received.parts.length !== 1)
@@ -698,11 +807,11 @@ class RawServiceMeshRuntime {
                 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));
+                return this.finishPendingProtocolReceive(this.processAdmission(received, header, nowMs));
             }
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe ||
                 header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck) {
-                return this.processLiveness(received, nowMs).catch((error) => this.receiveProtocolFailure(error));
+                return this.finishPendingProtocolReceive(this.processLiveness(received, nowMs));
             }
             const stateful = this.serviceIngress !== undefined && this.serviceIngressAccepts?.(header.command) !== false
                 ? this.serviceIngress({
@@ -720,7 +829,7 @@ class RawServiceMeshRuntime {
                 })
                 : undefined;
             if (stateful instanceof Promise)
-                return stateful.then((result) => result ?? this.processApplicationReceived(received, header, applicationJobOwner), (error) => this.receiveProtocolFailure(error));
+                return this.finishPendingStatefulReceive(stateful, received, header, applicationJobOwner);
             if (stateful !== undefined)
                 return stateful;
             return this.processApplicationReceived(received, header, applicationJobOwner);
@@ -731,6 +840,12 @@ class RawServiceMeshRuntime {
             return this.receiveProtocolFailure(error);
         }
     }
+    finishPendingProtocolReceive(pending) {
+        return pending.catch((error) => this.receiveProtocolFailure(error));
+    }
+    finishPendingStatefulReceive(pending, received, header, owner) {
+        return pending.then((result) => result ?? this.processApplicationReceived(received, header, owner), (error) => this.receiveProtocolFailure(error));
+    }
     receiveProtocolFailure(error) {
         if (error instanceof service_wire_m6a_codec_1.ServiceWireProtocolError)
             return 'protocolError';
@@ -776,7 +891,7 @@ class RawServiceMeshRuntime {
         }
         else if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.admit) {
             this.controlSends.delete(helloKey);
-            this.refreshAdmissionPending(nowMs);
+            this.progressPeerAdmission(nowMs);
             if (result === 'notRequired') {
                 this.retireNotRequiredExpectedPeer(received.sourceRid, descriptor.advertisedEndpoint);
             }
@@ -860,13 +975,16 @@ class RawServiceMeshRuntime {
             }
             const job = applicationJobOwner.acquire('application');
             return job instanceof Promise
-                ? job.then((permit) => this.enqueueOrdinaryRecord(received, owner, correlation, permit))
+                ? this.enqueuePendingOrdinaryRecord(job, received, owner, correlation)
                 : this.enqueueOrdinaryRecord(received, owner, correlation, job);
         }
         catch (error) {
             return this.receiveProtocolFailure(error);
         }
     }
+    enqueuePendingOrdinaryRecord(pending, received, owner, correlation) {
+        return pending.then((permit) => this.enqueueOrdinaryRecord(received, owner, correlation, permit));
+    }
     enqueueOrdinaryRecord(received, owner, correlation, applicationJob) {
         const accepted = this.mailbox.tryEnqueue({
             owner,
@@ -894,7 +1012,9 @@ class RawServiceMeshRuntime {
         return 'dropped';
     }
     expireOperations(nowMs, turnDeadlineMs) {
-        return this.operations.expire(nowMs, turnDeadlineMs);
+        return this.requestOwner === undefined && nowMs >= this.operations.nextDeadlineMs()
+            ? this.operations.expire(nowMs, turnDeadlineMs)
+            : 0;
     }
     get pendingOperationCount() {
         return this.operations.size;
@@ -908,26 +1028,33 @@ class RawServiceMeshRuntime {
      * ADMIT, which keeps the existing announce cadence.
      */
     nextMaintenanceDeadlineMs(nowMs) {
-        this.refreshAdmissionPending(nowMs);
-        return Math.min(this.operations.nextDeadlineMs(), this.liveness.nextDeadlineMs());
+        this.progressPeerAdmission(nowMs);
+        return Math.min(this.requestOwner === undefined ? this.operations.nextDeadlineMs() : Infinity, this.liveness.nextDeadlineMs());
     }
-    refreshAdmissionPending(nowMs) {
+    progressPeerAdmission(nowMs) {
         let pending = false;
         if (!this.closed && this.controlSends.size !== 0) {
             for (const nodeRoutingId of this.selectedRoutes.keys()) {
-                const exchange = this.controlSends.get(controlSendKey(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello));
+                const key = controlSendKey(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello);
+                const exchange = this.controlSends.get(key);
+                // An unsent HELLO intent may resume after the host admission seal opens.
+                // Only retransmission of submitted bytes waits for the management cadence.
                 if (exchange?.current?.() === true) {
+                    if (exchange.hello === undefined)
+                        this.announcePeer(nodeRoutingId);
                     pending = true;
-                    break;
                 }
             }
         }
         this.liveness.setAdmissionPending(pending, nowMs);
     }
     tickLiveness(nowMs = performance.now()) {
+        this.progressPeerAdmission(nowMs);
         const admissionDue = this.liveness.tickAdmission(nowMs);
         const result = this.liveness.tick(nowMs);
         this.requireStarted();
+        if (!admissionDue && result.probes.length === 0 && result.timedOutNodes.length === 0)
+            return result;
         if (admissionDue)
             for (const nodeRoutingId of this.selectedRoutes.keys())
                 void this.announcePeer(nodeRoutingId);
@@ -940,13 +1067,29 @@ class RawServiceMeshRuntime {
             ];
             this.startControlSend(probe.nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe, () => this.submitControl(probe.nodeRoutingId, parts));
         }
+        const failures = [];
         for (const nodeRoutingId of result.timedOutNodes) {
             const peer = this.topology.peer(nodeRoutingId);
             if (peer === undefined)
                 continue;
-            this.requireStarted().disconnectRid(nodeRoutingId);
-            this.removePeer(peer);
+            try {
+                this.removePeer(peer, () => {
+                    try {
+                        this.requireStarted().disconnectRid(nodeRoutingId);
+                    }
+                    catch (error) {
+                        failures.push(error);
+                    }
+                });
+            }
+            catch (error) {
+                failures.push(error);
+            }
         }
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1)
+            throw new AggregateError(failures, 'Liveness peer cleanup failed.');
         return result;
     }
     /**
@@ -985,42 +1128,50 @@ class RawServiceMeshRuntime {
         this.selectedRoutes = observed;
         for (const nodeRoutingId of selected)
             this.notifyPeerRouteChanged(nodeRoutingId);
-        // A new selected route admits only through a new handshake.
+        // Selected routes begin admission before waiting for the management cadence.
         for (const nodeRoutingId of selected)
             await this.announcePeer(nodeRoutingId);
-        this.refreshAdmissionPending(performance.now());
+        this.progressPeerAdmission(performance.now());
         return changes;
     }
     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;
-        const router = this.router;
-        if (router !== undefined) {
-            this.applicationJobQueue.unregisterReceiveFlowTarget?.(router);
-        }
         const host = this.host;
-        if (host !== undefined)
-            host.close();
-        this.router = undefined;
+        if (this.closed && host === undefined)
+            return;
         this.host = undefined;
+        try {
+            if (!this.closed) {
+                this.closed = true;
+                this.applicationJobStop.abort((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown, '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.releaseOperations();
+                this.serviceIngress = undefined;
+                const router = this.router;
+                if (router !== undefined) {
+                    this.applicationJobQueue.unregisterReceiveFlowTarget?.(router);
+                }
+            }
+            if (host !== undefined)
+                host.close();
+            this.router = undefined;
+        }
+        catch (error) {
+            this.host = host;
+            throw error;
+        }
     }
-    requestToTarget(targetNodeRoutingId, payload, timeoutMs, channelName, onAdmitted, observer, operationKind) {
+    requestToTarget(targetNodeRoutingId, payload, timeoutMs, channelName, onAdmitted, observer, operationKind, requestOperation) {
         const correlation = this.nextCorrelation++;
         const header = channelName === undefined
             ? (0, service_wire_m6a_codec_1.encodeNodeRequestHeader)(correlation)
             : (0, service_wire_m6a_codec_1.encodeChannelRequestHeader)(correlation, channelName);
-        const encodedPayload = this.applicationFrame(payload);
+        let encodedPayload = this.applicationFrame(payload);
         let selectedTargetNodeRoutingId = targetNodeRoutingId;
         if (selectedTargetNodeRoutingId !== this.descriptor.nodeRoutingId &&
             !this.isPeerRouteReady(selectedTargetNodeRoutingId)) {
@@ -1047,19 +1198,22 @@ class RawServiceMeshRuntime {
             }
         }
         if (selectedTargetNodeRoutingId === this.descriptor.nodeRoutingId) {
+            encodedPayload = (0, payload_slab_1.copyPayloadBytes)(encodedPayload);
             // The local admission path aborts its capacity wait on the terminal
             // Promise, so a local request always keeps the Promise entry.
-            const pending = this.operations.register(timeoutMs);
+            const pending = requestOperation === undefined
+                ? this.operations.register(timeoutMs)
+                : this.registerRequest(timeoutMs, observer, operationKind, requestOperation);
             const parts = [header, encodedPayload];
             const capacityStop = new AbortController();
             void pending.promise.finally(() => capacityStop.abort()).catch(() => undefined);
             void (async () => {
                 const applicationJobOwner = await this.reserveLocalIngress(capacityStop.signal);
                 try {
-                    if (!this.operations.isPending(pending.id))
+                    if (!pending.isPending())
                         return;
                     const applicationJob = await applicationJobOwner.acquire('application', capacityStop.signal);
-                    if (!this.operations.isPending(pending.id)) {
+                    if (!pending.isPending()) {
                         applicationJob.close();
                         return;
                     }
@@ -1069,19 +1223,19 @@ class RawServiceMeshRuntime {
                         parts,
                         sourceRoutingId: this.descriptor.nodeRoutingId,
                         correlation,
-                        localReply: (terminalResult, failureCode, reply) => this.operations.complete(pending.id, {
+                        localReply: (terminalResult, failureCode, reply) => this.completeRequest(pending, {
                             terminalResult,
                             failureCode,
                             ...(reply === undefined ? {} : { payload: reply })
-                        }),
+                        }, requestOperation === undefined ? undefined : observer, operationKind),
                         applicationJob
                     });
                     if (!accepted) {
                         applicationJob.close();
-                        this.operations.complete(pending.id, {
+                        this.completeRequest(pending, {
                             terminalResult: runtime_values_1.RequestResult.NotConnected,
                             failureCode: 0
-                        });
+                        }, requestOperation === undefined ? undefined : observer, operationKind);
                     }
                     else {
                         onAdmitted?.();
@@ -1090,31 +1244,22 @@ class RawServiceMeshRuntime {
                 finally {
                     applicationJobOwner.close();
                 }
-            })().catch((error) => this.operations.fail(pending.id, error));
+            })().catch((error) => this.failRequest(pending, error, requestOperation === undefined ? undefined : observer, operationKind));
             return pending;
         }
-        const pending = this.registerRequest(timeoutMs, observer, operationKind);
-        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.
+        const pending = this.registerRequest(timeoutMs, observer, operationKind, requestOperation);
+        const selectedPeer = this.topology.readyPeer(selectedTargetNodeRoutingId);
+        if (selectedPeer === undefined &&
+            !this.expectedPeers.has(selectedTargetNodeRoutingId) &&
+            this.topology.peer(selectedTargetNodeRoutingId) === undefined) {
             this.completeRequest(pending, {
                 terminalResult: runtime_values_1.RequestResult.NotFound,
                 failureCode: REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
-            });
+            }, requestOperation === undefined ? undefined : observer, operationKind);
             return pending;
         }
         const parts = [header, encodedPayload];
-        let request;
-        try {
-            request = this.requireStarted().request(selectedTargetNodeRoutingId, parts, timeoutMs, selectedPeer.liveness?.recordReceived, onAdmitted);
-        }
-        catch (error) {
-            this.failRequest(pending, error);
-            return pending;
-        }
-        void request.then((replyParts) => {
+        const completed = (replyParts) => {
             try {
                 if (replyParts.length < 1 || replyParts.length > 2) {
                     throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Invalid reply parts.');
@@ -1135,16 +1280,37 @@ class RawServiceMeshRuntime {
                     terminalResult: reply.terminalResult,
                     failureCode: reply.failureCode
                 };
-                this.operations.complete(pending.id, reply.terminalResult === 0
+                const value = reply.terminalResult === 0
                     ? { ...result, payload: (0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(replyParts[1]) }
-                    : result);
+                    : result;
+                if (requestOperation !== undefined && observer !== undefined)
+                    observer.operationCompleted(pending.id, value, operationKind);
+                else
+                    pending.reply(value);
             }
             catch (error) {
-                this.operations.fail(pending.id, error);
+                this.failRequest(pending, error, requestOperation === undefined ? undefined : observer, operationKind);
             }
-        }, (error) => {
-            this.operations.fail(pending.id, error);
-        });
+        };
+        const failed = (error) => this.failRequest(pending, error, requestOperation === undefined ? undefined : observer, operationKind);
+        if (selectedPeer !== undefined) {
+            try {
+                this.requireStarted().request(selectedTargetNodeRoutingId, parts, (0, request_deadline_1.remainingRequestTimeout)('Request', pending.deadlineMs), completed, failed, selectedPeer.liveness?.recordReceived, onAdmitted, pending);
+            }
+            catch (error) {
+                failed(error);
+            }
+            return pending;
+        }
+        (0, durable_service_request_1.admitServiceRequest)(this, selectedTargetNodeRoutingId, pending, (remaining, finished) => {
+            this.requireStarted().request(selectedTargetNodeRoutingId, parts, remaining, (reply) => {
+                finished();
+                completed(reply);
+            }, (error) => {
+                finished();
+                failed(error);
+            }, this.topology.admittedPeer(selectedTargetNodeRoutingId)?.liveness?.recordReceived, onAdmitted, pending);
+        }, failed);
         return pending;
     }
     /**
@@ -1155,10 +1321,10 @@ class RawServiceMeshRuntime {
         return Buffer.isBuffer(payload) ? payload : (0, service_wire_m6a_codec_1.encodeApplicationPayload)(payload);
     }
     applicationPayload(payload) {
-        return Buffer.isBuffer(payload) ? (0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(payload) : payload;
+        return Buffer.isBuffer(payload) ? (0, service_wire_m6a_codec_1.decodeApplicationPayload)(payload) : payload;
     }
     admitPeer(descriptor, connectionId, nowMs, expected, command = service_wire_m6a_codec_1.M6aServiceWireCommand.hello, descriptorBytes) {
-        const previous = this.topology.peer(descriptor.nodeRoutingId);
+        const previous = this.topology.admittedPeer(descriptor.nodeRoutingId);
         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);
@@ -1171,7 +1337,11 @@ class RawServiceMeshRuntime {
         if (result === 'notRequired' && previous !== undefined) {
             this.liveness.disconnect(descriptor.nodeRoutingId, previous.liveness?.connectionId ?? previous.connectionId);
         }
-        if (result === 'admitted')
+        if (result === 'admitted' &&
+            (previous?.connectionId !== topologyConnectionId ||
+                previous.descriptor.lifecycleGeneration !== descriptor.lifecycleGeneration ||
+                previous.remoteAdmitReceived !==
+                    this.topology.admittedPeer(descriptor.nodeRoutingId)?.remoteAdmitReceived))
             this.notifyPeerRouteChanged(descriptor.nodeRoutingId);
         return result;
     }
@@ -1204,10 +1374,16 @@ class RawServiceMeshRuntime {
         });
         this.endpointOnlyPeers.delete(endpoint);
     }
-    removePeer(peer) {
+    removePeer(peer, disconnectPhysical) {
         this.topology.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);
+        try {
+            disconnectPhysical?.();
+        }
+        finally {
+            // The logical admission has ended even when the physical disconnect reports a failure.
+            this.onPeerDisconnected?.(peer.descriptor.nodeRoutingId, peer.descriptor.advertisedEndpoint, peer.descriptor.lifecycleGeneration);
+        }
     }
     requireStarted() {
         if (this.router === undefined)
@@ -1234,9 +1410,7 @@ class RawServiceMeshRuntime {
         if (command === service_wire_m6a_codec_1.M6aServiceWireCommand.hello)
             this.liveness.setAdmissionPending(true, performance.now());
         const existing = this.controlSends.get(key);
-        if (existing !== undefined &&
-            existing.task !== undefined &&
-            (command !== service_wire_m6a_codec_1.M6aServiceWireCommand.hello || existing.current?.() === true)) {
+        if (existing?.task !== undefined) {
             if (command !== service_wire_m6a_codec_1.M6aServiceWireCommand.hello) {
                 existing.next = attempt;
                 existing.current = current;
@@ -1254,7 +1428,7 @@ class RawServiceMeshRuntime {
         const completeSend = () => {
             if (owner.controlSends.get(key) !== state)
                 return;
-            if (hello !== undefined && current?.() === true)
+            if (hello !== undefined)
                 delete state.task;
             else
                 owner.controlSends.delete(key);
@@ -1297,6 +1471,8 @@ class RawServiceMeshRuntime {
             throw failure.error;
     }
     send(targetNodeRoutingId, parts) {
+        if (!this.isPeerRouteReady(targetNodeRoutingId))
+            return false;
         try {
             const submission = this.requireStarted().submitSend(targetNodeRoutingId, parts);
             if (submission.result === runtime_values_1.SubmitResult.Ok)
@@ -1317,6 +1493,9 @@ class RawServiceMeshRuntime {
     }
 }
 exports.RawServiceMeshRuntime = RawServiceMeshRuntime;
+function channelSendSubmitResult(accepted) {
+    return accepted ? runtime_values_1.SubmitResult.Ok : runtime_values_1.SubmitResult.NotConnected;
+}
 function controlSendKey(target, command) {
     return `${command}:${target}`;
 }