@zlink-systems/framework 0.25.0 → 0.27.0

package/dist/runtime/channels/channel-socket-registry.js

@@ -1,27 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkChannelSocketRegistry = void 0;
+const disposal_1 = require("../disposal");
+const stream_wire_1 = require("@zlink-systems/stream-wire");
+const node_crypto_1 = require("node:crypto");
 const contracts_1 = require("../../contracts");
-const internal_event_contracts_1 = require("../diagnostics/internal-event-contracts");
-const configuration_1 = require("../configuration");
-const abort_1 = require("../abort");
+const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
+const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
 const RuntimeEndpointConnections_1 = require("../../contracts/Configuration/RuntimeEndpointConnections");
-const route_member_snapshot_1 = require("./route-member-snapshot");
-const framework_errors_internal_1 = require("../framework-errors-internal");
-const node_crypto_1 = require("node:crypto");
+const abort_1 = require("../abort");
 const runtime_message_1 = require("../backend/runtime-message");
-const service_discovery_registry_1 = require("../foundation/service-discovery-registry");
+const runtime_values_1 = require("../backend/runtime-values");
+const configuration_1 = require("../configuration");
+const internal_event_contracts_1 = require("../diagnostics/internal-event-contracts");
+const listener_records_1 = require("../foundation/listener-records");
 const runtime_state_projections_1 = require("../foundation/runtime-state-projections");
+const service_discovery_registry_1 = require("../foundation/service-discovery-registry");
+const service_liveness_registry_1 = require("../foundation/service-liveness-registry");
 const service_wire_m6a_codec_1 = require("../foundation/service-wire-m6a-codec");
+const framework_errors_internal_1 = require("../framework-errors-internal");
 const client_server_service_wire_1 = require("./client-server-service-wire");
 const fanout_service_wire_1 = require("./fanout-service-wire");
-const runtime_values_1 = require("../backend/runtime-values");
+const route_member_snapshot_1 = require("./route-member-snapshot");
 const MAX_LIFECYCLE_GENERATION = 0x7fffffffffffffffn;
-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 = service_liveness_registry_1.DEFAULT_SERVICE_PROBE_INTERVAL_MS;
+const CLIENT_SERVER_PEER_DEADLINE_MS = service_liveness_registry_1.DEFAULT_SERVICE_PEER_TIMEOUT_MS;
+const CLIENT_SERVER_LIVENESS_TICK_MS = 100;
+const DEFAULT_SEND_TIMEOUT_MS = 1_000;
 class ZLinkChannelSocketRegistry {
     registration;
     adapter;
@@ -43,7 +48,8 @@ class ZLinkChannelSocketRegistry {
     routeMeshPublicWeights = new Map();
     clientServerAdmittedClients = new Map();
     clientServerServerPeers = new Map();
-    ownedMonitors = new Set();
+    disposal = new disposal_1.RuntimeDisposal();
+    ownedResources = new Set();
     fanoutConnections = new Map();
     fanoutPublisherNextBeacon = new Map();
     clientServerLivenessTimer;
@@ -51,17 +57,23 @@ class ZLinkChannelSocketRegistry {
     clientServerMonitorHandlers = new Map();
     fanoutMonitorHandlers = new Map();
     fanoutTopologyHandlers = new Map();
-    constructor(registration, adapter, context, monitoringAdapter, oneWayFailureSink, applicationJobQueue) {
+    listenerRecords;
+    constructor(registration, adapter, context, monitoringAdapter, oneWayFailureSink, applicationJobQueue, listenerRecords) {
         this.registration = registration;
         this.adapter = adapter;
         this.context = context;
         this.monitoringAdapter = monitoringAdapter;
         this.oneWayFailureSink = oneWayFailureSink;
         this.applicationJobQueue = applicationJobQueue;
+        this.listenerRecords = listenerRecords ?? new listener_records_1.ZLinkListenerRecords();
     }
-    async dispose() {
+    dispose() {
+        return this.disposal.run(() => this.disposeCore());
+    }
+    async disposeCore() {
+        this.clientServerDiscovery.dispose((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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(),
             ...clientServerConnections.map((value) => value.dealer),
@@ -77,8 +89,6 @@ class ZLinkChannelSocketRegistry {
             ...this.routeRouters.values()
         ]))
             this.unregisterReceiveFlowSocket(socket);
-        this.clientDealers.clear();
-        this.clientServerConnections.clear();
         this.clientServerReadyIdentities.clear();
         this.clientServerServerDescriptors.clear();
         this.clientServerPublicWeights.clear();
@@ -88,23 +98,40 @@ 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);
+            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.status === 'rejected')
             .map((result) => result.reason);
@@ -124,13 +151,16 @@ class ZLinkChannelSocketRegistry {
             throw new configuration_1.ZLinkConfigurationException(`Channel client '${channelName}' is not registered.`);
         }
         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;
     }
     channelRouter(channelName) {
@@ -146,6 +176,7 @@ class ZLinkChannelSocketRegistry {
             throw new configuration_1.ZLinkConfigurationException(`Channel server '${channelName}' does not define a bind endpoint.`);
         }
         const router = this.adapter.createRouterSocket(this.context);
+        this.channelRouters.set(channelName, router);
         this.registerReceiveFlowSocket(router);
         router.setChannelName(channelName);
         const identity = this.clientServerIdentities.get(channelName) ?? {
@@ -154,14 +185,14 @@ class ZLinkChannelSocketRegistry {
         };
         this.clientServerIdentities.set(channelName, identity);
         router.setRoutingId(identity.serverRid);
-        const publicWeight = channel.server.weight ?? 100;
+        const publicWeight = channel.server.weight ?? RegistrationBuilderPolicy_1.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;
@@ -176,15 +207,15 @@ 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: contracts_1.ZLinkFrameworkRuntimeState.Serving,
                 securityIdentity: 'default',
@@ -196,27 +227,26 @@ class ZLinkChannelSocketRegistry {
         return router;
     }
     clientServerServerIdentity(channelName) {
-        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 configuration_1.ZLinkConfigurationException(`Channel server '${channelName}' is not registered.`);
         }
-        const boundEndpoint = router.lastEndpoint ?? channel.server.bind;
-        if (boundEndpoint === undefined || boundEndpoint.length === 0) {
-            throw new configuration_1.ZLinkConfigurationException(`Channel server '${channelName}' did not report its bound endpoint.`);
-        }
-        return {
-            ...identity,
-            endpoint: advertisedEndpoint(boundEndpoint, channel.server.advertiseHost)
-        };
+        return { ...identity, endpoint };
+    }
+    fanoutPublisherEndpoint(channelName) {
+        return this.listenerRecords.endpoint('fanout', channelName);
+    }
+    recordListener(kind, name, endpoint) {
+        this.listenerRecords.record(kind, name, endpoint);
     }
     clientServerServerSocket(channelName) {
         return this.channelRouter(channelName);
     }
     clientServerServerWeight(channelName) {
         this.channelRouter(channelName);
-        return this.clientServerPublicWeights.get(channelName) ?? 100;
+        return this.clientServerPublicWeights.get(channelName) ?? RegistrationBuilderPolicy_1.ZLINK_DEFAULT_PUBLIC_WEIGHT;
     }
     setClientServerServerWeight(channelName, weight) {
         requirePublicWeight(weight);
@@ -237,50 +267,33 @@ class ZLinkChannelSocketRegistry {
             throw new configuration_1.ZLinkConfigurationException(`Channel client '${channelName}' is not registered.`);
         }
         const dealer = this.adapter.createDealerSocket(this.context);
-        this.registerReceiveFlowSocket(dealer);
-        dealer.setChannelName(channelName);
-        dealer.setRoutingId(`cs-client-${(0, node_crypto_1.randomUUID)()}`);
-        applySocketConfig(dealer, client);
-        const cleanupDealer = () => {
-            this.unregisterReceiveFlowSocket(dealer);
-            void Promise.allSettled([dealer.dispose()]);
-        };
-        let readablePoller;
-        try {
-            readablePoller = this.adapter.createReadablePoller(dealer);
-        }
-        catch (error) {
-            cleanupDealer();
-            throw error;
-        }
-        let monitor;
-        try {
-            monitor = this.monitoringAdapter.openSocketMonitor(dealer);
-        }
-        catch (error) {
-            try {
-                readablePoller.dispose();
-            }
-            finally {
-                cleanupDealer();
-            }
-            throw error;
-        }
-        this.ownedMonitors.add(monitor);
         const connection = {
             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 = [dealer];
         try {
+            this.clientServerConnections.set(connectionId, connection);
+            this.registerReceiveFlowSocket(dealer);
+            dealer.setChannelName(channelName);
+            dealer.setRoutingId(`cs-client-${(0, node_crypto_1.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((alias) => this.clientServerConnections.get(alias) === connection))
                     return;
@@ -290,7 +303,7 @@ class ZLinkChannelSocketRegistry {
                 const routingId = event.routingId === undefined ? undefined : String(event.routingId);
                 if (event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.ConnectionReady) {
                     // This single-endpoint DEALER also receives its disconnected ready-count snapshot.
-                    if (event.value === 0n || connection.terminationRequested)
+                    if (event.value === 0n)
                         return;
                     connection.physicalConnectionId = Symbol(connectionId);
                     connection.admissionAttempt = undefined;
@@ -304,47 +317,32 @@ class ZLinkChannelSocketRegistry {
                     event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.HandshakeFailedNoDetail ||
                     event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.HandshakeFailedProtocol ||
                     event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.HandshakeFailedAuth) {
-                    if (connection.terminationRequested &&
-                        (event.remoteAddr !== connection.endpoint ||
-                            (event.nativeEvent !== internal_event_contracts_1.ZLinkSocketNativeEventType.Disconnected &&
-                                event.nativeEvent !== internal_event_contracts_1.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) {
         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);
@@ -364,21 +362,34 @@ class ZLinkChannelSocketRegistry {
                 });
             }
         }
-        if (current.aliases.size > 0)
+        this.notifyClientServerTopology(current.channelName);
+        if (current.aliases.size > 0) {
+            this.clientServerConnections.delete(connectionId);
             return;
+        }
         await this.disposeClientServerPhysical(connectionId, current);
+        this.clientServerConnections.delete(connectionId);
     }
     async disposeClientServerPhysical(connectionId, current) {
         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.status === 'rejected')
             .map((result) => result.reason);
@@ -387,6 +398,8 @@ 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(descriptor, connectionId) {
         const connection = this.clientServerConnections.get(connectionId);
@@ -396,6 +409,7 @@ class ZLinkChannelSocketRegistry {
             const admitted = this.clientServerDiscovery.admitClientServer(descriptor, connection.readyConnectionId);
             if (admitted)
                 connection.admittedDescriptor = descriptor;
+            this.notifyClientServerTopology(descriptor.channelName);
             return admitted;
         }
         const duplicateId = [...this.clientServerReadyIdentities].find(([, identity]) => identity.channelName === descriptor.channelName &&
@@ -429,6 +443,7 @@ class ZLinkChannelSocketRegistry {
             connection.readyConnectionId = connectionId;
             connection.admittedDescriptor = descriptor;
         }
+        this.notifyClientServerTopology(descriptor.channelName);
         return admitted;
     }
     removeClientServerReady(channelName, serverRoutingId, connectionId) {
@@ -443,6 +458,7 @@ class ZLinkChannelSocketRegistry {
                 connection.outstandingProbeId = undefined;
             }
         }
+        this.notifyClientServerTopology(channelName);
         return removed;
     }
     selectClientServerDealer(channelName) {
@@ -466,47 +482,58 @@ 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.
-     */
-    async awaitClientDealerForOutbound(channelName, signal, deadlineAtMs) {
-        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();
+    /** Observes discovery changes until the client DEALER admission deadline. */
+    async awaitClientDealerForOutbound(channelName, signal) {
+        (0, abort_1.throwIfAborted)(signal);
+        const select = () => {
             const dealer = this.clientDealerForOutbound(channelName);
             if (dealer !== undefined)
                 return dealer;
-            const remainingMs = deadline - performance.now();
-            if (remainingMs <= 0)
-                return undefined;
-            (0, abort_1.throwIfAborted)(signal);
-            await new Promise((resolve) => {
-                setTimeout(resolve, Math.min(CLIENT_SERVER_READY_POLL_INTERVAL_MS, remainingMs));
-            });
-        }
+            if (this.clientServerDiscovery.hasReadyClientServer(channelName)) {
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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 = () => {
+                clearTimeout(deadline);
+                unsubscribe();
+                signal?.removeEventListener('abort', abort);
+            };
+            const abort = () => {
+                cleanup();
+                reject((0, abort_1.createAbortError)());
+            };
+            const changed = (error) => {
+                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() {
         for (const [channelName, channel] of this.registration.channels) {
@@ -535,26 +562,39 @@ class ZLinkChannelSocketRegistry {
         }
     }
     clientServerMonitoringSource(channelName) {
-        if (this.registration.channels.get(channelName)?.client === undefined) {
-            throw new configuration_1.ZLinkConfigurationException(`Channel client '${channelName}' is not registered.`);
+        const channel = this.registration.channels.get(channelName);
+        if (channel?.client === undefined && channel?.server === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`ClientServer channel '${channelName}' is not registered.`);
         }
         let disposed = false;
         let handler;
+        const register = (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);
+        };
         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 () => {
@@ -588,9 +628,6 @@ class ZLinkChannelSocketRegistry {
                 ? 1
                 : 0);
     }
-    hasKnownClientServerTargets(channelName) {
-        return this.clientServerDiscovery.clientServerDescriptors(channelName).length > 0;
-    }
     fanoutActiveTargets(channelName) {
         return this.clientServerDiscovery.fanoutEndpoints(channelName);
     }
@@ -622,6 +659,11 @@ class ZLinkChannelSocketRegistry {
             this.clientServerServerDescriptors.set(channelName, descriptor);
             this.pushClientServerDescriptorUpdate(channelName, descriptor);
         }
+        this.notifyClientServerTopology(channelName);
+    }
+    notifyClientServerTopology(channelName) {
+        for (const handler of this.clientServerMonitorHandlers.get(channelName) ?? [])
+            handler();
     }
     tryHandleClientServerControl(channelName, received, router) {
         if (received.parts.length === 0)
@@ -648,17 +690,17 @@ class ZLinkChannelSocketRegistry {
             else if (record.kind !== 'hello' ||
                 received.parts.length !== 1 ||
                 received.replyToken === null) {
-                reply = (0, client_server_service_wire_1.encodeClientServerReject)(1);
+                reply = (0, client_server_service_wire_1.encodeClientServerReject)(client_server_service_wire_1.ClientServerRejectReason.ProtocolVersionUnsupported);
             }
             else {
                 const descriptor = this.clientServerServerDescriptors.get(channelName);
                 if (descriptor === undefined ||
                     record.hello.channelName !== channelName ||
                     record.hello.securityIdentity !== descriptor.securityIdentity) {
-                    reply = (0, client_server_service_wire_1.encodeClientServerReject)(3);
+                    reply = (0, client_server_service_wire_1.encodeClientServerReject)(client_server_service_wire_1.ClientServerRejectReason.AdmissionMismatch);
                 }
                 else {
-                    const normalizedEffectiveMaxMessageBytes = Math.min(normalizedMessageLimit(router.maxMessageSize), record.hello.normalizedEffectiveMaxMessageBytes);
+                    const normalizedEffectiveMaxMessageBytes = Math.min((0, client_server_service_wire_1.normalizeClientServerMessageLimit)(router.maxMessageSize), record.hello.normalizedEffectiveMaxMessageBytes);
                     reply = (0, client_server_service_wire_1.encodeClientServerAdmit)(descriptor, normalizedEffectiveMaxMessageBytes);
                     this.admitClientServerServerPeer(channelName, String(received.routingId), normalizedEffectiveMaxMessageBytes);
                 }
@@ -689,7 +731,7 @@ class ZLinkChannelSocketRegistry {
             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)
@@ -732,23 +774,26 @@ class ZLinkChannelSocketRegistry {
             throw new configuration_1.ZLinkConfigurationException(`Fanout subscriber '${channelName}' is not registered.`);
         }
         const subscriber = this.adapter.createSubscriberSocket(this.context);
-        subscriber.setChannelName(channelName);
-        setFanoutSubscriptions(subscriber, channel.subscriptions);
-        const monitor = this.monitoringAdapter.openSocketMonitor(subscriber);
         const connection = {
             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 = [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;
@@ -771,30 +816,37 @@ 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) {
         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.status === 'rejected')
@@ -804,6 +856,9 @@ 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(connectionId, topicMessage, source, nowMs = performance.now()) {
         return this.handleFanoutInboundResult(connectionId, topicMessage, source, nowMs).consumed;
@@ -993,10 +1048,8 @@ class ZLinkChannelSocketRegistry {
         }
     }
     drainClientServerControl(connectionId, connection) {
-        if (connection.terminationRequested)
-            return;
         for (;;) {
-            if (!connection.readablePoller.wait(0))
+            if (connection.readablePoller === undefined || !connection.readablePoller.wait(0))
                 return;
             const received = connection.dealer.recv(1);
             if (received === undefined) {
@@ -1025,7 +1078,7 @@ class ZLinkChannelSocketRegistry {
                 this.applyClientServerDescriptorUpdate(connectionId, connection, record.admission);
             }
             catch (error) {
-                this.requestClientServerEndpointTermination(connectionId, connection);
+                this.restartClientServerAdmission(connectionId, connection);
                 this.oneWayFailureSink?.(error);
                 return;
             }
@@ -1034,18 +1087,30 @@ class ZLinkChannelSocketRegistry {
             }
         }
     }
-    requestClientServerEndpointTermination(connectionId, connection) {
-        if (connection.terminationRequested)
-            return;
-        connection.terminationRequested = true;
+    /**
+     * Ends the current logical admission of this connection: later replies of
+     * the fenced attempt no longer apply and its ready target is withdrawn.
+     */
+    endClientServerAdmission(connectionId, connection, routingId, endpoint) {
         connection.physicalConnectionId = Symbol(connectionId);
         connection.admissionAttempt = undefined;
-        this.removeReadyConnection(connectionId);
-        try {
-            connection.dealer.disconnect(connection.endpoint);
+        if (connection.readyConnectionId !== undefined) {
+            this.removeReadyConnection(connection.readyConnectionId);
         }
-        catch (error) {
-            this.oneWayFailureSink?.(error);
+        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.
+     */
+    restartClientServerAdmission(connectionId, connection) {
+        this.endClientServerAdmission(connectionId, connection, undefined, connection.endpoint);
+        for (const callbacks of [...connection.callbacksByAlias.values()]) {
+            callbacks.onTransportReady('', connection.endpoint);
         }
     }
     applyClientServerDescriptorUpdate(connectionId, connection, admission) {
@@ -1088,12 +1153,13 @@ class ZLinkChannelSocketRegistry {
     ensureClientServerLivenessTimer() {
         if (this.clientServerLivenessTimer !== undefined)
             return;
-        this.clientServerLivenessTimer = setInterval(() => this.tickClientServerLiveness(), 100);
+        this.clientServerLivenessTimer = setInterval(() => this.tickClientServerLiveness(), CLIENT_SERVER_LIVENESS_TICK_MS);
         this.clientServerLivenessTimer.unref();
     }
     drainSocketMonitors() {
-        for (const monitor of this.ownedMonitors)
-            monitor.drain();
+        for (const monitor of this.ownedResources)
+            if ('drain' in monitor)
+                monitor.drain();
     }
     removeReadyConnection(connectionId) {
         const identity = this.clientServerReadyIdentities.get(connectionId);
@@ -1110,6 +1176,7 @@ class ZLinkChannelSocketRegistry {
             connection.nextProbeAt = undefined;
             connection.outstandingProbeId = undefined;
         }
+        this.notifyClientServerTopology(identity.channelName);
     }
     requestClientServerLiveness(connectionId, connection, probeId) {
         const message = runtime_message_1.ZLinkBufferMessage.from((0, client_server_service_wire_1.encodeClientServerLivenessProbe)(probeId));
@@ -1203,7 +1270,7 @@ class ZLinkChannelSocketRegistry {
     }
     allocateClientServerProbeId() {
         const result = this.nextClientServerProbeId;
-        this.nextClientServerProbeId = result === 0xffffffffffffffffn ? 1n : result + 1n;
+        this.nextClientServerProbeId = result === stream_wire_1.UINT64_MAX ? 1n : result + 1n;
         return result;
     }
     publisher(channelName) {
@@ -1219,25 +1286,18 @@ class ZLinkChannelSocketRegistry {
             throw new configuration_1.ZLinkConfigurationException(`Channel publisher '${channelName}' does not define a bind endpoint.`);
         }
         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 = (0, configuration_1.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);
         this.ensureClientServerLivenessTimer();
         return publisher;
     }
-    fanoutPublisherEndpoint(channelName) {
-        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) {
         const existing = this.routeRouters.get(routerChannelId);
         if (existing !== undefined) {
@@ -1248,6 +1308,7 @@ class ZLinkChannelSocketRegistry {
             throw new configuration_1.ZLinkConfigurationException(`Route channel '${routerChannelId}' is not registered.`);
         }
         const router = this.adapter.createRouterSocket(this.context);
+        this.routeRouters.set(routerChannelId, router);
         this.registerReceiveFlowSocket(router);
         router.setChannelName(routerChannelId);
         if ((routeChannel.manualConnections?.length ?? 0) > 0 &&
@@ -1255,7 +1316,7 @@ class ZLinkChannelSocketRegistry {
             router.setProbe(true);
         }
         router.setRoutingId(routeChannel.routingId ?? `${routeChannel.routingIdPrefix ?? routerChannelId}-${(0, node_crypto_1.randomUUID)()}`);
-        const publicWeight = routeChannel.weight ?? 100;
+        const publicWeight = routeChannel.weight ?? RegistrationBuilderPolicy_1.ZLINK_DEFAULT_PUBLIC_WEIGHT;
         this.routeMeshPublicWeights.set(routerChannelId, publicWeight);
         router.peerWeight = rawAvailabilityWeight(publicWeight);
         applySocketConfig(router, routeChannel);
@@ -1269,7 +1330,6 @@ class ZLinkChannelSocketRegistry {
         if (routeChannel.bind !== undefined && routeChannel.bind.trim().length > 0) {
             router.bind(routeChannel.bind);
         }
-        this.routeRouters.set(routerChannelId, router);
         return router;
     }
     routeMeshSocket(routerChannelId) {
@@ -1277,7 +1337,7 @@ class ZLinkChannelSocketRegistry {
     }
     routeMeshWeight(routerChannelId) {
         this.routeRouter(routerChannelId);
-        return this.routeMeshPublicWeights.get(routerChannelId) ?? 100;
+        return this.routeMeshPublicWeights.get(routerChannelId) ?? RegistrationBuilderPolicy_1.ZLINK_DEFAULT_PUBLIC_WEIGHT;
     }
     setRouteMeshWeight(routerChannelId, weight) {
         requirePublicWeight(weight);
@@ -1299,7 +1359,7 @@ class ZLinkChannelSocketRegistry {
             return;
         }
         const monitor = this.monitoringAdapter.openSocketMonitor(socket);
-        this.ownedMonitors.add(monitor);
+        this.ownedResources.add(monitor);
         monitor.onEvent((event) => {
             if (event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.Disconnected &&
                 event.remoteAddr.length > 0) {
@@ -1312,7 +1372,7 @@ 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 (event.nativeEvent === internal_event_contracts_1.ZLinkSocketNativeEventType.ConnectionReady &&
@@ -1341,7 +1401,7 @@ async function requestClientServerAdmission(dealer, channelName, securityIdentit
     const message = runtime_message_1.ZLinkBufferMessage.from((0, client_server_service_wire_1.encodeClientServerHello)({
         channelName,
         securityIdentity,
-        normalizedEffectiveMaxMessageBytes: normalizedMessageLimit(dealer.maxMessageSize)
+        normalizedEffectiveMaxMessageBytes: (0, client_server_service_wire_1.normalizeClientServerMessageLimit)(dealer.maxMessageSize)
     }));
     try {
         const parts = await dealer.request(message, timeoutMs);
@@ -1404,13 +1464,14 @@ function setFanoutSubscriptions(subscriber, applicationTopics) {
 }
 function deriveRoutingId(baseRoutingId, suffix) {
     const derived = `${baseRoutingId}\0${suffix}`;
-    if (Buffer.byteLength(derived, 'utf8') > 255) {
-        throw new configuration_1.ZLinkConfigurationException(`Derived routing id with suffix '${suffix}' exceeds the 255 byte limit.`);
+    if (Buffer.byteLength(derived, 'utf8') > CoreTypes_1.ZLINK_MAX_ROUTING_ID_BYTES) {
+        throw new configuration_1.ZLinkConfigurationException(`Derived routing id with suffix '${suffix}' exceeds the ${CoreTypes_1.ZLINK_MAX_ROUTING_ID_BYTES} byte limit.`);
     }
     return derived;
 }
 function applyFanoutPublisherSocketOptions(publisher, channel) {
     publisher.noDrop = channel.noDrop ?? false;
+    publisher.sendTimeoutMs = configuredSendTimeoutMs(channel.publisher?.sendTimeoutMs);
 }
 function fanoutDiscoveryConnectionId(connectionId) {
     return `fanout:${connectionId.replaceAll('\0', '/')}`;
@@ -1429,12 +1490,9 @@ function advertisedEndpoint(boundEndpoint, advertiseHost) {
     }
     return result;
 }
-function normalizedMessageLimit(value) {
-    return Number.isSafeInteger(value) && value > 0 ? Math.min(value, 0xffff_ffff) : 0x7fff_ffff;
-}
 function requirePublicWeight(weight) {
-    if (!Number.isInteger(weight) || weight < 0 || weight > 10_000) {
-        throw new configuration_1.ZLinkConfigurationException('Weight must be an integer in 0..10000.');
+    if (!(0, RegistrationBuilderPolicy_1.isValidPublicWeight)(weight)) {
+        throw new configuration_1.ZLinkConfigurationException(`Weight must be an integer in 0..${RegistrationBuilderPolicy_1.ZLINK_MAX_PUBLIC_WEIGHT}.`);
     }
 }
 function rawAvailabilityWeight(weight) {
@@ -1459,3 +1517,6 @@ function applySocketConfig(socket, config) {
         socket.maxMessageSize = config.maxMessageSize;
     }
 }
+function configuredSendTimeoutMs(value) {
+    return value ?? DEFAULT_SEND_TIMEOUT_MS;
+}