@zlink-systems/framework 0.10.0

package/dist/runtime/channels/fanout-location-runtime.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkFanoutLocationRuntime = void 0;
+const node_crypto_1 = require("node:crypto");
+const Locations_1 = require("../../contracts/Locations");
+const Options_1 = require("../../contracts/Locations/Options");
+const configuration_1 = require("../configuration");
+const state_lane_1 = require("../execution/state-lane");
+class ZLinkFanoutLocationRuntime {
+    registration;
+    sockets;
+    locationRuntime;
+    stores;
+    onSubscriberOpened;
+    lane = new state_lane_1.ZLinkStateLane();
+    options;
+    store;
+    localDescriptors = new Map();
+    publisherIdentities = new Map();
+    connections = new Map();
+    controller;
+    timer;
+    constructor(registration, sockets, locationRuntime, stores, options, onSubscriberOpened) {
+        this.registration = registration;
+        this.sockets = sockets;
+        this.locationRuntime = locationRuntime;
+        this.stores = stores;
+        this.onSubscriberOpened = onSubscriberOpened;
+        if (stores.fanoutStore === undefined) {
+            throw new configuration_1.ZLinkConfigurationException('Automatic fanout requires a location store with dedicated fanout publisher operations.');
+        }
+        this.store = stores.fanoutStore;
+        this.options = { ...Options_1.zlinkRuntimeDefaultLocationOptions, ...options };
+    }
+    async start(signal) {
+        if (await this.lane.run(() => this.controller !== undefined))
+            return;
+        await this.publishLocalPublishers(signal);
+        await this.reconcileSubscribers(signal);
+        const started = await this.lane.run(() => {
+            if (this.controller !== undefined)
+                return false;
+            this.controller = new AbortController();
+            return true;
+        });
+        if (!started)
+            return;
+        this.schedule();
+    }
+    async tick(signal) {
+        await this.tickCore(signal);
+    }
+    async tickCore(signal) {
+        await this.publishLocalPublishers(signal);
+        await this.reconcileSubscribers(signal);
+    }
+    async stop(signal) {
+        const timer = await this.lane.run(() => {
+            this.controller?.abort();
+            this.controller = undefined;
+            const current = this.timer;
+            this.timer = undefined;
+            return current;
+        });
+        if (timer !== undefined)
+            clearTimeout(timer);
+        const connectionIds = await this.lane.run(() => [...this.connections.keys()]);
+        await Promise.allSettled(connectionIds.map(id => this.closeConnection(id)));
+        await this.removeLocalPublishers(signal);
+    }
+    activeTargets(channelName) {
+        return [...this.connections.values()]
+            .filter(target => target.state === 'ready')
+            .map(target => target.descriptor)
+            .filter(descriptor => descriptor.channelName === channelName);
+    }
+    async reclaimOwnerRows(signal) {
+        const owner = this.requireOwnerToken();
+        const descriptors = await this.lane.run(() => [...this.localDescriptors]);
+        for (const [channelName, current] of descriptors) {
+            if (current.ownerId === owner.ownerId
+                && current.leaseGeneration === owner.leaseGeneration) {
+                continue;
+            }
+            const candidate = {
+                ...current,
+                ownerId: owner.ownerId,
+                leaseGeneration: owner.leaseGeneration
+            };
+            const result = await this.store.updateFanoutPublisher(candidate, Locations_1.ZLinkLocationWriteIntent.Takeover, signal);
+            if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
+                throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor recovery was fenced.`);
+            }
+            await this.lane.run(() => this.localDescriptors.set(channelName, {
+                ...candidate,
+                updatedAt: result.updatedAt
+            }));
+        }
+    }
+    async publishLocalPublishers(signal) {
+        const owner = this.requireOwnerToken();
+        for (const [channelName, channel] of this.registration.channels) {
+            if (channel.publisher === undefined)
+                continue;
+            const publisher = this.sockets.publisher(channelName);
+            const endpoint = advertisedEndpoint(publisher.lastEndpoint ?? channel.publisher.bind ?? '', channel.publisher.advertiseHost);
+            if (endpoint.length === 0) {
+                throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' did not report a bound endpoint.`);
+            }
+            const current = await this.lane.run(() => this.localDescriptors.get(channelName));
+            if (current !== undefined) {
+                const result = await this.store.updateFanoutPublisher(current, Locations_1.ZLinkLocationWriteIntent.Renew, signal);
+                if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
+                    throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor renewal was fenced.`);
+                }
+                await this.lane.run(() => this.localDescriptors.set(channelName, {
+                    ...current,
+                    updatedAt: result.updatedAt
+                }));
+                continue;
+            }
+            const generatedLifecycle = BigInt(`0x${(0, node_crypto_1.randomUUID)().replaceAll('-', '').slice(0, 16)}`) & 0x7fffffffffffffffn;
+            const identity = await this.lane.run(() => {
+                const currentIdentity = this.publisherIdentities.get(channelName);
+                if (currentIdentity !== undefined)
+                    return currentIdentity;
+                const created = {
+                    publisherRid: channel.routingId
+                        ?? `${channel.routingIdPrefix ?? 'fanout'}-${(0, node_crypto_1.randomUUID)()}`,
+                    lifecycleGeneration: generatedLifecycle === 0n
+                        ? 1n
+                        : generatedLifecycle
+                };
+                this.publisherIdentities.set(channelName, created);
+                return created;
+            });
+            const descriptor = {
+                channelName,
+                publisherRid: identity.publisherRid,
+                lifecycleGeneration: identity.lifecycleGeneration,
+                descriptorRevision: 1n,
+                endpoint,
+                state: Locations_1.ZLinkFrameworkRuntimeState.Serving,
+                securityIdentity: 'default',
+                ownerId: owner.ownerId,
+                leaseGeneration: owner.leaseGeneration,
+                updatedAt: new Date(0)
+            };
+            const result = await this.store.updateFanoutPublisher(descriptor, Locations_1.ZLinkLocationWriteIntent.NewClaim, signal);
+            if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
+                throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor claim failed with '${result.status}'.`);
+            }
+            await this.lane.run(() => this.localDescriptors.set(channelName, {
+                ...descriptor,
+                updatedAt: result.updatedAt
+            }));
+        }
+    }
+    async reconcileSubscribers(signal) {
+        for (const [channelName, channel] of this.registration.channels) {
+            if (channel.subscriber === undefined
+                || (channel.subscriber.manualConnections?.length ?? 0) > 0) {
+                continue;
+            }
+            const rows = await this.listLivePublishers(channelName, signal);
+            const desired = new Map(rows.map(row => [
+                fanoutConnectionId(row),
+                row
+            ]));
+            for (const [connectionId, descriptor] of desired) {
+                const current = await this.lane.run(() => this.connections.get(connectionId));
+                if (current === undefined) {
+                    await this.openConnection(connectionId, descriptor);
+                    continue;
+                }
+                if (descriptor.descriptorRevision
+                    < current.descriptor.descriptorRevision) {
+                    continue;
+                }
+                if (descriptor.descriptorRevision
+                    === current.descriptor.descriptorRevision) {
+                    if (!sameFanoutDescriptor(descriptor, current.descriptor)) {
+                        await this.closeConnection(connectionId);
+                    }
+                    continue;
+                }
+                if (!sameFanoutImmutableIdentity(descriptor, current.descriptor)) {
+                    await this.closeConnection(connectionId);
+                    continue;
+                }
+                await this.lane.run(() => {
+                    if (this.connections.get(connectionId) === current)
+                        current.descriptor = descriptor;
+                });
+                if (current.state === 'ready') {
+                    this.sockets.admitFanoutPublisher(descriptor, connectionId);
+                }
+            }
+            const connections = await this.lane.run(() => [...this.connections]);
+            for (const [connectionId, current] of connections) {
+                if (current.descriptor.channelName === channelName
+                    && !desired.has(connectionId)) {
+                    await this.closeConnection(connectionId);
+                }
+            }
+        }
+    }
+    async openConnection(connectionId, descriptor) {
+        let target;
+        const subscriber = this.sockets.openFanoutSubscriberConnection(descriptor.channelName, connectionId, descriptor.endpoint, {
+            onReady: () => {
+                const current = this.connections.get(connectionId);
+                if (target !== undefined && current === target) {
+                    current.state = 'ready';
+                    this.sockets.admitFanoutPublisher(descriptor, connectionId);
+                }
+            },
+            onTerminated: () => {
+                const current = this.connections.get(connectionId);
+                if (target !== undefined
+                    && current === target
+                    && current.reconnectEligible) {
+                    this.sockets.removeFanoutPublisher(descriptor, connectionId);
+                    current.state = 'connecting';
+                    setImmediate(() => {
+                        void this.replaceConnection(current)
+                            .catch(error => this.locationRuntime.reportDiscoveryFailure(error));
+                    });
+                }
+            }
+        });
+        target = {
+            descriptor,
+            connectionId,
+            subscriber,
+            reconnectEligible: true,
+            stopReceiver: async () => { },
+            state: 'connecting'
+        };
+        await this.lane.run(() => this.connections.set(connectionId, target));
+        target.stopReceiver = this.onSubscriberOpened(descriptor.channelName, connectionId, subscriber);
+    }
+    async closeConnection(connectionId) {
+        const current = await this.lane.run(() => {
+            const target = this.connections.get(connectionId);
+            if (target !== undefined) {
+                target.reconnectEligible = false;
+                this.connections.delete(connectionId);
+            }
+            return target;
+        });
+        if (current === undefined)
+            return;
+        this.sockets.removeFanoutPublisher(current.descriptor, connectionId);
+        await current.stopReceiver();
+        await this.sockets.closeFanoutSubscriberConnection(connectionId);
+    }
+    async replaceConnection(expected) {
+        const prepared = await this.lane.run(() => {
+            const controller = this.controller;
+            if (this.connections.get(expected.connectionId) !== expected
+                || !expected.reconnectEligible
+                || controller === undefined)
+                return undefined;
+            return { controller, descriptor: expected.descriptor };
+        });
+        if (prepared === undefined) {
+            return;
+        }
+        await this.closeConnection(expected.connectionId);
+        if (await this.lane.run(() => this.controller === prepared.controller)) {
+            await this.openConnection(expected.connectionId, prepared.descriptor);
+        }
+    }
+    async listLivePublishers(channelName, signal) {
+        const rows = [];
+        let continuationToken;
+        do {
+            const page = await this.store.listFanoutPublishers(channelName, { pageSize: 1000, continuationToken }, signal);
+            rows.push(...page.items);
+            continuationToken = page.continuationToken;
+        } while (continuationToken !== undefined);
+        const live = [];
+        for (const descriptor of rows) {
+            if (descriptor.state !== Locations_1.ZLinkFrameworkRuntimeState.Serving)
+                continue;
+            const lease = await this.storeOwnerLease(descriptor.ownerId, signal);
+            if (lease.kind === 'found'
+                && lease.token.leaseGeneration === descriptor.leaseGeneration
+                && lease.leaseExpiresAt.getTime() > lease.storeNow.getTime()) {
+                live.push(descriptor);
+            }
+        }
+        return live;
+    }
+    storeOwnerLease(ownerId, signal) {
+        return this.stores.ownerLeaseStore.readOwnerLease(ownerId, signal);
+    }
+    async removeLocalPublishers(signal) {
+        const owner = this.locationRuntime.currentOwnerToken;
+        if (owner === undefined)
+            return;
+        const descriptors = await this.lane.run(() => [...this.localDescriptors.values()]);
+        for (const descriptor of descriptors) {
+            await this.store.removeFanoutPublisher({
+                channelName: descriptor.channelName,
+                publisherRid: descriptor.publisherRid
+            }, owner, signal);
+        }
+        await this.lane.run(() => this.localDescriptors.clear());
+    }
+    requireOwnerToken() {
+        const token = this.locationRuntime.currentOwnerToken;
+        if (token === undefined) {
+            throw new configuration_1.ZLinkConfigurationException('Fanout descriptor publication requires an active owner lease.');
+        }
+        return token;
+    }
+    schedule() {
+        if (this.controller === undefined)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            void this.tickCore(this.controller?.signal)
+                .catch(error => this.locationRuntime.reportDiscoveryFailure(error))
+                .finally(() => this.schedule());
+        }, this.options.pollingIntervalMs);
+        this.timer.unref();
+    }
+}
+exports.ZLinkFanoutLocationRuntime = ZLinkFanoutLocationRuntime;
+function advertisedEndpoint(boundEndpoint, advertiseHost) {
+    const result = (0, configuration_1.buildAdvertisedEndpoint)(boundEndpoint, advertiseHost);
+    if (result === undefined) {
+        throw new configuration_1.ZLinkConfigurationException(`Fanout publisher bound endpoint '${boundEndpoint}' cannot be advertised.`);
+    }
+    return result;
+}
+function fanoutConnectionId(descriptor) {
+    return `${descriptor.channelName}\0${String(descriptor.publisherRid)}\0`
+        + descriptor.lifecycleGeneration.toString();
+}
+function sameFanoutImmutableIdentity(left, right) {
+    return left.channelName === right.channelName
+        && left.publisherRid === right.publisherRid
+        && left.lifecycleGeneration === right.lifecycleGeneration
+        && left.endpoint === right.endpoint
+        && left.securityIdentity === right.securityIdentity
+        && left.ownerId === right.ownerId
+        && left.leaseGeneration === right.leaseGeneration;
+}
+function sameFanoutDescriptor(left, right) {
+    return sameFanoutImmutableIdentity(left, right)
+        && left.descriptorRevision === right.descriptorRevision
+        && left.state === right.state;
+}

package/dist/runtime/channels/fanout-service-wire.d.ts

@@ -0,0 +1,12 @@
+import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
+export declare const FANOUT_LIVENESS_TOPIC = "\u0001ZLF1";
+export declare const FANOUT_LIVENESS_PAYLOAD: Uint8Array<ArrayBuffer>;
+export type ZLinkFanoutInboundKind = 'application' | 'beacon' | 'protocolError';
+export interface ZLinkFanoutInboundClassification {
+    readonly kind: ZLinkFanoutInboundKind;
+    readonly header?: ZLinkChannelEnvelopeHeader;
+}
+export declare function inspectFanoutInbound(topic: string, parts: readonly {
+    data(): Uint8Array;
+}[]): ZLinkFanoutInboundClassification;
+export declare function requirePublicFanoutTopic(topic: string): void;

package/dist/runtime/channels/fanout-service-wire.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FANOUT_LIVENESS_PAYLOAD = exports.FANOUT_LIVENESS_TOPIC = void 0;
+exports.inspectFanoutInbound = inspectFanoutInbound;
+exports.requirePublicFanoutTopic = requirePublicFanoutTopic;
+const configuration_1 = require("../configuration");
+const channel_envelope_inspection_1 = require("./channel-envelope-inspection");
+exports.FANOUT_LIVENESS_TOPIC = '\x01ZLF1';
+exports.FANOUT_LIVENESS_PAYLOAD = Uint8Array.from([0x5a, 0x46, 0x01, 0x01]);
+function inspectFanoutInbound(topic, parts) {
+    if (topic !== exports.FANOUT_LIVENESS_TOPIC) {
+        const header = (0, channel_envelope_inspection_1.tryDecodeChannelHeader)(parts);
+        return header === undefined
+            ? { kind: 'protocolError' }
+            : { kind: 'application', header };
+    }
+    if (parts.length !== 1)
+        return { kind: 'protocolError' };
+    const payload = parts[0].data();
+    return payload.length === exports.FANOUT_LIVENESS_PAYLOAD.length
+        && payload.every((value, index) => value === exports.FANOUT_LIVENESS_PAYLOAD[index])
+        ? { kind: 'beacon' }
+        : { kind: 'protocolError' };
+}
+function requirePublicFanoutTopic(topic) {
+    if (topic === exports.FANOUT_LIVENESS_TOPIC) {
+        throw new configuration_1.ZLinkConfigurationException('Fanout topic is reserved for framework liveness.');
+    }
+}

package/dist/runtime/channels/handler-filter-scope.d.ts

@@ -0,0 +1,8 @@
+import type { Type, ZLinkHandlerFilterContext } from '../../contracts';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+export interface ZLinkHandlerFilterScopeResolver {
+    resolve<T>(type: Type<T>): Promise<T>;
+}
+export type ZLinkHandlerFilterScopeRunner = <T>(context: ZLinkHandlerFilterContext, callback: (resolver: ZLinkHandlerFilterScopeResolver) => Promise<T>) => Promise<T>;
+export declare function registerHandlerFilterScope(providerResolver: ZLinkProviderResolver, runner: ZLinkHandlerFilterScopeRunner): void;
+export declare function handlerFilterScope(providerResolver: ZLinkProviderResolver | undefined): ZLinkHandlerFilterScopeRunner | undefined;

package/dist/runtime/channels/handler-filter-scope.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHandlerFilterScope = registerHandlerFilterScope;
+exports.handlerFilterScope = handlerFilterScope;
+const handlerFilterScopes = new WeakMap();
+function registerHandlerFilterScope(providerResolver, runner) {
+    handlerFilterScopes.set(providerResolver, runner);
+}
+function handlerFilterScope(providerResolver) {
+    return providerResolver === undefined ? undefined : handlerFilterScopes.get(providerResolver);
+}

package/dist/runtime/channels/index.d.ts

@@ -0,0 +1,9 @@
+export { ZLinkChannelRuntimeManager, type ZLinkChannelRuntimeManagerOptions } from './channel-runtime-manager';
+export { ZLinkClientServerLocationRuntime } from './client-server-location-runtime';
+export { ZLinkRuntimeRouteTransport, type ZLinkChannelClientTransport, type ZLinkChannelClientTransportSource, type ZLinkRouteClientTransport, type ZLinkSpotPublisherClientTransport } from './channel-transports';
+export { DefaultZLinkChannelRuntimeOptions } from './channel-socket-options';
+export { ZLinkDispatchErrorReporter, type ZLinkDispatchErrorSink } from './dispatch-error-reporter';
+export { ZLinkRouteDisconnectedError } from './route-disconnected-error';
+export { DefaultZLinkChannelClient, DefaultZLinkFanoutClient, DefaultZLinkRouteClient, DefaultZLinkSpotPublisherClient } from './channel-clients';
+export { ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT, ZLinkChannelReceiveLoop, ZLinkReceiveRoundRobinCoordinator, ZLinkRouteReceiveLoop, ZLinkSubscriberReceiveLoop } from './channel-receive-loops';
+export { ZLinkChannelPublishDispatcher, ZLinkChannelRequestDispatcher, ZLinkRoutePacketDispatcher, type ZLinkChannelPublishDispatcherOptions, type ZLinkChannelRequestDispatcherOptions, type ZLinkChannelRequestHandler, type ZLinkChannelSendHandler, type ZLinkRouteHandlerRegistration, type ZLinkRoutePacketDispatcherOptions, type ZLinkRouteRuntimeRequestHandler, type ZLinkRouteRuntimeSendHandler, type ZLinkRuntimePublishHandler } from './channel-dispatchers';

package/dist/runtime/channels/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkRoutePacketDispatcher = exports.ZLinkChannelRequestDispatcher = exports.ZLinkChannelPublishDispatcher = exports.ZLinkSubscriberReceiveLoop = exports.ZLinkRouteReceiveLoop = exports.ZLinkReceiveRoundRobinCoordinator = exports.ZLinkChannelReceiveLoop = exports.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT = exports.DefaultZLinkSpotPublisherClient = exports.DefaultZLinkRouteClient = exports.DefaultZLinkFanoutClient = exports.DefaultZLinkChannelClient = exports.ZLinkRouteDisconnectedError = exports.ZLinkDispatchErrorReporter = exports.DefaultZLinkChannelRuntimeOptions = exports.ZLinkRuntimeRouteTransport = exports.ZLinkClientServerLocationRuntime = exports.ZLinkChannelRuntimeManager = void 0;
+var channel_runtime_manager_1 = require("./channel-runtime-manager");
+Object.defineProperty(exports, "ZLinkChannelRuntimeManager", { enumerable: true, get: function () { return channel_runtime_manager_1.ZLinkChannelRuntimeManager; } });
+var client_server_location_runtime_1 = require("./client-server-location-runtime");
+Object.defineProperty(exports, "ZLinkClientServerLocationRuntime", { enumerable: true, get: function () { return client_server_location_runtime_1.ZLinkClientServerLocationRuntime; } });
+var channel_transports_1 = require("./channel-transports");
+Object.defineProperty(exports, "ZLinkRuntimeRouteTransport", { enumerable: true, get: function () { return channel_transports_1.ZLinkRuntimeRouteTransport; } });
+var channel_socket_options_1 = require("./channel-socket-options");
+Object.defineProperty(exports, "DefaultZLinkChannelRuntimeOptions", { enumerable: true, get: function () { return channel_socket_options_1.DefaultZLinkChannelRuntimeOptions; } });
+var dispatch_error_reporter_1 = require("./dispatch-error-reporter");
+Object.defineProperty(exports, "ZLinkDispatchErrorReporter", { enumerable: true, get: function () { return dispatch_error_reporter_1.ZLinkDispatchErrorReporter; } });
+var route_disconnected_error_1 = require("./route-disconnected-error");
+Object.defineProperty(exports, "ZLinkRouteDisconnectedError", { enumerable: true, get: function () { return route_disconnected_error_1.ZLinkRouteDisconnectedError; } });
+var channel_clients_1 = require("./channel-clients");
+Object.defineProperty(exports, "DefaultZLinkChannelClient", { enumerable: true, get: function () { return channel_clients_1.DefaultZLinkChannelClient; } });
+Object.defineProperty(exports, "DefaultZLinkFanoutClient", { enumerable: true, get: function () { return channel_clients_1.DefaultZLinkFanoutClient; } });
+Object.defineProperty(exports, "DefaultZLinkRouteClient", { enumerable: true, get: function () { return channel_clients_1.DefaultZLinkRouteClient; } });
+Object.defineProperty(exports, "DefaultZLinkSpotPublisherClient", { enumerable: true, get: function () { return channel_clients_1.DefaultZLinkSpotPublisherClient; } });
+var channel_receive_loops_1 = require("./channel-receive-loops");
+Object.defineProperty(exports, "ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT", { enumerable: true, get: function () { return channel_receive_loops_1.ZLINK_CHANNEL_RAW_RECEIVE_RESERVATION_LIMIT; } });
+Object.defineProperty(exports, "ZLinkChannelReceiveLoop", { enumerable: true, get: function () { return channel_receive_loops_1.ZLinkChannelReceiveLoop; } });
+Object.defineProperty(exports, "ZLinkReceiveRoundRobinCoordinator", { enumerable: true, get: function () { return channel_receive_loops_1.ZLinkReceiveRoundRobinCoordinator; } });
+Object.defineProperty(exports, "ZLinkRouteReceiveLoop", { enumerable: true, get: function () { return channel_receive_loops_1.ZLinkRouteReceiveLoop; } });
+Object.defineProperty(exports, "ZLinkSubscriberReceiveLoop", { enumerable: true, get: function () { return channel_receive_loops_1.ZLinkSubscriberReceiveLoop; } });
+var channel_dispatchers_1 = require("./channel-dispatchers");
+Object.defineProperty(exports, "ZLinkChannelPublishDispatcher", { enumerable: true, get: function () { return channel_dispatchers_1.ZLinkChannelPublishDispatcher; } });
+Object.defineProperty(exports, "ZLinkChannelRequestDispatcher", { enumerable: true, get: function () { return channel_dispatchers_1.ZLinkChannelRequestDispatcher; } });
+Object.defineProperty(exports, "ZLinkRoutePacketDispatcher", { enumerable: true, get: function () { return channel_dispatchers_1.ZLinkRoutePacketDispatcher; } });

package/dist/runtime/channels/local-spot-route-transport.d.ts

@@ -0,0 +1,9 @@
+import type { RoutingId } from '../../contracts';
+import type { ZLinkLocalSpotRouteDispatcher } from './spot-route-dispatch-strategy';
+export declare class ZLinkLocalSpotRouteTransport {
+    private readonly dispatcher;
+    private readonly defaultRequestTimeoutMs;
+    constructor(dispatcher: ZLinkLocalSpotRouteDispatcher | undefined, defaultRequestTimeoutMs: number | undefined);
+    send(routerChannelId: string, spotId: RoutingId, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    request<TReply>(routerChannelId: string, spotId: RoutingId, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+}

package/dist/runtime/channels/local-spot-route-transport.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkLocalSpotRouteTransport = void 0;
+const configuration_1 = require("../configuration");
+class ZLinkLocalSpotRouteTransport {
+    dispatcher;
+    defaultRequestTimeoutMs;
+    constructor(dispatcher, defaultRequestTimeoutMs) {
+        this.dispatcher = dispatcher;
+        this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
+    }
+    async send(routerChannelId, spotId, packetName, message, signal, metadata, timeoutMs) {
+        if (this.dispatcher === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`Route channel '${routerChannelId}' could not dispatch local SPOT send.`);
+        }
+        await this.dispatcher.send(spotId, packetName, message, {
+            channelName: routerChannelId,
+            admissionTimeoutMs: timeoutMs ?? this.defaultRequestTimeoutMs,
+            signal,
+            metadata
+        });
+    }
+    request(routerChannelId, spotId, packetName, request, timeoutMs, signal) {
+        if (this.dispatcher === undefined) {
+            throw new configuration_1.ZLinkConfigurationException(`Route channel '${routerChannelId}' could not dispatch local SPOT request.`);
+        }
+        const pending = this.dispatcher.request(spotId, packetName, request, {
+            channelName: routerChannelId,
+            signal
+        });
+        const effectiveTimeoutMs = timeoutMs ?? this.defaultRequestTimeoutMs;
+        if (effectiveTimeoutMs === undefined)
+            return pending;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new configuration_1.ZLinkConfigurationException(`Route channel '${routerChannelId}' local SPOT request timed out.`)), effectiveTimeoutMs);
+            pending.then((value) => { clearTimeout(timeout); resolve(value); }, (error) => { clearTimeout(timeout); reject(error); });
+        });
+    }
+}
+exports.ZLinkLocalSpotRouteTransport = ZLinkLocalSpotRouteTransport;

package/dist/runtime/channels/route-disconnected-error.d.ts

@@ -0,0 +1,3 @@
+export declare class ZLinkRouteDisconnectedError extends Error {
+    constructor(message: string);
+}

package/dist/runtime/channels/route-disconnected-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkRouteDisconnectedError = void 0;
+class ZLinkRouteDisconnectedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ZLinkRouteDisconnectedError';
+    }
+}
+exports.ZLinkRouteDisconnectedError = ZLinkRouteDisconnectedError;

package/dist/runtime/channels/route-member-snapshot.d.ts

@@ -0,0 +1,10 @@
+export type ZLinkRouteMemberStatus = 'unknown' | 'missing' | 'connected' | 'disconnected';
+export declare class ZLinkRouteMemberSnapshot {
+    private readonly members;
+    private readonly connected;
+    private readonly memberByEndpoint;
+    clear(): void;
+    observeReady(channel: string, routingId: string, endpoint: string): void;
+    observeTermination(channel: string, routingId: string | undefined, endpoint: string): string | undefined;
+    status(channel: string, routingId: string): ZLinkRouteMemberStatus;
+}

package/dist/runtime/channels/route-member-snapshot.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkRouteMemberSnapshot = void 0;
+class ZLinkRouteMemberSnapshot {
+    members = new Map();
+    connected = new Map();
+    memberByEndpoint = new Map();
+    clear() {
+        this.members.clear();
+        this.connected.clear();
+        this.memberByEndpoint.clear();
+    }
+    observeReady(channel, routingId, endpoint) {
+        getOrCreateSet(this.members, channel).add(routingId);
+        getOrCreateSet(this.connected, channel).add(routingId);
+        if (endpoint.length > 0)
+            getOrCreateMap(this.memberByEndpoint, channel).set(endpoint, routingId);
+    }
+    observeTermination(channel, routingId, endpoint) {
+        const connected = this.connected.get(channel);
+        const disconnected = routingId
+            ?? this.memberByEndpoint.get(channel)?.get(endpoint)
+            ?? (connected?.size === 1 ? connected.values().next().value : undefined);
+        if (disconnected === undefined)
+            return undefined;
+        getOrCreateSet(this.members, channel).add(disconnected);
+        connected?.delete(disconnected);
+        return disconnected;
+    }
+    status(channel, routingId) {
+        const members = this.members.get(channel);
+        if (members === undefined || members.size === 0)
+            return 'unknown';
+        if (!members.has(routingId))
+            return 'missing';
+        return this.connected.get(channel)?.has(routingId) === true ? 'connected' : 'disconnected';
+    }
+}
+exports.ZLinkRouteMemberSnapshot = ZLinkRouteMemberSnapshot;
+function getOrCreateSet(map, key) {
+    let values = map.get(key);
+    if (values === undefined) {
+        values = new Set();
+        map.set(key, values);
+    }
+    return values;
+}
+function getOrCreateMap(map, key) {
+    let values = map.get(key);
+    if (values === undefined) {
+        values = new Map();
+        map.set(key, values);
+    }
+    return values;
+}

package/dist/runtime/channels/router-socket-spot-route-transport.d.ts

@@ -0,0 +1,12 @@
+import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkBackendSendFlags } from '../backend/contracts';
+import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
+import { type ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
+import type { ZLinkChannelSocketRegistry } from './channel-socket-registry';
+export declare class ZLinkRouterSocketSpotRouteTransport {
+    private readonly sockets;
+    constructor(sockets: ZLinkChannelSocketRegistry);
+    send(target: ZLinkSpotRouteTarget, parts: readonly Message[], flags: ZLinkBackendSendFlags, signal?: AbortSignal): Promise<void>;
+    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, flags: ZLinkBackendSendFlags, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+}

package/dist/runtime/channels/router-socket-spot-route-transport.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkRouterSocketSpotRouteTransport = void 0;
+const abort_1 = require("../abort");
+const channel_envelope_1 = require("./channel-envelope");
+class ZLinkRouterSocketSpotRouteTransport {
+    sockets;
+    constructor(sockets) {
+        this.sockets = sockets;
+    }
+    async send(target, parts, flags, signal) {
+        const router = this.sockets.routeRouter(target.routerChannelId);
+        try {
+            await (0, abort_1.awaitWithAbort)(router.sendToSpot(target.targetNodeRid, target.spotId, parts, flags), signal);
+        }
+        finally {
+            (0, channel_envelope_1.closeMessages)(parts);
+        }
+    }
+    async request(target, parts, codecs, flags, timeoutMs, signal) {
+        const router = this.sockets.routeRouter(target.routerChannelId);
+        void flags;
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs);
+        const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
+            void operation.then(channel_envelope_1.closeMessages, () => undefined);
+        });
+        try {
+            return (0, channel_envelope_1.decodeChannelReply)(replyParts, codecs);
+        }
+        finally {
+            (0, channel_envelope_1.closeMessages)(replyParts);
+            (0, channel_envelope_1.closeMessages)(parts);
+        }
+    }
+    async requestRaw(target, request, timeoutMs, signal) {
+        const router = this.sockets.routeRouter(target.routerChannelId);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, [request], timeoutMs);
+        return await (0, abort_1.awaitWithAbort)(operation, signal, () => {
+            void operation.then(channel_envelope_1.closeMessages, () => undefined);
+        });
+    }
+}
+exports.ZLinkRouterSocketSpotRouteTransport = ZLinkRouterSocketSpotRouteTransport;