@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/channels/channel-runtime-lifecycle.ts

@@ -33,7 +33,6 @@ import {
   type ZLinkRouteRuntimeSendHandler
 } from './channel-dispatchers';
 import {
-  createChannelApplicationDispatchQueue,
   ZLinkChannelReceiveLoop,
   ZLinkReceiveRoundRobinCoordinator,
   ZLinkRouteReceiveLoop,
@@ -52,7 +51,6 @@ import {
 } from '../../contracts/Configuration/RuntimeEndpointConnections';
 import type { ApplicationJobQueue } from '../host/application-job-queue';
 import { startOutsideStateLane, ZLinkStateLane } from '../execution/state-lane';
-import { ZLinkSerialExecutionQueue } from '../execution/serial-execution-queue';
 
 interface ManualFanoutSubscriberState {
   readonly channelName: string;
@@ -83,7 +81,6 @@ interface ChannelRuntimeDisposeWork {
   readonly subscriberLoops: readonly ZLinkSubscriberReceiveLoop[];
   readonly manualTransitions: readonly Promise<void>[];
   readonly routeLoops: readonly { stop(): Promise<void> }[];
-  readonly applicationDispatchQueues: readonly ZLinkSerialExecutionQueue[];
   readonly clientServerLocation?: ZLinkClientServerLocationRuntime;
   readonly fanoutLocation?: ZLinkFanoutLocationRuntime;
   readonly spotRouteBridges: readonly ZLinkBackendSpotRouteBridge[];
@@ -107,10 +104,9 @@ export class ZLinkChannelRuntimeLifecycle {
   private readonly receiveRoundRobin = new ZLinkReceiveRoundRobinCoordinator();
   private readonly channelReceiveLoops: ZLinkChannelReceiveLoop[] = [];
   private readonly subscriberReceiveLoops: ZLinkSubscriberReceiveLoop[] = [];
-  private readonly manualFanoutSubscribers = new Map<string, ManualFanoutSubscriberState>();
+  readonly manualFanoutSubscribers = new Map<string, ManualFanoutSubscriberState>();
   private readonly manualFanoutSubscriberOwners = new Set<object>();
   private readonly routeReceiveLoops: Array<{ stop(): Promise<void> }> = [];
-  private readonly applicationDispatchQueues = new Map<string, ZLinkSerialExecutionQueue>();
   private readonly meshChannelDispatchers = new Map<string, ZLinkChannelRequestDispatcher>();
   private readonly meshRouteDispatchers = new Map<string, ZLinkRoutePacketDispatcher>();
   private nextManualFanoutIndex = 0;
@@ -259,11 +255,13 @@ export class ZLinkChannelRuntimeLifecycle {
         ...(mesh.routeSendHandlers ?? []).map((registration) => ({
           kind: 'send' as const,
           packetName: registration.packetName,
+          messageType: registration.messageType,
           handler: this.options.dispatchServices.routeSendHandler(registration.handlerType)
         })),
         ...(mesh.routeRequestHandlers ?? []).map((registration) => ({
           kind: 'request' as const,
           packetName: registration.packetName,
+          messageType: registration.messageType,
           handler: this.options.dispatchServices.routeRequestHandler(registration.handlerType)
         })),
         ...[...(this.options.internalRouteSendHandlers?.entries() ?? [])].map(
@@ -314,27 +312,42 @@ export class ZLinkChannelRuntimeLifecycle {
               taskRunner.errorSink
             ),
             handlers: new Map(
-              channel.requestHandlers?.map((handler) => [
-                handler.packetName,
-                (
+              channel.requestHandlers?.map((handler) => {
+                const configuredHandler = (
                   handler as typeof handler & {
                     readonly handler?: ZLinkRequestHandler<unknown, unknown>;
                   }
-                ).handler ??
-                  adaptRouteRequestHandler(
-                    this.options.dispatchServices.routeRequestHandler(handler.handlerType)
-                  )
-              ])
+                ).handler;
+                return [
+                  handler.packetName,
+                  {
+                    messageType: handler.messageType,
+                    handler:
+                      configuredHandler ??
+                      adaptRouteRequestHandler(
+                        this.options.dispatchServices.routeRequestHandler(handler.handlerType)
+                      )
+                  }
+                ];
+              })
             ),
             sendHandlers: new Map(
-              channel.sendHandlers?.map((handler) => [
-                handler.packetName,
-                (handler as typeof handler & { readonly handler?: ZLinkSendHandler<unknown> })
-                  .handler ??
-                  adaptRouteSendHandler(
-                    this.options.dispatchServices.routeSendHandler(handler.handlerType)
-                  )
-              ])
+              channel.sendHandlers?.map((handler) => {
+                const configuredHandler = (
+                  handler as typeof handler & { readonly handler?: ZLinkSendHandler<unknown> }
+                ).handler;
+                return [
+                  handler.packetName,
+                  {
+                    messageType: handler.messageType,
+                    handler:
+                      configuredHandler ??
+                      adaptRouteSendHandler(
+                        this.options.dispatchServices.routeSendHandler(handler.handlerType)
+                      )
+                  }
+                ];
+              })
             ),
             filters: this.options.dispatchServices.handlerFilters(),
             unhandled: this.options.registration.dispatch?.unhandled
@@ -411,9 +424,6 @@ export class ZLinkChannelRuntimeLifecycle {
         ...work.manualTransitions
       ])
     );
-    const applicationStopped = await startOutsideStateLane(() =>
-      Promise.allSettled(work.applicationDispatchQueues.map((queue) => queue.close()))
-    );
     const descriptorStopped =
       work.clientServerLocation === undefined
         ? []
@@ -434,7 +444,6 @@ export class ZLinkChannelRuntimeLifecycle {
     );
     const errors = [
       ...transportStopped,
-      ...applicationStopped,
       ...descriptorStopped,
       ...fanoutDescriptorStopped,
       ...cleanup
@@ -449,7 +458,6 @@ export class ZLinkChannelRuntimeLifecycle {
       this.channelReceiveLoops.length = 0;
       this.subscriberReceiveLoops.length = 0;
       this.routeReceiveLoops.length = 0;
-      this.applicationDispatchQueues.clear();
       this.clientServerLocation = undefined;
       this.fanoutLocation = undefined;
       this.taskRunner = undefined;
@@ -478,7 +486,6 @@ export class ZLinkChannelRuntimeLifecycle {
       this.drainManualFanoutSubscriberCore(state)
     );
     const routeLoops = [...this.routeReceiveLoops];
-    const applicationDispatchQueues = [...this.applicationDispatchQueues.values()];
     const clientServerLocation = this.clientServerLocation;
     const fanoutLocation = this.fanoutLocation;
     const spotRouteBridges = [...this.options.spotRouteBridges.values()];
@@ -487,22 +494,12 @@ export class ZLinkChannelRuntimeLifecycle {
       subscriberLoops,
       manualTransitions,
       routeLoops,
-      applicationDispatchQueues,
       clientServerLocation,
       fanoutLocation,
       spotRouteBridges
     };
   }
 
-  private applicationDispatchQueue(channelName: string): ZLinkSerialExecutionQueue {
-    let queue = this.applicationDispatchQueues.get(channelName);
-    if (queue === undefined) {
-      queue = createChannelApplicationDispatchQueue();
-      this.applicationDispatchQueues.set(channelName, queue);
-    }
-    return queue;
-  }
-
   private openOutboundSockets(): void {
     // The process-local Server is an independent peer source. Location Store
     // discovery may later alias the same admitted identity, but startup and
@@ -536,19 +533,27 @@ export class ZLinkChannelRuntimeLifecycle {
         handlers: new Map(
           channel.requestHandlers?.map((handler) => [
             handler.packetName,
-            handler.handler ??
-              this.options.dispatchServices.channelRequestHandler(
-                requireChannelHandlerType(handler.handlerType, channelName, handler.packetName)
-              )
+            {
+              messageType: handler.messageType,
+              handler:
+                handler.handler ??
+                this.options.dispatchServices.channelRequestHandler(
+                  requireChannelHandlerType(handler.handlerType, channelName, handler.packetName)
+                )
+            }
           ])
         ),
         sendHandlers: new Map(
           channel.sendHandlers?.map((handler) => [
             handler.packetName,
-            handler.handler ??
-              this.options.dispatchServices.channelSendHandler(
-                requireChannelHandlerType(handler.handlerType, channelName, handler.packetName)
-              )
+            {
+              messageType: handler.messageType,
+              handler:
+                handler.handler ??
+                this.options.dispatchServices.channelSendHandler(
+                  requireChannelHandlerType(handler.handlerType, channelName, handler.packetName)
+                )
+            }
           ])
         ),
         filters: this.options.dispatchServices.handlerFilters(),
@@ -572,8 +577,7 @@ export class ZLinkChannelRuntimeLifecycle {
         this.options.applicationJobQueue,
         (error) =>
           taskRunner.errorSink.reportRuntimeTaskException(`channel:${channelName}:dispatch`, error),
-        this.receiveRoundRobin,
-        this.applicationDispatchQueue(channelName)
+        this.receiveRoundRobin
       );
       this.channelReceiveLoops.push(loop);
       tasks.push(taskRunner.run(`channel:${channelName}`, (signal) => loop.run(signal)));
@@ -599,7 +603,10 @@ export class ZLinkChannelRuntimeLifecycle {
         codecs: this.options.codecs,
         dispatchErrors: this.options.dispatchServices.dispatchErrorReporter(taskRunner.errorSink),
         handlers: new Map(
-          channel.publishHandlers?.map((handler) => [handler.packetName, handler.handler])
+          channel.publishHandlers?.map((handler) => [
+            handler.packetName,
+            { handler: handler.handler, messageType: handler.messageType }
+          ])
         ),
         filters: this.options.dispatchServices.handlerFilters(),
         unhandled: this.options.registration.dispatch?.unhandled,
@@ -657,7 +664,7 @@ export class ZLinkChannelRuntimeLifecycle {
     return state;
   }
 
-  private requestManualFanoutConnect(
+  requestManualFanoutConnect(
     channelName: string,
     endpoint: string,
     taskRunner: ZLinkRuntimeTaskRunner,
@@ -785,8 +792,7 @@ export class ZLinkChannelRuntimeLifecycle {
           taskRunner.errorSink.reportRuntimeTaskException(
             `subscriber:${state.channelName}:manual:${state.index}:dispatch`,
             error
-          ),
-        this.applicationDispatchQueue(channelName)
+          )
       );
       state.openingToken = undefined;
       state.active = { token, loop };
@@ -887,7 +893,10 @@ export class ZLinkChannelRuntimeLifecycle {
       codecs: this.options.codecs,
       dispatchErrors: this.options.dispatchServices.dispatchErrorReporter(taskRunner.errorSink),
       handlers: new Map(
-        channel.publishHandlers?.map((handler) => [handler.packetName, handler.handler])
+        channel.publishHandlers?.map((handler) => [
+          handler.packetName,
+          { handler: handler.handler, messageType: handler.messageType }
+        ])
       ),
       filters: this.options.dispatchServices.handlerFilters(),
       unhandled: this.options.registration.dispatch?.unhandled,
@@ -905,8 +914,7 @@ export class ZLinkChannelRuntimeLifecycle {
         taskRunner.errorSink.reportRuntimeTaskException(
           `subscriber:${channelName}:automatic:${connectionId}:dispatch`,
           error
-        ),
-      this.applicationDispatchQueue(channelName)
+        )
     );
     this.subscriberReceiveLoops.push(loop);
     void taskRunner.run(`subscriber:${channelName}:automatic:${connectionId}`, (signal) =>
@@ -975,8 +983,7 @@ export class ZLinkChannelRuntimeLifecycle {
           taskRunner.errorSink.reportRuntimeTaskException(
             `route:${routeChannel.routerChannelId}:dispatch`,
             error
-          ),
-        this.applicationDispatchQueue(routeChannel.routerChannelId)
+          )
       );
       this.routeReceiveLoops.push(loop);
       tasks.push(
@@ -1006,9 +1013,7 @@ export class ZLinkChannelRuntimeLifecycle {
 function adaptRouteRequestHandler(
   handler: ZLinkRouteRuntimeRequestHandler
 ): ZLinkRequestHandler<unknown, unknown> {
-  return {
-    handle: async (payload, context) => handler.handle(payload, context as never)
-  };
+  return { handle: async (payload, context) => handler.handle(payload, context as never) };
 }
 
 function adaptRouteSendHandler(handler: ZLinkRouteRuntimeSendHandler): ZLinkSendHandler<unknown> {

package/src/runtime/channels/channel-runtime-manager.ts

@@ -1,4 +1,11 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
 import type { ZLinkMeshDispatchAdmission } from '../admission';
+import {
+  identityRequestReply,
+  rejectZLinkRequestReply,
+  type ZLinkRequestResult
+} from '../messaging/request-result';
 import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { RoutingId } from '../../contracts';
@@ -6,6 +13,7 @@ import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProvider
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 import type { ZLinkMessageFlowModeCell } from '../diagnostics';
+import type { ZLinkTelemetryLease } from '../diagnostics/message-flow-delivery';
 import type { Message } from '../../contracts/Common/Message';
 import type { ReceiveRecord } from '../foundation/service-runtime-contracts';
 import { ZLinkConfigurationException, type ZLinkFrameworkRegistration } from '../configuration';
@@ -41,6 +49,7 @@ import {
 } from '../host/application-job-queue';
 
 export class ZLinkChannelRuntimeManager {
+  private readonly requests: RequestRuntime;
   private readonly registration: ZLinkFrameworkRegistration;
   private readonly sockets: ZLinkChannelSocketRegistry;
   private readonly spotRoutes: ZLinkSpotRouteDispatchStrategy;
@@ -55,6 +64,7 @@ export class ZLinkChannelRuntimeManager {
     options: ZLinkChannelRuntimeManagerOptions = {}
   ) {
     this.registration = registration;
+    this.requests = options.requests ?? new RequestRuntime();
     const applicationJobQueue =
       options.applicationJobQueue ??
       new ApplicationJobQueue(resolveApplicationJobQueueConfiguration());
@@ -73,10 +83,12 @@ export class ZLinkChannelRuntimeManager {
     const dispatchServices = new ZLinkChannelDispatchServices(
       registration,
       providerResolver,
-      options.messageFlowModeCell
+      options.messageFlowModeCell,
+      options.telemetryLease
     );
     const spotRouteBridges = new Map<string, ZLinkBackendSpotRouteBridge>();
     this.spotRoutes = new ZLinkSpotRouteDispatchStrategy({
+      requests: this.requests,
       registration,
       sockets: this.sockets,
       codecs,
@@ -84,7 +96,12 @@ export class ZLinkChannelRuntimeManager {
       localSpotRouteDispatcher: options.localSpotRouteDispatcher,
       flowCreationEnabled: () => dispatchServices.flowCreationEnabled()
     });
-    this.outbound = new ZLinkChannelOutboundOperations(this.sockets, codecs, dispatchServices);
+    this.outbound = new ZLinkChannelOutboundOperations(
+      this.sockets,
+      codecs,
+      dispatchServices,
+      this.requests
+    );
     this.lifecycle = new ZLinkChannelRuntimeLifecycle({
       registration,
       adapter,
@@ -245,24 +262,37 @@ export class ZLinkChannelRuntimeManager {
     return this.outbound.send(channelName, packetName, message, metadata);
   }
 
-  async request<TReply>(
+  request<TReply>(
     channelName: string,
     packetName: string | undefined,
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>,
-    onAdmitted?: () => void
-  ): Promise<TReply> {
-    return this.outbound.request<TReply>(
-      channelName,
-      packetName,
-      request,
-      timeoutMs,
-      signal,
-      metadata,
-      onAdmitted
-    );
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>
+  ): ZLinkRequestResult<TReply> {
+    try {
+      const operation = this.requests.begin(timeoutMs, signal, requestOperation);
+      const pending = this.outbound.request<TReply>(
+        channelName,
+        packetName,
+        request,
+        timeoutMs,
+        signal,
+        metadata,
+        onAdmitted,
+        operation
+      );
+      return {
+        pending,
+        decode: identityRequestReply<TReply>,
+        mapFailure: identityRequestReply,
+        operation: operation as PendingOperation<TReply>
+      };
+    } catch (error) {
+      return rejectZLinkRequestReply(error);
+    }
   }
 
   tryPublish(
@@ -296,7 +326,7 @@ export class ZLinkChannelRuntimeManager {
     return this.outbound.routeSubmit(routerChannelId, targetNodeRid, packetName, message, metadata);
   }
 
-  async routeRequest<TReply>(
+  routeRequest<TReply>(
     routerChannelId: string,
     targetNodeRid: string,
     packetName: string | undefined,
@@ -304,7 +334,8 @@ export class ZLinkChannelRuntimeManager {
     timeoutMs: number | undefined,
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>
   ): Promise<TReply> {
     return this.outbound.routeRequest<TReply>(
       routerChannelId,
@@ -314,7 +345,8 @@ export class ZLinkChannelRuntimeManager {
       timeoutMs,
       signal,
       metadata,
-      onAdmitted
+      onAdmitted,
+      requestOperation
     );
   }
 
@@ -327,14 +359,16 @@ export class ZLinkChannelRuntimeManager {
     return this.spotRoutes.routeSendToSpot(spotRouteTarget, packetName, message, metadata);
   }
 
-  async routeRequestToSpot<TReply>(
+  routeRequestToSpot<TReply>(
     spotRouteTarget: ZLinkSpotRouteTarget,
     packetName: string | undefined,
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>,
+    destination?: OperationObserver<unknown, unknown>
   ): Promise<TReply> {
     return this.spotRoutes.routeRequestToSpot<TReply>(
       spotRouteTarget,
@@ -343,18 +377,22 @@ export class ZLinkChannelRuntimeManager {
       timeoutMs,
       signal,
       metadata,
-      onAdmitted
+      onAdmitted,
+      requestOperation,
+      destination
     );
   }
 
-  async routeRequestFromSpotToSpot<TReply>(
+  routeRequestFromSpotToSpot<TReply>(
     sourceSpot: ZLinkBackendSpot,
     spotRouteTarget: ZLinkSpotRouteTarget,
     packetName: string | undefined,
     request: unknown,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>,
+    destination?: OperationObserver<unknown, unknown>
   ): Promise<TReply> {
     return this.spotRoutes.routeRequestFromSpotToSpot<TReply>(
       sourceSpot,
@@ -363,7 +401,9 @@ export class ZLinkChannelRuntimeManager {
       request,
       timeoutMs,
       signal,
-      onAdmitted
+      onAdmitted,
+      requestOperation,
+      destination
     );
   }
 
@@ -389,7 +429,8 @@ export class ZLinkChannelRuntimeManager {
     request: Message,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>
   ): Promise<readonly Message[]> {
     return this.spotRoutes.routeRequestRawFromSpotToSpot(
       sourceSpot,
@@ -397,7 +438,8 @@ export class ZLinkChannelRuntimeManager {
       request,
       timeoutMs,
       signal,
-      onAdmitted
+      onAdmitted,
+      requestOperation
     );
   }
 
@@ -406,14 +448,16 @@ export class ZLinkChannelRuntimeManager {
     request: Message,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    onAdmitted?: () => void
+    onAdmitted?: () => void,
+    requestOperation?: PendingOperation<unknown>
   ): Promise<readonly Message[]> {
     return this.spotRoutes.routeRequestRawToSpot(
       spotRouteTarget,
       request,
       timeoutMs,
       signal,
-      onAdmitted
+      onAdmitted,
+      requestOperation
     );
   }
 
@@ -426,6 +470,7 @@ export class ZLinkChannelRuntimeManager {
   }
 
   async dispose(signal?: AbortSignal): Promise<void> {
+    this.requests.close();
     await this.lifecycle.dispose(signal);
   }
 }
@@ -441,6 +486,7 @@ function splitMonitoringSocketSourceName(sourceName: string): readonly [string,
 }
 
 export interface ZLinkChannelRuntimeManagerOptions {
+  readonly requests?: RequestRuntime;
   readonly listenerRecords?: ZLinkListenerRecords;
   readonly internalRouteSendHandlers?: ReadonlyMap<string, ZLinkRouteRuntimeSendHandler>;
   readonly internalRouteRequestHandlers?: ReadonlyMap<string, ZLinkRouteRuntimeRequestHandler>;
@@ -460,6 +506,7 @@ export interface ZLinkChannelRuntimeManagerOptions {
     ): Promise<TReply>;
   };
   readonly messageFlowModeCell?: ZLinkMessageFlowModeCell;
+  readonly telemetryLease?: ZLinkTelemetryLease;
   readonly oneWayFailureSink?: (error: unknown) => void;
   readonly applicationJobQueue?: ApplicationJobQueue;
 }

package/src/runtime/channels/channel-socket-registry.ts

@@ -1,3 +1,4 @@
+import { inspectRuntime } from '../internal-observation';
 import { RuntimeDisposal } from '../disposal';
 import { UINT64_MAX } from '@zlink-systems/stream-wire';
 import { randomBytes, randomUUID } from 'node:crypto';
@@ -16,7 +17,10 @@ import {
   ZLINK_MAX_PUBLIC_WEIGHT
 } from '../../contracts/Configuration/RegistrationBuilderPolicy';
 import type { ZLinkChannelOptions } from '../../contracts/Configuration/RegistrationTypes';
-import { attachEndpointConnections } from '../../contracts/Configuration/RuntimeEndpointConnections';
+import {
+  attachEndpointConnections,
+  endpointConnections
+} from '../../contracts/Configuration/RuntimeEndpointConnections';
 import { createAbortError, throwIfAborted } from '../abort';
 import type {
   ZLinkBackendContext,
@@ -132,6 +136,14 @@ interface FanoutPublisherConnection {
 }
 
 export class ZLinkChannelSocketRegistry {
+  [inspectRuntime]() {
+    return Object.freeze({
+      clientServerConnections: this.clientServerConnections.size,
+      fanoutConnections: this.fanoutConnections.size,
+      clientServerObservers: this.clientServerDiscovery[inspectRuntime]().clientServerObservers
+    });
+  }
+
   private readonly clientDealers = new Map<string, ZLinkBackendDealerSocket>();
   private readonly channelRouters = new Map<string, ZLinkBackendRouterSocket>();
   private readonly publishers = new Map<string, ZLinkBackendPublisherSocket>();
@@ -144,7 +156,7 @@ export class ZLinkChannelSocketRegistry {
       readonly lifecycleGeneration: bigint;
     }
   >();
-  private readonly clientServerConnections = new Map<string, ClientServerPhysicalConnection>();
+  readonly clientServerConnections = new Map<string, ClientServerPhysicalConnection>();
   private readonly clientServerDiscovery = new ServiceDiscoveryRegistry();
   private readonly clientServerReadyIdentities = new Map<
     string,
@@ -1443,7 +1455,7 @@ export class ZLinkChannelSocketRegistry {
     }
   }
 
-  private applyClientServerDescriptorUpdate(
+  applyClientServerDescriptorUpdate(
     connectionId: string,
     connection: { readonly channelName: string; readonly physicalConnectionId: symbol },
     admission: ZLinkClientServerAdmission
@@ -1506,7 +1518,7 @@ export class ZLinkChannelSocketRegistry {
     this.clientServerLivenessTimer.unref();
   }
 
-  private drainSocketMonitors(): void {
+  drainSocketMonitors(): void {
     for (const monitor of this.ownedResources) if ('drain' in monitor) monitor.drain();
   }
 
@@ -1714,7 +1726,10 @@ export class ZLinkChannelSocketRegistry {
     applySocketConfig(router, routeChannel);
     this.trackRouteMonitor(routerChannelId, router);
     if ((routeChannel.manualConnections ?? []).length > 0) {
-      for (const endpoint of routeChannel.manualConnections ?? []) {
+      for (const endpoint of endpointConnections(
+        routeChannel,
+        routeChannel.manualConnections ?? []
+      ).listConnections()) {
         router.connect(endpoint);
       }
     }