@zlink-systems/framework 0.25.0 → 0.27.0

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

@@ -1,30 +1,36 @@
-import { randomUUID } from 'node:crypto';
+import { constants as osConstants } from 'node:os';
+import { ApplicationIngressRecordOwner } from '../application-jobs/application-ingress-record-owner';
+import type {
+  ApplicationJobPermitPort,
+  ApplicationJobQueuePort
+} from '../application-jobs/contracts';
 import type {
   ZLinkRawBindingPort,
   ZLinkRawHostPort,
-  ZLinkRawMonitorRecord,
-  ZLinkRawMonitorPort,
   ZLinkRawReceivedRecord,
   ZLinkRawRouterPort
 } from '../backend/raw-binding-port';
 import { RequestResult, SubmitResult } from '../backend/runtime-values';
-import type {
-  ApplicationJobPermitPort,
-  ApplicationJobQueuePort
-} from '../application-jobs/contracts';
-import { ApplicationIngressRecordOwner } from '../application-jobs/application-ingress-record-owner';
+import { enumWireRejectReason } from '../protocol/service_wire_codec.generated';
 import { OperationRegistry, type PendingOperation } from './operation-registry';
 import { ServiceLivenessRegistry, type ServiceLivenessTick } from './service-liveness-registry';
 import { ServiceMailbox, type ServiceMailboxRecord } from './service-mailbox';
 import {
-  ServiceTopologyRegistry,
   sameServiceNodeDescriptor,
+  ServiceTopologyRegistry,
   validateDescriptor,
   type AdmittedServicePeer,
   type PeerAdmissionResult,
-  type ServicePeerAdmissionExpectation,
-  type ServiceNodeDescriptor
+  type ServiceNodeDescriptor,
+  type ServicePeerAdmissionExpectation
 } from './service-topology-registry';
+import { createServiceWireCodec } from './service-wire-codec';
+import {
+  SERVICE_WIRE_MAGIC,
+  SERVICE_WIRE_MAJOR,
+  ServiceWireCommand,
+  ServiceWireFrameworkErrorCode
+} from './service-wire-constants.generated';
 import {
   decodeApplicationPayloadView,
   decodeChannelRequestHeader,
@@ -43,14 +49,11 @@ import {
   encodeReplyHeader,
   encodeRouteMeshAdmission,
   M6aServiceWireCommand,
-  type ServiceApplicationPayload,
-  ServiceWireProtocolError
+  ServiceWireProtocolError,
+  type ServiceApplicationPayload
 } from './service-wire-m6a-codec';
-import { createServiceWireCodec } from './service-wire-codec';
-import {
-  ServiceWireCommand,
-  ServiceWireFrameworkErrorCode
-} from './service-wire-constants.generated';
+
+const nativeErrnoValues = osConstants.errno;
 
 export type RawServicePumpResult =
   'noData' | 'infrastructure' | 'application' | 'dropped' | 'protocolError';
@@ -96,6 +99,7 @@ export type RawServiceIngressHandler = (
 ) => RawServicePumpResult | undefined | Promise<RawServicePumpResult | undefined>;
 
 export interface RawServiceMeshRuntimeOptions {
+  readonly onPendingOperationsChanged?: () => void;
   readonly descriptor: ServiceNodeDescriptor;
   readonly resolveAdvertisedEndpoint?: (boundEndpoint: string) => string;
   readonly probeIntervalMs?: number;
@@ -119,31 +123,20 @@ export interface RawServiceMeshRuntimeOptions {
   }) => void;
 }
 
-const MONITOR_DISCONNECTED = 0x0200;
-const MONITOR_CONNECTION_READY = 0x1000;
-const MONITOR_CONNECTION_READY_EDGE = 1;
 // Framework error code 13 (RequestTargetNotFound) is encoded as 14 on a
 // RequestResult.NotFound reply. Boundary transport results keep failureCode 0.
-const REQUEST_TARGET_NOT_FOUND_FAILURE_CODE = 14;
-type PhysicalConnectionDirection = 'inbound' | 'outbound' | 'unknown';
-
-interface PhysicalConnectionCandidate {
-  readonly connectionId: string;
-  readonly direction: PhysicalConnectionDirection;
-  readonly discriminator: string;
-  readonly localAddress: string;
-  readonly remoteAddress: string;
-}
+const RAW_MESH_RECEIVE_RECORD_BUDGET = 64;
+const RAW_MESH_RECEIVE_BYTE_BUDGET = 4 * 1024 * 1024;
+export const RAW_MESH_RECEIVE_TIME_BUDGET_MS = 2;
+
+const REQUEST_TARGET_NOT_FOUND_FAILURE_CODE = ServiceWireFrameworkErrorCode.requestTargetNotFound;
 
 const livenessCodec = createServiceWireCodec({
-  magic: [0x5a, 0x4d],
-  major: 1,
+  magic: SERVICE_WIRE_MAGIC,
+  major: SERVICE_WIRE_MAJOR,
   commands: M6aServiceWireCommand
 });
 
-const MAX_PENDING_MONITOR_EVENTS = 8192;
-const MAX_UNRESOLVED_CONNECTION_CANDIDATES = 4096;
-
 /**
  * RouteMesh M6A runtime built only on the public raw binding package.
  * It owns protocol, admission, mailbox, request and liveness state.
@@ -153,7 +146,7 @@ export class RawServiceMeshRuntime {
   readonly mailbox: ServiceMailbox;
   readonly liveness: ServiceLivenessRegistry;
 
-  private readonly operations = new OperationRegistry<RawServiceRequestResult>();
+  private readonly operations: OperationRegistry<RawServiceRequestResult>;
   private readonly expectedPeers = new Map<
     string,
     {
@@ -162,24 +155,16 @@ export class RawServiceMeshRuntime {
       readonly endpoint?: string;
       readonly securityIdentity?: string;
       readonly lifecycleGeneration?: bigint;
+      helloSubmittedGeneration?: bigint;
     }
   >();
   private readonly endpointOnlyPeers = new Set<string>();
   private readonly peerConnectionIntentRemoved = new Set<(nodeRoutingId: string) => void>();
-  private readonly connectionCandidates = new Map<
-    string,
-    Map<string, PhysicalConnectionCandidate>
-  >();
-  private readonly unresolvedConnectionCandidates: PhysicalConnectionCandidate[] = [];
-  private readonly connectionIds = new Map<string, string>();
   /**
-   * The monitor drain updates this fence before the event reaches the
-   * normal runtime handler. `null` means that the last observed pair is no
-   * longer usable by the application route.
+   * The last observed Core selected route of each RID (Core ROUTER §10.1):
+   * RID -> route generation. Only `observeSelectedRoutes` replaces it.
    */
-  private readonly monitorConnectionStates = new Map<string, string | null>();
-  private monitorEvents: ZLinkRawMonitorRecord[] = [];
-  private monitorDrainBuffer: ZLinkRawMonitorRecord[] = [];
+  private selectedRoutes = new Map<string, bigint>();
   private readonly bindingPort: ZLinkRawBindingPort;
   private readonly applicationJobQueue: ApplicationJobQueuePort;
   private readonly peerAdmissionSealed?: () => boolean;
@@ -192,12 +177,12 @@ export class RawServiceMeshRuntime {
   private descriptor: ServiceNodeDescriptor;
   private host?: ZLinkRawHostPort;
   private router?: ZLinkRawRouterPort;
-  private monitor?: ZLinkRawMonitorPort;
   private nextCorrelation = 1n;
   private serviceIngress?: RawServiceIngressHandler;
   private closed = false;
 
   constructor(options: RawServiceMeshRuntimeOptions) {
+    this.operations = new OperationRegistry(undefined, options.onPendingOperationsChanged);
     this.descriptor = options.descriptor;
     this.topology = new ServiceTopologyRegistry(options.descriptor);
     this.mailbox = new ServiceMailbox(options.onMailboxReady);
@@ -239,8 +224,6 @@ export class RawServiceMeshRuntime {
       };
       this.topology.publishLocal(next);
       this.descriptor = next;
-      this.monitor = router.monitor();
-      this.pullMonitorEvents();
       this.host = host;
       this.router = router;
     } catch (error) {
@@ -254,13 +237,16 @@ export class RawServiceMeshRuntime {
 
   connectPeer(endpoint: string, expected: ServiceNodeDescriptor): void {
     this.requireStarted().connectToRoutingId(expected.nodeRoutingId, endpoint);
-    this.expectedPeers.set(expected.nodeRoutingId, {
-      meshName: expected.meshName,
-      nodeRoutingId: expected.nodeRoutingId,
-      endpoint,
-      securityIdentity: expected.securityIdentity,
-      lifecycleGeneration: expected.lifecycleGeneration
-    });
+    this.expectedPeers.set(
+      expected.nodeRoutingId,
+      Object.assign(this.expectedPeers.get(expected.nodeRoutingId) ?? {}, {
+        meshName: expected.meshName,
+        nodeRoutingId: expected.nodeRoutingId,
+        endpoint,
+        securityIdentity: expected.securityIdentity,
+        lifecycleGeneration: expected.lifecycleGeneration
+      })
+    );
   }
 
   connectPeerByRoutingId(
@@ -270,13 +256,16 @@ export class RawServiceMeshRuntime {
     lifecycleGeneration?: bigint
   ): void {
     this.requireStarted().connectToRoutingId(nodeRoutingId, endpoint);
-    this.expectedPeers.set(nodeRoutingId, {
-      meshName: this.topology.localDescriptor().meshName,
+    this.expectedPeers.set(
       nodeRoutingId,
-      endpoint,
-      securityIdentity,
-      lifecycleGeneration
-    });
+      Object.assign(this.expectedPeers.get(nodeRoutingId) ?? {}, {
+        meshName: this.topology.localDescriptor().meshName,
+        nodeRoutingId,
+        endpoint,
+        securityIdentity,
+        lifecycleGeneration
+      })
+    );
   }
 
   expectPeerByRoutingId(
@@ -285,13 +274,16 @@ export class RawServiceMeshRuntime {
     securityIdentity?: string,
     lifecycleGeneration?: bigint
   ): void {
-    this.expectedPeers.set(nodeRoutingId, {
-      meshName: this.topology.localDescriptor().meshName,
+    this.expectedPeers.set(
       nodeRoutingId,
-      endpoint,
-      securityIdentity,
-      lifecycleGeneration
-    });
+      Object.assign(this.expectedPeers.get(nodeRoutingId) ?? {}, {
+        meshName: this.topology.localDescriptor().meshName,
+        nodeRoutingId,
+        endpoint,
+        securityIdentity,
+        lifecycleGeneration
+      })
+    );
   }
 
   connectPeerEndpoint(endpoint: string): void {
@@ -379,35 +371,42 @@ export class RawServiceMeshRuntime {
   }
 
   async announcePeer(nodeRoutingId: string): Promise<boolean> {
-    if (!this.expectedPeers.has(nodeRoutingId) || this.peerAdmissionSealed?.() === true)
+    const expected = this.expectedPeers.get(nodeRoutingId);
+    const generation = this.selectedRoutes.get(nodeRoutingId);
+    if (
+      expected === undefined ||
+      generation === undefined ||
+      expected.helloSubmittedGeneration === generation ||
+      this.peerAdmissionSealed?.() === true
+    )
       return false;
-    return this.send(nodeRoutingId, [
+    const accepted = await this.send(nodeRoutingId, [
       encodeRouteMeshAdmission(M6aServiceWireCommand.hello, this.topology.localDescriptor())
     ]);
+    if (
+      accepted &&
+      this.expectedPeers.get(nodeRoutingId) === expected &&
+      this.selectedRoutes.get(nodeRoutingId) === generation
+    )
+      expected.helloSubmittedGeneration = generation;
+    return accepted;
   }
 
   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.peer(nodeRoutingId);
-    const monitorConnection = this.monitorConnectionStates.get(nodeRoutingId);
-    const applicationRouteReady =
-      monitorConnection === undefined || monitorConnection === peer?.connectionId;
-    const ready =
+    return (
       peer !== undefined &&
       (lifecycleGeneration === undefined ||
         peer.descriptor.lifecycleGeneration === lifecycleGeneration) &&
-      applicationRouteReady &&
-      this.liveness.isReady(nodeRoutingId, peer.connectionId);
-    return ready;
+      this.liveness.isReady(nodeRoutingId, peer.connectionId)
+    );
   }
 
   async announceExpectedPeers(): Promise<number> {
     let accepted = 0;
     for (const nodeRoutingId of this.expectedPeers.keys()) {
-      // Admission is a one-time fence for the current physical connection.
-      // Re-sending Hello after the peer is admitted would re-run admission on
-      // every poll and reset the liveness record before application traffic
-      // can use the route. A disconnected peer is removed by monitor handling
-      // and remains eligible for the next admission attempt.
       if (this.topology.peer(nodeRoutingId) !== undefined) continue;
       if (await this.announcePeer(nodeRoutingId)) accepted++;
     }
@@ -451,7 +450,6 @@ export class RawServiceMeshRuntime {
     for (const peer of this.topology.peers()) {
       await this.send(peer.descriptor.nodeRoutingId, [update]);
     }
-    await this.announceExpectedPeers();
   }
 
   replaceDiscoveredNotRequired(descriptors: readonly ServiceNodeDescriptor[]): void {
@@ -481,23 +479,6 @@ export class RawServiceMeshRuntime {
     if (selection.kind !== 'selected') return selection.submitResult;
     const selected = selection.peer;
     const applicationFrame = this.applicationFrame(payload);
-    if (selected.descriptor.nodeRoutingId === this.descriptor.nodeRoutingId) {
-      const applicationJobOwner = await this.reserveLocalIngress();
-      try {
-        const applicationJob = await applicationJobOwner.acquire('application');
-        const accepted = this.mailbox.tryEnqueue({
-          owner: `channel:${channelName}`,
-          domain: 'application',
-          parts: [encodeChannelSendHeader(channelName), applicationFrame],
-          sourceRoutingId: this.descriptor.nodeRoutingId,
-          applicationJob
-        });
-        if (!accepted) applicationJob.close();
-        return accepted ? SubmitResult.Ok : SubmitResult.NotAdmitted;
-      } finally {
-        applicationJobOwner.close();
-      }
-    }
     return (await this.send(selected.descriptor.nodeRoutingId, [
       encodeChannelSendHeader(channelName),
       applicationFrame
@@ -535,7 +516,7 @@ export class RawServiceMeshRuntime {
 
   private selectChannelTarget(channelName: string): RawServiceChannelTargetSelection {
     const selected = this.topology.selectChannel(channelName, (peer) =>
-      this.isLocalOrReadyPeer(peer.descriptor.nodeRoutingId)
+      this.isPeerRouteReady(peer.descriptor.nodeRoutingId)
     );
     if (selected !== undefined) return { kind: 'selected', peer: selected };
     return this.topology.hasKnownChannelTarget(channelName)
@@ -554,10 +535,6 @@ export class RawServiceMeshRuntime {
         };
   }
 
-  private isLocalOrReadyPeer(nodeRoutingId: string): boolean {
-    return nodeRoutingId === this.descriptor.nodeRoutingId || this.isPeerRouteReady(nodeRoutingId);
-  }
-
   setServiceIngress(handler: RawServiceIngressHandler): void {
     if (this.serviceIngress !== undefined && this.serviceIngress !== handler) {
       throw new Error('Raw service ingress is already registered.');
@@ -629,24 +606,23 @@ export class RawServiceMeshRuntime {
     nowMs = performance.now(),
     observe?: RawServicePumpObserver
   ): Promise<RawServicePumpResult> {
-    this.pullMonitorEvents();
     return this.receiveOne(nowMs, observe);
   }
 
-  setReadableHandler(handler: () => void): void {
+  setReadableHandler(handler: (receiveReady: boolean, routeReady: 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): Promise<boolean> {
-    await this.drainMonitorEvents();
+  async pumpBatch(receiveReady = true, routeReady = false): Promise<boolean> {
+    if (routeReady) await this.observeSelectedRoutes();
     const startedAtMs = performance.now();
     let messages = 0;
     let bytes = 0;
     const observe: RawServicePumpObserver = (_source, byteCount) => {
       bytes += byteCount;
     };
-    while (receiveReady && messages < 64 && !this.closed) {
+    while (receiveReady && messages < RAW_MESH_RECEIVE_RECORD_BUDGET && !this.closed) {
       const result = await this.receiveOne(performance.now(), observe);
       if (result === 'noData') {
         receiveReady = false;
@@ -655,7 +631,11 @@ export class RawServiceMeshRuntime {
       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 >= 4 * 1024 * 1024 || performance.now() - startedAtMs >= 2) break;
+      if (
+        bytes >= RAW_MESH_RECEIVE_BYTE_BUDGET ||
+        performance.now() - startedAtMs >= RAW_MESH_RECEIVE_TIME_BUDGET_MS
+      )
+        break;
     }
     if (!this.closed) {
       await this.announceExpectedPeers();
@@ -711,24 +691,6 @@ export class RawServiceMeshRuntime {
     }
   }
 
-  private pullMonitorEvents(): void {
-    this.monitor?.drain((event) => {
-      this.observeMonitorEvent(event);
-      if (this.monitorEvents.length < MAX_PENDING_MONITOR_EVENTS) {
-        this.monitorEvents.push(event);
-        return;
-      }
-      const existingIndex = this.monitorEvents.findIndex((candidate) =>
-        sameMonitorConnection(candidate, event)
-      );
-      if (existingIndex >= 0) this.monitorEvents[existingIndex] = event;
-      else {
-        this.monitorEvents.shift();
-        this.monitorEvents.push(event);
-      }
-    });
-  }
-
   private reportProtocolError(
     received: import('../backend/node/node-raw-binding-port').ZLinkRawReceivedRecord
   ): void {
@@ -809,14 +771,17 @@ export class RawServiceMeshRuntime {
           (expected.meshName !== descriptor.meshName ||
             expected.nodeRoutingId !== descriptor.nodeRoutingId)
         ) {
-          await this.send(received.sourceRid, [encodeReject(3)]);
+          await this.send(received.sourceRid, [
+            encodeReject(enumWireRejectReason('identityMismatch'))
+          ]);
           return 'infrastructure';
         }
-        const connection = this.currentConnectionCandidate(
-          received.sourceRid,
-          descriptor.advertisedEndpoint
+        const result = this.admitPeer(
+          descriptor,
+          routeConnectionId(received.routeGeneration),
+          nowMs,
+          expected
         );
-        const result = this.admitPeer(descriptor, connection, nowMs, expected);
         if (result !== 'admitted' && result !== 'notRequired') {
           const detail =
             result === 'invalidDescriptor'
@@ -848,25 +813,7 @@ export class RawServiceMeshRuntime {
       }
       if (header.command === M6aServiceWireCommand.reject) {
         if (received.parts.length !== 1) return 'protocolError';
-        const reason = decodeReject(received.parts[0]!);
-        // A reject belongs to one physical candidate, but the wire record does
-        // not carry that candidate's connection id. Keep an already admitted
-        // peer: bilateral manual connect can reject the duplicate after the
-        // other candidate has become Ready.
-        if (reason === 4 && this.topology.peer(received.sourceRid) === undefined) {
-          const expected = this.expectedPeers.get(received.sourceRid);
-          const local = this.topology.localDescriptor();
-          this.topology.markNotRequired({
-            ...local,
-            nodeRoutingId: received.sourceRid,
-            lifecycleGeneration: 1n,
-            descriptorRevision: 1n,
-            advertisedEndpoint: expected?.endpoint ?? local.advertisedEndpoint,
-            channels: [],
-            objectRole: 'client'
-          });
-          this.retireNotRequiredExpectedPeer(received.sourceRid);
-        }
+        decodeReject(received.parts[0]!);
         return 'infrastructure';
       }
       const peer = this.topology.peer(received.sourceRid);
@@ -997,6 +944,14 @@ export class RawServiceMeshRuntime {
     }
   }
 
+  expireOperations(nowMs: number, turnDeadlineMs: number): number {
+    return this.operations.expire(nowMs, turnDeadlineMs);
+  }
+
+  get pendingOperationCount(): number {
+    return this.operations.size;
+  }
+
   async tickLiveness(nowMs = performance.now()): Promise<ServiceLivenessTick> {
     const result = this.liveness.tick(nowMs);
     this.requireStarted();
@@ -1011,130 +966,50 @@ export class RawServiceMeshRuntime {
     for (const nodeRoutingId of result.timedOutNodes) {
       const peer = this.topology.peer(nodeRoutingId);
       if (peer === undefined) continue;
-      // Liveness timeout is a semantic peer removal.  Route topology,
-      // physical candidate state, and auto-connect intent must be retired by
-      // the same owner so a failed endpoint cannot be selected again.
-      this.removeConnectionCandidate(nodeRoutingId, peer.connectionId);
+      // Liveness timeout is a semantic peer removal of the admitted route.
       this.removePeer(peer);
     }
     return result;
   }
 
-  async drainMonitorEvents(nowMs = performance.now()): Promise<number> {
-    this.pullMonitorEvents();
-    let handled = 0;
-    // Detach the current batch so monitor pulls that run while an event is
-    // being handled append to the next batch without copying or reindexing it.
-    const events = this.monitorEvents;
-    this.monitorEvents = this.monitorDrainBuffer;
-    this.monitorDrainBuffer = events;
-    this.monitorEvents.length = 0;
-    for (const event of events) {
-      handled++;
-      const nodeRoutingId = event.routingId ?? this.expectedPeerRoutingId(event.remoteAddress);
-      if (event.event === MONITOR_CONNECTION_READY && isConnectionReadyEdge(event)) {
-        if (nodeRoutingId === undefined) {
-          const candidate = this.createUnresolvedConnectionCandidate(event);
-          const alreadyQueued = this.unresolvedConnectionCandidates.some(
-            (value) => value.connectionId === candidate.connectionId
-          );
-          if (
-            !alreadyQueued &&
-            this.unresolvedConnectionCandidates.length < MAX_UNRESOLVED_CONNECTION_CANDIDATES
-          ) {
-            this.unresolvedConnectionCandidates.push(candidate);
-          }
-          continue;
-        }
-        if (!this.acceptsExpectedMonitorEndpoint(nodeRoutingId, event)) {
-          continue;
-        }
-        const candidate = this.createConnectionCandidate(nodeRoutingId, event);
-        const existingPeer = this.topology.peer(nodeRoutingId);
-        if (existingPeer !== undefined && existingPeer.connectionId === candidate.connectionId) {
-          this.monitorConnectionStates.set(nodeRoutingId, candidate.connectionId);
-          continue;
-        }
-        if (existingPeer !== undefined) {
-          if (this.liveness.isReady(nodeRoutingId, existingPeer.connectionId)) {
-            const existingCandidate = this.connectionCandidates
-              .get(nodeRoutingId)
-              ?.get(existingPeer.connectionId);
-            if (this.isDiscoveredLifecycleReplacement(existingPeer, nodeRoutingId)) {
-              // A current discovery descriptor with the same RID but a
-              // different lifecycle token denotes a replacement process.
-              // Keep its physical pair provisional until its Hello passes
-              // the descriptor fence; the old ready peer remains semantic
-              // current until then.
-              let provisionalCandidates = this.connectionCandidates.get(nodeRoutingId);
-              if (provisionalCandidates === undefined) {
-                provisionalCandidates = new Map();
-                this.connectionCandidates.set(nodeRoutingId, provisionalCandidates);
-              }
-              provisionalCandidates.set(candidate.connectionId, candidate);
-              await this.announcePeer(nodeRoutingId);
-              continue;
-            }
-            if (existingCandidate?.connectionId === candidate.connectionId) {
-              this.removeConnectionCandidate(nodeRoutingId, candidate.connectionId);
-              this.monitorConnectionStates.set(nodeRoutingId, existingPeer.connectionId);
-              continue;
-            }
-            // A non-replacement ready route is the current semantic owner.
-            // A second physical candidate may be admitted only after the
-            // current lease expires; this also prevents a late old-process
-            // reconnect from replacing the ready replacement by arrival order.
-            this.removeConnectionCandidate(nodeRoutingId, candidate.connectionId);
-            continue;
-          }
-          // Keep the physical candidate until the wire descriptor decides
-          // whether it is the current logical peer. READY events can race
-          // with DISCONNECTED events during reconnect; rejecting the READY
-          // here can terminate the replacement before admission evaluates its
-          // lifecycle generation.
-          let provisionalCandidates = this.connectionCandidates.get(nodeRoutingId);
-          if (provisionalCandidates === undefined) {
-            provisionalCandidates = new Map();
-            this.connectionCandidates.set(nodeRoutingId, provisionalCandidates);
-          }
-          provisionalCandidates.set(candidate.connectionId, candidate);
-          this.connectionIds.set(nodeRoutingId, candidate.connectionId);
-          await this.announcePeer(nodeRoutingId);
-          continue;
-        }
-        let candidates = this.connectionCandidates.get(nodeRoutingId);
-        if (candidates === undefined) {
-          candidates = new Map();
-          this.connectionCandidates.set(nodeRoutingId, candidates);
-        }
-        candidates.set(candidate.connectionId, candidate);
-        // Before wire admission the monitor candidate is the only physical
-        // route evidence available to the admission message.
-        this.connectionIds.set(nodeRoutingId, candidate.connectionId);
-        await this.announcePeer(nodeRoutingId);
-      } else if (event.event === MONITOR_DISCONNECTED && nodeRoutingId !== undefined) {
-        const peer = this.topology.peer(nodeRoutingId);
-        const disconnectedId = monitorConnectionId(event, nodeRoutingId);
-        this.removeConnectionCandidate(nodeRoutingId, disconnectedId);
-        if (peer !== undefined && peer.connectionId === disconnectedId) {
-          this.removePeer(peer);
-        }
-      } else if (event.event === MONITOR_DISCONNECTED) {
-        const disconnectedId = monitorConnectionId(event);
-        const index = this.unresolvedConnectionCandidates.findIndex(
-          (candidate) => candidate.connectionId === disconnectedId
-        );
-        if (index >= 0) this.unresolvedConnectionCandidates.splice(index, 1);
+  /**
+   * The socket's one route observer (Core ROUTER §10.1). It replaces the
+   * observation with Core's selected-route snapshot, ends the admission of
+   * every RID whose observed route disappeared or was replaced, and starts the
+   * handshake of every newly selected route. Returns the number of changes.
+   */
+  async observeSelectedRoutes(): Promise<number> {
+    const router = this.router;
+    if (router === undefined || this.closed) return 0;
+    const observed = new Map<string, bigint>();
+    for (const route of router.routesSnapshot()) {
+      observed.set(route.routingId, route.routeGeneration);
+    }
+    let changes = 0;
+    for (const [nodeRoutingId, generation] of this.selectedRoutes) {
+      if (observed.get(nodeRoutingId) === generation) continue;
+      changes++;
+      const expected = this.expectedPeers.get(nodeRoutingId);
+      if (expected !== undefined) delete expected.helloSubmittedGeneration;
+      const peer = this.topology.peer(nodeRoutingId);
+      if (peer !== undefined && peer.connectionId === routeConnectionId(generation)) {
+        this.removePeer(peer);
       }
     }
-    this.monitorDrainBuffer.length = 0;
-    void nowMs;
-    return handled;
+    const selected: string[] = [];
+    for (const [nodeRoutingId, generation] of observed) {
+      if (this.selectedRoutes.get(nodeRoutingId) === generation) continue;
+      if (!this.selectedRoutes.has(nodeRoutingId)) changes++;
+      selected.push(nodeRoutingId);
+    }
+    this.selectedRoutes = observed;
+    // A new selected route admits only through a new handshake.
+    for (const nodeRoutingId of selected) await this.announcePeer(nodeRoutingId);
+    return changes;
   }
 
   close(): void {
     if (this.closed) return;
-    this.closed = true;
     this.applicationJobStop.abort(
       new Error('Raw service runtime application job admission stopped.')
     );
@@ -1145,12 +1020,11 @@ export class RawServiceMeshRuntime {
     if (router !== undefined) {
       this.applicationJobQueue.unregisterReceiveFlowTarget?.(router);
     }
-    this.monitor?.close();
-    this.monitor = undefined;
     const host = this.host;
+    if (host !== undefined) host.close();
     this.router = undefined;
     this.host = undefined;
-    if (host !== undefined) host.close();
+    this.closed = true;
   }
 
   private requestToTarget(
@@ -1181,14 +1055,11 @@ export class RawServiceMeshRuntime {
         for (;;) {
           const alternate = this.topology.selectChannel(channelName, (peer) => {
             const candidate = peer.descriptor.nodeRoutingId;
-            return !excludedTargets.has(candidate) && this.isLocalOrReadyPeer(candidate);
+            return !excludedTargets.has(candidate) && this.isPeerRouteReady(candidate);
           });
           if (alternate === undefined) break;
           selectedTargetNodeRoutingId = alternate.descriptor.nodeRoutingId;
-          if (
-            selectedTargetNodeRoutingId === this.descriptor.nodeRoutingId ||
-            this.isPeerRouteReady(selectedTargetNodeRoutingId)
-          ) {
+          if (this.isPeerRouteReady(selectedTargetNodeRoutingId)) {
             break;
           }
           excludedTargets.add(selectedTargetNodeRoutingId);
@@ -1212,10 +1083,7 @@ export class RawServiceMeshRuntime {
             return;
           }
           const accepted = this.mailbox.tryEnqueue({
-            owner:
-              channelName === undefined
-                ? `node:${this.descriptor.nodeRoutingId}`
-                : `channel:${channelName}`,
+            owner: `node:${this.descriptor.nodeRoutingId}`,
             domain: 'application',
             parts,
             sourceRoutingId: this.descriptor.nodeRoutingId,
@@ -1241,17 +1109,13 @@ export class RawServiceMeshRuntime {
       })().catch((error) => this.operations.fail(pending.id, error));
       return pending;
     }
-    if (!this.isPeerRouteReady(selectedTargetNodeRoutingId)) {
-      // Preserve Core's distinct target-not-found result for an RID the
-      // topology has never observed. A known peer without a usable route is
-      // a Framework NotConnected result; an unknown RID is completed locally
-      // as RequestTargetNotFound without submitting an application frame.
-      const knownTarget =
-        this.topology.peer(selectedTargetNodeRoutingId) !== undefined ||
-        this.topology.knownDescriptor(selectedTargetNodeRoutingId) !== undefined;
+    if (this.topology.peer(selectedTargetNodeRoutingId) === 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.operations.complete(pending.id, {
-        terminalResult: knownTarget ? RequestResult.NotConnected : RequestResult.NotFound,
-        failureCode: knownTarget ? 0 : REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
+        terminalResult: RequestResult.NotFound,
+        failureCode: REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
       });
       return pending;
     }
@@ -1320,7 +1184,7 @@ export class RawServiceMeshRuntime {
 
   private admitPeer(
     descriptor: ServiceNodeDescriptor,
-    connection: PhysicalConnectionCandidate,
+    connectionId: string,
     nowMs: number,
     expected?: {
       readonly endpoint?: string;
@@ -1340,232 +1204,16 @@ export class RawServiceMeshRuntime {
         `RouteMesh peer '${descriptor.nodeRoutingId}' descriptor revision is stale or conflicting.`
       );
     }
-    const result = this.topology.admit(
-      descriptor,
-      connection.connectionId,
-      expected,
-      connection.discriminator
-    );
+    const result = this.topology.admit(descriptor, connectionId, expected);
     if (result === 'admitted') {
-      this.connectionIds.set(descriptor.nodeRoutingId, connection.connectionId);
-      this.liveness.admit(descriptor.nodeRoutingId, connection.connectionId, nowMs);
-      this.liveness.requestProbe(descriptor.nodeRoutingId, connection.connectionId, nowMs);
-      this.monitorConnectionStates.set(descriptor.nodeRoutingId, connection.connectionId);
-      if (previous !== undefined && previous.connectionId !== connection.connectionId) {
-        const previousCandidate = this.connectionCandidates
-          .get(descriptor.nodeRoutingId)
-          ?.get(previous.connectionId);
-        if (previousCandidate !== undefined) {
-          this.removeConnectionCandidate(descriptor.nodeRoutingId, previousCandidate.connectionId);
-        }
-      }
+      this.liveness.admit(descriptor.nodeRoutingId, connectionId, nowMs);
+      this.liveness.requestProbe(descriptor.nodeRoutingId, connectionId, nowMs);
     } else if (result === 'notRequired' && previous !== undefined) {
       this.liveness.disconnect(descriptor.nodeRoutingId, previous.connectionId);
-    } else if (previous !== undefined) {
-      this.connectionIds.set(descriptor.nodeRoutingId, previous.connectionId);
-      if (connection.connectionId !== previous.connectionId) {
-        this.removeConnectionCandidate(descriptor.nodeRoutingId, connection.connectionId);
-      }
     }
     return result;
   }
 
-  private currentConnectionCandidate(
-    nodeRoutingId: string,
-    advertisedEndpoint: string
-  ): PhysicalConnectionCandidate {
-    let connectionId = this.connectionIds.get(nodeRoutingId);
-    let candidate =
-      connectionId === undefined
-        ? undefined
-        : this.connectionCandidates.get(nodeRoutingId)?.get(connectionId);
-    if (candidate === undefined) {
-      candidate = this.promoteUnresolvedConnectionCandidate(nodeRoutingId, advertisedEndpoint);
-      connectionId = candidate?.connectionId;
-    }
-    if (candidate === undefined) {
-      const localRid = this.topology.localDescriptor().nodeRoutingId;
-      const endpointOnly = this.endpointOnlyPeers.has(advertisedEndpoint);
-      const direction: PhysicalConnectionDirection = this.expectedPeers.has(nodeRoutingId)
-        ? 'outbound'
-        : endpointOnly
-          ? localRid.localeCompare(nodeRoutingId) <= 0
-            ? 'outbound'
-            : 'inbound'
-          : 'inbound';
-      const initiator =
-        endpointOnly && localRid.localeCompare(nodeRoutingId) > 0
-          ? nodeRoutingId
-          : direction === 'outbound'
-            ? localRid
-            : nodeRoutingId;
-      connectionId = `unmonitored:${direction}:${randomUUID()}`;
-      candidate = {
-        connectionId,
-        direction,
-        discriminator: `initiator:${initiator}`,
-        localAddress: '',
-        remoteAddress: advertisedEndpoint
-      };
-      let candidates = this.connectionCandidates.get(nodeRoutingId);
-      if (candidates === undefined) {
-        candidates = new Map();
-        this.connectionCandidates.set(nodeRoutingId, candidates);
-      }
-      candidates.set(connectionId, candidate);
-      this.connectionIds.set(nodeRoutingId, connectionId);
-    }
-    return candidate;
-  }
-
-  private createConnectionCandidate(
-    nodeRoutingId: string,
-    event: ZLinkRawMonitorRecord
-  ): PhysicalConnectionCandidate {
-    const local = this.topology.localDescriptor();
-    const expected = this.expectedPeers.get(nodeRoutingId);
-    const direction: PhysicalConnectionDirection =
-      event.localAddress === local.advertisedEndpoint
-        ? 'inbound'
-        : expected?.endpoint === event.remoteAddress
-          ? 'outbound'
-          : this.endpointOnlyPeers.has(event.remoteAddress)
-            ? 'outbound'
-            : 'unknown';
-    const initiator =
-      direction === 'outbound'
-        ? local.nodeRoutingId
-        : direction === 'inbound'
-          ? nodeRoutingId
-          : undefined;
-    return {
-      connectionId: monitorConnectionId(event, nodeRoutingId),
-      direction,
-      discriminator:
-        initiator === undefined
-          ? `unknown:${monitorConnectionId(event, nodeRoutingId)}`
-          : `initiator:${initiator}`,
-      localAddress: event.localAddress,
-      remoteAddress: event.remoteAddress
-    };
-  }
-
-  private createUnresolvedConnectionCandidate(
-    event: ZLinkRawMonitorRecord
-  ): PhysicalConnectionCandidate {
-    const connectionId = monitorConnectionId(event);
-    const local = this.topology.localDescriptor();
-    const direction: PhysicalConnectionDirection =
-      this.endpointOnlyPeers.has(event.remoteAddress) ||
-      this.expectedPeerRoutingId(event.remoteAddress) !== undefined
-        ? 'outbound'
-        : event.localAddress === local.advertisedEndpoint
-          ? 'inbound'
-          : 'unknown';
-    return {
-      connectionId,
-      direction,
-      discriminator: `unresolved:${connectionId}`,
-      localAddress: event.localAddress,
-      remoteAddress: event.remoteAddress
-    };
-  }
-
-  private promoteUnresolvedConnectionCandidate(
-    nodeRoutingId: string,
-    advertisedEndpoint: string
-  ): PhysicalConnectionCandidate | undefined {
-    const relevant = this.unresolvedConnectionCandidates
-      .map((candidate, index) => ({ candidate, index }))
-      .filter(
-        ({ candidate }) =>
-          candidate.remoteAddress === advertisedEndpoint || candidate.direction === 'inbound'
-      );
-    if (relevant.length === 0) return undefined;
-    const directions = new Set(relevant.map((value) => value.candidate.direction));
-    const localRid = this.topology.localDescriptor().nodeRoutingId;
-    const preferredDirection: PhysicalConnectionDirection =
-      directions.has('inbound') && directions.has('outbound')
-        ? localRid.localeCompare(nodeRoutingId) <= 0
-          ? 'outbound'
-          : 'inbound'
-        : relevant.at(-1)!.candidate.direction;
-    const selected =
-      [...relevant].reverse().find((value) => value.candidate.direction === preferredDirection) ??
-      relevant.at(-1)!;
-    this.unresolvedConnectionCandidates.splice(selected.index, 1);
-    const initiator =
-      selected.candidate.direction === 'outbound'
-        ? localRid
-        : selected.candidate.direction === 'inbound'
-          ? nodeRoutingId
-          : undefined;
-    const candidate: PhysicalConnectionCandidate = {
-      ...selected.candidate,
-      discriminator:
-        initiator === undefined
-          ? `unknown:${selected.candidate.connectionId}`
-          : `initiator:${initiator}`
-    };
-    let candidates = this.connectionCandidates.get(nodeRoutingId);
-    if (candidates === undefined) {
-      candidates = new Map();
-      this.connectionCandidates.set(nodeRoutingId, candidates);
-    }
-    candidates.set(candidate.connectionId, candidate);
-    this.connectionIds.set(nodeRoutingId, candidate.connectionId);
-    return candidate;
-  }
-
-  private removeConnectionCandidate(nodeRoutingId: string, connectionId: string): void {
-    const candidates = this.connectionCandidates.get(nodeRoutingId);
-    candidates?.delete(connectionId);
-    if (candidates?.size === 0) this.connectionCandidates.delete(nodeRoutingId);
-    if (this.connectionIds.get(nodeRoutingId) === connectionId) {
-      this.connectionIds.delete(nodeRoutingId);
-    }
-  }
-
-  private isDiscoveredLifecycleReplacement(
-    admitted: AdmittedServicePeer,
-    nodeRoutingId: string
-  ): boolean {
-    const expected = this.expectedPeers.get(nodeRoutingId);
-    // A same-RID replacement is permitted only from a complete discovery
-    // fence. Manual/endpoint-only intent has no authority to replace a ready
-    // peer, and lifecycle generations are opaque equality tokens.
-    return (
-      expected?.endpoint !== undefined &&
-      expected.securityIdentity !== undefined &&
-      expected.lifecycleGeneration !== undefined &&
-      admitted.descriptor.lifecycleGeneration !== expected.lifecycleGeneration
-    );
-  }
-
-  private expectedPeerRoutingId(endpoint: string): string | undefined {
-    for (const [nodeRoutingId, expected] of this.expectedPeers) {
-      if (expected.endpoint === endpoint) return nodeRoutingId;
-    }
-    return undefined;
-  }
-
-  private acceptsExpectedMonitorEndpoint(
-    nodeRoutingId: string,
-    event: Pick<ZLinkRawMonitorRecord, 'remoteAddress' | 'routingId'>
-  ): boolean {
-    // A monitor address is the physical socket address, which may be an
-    // ephemeral port. Once Core has resolved the peer routing ID, that ID is
-    // the semantic identity; comparing the physical address with the
-    // discovery advertised endpoint would reject valid READY events.
-    if (event.routingId === nodeRoutingId) return true;
-    const expected = this.expectedPeers.get(nodeRoutingId);
-    return (
-      expected === undefined ||
-      expected.endpoint === undefined ||
-      expected.endpoint === event.remoteAddress
-    );
-  }
-
   private retireNotRequiredExpectedPeer(nodeRoutingId: string, advertisedEndpoint?: string): void {
     const expected = this.expectedPeers.get(nodeRoutingId);
     const endpoint =
@@ -1597,9 +1245,6 @@ export class RawServiceMeshRuntime {
   }
 
   private removePeer(peer: AdmittedServicePeer): void {
-    if (this.monitorConnectionStates.get(peer.descriptor.nodeRoutingId) === peer.connectionId) {
-      this.monitorConnectionStates.set(peer.descriptor.nodeRoutingId, null);
-    }
     this.topology.disconnect(peer.descriptor.nodeRoutingId, peer.connectionId);
     this.liveness.disconnect(peer.descriptor.nodeRoutingId, peer.connectionId);
     this.onPeerDisconnected?.(
@@ -1609,25 +1254,6 @@ export class RawServiceMeshRuntime {
     );
   }
 
-  private observeMonitorEvent(event: ZLinkRawMonitorRecord): void {
-    const nodeRoutingId = event.routingId ?? this.expectedPeerRoutingId(event.remoteAddress);
-    if (nodeRoutingId === undefined) return;
-    const connectionId = monitorConnectionId(event, nodeRoutingId);
-    if (event.event === MONITOR_CONNECTION_READY && isConnectionReadyEdge(event)) {
-      if (!this.acceptsExpectedMonitorEndpoint(nodeRoutingId, event)) return;
-      // The event is queued for admission. Updating monitor state here would
-      // allow a late stale READY to overwrite the admitted replacement.
-      return;
-    }
-    if (
-      event.event === MONITOR_DISCONNECTED &&
-      this.monitorConnectionStates.get(nodeRoutingId) === connectionId &&
-      this.topology.peer(nodeRoutingId)?.connectionId === connectionId
-    ) {
-      this.monitorConnectionStates.set(nodeRoutingId, null);
-    }
-  }
-
   private requireStarted(): ZLinkRawRouterPort {
     if (this.router === undefined) throw new Error('Raw service runtime is not started.');
     return this.router;
@@ -1677,38 +1303,15 @@ function isAlreadyDisconnectedError(error: unknown): boolean {
   if (typeof error !== 'object' || error === null || !('nativeErrno' in error)) {
     return false;
   }
-  return (error as { readonly nativeErrno?: unknown }).nativeErrno === 2;
-}
-
-function monitorConnectionId(
-  event: ZLinkRawMonitorRecord,
-  resolvedNodeRoutingId = event.routingId ?? ''
-): string {
-  if (event.connectionId !== undefined && event.connectionId !== 0n) {
-    return JSON.stringify([resolvedNodeRoutingId, 'connection', event.connectionId.toString()]);
-  }
-  return JSON.stringify([
-    // Monitor `value` is event-specific: CONNECTION_READY reports the
-    // socket's ready count and DISCONNECTED reports its reason. It is not a
-    // connection identity. The public monitor record has no native
-    // connection id, so use the stable routing and endpoint tuple instead.
-    resolvedNodeRoutingId,
-    event.localAddress,
-    event.remoteAddress
-  ]);
+  return (error as { readonly nativeErrno?: unknown }).nativeErrno === nativeErrnoValues.ENOENT;
 }
 
-function sameMonitorConnection(left: ZLinkRawMonitorRecord, right: ZLinkRawMonitorRecord): boolean {
-  return (
-    monitorConnectionId(left) === monitorConnectionId(right) &&
-    left.remoteAddress === right.remoteAddress
-  );
-}
-
-function isConnectionReadyEdge(event: ZLinkRawMonitorRecord): boolean {
-  return event.flags === undefined
-    ? event.value > 0n
-    : (event.flags & MONITOR_CONNECTION_READY_EDGE) !== 0;
+/**
+ * An admission belongs to one Core selected route. Its connection identity is
+ * that route's generation, an opaque token compared only for equality.
+ */
+function routeConnectionId(routeGeneration: bigint): string {
+  return `route:${routeGeneration.toString()}`;
 }
 
 function describeInvalidAdmissionDescriptor(
@@ -1778,17 +1381,13 @@ function immutableDescriptorMismatch(
   return undefined;
 }
 
-function admissionReason(result: PeerAdmissionResult): number {
+function admissionReason(result: Exclude<PeerAdmissionResult, 'admitted' | 'notRequired'>): number {
   switch (result) {
     case 'meshMismatch':
-      return 2;
+      return enumWireRejectReason('topologyMismatch');
     case 'staleDescriptor':
-      return 7;
+      return enumWireRejectReason('descriptorRevisionStale');
     case 'invalidDescriptor':
-      return 11;
-    case 'notRequired':
-      return 4;
-    case 'admitted':
-      return 1;
+      return enumWireRejectReason('invalidDescriptor');
   }
 }