@zlink-systems/framework 0.10.0

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

@@ -0,0 +1,84 @@
+import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
+import type { RoutingId } from '../../contracts';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import type { ZLinkSubmitResult } from '../messaging/submission-result';
+import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
+import type { ZLinkMessageFlowModeCell } from '../diagnostics';
+import type { Message } from '../../contracts/Common/Message';
+import type { ReceiveRecord } from '../foundation/service-runtime-contracts';
+import { type ZLinkFrameworkRegistration } from '../configuration';
+import type { ZLinkBackendContext, ZLinkBackendRouterSocket, ZLinkBackendSpot, ZLinkBackendSpotNode, ZLinkBackendSocketMonitor, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
+import type { ZLinkRuntimeTaskRunner } from '../execution';
+import { ZLinkLocationRuntime, type ZLinkLocationEventSink, type ZLinkLocationRuntimeStores } from '../locations';
+import { type ZLinkRouteRuntimeRequestHandler, type ZLinkRouteRuntimeSendHandler } from './channel-dispatchers';
+import { ApplicationJobQueue } from '../host/application-job-queue';
+export declare class ZLinkChannelRuntimeManager {
+    private readonly registration;
+    private readonly sockets;
+    private readonly spotRoutes;
+    private readonly outbound;
+    private readonly lifecycle;
+    constructor(registration: ZLinkFrameworkRegistration, adapter: ZLinkChannelBackendAdapter, context: ZLinkBackendContext, providerResolver?: ZLinkProviderResolver, options?: ZLinkChannelRuntimeManagerOptions);
+    clientServerTopology(channelName: string): {
+        localRole: "client" | "server" | "clientAndServer" | undefined;
+        descriptors: readonly Pick<import("../foundation").ClientServerDescriptor, "state" | "weight" | "serverRoutingId">[];
+        pendingRequestCount: number;
+    };
+    fanoutTopology(channelName: string): {
+        descriptors: readonly import("../foundation").FanoutPublisherDescriptor[];
+    };
+    getFanoutListenerStatus(channelName: string): {
+        channelName: string;
+        endpoint: string;
+        observedAt: Date;
+    };
+    observeClientServerTopology(channelName: string, changed: () => void): () => void;
+    observeFanoutTopology(channelName: string, changed: () => void): () => void;
+    configureLocationAutoConnect(runtime: ZLinkLocationRuntime, stores: ZLinkLocationRuntimeStores, options: ZLinkLocationOptionOverrides, events?: ZLinkLocationEventSink): void;
+    startLocationAutoConnect(signal?: AbortSignal): Promise<void>;
+    reclaimLocationOwnerRows(signal?: AbortSignal): Promise<void>;
+    setSpotNodes(spotNodes: ReadonlyMap<string, ZLinkBackendSpotNode>): void;
+    clientServerServerSocket(channelName: string): ZLinkBackendRouterSocket;
+    routeMeshSocket(routerChannelId: string): ZLinkBackendRouterSocket;
+    bindRouteMeshRouters(): void;
+    openMonitoringSource(sourceName: string, adapter: ZLinkMonitoringBackendAdapter): ZLinkBackendSocketMonitor;
+    start(taskRunner?: ZLinkRuntimeTaskRunner): Promise<void>[];
+    prepareMeshDispatch(taskRunner?: ZLinkRuntimeTaskRunner): void;
+    dispatchMeshChannel(meshName: string, record: ReceiveRecord, signal?: AbortSignal): Promise<void>;
+    dispatchMeshRoute(meshName: string, record: ReceiveRecord, signal?: AbortSignal): Promise<void>;
+    dispatchLocalMeshRoute(meshName: string, sourceNodeRid: RoutingId, parts: readonly Message[], signal?: AbortSignal): Promise<void>;
+    canDispatchLocalMeshRoute(meshName: string): boolean;
+    send(channelName: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    tryPublish(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
+    publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+    routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    canRouteChannel(routerChannelId: string): boolean;
+    canRoutePacketChannel(routerChannelId: string): boolean;
+    dispose(signal?: AbortSignal): Promise<void>;
+}
+export interface ZLinkChannelRuntimeManagerOptions {
+    readonly internalRouteSendHandlers?: ReadonlyMap<string, ZLinkRouteRuntimeSendHandler>;
+    readonly internalRouteRequestHandlers?: ReadonlyMap<string, ZLinkRouteRuntimeRequestHandler>;
+    readonly monitoringAdapter?: ZLinkMonitoringBackendAdapter;
+    readonly localSpotRouteDispatcher?: {
+        send(spotId: RoutingId, packetName: string | undefined, message: unknown, context: {
+            readonly channelName: string;
+            readonly signal?: AbortSignal;
+        }): Promise<void>;
+        request<TReply>(spotId: RoutingId, packetName: string | undefined, request: unknown, context: {
+            readonly channelName: string;
+            readonly signal?: AbortSignal;
+        }): Promise<TReply>;
+    };
+    readonly messageFlowModeCell?: ZLinkMessageFlowModeCell;
+    readonly oneWayFailureSink?: (error: unknown) => void;
+    readonly applicationJobQueue?: ApplicationJobQueue;
+}

package/dist/runtime/channels/channel-runtime-manager.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkChannelRuntimeManager = void 0;
+const configuration_1 = require("../configuration");
+const channel_socket_registry_1 = require("./channel-socket-registry");
+const channel_dispatch_services_1 = require("./channel-dispatch-services");
+const channel_outbound_operations_1 = require("./channel-outbound-operations");
+const channel_runtime_lifecycle_1 = require("./channel-runtime-lifecycle");
+const spot_route_dispatch_strategy_1 = require("./spot-route-dispatch-strategy");
+const application_job_queue_1 = require("../host/application-job-queue");
+class ZLinkChannelRuntimeManager {
+    registration;
+    sockets;
+    spotRoutes;
+    outbound;
+    lifecycle;
+    constructor(registration, adapter, context, providerResolver, options = {}) {
+        this.registration = registration;
+        const applicationJobQueue = options.applicationJobQueue
+            ?? new application_job_queue_1.ApplicationJobQueue((0, application_job_queue_1.resolveApplicationJobQueueConfiguration)());
+        this.sockets = new channel_socket_registry_1.ZLinkChannelSocketRegistry(registration, adapter, context, options.monitoringAdapter, options.oneWayFailureSink, applicationJobQueue);
+        const codecs = { serializers: registration.messageSerializers };
+        const dispatchServices = new channel_dispatch_services_1.ZLinkChannelDispatchServices(registration, providerResolver, options.messageFlowModeCell);
+        const spotRouteBridges = new Map();
+        this.spotRoutes = new spot_route_dispatch_strategy_1.ZLinkSpotRouteDispatchStrategy({
+            registration,
+            sockets: this.sockets,
+            codecs,
+            spotRouteBridges,
+            localSpotRouteDispatcher: options.localSpotRouteDispatcher,
+            flowCreationEnabled: () => dispatchServices.flowCreationEnabled()
+        });
+        this.outbound = new channel_outbound_operations_1.ZLinkChannelOutboundOperations(this.sockets, codecs, dispatchServices);
+        this.lifecycle = new channel_runtime_lifecycle_1.ZLinkChannelRuntimeLifecycle({
+            registration,
+            adapter,
+            sockets: this.sockets,
+            codecs,
+            dispatchServices,
+            applicationJobQueue,
+            spotRoutes: this.spotRoutes,
+            spotRouteBridges,
+            internalRouteSendHandlers: options.internalRouteSendHandlers,
+            internalRouteRequestHandlers: options.internalRouteRequestHandlers,
+        });
+    }
+    clientServerTopology(channelName) {
+        const channel = this.registration.channels.get(channelName);
+        const client = channel?.client !== undefined;
+        const server = channel?.server !== undefined;
+        return {
+            localRole: client && server ? 'clientAndServer'
+                : client ? 'client'
+                    : server ? 'server'
+                        : undefined,
+            descriptors: this.sockets.clientServerActiveTargets(channelName),
+            pendingRequestCount: this.outbound.pendingRequestCount(channelName)
+        };
+    }
+    fanoutTopology(channelName) {
+        return { descriptors: this.sockets.fanoutActiveTargets(channelName) };
+    }
+    getFanoutListenerStatus(channelName) {
+        const endpoint = this.sockets.fanoutPublisherEndpoint(channelName);
+        if (endpoint === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' has not reported a bound listener.`);
+        }
+        return {
+            channelName,
+            endpoint,
+            observedAt: new Date()
+        };
+    }
+    observeClientServerTopology(channelName, changed) {
+        const monitor = this.sockets.clientServerMonitoringSource(channelName);
+        monitor.onEvent(changed);
+        return () => { void monitor.dispose(); };
+    }
+    observeFanoutTopology(channelName, changed) {
+        const source = this.sockets.fanoutTopologyMonitoringSource(channelName);
+        source.onChange(changed);
+        return () => { void source.dispose(); };
+    }
+    configureLocationAutoConnect(runtime, stores, options, events) {
+        this.lifecycle.configureLocationAutoConnect(runtime, stores, options, events);
+    }
+    async startLocationAutoConnect(signal) {
+        await this.lifecycle.startLocationAutoConnect(signal);
+    }
+    async reclaimLocationOwnerRows(signal) {
+        await this.lifecycle.reclaimLocationOwnerRows(signal);
+    }
+    setSpotNodes(spotNodes) {
+        this.spotRoutes.setSpotNodes(spotNodes);
+    }
+    clientServerServerSocket(channelName) {
+        return this.sockets.channelRouter(channelName);
+    }
+    routeMeshSocket(routerChannelId) {
+        return this.sockets.routeRouter(routerChannelId);
+    }
+    bindRouteMeshRouters() {
+        this.lifecycle.bindRouteMeshRouters();
+    }
+    openMonitoringSource(sourceName, adapter) {
+        const [channelName, role] = splitMonitoringSocketSourceName(sourceName);
+        switch (role) {
+            case 'server':
+                return adapter.openSocketMonitor(this.sockets.channelRouter(channelName));
+            case 'client':
+                return this.sockets.clientServerMonitoringSource(channelName);
+            case 'publisher':
+                return adapter.openSocketMonitor(this.sockets['publisher'](channelName));
+            case 'subscriber':
+                return this.sockets.fanoutMonitoringSource(channelName);
+            case 'router':
+                return adapter.openSocketMonitor(this.sockets.routeRouter(channelName));
+            default:
+                throw new configuration_1.ZLinkConfigurationException(`Monitoring socket source '${sourceName}' is not registered.`);
+        }
+    }
+    start(taskRunner) {
+        return this.lifecycle.start(taskRunner);
+    }
+    prepareMeshDispatch(taskRunner) {
+        this.lifecycle.prepareMeshDispatch(taskRunner);
+    }
+    dispatchMeshChannel(meshName, record, signal) {
+        return this.lifecycle.dispatchMeshChannel(meshName, record, signal);
+    }
+    dispatchMeshRoute(meshName, record, signal) {
+        return this.lifecycle.dispatchMeshRoute(meshName, record, signal);
+    }
+    dispatchLocalMeshRoute(meshName, sourceNodeRid, parts, signal) {
+        return this.lifecycle.dispatchLocalMeshRoute(meshName, sourceNodeRid, parts, signal);
+    }
+    canDispatchLocalMeshRoute(meshName) {
+        return this.lifecycle.canDispatchLocalMeshRoute(meshName);
+    }
+    send(channelName, packetName, message, signal, metadata) {
+        return this.outbound.send(channelName, packetName, message, signal, metadata);
+    }
+    async request(channelName, packetName, request, timeoutMs, signal, metadata) {
+        return this.outbound.request(channelName, packetName, request, timeoutMs, signal, metadata);
+    }
+    tryPublish(channelName, topic, packetName, event, metadata) {
+        return this.outbound.tryPublish(channelName, topic, packetName, event, metadata);
+    }
+    publish(channelName, topic, packetName, event, signal, metadata) {
+        return this.outbound.publish(channelName, topic, packetName, event, signal, metadata);
+    }
+    routeSubmit(routerChannelId, targetNodeRid, packetName, message, signal, metadata) {
+        return this.outbound.routeSubmit(routerChannelId, targetNodeRid, packetName, message, signal, metadata);
+    }
+    async routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
+        return this.outbound.routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata);
+    }
+    async routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
+        return this.spotRoutes.routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    }
+    async routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
+        return this.spotRoutes.routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata);
+    }
+    async routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
+        return this.spotRoutes.routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
+    }
+    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
+        return this.spotRoutes.routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    }
+    async routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal) {
+        return this.spotRoutes.routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal);
+    }
+    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal) {
+        return this.spotRoutes.routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal);
+    }
+    canRouteChannel(routerChannelId) {
+        return this.spotRoutes.canRouteChannel(routerChannelId);
+    }
+    canRoutePacketChannel(routerChannelId) {
+        return this.spotRoutes.canRoutePacketChannel(routerChannelId);
+    }
+    async dispose(signal) {
+        await this.lifecycle.dispose(signal);
+    }
+}
+exports.ZLinkChannelRuntimeManager = ZLinkChannelRuntimeManager;
+function splitMonitoringSocketSourceName(sourceName) {
+    const separator = sourceName.lastIndexOf('.');
+    if (separator <= 0 || separator === sourceName.length - 1) {
+        throw new configuration_1.ZLinkConfigurationException(`Monitoring socket source '${sourceName}' is not registered.`);
+    }
+    return [sourceName.slice(0, separator), sourceName.slice(separator + 1)];
+}

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

@@ -0,0 +1,18 @@
+import type { ZLinkSocketConfig as ZLinkRuntimeSocketConfig } from '../../contracts/Configuration';
+import type { ZLinkBackendRouterSocket } from '../backend/contracts';
+interface ZLinkChannelSocketOptionsRuntime {
+    clientServerServerSocket(channelName: string): ZLinkBackendRouterSocket;
+    routeMeshSocket(channelName: string): ZLinkBackendRouterSocket;
+    clientServerServerWeight?(channelName: string): number;
+    setClientServerServerWeight?(channelName: string, weight: number): void;
+    routeMeshWeight?(channelName: string): number;
+    setRouteMeshWeight?(channelName: string, weight: number): void;
+}
+export declare class DefaultZLinkChannelRuntimeOptions {
+    private readonly manager;
+    constructor(manager: () => ZLinkChannelSocketOptionsRuntime | undefined);
+    serverChannel(channelName: string): ZLinkRuntimeSocketConfig;
+    routeChannel(channelName: string): ZLinkRuntimeSocketConfig;
+    private requireManager;
+}
+export {};

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

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultZLinkChannelRuntimeOptions = void 0;
+const configuration_1 = require("../configuration");
+const SendTimeoutValidation_1 = require("../../contracts/Configuration/SendTimeoutValidation");
+class ZLinkLiveSocketConfig {
+    socket;
+    readWeight;
+    writeWeight;
+    constructor(socket, readWeight, writeWeight) {
+        this.socket = socket;
+        this.readWeight = readWeight;
+        this.writeWeight = writeWeight;
+    }
+    get weight() {
+        return this.readWeight();
+    }
+    set weight(value) {
+        validatePublicWeight(value);
+        this.writeWeight(value);
+    }
+    get sendHighWaterMark() {
+        return this.socket.sendHighWaterMark;
+    }
+    set sendHighWaterMark(value) {
+        validateHighWaterMark(value, 'sendHighWaterMark');
+        this.socket.sendHighWaterMark = value;
+    }
+    get receiveHighWaterMark() {
+        return this.socket.receiveHighWaterMark;
+    }
+    set receiveHighWaterMark(value) {
+        validateHighWaterMark(value, 'receiveHighWaterMark');
+        this.socket.receiveHighWaterMark = value;
+    }
+    get sendTimeoutMs() {
+        return this.socket.sendTimeoutMs;
+    }
+    set sendTimeoutMs(value) {
+        validateSendTimeout(value);
+        this.socket.sendTimeoutMs = value;
+    }
+}
+class ZLinkServerRuntimeOptions {
+    serverSocket;
+    constructor(serverSocket) {
+        this.serverSocket = serverSocket;
+    }
+    configureServerSocket() {
+        return this.serverSocket;
+    }
+}
+class ZLinkRouteRuntimeOptions {
+    socket;
+    constructor(socket) {
+        this.socket = socket;
+    }
+    configureSocket() {
+        return this.socket;
+    }
+}
+class DefaultZLinkChannelRuntimeOptions {
+    manager;
+    constructor(manager) {
+        this.manager = manager;
+    }
+    serverChannel(channelName) {
+        requireChannelName(channelName);
+        const manager = this.requireManager();
+        const socket = manager.clientServerServerSocket(channelName);
+        return new ZLinkServerRuntimeOptions(new ZLinkLiveSocketConfig(socket, () => manager.clientServerServerWeight?.(channelName) ?? socket.peerWeight, (weight) => {
+            if (manager.setClientServerServerWeight !== undefined) {
+                manager.setClientServerServerWeight(channelName, weight);
+            }
+            else {
+                socket.peerWeight = weight;
+            }
+        })).configureServerSocket();
+    }
+    routeChannel(channelName) {
+        requireChannelName(channelName);
+        const manager = this.requireManager();
+        const socket = manager.routeMeshSocket(channelName);
+        return new ZLinkRouteRuntimeOptions(new ZLinkLiveSocketConfig(socket, () => manager.routeMeshWeight?.(channelName) ?? socket.peerWeight, (weight) => {
+            if (manager.setRouteMeshWeight !== undefined) {
+                manager.setRouteMeshWeight(channelName, weight);
+            }
+            else {
+                socket.peerWeight = weight;
+            }
+        })).configureSocket();
+    }
+    requireManager() {
+        const manager = this.manager();
+        if (manager === undefined) {
+            throw new configuration_1.ZLinkConfigurationException('Channel runtime is not started.');
+        }
+        return manager;
+    }
+}
+exports.DefaultZLinkChannelRuntimeOptions = DefaultZLinkChannelRuntimeOptions;
+function requireChannelName(channelName) {
+    if (channelName.trim().length === 0 || channelName.trim() !== channelName) {
+        throw new configuration_1.ZLinkConfigurationException('Channel name must not be empty or padded.');
+    }
+}
+function validatePublicWeight(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 10_000) {
+        throw new configuration_1.ZLinkConfigurationException('Weight must be an integer in 0..10000.');
+    }
+}
+function validateHighWaterMark(value, label) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new configuration_1.ZLinkConfigurationException(`${label} must be a non-negative integer.`);
+    }
+}
+function validateSendTimeout(value) {
+    (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)('sendTimeoutMs', value);
+}

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

@@ -0,0 +1,157 @@
+import { type ZLinkClientServerServerDescriptor, type ZLinkFanoutPublisherDescriptor } from '../../contracts';
+import { type ZLinkFrameworkRegistration } from '../configuration';
+import type { ZLinkBackendContext, ZLinkBackendDealerSocket, ZLinkBackendPublisherSocket, ZLinkBackendRouterSocket, ZLinkBackendSocketMonitor, ZLinkBackendSubscriberSocket, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
+import type { Message } from '../../contracts/Common/Message';
+import { ServiceDiscoveryRegistry } from '../foundation/service-discovery-registry';
+import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
+import type { ApplicationJobQueue } from '../host/application-job-queue';
+export interface ZLinkClientServerServerSocketIdentity {
+    readonly serverRid: string;
+    readonly lifecycleGeneration: bigint;
+    readonly endpoint: string;
+}
+export interface ZLinkClientServerConnectionCallbacks {
+    readonly onTransportReady: (routingId: string, endpoint: string) => void;
+    readonly onTerminated: (routingId: string | undefined, endpoint: string) => void;
+}
+type ClientServerDiscoveryDescriptor = Parameters<ServiceDiscoveryRegistry['admitClientServer']>[0];
+export interface ZLinkFanoutConnectionCallbacks {
+    readonly onReady: () => void;
+    readonly onTerminated: (reason: 'disconnect' | 'deadline' | 'protocol') => void;
+}
+export declare class ZLinkChannelSocketRegistry {
+    private readonly registration;
+    private readonly adapter;
+    private readonly context;
+    private readonly monitoringAdapter?;
+    private readonly oneWayFailureSink?;
+    private readonly applicationJobQueue?;
+    private readonly clientDealers;
+    private readonly channelRouters;
+    private readonly publishers;
+    private readonly routeRouters;
+    private readonly routeMembers;
+    private readonly clientServerIdentities;
+    private readonly clientServerConnections;
+    private readonly clientServerDiscovery;
+    private readonly clientServerReadyIdentities;
+    private readonly clientServerServerDescriptors;
+    private readonly clientServerPublicWeights;
+    private readonly routeMeshPublicWeights;
+    private readonly clientServerAdmittedClients;
+    private readonly clientServerServerPeers;
+    private readonly ownedMonitors;
+    private readonly fanoutConnections;
+    private readonly fanoutPublisherNextBeacon;
+    private clientServerLivenessTimer?;
+    private nextClientServerProbeId;
+    private readonly clientServerMonitorHandlers;
+    private readonly fanoutMonitorHandlers;
+    private readonly fanoutTopologyHandlers;
+    constructor(registration: ZLinkFrameworkRegistration, adapter: ZLinkChannelBackendAdapter, context: ZLinkBackendContext, monitoringAdapter?: ZLinkMonitoringBackendAdapter | undefined, oneWayFailureSink?: ((error: unknown) => void) | undefined, applicationJobQueue?: ApplicationJobQueue | undefined);
+    dispose(): Promise<void>;
+    clientDealer(channelName: string): ZLinkBackendDealerSocket;
+    channelRouter(channelName: string): ZLinkBackendRouterSocket;
+    clientServerServerIdentity(channelName: string): ZLinkClientServerServerSocketIdentity;
+    clientServerServerSocket(channelName: string): ZLinkBackendRouterSocket;
+    clientServerServerWeight(channelName: string): number;
+    setClientServerServerWeight(channelName: string, weight: number): void;
+    openClientServerConnection(channelName: string, connectionId: string, endpoint: string, callbacks: ZLinkClientServerConnectionCallbacks): ZLinkBackendDealerSocket;
+    closeClientServerConnection(connectionId: string): Promise<void>;
+    private disposeClientServerPhysical;
+    admitClientServerConnection(descriptor: ClientServerDiscoveryDescriptor, connectionId: string): boolean;
+    removeClientServerReady(channelName: string, serverRoutingId: string, connectionId: string): boolean;
+    selectClientServerDealer(channelName: string): ZLinkBackendDealerSocket | undefined;
+    clientDealerForOutbound(channelName: string): ZLinkBackendDealerSocket | undefined;
+    selectedClientServerRid(channelName: string, dealer: ZLinkBackendDealerSocket): string | 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.
+     */
+    awaitClientDealerForOutbound(channelName: string, signal?: AbortSignal, deadlineAtMs?: number): Promise<ZLinkBackendDealerSocket | undefined>;
+    startManualClientServerConnections(): void;
+    startLocalClientServerConnections(): void;
+    clientServerMonitoringSource(channelName: string): ZLinkBackendSocketMonitor;
+    clientServerActiveTargets(channelName: string): readonly Pick<ClientServerDiscoveryDescriptor, 'serverRoutingId' | 'weight' | 'state'>[];
+    hasKnownClientServerTargets(channelName: string): boolean;
+    fanoutActiveTargets(channelName: string): readonly import("../foundation/service-discovery-registry").FanoutPublisherDescriptor[];
+    admitFanoutPublisher(descriptor: ZLinkFanoutPublisherDescriptor, connectionId: string): boolean;
+    removeFanoutPublisher(descriptor: ZLinkFanoutPublisherDescriptor, connectionId: string): boolean;
+    setClientServerServerDescriptor(descriptor: ZLinkClientServerServerDescriptor | undefined, channelName: string): void;
+    tryHandleClientServerControl(channelName: string, received: {
+        readonly parts: readonly Message[];
+        readonly replyToken: unknown | null;
+        readonly routingId: unknown;
+    }, router: ZLinkBackendRouterSocket): boolean;
+    tickClientServerLiveness(nowMs?: number): void;
+    openFanoutSubscriberConnection(channelName: string, connectionId: string, endpoint: string, callbacks: ZLinkFanoutConnectionCallbacks): ZLinkBackendSubscriberSocket;
+    closeFanoutSubscriberConnection(connectionId: string): Promise<void>;
+    handleFanoutInbound(connectionId: string, topicMessage: {
+        readonly topic: string;
+        readonly parts: readonly {
+            data(): Uint8Array;
+        }[];
+    }, source: ZLinkBackendSubscriberSocket, nowMs?: number): boolean;
+    handleFanoutInboundResult(connectionId: string, topicMessage: {
+        readonly topic: string;
+        readonly parts: readonly {
+            data(): Uint8Array;
+        }[];
+    }, source: ZLinkBackendSubscriberSocket, nowMs?: number): {
+        readonly consumed: boolean;
+        readonly decodedHeader?: ZLinkChannelEnvelopeHeader;
+    };
+    isFanoutConnectionReady(connectionId: string): boolean;
+    fanoutMonitoringSource(channelName: string): ZLinkBackendSocketMonitor;
+    fanoutTopologyMonitoringSource(channelName: string): {
+        onChange(handler: () => void): void;
+        dispose(): Promise<void>;
+    };
+    private notifyFanoutTopology;
+    private tickFanoutLiveness;
+    private openManualClientServerConnection;
+    private openConfiguredClientServerConnection;
+    private admitConfiguredClientServerConnection;
+    private drainClientServerControl;
+    private requestClientServerEndpointTermination;
+    private applyClientServerDescriptorUpdate;
+    private ensureClientServerLivenessTimer;
+    private drainSocketMonitors;
+    private removeReadyConnection;
+    private requestClientServerLiveness;
+    private admitClientServerServerPeer;
+    private requestClientServerServerLiveness;
+    private acceptClientServerServerLivenessAck;
+    private reportStaleClientServerLivenessAck;
+    private pushClientServerDescriptorUpdate;
+    private allocateClientServerProbeId;
+    publisher(channelName: string): ZLinkBackendPublisherSocket;
+    fanoutPublisherEndpoint(channelName: string): string | undefined;
+    routeRouter(routerChannelId: string): ZLinkBackendRouterSocket;
+    routeMeshSocket(routerChannelId: string): ZLinkBackendRouterSocket;
+    routeMeshWeight(routerChannelId: string): number;
+    setRouteMeshWeight(routerChannelId: string, weight: number): void;
+    private registerReceiveFlowSocket;
+    private unregisterReceiveFlowSocket;
+    routeMemberStatus(routerChannelId: string, targetNodeRid: string): 'unknown' | 'missing' | 'connected' | 'disconnected';
+    monitorDisconnects(socket: ZLinkBackendDealerSocket | ZLinkBackendSubscriberSocket, handler: (endpoint: string) => void): void;
+    private trackRouteMonitor;
+}
+export {};