@zlink-systems/framework 0.25.0 → 0.27.0

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

@@ -1,42 +1,58 @@
+import { RuntimeDisposal } from '../disposal';
+import { UINT64_MAX } from '@zlink-systems/stream-wire';
+import { randomBytes, randomUUID } from 'node:crypto';
 import {
   ZLinkFrameworkRuntimeState,
   type RoutingId,
   type ZLinkClientServerServerDescriptor,
   type ZLinkFanoutPublisherDescriptor
 } from '../../contracts';
-import type { ZLinkChannelOptions } from '../../contracts/Configuration/RegistrationTypes';
-import { ZLinkSocketNativeEventType } from '../diagnostics/internal-event-contracts';
+import { ZLINK_MAX_ROUTING_ID_BYTES } from '../../contracts/Common/CoreTypes';
+import type { Message } from '../../contracts/Common/Message';
 import {
-  buildAdvertisedEndpoint,
-  ZLinkConfigurationException,
-  type ZLinkFrameworkRegistration
-} from '../configuration';
+  isValidPublicWeight,
+  ZLINK_DEFAULT_PUBLIC_WEIGHT,
+  ZLINK_MAX_PUBLIC_WEIGHT
+} from '../../contracts/Configuration/RegistrationBuilderPolicy';
+import type { ZLinkChannelOptions } from '../../contracts/Configuration/RegistrationTypes';
+import { attachEndpointConnections } from '../../contracts/Configuration/RuntimeEndpointConnections';
+import { createAbortError, throwIfAborted } from '../abort';
 import type {
   ZLinkBackendContext,
   ZLinkBackendDealerSocket,
   ZLinkBackendPublisherSocket,
-  ZLinkBackendRouterSocket,
   ZLinkBackendReadablePoller,
+  ZLinkBackendRouterSocket,
   ZLinkBackendSocketMonitor,
   ZLinkBackendSocketMonitorEvent,
   ZLinkBackendSubscriberSocket,
   ZLinkChannelBackendAdapter,
   ZLinkMonitoringBackendAdapter
 } from '../backend/contracts';
-import { throwIfAborted } from '../abort';
-import { attachEndpointConnections } from '../../contracts/Configuration/RuntimeEndpointConnections';
-import { ZLinkRouteMemberSnapshot } from './route-member-snapshot';
-import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException
-} from '../framework-errors-internal';
-import { randomBytes, randomUUID } from 'node:crypto';
 import { ZLinkBufferMessage as RuntimeMessage } from '../backend/runtime-message';
-import type { Message } from '../../contracts/Common/Message';
-import { ServiceDiscoveryRegistry } from '../foundation/service-discovery-registry';
+import { isBackendRequestTimeoutError } from '../backend/runtime-values';
+import {
+  buildAdvertisedEndpoint,
+  ZLinkConfigurationException,
+  type ZLinkFrameworkRegistration
+} from '../configuration';
+import { ZLinkSocketNativeEventType } from '../diagnostics/internal-event-contracts';
+import { ZLinkListenerRecords } from '../foundation/listener-records';
 import { discoveryAvailabilityForRuntimeState } from '../foundation/runtime-state-projections';
+import { ServiceDiscoveryRegistry } from '../foundation/service-discovery-registry';
+import {
+  DEFAULT_SERVICE_PEER_TIMEOUT_MS,
+  DEFAULT_SERVICE_PROBE_INTERVAL_MS
+} from '../foundation/service-liveness-registry';
 import { ServiceWireProtocolError } from '../foundation/service-wire-m6a-codec';
 import {
+  createInternalFrameworkException,
+  ZLinkFrameworkInternalErrorKind
+} from '../framework-errors-internal';
+import type { ApplicationJobQueue } from '../host/application-job-queue';
+import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
+import {
+  ClientServerRejectReason,
   decodeClientServerControl,
   encodeClientServerAdmit,
   encodeClientServerHello,
@@ -45,6 +61,7 @@ import {
   encodeClientServerReject,
   encodeClientServerUpdate,
   isClientServerControlFrame,
+  normalizeClientServerMessageLimit,
   type ZLinkClientServerAdmission
 } from './client-server-service-wire';
 import {
@@ -52,16 +69,13 @@ import {
   FANOUT_LIVENESS_TOPIC,
   inspectFanoutInbound
 } from './fanout-service-wire';
-import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
-import type { ApplicationJobQueue } from '../host/application-job-queue';
-import { isBackendRequestTimeoutError } from '../backend/runtime-values';
+import { ZLinkRouteMemberSnapshot } from './route-member-snapshot';
 
 const MAX_LIFECYCLE_GENERATION = 0x7fff_ffff_ffff_ffffn;
-const CLIENT_SERVER_PROBE_INTERVAL_MS = 5_000;
-const CLIENT_SERVER_PEER_DEADLINE_MS = 15_000;
-const CLIENT_SERVER_READY_WAIT_CAP_MS = 5_000;
-const CLIENT_SERVER_READY_POLL_INTERVAL_MS = 5;
-const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+const CLIENT_SERVER_PROBE_INTERVAL_MS = DEFAULT_SERVICE_PROBE_INTERVAL_MS;
+const CLIENT_SERVER_PEER_DEADLINE_MS = DEFAULT_SERVICE_PEER_TIMEOUT_MS;
+const CLIENT_SERVER_LIVENESS_TICK_MS = 100;
+const DEFAULT_SEND_TIMEOUT_MS = 1_000;
 
 export interface ZLinkClientServerServerSocketIdentity {
   readonly serverRid: string;
@@ -80,12 +94,11 @@ interface ClientServerPhysicalConnection {
   readonly channelName: string;
   readonly endpoint: string;
   readonly dealer: ZLinkBackendDealerSocket;
-  readonly readablePoller: ZLinkBackendReadablePoller;
-  readonly monitor: ZLinkBackendSocketMonitor;
+  readablePoller?: ZLinkBackendReadablePoller;
+  monitor?: ZLinkBackendSocketMonitor;
   readonly aliases: Set<string>;
   readonly callbacksByAlias: Map<string, ZLinkClientServerConnectionCallbacks>;
   physicalConnectionId: symbol;
-  terminationRequested: boolean;
   readyConnectionId?: string;
   admittedDescriptor?: ClientServerDiscoveryDescriptor;
   nextProbeAt?: number;
@@ -103,7 +116,7 @@ interface FanoutPublisherConnection {
   readonly channelName: string;
   readonly endpoint: string;
   readonly subscriber: ZLinkBackendSubscriberSocket;
-  readonly monitor: ZLinkBackendSocketMonitor;
+  monitor?: ZLinkBackendSocketMonitor;
   readonly callbacks: ZLinkFanoutConnectionCallbacks;
   readonly physicalConnectionId: symbol;
   transportReady: boolean;
@@ -155,14 +168,20 @@ export class ZLinkChannelSocketRegistry {
       outstandingProbeId?: bigint;
     }
   >();
-  private readonly ownedMonitors = new Set<ZLinkBackendSocketMonitor>();
+  private readonly disposal = new RuntimeDisposal();
+  private readonly ownedResources = new Set<
+    | ZLinkBackendSocketMonitor
+    | ZLinkBackendReadablePoller
+    | ZLinkBackendDealerSocket
+    | ZLinkBackendSubscriberSocket
+  >();
   private readonly fanoutConnections = new Map<string, FanoutPublisherConnection>();
   private readonly fanoutPublisherNextBeacon = new Map<string, number>();
   private clientServerLivenessTimer?: NodeJS.Timeout;
   private nextClientServerProbeId = 1n;
   private readonly clientServerMonitorHandlers = new Map<
     string,
-    Set<(event: ZLinkBackendSocketMonitorEvent) => void>
+    Set<(event?: ZLinkBackendSocketMonitorEvent) => void>
   >();
   private readonly fanoutMonitorHandlers = new Map<
     string,
@@ -170,19 +189,34 @@ export class ZLinkChannelSocketRegistry {
   >();
   private readonly fanoutTopologyHandlers = new Map<string, Set<() => void>>();
 
+  private readonly listenerRecords: ZLinkListenerRecords;
+
   constructor(
     private readonly registration: ZLinkFrameworkRegistration,
     private readonly adapter: ZLinkChannelBackendAdapter,
     private readonly context: ZLinkBackendContext,
     private readonly monitoringAdapter?: ZLinkMonitoringBackendAdapter,
     private readonly oneWayFailureSink?: (error: unknown) => void,
-    private readonly applicationJobQueue?: ApplicationJobQueue
-  ) {}
+    private readonly applicationJobQueue?: ApplicationJobQueue,
+    listenerRecords?: ZLinkListenerRecords
+  ) {
+    this.listenerRecords = listenerRecords ?? new ZLinkListenerRecords();
+  }
+
+  dispose(): Promise<void> {
+    return this.disposal.run(() => this.disposeCore());
+  }
 
-  async dispose(): Promise<void> {
+  private async disposeCore(): Promise<void> {
+    this.clientServerDiscovery.dispose(
+      createInternalFrameworkException(
+        ZLinkFrameworkInternalErrorKind.RuntimeShutdown,
+        'Channel sockets are shutting down.'
+      )
+    );
     const clientServerConnections = [...new Set(this.clientServerConnections.values())];
-    const clientServerPollers = clientServerConnections.map(
-      (connection) => connection.readablePoller
+    const clientServerPollers = clientServerConnections.flatMap((connection) =>
+      connection.readablePoller === undefined ? [] : [connection.readablePoller]
     );
     const sockets = [
       ...this.clientDealers.values(),
@@ -199,8 +233,6 @@ export class ZLinkChannelSocketRegistry {
       ...this.routeRouters.values()
     ]))
       this.unregisterReceiveFlowSocket(socket);
-    this.clientDealers.clear();
-    this.clientServerConnections.clear();
     this.clientServerReadyIdentities.clear();
     this.clientServerServerDescriptors.clear();
     this.clientServerPublicWeights.clear();
@@ -210,23 +242,37 @@ export class ZLinkChannelSocketRegistry {
     this.clientServerMonitorHandlers.clear();
     this.fanoutMonitorHandlers.clear();
     this.fanoutTopologyHandlers.clear();
-    this.fanoutConnections.clear();
     this.fanoutPublisherNextBeacon.clear();
     if (this.clientServerLivenessTimer !== undefined) {
       clearInterval(this.clientServerLivenessTimer);
       this.clientServerLivenessTimer = undefined;
     }
-    this.channelRouters.clear();
-    this.publishers.clear();
-    this.routeRouters.clear();
     this.routeMembers.clear();
-    const monitors = [...this.ownedMonitors];
-    this.ownedMonitors.clear();
-    const cleanup = await Promise.allSettled([
-      ...clientServerPollers.map((poller) => poller.dispose()),
-      ...monitors.map((monitor) => monitor.dispose()),
-      ...sockets.map((socket) => socket.dispose())
-    ]);
+    const cleanup = await Promise.allSettled(
+      [...new Set([...clientServerPollers, ...this.ownedResources, ...sockets])].map(
+        async (resource) => {
+          await resource.dispose();
+          this.ownedResources.delete(resource as ZLinkBackendSocketMonitor);
+          for (const owners of [
+            this.clientDealers,
+            this.channelRouters,
+            this.publishers,
+            this.routeRouters
+          ]) {
+            for (const [name, owned] of owners) if (owned === resource) owners.delete(name);
+          }
+          for (const [name, owned] of this.clientServerConnections) {
+            if (owned.dealer === resource) this.clientServerConnections.delete(name);
+            if (owned.readablePoller === resource) owned.readablePoller = undefined;
+            if (owned.monitor === resource) owned.monitor = undefined;
+          }
+          for (const [name, owned] of this.fanoutConnections) {
+            if (owned.subscriber === resource) this.fanoutConnections.delete(name);
+            if (owned.monitor === resource) owned.monitor = undefined;
+          }
+        }
+      )
+    );
     const errors = cleanup
       .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
       .map((result) => result.reason);
@@ -247,13 +293,16 @@ export class ZLinkChannelSocketRegistry {
     }
 
     const dealer = this.adapter.createDealerSocket(this.context);
+    this.clientDealers.set(channelName, dealer);
     this.registerReceiveFlowSocket(dealer);
     dealer.setChannelName(channelName);
     if (channel?.routingId !== undefined && channel.routingId.length > 0) {
       dealer.setRoutingId(deriveRoutingId(channel.routingId, 'dealer'));
     }
-    applySocketConfig(dealer, client);
-    this.clientDealers.set(channelName, dealer);
+    applySocketConfig(dealer, {
+      ...client,
+      sendTimeoutMs: configuredSendTimeoutMs(client.sendTimeoutMs)
+    });
     return dealer;
   }
 
@@ -274,6 +323,7 @@ export class ZLinkChannelSocketRegistry {
     }
 
     const router = this.adapter.createRouterSocket(this.context);
+    this.channelRouters.set(channelName, router);
     this.registerReceiveFlowSocket(router);
     router.setChannelName(channelName);
     const identity = this.clientServerIdentities.get(channelName) ?? {
@@ -282,14 +332,14 @@ export class ZLinkChannelSocketRegistry {
     };
     this.clientServerIdentities.set(channelName, identity);
     router.setRoutingId(identity.serverRid);
-    const publicWeight = channel.server.weight ?? 100;
+    const publicWeight = channel.server.weight ?? ZLINK_DEFAULT_PUBLIC_WEIGHT;
     this.clientServerPublicWeights.set(channelName, publicWeight);
     router.peerWeight = rawAvailabilityWeight(publicWeight);
     applySocketConfig(router, channel.server);
     router.bind(channel.server.bind);
     if (this.monitoringAdapter !== undefined) {
       const monitor = this.monitoringAdapter.openSocketMonitor(router);
-      this.ownedMonitors.add(monitor);
+      this.ownedResources.add(monitor);
       monitor.onEvent((event) => {
         if (event.routingId === undefined) return;
         if (
@@ -305,15 +355,18 @@ export class ZLinkChannelSocketRegistry {
         this.clientServerAdmittedClients.get(channelName)?.delete(routingId);
       });
     }
-    this.channelRouters.set(channelName, router);
+    const endpoint = advertisedEndpoint(
+      router.lastEndpoint ?? channel.server.bind,
+      channel.server.advertiseHost
+    );
+    this.recordListener('clientServer', channelName, endpoint);
     if (!this.clientServerServerDescriptors.has(channelName)) {
-      const boundEndpoint = router.lastEndpoint ?? channel.server.bind;
       this.clientServerServerDescriptors.set(channelName, {
         channelName,
         serverRid: identity.serverRid,
         lifecycleGeneration: identity.lifecycleGeneration,
         descriptorRevision: 1n,
-        endpoint: advertisedEndpoint(boundEndpoint, channel.server.advertiseHost),
+        endpoint,
         weight: publicWeight,
         state: ZLinkFrameworkRuntimeState.Serving,
         securityIdentity: 'default',
@@ -326,22 +379,21 @@ export class ZLinkChannelSocketRegistry {
   }
 
   clientServerServerIdentity(channelName: string): ZLinkClientServerServerSocketIdentity {
-    const router = this.channelRouter(channelName);
+    this.channelRouter(channelName);
     const identity = this.clientServerIdentities.get(channelName);
-    const channel = this.registration.channels.get(channelName);
-    if (identity === undefined || channel?.server === undefined) {
+    const endpoint = this.listenerRecords.endpoint('clientServer', channelName);
+    if (identity === undefined || endpoint === undefined) {
       throw new ZLinkConfigurationException(`Channel server '${channelName}' is not registered.`);
     }
-    const boundEndpoint = router.lastEndpoint ?? channel.server.bind;
-    if (boundEndpoint === undefined || boundEndpoint.length === 0) {
-      throw new ZLinkConfigurationException(
-        `Channel server '${channelName}' did not report its bound endpoint.`
-      );
-    }
-    return {
-      ...identity,
-      endpoint: advertisedEndpoint(boundEndpoint, channel.server.advertiseHost)
-    };
+    return { ...identity, endpoint };
+  }
+
+  fanoutPublisherEndpoint(channelName: string): string | undefined {
+    return this.listenerRecords.endpoint('fanout', channelName);
+  }
+
+  private recordListener(kind: 'clientServer' | 'fanout', name: string, endpoint: string): void {
+    this.listenerRecords.record(kind, name, endpoint);
   }
 
   clientServerServerSocket(channelName: string): ZLinkBackendRouterSocket {
@@ -350,7 +402,7 @@ export class ZLinkChannelSocketRegistry {
 
   clientServerServerWeight(channelName: string): number {
     this.channelRouter(channelName);
-    return this.clientServerPublicWeights.get(channelName) ?? 100;
+    return this.clientServerPublicWeights.get(channelName) ?? ZLINK_DEFAULT_PUBLIC_WEIGHT;
   }
 
   setClientServerServerWeight(channelName: string, weight: number): void {
@@ -382,47 +434,38 @@ export class ZLinkChannelSocketRegistry {
       throw new ZLinkConfigurationException(`Channel client '${channelName}' is not registered.`);
     }
     const dealer = this.adapter.createDealerSocket(this.context);
-    this.registerReceiveFlowSocket(dealer);
-    dealer.setChannelName(channelName);
-    dealer.setRoutingId(`cs-client-${randomUUID()}`);
-    applySocketConfig(dealer, client);
-    const cleanupDealer = (): void => {
-      this.unregisterReceiveFlowSocket(dealer);
-      void Promise.allSettled([dealer.dispose()]);
-    };
-    let readablePoller: ZLinkBackendReadablePoller;
-    try {
-      readablePoller = this.adapter.createReadablePoller(dealer);
-    } catch (error) {
-      cleanupDealer();
-      throw error;
-    }
-    let monitor: ZLinkBackendSocketMonitor;
-    try {
-      monitor = this.monitoringAdapter.openSocketMonitor(dealer);
-    } catch (error) {
-      try {
-        readablePoller.dispose();
-      } finally {
-        cleanupDealer();
-      }
-      throw error;
-    }
-    this.ownedMonitors.add(monitor);
     const connection: ClientServerPhysicalConnection = {
       channelName,
       endpoint,
       dealer,
-      readablePoller,
-      monitor,
       aliases: new Set([connectionId]),
       callbacksByAlias: new Map([[connectionId, callbacks]]),
-      physicalConnectionId: Symbol(connectionId),
-      terminationRequested: false
+      physicalConnectionId: Symbol(connectionId)
     };
-    this.clientServerConnections.set(connectionId, connection);
-    this.ensureClientServerLivenessTimer();
+    this.ownedResources.add(dealer);
+    const created: (
+      | ZLinkBackendSocketMonitor
+      | ZLinkBackendReadablePoller
+      | ZLinkBackendDealerSocket
+      | ZLinkBackendSubscriberSocket
+    )[] = [dealer];
     try {
+      this.clientServerConnections.set(connectionId, connection);
+      this.registerReceiveFlowSocket(dealer);
+      dealer.setChannelName(channelName);
+      dealer.setRoutingId(`cs-client-${randomUUID()}`);
+      applySocketConfig(dealer, {
+        ...client,
+        sendTimeoutMs: configuredSendTimeoutMs(client.sendTimeoutMs)
+      });
+      connection.readablePoller = this.adapter.createReadablePoller(dealer);
+      created.push(connection.readablePoller);
+      this.ownedResources.add(connection.readablePoller);
+      const monitor = this.monitoringAdapter.openSocketMonitor(dealer);
+      connection.monitor = monitor;
+      created.push(monitor);
+      this.ownedResources.add(monitor);
+      this.ensureClientServerLivenessTimer();
       monitor.onEvent((event) => {
         if (
           ![...connection.aliases].some(
@@ -436,7 +479,7 @@ export class ZLinkChannelSocketRegistry {
         const routingId = event.routingId === undefined ? undefined : String(event.routingId);
         if (event.nativeEvent === ZLinkSocketNativeEventType.ConnectionReady) {
           // This single-endpoint DEALER also receives its disconnected ready-count snapshot.
-          if (event.value === 0n || connection.terminationRequested) return;
+          if (event.value === 0n) return;
           connection.physicalConnectionId = Symbol(connectionId);
           connection.admissionAttempt = undefined;
           for (const currentCallbacks of [...connection.callbacksByAlias.values()]) {
@@ -451,47 +494,32 @@ export class ZLinkChannelSocketRegistry {
           event.nativeEvent === ZLinkSocketNativeEventType.HandshakeFailedProtocol ||
           event.nativeEvent === ZLinkSocketNativeEventType.HandshakeFailedAuth
         ) {
-          if (
-            connection.terminationRequested &&
-            (event.remoteAddr !== connection.endpoint ||
-              (event.nativeEvent !== ZLinkSocketNativeEventType.Disconnected &&
-                event.nativeEvent !== ZLinkSocketNativeEventType.Closed))
-          )
-            return;
-          connection.physicalConnectionId = Symbol(connectionId);
-          connection.admissionAttempt = undefined;
-          if (connection.readyConnectionId !== undefined) {
-            this.removeReadyConnection(connection.readyConnectionId);
-          }
-          for (const currentCallbacks of [...connection.callbacksByAlias.values()]) {
-            currentCallbacks.onTerminated(routingId, event.remoteAddr);
-          }
-          if (connection.terminationRequested) {
-            connection.terminationRequested = false;
-            // Explicit disconnect removes intent; restore it once after this endpoint closes.
-            connection.dealer.connect(connection.endpoint);
-          }
+          // Core owns the endpoint reconnect (transport liveness §6); the
+          // connect intent stays and the next READY starts a new admission.
+          this.endClientServerAdmission(connectionId, connection, routingId, event.remoteAddr);
         }
       });
       dealer.connect(endpoint);
+      return dealer;
     } catch (error) {
       this.clientServerConnections.delete(connectionId);
-      this.ownedMonitors.delete(monitor);
-      try {
-        readablePoller.dispose();
-      } finally {
-        cleanupDealer();
-        void Promise.allSettled([monitor.dispose()]);
-      }
+      this.unregisterReceiveFlowSocket(dealer);
+      void Promise.allSettled(
+        created.map(async (resource) => {
+          await resource.dispose();
+          this.ownedResources.delete(resource);
+        })
+      ).then((results) => {
+        for (const result of results)
+          if (result.status === 'rejected') this.oneWayFailureSink?.(result.reason);
+      });
       throw error;
     }
-    return dealer;
   }
 
   async closeClientServerConnection(connectionId: string): Promise<void> {
     const current = this.clientServerConnections.get(connectionId);
     if (current === undefined) return;
-    this.clientServerConnections.delete(connectionId);
     current.aliases.delete(connectionId);
     current.callbacksByAlias.delete(connectionId);
     const ready = this.clientServerReadyIdentities.get(connectionId);
@@ -517,8 +545,13 @@ export class ZLinkChannelSocketRegistry {
         });
       }
     }
-    if (current.aliases.size > 0) return;
+    this.notifyClientServerTopology(current.channelName);
+    if (current.aliases.size > 0) {
+      this.clientServerConnections.delete(connectionId);
+      return;
+    }
     await this.disposeClientServerPhysical(connectionId, current);
+    this.clientServerConnections.delete(connectionId);
   }
 
   private async disposeClientServerPhysical(
@@ -528,12 +561,21 @@ export class ZLinkChannelSocketRegistry {
     try {
       current.dealer.disconnect(current.endpoint);
     } catch {
-      // Disposal below is the terminal cleanup if the transport already closed.
+      // The socket close below releases an endpoint that is already disconnected.
     }
-    this.ownedMonitors.delete(current.monitor);
     this.unregisterReceiveFlowSocket(current.dealer);
-    current.readablePoller.dispose();
-    const results = await Promise.allSettled([current.monitor.dispose(), current.dealer.dispose()]);
+    if (current.readablePoller !== undefined) {
+      current.readablePoller.dispose();
+      this.ownedResources.delete(current.readablePoller);
+      current.readablePoller = undefined;
+    }
+    const results = await Promise.allSettled([
+      current.monitor?.dispose(),
+      (async () => {
+        await current.dealer.dispose();
+        this.ownedResources.delete(current.dealer);
+      })()
+    ]);
     const errors = results
       .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
       .map((result) => result.reason);
@@ -541,6 +583,7 @@ export class ZLinkChannelSocketRegistry {
     if (errors.length > 1) {
       throw new AggregateError(errors, `ClientServer connection '${connectionId}' cleanup failed.`);
     }
+    if (current.monitor !== undefined) this.ownedResources.delete(current.monitor);
   }
 
   admitClientServerConnection(
@@ -555,6 +598,7 @@ export class ZLinkChannelSocketRegistry {
         connection.readyConnectionId
       );
       if (admitted) connection.admittedDescriptor = descriptor;
+      this.notifyClientServerTopology(descriptor.channelName);
       return admitted;
     }
     const duplicateId = [...this.clientServerReadyIdentities].find(
@@ -592,6 +636,7 @@ export class ZLinkChannelSocketRegistry {
       connection.readyConnectionId = connectionId;
       connection.admittedDescriptor = descriptor;
     }
+    this.notifyClientServerTopology(descriptor.channelName);
     return admitted;
   }
 
@@ -615,6 +660,7 @@ export class ZLinkChannelSocketRegistry {
         connection.outstandingProbeId = undefined;
       }
     }
+    this.notifyClientServerTopology(channelName);
     return removed;
   }
 
@@ -646,52 +692,60 @@ export class ZLinkChannelSocketRegistry {
     return undefined;
   }
 
-  /**
-   * Resolves a ClientServer send target, waiting when the ready candidate set is still empty, as
-   * `framework/doc/framework/common/spec/server/02-channel-transport/02-channel-messaging.ko.md` §3.2 requires: the call waits
-   * at call time for a bounded period and then fails with no-target. The bound is the shorter of
-   * the call's remaining deadline and five seconds, mirroring the .NET reference
-   * `ZLinkClientServerClientRuntime.WaitForReadyAsync`. The wait lives here because this registry
-   * owns ClientServer connections, admission and weighted selection. Sends have no per-call
-   * timeout, so they use the Channel's request timeout.
-   *
-   * The wait only observes admission that is already in flight: it never opens or reconnects a
-   * connection, so it cannot trigger the admission it waits for, and Framework startup keeps not
-   * waiting for local ClientServer admission. It applies whenever nothing is selectable, including
-   * candidate sets excluded by weight 0 or drain, because `selectClientServerDealer` filters the
-   * same way the reference `SelectReady()` does.
-   *
-   * Every attempt yields to the event loop between polls. ClientServer admission completes on the
-   * monitor drains that the backend poll timer pumps, so a synchronous wait would starve the
-   * admission it is waiting for and burn the whole bound before failing anyway. That is this
-   * execution model's form of the hazard the JVM mirror avoids by not holding the admission
-   * monitor across its sleep.
-   */
+  /** Observes discovery changes until the client DEALER admission deadline. */
   async awaitClientDealerForOutbound(
     channelName: string,
-    signal?: AbortSignal,
-    deadlineAtMs?: number
+    signal?: AbortSignal
   ): Promise<ZLinkBackendDealerSocket | undefined> {
-    const startedAtMs = performance.now();
-    const deadline = Math.min(
-      deadlineAtMs ??
-        startedAtMs +
-          (this.registration.channels.get(channelName)?.requestTimeoutMs ??
-            this.registration.requestTimeoutMs ??
-            DEFAULT_REQUEST_TIMEOUT_MS),
-      startedAtMs + CLIENT_SERVER_READY_WAIT_CAP_MS
-    );
-    for (;;) {
-      this.drainSocketMonitors();
+    throwIfAborted(signal);
+    const select = (): ZLinkBackendDealerSocket | undefined => {
       const dealer = this.clientDealerForOutbound(channelName);
       if (dealer !== undefined) return dealer;
-      const remainingMs = deadline - performance.now();
-      if (remainingMs <= 0) return undefined;
-      throwIfAborted(signal);
-      await new Promise<void>((resolve) => {
-        setTimeout(resolve, Math.min(CLIENT_SERVER_READY_POLL_INTERVAL_MS, remainingMs));
-      });
-    }
+      if (this.clientServerDiscovery.hasReadyClientServer(channelName)) {
+        throw createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.RouteNotConnected,
+          `Channel '${channelName}' has no eligible ClientServer member.`
+        );
+      }
+      return undefined;
+    };
+    const dealer = select();
+    if (dealer !== undefined) return dealer;
+    const sendTimeoutMs = configuredSendTimeoutMs(
+      this.registration.channels.get(channelName)?.client?.sendTimeoutMs
+    );
+    return new Promise((resolve, reject) => {
+      const cleanup = (): void => {
+        clearTimeout(deadline);
+        unsubscribe();
+        signal?.removeEventListener('abort', abort);
+      };
+      const abort = (): void => {
+        cleanup();
+        reject(createAbortError());
+      };
+      const changed = (error?: Error): void => {
+        try {
+          if (error !== undefined) throw error;
+          const selected = select();
+          if (selected === undefined) return;
+          cleanup();
+          resolve(selected);
+        } catch (error) {
+          cleanup();
+          reject(error);
+        }
+      };
+      const unsubscribe = this.clientServerDiscovery.onClientServerChanged(changed);
+      const deadline = setTimeout(() => {
+        cleanup();
+        resolve(undefined);
+      }, sendTimeoutMs);
+      signal?.addEventListener('abort', abort, { once: true });
+      // Registration and selection share one event-loop turn; recheck after subscribing.
+      changed();
+      if (signal?.aborted === true) abort();
+    });
   }
 
   startManualClientServerConnections(): void {
@@ -726,26 +780,41 @@ export class ZLinkChannelSocketRegistry {
     }
   }
 
-  clientServerMonitoringSource(channelName: string): ZLinkBackendSocketMonitor {
-    if (this.registration.channels.get(channelName)?.client === undefined) {
-      throw new ZLinkConfigurationException(`Channel client '${channelName}' is not registered.`);
+  clientServerMonitoringSource(channelName: string): ZLinkBackendSocketMonitor & {
+    onChange(handler: () => void): void;
+  } {
+    const channel = this.registration.channels.get(channelName);
+    if (channel?.client === undefined && channel?.server === undefined) {
+      throw new ZLinkConfigurationException(
+        `ClientServer channel '${channelName}' is not registered.`
+      );
     }
     let disposed = false;
-    let handler: ((event: ZLinkBackendSocketMonitorEvent) => void) | undefined;
+    let handler: ((event?: ZLinkBackendSocketMonitorEvent) => void) | undefined;
+    const register = (next: (event?: ZLinkBackendSocketMonitorEvent) => void): void => {
+      if (disposed) return;
+      if (handler !== undefined) {
+        this.clientServerMonitorHandlers.get(channelName)?.delete(handler);
+      }
+      handler = next;
+      let handlers = this.clientServerMonitorHandlers.get(channelName);
+      if (handlers === undefined) {
+        handlers = new Set();
+        this.clientServerMonitorHandlers.set(channelName, handlers);
+      }
+      handlers.add(next);
+    };
     return {
       nativeInstance: {},
       onEvent: (next) => {
-        if (disposed) return;
-        if (handler !== undefined) {
-          this.clientServerMonitorHandlers.get(channelName)?.delete(handler);
-        }
-        handler = next;
-        let handlers = this.clientServerMonitorHandlers.get(channelName);
-        if (handlers === undefined) {
-          handlers = new Set();
-          this.clientServerMonitorHandlers.set(channelName, handlers);
-        }
-        handlers.add(next);
+        register((event) => {
+          if (event !== undefined) next(event);
+        });
+      },
+      onChange: (next) => {
+        register((event) => {
+          if (event === undefined) next();
+        });
       },
       drain: () => 0,
       dispose: async () => {
@@ -790,10 +859,6 @@ export class ZLinkChannelSocketRegistry {
     );
   }
 
-  hasKnownClientServerTargets(channelName: string): boolean {
-    return this.clientServerDiscovery.clientServerDescriptors(channelName).length > 0;
-  }
-
   fanoutActiveTargets(channelName: string) {
     return this.clientServerDiscovery.fanoutEndpoints(channelName);
   }
@@ -836,6 +901,11 @@ export class ZLinkChannelSocketRegistry {
       this.clientServerServerDescriptors.set(channelName, descriptor);
       this.pushClientServerDescriptorUpdate(channelName, descriptor);
     }
+    this.notifyClientServerTopology(channelName);
+  }
+
+  private notifyClientServerTopology(channelName: string): void {
+    for (const handler of this.clientServerMonitorHandlers.get(channelName) ?? []) handler();
   }
 
   tryHandleClientServerControl(
@@ -883,7 +953,7 @@ export class ZLinkChannelSocketRegistry {
         received.parts.length !== 1 ||
         received.replyToken === null
       ) {
-        reply = encodeClientServerReject(1);
+        reply = encodeClientServerReject(ClientServerRejectReason.ProtocolVersionUnsupported);
       } else {
         const descriptor = this.clientServerServerDescriptors.get(channelName);
         if (
@@ -891,10 +961,10 @@ export class ZLinkChannelSocketRegistry {
           record.hello.channelName !== channelName ||
           record.hello.securityIdentity !== descriptor.securityIdentity
         ) {
-          reply = encodeClientServerReject(3);
+          reply = encodeClientServerReject(ClientServerRejectReason.AdmissionMismatch);
         } else {
           const normalizedEffectiveMaxMessageBytes = Math.min(
-            normalizedMessageLimit(router.maxMessageSize),
+            normalizeClientServerMessageLimit(router.maxMessageSize),
             record.hello.normalizedEffectiveMaxMessageBytes
           );
           reply = encodeClientServerAdmit(descriptor, normalizedEffectiveMaxMessageBytes);
@@ -929,7 +999,7 @@ export class ZLinkChannelSocketRegistry {
       this.drainClientServerControl(connectionId, connection);
       if (connection.deadlineAt === undefined) continue;
       if (nowMs >= connection.deadlineAt) {
-        this.requestClientServerEndpointTermination(connectionId, connection);
+        this.restartClientServerAdmission(connectionId, connection);
         continue;
       }
       if (connection.nextProbeAt === undefined || nowMs < connection.nextProbeAt) continue;
@@ -980,23 +1050,31 @@ export class ZLinkChannelSocketRegistry {
       );
     }
     const subscriber = this.adapter.createSubscriberSocket(this.context);
-    subscriber.setChannelName(channelName);
-    setFanoutSubscriptions(subscriber, channel.subscriptions);
-    const monitor = this.monitoringAdapter.openSocketMonitor(subscriber);
     const connection: FanoutPublisherConnection = {
       channelName,
       endpoint,
       subscriber,
-      monitor,
       callbacks,
       physicalConnectionId: Symbol(connectionId),
       transportReady: false,
       ready: false
     };
-    this.fanoutConnections.set(connectionId, connection);
-    this.ownedMonitors.add(monitor);
-    this.ensureClientServerLivenessTimer();
+    this.ownedResources.add(subscriber);
+    const created: (
+      | ZLinkBackendSocketMonitor
+      | ZLinkBackendReadablePoller
+      | ZLinkBackendDealerSocket
+      | ZLinkBackendSubscriberSocket
+    )[] = [subscriber];
     try {
+      this.fanoutConnections.set(connectionId, connection);
+      subscriber.setChannelName(channelName);
+      setFanoutSubscriptions(subscriber, channel.subscriptions);
+      const monitor = this.monitoringAdapter.openSocketMonitor(subscriber);
+      connection.monitor = monitor;
+      created.push(monitor);
+      this.ownedResources.add(monitor);
+      this.ensureClientServerLivenessTimer();
       monitor.onEvent((event) => {
         if (this.fanoutConnections.get(connectionId) !== connection) return;
         for (const handler of this.fanoutMonitorHandlers.get(channelName) ?? []) {
@@ -1020,28 +1098,36 @@ export class ZLinkChannelSocketRegistry {
         }
       });
       subscriber.connect(endpoint);
+      return subscriber;
     } catch (error) {
       this.fanoutConnections.delete(connectionId);
-      this.ownedMonitors.delete(monitor);
-      void Promise.allSettled([monitor.dispose(), subscriber.dispose()]);
+      void Promise.allSettled(
+        created.map(async (resource) => {
+          await resource.dispose();
+          this.ownedResources.delete(resource);
+        })
+      ).then((results) => {
+        for (const result of results)
+          if (result.status === 'rejected') this.oneWayFailureSink?.(result.reason);
+      });
       throw error;
     }
-    return subscriber;
   }
 
   async closeFanoutSubscriberConnection(connectionId: string): Promise<void> {
     const connection = this.fanoutConnections.get(connectionId);
     if (connection === undefined) return;
-    this.fanoutConnections.delete(connectionId);
     try {
       connection.subscriber.disconnect(connection.endpoint);
     } catch {
-      // Disposal remains the terminal cleanup path.
+      // The socket close below releases an endpoint that is already disconnected.
     }
-    this.ownedMonitors.delete(connection.monitor);
     const results = await Promise.allSettled([
-      connection.monitor.dispose(),
-      connection.subscriber.dispose()
+      connection.monitor?.dispose(),
+      (async () => {
+        await connection.subscriber.dispose();
+        this.ownedResources.delete(connection.subscriber);
+      })()
     ]);
     const errors = results
       .filter((result): result is PromiseRejectedResult => result.status === 'rejected')
@@ -1050,6 +1136,8 @@ export class ZLinkChannelSocketRegistry {
     if (errors.length > 1) {
       throw new AggregateError(errors, `Fanout connection '${connectionId}' cleanup failed.`);
     }
+    this.fanoutConnections.delete(connectionId);
+    if (connection.monitor !== undefined) this.ownedResources.delete(connection.monitor);
   }
 
   handleFanoutInbound(
@@ -1170,7 +1258,7 @@ export class ZLinkChannelSocketRegistry {
     };
   }
 
-  private notifyFanoutTopology(channelName: string): void {
+  notifyFanoutTopology(channelName: string): void {
     for (const handler of this.fanoutTopologyHandlers.get(channelName) ?? []) {
       try {
         handler();
@@ -1298,9 +1386,8 @@ export class ZLinkChannelSocketRegistry {
     connectionId: string,
     connection: ClientServerPhysicalConnection
   ): void {
-    if (connection.terminationRequested) return;
     for (;;) {
-      if (!connection.readablePoller.wait(0)) return;
+      if (connection.readablePoller === undefined || !connection.readablePoller.wait(0)) return;
       const received = connection.dealer.recv(1);
       if (received === undefined) {
         connection.readablePoller.markDrained();
@@ -1331,7 +1418,7 @@ export class ZLinkChannelSocketRegistry {
         }
         this.applyClientServerDescriptorUpdate(connectionId, connection, record.admission);
       } catch (error) {
-        this.requestClientServerEndpointTermination(connectionId, connection);
+        this.restartClientServerAdmission(connectionId, connection);
         this.oneWayFailureSink?.(error);
         return;
       } finally {
@@ -1340,19 +1427,39 @@ export class ZLinkChannelSocketRegistry {
     }
   }
 
-  private requestClientServerEndpointTermination(
+  /**
+   * Ends the current logical admission of this connection: later replies of
+   * the fenced attempt no longer apply and its ready target is withdrawn.
+   */
+  private endClientServerAdmission(
     connectionId: string,
-    connection: ClientServerPhysicalConnection
+    connection: ClientServerPhysicalConnection,
+    routingId: string | undefined,
+    endpoint: string
   ): void {
-    if (connection.terminationRequested) return;
-    connection.terminationRequested = true;
     connection.physicalConnectionId = Symbol(connectionId);
     connection.admissionAttempt = undefined;
-    this.removeReadyConnection(connectionId);
-    try {
-      connection.dealer.disconnect(connection.endpoint);
-    } catch (error) {
-      this.oneWayFailureSink?.(error);
+    if (connection.readyConnectionId !== undefined) {
+      this.removeReadyConnection(connection.readyConnectionId);
+    }
+    for (const callbacks of [...connection.callbacksByAlias.values()]) {
+      callbacks.onTerminated(routingId, endpoint);
+    }
+  }
+
+  /**
+   * A peer deadline or an invalid pushed control ends only the current logical
+   * admission. The connect intent stays with Core, which owns the endpoint
+   * reconnect (transport liveness §6); the service handshake starts again on
+   * the existing admission path.
+   */
+  private restartClientServerAdmission(
+    connectionId: string,
+    connection: ClientServerPhysicalConnection
+  ): void {
+    this.endClientServerAdmission(connectionId, connection, undefined, connection.endpoint);
+    for (const callbacks of [...connection.callbacksByAlias.values()]) {
+      callbacks.onTransportReady('', connection.endpoint);
     }
   }
 
@@ -1412,12 +1519,15 @@ export class ZLinkChannelSocketRegistry {
 
   private ensureClientServerLivenessTimer(): void {
     if (this.clientServerLivenessTimer !== undefined) return;
-    this.clientServerLivenessTimer = setInterval(() => this.tickClientServerLiveness(), 100);
+    this.clientServerLivenessTimer = setInterval(
+      () => this.tickClientServerLiveness(),
+      CLIENT_SERVER_LIVENESS_TICK_MS
+    );
     this.clientServerLivenessTimer.unref();
   }
 
   private drainSocketMonitors(): void {
-    for (const monitor of this.ownedMonitors) monitor.drain();
+    for (const monitor of this.ownedResources) if ('drain' in monitor) monitor.drain();
   }
 
   private removeReadyConnection(connectionId: string): void {
@@ -1438,6 +1548,7 @@ export class ZLinkChannelSocketRegistry {
       connection.nextProbeAt = undefined;
       connection.outstandingProbeId = undefined;
     }
+    this.notifyClientServerTopology(identity.channelName);
   }
 
   private requestClientServerLiveness(
@@ -1585,7 +1696,7 @@ export class ZLinkChannelSocketRegistry {
 
   private allocateClientServerProbeId(): bigint {
     const result = this.nextClientServerProbeId;
-    this.nextClientServerProbeId = result === 0xffff_ffff_ffff_ffffn ? 1n : result + 1n;
+    this.nextClientServerProbeId = result === UINT64_MAX ? 1n : result + 1n;
     return result;
   }
 
@@ -1608,10 +1719,17 @@ export class ZLinkChannelSocketRegistry {
     }
 
     const publisher = this.adapter.createPublisherSocket(this.context);
+    this.publishers.set(channelName, publisher);
     publisher.setChannelName(channelName);
     applyFanoutPublisherSocketOptions(publisher, channel);
     publisher.bind(channel.publisher.bind);
-    this.publishers.set(channelName, publisher);
+    const endpoint = buildAdvertisedEndpoint(
+      publisher.lastEndpoint ?? channel.publisher.bind,
+      channel.publisher.advertiseHost
+    );
+    if (endpoint !== undefined && endpoint.length > 0) {
+      this.recordListener('fanout', channelName, endpoint);
+    }
     this.fanoutPublisherNextBeacon.set(
       channelName,
       performance.now() + CLIENT_SERVER_PROBE_INTERVAL_MS
@@ -1620,20 +1738,6 @@ export class ZLinkChannelSocketRegistry {
     return publisher;
   }
 
-  fanoutPublisherEndpoint(channelName: string): string | undefined {
-    const channel = this.registration.channels.get(channelName);
-    const publisher = this.publishers.get(channelName);
-    const boundEndpoint = publisher?.lastEndpoint;
-    if (
-      channel?.publisher === undefined ||
-      boundEndpoint === undefined ||
-      boundEndpoint.length === 0
-    ) {
-      return undefined;
-    }
-    return advertisedEndpoint(boundEndpoint, channel.publisher.advertiseHost);
-  }
-
   routeRouter(routerChannelId: string): ZLinkBackendRouterSocket {
     const existing = this.routeRouters.get(routerChannelId);
     if (existing !== undefined) {
@@ -1647,6 +1751,7 @@ export class ZLinkChannelSocketRegistry {
       );
     }
     const router = this.adapter.createRouterSocket(this.context);
+    this.routeRouters.set(routerChannelId, router);
     this.registerReceiveFlowSocket(router);
     router.setChannelName(routerChannelId);
     if (
@@ -1658,7 +1763,7 @@ export class ZLinkChannelSocketRegistry {
     router.setRoutingId(
       routeChannel.routingId ?? `${routeChannel.routingIdPrefix ?? routerChannelId}-${randomUUID()}`
     );
-    const publicWeight = routeChannel.weight ?? 100;
+    const publicWeight = routeChannel.weight ?? ZLINK_DEFAULT_PUBLIC_WEIGHT;
     this.routeMeshPublicWeights.set(routerChannelId, publicWeight);
     router.peerWeight = rawAvailabilityWeight(publicWeight);
     applySocketConfig(router, routeChannel);
@@ -1672,7 +1777,6 @@ export class ZLinkChannelSocketRegistry {
     if (routeChannel.bind !== undefined && routeChannel.bind.trim().length > 0) {
       router.bind(routeChannel.bind);
     }
-    this.routeRouters.set(routerChannelId, router);
     return router;
   }
 
@@ -1682,7 +1786,7 @@ export class ZLinkChannelSocketRegistry {
 
   routeMeshWeight(routerChannelId: string): number {
     this.routeRouter(routerChannelId);
-    return this.routeMeshPublicWeights.get(routerChannelId) ?? 100;
+    return this.routeMeshPublicWeights.get(routerChannelId) ?? ZLINK_DEFAULT_PUBLIC_WEIGHT;
   }
 
   setRouteMeshWeight(routerChannelId: string, weight: number): void {
@@ -1719,7 +1823,7 @@ export class ZLinkChannelSocketRegistry {
       return;
     }
     const monitor = this.monitoringAdapter.openSocketMonitor(socket);
-    this.ownedMonitors.add(monitor);
+    this.ownedResources.add(monitor);
     monitor.onEvent((event) => {
       if (
         event.nativeEvent === ZLinkSocketNativeEventType.Disconnected &&
@@ -1735,7 +1839,7 @@ export class ZLinkChannelSocketRegistry {
       return;
     }
     const monitor = this.monitoringAdapter.openSocketMonitor(router);
-    this.ownedMonitors.add(monitor);
+    this.ownedResources.add(monitor);
     monitor.onEvent((event) => {
       const routingId = event.routingId === undefined ? undefined : String(event.routingId);
       if (
@@ -1777,7 +1881,7 @@ async function requestClientServerAdmission(
     encodeClientServerHello({
       channelName,
       securityIdentity,
-      normalizedEffectiveMaxMessageBytes: normalizedMessageLimit(dealer.maxMessageSize)
+      normalizedEffectiveMaxMessageBytes: normalizeClientServerMessageLimit(dealer.maxMessageSize)
     })
   );
   try {
@@ -1855,9 +1959,9 @@ function setFanoutSubscriptions(
 
 function deriveRoutingId(baseRoutingId: string, suffix: string): string {
   const derived = `${baseRoutingId}\0${suffix}`;
-  if (Buffer.byteLength(derived, 'utf8') > 255) {
+  if (Buffer.byteLength(derived, 'utf8') > ZLINK_MAX_ROUTING_ID_BYTES) {
     throw new ZLinkConfigurationException(
-      `Derived routing id with suffix '${suffix}' exceeds the 255 byte limit.`
+      `Derived routing id with suffix '${suffix}' exceeds the ${ZLINK_MAX_ROUTING_ID_BYTES} byte limit.`
     );
   }
   return derived;
@@ -1868,6 +1972,7 @@ function applyFanoutPublisherSocketOptions(
   channel: ZLinkChannelOptions
 ): void {
   publisher.noDrop = channel.noDrop ?? false;
+  publisher.sendTimeoutMs = configuredSendTimeoutMs(channel.publisher?.sendTimeoutMs);
 }
 
 function fanoutDiscoveryConnectionId(connectionId: string): string {
@@ -1891,13 +1996,11 @@ function advertisedEndpoint(boundEndpoint: string, advertiseHost: string | undef
   return result;
 }
 
-function normalizedMessageLimit(value: number): number {
-  return Number.isSafeInteger(value) && value > 0 ? Math.min(value, 0xffff_ffff) : 0x7fff_ffff;
-}
-
 function requirePublicWeight(weight: number): void {
-  if (!Number.isInteger(weight) || weight < 0 || weight > 10_000) {
-    throw new ZLinkConfigurationException('Weight must be an integer in 0..10000.');
+  if (!isValidPublicWeight(weight)) {
+    throw new ZLinkConfigurationException(
+      `Weight must be an integer in 0..${ZLINK_MAX_PUBLIC_WEIGHT}.`
+    );
   }
 }
 
@@ -1933,3 +2036,7 @@ function applySocketConfig(
     socket.maxMessageSize = config.maxMessageSize;
   }
 }
+
+function configuredSendTimeoutMs(value: number | undefined): number {
+  return value ?? DEFAULT_SEND_TIMEOUT_MS;
+}