@zlink-systems/framework 0.31.0 → 0.32.0

package/dist/runtime/channels/channel-receive-loops.d.ts

@@ -25,13 +25,13 @@ interface ZLinkChannelRequestDispatchLoop {
         readonly send?: () => ZLinkMultipartOperation<ZLinkMultipartAsyncSubmitOperation>;
     }, router: ZLinkBackendRouterSocket & {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader): Promise<boolean | void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, receivedAt?: Date): Promise<boolean | void>;
 }
 interface ZLinkChannelPublishDispatchLoop {
     dispatch(topicMessage: {
         readonly topic: string;
         readonly parts: readonly Message[];
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader): Promise<void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, receivedAt?: Date): Promise<void>;
 }
 interface ZLinkSubscriberInfrastructureResult {
     readonly consumed: boolean;
@@ -54,7 +54,7 @@ interface ZLinkRoutePacketDispatchLoop {
         readonly replyToken: unknown | null;
     }, router: {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, infrastructureChecked?: boolean): Promise<boolean | void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, infrastructureChecked?: boolean, receivedAt?: Date): Promise<boolean | void>;
 }
 interface ZLinkChannelInfrastructureHandler {
     (received: {
@@ -87,6 +87,7 @@ export declare class ZLinkChannelReceiveLoop {
     private readonly applicationJobQueue;
     private readonly roundRobin?;
     private readonly applicationDispatchQueue;
+    private readonly receivedAtClock;
     private stoppedFlag;
     private isStopped;
     private running?;
@@ -96,7 +97,7 @@ export declare class ZLinkChannelReceiveLoop {
     private readonly capacityStop;
     constructor(channelName: string, router: ZLinkBackendRouterSocket & {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, dispatcher: ZLinkChannelRequestDispatchLoop, spotRouteBridge: ZLinkBackendSpotRouteBridge | undefined, infrastructureHandler: ZLinkChannelInfrastructureHandler | undefined, poller: ZLinkBackendReadablePoller, applicationJobQueue: ApplicationJobQueue, reportError?: ZLinkReceiveTaskErrorReporter, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, applicationDispatchQueue?: ZLinkSerialExecutionQueue);
+    }, dispatcher: ZLinkChannelRequestDispatchLoop, spotRouteBridge: ZLinkBackendSpotRouteBridge | undefined, infrastructureHandler: ZLinkChannelInfrastructureHandler | undefined, poller: ZLinkBackendReadablePoller, applicationJobQueue: ApplicationJobQueue, reportError?: ZLinkReceiveTaskErrorReporter, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, applicationDispatchQueue?: ZLinkSerialExecutionQueue, receivedAtClock?: () => Date);
     run(signal?: AbortSignal): Promise<void>;
     private runLoop;
     stop(): Promise<void>;
@@ -111,6 +112,7 @@ export declare class ZLinkSubscriberReceiveLoop {
     private readonly infrastructureHandler?;
     private readonly roundRobin?;
     private readonly applicationDispatchQueue;
+    private readonly receivedAtClock;
     private stoppedFlag;
     private isStopped;
     private running?;
@@ -118,7 +120,7 @@ export declare class ZLinkSubscriberReceiveLoop {
     private readonly receiveOwner;
     private readonly rawReceiveReservations;
     private readonly capacityStop;
-    constructor(adapter: ZLinkChannelBackendAdapter, subscriber: ZLinkBackendSubscriberSocket, dispatcher: ZLinkChannelPublishDispatchLoop, applicationJobQueue: ApplicationJobQueue, infrastructureHandler?: ((topicMessage: ReturnType<ZLinkChannelBackendAdapter["createTopicMessage"]>) => boolean | ZLinkSubscriberInfrastructureResult) | undefined, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, reportError?: ZLinkReceiveTaskErrorReporter, applicationDispatchQueue?: ZLinkSerialExecutionQueue);
+    constructor(adapter: ZLinkChannelBackendAdapter, subscriber: ZLinkBackendSubscriberSocket, dispatcher: ZLinkChannelPublishDispatchLoop, applicationJobQueue: ApplicationJobQueue, infrastructureHandler?: ((topicMessage: ReturnType<ZLinkChannelBackendAdapter["createTopicMessage"]>) => boolean | ZLinkSubscriberInfrastructureResult) | undefined, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, reportError?: ZLinkReceiveTaskErrorReporter, applicationDispatchQueue?: ZLinkSerialExecutionQueue, receivedAtClock?: () => Date);
     private readonly poller;
     run(signal?: AbortSignal): Promise<void>;
     private runLoop;
@@ -134,6 +136,7 @@ export declare class ZLinkRouteReceiveLoop {
     private readonly applicationJobQueue;
     private readonly roundRobin?;
     private readonly applicationDispatchQueue;
+    private readonly receivedAtClock;
     private stoppedFlag;
     private isStopped;
     private running?;
@@ -143,7 +146,7 @@ export declare class ZLinkRouteReceiveLoop {
     private readonly capacityStop;
     constructor(router: ZLinkBackendRouterSocket & {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, dispatcher: ZLinkRoutePacketDispatchLoop, poller: ZLinkBackendReadablePoller, applicationJobQueue: ApplicationJobQueue, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, reportError?: ZLinkReceiveTaskErrorReporter, applicationDispatchQueue?: ZLinkSerialExecutionQueue);
+    }, dispatcher: ZLinkRoutePacketDispatchLoop, poller: ZLinkBackendReadablePoller, applicationJobQueue: ApplicationJobQueue, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, reportError?: ZLinkReceiveTaskErrorReporter, applicationDispatchQueue?: ZLinkSerialExecutionQueue, receivedAtClock?: () => Date);
     run(signal?: AbortSignal): Promise<void>;
     private runLoop;
     stop(): Promise<void>;

package/dist/runtime/channels/channel-receive-loops.js

@@ -9,18 +9,50 @@ const application_job_queue_scope_1 = require("../application-jobs/application-j
 const serial_execution_queue_1 = require("../execution/serial-execution-queue");
 function createChannelApplicationDispatchQueue() {
     return new serial_execution_queue_1.ZLinkSerialExecutionQueue(async (record) => {
+        const permit = record.context;
+        const previousPermit = (0, application_job_queue_scope_1.enterApplicationJobPermitScope)(permit);
         try {
             void Promise.resolve(record.operation()).then((value) => {
-                record.resolve(value);
-                record.release();
+                try {
+                    record.resolve(value);
+                }
+                finally {
+                    try {
+                        record.release();
+                    }
+                    finally {
+                        (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
+                    }
+                }
             }, (error) => {
-                record.reject(error);
-                record.release();
+                try {
+                    record.reject(error);
+                }
+                finally {
+                    try {
+                        record.release();
+                    }
+                    finally {
+                        (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
+                    }
+                }
             });
         }
         catch (error) {
-            record.reject(error);
-            record.release();
+            try {
+                record.reject(error);
+            }
+            finally {
+                try {
+                    record.release();
+                }
+                finally {
+                    (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
+                }
+            }
+        }
+        finally {
+            (0, application_job_queue_scope_1.leaveApplicationJobPermitScope)(previousPermit);
         }
     });
 }
@@ -122,6 +154,7 @@ class ZLinkChannelReceiveLoop {
     applicationJobQueue;
     roundRobin;
     applicationDispatchQueue;
+    receivedAtClock;
     //  The loop awaits between the two reads and stop() can land in that gap.
     //  Reading through a method keeps the second check honest; a field read stays
     //  narrowed to false across the await and is treated as dead code.
@@ -134,7 +167,7 @@ class ZLinkChannelReceiveLoop {
     receiveOwner;
     rawReceiveReservations;
     capacityStop = new AbortController();
-    constructor(channelName, router, dispatcher, spotRouteBridge, infrastructureHandler, poller, applicationJobQueue, reportError, roundRobin, applicationDispatchQueue = createChannelApplicationDispatchQueue()) {
+    constructor(channelName, router, dispatcher, spotRouteBridge, infrastructureHandler, poller, applicationJobQueue, reportError, roundRobin, applicationDispatchQueue = createChannelApplicationDispatchQueue(), receivedAtClock = () => new Date()) {
         this.channelName = channelName;
         this.router = router;
         this.dispatcher = dispatcher;
@@ -144,6 +177,7 @@ class ZLinkChannelReceiveLoop {
         this.applicationJobQueue = applicationJobQueue;
         this.roundRobin = roundRobin;
         this.applicationDispatchQueue = applicationDispatchQueue;
+        this.receivedAtClock = receivedAtClock;
         this.inFlight = new channel_receive_task_tracker_1.ZLinkReceiveTaskTracker(reportError);
         this.receiveOwner = roundRobin?.register() ?? Symbol('channel-receive-owner');
         this.rawReceiveReservations = new ZLinkRawReceiveReservationPool(exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT);
@@ -200,6 +234,7 @@ class ZLinkChannelReceiveLoop {
                                 this.roundRobin?.setReady(this.receiveOwner, false);
                                 break;
                             }
+                            const receivedAt = this.receivedAtClock();
                             const receivedBytes = messageBytes(received.parts);
                             let classification;
                             try {
@@ -223,7 +258,7 @@ class ZLinkChannelReceiveLoop {
                             }
                             else {
                                 applicationJobPermit.markApplicationQueued();
-                                const task = (0, application_job_queue_scope_1.runWithApplicationJobPermit)(applicationJobPermit, () => this.applicationDispatchQueue.submitPreAdmitted((0, application_job_queue_scope_1.bindApplicationJobPermit)(() => this.dispatchAndClose(received, signal, classification.decodedHeader, true))));
+                                const task = this.applicationDispatchQueue.submitPreAdmitted(() => this.dispatchAndClose(received, signal, classification.decodedHeader, true, undefined, receivedAt), undefined, applicationJobPermit);
                                 this.inFlight.track(task);
                             }
                             if (batch.record(receivedBytes))
@@ -261,7 +296,7 @@ class ZLinkChannelReceiveLoop {
             this.poller.dispose();
         }
     }
-    async dispatchAndClose(received, signal, decodedHeader, infrastructureChecked = false, releaseRawReceive) {
+    async dispatchAndClose(received, signal, decodedHeader, infrastructureChecked = false, releaseRawReceive, receivedAt = this.receivedAtClock()) {
         let closeReceived = true;
         try {
             if (!infrastructureChecked) {
@@ -272,7 +307,7 @@ class ZLinkChannelReceiveLoop {
                 }
                 decodedHeader = classification.decodedHeader;
             }
-            const consumed = await this.dispatcher.dispatch(received, this.router, signal, decodedHeader);
+            const consumed = await this.dispatcher.dispatch(received, this.router, signal, decodedHeader, receivedAt);
             if (consumed === true) {
                 closeReceived = false;
             }
@@ -305,6 +340,7 @@ class ZLinkSubscriberReceiveLoop {
     infrastructureHandler;
     roundRobin;
     applicationDispatchQueue;
+    receivedAtClock;
     //  The loop awaits between the two reads and stop() can land in that gap.
     //  Reading through a method keeps the second check honest; a field read stays
     //  narrowed to false across the await and is treated as dead code.
@@ -317,7 +353,7 @@ class ZLinkSubscriberReceiveLoop {
     receiveOwner;
     rawReceiveReservations;
     capacityStop = new AbortController();
-    constructor(adapter, subscriber, dispatcher, applicationJobQueue, infrastructureHandler, roundRobin, reportError, applicationDispatchQueue = createChannelApplicationDispatchQueue()) {
+    constructor(adapter, subscriber, dispatcher, applicationJobQueue, infrastructureHandler, roundRobin, reportError, applicationDispatchQueue = createChannelApplicationDispatchQueue(), receivedAtClock = () => new Date()) {
         this.adapter = adapter;
         this.subscriber = subscriber;
         this.dispatcher = dispatcher;
@@ -325,6 +361,7 @@ class ZLinkSubscriberReceiveLoop {
         this.infrastructureHandler = infrastructureHandler;
         this.roundRobin = roundRobin;
         this.applicationDispatchQueue = applicationDispatchQueue;
+        this.receivedAtClock = receivedAtClock;
         this.inFlight = new channel_receive_task_tracker_1.ZLinkReceiveTaskTracker(reportError);
         this.poller = adapter.createReadablePoller(subscriber);
         this.receiveOwner = roundRobin?.register() ?? Symbol('subscriber-receive-owner');
@@ -391,6 +428,7 @@ class ZLinkSubscriberReceiveLoop {
                     break;
                 continue;
             }
+            const receivedAt = this.receivedAtClock();
             const receivedBytes = messageBytes(topicMessage.parts);
             let classification;
             try {
@@ -420,7 +458,7 @@ class ZLinkSubscriberReceiveLoop {
                 break;
             }
             applicationJobPermit.markApplicationQueued();
-            const task = (0, application_job_queue_scope_1.runWithApplicationJobPermit)(applicationJobPermit, () => this.applicationDispatchQueue.submitPreAdmitted((0, application_job_queue_scope_1.bindApplicationJobPermit)(() => this.dispatchAndClose(topicMessage, signal, classification.decodedHeader, true))));
+            const task = this.applicationDispatchQueue.submitPreAdmitted(() => this.dispatchAndClose(topicMessage, signal, classification.decodedHeader, true, undefined, receivedAt), undefined, applicationJobPermit);
             releaseRawReceive();
             this.inFlight.track(task);
             if (batch.record(receivedBytes)) {
@@ -451,7 +489,7 @@ class ZLinkSubscriberReceiveLoop {
             throw error;
         }
     }
-    async dispatchAndClose(topicMessage, signal, decodedHeader, infrastructureChecked = false, releaseRawReceive) {
+    async dispatchAndClose(topicMessage, signal, decodedHeader, infrastructureChecked = false, releaseRawReceive, receivedAt = this.receivedAtClock()) {
         try {
             if (!infrastructureChecked) {
                 const classification = this.classify(topicMessage);
@@ -459,7 +497,7 @@ class ZLinkSubscriberReceiveLoop {
                     return;
                 decodedHeader = classification.decodedHeader;
             }
-            await this.dispatcher.dispatch(topicMessage, signal, decodedHeader);
+            await this.dispatcher.dispatch(topicMessage, signal, decodedHeader, receivedAt);
         }
         finally {
             releaseRawReceive?.();
@@ -484,6 +522,7 @@ class ZLinkRouteReceiveLoop {
     applicationJobQueue;
     roundRobin;
     applicationDispatchQueue;
+    receivedAtClock;
     //  The loop awaits between the two reads and stop() can land in that gap.
     //  Reading through a method keeps the second check honest; a field read stays
     //  narrowed to false across the await and is treated as dead code.
@@ -496,13 +535,14 @@ class ZLinkRouteReceiveLoop {
     receiveOwner;
     rawReceiveReservations;
     capacityStop = new AbortController();
-    constructor(router, dispatcher, poller, applicationJobQueue, roundRobin, reportError, applicationDispatchQueue = createChannelApplicationDispatchQueue()) {
+    constructor(router, dispatcher, poller, applicationJobQueue, roundRobin, reportError, applicationDispatchQueue = createChannelApplicationDispatchQueue(), receivedAtClock = () => new Date()) {
         this.router = router;
         this.dispatcher = dispatcher;
         this.poller = poller;
         this.applicationJobQueue = applicationJobQueue;
         this.roundRobin = roundRobin;
         this.applicationDispatchQueue = applicationDispatchQueue;
+        this.receivedAtClock = receivedAtClock;
         this.inFlight = new channel_receive_task_tracker_1.ZLinkReceiveTaskTracker(reportError);
         this.receiveOwner = roundRobin?.register() ?? Symbol('route-receive-owner');
         this.rawReceiveReservations = new ZLinkRawReceiveReservationPool(exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT);
@@ -560,6 +600,7 @@ class ZLinkRouteReceiveLoop {
                     break;
                 continue;
             }
+            const receivedAt = this.receivedAtClock();
             const receivedBytes = messageBytes(received.parts);
             let infrastructure;
             try {
@@ -612,7 +653,7 @@ class ZLinkRouteReceiveLoop {
                 break;
             }
             applicationJobPermit.markApplicationQueued();
-            const task = (0, application_job_queue_scope_1.runWithApplicationJobPermit)(applicationJobPermit, () => this.applicationDispatchQueue.submitPreAdmitted((0, application_job_queue_scope_1.bindApplicationJobPermit)(() => this.dispatchAndClose(received, signal, true))));
+            const task = this.applicationDispatchQueue.submitPreAdmitted(() => this.dispatchAndClose(received, signal, true, undefined, receivedAt), undefined, applicationJobPermit);
             releaseRawReceive();
             this.inFlight.track(task);
             if (batch.record(receivedBytes)) {
@@ -643,10 +684,10 @@ class ZLinkRouteReceiveLoop {
             throw error;
         }
     }
-    async dispatchAndClose(received, signal, infrastructureChecked = false, releaseRawReceive) {
+    async dispatchAndClose(received, signal, infrastructureChecked = false, releaseRawReceive, receivedAt = this.receivedAtClock()) {
         let closeReceived = true;
         try {
-            const consumed = await this.dispatcher.dispatch(received, this.router, signal, (0, channel_envelope_inspection_1.tryDecodeChannelHeader)(received.parts, this.dispatcher.flowEnabled?.() ?? true), infrastructureChecked);
+            const consumed = await this.dispatcher.dispatch(received, this.router, signal, (0, channel_envelope_inspection_1.tryDecodeChannelHeader)(received.parts, this.dispatcher.flowEnabled?.() ?? true), infrastructureChecked, receivedAt);
             if (consumed === true) {
                 closeReceived = false;
             }

package/dist/runtime/channels/channel-runtime-lifecycle.d.ts

@@ -7,12 +7,30 @@ import { ZLinkLocationRuntime, type ZLinkLocationEventSink, type ZLinkLocationRu
 import type { Message } from '../../contracts/Common/Message';
 import type { ReceiveRecord } from '../foundation/service-runtime-contracts';
 import type { RoutingId } from '../../contracts';
-import { type ZLinkRouteRuntimeRequestHandler, type ZLinkRouteRuntimeSendHandler } from './channel-dispatchers';
+import { ZLinkChannelPublishDispatcher, type ZLinkRouteRuntimeRequestHandler, type ZLinkRouteRuntimeSendHandler } from './channel-dispatchers';
+import { ZLinkSubscriberReceiveLoop } from './channel-receive-loops';
 import { ZLinkChannelDispatchServices } from './channel-dispatch-services';
 import type { ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
 import { ZLinkChannelSocketRegistry } from './channel-socket-registry';
 import { ZLinkSpotRouteDispatchStrategy } from './spot-route-dispatch-strategy';
 import type { ApplicationJobQueue } from '../host/application-job-queue';
+interface ManualFanoutSubscriberState {
+    readonly channelName: string;
+    readonly endpoint: string;
+    readonly index: number;
+    readonly connectionId: string;
+    readonly taskRunner: ZLinkRuntimeTaskRunner;
+    readonly dispatcher: ZLinkChannelPublishDispatcher;
+    desired: boolean;
+    transition: Promise<void>;
+    openingToken?: symbol;
+    active?: ManualFanoutSubscriberActive;
+    stopping?: ManualFanoutSubscriberActive;
+}
+interface ManualFanoutSubscriberActive {
+    readonly token: symbol;
+    readonly loop: ZLinkSubscriberReceiveLoop;
+}
 export interface ZLinkChannelRuntimeLifecycleOptions {
     readonly registration: ZLinkFrameworkRegistration;
     readonly adapter: ZLinkChannelBackendAdapter;
@@ -31,7 +49,7 @@ export declare class ZLinkChannelRuntimeLifecycle {
     private readonly receiveRoundRobin;
     private readonly channelReceiveLoops;
     private readonly subscriberReceiveLoops;
-    private readonly manualFanoutSubscribers;
+    readonly manualFanoutSubscribers: Map<string, ManualFanoutSubscriberState>;
     private readonly manualFanoutSubscriberOwners;
     private readonly routeReceiveLoops;
     private readonly meshChannelDispatchers;
@@ -71,7 +89,7 @@ export declare class ZLinkChannelRuntimeLifecycle {
     private startChannelReceivers;
     private startSubscriberReceivers;
     private getOrCreateManualFanoutSubscriber;
-    private requestManualFanoutConnect;
+    requestManualFanoutConnect(channelName: string, endpoint: string, taskRunner: ZLinkRuntimeTaskRunner, dispatcher: ZLinkChannelPublishDispatcher): void;
     private requestManualFanoutDisconnect;
     private enqueueManualFanoutTransition;
     private openManualFanoutSubscriber;
@@ -85,3 +103,4 @@ export declare class ZLinkChannelRuntimeLifecycle {
     private startRouteReceivers;
     private createSpotRouteBridgeForRouter;
 }
+export {};

package/dist/runtime/channels/channel-socket-registry.d.ts

@@ -1,13 +1,14 @@
 import { inspectRuntime } from '../internal-observation';
 import { type RoutingId, type ZLinkClientServerServerDescriptor, type ZLinkFanoutPublisherDescriptor } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import type { ZLinkBackendContext, ZLinkBackendDealerSocket, ZLinkBackendPublisherSocket, ZLinkBackendRouterSocket, ZLinkBackendSocketMonitor, ZLinkBackendSubscriberSocket, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
+import type { ZLinkBackendContext, ZLinkBackendDealerSocket, ZLinkBackendPublisherSocket, ZLinkBackendReadablePoller, ZLinkBackendRouterSocket, ZLinkBackendSocketMonitor, ZLinkBackendSubscriberSocket, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
 import { type ZLinkFrameworkRegistration } from '../configuration';
 import { ZLinkListenerRecords } from '../foundation/listener-records';
 import { ServiceDiscoveryRegistry } from '../foundation/service-discovery-registry';
 import { ServiceLivenessConnection } from '../foundation/service-liveness-registry';
 import type { ApplicationJobQueue } from '../host/application-job-queue';
 import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
+import { type ZLinkClientServerAdmission } from './client-server-service-wire';
 export interface ZLinkClientServerServerSocketIdentity {
     readonly serverRid: string;
     readonly lifecycleGeneration: bigint;
@@ -18,6 +19,20 @@ export interface ZLinkClientServerConnectionCallbacks {
     readonly onTerminated: (routingId: string | undefined, endpoint: string) => void;
 }
 type ClientServerDiscoveryDescriptor = Parameters<ServiceDiscoveryRegistry['admitClientServer']>[0];
+interface ClientServerPhysicalConnection {
+    readonly channelName: string;
+    readonly endpoint: string;
+    readonly dealer: ZLinkBackendDealerSocket;
+    readablePoller?: ZLinkBackendReadablePoller;
+    monitor?: ZLinkBackendSocketMonitor;
+    readonly aliases: Set<string>;
+    readonly callbacksByAlias: Map<string, ZLinkClientServerConnectionCallbacks>;
+    physicalConnectionId: symbol;
+    readyConnectionId?: string;
+    admittedDescriptor?: ClientServerDiscoveryDescriptor;
+    liveness?: ServiceLivenessConnection;
+    admissionAttempt?: symbol;
+}
 export interface ZLinkFanoutConnectionCallbacks {
     readonly onReady: () => void;
     readonly onTerminated: (reason: 'disconnect' | 'deadline' | 'protocol') => void;
@@ -46,7 +61,7 @@ export declare class ZLinkChannelSocketRegistry {
     private readonly routeRouters;
     private readonly routeMembers;
     private readonly clientServerIdentities;
-    private readonly clientServerConnections;
+    readonly clientServerConnections: Map<string, ClientServerPhysicalConnection>;
     private readonly clientServerDiscovery;
     private readonly clientServerReadyIdentities;
     private readonly clientServerServerDescriptors;
@@ -143,9 +158,12 @@ export declare class ZLinkChannelSocketRegistry {
      * the existing admission path.
      */
     private restartClientServerAdmission;
-    private applyClientServerDescriptorUpdate;
+    applyClientServerDescriptorUpdate(connectionId: string, connection: {
+        readonly channelName: string;
+        readonly physicalConnectionId: symbol;
+    }, admission: ZLinkClientServerAdmission): void;
     private ensureClientServerLivenessTimer;
-    private drainSocketMonitors;
+    drainSocketMonitors(): void;
     private removeReadyConnection;
     private requestClientServerLiveness;
     private admitClientServerServerPeer;

package/dist/runtime/diagnostics/runtime-metrics.d.ts

@@ -169,7 +169,7 @@ export declare class ZLinkRuntimeMetrics {
     recordChannelSelectionFailure(meshName: string, channelName: string, reason: string): void;
     recordMessageDropped(meshName: string, surface: string, messageKind: string, reason: string): void;
     startInstanceSpotActivation(meshName: string, instanceSpotType: string): ZLinkRuntimeMetricOperation;
-    startRelocation(meshName: string, objectKind: 'actor' | 'user_spot' | 'instance_spot', policy: 'recreate' | 'snapshot'): ZLinkRelocationMetricOperation;
+    startRelocation(meshName: string, objectKind: 'actor' | 'user_spot' | 'instance_spot', policy: 'recreate' | 'snapshot', onComplete?: (outcome: string) => void): ZLinkRelocationMetricOperation;
     recordInstanceSpotClaimConflict(meshName: string, instanceSpotType: string, reason: string): void;
     recordInstanceSpotTakeover(meshName: string, instanceSpotType: string, outcome: string): void;
     enabled(): boolean;

package/dist/runtime/diagnostics/runtime-metrics.js

@@ -426,7 +426,7 @@ class ZLinkRuntimeMetrics {
             }
         };
     }
-    startRelocation(meshName, objectKind, policy) {
+    startRelocation(meshName, objectKind, policy, onComplete) {
         const started = process.hrtime.bigint();
         const startAttributes = { mesh_name: meshName, object_kind: objectKind, policy };
         let completed = false;
@@ -444,6 +444,7 @@ class ZLinkRuntimeMetrics {
                 const terminal = { ...startAttributes, outcome };
                 this.count(exports.METRIC_NAMES.RelocationCompleted, 1, terminal);
                 this.duration(exports.METRIC_NAMES.RelocationDuration, Number(process.hrtime.bigint() - started) / exports.NANOSECONDS_PER_SECOND, terminal);
+                onComplete?.(outcome);
             }
         };
     }

package/dist/runtime/execution/serial-execution-queue.d.ts

@@ -33,16 +33,28 @@ export interface ZLinkSerialWorkPreparation {
     prepare(signal: AbortSignal): Promise<void>;
     cancel(): void;
 }
+type SerialWorkRecord<T> = Omit<ZLinkSerialWorkRecord<T>, 'acceptedSequence'> & {
+    acceptedSequence: bigint;
+    readonly operationEnvelope: boolean;
+    readonly mailbox?: ZLinkSerialExecutionQueue;
+    readonly preparation?: ZLinkSerialWorkPreparation;
+    preparationState: 'idle' | 'pending' | 'canceling' | 'ready' | 'failed';
+    preparationController?: AbortController;
+    preparationError?: unknown;
+};
+interface ZLinkSerialAdmissionLane {
+    readonly records: Array<SerialWorkRecord<unknown>>;
+}
 /**
  * One event-loop serial execution queue per Spot, Actor mailbox, or Stream session.
  * Application work carries the host permit through the queue until the handler starts.
  */
 export declare class ZLinkSerialExecutionQueue {
-    private readonly executeRecord;
+    readonly executeRecord: (record: ZLinkSerialWorkRecord<unknown>) => Promise<void>;
     private readonly sharedOwner?;
-    private readonly application;
-    private readonly lifecycle;
-    private activeLifecycle?;
+    readonly application: ZLinkSerialAdmissionLane;
+    readonly lifecycle: ZLinkSerialAdmissionLane;
+    activeLifecycle?: ZLinkSerialWorkRecord<unknown>;
     private activeRecord?;
     /** The admitted node itself owns ready membership; no second readiness flag. */
     private ownerMembership?;
@@ -54,7 +66,7 @@ export declare class ZLinkSerialExecutionQueue {
     private lifecycleDebt;
     private claimStartedAt?;
     private closed;
-    private readonly idleWaiters;
+    readonly idleWaiters: Array<() => void>;
     constructor(executeRecord: (record: ZLinkSerialWorkRecord<unknown>) => Promise<void>, options?: ZLinkSerialSchedulerOptions, sharedOwner?: ZLinkSerialExecutionQueue | undefined);
     submit<T>(operation: () => Promise<T> | T, options?: ZLinkSerialWorkOptions, context?: unknown): Promise<T>;
     submitDetached<T>(operation: () => Promise<T> | T, onError: (error: unknown) => void, options?: ZLinkSerialWorkOptions, context?: unknown): void;
@@ -79,22 +91,23 @@ export declare class ZLinkSerialExecutionQueue {
     /** Stops admission within the lifecycle operation that owns this queue's close. */
     closeAdmission(): void;
     get admissionClosed(): boolean;
-    private admit;
-    private scheduleDrain;
+    admit<T>(operation: () => Promise<T> | T, options: ZLinkSerialWorkOptions | undefined, context?: unknown, preparation?: ZLinkSerialWorkPreparation, operationEnvelope?: boolean): Promise<T>;
+    scheduleDrain(): void;
     /** Notifications carry no payload, admission sequence, result Promise, or host permit. */
-    private enqueueMailboxTurn;
+    enqueueMailboxTurn(operation: () => void): void;
     /** Called only by the shared scheduler's consumer, never by a producer. */
     private consumeMailbox;
     private finishMailbox;
-    private drain;
+    drain(): Promise<void>;
     private prepareSelected;
-    private selectNext;
-    private takeSelected;
+    selectNext(): SerialWorkRecord<unknown> | undefined;
+    takeSelected(selected: SerialWorkRecord<unknown>): ZLinkSerialWorkRecord<unknown>;
     private takeLifecycle;
-    private takeApplication;
+    takeApplication(selected: SerialWorkRecord<unknown>): ZLinkSerialWorkRecord<unknown>;
     private startPreparation;
     /** Returns false while an outstanding readiness attempt is being canceled. */
     private cancelPreparationForRearbitration;
     private shouldYield;
-    private resolveIdleWaiters;
+    resolveIdleWaiters(): void;
 }
+export {};

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

@@ -3,12 +3,12 @@ import type { RequestRuntime } from './request-runtime';
 import { inspectRuntime } from '../internal-observation';
 import { ApplicationIngressRecordOwner } from '../application-jobs/application-ingress-record-owner';
 import type { ApplicationJobQueuePort } from '../application-jobs/contracts';
-import type { ZLinkRawBindingPort } from '../backend/raw-binding-port';
+import type { ZLinkRawBindingPort, ZLinkRawReceivedRecord, ZLinkRawRouterPort } from '../backend/raw-binding-port';
 import { SubmitResult } from '../backend/runtime-values';
 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';
+import { ServiceTopologyRegistry, type PeerAdmissionResult, type ServiceNodeDescriptor } from './service-topology-registry';
 import { type ServiceApplicationPayload } from './service-wire-m6a-codec';
 export type RawServicePumpResult = 'noData' | 'infrastructure' | 'application' | 'dropped' | 'protocolError';
 export type RawServicePumpObserver = (sourceRoutingId: string, byteCount: number) => void;
@@ -67,6 +67,12 @@ export interface RawServiceMeshRuntimeOptions {
     }) => void;
 }
 export declare const RAW_MESH_RECEIVE_TIME_BUDGET_MS = 2;
+interface ControlSendState {
+    task?: Promise<boolean>;
+    next?: () => boolean | Promise<boolean>;
+    current?: () => boolean;
+    hello?: Uint8Array;
+}
 /**
  * RouteMesh M6A runtime built only on the public raw binding package.
  * It owns protocol, admission, mailbox, request and liveness state.
@@ -85,7 +91,13 @@ export declare class RawServiceMeshRuntime {
     private readonly requestOwner;
     private readonly releaseOperations;
     private readonly operations;
-    private readonly expectedPeers;
+    readonly expectedPeers: Map<string, {
+        readonly meshName: string;
+        readonly nodeRoutingId: string;
+        readonly endpoint?: string;
+        readonly securityIdentity?: string;
+        readonly lifecycleGeneration?: bigint;
+    }>;
     private readonly endpointOnlyPeers;
     private readonly peerConnectionIntentRemoved;
     private readonly peerRouteChanged;
@@ -93,7 +105,7 @@ export declare class RawServiceMeshRuntime {
      * The last observed Core selected route of each RID (Core ROUTER §10.1):
      * RID -> route generation. Only `observeSelectedRoutes` replaces it.
      */
-    private selectedRoutes;
+    selectedRoutes: Map<string, bigint>;
     private connectionAttempts;
     private readonly bindingPort;
     private readonly applicationJobQueue;
@@ -103,7 +115,7 @@ export declare class RawServiceMeshRuntime {
     private receiveAcquisition?;
     private receivePermit?;
     private receiveRotation?;
-    private readonly controlSends;
+    readonly controlSends: Map<string, ControlSendState>;
     private infrastructureFailure?;
     private readonly onReceiveReady?;
     private readonly infrastructureTaskRunner?;
@@ -114,7 +126,7 @@ export declare class RawServiceMeshRuntime {
     private readonly resolveAdvertisedEndpoint?;
     private descriptor;
     private host?;
-    private router?;
+    router?: ZLinkRawRouterPort;
     private nextCorrelation;
     private serviceIngress?;
     private serviceIngressAccepts?;
@@ -186,9 +198,9 @@ export declare class RawServiceMeshRuntime {
     private acquireReceivePermit;
     private finishPendingReceive;
     private finishReceive;
-    private reportProtocolError;
+    reportProtocolError(received: import('../backend/node/node-raw-binding-port').ZLinkRawReceivedRecord): void;
     private replyGenericProtocolError;
-    private processReceived;
+    processReceived(received: ZLinkRawReceivedRecord, nowMs: number, applicationJobOwner: ApplicationIngressRecordOwner): RawServicePumpResult | Promise<RawServicePumpResult>;
     private finishPendingProtocolReceive;
     private finishPendingStatefulReceive;
     private receiveProtocolFailure;
@@ -223,14 +235,18 @@ export declare class RawServiceMeshRuntime {
      */
     private applicationFrame;
     private applicationPayload;
-    private admitPeer;
+    admitPeer(descriptor: ServiceNodeDescriptor, connectionId: string | bigint, nowMs: number, expected?: {
+        readonly endpoint?: string;
+        readonly securityIdentity?: string;
+        readonly lifecycleGeneration?: bigint;
+    }, command?: number, descriptorBytes?: Uint8Array): PeerAdmissionResult;
     private retireNotRequiredExpectedPeer;
     private selectBilateralConnection;
     private removePeer;
     private requireStarted;
-    private sendControl;
+    sendControl(targetNodeRoutingId: string, parts: readonly Uint8Array[]): Promise<boolean>;
     private submitControl;
-    private startControlSend;
+    startControlSend(target: string, command: number, attempt: () => boolean | Promise<boolean>, current?: () => boolean, hello?: Uint8Array): boolean;
     reportInfrastructureFailure(error: unknown): void;
     private observeInfrastructureFailure;
     private send;