@zlink-systems/framework 0.29.1 → 0.30.0

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

@@ -46,6 +46,12 @@ class RawServiceMeshRuntime {
     applicationJobQueue;
     peerAdmissionSealed;
     applicationJobStop = new AbortController();
+    receiveAcquisition;
+    receivePermit;
+    controlSends = new Map();
+    infrastructureFailure;
+    onReceiveReady;
+    infrastructureTaskRunner;
     onPeerNotRequired;
     onPeerDisconnected;
     onProtocolError;
@@ -58,6 +64,8 @@ class RawServiceMeshRuntime {
     serviceIngress;
     closed = false;
     constructor(options) {
+        this.onReceiveReady = options.onReceiveReady;
+        this.infrastructureTaskRunner = options.infrastructureTaskRunner;
         this.operations = new operation_registry_1.OperationRegistry(undefined, options.onPendingOperationsChanged);
         this.descriptor = options.descriptor;
         this.topology = new service_topology_registry_1.ServiceTopologyRegistry(options.descriptor);
@@ -222,22 +230,22 @@ class RawServiceMeshRuntime {
         for (const listener of this.peerConnectionIntentRemoved)
             listener(nodeRoutingId);
     }
-    async announcePeer(nodeRoutingId) {
+    announcePeer(nodeRoutingId) {
         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;
-        const accepted = await this.send(nodeRoutingId, [
+            return Promise.resolve(false);
+        const current = () => this.expectedPeers.get(nodeRoutingId) === expected &&
+            this.selectedRoutes.get(nodeRoutingId) === generation;
+        return Promise.resolve(this.startControlSend(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello, () => this.submitControl(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;
+        ], () => {
+            if (current())
+                expected.helloSubmittedGeneration = generation;
+        }), current));
     }
     isPeerRouteReady(nodeRoutingId, lifecycleGeneration) {
         // Admission is bound to the observed selected route: the route observer
@@ -245,8 +253,7 @@ class RawServiceMeshRuntime {
         const peer = this.topology.peer(nodeRoutingId);
         return (peer !== undefined &&
             (lifecycleGeneration === undefined ||
-                peer.descriptor.lifecycleGeneration === lifecycleGeneration) &&
-            this.liveness.isReady(nodeRoutingId, peer.connectionId));
+                peer.descriptor.lifecycleGeneration === lifecycleGeneration));
     }
     async announceExpectedPeers() {
         let accepted = 0;
@@ -351,14 +358,15 @@ class RawServiceMeshRuntime {
         const waitSignal = signal === undefined
             ? this.applicationJobStop.signal
             : AbortSignal.any([this.applicationJobStop.signal, signal]);
-        const permit = await this.applicationJobQueue.acquire(waitSignal);
+        const permit = await this.applicationJobQueue.acquire(waitSignal, 'local');
         return application_ingress_record_owner_1.ApplicationIngressRecordOwner.create(this.applicationJobQueue, permit, { close() { } });
     }
     async sendService(targetNodeRoutingId, parts) {
         return this.send(targetNodeRoutingId, parts);
     }
     requestService(targetNodeRoutingId, parts, timeoutMs) {
-        return this.requireStarted().request(targetNodeRoutingId, parts, timeoutMs);
+        const admission = this.topology.peer(targetNodeRoutingId)?.liveness;
+        return this.requireStarted().request(targetNodeRoutingId, parts, timeoutMs, admission?.recordReceived);
     }
     replyService(record, parts) {
         if (record.requestSequence === undefined) {
@@ -383,6 +391,22 @@ class RawServiceMeshRuntime {
         ]);
     }
     async pumpOne(nowMs = performance.now(), observe) {
+        const result = await this.receiveOne(nowMs, observe);
+        const acquisition = this.receiveAcquisition;
+        if (acquisition === undefined)
+            return result;
+        // A single receive operation may await its FIFO grant. Infrastructure
+        // rounds use receiveOne directly and end while that grant is pending.
+        try {
+            await acquisition;
+        }
+        catch (error) {
+            if (this.closed)
+                return 'noData';
+            throw error;
+        }
+        if (this.closed)
+            return 'noData';
         return this.receiveOne(nowMs, observe);
     }
     setReadableHandler(handler) {
@@ -390,6 +414,7 @@ class RawServiceMeshRuntime {
     }
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
     async pumpBatch(receiveReady = true, routeReady = false) {
+        this.observeInfrastructureFailure();
         if (routeReady)
             await this.observeSelectedRoutes();
         const startedAtMs = performance.now();
@@ -412,22 +437,49 @@ class RawServiceMeshRuntime {
                 break;
         }
         if (!this.closed) {
-            await this.announceExpectedPeers();
-            await this.tickLiveness();
+            for (const nodeRoutingId of this.expectedPeers.keys()) {
+                if (this.topology.peer(nodeRoutingId) === undefined)
+                    await this.announcePeer(nodeRoutingId);
+            }
+            this.tickLiveness();
         }
         return receiveReady && messages > 0;
     }
     async receiveOne(nowMs, observe) {
         const router = this.requireStarted();
-        let permit;
-        try {
-            permit = await this.applicationJobQueue.acquire(this.applicationJobStop.signal);
-        }
-        catch (error) {
-            if (this.closed || this.applicationJobStop.signal.aborted)
-                return 'noData';
-            throw error;
+        this.observeInfrastructureFailure();
+        if (this.receivePermit === undefined && this.receiveAcquisition === undefined) {
+            let resolveAcquisition;
+            let rejectAcquisition;
+            const acquisition = new Promise((resolve, reject) => {
+                resolveAcquisition = resolve;
+                rejectAcquisition = reject;
+            });
+            const permit = this.applicationJobQueue.acquireOrResume((permit) => {
+                this.receiveAcquisition = undefined;
+                if (this.closed)
+                    permit.releaseAfterInternalProcessing();
+                else {
+                    this.receivePermit = permit;
+                    this.onReceiveReady?.();
+                }
+                resolveAcquisition(permit);
+            }, rejectAcquisition, this.applicationJobStop.signal, 'remote');
+            if (permit !== undefined)
+                this.receivePermit = permit;
+            else {
+                this.receiveAcquisition = acquisition;
+                acquisition.catch((error) => {
+                    this.receiveAcquisition = undefined;
+                    if (!this.applicationJobStop.signal.aborted)
+                        this.reportInfrastructureFailure(error);
+                });
+            }
         }
+        const permit = this.receivePermit;
+        this.receivePermit = undefined;
+        if (permit === undefined)
+            return 'noData';
         if (this.closed) {
             permit.releaseAfterInternalProcessing();
             return 'noData';
@@ -498,7 +550,7 @@ class RawServiceMeshRuntime {
             (received.parts.length === 1 && received.parts[0].byteLength === 0)) {
             if (this.peerAdmissionSealed?.() === true)
                 return 'dropped';
-            return (await this.send(received.sourceRid, [
+            return (await this.sendControl(received.sourceRid, [
                 (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.topology.localDescriptor())
             ]))
                 ? 'infrastructure'
@@ -519,19 +571,19 @@ class RawServiceMeshRuntime {
                 if (expected !== undefined &&
                     (expected.meshName !== descriptor.meshName ||
                         expected.nodeRoutingId !== descriptor.nodeRoutingId)) {
-                    await this.send(received.sourceRid, [
+                    await this.sendControl(received.sourceRid, [
                         (0, service_wire_m6a_codec_1.encodeReject)((0, service_wire_codec_generated_1.enumWireRejectReason)('identityMismatch'))
                     ]);
                     return 'infrastructure';
                 }
-                const result = this.admitPeer(descriptor, routeConnectionId(received.routeGeneration), nowMs, expected);
+                const result = this.admitPeer(descriptor, received.routeGeneration, nowMs, expected);
                 if (result !== 'admitted' && result !== 'notRequired') {
                     const detail = result === 'invalidDescriptor'
                         ? describeInvalidAdmissionDescriptor(descriptor, expected, this.topology.peer(descriptor.nodeRoutingId)?.descriptor)
                         : undefined;
                     console.warn(`RouteMesh admission rejected peer '${received.sourceRid}' as ${result}` +
                         (detail === undefined ? '.' : ` (${detail}).`));
-                    await this.send(received.sourceRid, [(0, service_wire_m6a_codec_1.encodeReject)(admissionReason(result))]);
+                    await this.sendControl(received.sourceRid, [(0, service_wire_m6a_codec_1.encodeReject)(admissionReason(result))]);
                     return 'infrastructure';
                 }
                 if (result === 'admitted')
@@ -540,7 +592,7 @@ class RawServiceMeshRuntime {
                     // Hello supplies only the sender's descriptor. Even NotRequired
                     // peers must receive ours before the intent owner closes transport;
                     // submitting a response does not guarantee delivery before close.
-                    await this.send(received.sourceRid, [
+                    await this.sendControl(received.sourceRid, [
                         (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.admit, this.topology.localDescriptor())
                     ]);
                 }
@@ -558,16 +610,18 @@ class RawServiceMeshRuntime {
             const peer = this.topology.peer(received.sourceRid);
             if (peer === undefined)
                 return 'protocolError';
+            if (peer.liveness !== undefined && peer.liveness.connectionId === received.routeGeneration)
+                this.liveness.recordReceived(peer.liveness, nowMs);
             if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe ||
                 header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck) {
                 if (received.parts.length !== 1)
                     return 'protocolError';
                 const record = livenessCodec.decodeLivenessRecord(received.parts[0]);
                 if (record.command === service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe) {
-                    const ack = this.liveness.acknowledgeProbe(received.sourceRid, peer.connectionId, record.probeId);
+                    const ack = this.liveness.acknowledgeProbe(received.sourceRid, received.routeGeneration, record.probeId);
                     if (ack === undefined)
                         return 'protocolError';
-                    const sent = await this.send(received.sourceRid, [
+                    const sent = await this.sendControl(received.sourceRid, [
                         livenessCodec.encodeLivenessRecord({
                             command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessAck,
                             probeId: record.probeId
@@ -577,7 +631,7 @@ class RawServiceMeshRuntime {
                         return 'dropped';
                 }
                 else {
-                    this.liveness.acknowledge(received.sourceRid, peer.connectionId, record.probeId, nowMs);
+                    this.liveness.acknowledge(received.sourceRid, received.routeGeneration, record.probeId, nowMs);
                 }
                 return 'infrastructure';
             }
@@ -684,22 +738,23 @@ class RawServiceMeshRuntime {
     get pendingOperationCount() {
         return this.operations.size;
     }
-    async tickLiveness(nowMs = performance.now()) {
+    tickLiveness(nowMs = performance.now()) {
         const result = this.liveness.tick(nowMs);
         this.requireStarted();
         for (const probe of result.probes) {
-            await this.send(probe.nodeRoutingId, [
+            const parts = [
                 livenessCodec.encodeLivenessRecord({
                     command: service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe,
                     probeId: probe.probeId
                 })
-            ]);
+            ];
+            this.startControlSend(probe.nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.livenessProbe, () => this.submitControl(probe.nodeRoutingId, parts));
         }
         for (const nodeRoutingId of result.timedOutNodes) {
             const peer = this.topology.peer(nodeRoutingId);
             if (peer === undefined)
                 continue;
-            // Liveness timeout is a semantic peer removal of the admitted route.
+            this.requireStarted().disconnectRid(nodeRoutingId);
             this.removePeer(peer);
         }
         return result;
@@ -727,7 +782,7 @@ class RawServiceMeshRuntime {
             if (expected !== undefined)
                 delete expected.helloSubmittedGeneration;
             const peer = this.topology.peer(nodeRoutingId);
-            if (peer !== undefined && peer.connectionId === routeConnectionId(generation)) {
+            if (peer?.liveness?.connectionId === generation) {
                 this.removePeer(peer);
             }
         }
@@ -748,7 +803,12 @@ class RawServiceMeshRuntime {
     close() {
         if (this.closed)
             return;
+        this.closed = true;
         this.applicationJobStop.abort(new Error('Raw service runtime application job admission stopped.'));
+        this.receivePermit?.releaseAfterInternalProcessing();
+        this.receivePermit = undefined;
+        for (const send of this.controlSends.values())
+            delete send.next;
         this.mailbox.close();
         this.operations.close('Raw service runtime closed.');
         this.serviceIngress = undefined;
@@ -761,7 +821,6 @@ class RawServiceMeshRuntime {
             host.close();
         this.router = undefined;
         this.host = undefined;
-        this.closed = true;
     }
     requestToTarget(targetNodeRoutingId, payload, timeoutMs, channelName) {
         const correlation = this.nextCorrelation++;
@@ -836,7 +895,8 @@ class RawServiceMeshRuntime {
             })().catch((error) => this.operations.fail(pending.id, error));
             return pending;
         }
-        if (this.topology.peer(selectedTargetNodeRoutingId) === undefined) {
+        const selectedPeer = this.topology.peer(selectedTargetNodeRoutingId);
+        if (selectedPeer === undefined) {
             // Logical target selection is the requester's decision: an RID that is
             // not an admitted peer is not a target. Whether an admitted target's
             // route can carry the request is Core's REQUEST result.
@@ -847,11 +907,9 @@ class RawServiceMeshRuntime {
             return pending;
         }
         const parts = [header, encodedPayload];
-        let router;
         let request;
         try {
-            router = this.requireStarted();
-            request = router.request(selectedTargetNodeRoutingId, parts, timeoutMs);
+            request = this.requireStarted().request(selectedTargetNodeRoutingId, parts, timeoutMs, selectedPeer.liveness?.recordReceived);
         }
         catch (error) {
             this.operations.fail(pending.id, error);
@@ -909,13 +967,14 @@ 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, connectionId, expected);
-        if (result === 'admitted') {
-            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);
+        const topologyConnectionId = typeof connectionId === 'bigint' ? `route:${connectionId}` : connectionId;
+        const result = this.topology.admit(descriptor, topologyConnectionId, expected, () => {
+            const admission = this.liveness.admit(descriptor.nodeRoutingId, connectionId, nowMs);
+            this.liveness.recordReceived(admission, nowMs);
+            return admission;
+        });
+        if (result === 'notRequired' && previous !== undefined) {
+            this.liveness.disconnect(descriptor.nodeRoutingId, previous.liveness?.connectionId ?? previous.connectionId);
         }
         return result;
     }
@@ -950,7 +1009,7 @@ class RawServiceMeshRuntime {
     }
     removePeer(peer) {
         this.topology.disconnect(peer.descriptor.nodeRoutingId, peer.connectionId);
-        this.liveness.disconnect(peer.descriptor.nodeRoutingId, peer.connectionId);
+        this.liveness.disconnect(peer.descriptor.nodeRoutingId, peer.liveness?.connectionId ?? peer.connectionId);
         this.onPeerDisconnected?.(peer.descriptor.nodeRoutingId, peer.descriptor.advertisedEndpoint, peer.descriptor.lifecycleGeneration);
     }
     requireStarted() {
@@ -958,19 +1017,96 @@ class RawServiceMeshRuntime {
             throw new Error('Raw service runtime is not started.');
         return this.router;
     }
-    async send(targetNodeRoutingId, parts) {
+    async sendControl(targetNodeRoutingId, parts) {
+        return this.startControlSend(targetNodeRoutingId, (0, service_wire_m6a_codec_1.decodeHeader)(parts[0]).command, () => this.submitControl(targetNodeRoutingId, parts));
+    }
+    submitControl(target, parts, accepted) {
+        let submission;
         try {
-            await this.requireStarted().send(targetNodeRoutingId, parts);
-            return true;
+            submission = this.requireStarted().submitSend(target, parts);
         }
         catch (error) {
-            if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'submit') {
-                const terminal = (0, submission_result_1.submitToRequestResult)(error.result, error.phase);
-                if (terminal === runtime_values_1.RequestResult.NotConnected || terminal === runtime_values_1.RequestResult.NotFound)
-                    return false;
+            return this.sendFailure(error);
+        }
+        if (submission.result === runtime_values_1.SubmitResult.Ok) {
+            accepted?.();
+            return true;
+        }
+        return submission.admitted.then(() => {
+            accepted?.();
+            return true;
+        }, (error) => this.sendFailure(error));
+    }
+    startControlSend(target, command, attempt, current) {
+        const key = JSON.stringify([target, command]);
+        const existing = this.controlSends.get(key);
+        if (existing !== undefined &&
+            (command !== service_wire_m6a_codec_1.M6aServiceWireCommand.hello || existing.current?.() === true)) {
+            if (command !== service_wire_m6a_codec_1.M6aServiceWireCommand.hello) {
+                existing.next = attempt;
+                existing.current = current;
             }
-            throw error;
+            return true;
+        }
+        const first = attempt();
+        if (typeof first === 'boolean')
+            return first;
+        const owner = this;
+        const state = {
+            current,
+            task: first.then(function drain(accepted) {
+                if (!owner.closed && state.next !== undefined) {
+                    const next = state.next;
+                    delete state.next;
+                    return Promise.resolve(next()).then(drain);
+                }
+                if (owner.controlSends.get(key) === state)
+                    owner.controlSends.delete(key);
+                return accepted;
+            })
+        };
+        this.controlSends.set(key, state);
+        state.task.then(() => { }, (error) => {
+            if (this.controlSends.get(key) === state)
+                this.controlSends.delete(key);
+            if (this.infrastructureTaskRunner === undefined)
+                this.reportInfrastructureFailure(error);
+        });
+        this.infrastructureTaskRunner?.runDetached('RouteMesh control SEND', async () => {
+            await state.task;
+        });
+        return true;
+    }
+    reportInfrastructureFailure(error) {
+        this.infrastructureFailure = {
+            error: this.infrastructureFailure === undefined
+                ? error
+                : new AggregateError([this.infrastructureFailure.error, error], 'RouteMesh infrastructure failed.')
+        };
+        this.onReceiveReady?.();
+    }
+    observeInfrastructureFailure() {
+        const failure = this.infrastructureFailure;
+        this.infrastructureFailure = undefined;
+        if (failure !== undefined)
+            throw failure.error;
+    }
+    send(targetNodeRoutingId, parts) {
+        return this.requireStarted()
+            .send(targetNodeRoutingId, parts)
+            .then(() => {
+            return true;
+        }, (error) => {
+            return this.sendFailure(error);
+        });
+    }
+    sendFailure(error) {
+        if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'submit') {
+            const terminal = (0, submission_result_1.submitToRequestResult)(error.result, error.phase);
+            if (terminal === runtime_values_1.RequestResult.NotConnected || terminal === runtime_values_1.RequestResult.NotFound)
+                return false;
         }
+        throw error;
     }
 }
 exports.RawServiceMeshRuntime = RawServiceMeshRuntime;
@@ -1010,13 +1146,6 @@ function isAlreadyDisconnectedError(error) {
     }
     return error.nativeErrno === nativeErrnoValues.ENOENT;
 }
-/**
- * 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 {
         (0, service_topology_registry_1.validateDescriptor)(descriptor);

package/dist/runtime/foundation/service-liveness-registry.d.ts

@@ -1,6 +1,6 @@
 export interface ServiceProbe {
     readonly nodeRoutingId: string;
-    readonly connectionId: string;
+    readonly connectionId: string | bigint;
     readonly probeId: bigint;
 }
 export interface ServiceLivenessTick {
@@ -9,6 +9,19 @@ export interface ServiceLivenessTick {
 }
 export declare const DEFAULT_SERVICE_PROBE_INTERVAL_MS = 5000;
 export declare const DEFAULT_SERVICE_PEER_TIMEOUT_MS = 15000;
+export declare class ServiceLivenessConnection {
+    readonly connectionId: string | bigint;
+    private readonly probeIntervalMs;
+    private readonly peerTimeoutMs;
+    deadlineMs: number;
+    nextProbeMs: number;
+    outstandingProbe?: bigint;
+    constructor(connectionId: string | bigint, nowMs: number, probeIntervalMs?: number, peerTimeoutMs?: number);
+    readonly recordReceived: (nowMs?: number) => void;
+    isExpired(nowMs: number): boolean;
+    tryGetProbe(nowMs: number, allocateProbeId: () => bigint): bigint | undefined;
+    acknowledge(probeId: bigint, nowMs: number): boolean;
+}
 /** Uses monotonic milliseconds and never treats application traffic as a probe ACK. */
 export declare class ServiceLivenessRegistry {
     private readonly probeIntervalMs;
@@ -16,13 +29,12 @@ export declare class ServiceLivenessRegistry {
     private readonly peers;
     private nextProbeId;
     constructor(probeIntervalMs?: number, peerTimeoutMs?: number);
-    admit(nodeRoutingId: string, connectionId: string, nowMs: number): void;
-    requestProbe(nodeRoutingId: string, connectionId: string, nowMs: number): boolean;
-    disconnect(nodeRoutingId: string, connectionId: string): boolean;
-    acknowledge(nodeRoutingId: string, connectionId: string, probeId: bigint, nowMs: number): boolean;
-    acknowledgeProbe(nodeRoutingId: string, connectionId: string, probeId: bigint): ServiceProbe | undefined;
+    admit(nodeRoutingId: string, connectionId: string | bigint, nowMs: number): ServiceLivenessConnection;
+    recordReceived(connection: ServiceLivenessConnection, nowMs: number): void;
+    disconnect(nodeRoutingId: string, connectionId: string | bigint): boolean;
+    acknowledge(nodeRoutingId: string, connectionId: string | bigint, probeId: bigint, nowMs: number): boolean;
+    acknowledgeProbe(nodeRoutingId: string, connectionId: string | bigint, probeId: bigint): ServiceProbe | undefined;
     tick(nowMs: number): ServiceLivenessTick;
     get size(): number;
-    isReady(nodeRoutingId: string, connectionId: string): boolean;
-    private allocateProbeId;
+    private readonly allocateProbeId;
 }

package/dist/runtime/foundation/service-liveness-registry.js

@@ -1,9 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceLivenessRegistry = exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS = exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS = void 0;
+exports.ServiceLivenessRegistry = exports.ServiceLivenessConnection = exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS = exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS = void 0;
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS = 5_000;
 exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS = 15_000;
+class ServiceLivenessConnection {
+    connectionId;
+    probeIntervalMs;
+    peerTimeoutMs;
+    deadlineMs;
+    nextProbeMs;
+    outstandingProbe;
+    constructor(connectionId, nowMs, probeIntervalMs = exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS, peerTimeoutMs = exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS) {
+        this.connectionId = connectionId;
+        this.probeIntervalMs = probeIntervalMs;
+        this.peerTimeoutMs = peerTimeoutMs;
+        this.deadlineMs = nowMs + peerTimeoutMs;
+        this.nextProbeMs = nowMs;
+    }
+    recordReceived = (nowMs = performance.now()) => {
+        this.deadlineMs = Math.max(this.deadlineMs, nowMs + this.peerTimeoutMs);
+    };
+    isExpired(nowMs) {
+        return nowMs >= this.deadlineMs;
+    }
+    tryGetProbe(nowMs, allocateProbeId) {
+        if (nowMs < this.nextProbeMs)
+            return undefined;
+        this.outstandingProbe ??= allocateProbeId();
+        do {
+            this.nextProbeMs += this.probeIntervalMs;
+        } while (this.nextProbeMs <= nowMs);
+        return this.outstandingProbe;
+    }
+    acknowledge(probeId, nowMs) {
+        this.recordReceived(nowMs);
+        if (this.outstandingProbe !== probeId)
+            return false;
+        this.outstandingProbe = undefined;
+        return true;
+    }
+}
+exports.ServiceLivenessConnection = ServiceLivenessConnection;
 /** Uses monotonic milliseconds and never treats application traffic as a probe ACK. */
 class ServiceLivenessRegistry {
     probeIntervalMs;
@@ -22,26 +60,19 @@ class ServiceLivenessRegistry {
     }
     admit(nodeRoutingId, connectionId, nowMs) {
         requireIdentity(nodeRoutingId, 'nodeRoutingId');
-        requireIdentity(connectionId, 'connectionId');
+        if (typeof connectionId === 'string')
+            requireIdentity(connectionId, 'connectionId');
+        else if (connectionId === 0n)
+            throw new TypeError('connectionId must be nonzero.');
         const current = this.peers.get(nodeRoutingId);
         if (current?.connectionId === connectionId)
-            return;
-        this.peers.set(nodeRoutingId, {
-            connectionId,
-            deadlineMs: nowMs + this.peerTimeoutMs,
-            nextProbeMs: nowMs + this.probeIntervalMs,
-            ready: false
-        });
+            return current;
+        const admitted = new ServiceLivenessConnection(connectionId, nowMs, this.probeIntervalMs, this.peerTimeoutMs);
+        this.peers.set(nodeRoutingId, admitted);
+        return admitted;
     }
-    requestProbe(nodeRoutingId, connectionId, nowMs) {
-        const current = this.peers.get(nodeRoutingId);
-        if (current === undefined ||
-            current.connectionId !== connectionId ||
-            current.ready ||
-            current.outstandingProbe !== undefined)
-            return false;
-        current.nextProbeMs = Math.min(current.nextProbeMs, nowMs);
-        return true;
+    recordReceived(connection, nowMs) {
+        connection.recordReceived(nowMs);
     }
     disconnect(nodeRoutingId, connectionId) {
         const current = this.peers.get(nodeRoutingId);
@@ -52,15 +83,9 @@ class ServiceLivenessRegistry {
     }
     acknowledge(nodeRoutingId, connectionId, probeId, nowMs) {
         const current = this.peers.get(nodeRoutingId);
-        if (current === undefined ||
-            current.connectionId !== connectionId ||
-            current.outstandingProbe !== probeId) {
+        if (current === undefined || current.connectionId !== connectionId)
             return false;
-        }
-        current.outstandingProbe = undefined;
-        current.deadlineMs = nowMs + this.peerTimeoutMs;
-        current.ready = true;
-        return true;
+        return current.acknowledge(probeId, nowMs);
     }
     acknowledgeProbe(nodeRoutingId, connectionId, probeId) {
         const current = this.peers.get(nodeRoutingId);
@@ -73,22 +98,14 @@ class ServiceLivenessRegistry {
         const probes = [];
         const timedOutNodes = [];
         for (const [nodeRoutingId, peer] of this.peers) {
-            if (peer.deadlineMs <= nowMs) {
+            if (peer.isExpired(nowMs)) {
                 timedOutNodes.push(nodeRoutingId);
                 this.peers.delete(nodeRoutingId);
                 continue;
             }
-            if (peer.nextProbeMs > nowMs)
-                continue;
-            peer.outstandingProbe ??= this.allocateProbeId();
-            probes.push({
-                nodeRoutingId,
-                connectionId: peer.connectionId,
-                probeId: peer.outstandingProbe
-            });
-            do {
-                peer.nextProbeMs += this.probeIntervalMs;
-            } while (peer.nextProbeMs <= nowMs);
+            const probeId = peer.tryGetProbe(nowMs, this.allocateProbeId);
+            if (probeId !== undefined)
+                probes.push({ nodeRoutingId, connectionId: peer.connectionId, probeId });
         }
         timedOutNodes.sort();
         return { probes, timedOutNodes };
@@ -96,16 +113,12 @@ class ServiceLivenessRegistry {
     get size() {
         return this.peers.size;
     }
-    isReady(nodeRoutingId, connectionId) {
-        const current = this.peers.get(nodeRoutingId);
-        return current?.connectionId === connectionId && current.ready;
-    }
-    allocateProbeId() {
+    allocateProbeId = () => {
         const result = this.nextProbeId++;
         if (this.nextProbeId > stream_wire_1.UINT64_MAX)
             this.nextProbeId = 1n;
         return result;
-    }
+    };
 }
 exports.ServiceLivenessRegistry = ServiceLivenessRegistry;
 function requireIdentity(value, field) {