@zlink-systems/framework 0.27.0 → 0.28.0

package/dist/runtime/channels/channel-outbound-operations.js

@@ -5,6 +5,7 @@ exports.keepChannelRequestAlive = keepChannelRequestAlive;
 exports.requestTerminalResult = requestTerminalResult;
 exports.isRemoteChannelErrorReply = isRemoteChannelErrorReply;
 const framework_errors_internal_1 = require("../framework-errors-internal");
+const request_deadline_1 = require("../messaging/request-deadline");
 const runtime_values_1 = require("../backend/runtime-values");
 const submission_result_1 = require("../messaging/submission-result");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
@@ -32,16 +33,15 @@ class ZLinkChannelOutboundOperations {
     pendingRequestCount(channelName) {
         return this.pendingRequests.get(channelName) ?? 0;
     }
-    send(channelName, packetName, message, signal, metadata = EMPTY_OUTBOUND_METADATA) {
+    send(channelName, packetName, message, metadata = EMPTY_OUTBOUND_METADATA) {
         // Call-scoped flow (spec 27 §4): the envelope encoder and the trace
         // points below share one ambient flow that does not outlive this call.
-        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.sendScoped(channelName, packetName, message, signal, metadata));
+        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.sendScoped(channelName, packetName, message, metadata));
     }
-    async sendScoped(channelName, packetName, message, signal, metadata = EMPTY_OUTBOUND_METADATA) {
-        (0, abort_1.throwIfAborted)(signal);
-        const dealer = await this.sockets.awaitClientDealerForOutbound(channelName, signal);
+    async sendScoped(channelName, packetName, message, metadata = EMPTY_OUTBOUND_METADATA) {
+        const dealer = await this.sockets.awaitClientDealerForOutbound(channelName);
         if (dealer === undefined) {
-            return { status: submission_result_1.ZLinkSubmitStatus.TimedOut };
+            return { status: submission_result_1.ZLinkSubmitStatus.Shutdown };
         }
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, undefined, this.codecs, undefined, this.dispatchServices.flowCreationEnabled(), metadata);
         try {
@@ -49,17 +49,8 @@ class ZLinkChannelOutboundOperations {
         }
         catch (error) {
             (0, channel_envelope_1.closeMessages)(parts);
-            if (isSubmitDeadline(error)) {
-                this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Backpressured)?.trace({
-                    surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.Channel,
-                    messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send,
-                    channelName,
-                    channelRouteKind: 'client_server',
-                    packetName,
-                    correlationId: undefined,
-                    result: 'backpressured'
-                });
-                return { status: submission_result_1.ZLinkSubmitStatus.TimedOut };
+            if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'submit') {
+                return (0, submission_result_1.classifySubmitResult)(error.result, 'One-way send', error.phase);
             }
             throw error;
         }
@@ -81,6 +72,8 @@ class ZLinkChannelOutboundOperations {
         return keepChannelRequestAlive((0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.requestScoped(channelName, packetName, request, timeoutMs, signal, metadata)));
     }
     async requestScoped(channelName, packetName, request, timeoutMs, signal, metadata) {
+        const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
+        const deadlineUnixMs = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
         let correlationId;
         let selectedServerRid;
         let terminalRecorded = false;
@@ -101,14 +94,16 @@ class ZLinkChannelOutboundOperations {
         };
         try {
             (0, abort_1.throwIfAborted)(signal);
-            const dealer = await this.sockets.awaitClientDealerForOutbound(channelName, signal);
+            const readyWait = new AbortController();
+            const readySignal = signal === undefined ? readyWait.signal : AbortSignal.any([signal, readyWait.signal]);
+            const dealer = await (0, request_deadline_1.waitRequestReply)(this.sockets.awaitClientDealerForOutbound(channelName, readySignal), `Channel request '${channelName}'`, deadlineMs, signal, () => readyWait.abort());
             if (dealer === undefined) {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `Channel '${channelName}' has no ready ClientServer server before its admission deadline.`);
             }
             const serverRid = this.sockets.selectedClientServerRid(channelName, dealer);
             selectedServerRid = serverRid;
             correlationId = (0, channel_envelope_1.newChannelCorrelationId)();
-            const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, timeoutMs, undefined, this.codecs, correlationId, this.dispatchServices.flowCreationEnabled(), metadata);
+            const parts = (0, channel_envelope_1.encodeChannelEnvelopePartsAtDeadline)(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, deadlineUnixMs, undefined, this.codecs, correlationId, this.dispatchServices.flowCreationEnabled(), metadata);
             this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent)?.trace({
                 surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.Channel,
                 messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
@@ -122,7 +117,7 @@ class ZLinkChannelOutboundOperations {
                 let replyParts = [];
                 try {
                     try {
-                        replyParts = await (0, abort_1.awaitWithAbort)(dealer.request(parts, timeoutMs), signal);
+                        replyParts = await (0, abort_1.awaitWithAbort)(dealer.request(parts, (0, request_deadline_1.remainingRequestTimeout)(`Channel request '${channelName}'`, deadlineMs)), signal);
                     }
                     catch (error) {
                         if (signal?.aborted === true)
@@ -182,29 +177,18 @@ class ZLinkChannelOutboundOperations {
         publisher.publish(topic, parts);
         return publishResult(submission_result_1.ZLinkSubmitStatus.Submitted);
     }
-    routeSubmit(routerChannelId, targetNodeRid, packetName, message, signal, metadata = EMPTY_OUTBOUND_METADATA) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.routeSubmitScoped(routerChannelId, targetNodeRid, packetName, message, signal, metadata));
+    routeSubmit(routerChannelId, targetNodeRid, packetName, message, metadata = EMPTY_OUTBOUND_METADATA) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.routeSubmitScoped(routerChannelId, targetNodeRid, packetName, message, metadata));
     }
-    async routeSubmitScoped(routerChannelId, targetNodeRid, packetName, message, signal, metadata = EMPTY_OUTBOUND_METADATA) {
-        (0, abort_1.throwIfAborted)(signal);
+    async routeSubmitScoped(routerChannelId, targetNodeRid, packetName, message, metadata = EMPTY_OUTBOUND_METADATA) {
         const router = this.sockets.routeRouter(routerChannelId);
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, routerChannelId, packetName, message, undefined, undefined, (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.codecs), undefined, this.dispatchServices.flowCreationEnabled(), metadata);
         try {
             await router.send(targetNodeRid, parts);
         }
         catch (error) {
-            if (isSubmitDeadline(error)) {
-                this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Backpressured)?.trace({
-                    surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.RouteMeshChannel,
-                    messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send,
-                    channelName: routerChannelId,
-                    channelRouteKind: 'route_mesh',
-                    packetName,
-                    correlationId: undefined,
-                    targetRid: targetNodeRid,
-                    result: 'backpressured'
-                });
-                return { status: submission_result_1.ZLinkSubmitStatus.TimedOut };
+            if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'submit') {
+                return (0, submission_result_1.classifySubmitResult)(error.result, 'One-way send', error.phase);
             }
             throw error;
         }

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

@@ -44,16 +44,16 @@ export declare class ZLinkChannelRuntimeManager {
     dispatchMeshRoute(meshName: string, record: ReceiveRecord, signal?: AbortSignal): Promise<void>;
     dispatchLocalMeshRoute(meshName: string, sourceNodeRid: RoutingId, parts: readonly Message[], signal?: AbortSignal): Promise<void>;
     canDispatchLocalMeshRoute(meshName: string): boolean;
-    send(channelName: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    send(channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     tryPublish(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
-    routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
+    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[]>;
     canRouteChannel(routerChannelId: string): boolean;

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

@@ -138,8 +138,8 @@ class ZLinkChannelRuntimeManager {
     canDispatchLocalMeshRoute(meshName) {
         return this.lifecycle.canDispatchLocalMeshRoute(meshName);
     }
-    send(channelName, packetName, message, signal, metadata) {
-        return this.outbound.send(channelName, packetName, message, signal, metadata);
+    send(channelName, packetName, message, metadata) {
+        return this.outbound.send(channelName, packetName, message, metadata);
     }
     async request(channelName, packetName, request, timeoutMs, signal, metadata) {
         return this.outbound.request(channelName, packetName, request, timeoutMs, signal, metadata);
@@ -150,14 +150,14 @@ class ZLinkChannelRuntimeManager {
     publish(channelName, topic, packetName, event, signal, metadata) {
         return this.outbound.publish(channelName, topic, packetName, event, signal, metadata);
     }
-    routeSubmit(routerChannelId, targetNodeRid, packetName, message, signal, metadata) {
-        return this.outbound.routeSubmit(routerChannelId, targetNodeRid, packetName, message, signal, metadata);
+    routeSubmit(routerChannelId, targetNodeRid, packetName, message, metadata) {
+        return this.outbound.routeSubmit(routerChannelId, targetNodeRid, packetName, message, metadata);
     }
     async routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
         return this.outbound.routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata);
     }
-    async routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        return this.spotRoutes.routeSendToSpot(spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    async routeSendToSpot(spotRouteTarget, packetName, message, metadata) {
+        return this.spotRoutes.routeSendToSpot(spotRouteTarget, packetName, message, metadata);
     }
     async routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
         return this.spotRoutes.routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata);
@@ -165,8 +165,8 @@ class ZLinkChannelRuntimeManager {
     async routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
         return this.spotRoutes.routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
     }
-    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs) {
-        return this.spotRoutes.routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, signal, metadata, timeoutMs);
+    async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
+        return this.spotRoutes.routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
     async routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal) {
         return this.spotRoutes.routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal);

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

@@ -41,13 +41,6 @@ class ZLinkLiveSocketConfig {
         (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)('receiveTimeoutMs', value);
         this.socket.receiveTimeoutMs = value;
     }
-    get sendTimeoutMs() {
-        return this.socket.sendTimeoutMs;
-    }
-    set sendTimeoutMs(value) {
-        validateSendTimeout(value);
-        this.socket.sendTimeoutMs = value;
-    }
 }
 class ZLinkServerRuntimeOptions {
     serverSocket;
@@ -122,6 +115,3 @@ function validateHighWaterMark(value, label) {
         throw new configuration_1.ZLinkConfigurationException(`${label} must be a non-negative integer.`);
     }
 }
-function validateSendTimeout(value) {
-    (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)('sendTimeoutMs', value);
-}

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

@@ -70,7 +70,7 @@ export declare class ZLinkChannelSocketRegistry {
     selectClientServerDealer(channelName: string): ZLinkBackendDealerSocket | undefined;
     clientDealerForOutbound(channelName: string): ZLinkBackendDealerSocket | undefined;
     selectedClientServerRid(channelName: string, dealer: ZLinkBackendDealerSocket): string | undefined;
-    /** Observes discovery changes until the client DEALER admission deadline. */
+    /** Observes discovery changes until a server is ready or the runtime closes. */
     awaitClientDealerForOutbound(channelName: string, signal?: AbortSignal): Promise<ZLinkBackendDealerSocket | undefined>;
     startManualClientServerConnections(): void;
     startLocalClientServerConnections(): void;

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

@@ -158,8 +158,7 @@ class ZLinkChannelSocketRegistry {
             dealer.setRoutingId(deriveRoutingId(channel.routingId, 'dealer'));
         }
         applySocketConfig(dealer, {
-            ...client,
-            sendTimeoutMs: configuredSendTimeoutMs(client.sendTimeoutMs)
+            ...client
         });
         return dealer;
     }
@@ -283,8 +282,7 @@ class ZLinkChannelSocketRegistry {
             dealer.setChannelName(channelName);
             dealer.setRoutingId(`cs-client-${(0, node_crypto_1.randomUUID)()}`);
             applySocketConfig(dealer, {
-                ...client,
-                sendTimeoutMs: configuredSendTimeoutMs(client.sendTimeoutMs)
+                ...client
             });
             connection.readablePoller = this.adapter.createReadablePoller(dealer);
             created.push(connection.readablePoller);
@@ -482,7 +480,7 @@ class ZLinkChannelSocketRegistry {
         }
         return undefined;
     }
-    /** Observes discovery changes until the client DEALER admission deadline. */
+    /** Observes discovery changes until a server is ready or the runtime closes. */
     async awaitClientDealerForOutbound(channelName, signal) {
         (0, abort_1.throwIfAborted)(signal);
         const select = () => {
@@ -497,10 +495,8 @@ class ZLinkChannelSocketRegistry {
         const dealer = select();
         if (dealer !== undefined)
             return dealer;
-        const sendTimeoutMs = configuredSendTimeoutMs(this.registration.channels.get(channelName)?.client?.sendTimeoutMs);
         return new Promise((resolve, reject) => {
             const cleanup = () => {
-                clearTimeout(deadline);
                 unsubscribe();
                 signal?.removeEventListener('abort', abort);
             };
@@ -524,10 +520,6 @@ class ZLinkChannelSocketRegistry {
                 }
             };
             const unsubscribe = this.clientServerDiscovery.onClientServerChanged(changed);
-            const deadline = setTimeout(() => {
-                cleanup();
-                resolve(undefined);
-            }, sendTimeoutMs);
             signal?.addEventListener('abort', abort, { once: true });
             // Registration and selection share one event-loop turn; recheck after subscribing.
             changed();
@@ -1510,9 +1502,6 @@ function applySocketConfig(socket, config) {
     if (config.receiveTimeoutMs !== undefined) {
         socket.receiveTimeoutMs = config.receiveTimeoutMs;
     }
-    if (config.sendTimeoutMs !== undefined) {
-        socket.sendTimeoutMs = config.sendTimeoutMs;
-    }
     if (config.maxMessageSize !== undefined) {
         socket.maxMessageSize = config.maxMessageSize;
     }

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

@@ -10,7 +10,7 @@ import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 import type { ZLinkSpotRoutedSendOptions, ZLinkSpotRoutedRequestOptions } from '../spots/spot-outbound';
 import { type ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
 export interface ZLinkChannelClientTransport {
-    send(channelName: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
+    send(channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
     request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     tryPublish?(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
@@ -21,14 +21,12 @@ export interface ZLinkSpotPublisherClientTransport {
     publish(meshName: string, channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
 }
 export interface ZLinkRouteClientTransport {
-    submit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
+    submit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
     request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
-    submitToChannel(meshName: string, channelName: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
+    submitToChannel(meshName: string, channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): void | ZLinkSubmitResult | Promise<void | ZLinkSubmitResult>;
     requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     sendToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
         readonly packetName?: string;
-        readonly timeoutMs?: number;
-        readonly signal?: AbortSignal;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<ZLinkSubmitResult>;
     requestToSpot?<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
@@ -39,16 +37,16 @@ export interface ZLinkRouteClientTransport {
     }): Promise<TReply>;
 }
 interface ZLinkChannelTransportRuntime {
-    send(channelName: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    send(channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     tryPublish(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
-    routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
-    routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, timeoutMs?: number): Promise<void>;
-    routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, 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>;
+    routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
     routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
@@ -70,13 +68,13 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
     } | undefined) | undefined, codecs?: ZLinkChannelEnvelopeCodecRegistry | undefined, manualNodeTarget?: ((meshName: string, targetNodeRid: string) => boolean | undefined) | undefined, localNodeSubmit?: ((meshName: string, sourceNodeRid: string, parts: readonly MessageLike[]) => ZLinkSubmitResult) | undefined, metrics?: ZLinkRuntimeMetrics | undefined, flowCreationEnabled?: () => boolean, outboundFlow?: () => ZLinkMessageFlowTracer | undefined);
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
-    submit(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    submitInfrastructure(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    submit(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    submitInfrastructure(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     private submitNode;
     request<TReply>(meshName: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     private requestScoped;
     private traceNodeRequest;
-    submitToChannel(meshName: string, channelName: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    submitToChannel(meshName: string, channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     private submitToChannelScoped;
     requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
     private requestToChannelScoped;
@@ -85,8 +83,6 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
     private sendToSpotScoped;
     sendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
         readonly packetName?: string;
-        readonly timeoutMs?: number;
-        readonly signal?: AbortSignal;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<ZLinkSubmitResult>;
     requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: ZLinkSpotRoutedRequestOptions): Promise<TReply>;

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

@@ -52,20 +52,19 @@ class ZLinkRuntimeRouteTransport {
             this.routeChannelPredicate?.(routerChannelId) ??
             false);
     }
-    async submit(meshName, targetNodeRid, packetName, message, signal, metadata) {
+    async submit(meshName, targetNodeRid, 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.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, signal, metadata, false));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, false));
     }
-    async submitInfrastructure(meshName, targetNodeRid, packetName, message, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, signal, metadata, true));
+    async submitInfrastructure(meshName, targetNodeRid, packetName, message, metadata) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true));
     }
-    async submitNode(meshName, targetNodeRid, packetName, message, signal, metadata, allowObjectClientTarget) {
+    async submitNode(meshName, targetNodeRid, packetName, message, metadata, allowObjectClientTarget) {
         const node = this.meshNode(meshName);
         if (node === undefined) {
-            return this.requireManager().routeSubmit(meshName, targetNodeRid, packetName, message, signal, metadata);
+            return this.requireManager().routeSubmit(meshName, targetNodeRid, packetName, message, metadata);
         }
-        (0, abort_1.throwIfAborted)(signal);
         if (!allowObjectClientTarget &&
             node.isObjectClientNodeDirectTarget?.((0, routing_id_1.toBackendRoutingId)(targetNodeRid)) === true) {
             return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
@@ -135,11 +134,10 @@ class ZLinkRuntimeRouteTransport {
             ...(error instanceof Error ? { errorType: error.name, errorMessage: error.message } : {})
         });
     }
-    submitToChannel(meshName, channelName, packetName, message, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitToChannelScoped(meshName, channelName, packetName, message, signal, metadata));
+    submitToChannel(meshName, channelName, packetName, message, metadata) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitToChannelScoped(meshName, channelName, packetName, message, metadata));
     }
-    async submitToChannelScoped(meshName, channelName, packetName, message, signal, metadata) {
-        (0, abort_1.throwIfAborted)(signal);
+    async submitToChannelScoped(meshName, channelName, packetName, message, metadata) {
         const node = this.requireMeshNode(meshName);
         const parts = this.encodeMessage(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, metadata);
         const operation = `MeshNode '${meshName}' send to channel '${channelName}'`;
@@ -199,10 +197,9 @@ class ZLinkRuntimeRouteTransport {
             if (spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Instance) {
                 throw new configuration_1.ZLinkConfigurationException('Instance Spot routes require the MeshNode command 39 transport.');
             }
-            await this.requireManager().routeSendToSpot(spotRouteTarget, options.packetName, message, options.signal, options.metadata, options.timeoutMs);
+            await this.requireManager().routeSendToSpot(spotRouteTarget, options.packetName, message, options.metadata);
             return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
         }
-        (0, abort_1.throwIfAborted)(options.signal);
         const operation = `MeshNode '${spotRouteTarget.routerChannelId}' send to Spot '${spotRouteTarget.spotId}'`;
         try {
             const encoded = this.encodeMessage(3 /* ZLinkChannelMessageKind.Command */, spotRouteTarget.routerChannelId, options.packetName, message, undefined, options.metadata);
@@ -222,7 +219,7 @@ class ZLinkRuntimeRouteTransport {
         }
     }
     async sendFromSpotToSpot(sourceSpot, spotRouteTarget, message, options) {
-        await this.requireManager().routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, message, options.signal, options.metadata, options.timeoutMs);
+        await this.requireManager().routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, message, options.metadata);
         return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
     }
     requestToSpot(spotRouteTarget, request, options) {

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-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

@@ -11,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 {

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[]>;
 }