@zlink-systems/framework 0.25.0 → 0.27.0

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

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RawServiceMeshRuntime = void 0;
-const node_crypto_1 = require("node:crypto");
-const runtime_values_1 = require("../backend/runtime-values");
+exports.RawServiceMeshRuntime = exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS = void 0;
+const node_os_1 = require("node:os");
 const application_ingress_record_owner_1 = require("../application-jobs/application-ingress-record-owner");
+const runtime_values_1 = require("../backend/runtime-values");
+const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
 const operation_registry_1 = require("./operation-registry");
 const service_liveness_registry_1 = require("./service-liveness-registry");
 const service_mailbox_1 = require("./service-mailbox");
 const service_topology_registry_1 = require("./service-topology-registry");
-const service_wire_m6a_codec_1 = require("./service-wire-m6a-codec");
 const service_wire_codec_1 = require("./service-wire-codec");
 const service_wire_constants_generated_1 = require("./service-wire-constants.generated");
-const MONITOR_DISCONNECTED = 0x0200;
-const MONITOR_CONNECTION_READY = 0x1000;
-const MONITOR_CONNECTION_READY_EDGE = 1;
+const service_wire_m6a_codec_1 = require("./service-wire-m6a-codec");
+const nativeErrnoValues = node_os_1.constants.errno;
 // Framework error code 13 (RequestTargetNotFound) is encoded as 14 on a
 // RequestResult.NotFound reply. Boundary transport results keep failureCode 0.
-const REQUEST_TARGET_NOT_FOUND_FAILURE_CODE = 14;
+const RAW_MESH_RECEIVE_RECORD_BUDGET = 64;
+const RAW_MESH_RECEIVE_BYTE_BUDGET = 4 * 1024 * 1024;
+exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS = 2;
+const REQUEST_TARGET_NOT_FOUND_FAILURE_CODE = service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestTargetNotFound;
 const livenessCodec = (0, service_wire_codec_1.createServiceWireCodec)({
-    magic: [0x5a, 0x4d],
-    major: 1,
+    magic: service_wire_constants_generated_1.SERVICE_WIRE_MAGIC,
+    major: service_wire_constants_generated_1.SERVICE_WIRE_MAJOR,
     commands: service_wire_m6a_codec_1.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.
@@ -32,21 +32,15 @@ class RawServiceMeshRuntime {
     topology;
     mailbox;
     liveness;
-    operations = new operation_registry_1.OperationRegistry();
+    operations;
     expectedPeers = new Map();
     endpointOnlyPeers = new Set();
     peerConnectionIntentRemoved = new Set();
-    connectionCandidates = new Map();
-    unresolvedConnectionCandidates = [];
-    connectionIds = new Map();
     /**
-     * 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.
      */
-    monitorConnectionStates = new Map();
-    monitorEvents = [];
-    monitorDrainBuffer = [];
+    selectedRoutes = new Map();
     bindingPort;
     applicationJobQueue;
     peerAdmissionSealed;
@@ -59,11 +53,11 @@ class RawServiceMeshRuntime {
     descriptor;
     host;
     router;
-    monitor;
     nextCorrelation = 1n;
     serviceIngress;
     closed = false;
     constructor(options) {
+        this.operations = new operation_registry_1.OperationRegistry(undefined, options.onPendingOperationsChanged);
         this.descriptor = options.descriptor;
         this.topology = new service_topology_registry_1.ServiceTopologyRegistry(options.descriptor);
         this.mailbox = new service_mailbox_1.ServiceMailbox(options.onMailboxReady);
@@ -102,8 +96,6 @@ class RawServiceMeshRuntime {
             };
             this.topology.publishLocal(next);
             this.descriptor = next;
-            this.monitor = router.monitor();
-            this.pullMonitorEvents();
             this.host = host;
             this.router = router;
         }
@@ -117,32 +109,32 @@ class RawServiceMeshRuntime {
     }
     connectPeer(endpoint, expected) {
         this.requireStarted().connectToRoutingId(expected.nodeRoutingId, endpoint);
-        this.expectedPeers.set(expected.nodeRoutingId, {
+        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(endpoint, nodeRoutingId, securityIdentity, lifecycleGeneration) {
         this.requireStarted().connectToRoutingId(nodeRoutingId, endpoint);
-        this.expectedPeers.set(nodeRoutingId, {
+        this.expectedPeers.set(nodeRoutingId, Object.assign(this.expectedPeers.get(nodeRoutingId) ?? {}, {
             meshName: this.topology.localDescriptor().meshName,
             nodeRoutingId,
             endpoint,
             securityIdentity,
             lifecycleGeneration
-        });
+        }));
     }
     expectPeerByRoutingId(endpoint, nodeRoutingId, securityIdentity, lifecycleGeneration) {
-        this.expectedPeers.set(nodeRoutingId, {
+        this.expectedPeers.set(nodeRoutingId, Object.assign(this.expectedPeers.get(nodeRoutingId) ?? {}, {
             meshName: this.topology.localDescriptor().meshName,
             nodeRoutingId,
             endpoint,
             securityIdentity,
             lifecycleGeneration
-        });
+        }));
     }
     connectPeerEndpoint(endpoint) {
         this.requireStarted().connect(endpoint);
@@ -230,31 +222,34 @@ class RawServiceMeshRuntime {
             listener(nodeRoutingId);
     }
     async announcePeer(nodeRoutingId) {
-        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, [
             (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.topology.localDescriptor())
         ]);
+        if (accepted &&
+            this.expectedPeers.get(nodeRoutingId) === expected &&
+            this.selectedRoutes.get(nodeRoutingId) === generation)
+            expected.helloSubmittedGeneration = generation;
+        return accepted;
     }
     isPeerRouteReady(nodeRoutingId, lifecycleGeneration) {
+        // Admission is bound to the observed selected route: the route observer
+        // removes the peer when that route ends or is replaced.
         const peer = this.topology.peer(nodeRoutingId);
-        const monitorConnection = this.monitorConnectionStates.get(nodeRoutingId);
-        const applicationRouteReady = monitorConnection === undefined || monitorConnection === peer?.connectionId;
-        const ready = peer !== undefined &&
+        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() {
         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))
@@ -288,7 +283,6 @@ class RawServiceMeshRuntime {
         for (const peer of this.topology.peers()) {
             await this.send(peer.descriptor.nodeRoutingId, [update]);
         }
-        await this.announceExpectedPeers();
     }
     replaceDiscoveredNotRequired(descriptors) {
         this.topology.replaceDiscoveredNotRequired(descriptors);
@@ -308,25 +302,6 @@ class RawServiceMeshRuntime {
             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: [(0, service_wire_m6a_codec_1.encodeChannelSendHeader)(channelName), applicationFrame],
-                    sourceRoutingId: this.descriptor.nodeRoutingId,
-                    applicationJob
-                });
-                if (!accepted)
-                    applicationJob.close();
-                return accepted ? runtime_values_1.SubmitResult.Ok : runtime_values_1.SubmitResult.NotAdmitted;
-            }
-            finally {
-                applicationJobOwner.close();
-            }
-        }
         return (await this.send(selected.descriptor.nodeRoutingId, [
             (0, service_wire_m6a_codec_1.encodeChannelSendHeader)(channelName),
             applicationFrame
@@ -347,7 +322,7 @@ class RawServiceMeshRuntime {
         return this.requestToTarget(selection.peer.descriptor.nodeRoutingId, payload, timeoutMs, channelName);
     }
     selectChannelTarget(channelName) {
-        const selected = this.topology.selectChannel(channelName, (peer) => this.isLocalOrReadyPeer(peer.descriptor.nodeRoutingId));
+        const selected = this.topology.selectChannel(channelName, (peer) => this.isPeerRouteReady(peer.descriptor.nodeRoutingId));
         if (selected !== undefined)
             return { kind: 'selected', peer: selected };
         return this.topology.hasKnownChannelTarget(channelName)
@@ -365,9 +340,6 @@ class RawServiceMeshRuntime {
                 }
             };
     }
-    isLocalOrReadyPeer(nodeRoutingId) {
-        return nodeRoutingId === this.descriptor.nodeRoutingId || this.isPeerRouteReady(nodeRoutingId);
-    }
     setServiceIngress(handler) {
         if (this.serviceIngress !== undefined && this.serviceIngress !== handler) {
             throw new Error('Raw service ingress is already registered.');
@@ -410,22 +382,22 @@ class RawServiceMeshRuntime {
         ]);
     }
     async pumpOne(nowMs = performance.now(), observe) {
-        this.pullMonitorEvents();
         return this.receiveOne(nowMs, observe);
     }
     setReadableHandler(handler) {
         this.requireStarted().setReadableHandler(handler);
     }
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
-    async pumpBatch(receiveReady = true) {
-        await this.drainMonitorEvents();
+    async pumpBatch(receiveReady = true, routeReady = false) {
+        if (routeReady)
+            await this.observeSelectedRoutes();
         const startedAtMs = performance.now();
         let messages = 0;
         let bytes = 0;
         const observe = (_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;
@@ -434,7 +406,8 @@ 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)
+            if (bytes >= RAW_MESH_RECEIVE_BYTE_BUDGET ||
+                performance.now() - startedAtMs >= exports.RAW_MESH_RECEIVE_TIME_BUDGET_MS)
                 break;
         }
         if (!this.closed) {
@@ -483,22 +456,6 @@ class RawServiceMeshRuntime {
             applicationJobOwner.close();
         }
     }
-    pullMonitorEvents() {
-        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);
-            }
-        });
-    }
     reportProtocolError(received) {
         const request = received.requestSeq !== undefined;
         const replied = request && this.replyGenericProtocolError(received);
@@ -561,11 +518,12 @@ class RawServiceMeshRuntime {
                 if (expected !== undefined &&
                     (expected.meshName !== descriptor.meshName ||
                         expected.nodeRoutingId !== descriptor.nodeRoutingId)) {
-                    await this.send(received.sourceRid, [(0, service_wire_m6a_codec_1.encodeReject)(3)]);
+                    await this.send(received.sourceRid, [
+                        (0, service_wire_m6a_codec_1.encodeReject)((0, service_wire_codec_generated_1.enumWireRejectReason)('identityMismatch'))
+                    ]);
                     return 'infrastructure';
                 }
-                const connection = this.currentConnectionCandidate(received.sourceRid, descriptor.advertisedEndpoint);
-                const result = this.admitPeer(descriptor, connection, nowMs, expected);
+                const result = this.admitPeer(descriptor, routeConnectionId(received.routeGeneration), nowMs, expected);
                 if (result !== 'admitted' && result !== 'notRequired') {
                     const detail = result === 'invalidDescriptor'
                         ? describeInvalidAdmissionDescriptor(descriptor, expected, this.topology.peer(descriptor.nodeRoutingId)?.descriptor)
@@ -593,25 +551,7 @@ class RawServiceMeshRuntime {
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.reject) {
                 if (received.parts.length !== 1)
                     return 'protocolError';
-                const reason = (0, service_wire_m6a_codec_1.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);
-                }
+                (0, service_wire_m6a_codec_1.decodeReject)(received.parts[0]);
                 return 'infrastructure';
             }
             const peer = this.topology.peer(received.sourceRid);
@@ -737,6 +677,12 @@ class RawServiceMeshRuntime {
             throw error;
         }
     }
+    expireOperations(nowMs, turnDeadlineMs) {
+        return this.operations.expire(nowMs, turnDeadlineMs);
+    }
+    get pendingOperationCount() {
+        return this.operations.size;
+    }
     async tickLiveness(nowMs = performance.now()) {
         const result = this.liveness.tick(nowMs);
         this.requireStarted();
@@ -752,126 +698,55 @@ class RawServiceMeshRuntime {
             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()) {
-        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() {
+        const router = this.router;
+        if (router === undefined || this.closed)
+            return 0;
+        const observed = new Map();
+        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 = [];
+        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() {
         if (this.closed)
             return;
-        this.closed = true;
         this.applicationJobStop.abort(new Error('Raw service runtime application job admission stopped.'));
         this.mailbox.close();
         this.operations.close('Raw service runtime closed.');
@@ -880,13 +755,12 @@ class RawServiceMeshRuntime {
         if (router !== undefined) {
             this.applicationJobQueue.unregisterReceiveFlowTarget?.(router);
         }
-        this.monitor?.close();
-        this.monitor = undefined;
         const host = this.host;
-        this.router = undefined;
-        this.host = undefined;
         if (host !== undefined)
             host.close();
+        this.router = undefined;
+        this.host = undefined;
+        this.closed = true;
     }
     requestToTarget(targetNodeRoutingId, payload, timeoutMs, channelName) {
         const correlation = this.nextCorrelation++;
@@ -908,13 +782,12 @@ 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);
@@ -936,9 +809,7 @@ 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,
@@ -964,16 +835,13 @@ 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 ? runtime_values_1.RequestResult.NotConnected : runtime_values_1.RequestResult.NotFound,
-                failureCode: knownTarget ? 0 : REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
+                terminalResult: runtime_values_1.RequestResult.NotFound,
+                failureCode: REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
             });
             return pending;
         }
@@ -1031,7 +899,7 @@ class RawServiceMeshRuntime {
     applicationPayload(payload) {
         return Buffer.isBuffer(payload) ? (0, service_wire_m6a_codec_1.decodeApplicationPayloadView)(payload) : payload;
     }
-    admitPeer(descriptor, connection, nowMs, expected) {
+    admitPeer(descriptor, connectionId, nowMs, expected) {
         const previous = this.topology.peer(descriptor.nodeRoutingId);
         if (previous !== undefined &&
             previous.descriptor.lifecycleGeneration === descriptor.lifecycleGeneration &&
@@ -1040,190 +908,16 @@ class RawServiceMeshRuntime {
                     !(0, service_topology_registry_1.sameServiceNodeDescriptor)(previous.descriptor, descriptor)))) {
             throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`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;
     }
-    currentConnectionCandidate(nodeRoutingId, advertisedEndpoint) {
-        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 = 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}:${(0, node_crypto_1.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;
-    }
-    createConnectionCandidate(nodeRoutingId, event) {
-        const local = this.topology.localDescriptor();
-        const expected = this.expectedPeers.get(nodeRoutingId);
-        const direction = 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
-        };
-    }
-    createUnresolvedConnectionCandidate(event) {
-        const connectionId = monitorConnectionId(event);
-        const local = this.topology.localDescriptor();
-        const direction = 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
-        };
-    }
-    promoteUnresolvedConnectionCandidate(nodeRoutingId, advertisedEndpoint) {
-        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 = 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 = {
-            ...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;
-    }
-    removeConnectionCandidate(nodeRoutingId, connectionId) {
-        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);
-        }
-    }
-    isDiscoveredLifecycleReplacement(admitted, nodeRoutingId) {
-        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);
-    }
-    expectedPeerRoutingId(endpoint) {
-        for (const [nodeRoutingId, expected] of this.expectedPeers) {
-            if (expected.endpoint === endpoint)
-                return nodeRoutingId;
-        }
-        return undefined;
-    }
-    acceptsExpectedMonitorEndpoint(nodeRoutingId, event) {
-        // 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);
-    }
     retireNotRequiredExpectedPeer(nodeRoutingId, advertisedEndpoint) {
         const expected = this.expectedPeers.get(nodeRoutingId);
         const endpoint = expected?.endpoint ??
@@ -1254,31 +948,10 @@ class RawServiceMeshRuntime {
         this.endpointOnlyPeers.delete(endpoint);
     }
     removePeer(peer) {
-        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?.(peer.descriptor.nodeRoutingId, peer.descriptor.advertisedEndpoint, peer.descriptor.lifecycleGeneration);
     }
-    observeMonitorEvent(event) {
-        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);
-        }
-    }
     requireStarted() {
         if (this.router === undefined)
             throw new Error('Raw service runtime is not started.');
@@ -1329,30 +1002,14 @@ function isAlreadyDisconnectedError(error) {
     if (typeof error !== 'object' || error === null || !('nativeErrno' in error)) {
         return false;
     }
-    return error.nativeErrno === 2;
+    return error.nativeErrno === nativeErrnoValues.ENOENT;
 }
-function monitorConnectionId(event, resolvedNodeRoutingId = event.routingId ?? '') {
-    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
-    ]);
-}
-function sameMonitorConnection(left, right) {
-    return (monitorConnectionId(left) === monitorConnectionId(right) &&
-        left.remoteAddress === right.remoteAddress);
-}
-function isConnectionReadyEdge(event) {
-    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) {
+    return `route:${routeGeneration.toString()}`;
 }
 function describeInvalidAdmissionDescriptor(descriptor, expected, current) {
     try {
@@ -1407,14 +1064,10 @@ function immutableDescriptorMismatch(current, descriptor) {
 function admissionReason(result) {
     switch (result) {
         case 'meshMismatch':
-            return 2;
+            return (0, service_wire_codec_generated_1.enumWireRejectReason)('topologyMismatch');
         case 'staleDescriptor':
-            return 7;
+            return (0, service_wire_codec_generated_1.enumWireRejectReason)('descriptorRevisionStale');
         case 'invalidDescriptor':
-            return 11;
-        case 'notRequired':
-            return 4;
-        case 'admitted':
-            return 1;
+            return (0, service_wire_codec_generated_1.enumWireRejectReason)('invalidDescriptor');
     }
 }