@zlink-systems/framework 0.30.1 → 0.30.2

package/dist/runtime/foundation/operation-registry.js

@@ -29,7 +29,14 @@ class OperationRegistry {
     entries = new Map();
     nextId = 1n;
     deadlineCursor;
+    /**
+     * A lower bound of the earliest pending deadline. Completed entries only
+     * leave it early; a full expiry pass replaces it with the exact value.
+     */
+    earliestDeadlineMs = Number.POSITIVE_INFINITY;
+    scanEarliestDeadlineMs = Number.POSITIVE_INFINITY;
     closed = false;
+    pendingCount = 0;
     constructor(clock = systemClock, onPendingChanged) {
         this.clock = clock;
         this.onPendingChanged = onPendingChanged;
@@ -47,36 +54,63 @@ class OperationRegistry {
             resolve = onResolve;
             reject = onReject;
         });
-        const entry = {
-            context,
-            deadlineMs: timeoutOwner === 'registry' ? this.clock.now() + timeoutMs : undefined,
-            resolve,
-            reject
-        };
+        const deadlineMs = timeoutOwner === 'registry' ? this.clock.now() + timeoutMs : undefined;
+        const entry = { context, deadlineMs, resolve, reject };
         this.entries.set(id, entry);
-        if (this.entries.size === 1)
-            this.onPendingChanged?.();
+        this.notePending(deadlineMs);
         return { id, promise };
     }
-    complete(id, value) {
+    /** Registers an operation whose terminal goes to `observer` instead of a Promise. */
+    registerObserved(timeoutMs, observer, context) {
+        if (this.closed)
+            throw new Error('Operation registry is closed.');
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+            throw new RangeError('timeoutMs must be a non-negative finite number.');
+        }
+        const id = this.nextId++;
+        const deadlineMs = this.clock.now() + timeoutMs;
+        this.entries.set(id, { context, deadlineMs, observer });
+        this.notePending(deadlineMs);
+        return id;
+    }
+    /** The time the next expiry pass has work, as a lower bound (spec 08 §4.2). */
+    nextDeadlineMs() {
+        return this.earliestDeadlineMs;
+    }
+    notePending(deadlineMs) {
+        this.pendingCount++;
+        const earlier = deadlineMs !== undefined && deadlineMs < this.earliestDeadlineMs;
+        if (earlier)
+            this.earliestDeadlineMs = deadlineMs;
+        if (earlier || this.pendingCount === 1)
+            this.onPendingChanged?.();
+    }
+    complete(id, value, terminalContextRetentionMs = 0) {
         const entry = this.take(id);
         if (entry === undefined)
             return false;
-        entry.resolve(value);
+        if (entry.observer !== undefined)
+            entry.observer.operationCompleted(id, value, entry.context);
+        else
+            entry.resolve(value);
+        this.retainTerminal(id, entry, terminalContextRetentionMs);
         return true;
     }
     fail(id, reason) {
         const entry = this.take(id);
         if (entry === undefined)
             return false;
-        entry.reject(reason);
+        if (entry.observer !== undefined)
+            entry.observer.operationFailed(id, reason, entry.context);
+        else
+            entry.reject(reason);
         return true;
     }
     cancel(id, message) {
         return this.fail(id, new OperationCancelledError(id, message));
     }
     isPending(id) {
-        return this.entries.has(id);
+        return this.pendingEntry(id) !== undefined;
     }
     context(id) {
         return this.entries.get(id)?.context;
@@ -87,36 +121,70 @@ class OperationRegistry {
         this.closed = true;
         for (const id of this.entries.keys())
             this.cancel(id, reason);
+        this.entries.clear();
         this.deadlineCursor = undefined;
     }
+    failAll(reason) {
+        for (const id of this.entries.keys())
+            this.fail(id, reason);
+    }
     get size() {
-        return this.entries.size;
+        return this.pendingCount;
     }
     expire(nowMs, turnDeadlineMs) {
         let expired = 0;
         while (this.clock.now() < turnDeadlineMs) {
-            this.deadlineCursor ??= this.entries.entries();
+            if (this.deadlineCursor === undefined) {
+                this.deadlineCursor = this.entries.entries();
+                this.scanEarliestDeadlineMs = Number.POSITIVE_INFINITY;
+            }
             const current = this.deadlineCursor.next();
             if (current.done === true) {
                 this.deadlineCursor = undefined;
+                // Entries registered during the pass are appended and were scanned.
+                this.earliestDeadlineMs = this.scanEarliestDeadlineMs;
                 break;
             }
             const [id, entry] = current.value;
-            if (entry.deadlineMs !== undefined && entry.deadlineMs <= nowMs) {
-                if (this.fail(id, new OperationTimeoutError(id)))
+            if (entry.deadlineMs === undefined)
+                continue;
+            if (entry.deadlineMs <= nowMs) {
+                if (!this.isPending(id))
+                    this.entries.delete(id);
+                else if (this.fail(id, new OperationTimeoutError(id)))
                     expired++;
             }
+            else if (entry.deadlineMs < this.scanEarliestDeadlineMs) {
+                this.scanEarliestDeadlineMs = entry.deadlineMs;
+            }
         }
         return expired;
     }
     take(id) {
-        const entry = this.entries.get(id);
+        const entry = this.pendingEntry(id);
         if (entry === undefined)
             return undefined;
         this.entries.delete(id);
-        if (this.entries.size === 0)
+        this.pendingCount--;
+        if (this.pendingCount === 0)
             this.onPendingChanged?.();
         return entry;
     }
+    pendingEntry(id) {
+        const entry = this.entries.get(id);
+        return entry !== undefined && (entry.resolve !== undefined || entry.observer !== undefined)
+            ? entry
+            : undefined;
+    }
+    retainTerminal(id, entry, retentionMs) {
+        if (this.closed || entry.context === undefined || retentionMs === 0)
+            return;
+        entry.resolve = undefined;
+        entry.reject = undefined;
+        entry.observer = undefined;
+        entry.deadlineMs = this.clock.now() + retentionMs;
+        this.entries.set(id, entry);
+        this.earliestDeadlineMs = Math.min(this.earliestDeadlineMs, entry.deadlineMs);
+    }
 }
 exports.OperationRegistry = OperationRegistry;

package/dist/runtime/foundation/raw-service-mesh-runtime.d.ts

@@ -2,7 +2,7 @@ import { ApplicationIngressRecordOwner } from '../application-jobs/application-i
 import type { ApplicationJobQueuePort } from '../application-jobs/contracts';
 import type { ZLinkRawBindingPort } from '../backend/raw-binding-port';
 import { SubmitResult } from '../backend/runtime-values';
-import { type PendingOperation } from './operation-registry';
+import { type OperationObserver, type PendingOperation } from './operation-registry';
 import { ServiceLivenessRegistry, type ServiceLivenessTick } from './service-liveness-registry';
 import { ServiceMailbox, type ServiceMailboxRecord } from './service-mailbox';
 import { ServiceTopologyRegistry, type ServiceNodeDescriptor } from './service-topology-registry';
@@ -14,9 +14,22 @@ export interface RawServiceRequestResult {
     readonly failureCode: number;
     readonly payload?: ServiceApplicationPayload;
 }
+/** Receives observed request terminals; the context is the caller's operation kind. */
+export type RawServiceRequestObserver = OperationObserver<RawServiceRequestResult, number>;
+/**
+ * A registered request. An observed remote request has no Promise; its
+ * terminal reaches the observer. Local and Promise-contract requests carry
+ * the Promise.
+ */
+export interface RawServiceObservedRequest {
+    readonly id: bigint;
+    readonly promise?: Promise<RawServiceRequestResult>;
+}
 /** An M6A application frame already owned by the Framework runtime. */
 type ServiceApplicationPayloadInput = ServiceApplicationPayload | Buffer;
 export interface RawServiceIngressRecord {
+    /** Source identity recorded once by the first accepting owner (Location runtime §9.3). */
+    requestSource?: import('../locations/request-source-resolver').ZLinkRequestSourceFence;
     readonly onAdmitted?: () => void;
     readonly command: number;
     readonly flags: number;
@@ -104,12 +117,14 @@ export declare class RawServiceMeshRuntime {
     disconnectPeerEndpoint(endpoint: string): void;
     observePeerConnectionIntentRemoved(listener: (nodeRoutingId: string) => void): () => void;
     observePeerRoute(nodeRoutingId: string): import('./durable-service-request').PeerRouteObservation;
+    waitForPeerRoute(nodeRoutingId: string, lifecycleGeneration: bigint, deadlineUnixMs: bigint, signal?: AbortSignal): Promise<void>;
     get requestStopSignal(): AbortSignal;
     observePeerRouteChanged(listener: (nodeRoutingId: string) => void): () => void;
     hasSelectedPeerRoute(nodeRoutingId: string): boolean;
     private notifyPeerRouteChanged;
     private notifyPeerConnectionIntentRemoved;
-    announcePeer(nodeRoutingId: string): Promise<boolean>;
+    announcePeer(nodeRoutingId: string): boolean;
+    private isPeerAnnouncementCurrent;
     isPeerRouteReady(nodeRoutingId: string, lifecycleGeneration?: bigint): boolean;
     announceExpectedPeers(): Promise<number>;
     updateLocalDescriptor(options: {
@@ -124,7 +139,20 @@ export declare class RawServiceMeshRuntime {
     sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): boolean | Promise<boolean>;
     sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): Promise<SubmitResult>;
     requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted?: () => void): PendingOperation<RawServiceRequestResult>;
+    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted: (() => void) | undefined, observer: RawServiceRequestObserver, operationKind: number): RawServiceObservedRequest;
     requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted?: () => void): PendingOperation<RawServiceRequestResult>;
+    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted: (() => void) | undefined, observer: RawServiceRequestObserver, operationKind: number): RawServiceObservedRequest;
+    /**
+     * One pending entry per request: an observed request reports its terminal
+     * to the caller's observer; any other request keeps the Promise contract.
+     */
+    private registerRequest;
+    /**
+     * An observed caller learns the operation id only when the request call
+     * returns, so a terminal decided inside that call is delivered after it.
+     */
+    private completeRequest;
+    private failRequest;
     private selectChannelTarget;
     setServiceIngress(handler: RawServiceIngressHandler, accepts?: (command: number) => boolean): void;
     reserveLocalIngress(signal?: AbortSignal): Promise<ApplicationIngressRecordOwner>;
@@ -148,6 +176,14 @@ export declare class RawServiceMeshRuntime {
     private enqueueOrdinaryRecord;
     expireOperations(nowMs: number, turnDeadlineMs: number): number;
     get pendingOperationCount(): number;
+    cancelPendingOperations(reason: unknown): void;
+    /**
+     * The next management deadline of this node (spec 08 §4.2): request expiry,
+     * liveness probe or timeout, or an owned HELLO exchange still awaiting
+     * ADMIT, which keeps the existing announce cadence.
+     */
+    nextMaintenanceDeadlineMs(nowMs: number): number;
+    private refreshAdmissionPending;
     tickLiveness(nowMs?: number): ServiceLivenessTick;
     /**
      * The socket's one route observer (Core ROUTER §10.1). It replaces the
@@ -172,7 +208,7 @@ export declare class RawServiceMeshRuntime {
     private sendControl;
     private submitControl;
     private startControlSend;
-    private reportInfrastructureFailure;
+    reportInfrastructureFailure(error: unknown): void;
     private observeInfrastructureFailure;
     private send;
     private sendFailure;

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

@@ -177,13 +177,15 @@ class RawServiceMeshRuntime {
                 router.disconnectRid(nodeRoutingId);
             }
             else {
-                router.disconnect(endpoint);
+                try {
+                    router.disconnect(endpoint);
+                }
+                catch (error) {
+                    if (!isAlreadyDisconnectedError(error))
+                        throw error;
+                }
             }
         }
-        catch (error) {
-            if (!isAlreadyDisconnectedError(error))
-                throw error;
-        }
         finally {
             if (current !== undefined)
                 this.removePeer(current);
@@ -237,6 +239,34 @@ class RawServiceMeshRuntime {
             ready: admitted !== undefined && (selected === undefined || admitted === selected)
         };
     }
+    async waitForPeerRoute(nodeRoutingId, lifecycleGeneration, deadlineUnixMs, signal) {
+        const remaining = deadlineUnixMs - BigInt(Date.now());
+        if (remaining <= 0n)
+            throw new operation_registry_1.OperationTimeoutError(0n);
+        const pending = this.operations.register(Number(remaining));
+        const check = () => {
+            if (this.isPeerRouteReady(nodeRoutingId, lifecycleGeneration)) {
+                this.operations.complete(pending.id, { terminalResult: runtime_values_1.RequestResult.Ok, failureCode: 0 });
+            }
+        };
+        const unsubscribe = this.observePeerRouteChanged((rid) => {
+            if (rid === nodeRoutingId)
+                check();
+        });
+        const abort = () => this.operations.fail(pending.id, signal?.reason);
+        signal?.addEventListener('abort', abort, { once: true });
+        try {
+            if (signal?.aborted === true)
+                abort();
+            else
+                check();
+            await pending.promise;
+        }
+        finally {
+            unsubscribe();
+            signal?.removeEventListener('abort', abort);
+        }
+    }
     get requestStopSignal() {
         return this.applicationJobStop.signal;
     }
@@ -262,26 +292,29 @@ class RawServiceMeshRuntime {
             listener(nodeRoutingId);
     }
     announcePeer(nodeRoutingId) {
+        if (this.closed)
+            return false;
         const generation = this.selectedRoutes.get(nodeRoutingId);
         if (generation === undefined)
-            return Promise.resolve(false);
-        const current = () => {
-            const admission = this.topology.routeAdmission(nodeRoutingId);
-            return (this.selectedRoutes.get(nodeRoutingId) === generation &&
-                !(admission?.connectionId === routeConnectionId(generation) &&
-                    admission.remoteAdmitReceived === true) &&
-                this.peerAdmissionSealed?.() !== true);
-        };
+            return false;
         const key = controlSendKey(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello);
-        if (!current()) {
+        if (!this.isPeerAnnouncementCurrent(nodeRoutingId, generation)) {
             this.controlSends.delete(key);
-            return Promise.resolve(false);
+            return false;
         }
+        const current = () => this.isPeerAnnouncementCurrent(nodeRoutingId, generation);
         const existing = this.controlSends.get(key);
         const hello = existing?.current?.() === true
             ? existing.hello
             : (0, service_wire_m6a_codec_1.encodeRouteMeshAdmission)(service_wire_m6a_codec_1.M6aServiceWireCommand.hello, this.topology.localDescriptor());
-        return Promise.resolve(this.startControlSend(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello, () => this.submitControl(nodeRoutingId, [hello]), current, hello));
+        return this.startControlSend(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello, () => this.submitControl(nodeRoutingId, [hello]), current, hello);
+    }
+    isPeerAnnouncementCurrent(nodeRoutingId, generation) {
+        const admission = this.topology.routeAdmission(nodeRoutingId);
+        return (this.selectedRoutes.get(nodeRoutingId) === generation &&
+            !(admission?.connectionId === routeConnectionId(generation) &&
+                admission.remoteAdmitReceived === true) &&
+            this.peerAdmissionSealed?.() !== true);
     }
     isPeerRouteReady(nodeRoutingId, lifecycleGeneration) {
         // Admission is bound to the observed selected route: the route observer
@@ -353,17 +386,42 @@ class RawServiceMeshRuntime {
             ? runtime_values_1.SubmitResult.Ok
             : runtime_values_1.SubmitResult.NotConnected;
     }
-    requestToNode(targetNodeRoutingId, payload, timeoutMs, onAdmitted) {
-        return this.requestToTarget(targetNodeRoutingId, payload, timeoutMs, undefined, onAdmitted);
+    requestToNode(targetNodeRoutingId, payload, timeoutMs, onAdmitted, observer, operationKind) {
+        return this.requestToTarget(targetNodeRoutingId, payload, timeoutMs, undefined, onAdmitted, observer, operationKind);
     }
-    requestToChannel(channelName, payload, timeoutMs, onAdmitted) {
+    requestToChannel(channelName, payload, timeoutMs, onAdmitted, observer, operationKind) {
         const selection = this.selectChannelTarget(channelName);
         if (selection.kind !== 'selected') {
-            const pending = this.operations.register(timeoutMs);
-            this.operations.complete(pending.id, selection.requestResult);
+            const pending = this.registerRequest(timeoutMs, observer, operationKind);
+            this.completeRequest(pending, selection.requestResult);
             return pending;
         }
-        return this.requestToTarget(selection.peer.descriptor.nodeRoutingId, payload, timeoutMs, channelName, onAdmitted);
+        return this.requestToTarget(selection.peer.descriptor.nodeRoutingId, payload, timeoutMs, channelName, onAdmitted, observer, operationKind);
+    }
+    /**
+     * One pending entry per request: an observed request reports its terminal
+     * to the caller's observer; any other request keeps the Promise contract.
+     */
+    registerRequest(timeoutMs, observer, operationKind) {
+        return observer === undefined
+            ? this.operations.register(timeoutMs)
+            : { id: this.operations.registerObserved(timeoutMs, observer, operationKind) };
+    }
+    /**
+     * An observed caller learns the operation id only when the request call
+     * returns, so a terminal decided inside that call is delivered after it.
+     */
+    completeRequest(pending, result) {
+        if (pending.promise === undefined)
+            queueMicrotask(() => this.operations.complete(pending.id, result));
+        else
+            this.operations.complete(pending.id, result);
+    }
+    failRequest(pending, error) {
+        if (pending.promise === undefined)
+            queueMicrotask(() => this.operations.fail(pending.id, error));
+        else
+            this.operations.fail(pending.id, error);
     }
     selectChannelTarget(channelName) {
         const selected = this.topology.selectChannel(channelName, (peer) => this.isPeerRouteReady(peer.descriptor.nodeRoutingId));
@@ -718,6 +776,7 @@ class RawServiceMeshRuntime {
         }
         else if (header.command === service_wire_m6a_codec_1.M6aServiceWireCommand.admit) {
             this.controlSends.delete(helloKey);
+            this.refreshAdmissionPending(nowMs);
             if (result === 'notRequired') {
                 this.retireNotRequiredExpectedPeer(received.sourceRid, descriptor.advertisedEndpoint);
             }
@@ -779,12 +838,7 @@ class RawServiceMeshRuntime {
             }
             if (header.flags !== 0 ||
                 received.parts.length !== 2 ||
-                ![
-                    service_wire_m6a_codec_1.M6aServiceWireCommand.nodeSend,
-                    service_wire_m6a_codec_1.M6aServiceWireCommand.nodeRequest,
-                    service_wire_m6a_codec_1.M6aServiceWireCommand.channelSend,
-                    service_wire_m6a_codec_1.M6aServiceWireCommand.channelRequest
-                ].includes(header.command)) {
+                !isApplicationEnvelopeCommand(header.command)) {
                 return 'protocolError';
             }
             let owner;
@@ -820,9 +874,9 @@ class RawServiceMeshRuntime {
             parts: received.parts,
             sourceRoutingId: received.sourceRid,
             sourceRoute: received.sourceRoute,
-            ...(received.reply === undefined ? {} : { reply: received.reply }),
+            reply: received.reply,
             requestSequence: received.requestSeq,
-            ...(correlation === undefined ? {} : { correlation }),
+            correlation,
             applicationJob
         });
         if (accepted)
@@ -845,11 +899,38 @@ class RawServiceMeshRuntime {
     get pendingOperationCount() {
         return this.operations.size;
     }
+    cancelPendingOperations(reason) {
+        this.operations.failAll(reason);
+    }
+    /**
+     * The next management deadline of this node (spec 08 §4.2): request expiry,
+     * liveness probe or timeout, or an owned HELLO exchange still awaiting
+     * ADMIT, which keeps the existing announce cadence.
+     */
+    nextMaintenanceDeadlineMs(nowMs) {
+        this.refreshAdmissionPending(nowMs);
+        return Math.min(this.operations.nextDeadlineMs(), this.liveness.nextDeadlineMs());
+    }
+    refreshAdmissionPending(nowMs) {
+        let pending = false;
+        if (!this.closed && this.controlSends.size !== 0) {
+            for (const nodeRoutingId of this.selectedRoutes.keys()) {
+                const exchange = this.controlSends.get(controlSendKey(nodeRoutingId, service_wire_m6a_codec_1.M6aServiceWireCommand.hello));
+                if (exchange?.current?.() === true) {
+                    pending = true;
+                    break;
+                }
+            }
+        }
+        this.liveness.setAdmissionPending(pending, nowMs);
+    }
     tickLiveness(nowMs = performance.now()) {
+        const admissionDue = this.liveness.tickAdmission(nowMs);
         const result = this.liveness.tick(nowMs);
         this.requireStarted();
-        for (const nodeRoutingId of this.selectedRoutes.keys())
-            void this.announcePeer(nodeRoutingId);
+        if (admissionDue)
+            for (const nodeRoutingId of this.selectedRoutes.keys())
+                void this.announcePeer(nodeRoutingId);
         for (const probe of result.probes) {
             const parts = [
                 livenessCodec.encodeLivenessRecord({
@@ -907,6 +988,7 @@ class RawServiceMeshRuntime {
         // A new selected route admits only through a new handshake.
         for (const nodeRoutingId of selected)
             await this.announcePeer(nodeRoutingId);
+        this.refreshAdmissionPending(performance.now());
         return changes;
     }
     close() {
@@ -933,13 +1015,12 @@ class RawServiceMeshRuntime {
         this.router = undefined;
         this.host = undefined;
     }
-    requestToTarget(targetNodeRoutingId, payload, timeoutMs, channelName, onAdmitted) {
+    requestToTarget(targetNodeRoutingId, payload, timeoutMs, channelName, onAdmitted, observer, operationKind) {
         const correlation = this.nextCorrelation++;
         const header = channelName === undefined
             ? (0, service_wire_m6a_codec_1.encodeNodeRequestHeader)(correlation)
             : (0, service_wire_m6a_codec_1.encodeChannelRequestHeader)(correlation, channelName);
         const encodedPayload = this.applicationFrame(payload);
-        const pending = this.operations.register(timeoutMs);
         let selectedTargetNodeRoutingId = targetNodeRoutingId;
         if (selectedTargetNodeRoutingId !== this.descriptor.nodeRoutingId &&
             !this.isPeerRouteReady(selectedTargetNodeRoutingId)) {
@@ -966,6 +1047,9 @@ class RawServiceMeshRuntime {
             }
         }
         if (selectedTargetNodeRoutingId === this.descriptor.nodeRoutingId) {
+            // The local admission path aborts its capacity wait on the terminal
+            // Promise, so a local request always keeps the Promise entry.
+            const pending = this.operations.register(timeoutMs);
             const parts = [header, encodedPayload];
             const capacityStop = new AbortController();
             void pending.promise.finally(() => capacityStop.abort()).catch(() => undefined);
@@ -1009,12 +1093,13 @@ class RawServiceMeshRuntime {
             })().catch((error) => this.operations.fail(pending.id, error));
             return pending;
         }
+        const pending = this.registerRequest(timeoutMs, observer, operationKind);
         const selectedPeer = this.topology.admittedPeer(selectedTargetNodeRoutingId);
         if (selectedPeer === undefined) {
             // Logical target selection is the requester's decision: an RID that is
             // not an admitted peer is not a target. Whether an admitted target's
             // route can carry the request is Core's REQUEST result.
-            this.operations.complete(pending.id, {
+            this.completeRequest(pending, {
                 terminalResult: runtime_values_1.RequestResult.NotFound,
                 failureCode: REQUEST_TARGET_NOT_FOUND_FAILURE_CODE
             });
@@ -1026,7 +1111,7 @@ class RawServiceMeshRuntime {
             request = this.requireStarted().request(selectedTargetNodeRoutingId, parts, timeoutMs, selectedPeer.liveness?.recordReceived, onAdmitted);
         }
         catch (error) {
-            this.operations.fail(pending.id, error);
+            this.failRequest(pending, error);
             return pending;
         }
         void request.then((replyParts) => {
@@ -1146,6 +1231,8 @@ class RawServiceMeshRuntime {
     }
     startControlSend(target, command, attempt, current, hello) {
         const key = controlSendKey(target, command);
+        if (command === service_wire_m6a_codec_1.M6aServiceWireCommand.hello)
+            this.liveness.setAdmissionPending(true, performance.now());
         const existing = this.controlSends.get(key);
         if (existing !== undefined &&
             existing.task !== undefined &&
@@ -1185,15 +1272,17 @@ class RawServiceMeshRuntime {
         this.controlSends.set(key, state);
         task.then(() => { }, (error) => {
             completeSend();
-            if (this.infrastructureTaskRunner === undefined)
-                this.reportInfrastructureFailure(error);
-        });
-        this.infrastructureTaskRunner?.runDetached('RouteMesh control SEND', async () => {
-            await task;
+            this.reportInfrastructureFailure(error);
         });
         return true;
     }
     reportInfrastructureFailure(error) {
+        if (this.infrastructureTaskRunner !== undefined) {
+            this.infrastructureTaskRunner.runDetached('RouteMesh infrastructure', async () => {
+                throw error;
+            });
+            return;
+        }
         this.infrastructureFailure = {
             error: this.infrastructureFailure === undefined
                 ? error
@@ -1229,7 +1318,7 @@ class RawServiceMeshRuntime {
 }
 exports.RawServiceMeshRuntime = RawServiceMeshRuntime;
 function controlSendKey(target, command) {
-    return JSON.stringify([target, command]);
+    return `${command}:${target}`;
 }
 function routeConnectionId(generation) {
     return `route:${generation}`;
@@ -1239,20 +1328,27 @@ function routeConnectionId(generation) {
  * not application NodeSend(16) envelopes. Keep this list closed: a bare
  * record outside the frozen control vocabulary remains a protocol error.
  */
+const BARE_INFRASTRUCTURE_CONTROLS = new Set([
+    service_wire_constants_generated_1.ServiceWireCommand.relocationReady,
+    service_wire_constants_generated_1.ServiceWireCommand.relocationData,
+    service_wire_constants_generated_1.ServiceWireCommand.replyRelay,
+    service_wire_constants_generated_1.ServiceWireCommand.relocationCutover,
+    service_wire_constants_generated_1.ServiceWireCommand.relocationPrepare,
+    service_wire_constants_generated_1.ServiceWireCommand.sessionRelocationSeal,
+    service_wire_constants_generated_1.ServiceWireCommand.sessionRelocationSealed,
+    service_wire_constants_generated_1.ServiceWireCommand.sessionRelocationRoute,
+    service_wire_constants_generated_1.ServiceWireCommand.replyRelayAck,
+    service_wire_constants_generated_1.ServiceWireCommand.relocationState,
+    service_wire_constants_generated_1.ServiceWireCommand.relocationFailed
+]);
 function isBareInfrastructureControl(command) {
-    return [
-        service_wire_constants_generated_1.ServiceWireCommand.relocationReady,
-        service_wire_constants_generated_1.ServiceWireCommand.relocationData,
-        service_wire_constants_generated_1.ServiceWireCommand.replyRelay,
-        service_wire_constants_generated_1.ServiceWireCommand.relocationCutover,
-        service_wire_constants_generated_1.ServiceWireCommand.relocationPrepare,
-        service_wire_constants_generated_1.ServiceWireCommand.sessionRelocationSeal,
-        service_wire_constants_generated_1.ServiceWireCommand.sessionRelocationSealed,
-        service_wire_constants_generated_1.ServiceWireCommand.sessionRelocationRoute,
-        service_wire_constants_generated_1.ServiceWireCommand.replyRelayAck,
-        service_wire_constants_generated_1.ServiceWireCommand.relocationState,
-        service_wire_constants_generated_1.ServiceWireCommand.relocationFailed
-    ].includes(command);
+    return BARE_INFRASTRUCTURE_CONTROLS.has(command);
+}
+function isApplicationEnvelopeCommand(command) {
+    return (command === service_wire_m6a_codec_1.M6aServiceWireCommand.nodeSend ||
+        command === service_wire_m6a_codec_1.M6aServiceWireCommand.nodeRequest ||
+        command === service_wire_m6a_codec_1.M6aServiceWireCommand.channelSend ||
+        command === service_wire_m6a_codec_1.M6aServiceWireCommand.channelRequest);
 }
 function protocolCommand(parts) {
     if (parts.length === 0)

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

@@ -22,14 +22,25 @@ export declare class ServiceLivenessConnection {
     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;
     private readonly peerTimeoutMs;
     private readonly peers;
     private nextProbeId;
+    /**
+     * The earliest probe or timeout among admitted peers. Received traffic only
+     * extends a peer's deadline, so this stays a lower bound between ticks.
+     */
+    private nextDueMs;
+    private admissionActivityMs?;
     constructor(probeIntervalMs?: number, peerTimeoutMs?: number);
     admit(nodeRoutingId: string, connectionId: string | bigint, nowMs: number): ServiceLivenessConnection;
+    /** When the next tick has probe or timeout work (spec 08 §4.2 management deadline). */
+    nextDeadlineMs(): number;
+    /** Pending admission shares the existing liveness management cadence (MeshNode §7.1). */
+    setAdmissionPending(pending: boolean, nowMs: number): void;
+    private nextAdmissionDeadlineMs;
+    tickAdmission(nowMs: number): boolean;
     recordReceived(connection: ServiceLivenessConnection, nowMs: number): void;
     disconnect(nodeRoutingId: string, connectionId: string | bigint): boolean;
     acknowledge(nodeRoutingId: string, connectionId: string | bigint, probeId: bigint, nowMs: number): boolean;