@zlink-systems/framework 0.26.0 → 0.28.0

package/dist/runtime/channels/fanout-location-runtime.d.ts

@@ -1,8 +1,8 @@
 import { type ZLinkFanoutPublisherDescriptor } from '../../contracts/Locations';
 import { type ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
-import type { ZLinkFrameworkRegistration } from '../configuration';
-import type { ZLinkLocationRuntime, ZLinkLocationRuntimeStores } from '../locations';
 import type { ZLinkBackendSubscriberSocket } from '../backend/contracts';
+import { type ZLinkFrameworkRegistration } from '../configuration';
+import type { ZLinkLocationRuntime, ZLinkLocationRuntimeStores } from '../locations';
 import { ZLinkChannelSocketRegistry } from './channel-socket-registry';
 export declare class ZLinkFanoutLocationRuntime {
     private readonly registration;
@@ -15,7 +15,7 @@ export declare class ZLinkFanoutLocationRuntime {
     private readonly store;
     private readonly localDescriptors;
     private readonly publisherIdentities;
-    private readonly connections;
+    private readonly targets;
     private controller?;
     private timer?;
     constructor(registration: ZLinkFrameworkRegistration, sockets: ZLinkChannelSocketRegistry, locationRuntime: ZLinkLocationRuntime, stores: ZLinkLocationRuntimeStores, options: ZLinkLocationOptionOverrides, onSubscriberOpened: (channelName: string, connectionId: string, subscriber: ZLinkBackendSubscriberSocket) => () => Promise<void>);
@@ -24,11 +24,24 @@ export declare class ZLinkFanoutLocationRuntime {
     private tickCore;
     stop(signal?: AbortSignal): Promise<void>;
     activeTargets(channelName: string): readonly ZLinkFanoutPublisherDescriptor[];
+    topologyTargets(channelName: string): {
+        channelName: string;
+        publisherRoutingId: string;
+        lifecycleGeneration: bigint;
+        descriptorRevision: bigint;
+        advertisedEndpoint: string;
+        state: "error" | "preparing" | "serving" | "retiring" | "stopped";
+    }[] | undefined;
+    private isAutomaticSubscriber;
     reclaimOwnerRows(signal?: AbortSignal): Promise<void>;
     private publishLocalPublishers;
     private reconcileSubscribers;
+    private reconcileConnection;
     private openConnection;
+    private removeTarget;
     private closeConnection;
+    private detachConnection;
+    private closeDetachedConnection;
     private replaceConnection;
     private listLivePublishers;
     private storeOwnerLease;

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

@@ -4,8 +4,11 @@ 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 Stores_1 = require("../../contracts/Locations/Stores");
 const configuration_1 = require("../configuration");
 const state_lane_1 = require("../execution/state-lane");
+const runtime_state_projections_1 = require("../foundation/runtime-state-projections");
+const event_loop_resources_1 = require("../foundation/event-loop-resources");
 class ZLinkFanoutLocationRuntime {
     registration;
     sockets;
@@ -17,7 +20,7 @@ class ZLinkFanoutLocationRuntime {
     store;
     localDescriptors = new Map();
     publisherIdentities = new Map();
-    connections = new Map();
+    targets = new Map();
     controller;
     timer;
     constructor(registration, sockets, locationRuntime, stores, options, onSubscriberOpened) {
@@ -64,16 +67,39 @@ class ZLinkFanoutLocationRuntime {
         });
         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);
+        const targets = await this.lane.run(() => [...this.targets]);
+        const targetResults = await Promise.allSettled(targets.map(([id, target]) => this.removeTarget(id, target)));
+        const publisherResults = await Promise.allSettled([this.removeLocalPublishers(signal)]);
+        (0, event_loop_resources_1.finishResourceCleanup)([...targetResults, ...publisherResults].flatMap((result) => result.status === 'rejected' ? [result.reason] : []));
     }
     activeTargets(channelName) {
-        return [...this.connections.values()]
-            .filter((target) => target.state === 'ready')
+        return [...this.targets.values()]
+            .filter((target) => target.connection?.state === 'ready')
             .map((target) => target.descriptor)
             .filter((descriptor) => descriptor.channelName === channelName);
     }
+    topologyTargets(channelName) {
+        if (!this.isAutomaticSubscriber(channelName))
+            return undefined;
+        return [...this.targets.values()]
+            .filter((target) => target.descriptor.channelName === channelName)
+            .map((target) => ({
+            channelName,
+            publisherRoutingId: String(target.descriptor.publisherRid),
+            lifecycleGeneration: target.descriptor.lifecycleGeneration,
+            descriptorRevision: target.descriptor.descriptorRevision,
+            advertisedEndpoint: target.descriptor.endpoint,
+            state: target.descriptor.state === Locations_1.ZLinkFrameworkRuntimeState.Serving
+                ? target.connection?.state === 'ready'
+                    ? 'serving'
+                    : 'preparing'
+                : (0, runtime_state_projections_1.discoveryAvailabilityForRuntimeState)(target.descriptor.state)
+        }));
+    }
+    isAutomaticSubscriber(channelName) {
+        const subscriber = this.registration.channels.get(channelName)?.subscriber;
+        return subscriber !== undefined && (subscriber.manualConnections?.length ?? 0) === 0;
+    }
     async reclaimOwnerRows(signal) {
         const owner = this.requireOwnerToken();
         const descriptors = await this.lane.run(() => [...this.localDescriptors]);
@@ -154,124 +180,150 @@ class ZLinkFanoutLocationRuntime {
         }
     }
     async reconcileSubscribers(signal) {
-        for (const [channelName, channel] of this.registration.channels) {
-            if (channel.subscriber === undefined ||
-                (channel.subscriber.manualConnections?.length ?? 0) > 0) {
+        for (const channelName of this.registration.channels.keys()) {
+            if (!this.isAutomaticSubscriber(channelName))
                 continue;
-            }
+            const previous = this.topologyTargets(channelName);
             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));
+                let current = await this.lane.run(() => this.targets.get(connectionId));
                 if (current === undefined) {
-                    await this.openConnection(connectionId, descriptor);
-                    continue;
+                    const created = { descriptor };
+                    current = created;
+                    await this.lane.run(() => this.targets.set(connectionId, created));
                 }
-                if (descriptor.descriptorRevision < current.descriptor.descriptorRevision) {
+                else if (descriptor.descriptorRevision < current.descriptor.descriptorRevision) {
                     continue;
                 }
-                if (descriptor.descriptorRevision === current.descriptor.descriptorRevision) {
+                else if (descriptor.descriptorRevision === current.descriptor.descriptorRevision) {
                     if (!sameFanoutDescriptor(descriptor, current.descriptor)) {
-                        await this.closeConnection(connectionId);
+                        await this.removeTarget(connectionId, current);
+                        continue;
                     }
-                    continue;
                 }
-                if (!sameFanoutImmutableIdentity(descriptor, current.descriptor)) {
-                    await this.closeConnection(connectionId);
+                else if (!sameFanoutImmutableIdentity(descriptor, current.descriptor)) {
+                    await this.removeTarget(connectionId, current);
                     continue;
                 }
-                await this.lane.run(() => {
-                    if (this.connections.get(connectionId) === current)
-                        current.descriptor = descriptor;
-                });
-                if (current.state === 'ready') {
-                    this.sockets.admitFanoutPublisher(descriptor, connectionId);
+                else {
+                    const target = current;
+                    await this.lane.run(() => {
+                        if (this.targets.get(connectionId) === target)
+                            target.descriptor = descriptor;
+                    });
+                    if (current.connection?.state === 'ready') {
+                        this.sockets.admitFanoutPublisher(current.descriptor, connectionId);
+                    }
                 }
+                await this.reconcileConnection(connectionId, current);
             }
-            const connections = await this.lane.run(() => [...this.connections]);
-            for (const [connectionId, current] of connections) {
+            const targets = await this.lane.run(() => [...this.targets]);
+            for (const [connectionId, current] of targets) {
                 if (current.descriptor.channelName === channelName && !desired.has(connectionId)) {
-                    await this.closeConnection(connectionId);
+                    await this.removeTarget(connectionId, current);
                 }
             }
+            const next = this.topologyTargets(channelName);
+            if (previous.length !== next.length ||
+                previous.some((publisher, index) => publisher.publisherRoutingId !== next[index].publisherRoutingId ||
+                    publisher.state !== next[index].state)) {
+                this.sockets.notifyFanoutTopology(channelName);
+            }
+        }
+    }
+    async reconcileConnection(connectionId, target) {
+        if (target.descriptor.state !== Locations_1.ZLinkFrameworkRuntimeState.Serving) {
+            await this.closeConnection(target);
+        }
+        else if (target.connection === undefined) {
+            await this.openConnection(connectionId, target);
         }
     }
-    async openConnection(connectionId, descriptor) {
-        let target;
+    async openConnection(connectionId, target) {
+        const descriptor = target.descriptor;
+        let connection;
         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);
+                if (connection !== undefined && target.connection === connection) {
+                    connection.state = 'ready';
+                    this.sockets.admitFanoutPublisher(target.descriptor, connectionId);
                 }
             },
             onTerminated: () => {
-                const current = this.connections.get(connectionId);
-                if (target !== undefined && current === target && current.reconnectEligible) {
-                    this.sockets.removeFanoutPublisher(descriptor, connectionId);
-                    current.state = 'connecting';
+                if (connection !== undefined && target.connection === connection) {
+                    this.sockets.removeFanoutPublisher(target.descriptor, connectionId);
+                    connection.state = 'connecting';
+                    const terminated = connection;
                     setImmediate(() => {
-                        void this.replaceConnection(current).catch((error) => this.locationRuntime.reportDiscoveryFailure(error));
+                        void this.replaceConnection(target, terminated).catch((error) => this.locationRuntime.reportDiscoveryFailure(error));
                     });
                 }
             }
         });
-        target = {
-            descriptor,
+        connection = {
             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);
+        const opened = connection;
+        await this.lane.run(() => (target.connection = opened));
+        connection.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;
+    async removeTarget(connectionId, target) {
+        const detached = await this.lane.run(() => {
+            if (this.targets.get(connectionId) !== target)
+                return undefined;
+            this.targets.delete(connectionId);
+            return this.detachConnection(target);
         });
+        await this.closeDetachedConnection(target.descriptor, detached);
+    }
+    async closeConnection(target) {
+        const detached = await this.lane.run(() => this.detachConnection(target));
+        await this.closeDetachedConnection(target.descriptor, detached);
+    }
+    detachConnection(target) {
+        const connection = target.connection;
+        target.connection = undefined;
+        return connection;
+    }
+    async closeDetachedConnection(descriptor, current) {
         if (current === undefined)
             return;
-        this.sockets.removeFanoutPublisher(current.descriptor, connectionId);
-        await current.stopReceiver();
-        await this.sockets.closeFanoutSubscriberConnection(connectionId);
+        this.sockets.removeFanoutPublisher(descriptor, current.connectionId);
+        await (0, event_loop_resources_1.closeResources)([
+            { close: () => current.stopReceiver() },
+            { close: () => this.sockets.closeFanoutSubscriberConnection(current.connectionId) }
+        ]);
     }
-    async replaceConnection(expected) {
+    async replaceConnection(target, expected) {
         const prepared = await this.lane.run(() => {
             const controller = this.controller;
-            if (this.connections.get(expected.connectionId) !== expected ||
-                !expected.reconnectEligible ||
+            if (this.targets.get(expected.connectionId) !== target ||
+                target.connection !== expected ||
                 controller === undefined)
                 return undefined;
-            return { controller, descriptor: expected.descriptor };
+            return controller;
         });
         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);
+        await this.closeConnection(target);
+        if (await this.lane.run(() => this.controller === prepared && this.targets.get(expected.connectionId) === target)) {
+            await this.reconcileConnection(expected.connectionId, target);
         }
     }
     async listLivePublishers(channelName, signal) {
         const rows = [];
         let continuationToken;
         do {
-            const page = await this.store.listFanoutPublishers(channelName, { pageSize: 1000, continuationToken }, signal);
+            const page = await this.store.listFanoutPublishers(channelName, { pageSize: Stores_1.ZLINK_PROVIDER_MAX_PAGE_SIZE, 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 &&
@@ -289,13 +341,19 @@ class ZLinkFanoutLocationRuntime {
         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);
+        try {
+            await (0, event_loop_resources_1.closeResources)(descriptors.map((descriptor) => ({
+                close: async () => {
+                    await this.store.removeFanoutPublisher({
+                        channelName: descriptor.channelName,
+                        publisherRid: descriptor.publisherRid
+                    }, owner, signal);
+                }
+            })));
+        }
+        finally {
+            await this.lane.run(() => this.localDescriptors.clear());
         }
-        await this.lane.run(() => this.localDescriptors.clear());
     }
     requireOwnerToken() {
         const token = this.locationRuntime.currentOwnerToken;

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

@@ -4,6 +4,6 @@ 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>;
+    send(routerChannelId: string, spotId: RoutingId, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): 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

@@ -9,14 +9,12 @@ class ZLinkLocalSpotRouteTransport {
         this.dispatcher = dispatcher;
         this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
     }
-    async send(routerChannelId, spotId, packetName, message, signal, metadata, timeoutMs) {
+    async send(routerChannelId, spotId, packetName, message, metadata) {
         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
         });
     }

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

@@ -6,7 +6,7 @@ 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>;
+    send(target: ZLinkSpotRouteTarget, parts: readonly Message[], flags: ZLinkBackendSendFlags): 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

@@ -8,10 +8,10 @@ class ZLinkRouterSocketSpotRouteTransport {
     constructor(sockets) {
         this.sockets = sockets;
     }
-    async send(target, parts, flags, signal) {
+    async send(target, parts, flags) {
         const router = this.sockets.routeRouter(target.routerChannelId);
         try {
-            await (0, abort_1.awaitWithAbort)(router.sendToSpot(target.targetNodeRid, target.spotId, parts, flags), signal);
+            await router.sendToSpot(target.targetNodeRid, target.spotId, parts, flags);
         }
         finally {
             (0, channel_envelope_1.closeMessages)(parts);

package/dist/runtime/channels/source-spot-router.d.ts

@@ -5,6 +5,6 @@ export declare class ZLinkSourceSpotRouter {
     private readonly defaultRequestTimeoutMs;
     constructor(defaultRequestTimeoutMs: number | undefined);
     request<TReply>(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    send(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    send(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     requestRaw(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
 }

package/dist/runtime/channels/source-spot-router.js

@@ -26,14 +26,12 @@ class ZLinkSourceSpotRouter {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async send(sourceSpot, target, packetName, message, signal, metadata, timeoutMs) {
-        (0, abort_1.throwIfAborted)(signal);
+    async send(sourceSpot, target, packetName, message, metadata) {
         const parts = [
             (0, spot_direct_envelope_1.encodeSpotDirectEnvelope)(3 /* ZLinkChannelMessageKind.Command */, target.routerChannelId, packetName, message, metadata)
         ];
         try {
-            void timeoutMs;
-            await (0, abort_1.awaitWithAbort)(sourceSpot.sendToSpot(target.targetNodeRid, target.spotId, parts), signal);
+            await sourceSpot.sendToSpot(target.targetNodeRid, target.spotId, parts);
         }
         finally {
             (0, channel_envelope_1.closeMessages)(parts);

package/dist/runtime/channels/spot-direct-envelope.d.ts

@@ -1,5 +1,6 @@
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendMessageLike as MessageLike } from '../backend/runtime-values';
 import { ZLinkChannelMessageKind } from './channel-envelope';
+export declare const SPOT_DIRECT_ENVELOPE = "zlink.framework.spot-direct.v1";
 export declare function encodeSpotDirectEnvelope(kind: ZLinkChannelMessageKind.Request | ZLinkChannelMessageKind.Command, channelName: string, packetName: string | undefined, payload: unknown, metadata?: ReadonlyMap<string, string>): MessageLike;
 export declare function decodeSpotDirectReply<TReply>(parts: readonly Message[]): TReply;

package/dist/runtime/channels/spot-direct-envelope.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPOT_DIRECT_ENVELOPE = void 0;
 exports.encodeSpotDirectEnvelope = encodeSpotDirectEnvelope;
 exports.decodeSpotDirectReply = decodeSpotDirectReply;
 const configuration_1 = require("../configuration");
-const SPOT_DIRECT_ENVELOPE = 'zlink.framework.spot-direct.v1';
+exports.SPOT_DIRECT_ENVELOPE = 'zlink.framework.spot-direct.v1';
 function encodeSpotDirectEnvelope(kind, channelName, packetName, payload, metadata) {
     return Buffer.from(JSON.stringify({
-        marker: SPOT_DIRECT_ENVELOPE,
+        marker: exports.SPOT_DIRECT_ENVELOPE,
         kind,
         channelName,
         packetName,
@@ -19,7 +20,7 @@ function decodeSpotDirectReply(parts) {
         throw new configuration_1.ZLinkConfigurationException('Spot direct reply is missing.');
     }
     const reply = JSON.parse(parts[0].data().toString());
-    if (reply.marker !== SPOT_DIRECT_ENVELOPE) {
+    if (reply.marker !== exports.SPOT_DIRECT_ENVELOPE) {
         throw new configuration_1.ZLinkConfigurationException('Spot direct reply marker is invalid.');
     }
     if (reply.ok !== true) {

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

@@ -7,7 +7,7 @@ export declare class ZLinkSpotNodeRouteTransport {
     private readonly registration;
     private readonly targets;
     constructor(registration: ZLinkFrameworkRegistration, targets: ZLinkSpotRouteTargetResolver);
-    send(target: ZLinkSpotRouteTarget, parts: readonly Message[], signal?: AbortSignal): Promise<boolean>;
+    send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<boolean>;
     request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply> | undefined;
     requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]> | undefined;
 }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotNodeRouteTransport = void 0;
+const Registration_1 = require("../../contracts/Configuration/Registration");
 const abort_1 = require("../abort");
 const channel_envelope_1 = require("./channel-envelope");
 class ZLinkSpotNodeRouteTransport {
@@ -10,14 +11,13 @@ class ZLinkSpotNodeRouteTransport {
         this.registration = registration;
         this.targets = targets;
     }
-    async send(target, parts, signal) {
+    async send(target, parts) {
         const router = this.targets.spotNodeRouter(target.routerChannelId);
         if (router === undefined) {
             return false;
         }
         try {
-            (0, abort_1.throwIfAborted)(signal);
-            await (0, abort_1.awaitWithAbort)(router.sendToSpot(target.targetNodeRid, target.spotId, parts), signal);
+            await router.sendToSpot(target.targetNodeRid, target.spotId, parts);
             return true;
         }
         finally {
@@ -29,7 +29,7 @@ class ZLinkSpotNodeRouteTransport {
         if (router === undefined) {
             return undefined;
         }
-        const effectiveTimeoutMs = timeoutMs ?? this.registration.requestTimeoutMs ?? 30_000;
+        const effectiveTimeoutMs = timeoutMs ?? this.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS;
         (0, abort_1.throwIfAborted)(signal);
         const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, effectiveTimeoutMs);
         return (0, abort_1.awaitWithAbort)(operation, signal, () => {
@@ -49,7 +49,7 @@ class ZLinkSpotNodeRouteTransport {
         if (router === undefined) {
             return undefined;
         }
-        const effectiveTimeoutMs = timeoutMs ?? this.registration.requestTimeoutMs ?? 30_000;
+        const effectiveTimeoutMs = timeoutMs ?? this.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS;
         (0, abort_1.throwIfAborted)(signal);
         const operation = router.requestToSpot(target.targetNodeRid, target.spotId, request, effectiveTimeoutMs);
         return (0, abort_1.awaitWithAbort)(operation, signal, () => {

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

@@ -7,7 +7,7 @@ export declare class ZLinkSpotRouteBridgeTransport {
     private readonly defaultRequestTimeoutMs;
     constructor(bridges: ReadonlyMap<string, ZLinkBackendSpotRouteBridge>, defaultRequestTimeoutMs: number | undefined);
     has(routerChannelId: string): boolean;
-    send(target: ZLinkSpotRouteTarget, parts: readonly Message[], signal?: AbortSignal): Promise<void>;
+    send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<void>;
     request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
     requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
     private requireBridge;

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

@@ -15,10 +15,10 @@ class ZLinkSpotRouteBridgeTransport {
     has(routerChannelId) {
         return this.bridges.has(routerChannelId);
     }
-    async send(target, parts, signal) {
+    async send(target, parts) {
         const bridge = this.requireBridge(target.routerChannelId);
         try {
-            await (0, abort_1.awaitWithAbort)((0, channel_multipart_1.appendParts)(bridge.send(target.routerChannelId, target.targetNodeRid, target.spotId), parts).submit(), signal);
+            await (0, channel_multipart_1.appendParts)(bridge.send(target.routerChannelId, target.targetNodeRid, target.spotId), parts).submit();
         }
         finally {
             (0, channel_envelope_1.closeMessages)(parts);

package/dist/runtime/channels/spot-route-dispatch-strategy.d.ts

@@ -8,8 +8,6 @@ import type { ZLinkChannelSocketRegistry } from './channel-socket-registry';
 export interface ZLinkLocalSpotRouteDispatcher {
     send(spotId: RoutingId, packetName: string | undefined, message: unknown, context: {
         readonly channelName: string;
-        readonly admissionTimeoutMs?: number;
-        readonly signal?: AbortSignal;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<void>;
     request<TReply>(spotId: RoutingId, packetName: string | undefined, request: unknown, context: {
@@ -39,12 +37,12 @@ export declare class ZLinkSpotRouteDispatchStrategy {
     spotRouteNode(routerChannelId: string): ZLinkBackendSpotNode | undefined;
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
-    routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     private routeSendToSpotScoped;
     routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     private routeRequestToSpotScoped;
     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>;
+    routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): 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[]>;
 }

package/dist/runtime/channels/spot-route-dispatch-strategy.js

@@ -41,35 +41,34 @@ class ZLinkSpotRouteDispatchStrategy {
     canRoutePacketChannel(routerChannelId) {
         return this.targets.canRoutePacketChannel(routerChannelId);
     }
-    routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
+    routeSendToSpot(spotRouteTarget, packetName, message, metadata) {
         // Call-scoped flow (spec 27 §4): the envelope flow pair lives only for
         // the duration of this outbound call, never in the caller's context.
-        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeSendToSpotScoped(spotRouteTarget, packetName, message, signal, metadata, timeoutMs));
+        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeSendToSpotScoped(spotRouteTarget, packetName, message, metadata));
     }
-    async routeSendToSpotScoped(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        (0, abort_1.throwIfAborted)(signal);
+    async routeSendToSpotScoped(spotRouteTarget, packetName, message, metadata) {
         const localSpotRouteNode = this.targets.localRouteNode(spotRouteTarget);
         if (localSpotRouteNode !== undefined) {
-            await this.localTransport.send(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, message, signal, metadata, timeoutMs);
+            await this.localTransport.send(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, message, metadata);
             return;
         }
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, spotRouteTarget.routerChannelId, packetName, message, undefined, undefined, (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.options.codecs), undefined, this.options.flowCreationEnabled?.() ?? true, metadata);
         if (this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId) &&
-            (await this.spotNodeTransport.send(spotRouteTarget, parts, signal))) {
+            (await this.spotNodeTransport.send(spotRouteTarget, parts))) {
             return;
         }
         if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-            await this.bridgeTransport.send(spotRouteTarget, parts, signal);
+            await this.bridgeTransport.send(spotRouteTarget, parts);
             return;
         }
         if (this.targets.hasBoundRouteRouter(spotRouteTarget.routerChannelId)) {
-            await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT, signal);
+            await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
             return;
         }
-        if (await this.spotNodeTransport.send(spotRouteTarget, parts, signal)) {
+        if (await this.spotNodeTransport.send(spotRouteTarget, parts)) {
             return;
         }
-        await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT, signal);
+        await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
     }
     routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
         return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata));
@@ -102,8 +101,8 @@ class ZLinkSpotRouteDispatchStrategy {
     routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
         return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
     }
-    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
+        await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
     routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal) {
         return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal);

package/dist/runtime/diagnostics/diagnostic-text.d.ts

@@ -0,0 +1,2 @@
+/** Formats absent diagnostic text consistently across the Node runtime. */
+export declare function diagnosticTextOrAbsent(value: string | null | undefined): string;

package/dist/runtime/diagnostics/diagnostic-text.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnosticTextOrAbsent = diagnosticTextOrAbsent;
+/** Formats absent diagnostic text consistently across the Node runtime. */
+function diagnosticTextOrAbsent(value) {
+    return value ?? '<none>';
+}