@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/foundation/raw-service-mesh-runtime.ts

@@ -1,3 +1,13 @@
+import {
+  createInternalFrameworkException,
+  ZLinkFrameworkInternalErrorKind
+} from '../framework-errors-internal';
+import type { ConnectionAttempt } from '@zlink-systems/zlink';
+import { admitServiceRequest } from './durable-service-request';
+import { remainingRequestTimeout, requestTerminalError } from '../messaging/request-deadline';
+import type { OperationHandle } from './operation-registry';
+import type { RequestRuntime } from './request-runtime';
+import { inspectRuntime } from '../internal-observation';
 import { constants as osConstants } from 'node:os';
 import { ApplicationIngressRecordOwner } from '../application-jobs/application-ingress-record-owner';
 import type {
@@ -12,6 +22,7 @@ import type {
   ZLinkRawRouterPort
 } from '../backend/raw-binding-port';
 import { submitToRequestResult } from '../messaging/submission-result';
+import { copyPayloadBytes } from '../../contracts/Common/payload-slab';
 import { RequestResult, SubmitResult, isZLinkBackendResultError } from '../backend/runtime-values';
 import { enumWireRejectReason } from '../protocol/service_wire_codec.generated';
 import { SERVICE_WIRE_PREFIX_SIZE } from './service-wire-binary-primitives';
@@ -36,9 +47,11 @@ import {
   SERVICE_WIRE_MAGIC,
   SERVICE_WIRE_MAJOR,
   ServiceWireCommand,
-  ServiceWireFrameworkErrorCode
+  ServiceWireFrameworkErrorCode,
+  recoverRequestCorrelation
 } from './service-wire-constants.generated';
 import {
+  decodeApplicationPayload,
   decodeApplicationPayloadView,
   decodeChannelRequestHeader,
   decodeChannelSendHeader,
@@ -81,10 +94,7 @@ export type RawServiceRequestObserver = OperationObserver<RawServiceRequestResul
  * terminal reaches the observer. Local and Promise-contract requests carry
  * the Promise.
  */
-export interface RawServiceObservedRequest {
-  readonly id: bigint;
-  readonly promise?: Promise<RawServiceRequestResult>;
-}
+export interface RawServiceObservedRequest extends OperationHandle<RawServiceRequestResult> {}
 
 type RawServiceChannelTargetSelection =
   | { readonly kind: 'selected'; readonly peer: AdmittedServicePeer }
@@ -112,7 +122,7 @@ export interface RawServiceIngressRecord {
   readonly sourceNodeGeneration?: bigint;
   readonly sourceRoute?: Uint8Array;
   readonly requestSequence?: bigint;
-  readonly reply?: (parts: readonly Uint8Array[]) => void;
+  readonly reply?: ServiceMailboxRecord['reply'];
   readonly parts: readonly Buffer[];
   readonly applicationJobOwner?: ApplicationIngressRecordOwner;
 }
@@ -122,6 +132,7 @@ export type RawServiceIngressHandler = (
 ) => RawServicePumpResult | undefined | Promise<RawServicePumpResult | undefined>;
 
 export interface RawServiceMeshRuntimeOptions {
+  readonly requests?: RequestRuntime;
   readonly onReceiveReady?: () => void;
   readonly infrastructureTaskRunner?: import('../spots/spot-actor-join-dispatch').ZLinkDetachedTaskRunner;
   readonly onPendingOperationsChanged?: () => void;
@@ -166,6 +177,7 @@ const livenessCodec = createServiceWireCodec({
 interface ControlSendState {
   task?: Promise<boolean>;
   next?: () => boolean | Promise<boolean>;
+  // HELLO send eligibility; admission suspension does not end the exchange.
   current?: () => boolean;
   // Admission owns the first HELLO until ADMIT or route termination.
   hello?: Uint8Array;
@@ -176,12 +188,26 @@ interface ControlSendState {
  * It owns protocol, admission, mailbox, request and liveness state.
  */
 export class RawServiceMeshRuntime {
+  [inspectRuntime](nodeRoutingId?: string) {
+    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
+    });
+  }
+
   readonly topology: ServiceTopologyRegistry;
   readonly mailbox: ServiceMailbox;
   readonly liveness: ServiceLivenessRegistry;
 
+  private readonly requestOwner: RequestRuntime | undefined;
+  private readonly releaseOperations: () => void;
+
   private readonly operations: OperationRegistry<RawServiceRequestResult, number>;
-  private readonly expectedPeers = new Map<
+  readonly expectedPeers = new Map<
     string,
     {
       readonly meshName: string;
@@ -198,7 +224,8 @@ export class RawServiceMeshRuntime {
    * The last observed Core selected route of each RID (Core ROUTER §10.1):
    * RID -> route generation. Only `observeSelectedRoutes` replaces it.
    */
-  private selectedRoutes = new Map<string, bigint>();
+  selectedRoutes = new Map<string, bigint>();
+  private connectionAttempts: readonly ConnectionAttempt[] = [];
   private readonly bindingPort: ZLinkRawBindingPort;
   private readonly applicationJobQueue: ApplicationJobQueuePort;
   private readonly nodeMailboxOwner: string;
@@ -207,7 +234,7 @@ export class RawServiceMeshRuntime {
   private receiveAcquisition?: Promise<ApplicationJobPermitPort>;
   private receivePermit?: ApplicationJobPermitPort;
   private receiveRotation?: ApplicationJobReceiveRotationPort;
-  private readonly controlSends = new Map<string, ControlSendState>();
+  readonly controlSends = new Map<string, ControlSendState>();
   private infrastructureFailure?: { readonly error: unknown };
   private readonly onReceiveReady?: () => void;
   private readonly infrastructureTaskRunner?: RawServiceMeshRuntimeOptions['infrastructureTaskRunner'];
@@ -218,16 +245,25 @@ export class RawServiceMeshRuntime {
   private readonly resolveAdvertisedEndpoint?: RawServiceMeshRuntimeOptions['resolveAdvertisedEndpoint'];
   private descriptor: ServiceNodeDescriptor;
   private host?: ZLinkRawHostPort;
-  private router?: ZLinkRawRouterPort;
+  router?: ZLinkRawRouterPort;
   private nextCorrelation = 1n;
   private serviceIngress?: RawServiceIngressHandler;
   private serviceIngressAccepts?: (command: number) => boolean;
   private closed = false;
 
   constructor(options: RawServiceMeshRuntimeOptions) {
+    this.requestOwner = options.requests;
     this.onReceiveReady = options.onReceiveReady;
     this.infrastructureTaskRunner = options.infrastructureTaskRunner;
-    this.operations = new OperationRegistry(undefined, options.onPendingOperationsChanged);
+    this.operations =
+      options.requests?.operations<RawServiceRequestResult, number>() ??
+      new OperationRegistry(undefined, options.onPendingOperationsChanged, (reason) =>
+        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 ServiceTopologyRegistry(options.descriptor);
@@ -293,6 +329,7 @@ export class RawServiceMeshRuntime {
         lifecycleGeneration: expected.lifecycleGeneration
       })
     );
+    this.notifyPeerRouteChanged(expected.nodeRoutingId);
   }
 
   connectPeerByRoutingId(
@@ -312,6 +349,7 @@ export class RawServiceMeshRuntime {
         lifecycleGeneration
       })
     );
+    this.notifyPeerRouteChanged(nodeRoutingId);
   }
 
   expectPeerByRoutingId(
@@ -330,6 +368,7 @@ export class RawServiceMeshRuntime {
         lifecycleGeneration
       })
     );
+    this.notifyPeerRouteChanged(nodeRoutingId);
   }
 
   connectPeerEndpoint(endpoint: string): void {
@@ -414,13 +453,27 @@ export class RawServiceMeshRuntime {
     nodeRoutingId: string
   ): import('./durable-service-request').PeerRouteObservation {
     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: string): bigint | undefined {
+    return (
+      this.expectedPeers.get(nodeRoutingId)?.lifecycleGeneration ??
+      this.topology.admittedPeer(nodeRoutingId)?.descriptor.lifecycleGeneration
+    );
+  }
+
   async waitForPeerRoute(
     nodeRoutingId: string,
     lifecycleGeneration: bigint,
@@ -432,13 +485,13 @@ export class RawServiceMeshRuntime {
     const pending = this.operations.register(Number(remaining));
     const check = () => {
       if (this.isPeerRouteReady(nodeRoutingId, lifecycleGeneration)) {
-        this.operations.complete(pending.id, { terminalResult: RequestResult.Ok, failureCode: 0 });
+        pending.reply({ terminalResult: 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) abort();
@@ -483,15 +536,19 @@ export class RawServiceMeshRuntime {
     if (generation === undefined) return false;
     const key = controlSendKey(nodeRoutingId, 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);
+    if (!current()) {
+      if (existing === undefined) this.controlSends.set(key, { current });
+      return false;
+    }
     const hello =
-      existing?.current?.() === true
-        ? existing.hello!
-        : encodeRouteMeshAdmission(M6aServiceWireCommand.hello, this.topology.localDescriptor());
+      existing?.hello ??
+      encodeRouteMeshAdmission(M6aServiceWireCommand.hello, this.topology.localDescriptor());
     return this.startControlSend(
       nodeRoutingId,
       M6aServiceWireCommand.hello,
@@ -502,21 +559,16 @@ export class RawServiceMeshRuntime {
   }
 
   private isPeerAnnouncementCurrent(nodeRoutingId: string, generation: bigint): boolean {
-    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: string, lifecycleGeneration?: bigint): boolean {
     // 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 ||
@@ -593,20 +645,21 @@ export class RawServiceMeshRuntime {
     return this.send(targetNodeRoutingId, [NODE_SEND_HEADER, this.applicationFrame(payload)]);
   }
 
-  async sendToChannel(
+  sendToChannel(
     channelName: string,
     payload: ServiceApplicationPayloadInput
-  ): Promise<SubmitResult> {
+  ): SubmitResult | Promise<SubmitResult> {
     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, [
       encodeChannelSendHeader(channelName),
       applicationFrame
-    ]))
-      ? SubmitResult.Ok
-      : SubmitResult.NotConnected;
+    ]);
+    return typeof submitted === 'boolean'
+      ? channelSendSubmitResult(submitted)
+      : submitted.then(channelSendSubmitResult);
   }
 
   requestToNode(
@@ -621,7 +674,8 @@ export class RawServiceMeshRuntime {
     timeoutMs: number,
     onAdmitted: (() => void) | undefined,
     observer: RawServiceRequestObserver,
-    operationKind: number
+    operationKind: number,
+    requestOperation?: PendingOperation<unknown>
   ): RawServiceObservedRequest;
   requestToNode(
     targetNodeRoutingId: string,
@@ -629,7 +683,8 @@ export class RawServiceMeshRuntime {
     timeoutMs: number,
     onAdmitted?: () => void,
     observer?: RawServiceRequestObserver,
-    operationKind?: number
+    operationKind?: number,
+    requestOperation?: PendingOperation<unknown>
   ): RawServiceObservedRequest {
     return this.requestToTarget(
       targetNodeRoutingId,
@@ -638,7 +693,8 @@ export class RawServiceMeshRuntime {
       undefined,
       onAdmitted,
       observer,
-      operationKind
+      operationKind,
+      requestOperation
     );
   }
 
@@ -654,7 +710,8 @@ export class RawServiceMeshRuntime {
     timeoutMs: number,
     onAdmitted: (() => void) | undefined,
     observer: RawServiceRequestObserver,
-    operationKind: number
+    operationKind: number,
+    requestOperation?: PendingOperation<unknown>
   ): RawServiceObservedRequest;
   requestToChannel(
     channelName: string,
@@ -662,12 +719,18 @@ export class RawServiceMeshRuntime {
     timeoutMs: number,
     onAdmitted?: () => void,
     observer?: RawServiceRequestObserver,
-    operationKind?: number
+    operationKind?: number,
+    requestOperation?: PendingOperation<unknown>
   ): RawServiceObservedRequest {
     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(
@@ -681,6 +744,16 @@ export class RawServiceMeshRuntime {
     );
   }
 
+  beginInfrastructureRequest(
+    timeoutMs: number,
+    signal?: AbortSignal,
+    absoluteDeadlineMs = performance.now() + timeoutMs
+  ): PendingOperation<readonly Uint8Array[]> {
+    const pending = this.operations.register(timeoutMs, 'registry', undefined, absoluteDeadlineMs);
+    pending.setSignal(signal);
+    return pending as unknown as PendingOperation<readonly Uint8Array[]>;
+  }
+
   /**
    * One pending entry per request: an observed request reports its terminal
    * to the caller's observer; any other request keeps the Promise contract.
@@ -688,11 +761,19 @@ export class RawServiceMeshRuntime {
   private registerRequest(
     timeoutMs: number,
     observer: RawServiceRequestObserver | undefined,
-    operationKind: number | undefined
+    operationKind: number | undefined,
+    requestOperation?: PendingOperation<unknown>
   ): RawServiceObservedRequest {
+    if (requestOperation !== undefined) {
+      return requestOperation as PendingOperation<RawServiceRequestResult>;
+    }
     return observer === undefined
       ? this.operations.register(timeoutMs)
-      : { id: this.operations.registerObserved(timeoutMs, observer, operationKind) };
+      : this.observedRequest(this.operations.registerObserved(timeoutMs, observer, operationKind));
+  }
+
+  private observedRequest(id: bigint): RawServiceObservedRequest {
+    return this.operations.handle(id);
   }
 
   /**
@@ -701,23 +782,35 @@ export class RawServiceMeshRuntime {
    */
   private completeRequest(
     pending: RawServiceObservedRequest,
-    result: RawServiceRequestResult
+    result: RawServiceRequestResult,
+    observer?: RawServiceRequestObserver,
+    operationKind?: number
   ): void {
-    if (pending.promise === undefined)
-      queueMicrotask(() => this.operations.complete(pending.id, result));
-    else this.operations.complete(pending.id, result);
+    if (observer !== undefined) {
+      queueMicrotask(() => observer.operationCompleted(pending.id, result, operationKind));
+      return;
+    }
+    if (pending.promise === undefined || pending.hasObserver())
+      queueMicrotask(() => pending.reply(result));
+    else pending.reply(result);
   }
 
-  private failRequest(pending: RawServiceObservedRequest, error: unknown): void {
-    if (pending.promise === undefined)
-      queueMicrotask(() => this.operations.fail(pending.id, error));
-    else this.operations.fail(pending.id, error);
+  private failRequest(
+    pending: RawServiceObservedRequest,
+    error: unknown,
+    observer?: RawServiceRequestObserver,
+    operationKind?: number
+  ): void {
+    if (observer !== undefined) {
+      queueMicrotask(() => observer.operationFailed(pending.id, error, operationKind));
+      return;
+    }
+    if (pending.promise === undefined) queueMicrotask(() => pending.replyFailure(error));
+    else pending.replyFailure(error);
   }
 
   private selectChannelTarget(channelName: string): RawServiceChannelTargetSelection {
-    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)
       ? {
@@ -768,16 +861,64 @@ export class RawServiceMeshRuntime {
     targetNodeRoutingId: string,
     parts: readonly Uint8Array[],
     timeoutMs: number,
-    onAdmitted?: () => void
-  ): Promise<readonly Buffer[]> {
+    onAdmitted?: () => void,
+    existing?: Pick<PendingOperation<unknown>, 'id' | 'deadlineMs'>,
+    receiver?: undefined,
+    onSubmitted?: () => void
+  ): Promise<readonly Buffer[]>;
+  requestService(
+    targetNodeRoutingId: string,
+    parts: readonly Uint8Array[],
+    timeoutMs: number,
+    onAdmitted: (() => void) | undefined,
+    existing: Pick<PendingOperation<unknown>, 'id' | 'deadlineMs'> | undefined,
+    receiver: import('./operation-registry').OperationObserver<readonly Buffer[], unknown>
+  ): void;
+  requestService(
+    targetNodeRoutingId: string,
+    parts: readonly Uint8Array[],
+    timeoutMs: number,
+    onAdmitted?: () => void,
+    existing?: Pick<PendingOperation<unknown>, 'id' | 'deadlineMs'>,
+    receiver?: import('./operation-registry').OperationObserver<readonly Buffer[], unknown>,
+    onSubmitted?: () => void
+  ): Promise<readonly Buffer[]> | void {
+    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(
@@ -785,7 +926,7 @@ export class RawServiceMeshRuntime {
       RawServiceIngressRecord,
       'sourceRoutingId' | 'sourceRoute' | 'requestSequence' | 'reply'
     >,
-    parts: readonly Uint8Array[]
+    parts: readonly (Uint8Array | string)[]
   ): void {
     if (record.requestSequence === undefined) {
       throw new TypeError('Service reply requires a request sequence.');
@@ -813,10 +954,8 @@ export class RawServiceMeshRuntime {
     if (request.reply === undefined || request.correlation === undefined) {
       throw new TypeError('Reply requires a request mailbox record.');
     }
-    request.reply([
-      encodeReplyHeader(request.correlation, terminalResult, failureCode),
-      ...(terminalResult === 0 ? [this.applicationFrame(payload)] : [])
-    ]);
+    const header = encodeReplyHeader(request.correlation, terminalResult, failureCode);
+    request.reply(terminalResult === 0 ? [header, this.applicationFrame(payload)] : [header]);
   }
 
   async pumpOne(
@@ -838,14 +977,48 @@ export class RawServiceMeshRuntime {
     return this.receiveOne(nowMs, observe);
   }
 
-  setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean) => void): void {
+  setReadableHandler(
+    handler: (receiveReady: boolean, routeReady: boolean, connectReady: boolean) => void
+  ): void {
     this.requireStarted().setReadableHandler(handler);
   }
 
   /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
-  async pumpBatch(receiveReady = true, routeReady = false): Promise<boolean> {
-    this.observeInfrastructureFailure();
+  pumpBatch(
+    receiveReady = true,
+    routeReady = false,
+    connectReady = false
+  ): boolean | Promise<boolean> {
+    try {
+      this.observeInfrastructureFailure();
+      if (routeReady || connectReady) {
+        return this.receiveBatchAfterObservations(receiveReady, routeReady, connectReady);
+      }
+      return this.receiveBatch(receiveReady);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+
+  private async receiveBatchAfterObservations(
+    receiveReady: boolean,
+    routeReady: boolean,
+    connectReady: boolean
+  ): Promise<boolean> {
+    // 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);
+  }
+
+  private receiveBatch(receiveReady: boolean): boolean | Promise<boolean> {
     const startedAtMs = performance.now();
     let messages = 0;
     let bytes = 0;
@@ -857,30 +1030,49 @@ export class RawServiceMeshRuntime {
       '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?: RawServicePumpResult): boolean | Promise<boolean> => {
+      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 >= 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 >= RAW_MESH_RECEIVE_TIME_BUDGET_MS
-        )
-          break;
+      } catch (error) {
+        rotation.releaseUnused();
+        throw error;
       }
-    } finally {
       rotation.releaseUnused();
-    }
-    if (!this.closed) {
-      this.tickLiveness();
-    }
-    return receiveReady && messages > 0;
+      if (!this.closed) {
+        this.tickLiveness();
+      }
+      return receiveReady && messages > 0;
+    };
+    return drain();
   }
 
   private receiveOne(
@@ -894,35 +1086,7 @@ export class RawServiceMeshRuntime {
     this.receivePermit = undefined;
     permit ??= rotation?.take();
     if (permit === undefined && this.receiveAcquisition === undefined) {
-      let resolveAcquisition: ((permit: ApplicationJobPermitPort) => void) | undefined;
-      let rejectAcquisition: ((error: unknown) => void) | undefined;
-      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<ApplicationJobPermitPort>((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';
     if (this.closed) {
@@ -956,16 +1120,58 @@ export 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);
   }
 
+  private acquireReceivePermit(): ApplicationJobPermitPort | undefined {
+    let resolveAcquisition: ((permit: ApplicationJobPermitPort) => void) | undefined;
+    let rejectAcquisition: ((error: unknown) => void) | undefined;
+    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<ApplicationJobPermitPort>((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;
+  }
+
+  private finishPendingReceive(
+    result: Promise<RawServicePumpResult>,
+    received: ZLinkRawReceivedRecord,
+    owner: ApplicationIngressRecordOwner,
+    observe: RawServicePumpObserver | undefined
+  ): Promise<RawServicePumpResult> {
+    return result.then(
+      (value) => this.finishReceive(received, owner, observe, value),
+      (error) => {
+        owner.close();
+        throw error;
+      }
+    );
+  }
+
   private finishReceive(
     received: ZLinkRawReceivedRecord,
     owner: ApplicationIngressRecordOwner,
@@ -976,7 +1182,8 @@ export class RawServiceMeshRuntime {
       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;
@@ -985,7 +1192,7 @@ export class RawServiceMeshRuntime {
     }
   }
 
-  private reportProtocolError(
+  reportProtocolError(
     received: import('../backend/node/node-raw-binding-port').ZLinkRawReceivedRecord
   ): void {
     const request = received.requestSeq !== undefined;
@@ -1002,32 +1209,19 @@ export class RawServiceMeshRuntime {
     received: import('../backend/node/node-raw-binding-port').ZLinkRawReceivedRecord
   ): boolean {
     if (received.requestSeq === undefined || received.parts.length === 0) return false;
-    try {
-      const header = decodeHeader(received.parts[0]!);
-      const correlation =
-        header.command === M6aServiceWireCommand.nodeRequest
-          ? decodeNodeRequestHeader(received.parts[0]!)
-          : header.command === M6aServiceWireCommand.channelRequest
-            ? decodeChannelRequestHeader(received.parts[0]!).correlation
-            : undefined;
-      if (correlation === undefined) return false;
-      const reply = [
-        encodeReplyHeader(
-          correlation,
-          RequestResult.ProtocolError,
-          ServiceWireFrameworkErrorCode.requestProtocolError
-        )
-      ];
-      if (received.reply === undefined) return false;
-      received.reply(reply);
-      return true;
-    } catch (error) {
-      if (error instanceof ServiceWireProtocolError) return false;
-      throw error;
-    }
+    const correlation = recoverRequestCorrelation(received.parts[0]!);
+    if (correlation === undefined || received.reply === undefined) return false;
+    received.reply([
+      encodeReplyHeader(
+        correlation,
+        RequestResult.ProtocolError,
+        ServiceWireFrameworkErrorCode.requestProtocolError
+      )
+    ]);
+    return true;
   }
 
-  private processReceived(
+  processReceived(
     received: ZLinkRawReceivedRecord,
     nowMs: number,
     applicationJobOwner: ApplicationIngressRecordOwner
@@ -1045,9 +1239,7 @@ export class RawServiceMeshRuntime {
         header.command === M6aServiceWireCommand.hello ||
         header.command === M6aServiceWireCommand.admit
       ) {
-        return this.processAdmission(received, header, nowMs).catch((error) =>
-          this.receiveProtocolFailure(error)
-        );
+        return this.finishPendingProtocolReceive(this.processAdmission(received, header, nowMs));
       }
       if (header.command === M6aServiceWireCommand.reject) {
         if (received.parts.length !== 1) return 'protocolError';
@@ -1057,17 +1249,13 @@ export class RawServiceMeshRuntime {
       if (!currentSource) return 'dropped';
       this.liveness.recordReceived(peer.liveness, nowMs);
       if (header.command === M6aServiceWireCommand.update) {
-        return this.processAdmission(received, header, nowMs).catch((error) =>
-          this.receiveProtocolFailure(error)
-        );
+        return this.finishPendingProtocolReceive(this.processAdmission(received, header, nowMs));
       }
       if (
         header.command === M6aServiceWireCommand.livenessProbe ||
         header.command === 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
@@ -1086,11 +1274,7 @@ export 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);
     } catch (error) {
@@ -1099,6 +1283,24 @@ export class RawServiceMeshRuntime {
     }
   }
 
+  private finishPendingProtocolReceive(
+    pending: Promise<RawServicePumpResult>
+  ): Promise<RawServicePumpResult> {
+    return pending.catch((error) => this.receiveProtocolFailure(error));
+  }
+
+  private finishPendingStatefulReceive(
+    pending: Promise<RawServicePumpResult | undefined>,
+    received: ZLinkRawReceivedRecord,
+    header: ReturnType<typeof decodeHeader>,
+    owner: ApplicationIngressRecordOwner
+  ): Promise<RawServicePumpResult> {
+    return pending.then(
+      (result) => result ?? this.processApplicationReceived(received, header, owner),
+      (error) => this.receiveProtocolFailure(error)
+    );
+  }
+
   private receiveProtocolFailure(error: unknown): RawServicePumpResult {
     if (error instanceof ServiceWireProtocolError) return 'protocolError';
     throw error;
@@ -1170,7 +1372,7 @@ export class RawServiceMeshRuntime {
       ]);
     } else if (header.command === M6aServiceWireCommand.admit) {
       this.controlSends.delete(helloKey);
-      this.refreshAdmissionPending(nowMs);
+      this.progressPeerAdmission(nowMs);
       if (result === 'notRequired') {
         this.retireNotRequiredExpectedPeer(received.sourceRid, descriptor.advertisedEndpoint);
       } else if (
@@ -1274,13 +1476,26 @@ export 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);
     }
   }
 
+  private enqueuePendingOrdinaryRecord(
+    pending: Promise<
+      import('../application-jobs/application-ingress-record-owner').ApplicationJobRecordLease
+    >,
+    received: ZLinkRawReceivedRecord,
+    owner: string,
+    correlation: bigint | undefined
+  ): Promise<RawServicePumpResult> {
+    return pending.then((permit) =>
+      this.enqueueOrdinaryRecord(received, owner, correlation, permit)
+    );
+  }
+
   private enqueueOrdinaryRecord(
     received: ZLinkRawReceivedRecord,
     owner: string,
@@ -1316,7 +1531,9 @@ export class RawServiceMeshRuntime {
   }
 
   expireOperations(nowMs: number, turnDeadlineMs: number): number {
-    return this.operations.expire(nowMs, turnDeadlineMs);
+    return this.requestOwner === undefined && nowMs >= this.operations.nextDeadlineMs()
+      ? this.operations.expire(nowMs, turnDeadlineMs)
+      : 0;
   }
 
   get pendingOperationCount(): number {
@@ -1333,20 +1550,24 @@ export class RawServiceMeshRuntime {
    * ADMIT, which keeps the existing announce cadence.
    */
   nextMaintenanceDeadlineMs(nowMs: number): number {
-    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()
+    );
   }
 
-  private refreshAdmissionPending(nowMs: number): void {
+  private progressPeerAdmission(nowMs: number): void {
     let pending = false;
     if (!this.closed && this.controlSends.size !== 0) {
       for (const nodeRoutingId of this.selectedRoutes.keys()) {
-        const exchange = this.controlSends.get(
-          controlSendKey(nodeRoutingId, M6aServiceWireCommand.hello)
-        );
+        const key = controlSendKey(nodeRoutingId, 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;
         }
       }
     }
@@ -1354,9 +1575,12 @@ export class RawServiceMeshRuntime {
   }
 
   tickLiveness(nowMs = performance.now()): ServiceLivenessTick {
+    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);
     for (const probe of result.probes) {
@@ -1370,12 +1594,24 @@ export class RawServiceMeshRuntime {
         this.submitControl(probe.nodeRoutingId, parts)
       );
     }
+    const failures: unknown[] = [];
     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;
   }
 
@@ -1410,34 +1646,44 @@ export 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(): void {
-    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(
+          createInternalFrameworkException(
+            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;
+    }
   }
 
   private requestToTarget(
@@ -1447,14 +1693,15 @@ export class RawServiceMeshRuntime {
     channelName?: string,
     onAdmitted?: () => void,
     observer?: RawServiceRequestObserver,
-    operationKind?: number
+    operationKind?: number,
+    requestOperation?: PendingOperation<unknown>
   ): RawServiceObservedRequest {
     const correlation = this.nextCorrelation++;
     const header =
       channelName === undefined
         ? encodeNodeRequestHeader(correlation)
         : encodeChannelRequestHeader(correlation, channelName);
-    const encodedPayload = this.applicationFrame(payload);
+    let encodedPayload = this.applicationFrame(payload);
     let selectedTargetNodeRoutingId = targetNodeRoutingId;
     if (
       selectedTargetNodeRoutingId !== this.descriptor.nodeRoutingId &&
@@ -1482,21 +1729,30 @@ export class RawServiceMeshRuntime {
       }
     }
     if (selectedTargetNodeRoutingId === this.descriptor.nodeRoutingId) {
+      encodedPayload = 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
+            ) as PendingOperation<RawServiceRequestResult>);
       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)) return;
+          if (!pending.isPending()) return;
           const applicationJob = await applicationJobOwner.acquire(
             'application',
             capacityStop.signal
           );
-          if (!this.operations.isPending(pending.id)) {
+          if (!pending.isPending()) {
             applicationJob.close();
             return;
           }
@@ -1507,91 +1763,150 @@ export class RawServiceMeshRuntime {
             sourceRoutingId: this.descriptor.nodeRoutingId,
             correlation,
             localReply: (terminalResult, failureCode, reply) =>
-              this.operations.complete(pending.id, {
-                terminalResult,
-                failureCode,
-                ...(reply === undefined ? {} : { payload: 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, {
-              terminalResult: RequestResult.NotConnected,
-              failureCode: 0
-            });
+            this.completeRequest(
+              pending,
+              {
+                terminalResult: RequestResult.NotConnected,
+                failureCode: 0
+              },
+              requestOperation === undefined ? undefined : observer,
+              operationKind
+            );
           } else {
             onAdmitted?.();
           }
         } 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.
-      this.completeRequest(pending, {
-        terminalResult: RequestResult.NotFound,
-        failureCode: REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
-      });
+    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: RequestResult.NotFound,
+          failureCode: REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
+        },
+        requestOperation === undefined ? undefined : observer,
+        operationKind
+      );
       return pending;
     }
     const parts = [header, encodedPayload];
-    let request: Promise<readonly Uint8Array[]>;
-    try {
-      request = this.requireStarted().request(
-        selectedTargetNodeRoutingId,
-        parts,
-        timeoutMs,
-        selectedPeer.liveness?.recordReceived,
-        onAdmitted
+    const completed = (replyParts: readonly Buffer[]) => {
+      try {
+        if (replyParts.length < 1 || replyParts.length > 2) {
+          throw new ServiceWireProtocolError('Invalid reply parts.');
+        }
+        const reply = decodeReplyHeader(replyParts[0]!);
+        if (reply.correlation !== correlation)
+          throw new ServiceWireProtocolError('Reply correlation mismatch.');
+        if (reply.tail.byteLength !== 0) {
+          throw new ServiceWireProtocolError(
+            'Generic node/channel reply carries an operation-specific tail.'
+          );
+        }
+        if (reply.terminalResult === 0 && replyParts.length !== 2) {
+          throw new ServiceWireProtocolError('Successful reply omits its payload.');
+        }
+        if (reply.terminalResult !== 0 && replyParts.length !== 1) {
+          throw new ServiceWireProtocolError('Failed reply carries a payload.');
+        }
+        const result: RawServiceRequestResult = {
+          terminalResult: reply.terminalResult,
+          failureCode: reply.failureCode
+        };
+        const value =
+          reply.terminalResult === 0
+            ? { ...result, payload: decodeApplicationPayloadView(replyParts[1]!) }
+            : result;
+        if (requestOperation !== undefined && observer !== undefined)
+          observer.operationCompleted(pending.id, value, operationKind);
+        else pending.reply(value);
+      } catch (error) {
+        this.failRequest(
+          pending,
+          error,
+          requestOperation === undefined ? undefined : observer,
+          operationKind
+        );
+      }
+    };
+    const failed = (error: unknown) =>
+      this.failRequest(
+        pending,
+        error,
+        requestOperation === undefined ? undefined : observer,
+        operationKind
       );
-    } catch (error) {
-      this.failRequest(pending, error);
+    if (selectedPeer !== undefined) {
+      try {
+        this.requireStarted().request(
+          selectedTargetNodeRoutingId,
+          parts,
+          remainingRequestTimeout('Request', pending.deadlineMs)!,
+          completed,
+          failed,
+          selectedPeer.liveness?.recordReceived,
+          onAdmitted,
+          pending
+        );
+      } catch (error) {
+        failed(error);
+      }
       return pending;
     }
-    void request.then(
-      (replyParts) => {
-        try {
-          if (replyParts.length < 1 || replyParts.length > 2) {
-            throw new ServiceWireProtocolError('Invalid reply parts.');
-          }
-          const reply = decodeReplyHeader(replyParts[0]!);
-          if (reply.correlation !== correlation)
-            throw new ServiceWireProtocolError('Reply correlation mismatch.');
-          if (reply.tail.byteLength !== 0) {
-            throw new ServiceWireProtocolError(
-              'Generic node/channel reply carries an operation-specific tail.'
-            );
-          }
-          if (reply.terminalResult === 0 && replyParts.length !== 2) {
-            throw new ServiceWireProtocolError('Successful reply omits its payload.');
-          }
-          if (reply.terminalResult !== 0 && replyParts.length !== 1) {
-            throw new ServiceWireProtocolError('Failed reply carries a payload.');
-          }
-          const result: RawServiceRequestResult = {
-            terminalResult: reply.terminalResult,
-            failureCode: reply.failureCode
-          };
-          this.operations.complete(
-            pending.id,
-            reply.terminalResult === 0
-              ? { ...result, payload: decodeApplicationPayloadView(replyParts[1]!) }
-              : result
-          );
-        } catch (error) {
-          this.operations.fail(pending.id, error);
-        }
+    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
+        );
       },
-      (error) => {
-        this.operations.fail(pending.id, error);
-      }
+      failed
     );
     return pending;
   }
@@ -1605,10 +1920,10 @@ export class RawServiceMeshRuntime {
   }
 
   private applicationPayload(payload: ServiceApplicationPayloadInput): ServiceApplicationPayload {
-    return Buffer.isBuffer(payload) ? decodeApplicationPayloadView(payload) : payload;
+    return Buffer.isBuffer(payload) ? decodeApplicationPayload(payload) : payload;
   }
 
-  private admitPeer(
+  admitPeer(
     descriptor: ServiceNodeDescriptor,
     connectionId: string | bigint,
     nowMs: number,
@@ -1620,7 +1935,7 @@ export class RawServiceMeshRuntime {
     command: number = M6aServiceWireCommand.hello,
     descriptorBytes?: Uint8Array
   ): PeerAdmissionResult {
-    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(
@@ -1646,7 +1961,14 @@ export class RawServiceMeshRuntime {
         previous.liveness?.connectionId ?? previous.connectionId
       );
     }
-    if (result === 'admitted') this.notifyPeerRouteChanged(descriptor.nodeRoutingId);
+    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;
   }
 
@@ -1680,17 +2002,22 @@ export class RawServiceMeshRuntime {
     this.endpointOnlyPeers.delete(endpoint);
   }
 
-  private removePeer(peer: AdmittedServicePeer): void {
+  private removePeer(peer: AdmittedServicePeer, disconnectPhysical?: () => void): void {
     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
+      );
+    }
   }
 
   private requireStarted(): ZLinkRawRouterPort {
@@ -1698,10 +2025,7 @@ export class RawServiceMeshRuntime {
     return this.router;
   }
 
-  private async sendControl(
-    targetNodeRoutingId: string,
-    parts: readonly Uint8Array[]
-  ): Promise<boolean> {
+  async sendControl(targetNodeRoutingId: string, parts: readonly Uint8Array[]): Promise<boolean> {
     return this.startControlSend(targetNodeRoutingId, decodeHeader(parts[0]!).command, () =>
       this.submitControl(targetNodeRoutingId, parts)
     );
@@ -1721,7 +2045,7 @@ export class RawServiceMeshRuntime {
     );
   }
 
-  private startControlSend(
+  startControlSend(
     target: string,
     command: number,
     attempt: () => boolean | Promise<boolean>,
@@ -1732,11 +2056,7 @@ export class RawServiceMeshRuntime {
     if (command === M6aServiceWireCommand.hello)
       this.liveness.setAdmissionPending(true, performance.now());
     const existing = this.controlSends.get(key);
-    if (
-      existing !== undefined &&
-      existing.task !== undefined &&
-      (command !== M6aServiceWireCommand.hello || existing.current?.() === true)
-    ) {
+    if (existing?.task !== undefined) {
       if (command !== M6aServiceWireCommand.hello) {
         existing.next = attempt;
         existing.current = current;
@@ -1752,7 +2072,7 @@ export class RawServiceMeshRuntime {
     const state: ControlSendState = { current, hello };
     const completeSend = () => {
       if (owner.controlSends.get(key) !== state) return;
-      if (hello !== undefined && current?.() === true) delete state.task;
+      if (hello !== undefined) delete state.task;
       else owner.controlSends.delete(key);
     };
     const task = first.then(function drain(accepted): boolean | Promise<boolean> {
@@ -1805,6 +2125,7 @@ export class RawServiceMeshRuntime {
     targetNodeRoutingId: string,
     parts: readonly Uint8Array[]
   ): boolean | Promise<boolean> {
+    if (!this.isPeerRouteReady(targetNodeRoutingId)) return false;
     try {
       const submission = this.requireStarted().submitSend(targetNodeRoutingId, parts);
       if (submission.result === SubmitResult.Ok) return true;
@@ -1827,6 +2148,10 @@ export class RawServiceMeshRuntime {
   }
 }
 
+function channelSendSubmitResult(accepted: boolean): SubmitResult {
+  return accepted ? SubmitResult.Ok : SubmitResult.NotConnected;
+}
+
 function controlSendKey(target: string, command: number): string {
   return `${command}:${target}`;
 }