@zlink-systems/framework 0.25.0 → 0.26.0

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

@@ -1,7 +1,6 @@
 "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");
 const application_ingress_record_owner_1 = require("../application-jobs/application-ingress-record-owner");
 const operation_registry_1 = require("./operation-registry");
@@ -11,9 +10,6 @@ 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;
 // 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;
@@ -22,8 +18,6 @@ const livenessCodec = (0, service_wire_codec_1.createServiceWireCodec)({
     major: 1,
     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.
@@ -36,17 +30,11 @@ class RawServiceMeshRuntime {
     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,7 +47,6 @@ class RawServiceMeshRuntime {
     descriptor;
     host;
     router;
-    monitor;
     nextCorrelation = 1n;
     serviceIngress;
     closed = false;
@@ -102,8 +89,6 @@ class RawServiceMeshRuntime {
             };
             this.topology.publishLocal(next);
             this.descriptor = next;
-            this.monitor = router.monitor();
-            this.pullMonitorEvents();
             this.host = host;
             this.router = router;
         }
@@ -237,24 +222,22 @@ class RawServiceMeshRuntime {
         ]);
     }
     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.
+            // Admission is a one-time fence for the current selected route.
             // 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.
+            // can use the route. A peer whose selected route ended is removed by the
+            // route observer and remains eligible for the next admission attempt.
             if (this.topology.peer(nodeRoutingId) !== undefined)
                 continue;
             if (await this.announcePeer(nodeRoutingId))
@@ -410,7 +393,6 @@ class RawServiceMeshRuntime {
         ]);
     }
     async pumpOne(nowMs = performance.now(), observe) {
-        this.pullMonitorEvents();
         return this.receiveOne(nowMs, observe);
     }
     setReadableHandler(handler) {
@@ -418,7 +400,7 @@ class RawServiceMeshRuntime {
     }
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
     async pumpBatch(receiveReady = true) {
-        await this.drainMonitorEvents();
+        await this.observeSelectedRoutes();
         const startedAtMs = performance.now();
         let messages = 0;
         let bytes = 0;
@@ -483,22 +465,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);
@@ -564,8 +530,7 @@ class RawServiceMeshRuntime {
                     await this.send(received.sourceRid, [(0, service_wire_m6a_codec_1.encodeReject)(3)]);
                     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)
@@ -594,10 +559,8 @@ class RawServiceMeshRuntime {
                 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.
+                // Keep an already admitted peer: a reject of an earlier Hello on the
+                // same selected route does not end the admission that succeeded.
                 if (reason === 4 && this.topology.peer(received.sourceRid) === undefined) {
                     const expected = this.expectedPeers.get(received.sourceRid);
                     const local = this.topology.localDescriptor();
@@ -752,121 +715,48 @@ 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 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)
@@ -880,8 +770,6 @@ 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;
@@ -964,16 +852,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 +916,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 +925,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 +965,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.');
@@ -1331,28 +1021,12 @@ function isAlreadyDisconnectedError(error) {
     }
     return error.nativeErrno === 2;
 }
-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 {

package/dist/runtime/foundation/service-authority-payload-codec.d.ts

@@ -47,6 +47,7 @@ export declare function replaceServiceAuthorityRelocationState(payload: Uint8Arr
 export declare function encodeServiceUserSpotAuthorityPayload(value: ServiceUserSpotAuthorityPayload): Buffer;
 export declare function encodeServiceInstanceAuthorityPayload(value: ServiceInstanceAuthorityPayload): Buffer;
 export declare function decodeServiceReadySpotAuthority(payload: Uint8Array): ServiceReadySpotAuthority | undefined;
+export declare function decodeServiceClosingSpotAuthority(payload: Uint8Array): ServiceReadySpotAuthority | undefined;
 export declare function decodeServiceInstanceAuthorityPayload(payload: Uint8Array): ServiceDecodedInstanceAuthority | undefined;
 export declare function rewriteServiceAuthorityOwner(payload: Uint8Array, owner: ZLinkLocationOwnerToken): Buffer | undefined;
 export declare function rewriteServiceAuthorityRoute(payload: Uint8Array, owner: ZLinkLocationOwnerToken, target: {

package/dist/runtime/foundation/service-authority-payload-codec.js

@@ -4,6 +4,7 @@ exports.replaceServiceAuthorityRelocationState = replaceServiceAuthorityRelocati
 exports.encodeServiceUserSpotAuthorityPayload = encodeServiceUserSpotAuthorityPayload;
 exports.encodeServiceInstanceAuthorityPayload = encodeServiceInstanceAuthorityPayload;
 exports.decodeServiceReadySpotAuthority = decodeServiceReadySpotAuthority;
+exports.decodeServiceClosingSpotAuthority = decodeServiceClosingSpotAuthority;
 exports.decodeServiceInstanceAuthorityPayload = decodeServiceInstanceAuthorityPayload;
 exports.rewriteServiceAuthorityOwner = rewriteServiceAuthorityOwner;
 exports.rewriteServiceAuthorityRoute = rewriteServiceAuthorityRoute;
@@ -84,6 +85,13 @@ function decodeServiceReadySpotAuthority(payload) {
     const decoded = decodeSpotAuthority(payload);
     return decoded?.state === 'ready' && decoded.operationKind === 0 ? decoded : undefined;
 }
+function decodeServiceClosingSpotAuthority(payload) {
+    const decoded = decodeSpotAuthority(payload);
+    return decoded?.operationKind === 3 &&
+        (decoded.kind === 'user_spot' || decoded.state === 'closing')
+        ? decoded
+        : undefined;
+}
 function decodeServiceInstanceAuthorityPayload(payload) {
     const decoded = decodeSpotAuthority(payload);
     if (decoded?.kind !== 'instance_spot' ||