@zlink-systems/framework 0.10.0

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

@@ -0,0 +1,630 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkChannelRuntimeLifecycle = void 0;
+const configuration_1 = require("../configuration");
+const contracts_1 = require("../backend/contracts");
+const channel_autoconnect_1 = require("./channel-autoconnect");
+const channel_dispatchers_1 = require("./channel-dispatchers");
+const channel_receive_loops_1 = require("./channel-receive-loops");
+const client_server_location_runtime_1 = require("./client-server-location-runtime");
+const fanout_location_runtime_1 = require("./fanout-location-runtime");
+const RuntimeEndpointConnections_1 = require("../../contracts/Configuration/RuntimeEndpointConnections");
+const node_async_hooks_1 = require("node:async_hooks");
+const state_lane_1 = require("../execution/state-lane");
+const detachedStateLaneResource = new node_async_hooks_1.AsyncResource('zlink:channel-runtime-lifecycle');
+class ZLinkChannelRuntimeLifecycle {
+    options;
+    lane = new state_lane_1.ZLinkStateLane();
+    receiveRoundRobin = new channel_receive_loops_1.ZLinkReceiveRoundRobinCoordinator();
+    channelReceiveLoops = [];
+    subscriberReceiveLoops = [];
+    manualFanoutSubscribers = new Map();
+    manualFanoutSubscriberOwners = new Set();
+    routeReceiveLoops = [];
+    meshChannelDispatchers = new Map();
+    meshRouteDispatchers = new Map();
+    nextManualFanoutIndex = 0;
+    disposed = false;
+    locationAutoConnect;
+    clientServerLocation;
+    fanoutLocation;
+    taskRunner;
+    constructor(options) {
+        this.options = options;
+    }
+    configureLocationAutoConnect(runtime, stores, options, events) {
+        this.locationAutoConnect = (0, channel_autoconnect_1.createChannelLocationAutoConnectContext)(runtime, stores, options, events);
+    }
+    beginLocationAutoConnectCore() {
+        const location = this.locationAutoConnect;
+        if (location === undefined
+            || this.clientServerLocation !== undefined
+            || this.fanoutLocation !== undefined) {
+            return undefined;
+        }
+        const clientServerLocation = hasClientServerLocationTopology(this.options.registration)
+            ? new client_server_location_runtime_1.ZLinkClientServerLocationRuntime(this.options.registration, this.options.sockets, location.runtime, location.stores, location.options)
+            : undefined;
+        this.clientServerLocation = clientServerLocation;
+        return { location, clientServerLocation };
+    }
+    beginFanoutLocationAutoConnectCore(start) {
+        if (!hasFanoutLocationTopology(this.options.registration))
+            return undefined;
+        const fanoutLocation = new fanout_location_runtime_1.ZLinkFanoutLocationRuntime(this.options.registration, this.options.sockets, start.location.runtime, start.location.stores, start.location.options, (channelName, connectionId, subscriber) => this.startFanoutSubscriberLoop(channelName, connectionId, subscriber));
+        this.fanoutLocation = fanoutLocation;
+        return fanoutLocation;
+    }
+    resetLocationAutoConnectCore(start, fanoutLocation) {
+        if (this.clientServerLocation === start.clientServerLocation) {
+            this.clientServerLocation = undefined;
+        }
+        if (this.fanoutLocation === fanoutLocation) {
+            this.fanoutLocation = undefined;
+        }
+    }
+    async startLocationAutoConnect(signal) {
+        const start = await this.lane.run(() => this.beginLocationAutoConnectCore());
+        if (start === undefined)
+            return;
+        let fanoutLocation;
+        try {
+            await startOutsideStateLane(() => start.clientServerLocation?.start(signal) ?? Promise.resolve());
+            fanoutLocation = await this.lane.run(() => this.beginFanoutLocationAutoConnectCore(start));
+            await startOutsideStateLane(() => fanoutLocation?.start(signal) ?? Promise.resolve());
+        }
+        catch (error) {
+            await startOutsideStateLane(() => Promise.all([
+                start.clientServerLocation?.stop(signal).catch(() => undefined),
+                fanoutLocation?.stop(signal).catch(() => undefined)
+            ]));
+            await this.lane.run(() => this.resetLocationAutoConnectCore(start, fanoutLocation));
+            throw error;
+        }
+    }
+    async reclaimLocationOwnerRows(signal) {
+        const clientServerLocation = await this.lane.run(() => this.clientServerLocation);
+        await startOutsideStateLane(() => clientServerLocation?.reclaimOwnerRows(signal) ?? Promise.resolve());
+        const fanoutLocation = await this.lane.run(() => this.fanoutLocation);
+        await startOutsideStateLane(() => fanoutLocation?.reclaimOwnerRows(signal) ?? Promise.resolve());
+    }
+    bindRouteMeshRouters() {
+        for (const routeChannel of this.options.registration.routeChannelOptions.values()) {
+            if (routeChannel.bind !== undefined && routeChannel.bind.trim().length > 0) {
+                this.options.sockets.routeRouter(routeChannel.routerChannelId);
+            }
+        }
+    }
+    start(taskRunner) {
+        this.taskRunner = taskRunner;
+        this.prepareMeshDispatch(taskRunner);
+        this.openOutboundSockets();
+        const channelReceivers = this.startChannelReceivers(taskRunner);
+        const subscriberReceivers = this.startSubscriberReceivers(taskRunner);
+        const routeReceivers = this.startRouteReceivers(taskRunner);
+        const tasks = [
+            ...channelReceivers,
+            ...subscriberReceivers,
+            ...routeReceivers
+        ];
+        return tasks;
+    }
+    prepareMeshDispatch(taskRunner) {
+        if (this.meshChannelDispatchers.size > 0) {
+            return;
+        }
+        if (taskRunner === undefined) {
+            throw new configuration_1.ZLinkConfigurationException('MeshNode channel dispatch requires a runtime task runner.');
+        }
+        for (const [meshName, mesh] of this.options.registration.spotNodes) {
+            const routeHandlers = [
+                ...(mesh.routeSendHandlers ?? []).map((registration) => ({
+                    kind: 'send',
+                    packetName: registration.packetName,
+                    handler: this.options.dispatchServices.routeSendHandler(registration.handlerType)
+                })),
+                ...(mesh.routeRequestHandlers ?? []).map((registration) => ({
+                    kind: 'request',
+                    packetName: registration.packetName,
+                    handler: this.options.dispatchServices.routeRequestHandler(registration.handlerType)
+                })),
+                ...[...this.options.internalRouteSendHandlers?.entries() ?? []].map(([packetName, handler]) => ({
+                    kind: 'send', packetName, handler
+                })),
+                ...[...this.options.internalRouteRequestHandlers?.entries() ?? []].map(([packetName, handler]) => ({ kind: 'request', packetName, handler }))
+            ];
+            if (routeHandlers.length > 0) {
+                this.meshRouteDispatchers.set(meshName, new channel_dispatchers_1.ZLinkRoutePacketDispatcher({
+                    routerChannelId: meshName,
+                    codecs: this.options.codecs,
+                    dispatchErrors: this.options.dispatchServices.dispatchErrorReporter(taskRunner.errorSink),
+                    handlers: routeHandlers,
+                    filters: this.options.dispatchServices.handlerFilters(),
+                    unhandled: this.options.registration.dispatch?.unhandled
+                }));
+            }
+            for (const [channelName, channel] of Object.entries(mesh.meshChannels ?? {})) {
+                if ((channel.requestHandlers ?? []).length === 0 && (channel.sendHandlers ?? []).length === 0) {
+                    continue;
+                }
+                this.meshChannelDispatchers.set(meshChannelKey(meshName, channelName), new channel_dispatchers_1.ZLinkChannelRequestDispatcher({
+                    meshName,
+                    channelName,
+                    routeMesh: true,
+                    codecs: this.options.codecs,
+                    dispatchErrors: this.options.dispatchServices.dispatchErrorReporter(taskRunner.errorSink),
+                    handlers: new Map(channel.requestHandlers?.map((handler) => [
+                        handler.packetName,
+                        handler.handler
+                            ?? adaptRouteRequestHandler(this.options.dispatchServices.routeRequestHandler(handler.handlerType))
+                    ])),
+                    sendHandlers: new Map(channel.sendHandlers?.map((handler) => [
+                        handler.packetName,
+                        handler.handler
+                            ?? adaptRouteSendHandler(this.options.dispatchServices.routeSendHandler(handler.handlerType))
+                    ])),
+                    filters: this.options.dispatchServices.handlerFilters(),
+                    unhandled: this.options.registration.dispatch?.unhandled
+                }));
+            }
+        }
+    }
+    dispatchMeshChannel(meshName, record, signal) {
+        const channelName = record.channelName;
+        if (channelName === null) {
+            throw new configuration_1.ZLinkConfigurationException('MeshNode channel record is missing channelName.');
+        }
+        const dispatcher = this.meshChannelDispatchers.get(meshChannelKey(meshName, channelName));
+        if (dispatcher === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`RouteMesh '${meshName}' channel '${channelName}' has no registered handlers.`);
+        }
+        return dispatcher.dispatchMesh(record, signal);
+    }
+    dispatchMeshRoute(meshName, record, signal) {
+        const dispatcher = this.meshRouteDispatchers.get(meshName);
+        if (dispatcher === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`RouteMesh '${meshName}' has no registered node-direct handlers.`);
+        }
+        return dispatcher.dispatchMesh(record, signal);
+    }
+    dispatchLocalMeshRoute(meshName, sourceNodeRid, parts, signal) {
+        const dispatcher = this.meshRouteDispatchers.get(meshName);
+        if (dispatcher === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`RouteMesh '${meshName}' has no registered node-direct handlers.`);
+        }
+        return dispatcher.dispatchLocalCommand(parts, sourceNodeRid, signal);
+    }
+    canDispatchLocalMeshRoute(meshName) {
+        return this.meshRouteDispatchers.has(meshName);
+    }
+    async dispose(signal) {
+        const work = await this.lane.run(() => this.beginDisposeCore());
+        const transportStopped = await startOutsideStateLane(() => Promise.allSettled([
+            ...work.channelLoops.map((loop) => loop.stop()),
+            ...work.subscriberLoops.map((loop) => loop.stop()),
+            ...work.routeLoops.map((loop) => loop.stop()),
+            ...work.manualTransitions
+        ]));
+        const descriptorStopped = work.clientServerLocation === undefined
+            ? []
+            : await startOutsideStateLane(() => Promise.allSettled([work.clientServerLocation?.stop(signal)]));
+        const fanoutDescriptorStopped = work.fanoutLocation === undefined
+            ? []
+            : await startOutsideStateLane(() => Promise.allSettled([work.fanoutLocation?.stop(signal)]));
+        const cleanup = await startOutsideStateLane(() => Promise.allSettled([
+            ...work.spotRouteBridges.map((bridge) => bridge.dispose()),
+            this.options.sockets.dispose()
+        ]));
+        const errors = [
+            ...transportStopped,
+            ...descriptorStopped,
+            ...fanoutDescriptorStopped,
+            ...cleanup
+        ]
+            .filter((result) => result.status === 'rejected')
+            .map((result) => result.reason);
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, 'Channel runtime cleanup failed.');
+    }
+    beginDisposeCore() {
+        const channelLoops = [...this.channelReceiveLoops];
+        const manualStates = [...this.manualFanoutSubscribers.values()];
+        this.disposed = true;
+        for (const state of manualStates)
+            state.desired = false;
+        for (const owner of this.manualFanoutSubscriberOwners) {
+            (0, RuntimeEndpointConnections_1.detachEndpointConnections)(owner);
+        }
+        this.manualFanoutSubscriberOwners.clear();
+        this.manualFanoutSubscribers.clear();
+        const manualLoops = new Set(manualStates
+            .map(state => state.active?.loop ?? state.stopping?.loop)
+            .filter((loop) => loop !== undefined));
+        const subscriberLoops = [...this.subscriberReceiveLoops]
+            .filter(loop => !manualLoops.has(loop));
+        const manualTransitions = manualStates.map(state => this.drainManualFanoutSubscriberCore(state));
+        const routeLoops = [...this.routeReceiveLoops];
+        const clientServerLocation = this.clientServerLocation;
+        const fanoutLocation = this.fanoutLocation;
+        const spotRouteBridges = [...this.options.spotRouteBridges.values()];
+        this.channelReceiveLoops.length = 0;
+        this.subscriberReceiveLoops.length = 0;
+        this.routeReceiveLoops.length = 0;
+        this.clientServerLocation = undefined;
+        this.fanoutLocation = undefined;
+        this.taskRunner = undefined;
+        this.meshChannelDispatchers.clear();
+        this.meshRouteDispatchers.clear();
+        this.options.spotRouteBridges.clear();
+        return {
+            channelLoops,
+            subscriberLoops,
+            manualTransitions,
+            routeLoops,
+            clientServerLocation,
+            fanoutLocation,
+            spotRouteBridges
+        };
+    }
+    openOutboundSockets() {
+        // The process-local Server is an independent peer source. Location Store
+        // discovery may later alias the same admitted identity, but startup and
+        // fail-static selection must not depend on descriptor publication.
+        this.options.sockets.startLocalClientServerConnections();
+        this.options.sockets.startManualClientServerConnections();
+        for (const channelName of this.options.registration.fanoutPublishers) {
+            this.options.sockets.publisher(channelName);
+        }
+    }
+    startChannelReceivers(taskRunner) {
+        const tasks = [];
+        for (const [channelName, channel] of this.options.registration.channels) {
+            if (channel.server?.bind === undefined ||
+                ((channel.requestHandlers ?? []).length === 0 && (channel.sendHandlers ?? []).length === 0)) {
+                continue;
+            }
+            if (taskRunner === undefined) {
+                throw new configuration_1.ZLinkConfigurationException(`Channel '${channelName}' handler dispatch requires a runtime task runner.`);
+            }
+            const router = this.options.sockets.channelRouter(channelName);
+            const dispatcher = new channel_dispatchers_1.ZLinkChannelRequestDispatcher({
+                channelName,
+                codecs: this.options.codecs,
+                dispatchErrors: this.options.dispatchServices.dispatchErrorReporter(taskRunner.errorSink),
+                handlers: new Map(channel.requestHandlers?.map((handler) => [
+                    handler.packetName,
+                    handler.handler ?? this.options.dispatchServices.channelRequestHandler(requireChannelHandlerType(handler.handlerType, channelName, handler.packetName))
+                ])),
+                sendHandlers: new Map(channel.sendHandlers?.map((handler) => [
+                    handler.packetName,
+                    handler.handler ?? this.options.dispatchServices.channelSendHandler(requireChannelHandlerType(handler.handlerType, channelName, handler.packetName))
+                ])),
+                filters: this.options.dispatchServices.handlerFilters(),
+                unhandled: this.options.registration.dispatch?.unhandled,
+            });
+            const spotRouteBridge = this.createSpotRouteBridgeForRouter(channelName, router);
+            const loop = new channel_receive_loops_1.ZLinkChannelReceiveLoop(channelName, router, dispatcher, spotRouteBridge, (received, socket) => this.options.sockets.tryHandleClientServerControl(channelName, received, socket), this.options.adapter.createReadablePoller(router), this.options.applicationJobQueue, error => taskRunner.errorSink.reportRuntimeTaskException(`channel:${channelName}:dispatch`, error), this.receiveRoundRobin);
+            this.channelReceiveLoops.push(loop);
+            tasks.push(taskRunner.run(`channel:${channelName}`, (signal) => loop.run(signal)));
+        }
+        return tasks;
+    }
+    startSubscriberReceivers(taskRunner) {
+        const tasks = [];
+        for (const [channelName, channel] of this.options.registration.channels) {
+            if (channel.subscriber === undefined || (channel.publishHandlers ?? []).length === 0) {
+                continue;
+            }
+            if (taskRunner === undefined) {
+                throw new configuration_1.ZLinkConfigurationException(`Fanout channel '${channelName}' publish handler dispatch requires a runtime task runner.`);
+            }
+            const dispatcher = new channel_dispatchers_1.ZLinkChannelPublishDispatcher({
+                channelName,
+                codecs: this.options.codecs,
+                dispatchErrors: this.options.dispatchServices.dispatchErrorReporter(taskRunner.errorSink),
+                handlers: new Map(channel.publishHandlers?.map((handler) => [handler.packetName, handler.handler])),
+                filters: this.options.dispatchServices.handlerFilters(),
+                unhandled: this.options.registration.dispatch?.unhandled,
+                metrics: this.options.dispatchServices.metrics()
+            });
+            const endpointHandle = (0, RuntimeEndpointConnections_1.endpointConnections)(channel.subscriber, channel.subscriber.manualConnections ?? []);
+            const endpoints = endpointHandle.listConnections();
+            this.manualFanoutSubscriberOwners.add(channel.subscriber);
+            (0, RuntimeEndpointConnections_1.attachEndpointConnections)(channel.subscriber, {
+                connect: endpoint => this.requestManualFanoutConnect(channelName, endpoint, taskRunner, dispatcher),
+                disconnect: endpoint => this.requestManualFanoutDisconnect(channelName, endpoint)
+            });
+            for (const endpoint of endpoints) {
+                const state = this.getOrCreateManualFanoutSubscriber(channelName, endpoint, this.nextManualFanoutIndex++, taskRunner, dispatcher);
+                tasks.push(this.openManualFanoutSubscriber(state));
+            }
+        }
+        return tasks;
+    }
+    getOrCreateManualFanoutSubscriber(channelName, endpoint, index, taskRunner, dispatcher) {
+        const key = manualFanoutSubscriberKey(channelName, endpoint);
+        const existing = this.manualFanoutSubscribers.get(key);
+        if (existing !== undefined) {
+            existing.desired = true;
+            return existing;
+        }
+        const state = {
+            channelName,
+            endpoint,
+            index,
+            connectionId: key,
+            taskRunner,
+            dispatcher,
+            desired: true,
+            transition: Promise.resolve()
+        };
+        this.manualFanoutSubscribers.set(key, state);
+        return state;
+    }
+    requestManualFanoutConnect(channelName, endpoint, taskRunner, dispatcher) {
+        if (this.disposed)
+            return;
+        const state = this.getOrCreateManualFanoutSubscriber(channelName, endpoint, this.nextManualFanoutIndex++, taskRunner, dispatcher);
+        state.desired = true;
+        this.enqueueManualFanoutTransition(state, async () => {
+            if (!state.desired || state.active !== undefined || this.taskRunner !== taskRunner)
+                return;
+            void this.openManualFanoutSubscriber(state).catch(error => taskRunner.errorSink
+                .reportRuntimeTaskException(`subscriber:${state.channelName}:manual:${state.index}:open`, error));
+        });
+    }
+    requestManualFanoutDisconnect(channelName, endpoint) {
+        const state = this.manualFanoutSubscribers.get(manualFanoutSubscriberKey(channelName, endpoint));
+        if (state === undefined)
+            return;
+        state.desired = false;
+        this.enqueueManualFanoutTransition(state, async () => {
+            try {
+                await this.closeManualFanoutSubscriber(state);
+            }
+            finally {
+                await this.lane.run(() => {
+                    if (!state.desired)
+                        this.manualFanoutSubscribers.delete(state.connectionId);
+                });
+            }
+        });
+    }
+    enqueueManualFanoutTransition(state, transition) {
+        state.transition = state.transition
+            .then(() => startOutsideStateLane(transition), () => startOutsideStateLane(transition))
+            .catch(error => state.taskRunner.errorSink.reportRuntimeTaskException(`subscriber:${state.channelName}:manual:${state.index}:lifecycle`, error));
+    }
+    openManualFanoutSubscriber(state) {
+        const { channelName, endpoint, connectionId, taskRunner, dispatcher } = state;
+        if (this.disposed || !state.desired || this.taskRunner !== taskRunner) {
+            return Promise.resolve();
+        }
+        const token = Symbol(`manual-fanout:${channelName}:${endpoint}`);
+        state.openingToken = token;
+        let loop;
+        let reconnecting = false;
+        try {
+            const subscriber = this.options.sockets.openFanoutSubscriberConnection(channelName, connectionId, endpoint, {
+                onReady() { },
+                onTerminated: () => {
+                    if (this.disposed
+                        || (state.active?.token !== token && state.openingToken !== token)
+                        || reconnecting)
+                        return;
+                    reconnecting = true;
+                    setImmediate(() => {
+                        if (this.disposed
+                            || (state.active?.token !== token && state.openingToken !== token)) {
+                            reconnecting = false;
+                            return;
+                        }
+                        this.enqueueManualFanoutTransition(state, async () => {
+                            reconnecting = false;
+                            if (this.disposed || state.active?.token !== token)
+                                return;
+                            try {
+                                await this.closeManualFanoutSubscriber(state, token);
+                            }
+                            catch (error) {
+                                taskRunner.errorSink.reportRuntimeTaskException(`subscriber:${state.channelName}:manual:${state.index}:cleanup`, error);
+                            }
+                            if (this.shouldReconnectManualFanoutSubscriber(state)) {
+                                void this.openManualFanoutSubscriber(state).catch(error => taskRunner.errorSink
+                                    .reportRuntimeTaskException(`subscriber:${state.channelName}:manual:${state.index}:reconnect`, error));
+                            }
+                        });
+                    });
+                }
+            });
+            loop = new channel_receive_loops_1.ZLinkSubscriberReceiveLoop(this.options.adapter, subscriber, dispatcher, this.options.applicationJobQueue, message => this.options.sockets.handleFanoutInboundResult(connectionId, message, subscriber), this.receiveRoundRobin, error => taskRunner.errorSink.reportRuntimeTaskException(`subscriber:${state.channelName}:manual:${state.index}:dispatch`, error));
+            state.openingToken = undefined;
+            state.active = { token, loop };
+            this.subscriberReceiveLoops.push(loop);
+            return taskRunner.run(`subscriber:${channelName}:manual:${state.index}`, signal => loop.run(signal));
+        }
+        catch (error) {
+            state.openingToken = undefined;
+            return Promise.allSettled([
+                this.options.sockets.closeFanoutSubscriberConnection(connectionId)
+            ]).then(results => {
+                const closeError = results[0].status === 'rejected' ? results[0].reason : undefined;
+                if (closeError === undefined)
+                    throw error;
+                throw new AggregateError([error, closeError], `Fanout subscriber '${connectionId}' failed to open and close.`);
+            });
+        }
+    }
+    async closeManualFanoutSubscriber(state, expectedToken) {
+        const active = await this.lane.run(() => this.beginCloseManualFanoutSubscriberCore(state, expectedToken));
+        if (active === undefined)
+            return;
+        const errors = [];
+        try {
+            await startOutsideStateLane(() => active.loop.stop());
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        finally {
+            await this.lane.run(() => this.finishCloseManualFanoutSubscriberCore(state, active));
+        }
+        try {
+            await startOutsideStateLane(() => this.options.sockets.closeFanoutSubscriberConnection(state.connectionId));
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1) {
+            throw new AggregateError(errors, `Fanout subscriber '${state.connectionId}' cleanup failed.`);
+        }
+    }
+    shouldReconnectManualFanoutSubscriber(state) {
+        return !this.disposed && state.desired;
+    }
+    beginCloseManualFanoutSubscriberCore(state, expectedToken) {
+        const active = state.active;
+        if (active === undefined || (expectedToken !== undefined && active.token !== expectedToken)) {
+            return undefined;
+        }
+        state.active = undefined;
+        state.stopping = active;
+        return active;
+    }
+    finishCloseManualFanoutSubscriberCore(state, active) {
+        this.removeSubscriberReceiveLoopCore(active.loop);
+        state.stopping = undefined;
+    }
+    drainManualFanoutSubscriberCore(state) {
+        state.transition = state.transition.then(() => startOutsideStateLane(() => this.closeManualFanoutSubscriber(state)), () => startOutsideStateLane(() => this.closeManualFanoutSubscriber(state)));
+        return state.transition;
+    }
+    startFanoutSubscriberLoop(channelName, connectionId, subscriber) {
+        const taskRunner = this.taskRunner;
+        const channel = this.options.registration.channels.get(channelName);
+        if (taskRunner === undefined || channel === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`Fanout subscriber '${channelName}' requires a running task runner.`);
+        }
+        const dispatcher = new channel_dispatchers_1.ZLinkChannelPublishDispatcher({
+            channelName,
+            codecs: this.options.codecs,
+            dispatchErrors: this.options.dispatchServices
+                .dispatchErrorReporter(taskRunner.errorSink),
+            handlers: new Map(channel.publishHandlers?.map(handler => [
+                handler.packetName,
+                handler.handler
+            ])),
+            filters: this.options.dispatchServices.handlerFilters(),
+            unhandled: this.options.registration.dispatch?.unhandled,
+            metrics: this.options.dispatchServices.metrics()
+        });
+        const loop = new channel_receive_loops_1.ZLinkSubscriberReceiveLoop(this.options.adapter, subscriber, dispatcher, this.options.applicationJobQueue, message => this.options.sockets.handleFanoutInboundResult(connectionId, message, subscriber), undefined, error => taskRunner.errorSink.reportRuntimeTaskException(`subscriber:${channelName}:automatic:${connectionId}:dispatch`, error));
+        this.subscriberReceiveLoops.push(loop);
+        void taskRunner.run(`subscriber:${channelName}:automatic:${connectionId}`, signal => loop.run(signal));
+        return async () => {
+            await startOutsideStateLane(() => loop.stop());
+            await this.lane.run(() => this.removeSubscriberReceiveLoopCore(loop));
+        };
+    }
+    removeSubscriberReceiveLoopCore(loop) {
+        const index = this.subscriberReceiveLoops.indexOf(loop);
+        if (index >= 0)
+            this.subscriberReceiveLoops.splice(index, 1);
+    }
+    startRouteReceivers(taskRunner) {
+        const tasks = [];
+        for (const routeChannel of this.options.registration.routeChannelOptions.values()) {
+            const spotRouteNode = this.options.spotRoutes.spotRouteNode(routeChannel.routerChannelId);
+            if (routeChannel.bind === undefined && spotRouteNode === undefined) {
+                continue;
+            }
+            const router = this.options.sockets.routeRouter(routeChannel.routerChannelId);
+            const spotRouteBridge = this.createSpotRouteBridgeForRouter(routeChannel.routerChannelId, router);
+            const handlers = [
+                ...(0, channel_dispatchers_1.collectRouteChannelHandlers)(routeChannel),
+                ...[...this.options.internalRouteSendHandlers?.entries() ?? []].map(([packetName, handler]) => ({
+                    kind: 'send', packetName, handler
+                })),
+                ...[...this.options.internalRouteRequestHandlers?.entries() ?? []].map(([packetName, handler]) => ({ kind: 'request', packetName, handler }))
+            ];
+            if (taskRunner === undefined) {
+                throw new configuration_1.ZLinkConfigurationException(`Route channel '${routeChannel.routerChannelId}' dispatch requires a runtime task runner.`);
+            }
+            const dispatcher = new channel_dispatchers_1.ZLinkRoutePacketDispatcher({
+                routerChannelId: routeChannel.routerChannelId,
+                codecs: this.options.codecs,
+                dispatchErrors: this.options.dispatchServices.dispatchErrorReporter(taskRunner.errorSink),
+                handlers,
+                unhandled: this.options.registration.dispatch?.unhandled,
+                spotRouteBridge
+            });
+            const loop = new channel_receive_loops_1.ZLinkRouteReceiveLoop(router, dispatcher, this.options.adapter.createReadablePoller(router), this.options.applicationJobQueue, this.receiveRoundRobin, error => taskRunner.errorSink.reportRuntimeTaskException(`route:${routeChannel.routerChannelId}:dispatch`, error));
+            this.routeReceiveLoops.push(loop);
+            tasks.push(taskRunner.run(`route:${routeChannel.routerChannelId}`, (signal) => loop.run(signal)));
+        }
+        return tasks;
+    }
+    createSpotRouteBridgeForRouter(channelName, router) {
+        const spotRouteNode = this.options.spotRoutes.spotRouteNode(channelName);
+        if (spotRouteNode === undefined) {
+            return undefined;
+        }
+        const bridge = spotRouteNode.createRouteBridge();
+        bridge.attachRouterChannel(channelName, router, {
+            capabilities: contracts_1.ZLINK_BACKEND_SPOT_ROUTE_BRIDGE_ROUTE_WITH_CHANNEL_INBOUND
+        });
+        this.options.spotRouteBridges.set(channelName, bridge);
+        return bridge;
+    }
+}
+exports.ZLinkChannelRuntimeLifecycle = ZLinkChannelRuntimeLifecycle;
+function adaptRouteRequestHandler(handler) {
+    return {
+        handle: async (payload, context) => handler.handle(payload, context)
+    };
+}
+function adaptRouteSendHandler(handler) {
+    return {
+        handle: async (payload, context) => {
+            await handler.handle(payload, context);
+        }
+    };
+}
+function requireChannelHandlerType(handlerType, channelName, packetName) {
+    if (handlerType === undefined) {
+        throw new configuration_1.ZLinkConfigurationException(`Channel '${channelName}' handler '${packetName}' has neither an instance nor a handler type.`);
+    }
+    return handlerType;
+}
+function meshChannelKey(meshName, channelName) {
+    return `${meshName}\u0000${channelName}`;
+}
+function manualFanoutSubscriberKey(channelName, endpoint) {
+    return `manual\0${channelName}\0${endpoint}`;
+}
+function hasClientServerLocationTopology(registration) {
+    for (const channel of registration.channels.values()) {
+        if (channel.server !== undefined
+            || (channel.client !== undefined && (channel.client.manualConnections?.length ?? 0) === 0)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasFanoutLocationTopology(registration) {
+    for (const channel of registration.channels.values()) {
+        if (channel.publisher !== undefined
+            || (channel.subscriber !== undefined
+                && (channel.subscriber.manualConnections?.length ?? 0) === 0)) {
+            return true;
+        }
+    }
+    return false;
+}
+function startOutsideStateLane(work) {
+    return detachedStateLaneResource.runInAsyncScope(work);
+}