@zlink-systems/framework 0.30.0 → 0.30.1

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

@@ -68,10 +68,10 @@ class ZLinkChannelOutboundOperations {
             correlationId: undefined
         });
     }
-    request(channelName, packetName, request, timeoutMs, signal, metadata) {
-        return keepChannelRequestAlive((0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.requestScoped(channelName, packetName, request, timeoutMs, signal, metadata)));
+    request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        return keepChannelRequestAlive((0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.requestScoped(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted)));
     }
-    async requestScoped(channelName, packetName, request, timeoutMs, signal, metadata) {
+    async requestScoped(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
         const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
         const deadlineUnixMs = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
         let correlationId;
@@ -117,7 +117,7 @@ class ZLinkChannelOutboundOperations {
                 let replyParts = [];
                 try {
                     try {
-                        replyParts = await (0, abort_1.awaitWithAbort)(dealer.request(parts, (0, request_deadline_1.remainingRequestTimeout)(`Channel request '${channelName}'`, deadlineMs)), signal);
+                        replyParts = await (0, abort_1.awaitWithAbort)(dealer.request(parts, (0, request_deadline_1.remainingRequestTimeout)(`Channel request '${channelName}'`, deadlineMs), onAdmitted), signal);
                     }
                     catch (error) {
                         if (signal?.aborted === true)
@@ -205,10 +205,10 @@ class ZLinkChannelOutboundOperations {
             targetRid: targetNodeRid
         });
     }
-    routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.routeRequestScoped(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata));
+    routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.routeRequestScoped(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted));
     }
-    async routeRequestScoped(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
+    async routeRequestScoped(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
         let correlationId;
         let router;
         let terminalRecorded = false;
@@ -245,7 +245,7 @@ class ZLinkChannelOutboundOperations {
                 targetRid: targetNodeRid
             });
             const reply = await this.measureRequest(routerChannelId, async () => {
-                const replyParts = await (0, abort_1.awaitWithAbort)(router.request(targetNodeRid, parts, timeoutMs), signal);
+                const replyParts = await (0, abort_1.awaitWithAbort)(router.request(targetNodeRid, parts, timeoutMs, onAdmitted), signal);
                 try {
                     return (0, channel_envelope_1.decodeChannelReply)(replyParts, this.codecs);
                 }

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

@@ -45,17 +45,17 @@ export declare class ZLinkChannelRuntimeManager {
     dispatchLocalMeshRoute(meshName: string, sourceNodeRid: RoutingId, parts: readonly Message[], signal?: AbortSignal): Promise<void>;
     canDispatchLocalMeshRoute(meshName: string): boolean;
     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>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): 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, 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>;
+    routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     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>;
+    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
+    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
     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[]>;
+    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
+    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
     dispose(signal?: AbortSignal): Promise<void>;

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

@@ -141,8 +141,8 @@ class ZLinkChannelRuntimeManager {
     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);
+    async request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        return this.outbound.request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted);
     }
     tryPublish(channelName, topic, packetName, event, metadata) {
         return this.outbound.tryPublish(channelName, topic, packetName, event, metadata);
@@ -153,26 +153,26 @@ class ZLinkChannelRuntimeManager {
     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 routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        return this.outbound.routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted);
     }
     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);
+    async routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        return this.spotRoutes.routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted);
     }
-    async routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
-        return this.spotRoutes.routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
+    async routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted) {
+        return this.spotRoutes.routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted);
     }
     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);
+    async routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
+        return this.spotRoutes.routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted);
     }
-    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal) {
-        return this.spotRoutes.routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal);
+    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
+        return this.spotRoutes.routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
     }
     canRouteChannel(routerChannelId) {
         return this.spotRoutes.canRouteChannel(routerChannelId);

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

@@ -11,7 +11,7 @@ import type { ZLinkSpotRoutedSendOptions, ZLinkSpotRoutedRequestOptions } from '
 import { type ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
 export interface ZLinkChannelClientTransport {
     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>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): 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>;
 }
@@ -22,9 +22,9 @@ export interface ZLinkSpotPublisherClientTransport {
 }
 export interface ZLinkRouteClientTransport {
     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>;
+    request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     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>;
+    requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     sendToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
         readonly packetName?: string;
         readonly metadata?: ReadonlyMap<string, string>;
@@ -33,24 +33,25 @@ export interface ZLinkRouteClientTransport {
         readonly packetName?: string;
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<TReply>;
 }
 interface ZLinkChannelTransportRuntime {
     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>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): 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, 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>;
+    routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     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[]>;
-    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
+    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
+    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
+    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
 }
 export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     private readonly manager;
@@ -63,20 +64,20 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
     private readonly flowCreationEnabled;
     private readonly outboundFlow;
     constructor(manager: () => ZLinkChannelTransportRuntime | undefined, routeChannelPredicate?: ((routerChannelId: string) => boolean) | undefined, meshRuntime?: (() => {
-        readonly meshNode: (meshName: string) => ZLinkBackendMeshNode | undefined;
+        readonly meshNode?: (meshName: string) => ZLinkBackendMeshNode | undefined;
         readonly meshCompletionTable: (meshName: string) => ZLinkMeshCompletionTable | undefined;
     } | 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, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    submitInfrastructure(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
+    submit(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
+    submitInfrastructure(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult | 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>;
+    request<TReply>(meshName: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     private requestScoped;
     private traceNodeRequest;
     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>;
+    requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     private requestToChannelScoped;
     private submitRequestOperation;
     sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: ZLinkSpotRoutedSendOptions): Promise<ZLinkSubmitResult>;
@@ -91,19 +92,21 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
         readonly packetName?: string;
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<TReply>;
     requestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
     requestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
     private requestRawToSpotScoped;
     private requireManager;
     private meshNode;
-    private isSelfNode;
     private isKnownBackendPeer;
     private submitLocalNode;
     private requireMeshNode;

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

@@ -19,6 +19,7 @@ const framework_errors_internal_1 = require("../framework-errors-internal");
 const submission_result_1 = require("../messaging/submission-result");
 const routing_id_1 = require("../routing-id");
 const channel_envelope_1 = require("./channel-envelope");
+const NON_BLOCKING_SEND_OPTIONS = Object.freeze({ flags: runtime_values_1.ZLINK_BACKEND_SEND_DONT_WAIT });
 class ZLinkRuntimeRouteTransport {
     manager;
     routeChannelPredicate;
@@ -52,15 +53,19 @@ class ZLinkRuntimeRouteTransport {
             this.routeChannelPredicate?.(routerChannelId) ??
             false);
     }
-    async submit(meshName, targetNodeRid, packetName, message, metadata) {
+    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, metadata, false));
+        if (!this.flowCreationEnabled())
+            return this.submitNode(meshName, targetNodeRid, packetName, message, metadata, false);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, false));
     }
-    async submitInfrastructure(meshName, targetNodeRid, packetName, message, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true));
+    submitInfrastructure(meshName, targetNodeRid, packetName, message, metadata) {
+        if (!this.flowCreationEnabled())
+            return this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.submitNode(meshName, targetNodeRid, packetName, message, metadata, true));
     }
-    async submitNode(meshName, targetNodeRid, packetName, message, metadata, allowObjectClientTarget) {
+    submitNode(meshName, targetNodeRid, packetName, message, metadata, allowObjectClientTarget) {
         const node = this.meshNode(meshName);
         if (node === undefined) {
             return this.requireManager().routeSubmit(meshName, targetNodeRid, packetName, message, metadata);
@@ -70,28 +75,35 @@ class ZLinkRuntimeRouteTransport {
             return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
         }
         const parts = this.encodeMessage(3 /* ZLinkChannelMessageKind.Command */, meshName, packetName, message, undefined, metadata);
-        const operation = `MeshNode '${meshName}' send to node '${targetNodeRid}'`;
-        if (this.isSelfNode(node, targetNodeRid)) {
-            return this.submitLocalNode(meshName, String(node.status().routingId), parts);
+        const sourceNodeRid = node.routingId ?? node.status().routingId;
+        if ((0, routing_id_1.routingIdsEqual)(sourceNodeRid, targetNodeRid)) {
+            return this.submitLocalNode(meshName, String(sourceNodeRid), parts);
         }
-        if (!this.isKnownBackendPeer(node, targetNodeRid) &&
-            this.manualNodeTarget?.(meshName, targetNodeRid) === false) {
+        if (this.manualNodeTarget?.(meshName, targetNodeRid) === false &&
+            !this.isKnownBackendPeer(node, targetNodeRid)) {
             return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
         }
         try {
-            return mapMeshSubmitResult(await node.sendToNode((0, routing_id_1.toBackendRoutingId)(targetNodeRid), parts, { flags: 1 }));
+            const submitted = node.sendToNode((0, routing_id_1.toBackendRoutingId)(targetNodeRid), parts, NON_BLOCKING_SEND_OPTIONS);
+            return submitted instanceof Promise
+                ? submitted.then(mapMeshSubmitResult, (error) => {
+                    throw mapMeshSubmissionError(error, `MeshNode '${meshName}' send to node '${targetNodeRid}'`);
+                })
+                : mapMeshSubmitResult(submitted);
         }
         catch (error) {
-            throw mapMeshSubmissionError(error, operation);
+            throw mapMeshSubmissionError(error, `MeshNode '${meshName}' send to node '${targetNodeRid}'`);
         }
     }
-    request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata));
+    request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        if (!this.flowCreationEnabled())
+            return this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted));
     }
-    async requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
+    async requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
         const node = this.meshNode(meshName);
         if (node === undefined) {
-            return this.requireManager().routeRequest(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata);
+            return this.requireManager().routeRequest(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted);
         }
         const correlationId = (0, channel_envelope_1.newChannelCorrelationId)();
         try {
@@ -103,6 +115,7 @@ class ZLinkRuntimeRouteTransport {
             const completion = await this.submitRequestOperation(meshName, timeoutMs, signal, `MeshNode '${meshName}' request to node '${targetNodeRid}'`, (remainingTimeoutMs) => {
                 const operationId = node.requestToNode((0, routing_id_1.toBackendRoutingId)(targetNodeRid), parts, {
                     flags: 1,
+                    onAdmitted,
                     timeoutMs: remainingTimeoutMs
                 });
                 this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, undefined, meshName, targetNodeRid, packetName, correlationId);
@@ -142,7 +155,7 @@ class ZLinkRuntimeRouteTransport {
         const parts = this.encodeMessage(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, metadata);
         const operation = `MeshNode '${meshName}' send to channel '${channelName}'`;
         try {
-            const result = mapMeshSubmitResult(await node.sendToChannel(channelName, parts, { flags: 1 }));
+            const result = mapMeshSubmitResult(await node.sendToChannel(channelName, parts, NON_BLOCKING_SEND_OPTIONS));
             if (result.status === submission_result_1.ZLinkSubmitStatus.TargetNotFound) {
                 this.metrics?.recordChannelSelectionFailure(meshName, channelName, 'no_ready_target');
             }
@@ -152,16 +165,22 @@ class ZLinkRuntimeRouteTransport {
             throw mapMeshSubmissionError(error, operation);
         }
     }
-    requestToChannel(meshName, channelName, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata));
+    requestToChannel(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        if (!this.flowCreationEnabled())
+            return this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted));
     }
-    async requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata) {
+    async requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const node = this.requireMeshNode(meshName);
         const parts = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, metadata);
         const metric = this.metrics?.startRequest(meshName, 'channel');
         try {
-            const completion = await this.submitRequestOperation(meshName, timeoutMs, signal, `MeshNode '${meshName}' request to channel '${channelName}'`, (remainingTimeoutMs) => node.requestToChannel(channelName, parts, { flags: 1, timeoutMs: remainingTimeoutMs }));
+            const completion = await this.submitRequestOperation(meshName, timeoutMs, signal, `MeshNode '${meshName}' request to channel '${channelName}'`, (remainingTimeoutMs) => node.requestToChannel(channelName, parts, {
+                flags: 1,
+                timeoutMs: remainingTimeoutMs,
+                onAdmitted
+            }));
             const reply = this.decodeMeshReply(meshName, completion);
             metric?.complete('completed');
             return reply;
@@ -232,18 +251,19 @@ class ZLinkRuntimeRouteTransport {
             if (spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Instance) {
                 throw new configuration_1.ZLinkConfigurationException('Instance Spot routes require the MeshNode command 39 transport.');
             }
-            return this.requireManager().routeRequestToSpot(spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.metadata);
+            return this.requireManager().routeRequestToSpot(spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.metadata, options.onAdmitted);
         }
         (0, abort_1.throwIfAborted)(options.signal);
         let completionPromise;
         try {
             const encoded = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, meshName, options.packetName, request, options.timeoutMs, options.metadata);
             completionPromise = this.completionTable(meshName).submit(() => spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Instance
-                ? node.requestInstanceSpot(instanceSpotRouteFence(spotRouteTarget), encoded, options.timeoutMs, undefined, options.metadata, options.instanceSpot)
+                ? node.requestInstanceSpot(instanceSpotRouteFence(spotRouteTarget), encoded, options.timeoutMs, undefined, options.metadata, options.instanceSpot, options.onAdmitted)
                 : node
                     .entrySpot()
                     .requestToSpot((0, routing_id_1.toBackendRoutingId)(spotRouteTarget.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(spotRouteTarget.spotId), spotRouteTarget.targetSpotGeneration ?? 0n, encoded, {
                     flags: 1,
+                    onAdmitted: options.onAdmitted,
                     timeoutMs: options.timeoutMs,
                     routeFence: directSpotRouteFence(spotRouteTarget),
                     entrySpot: spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Entry
@@ -255,10 +275,10 @@ class ZLinkRuntimeRouteTransport {
         return this.waitForMeshReply(meshName, completionPromise);
     }
     async requestFromSpotToSpot(sourceSpot, spotRouteTarget, request, options) {
-        return this.requireManager().routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal);
+        return this.requireManager().routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.onAdmitted);
     }
     async requestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options) {
-        return this.requireManager().routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options.timeoutMs, options.signal);
+        return this.requireManager().routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options.timeoutMs, options.signal, options.onAdmitted);
     }
     requestRawToSpot(spotRouteTarget, request, options) {
         return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestRawToSpotScoped(spotRouteTarget, request, options));
@@ -277,6 +297,7 @@ class ZLinkRuntimeRouteTransport {
                     .entrySpot()
                     .requestToSpot((0, routing_id_1.toBackendRoutingId)(spotRouteTarget.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(spotRouteTarget.spotId), spotRouteTarget.targetSpotGeneration ?? 0n, parts, {
                     flags: 1,
+                    onAdmitted: options.onAdmitted,
                     timeoutMs: options.timeoutMs,
                     routeFence: directSpotRouteFence(spotRouteTarget),
                     entrySpot: spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Entry
@@ -302,7 +323,7 @@ class ZLinkRuntimeRouteTransport {
                 (0, mesh_completion_table_1.closeMeshCompletion)(completion);
             }
         }
-        return this.requireManager().routeRequestRawToSpot(spotRouteTarget, request, options.timeoutMs, options.signal);
+        return this.requireManager().routeRequestRawToSpot(spotRouteTarget, request, options.timeoutMs, options.signal, options.onAdmitted);
     }
     requireManager() {
         const manager = this.manager();
@@ -312,11 +333,7 @@ class ZLinkRuntimeRouteTransport {
         return manager;
     }
     meshNode(meshName) {
-        const runtime = this.meshRuntime?.();
-        return runtime?.meshNode?.(meshName);
-    }
-    isSelfNode(node, targetNodeRid) {
-        return (0, routing_id_1.routingIdsEqual)(node.status().routingId, targetNodeRid);
+        return this.meshRuntime?.()?.meshNode?.(meshName);
     }
     isKnownBackendPeer(node, targetNodeRid) {
         return node

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

@@ -5,5 +5,5 @@ export declare class ZLinkLocalSpotRouteTransport {
     private readonly defaultRequestTimeoutMs;
     constructor(dispatcher: ZLinkLocalSpotRouteDispatcher | undefined, defaultRequestTimeoutMs: number | undefined);
     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>;
+    request<TReply>(routerChannelId: string, spotId: RoutingId, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
 }

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

@@ -18,12 +18,13 @@ class ZLinkLocalSpotRouteTransport {
             metadata
         });
     }
-    request(routerChannelId, spotId, packetName, request, timeoutMs, signal) {
+    request(routerChannelId, spotId, packetName, request, timeoutMs, signal, onAdmitted) {
         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,
+            onAdmitted,
             signal
         });
         const effectiveTimeoutMs = timeoutMs ?? this.defaultRequestTimeoutMs;

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

@@ -7,6 +7,6 @@ export declare class ZLinkRouterSocketSpotRouteTransport {
     private readonly sockets;
     constructor(sockets: ZLinkChannelSocketRegistry);
     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[]>;
+    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, flags: ZLinkBackendSendFlags, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
+    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
 }

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

@@ -17,10 +17,10 @@ class ZLinkRouterSocketSpotRouteTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async request(target, parts, codecs, flags, timeoutMs, signal) {
+    async request(target, parts, codecs, flags, timeoutMs, signal, onAdmitted) {
         const router = this.sockets.routeRouter(target.routerChannelId);
         void flags;
-        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs, onAdmitted);
         const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });
@@ -32,9 +32,9 @@ class ZLinkRouterSocketSpotRouteTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async requestRaw(target, request, timeoutMs, signal) {
+    async requestRaw(target, request, timeoutMs, signal, onAdmitted) {
         const router = this.sockets.routeRouter(target.routerChannelId);
-        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, [request], timeoutMs);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, [request], timeoutMs, onAdmitted);
         return await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });

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

@@ -4,7 +4,7 @@ import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 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>;
+    request<TReply>(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
     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[]>;
+    requestRaw(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
 }

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

@@ -9,12 +9,12 @@ class ZLinkSourceSpotRouter {
     constructor(defaultRequestTimeoutMs) {
         this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
     }
-    async request(sourceSpot, target, packetName, request, timeoutMs, signal) {
+    async request(sourceSpot, target, packetName, request, timeoutMs, signal, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const parts = [
             (0, spot_direct_envelope_1.encodeSpotDirectEnvelope)(1 /* ZLinkChannelMessageKind.Request */, target.routerChannelId, packetName, request)
         ];
-        const operation = sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs ?? this.defaultRequestTimeoutMs);
+        const operation = sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs ?? this.defaultRequestTimeoutMs, onAdmitted);
         const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });
@@ -37,9 +37,9 @@ class ZLinkSourceSpotRouter {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async requestRaw(sourceSpot, target, request, timeoutMs, signal) {
+    async requestRaw(sourceSpot, target, request, timeoutMs, signal, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
-        const operation = sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, request, timeoutMs ?? this.defaultRequestTimeoutMs);
+        const operation = sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, request, timeoutMs ?? this.defaultRequestTimeoutMs, onAdmitted);
         return await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });

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

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

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

@@ -24,14 +24,14 @@ class ZLinkSpotNodeRouteTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    request(target, parts, codecs, timeoutMs, signal) {
+    request(target, parts, codecs, timeoutMs, signal, onAdmitted) {
         const router = this.targets.spotNodeRouter(target.routerChannelId);
         if (router === undefined) {
             return undefined;
         }
         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);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, effectiveTimeoutMs, onAdmitted);
         return (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         }).then((replyParts) => {
@@ -44,14 +44,14 @@ class ZLinkSpotNodeRouteTransport {
             }
         });
     }
-    requestRaw(target, request, timeoutMs, signal) {
+    requestRaw(target, request, timeoutMs, signal, onAdmitted) {
         const router = this.targets.spotNodeRouter(target.routerChannelId);
         if (router === undefined) {
             return undefined;
         }
         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);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, request, effectiveTimeoutMs, onAdmitted);
         return (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });

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

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

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

@@ -24,11 +24,11 @@ class ZLinkSpotRouteBridgeTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async request(target, parts, codecs, timeoutMs, signal) {
+    async request(target, parts, codecs, timeoutMs, signal, onAdmitted) {
         const bridge = this.requireBridge(target.routerChannelId);
         const operation = (0, channel_multipart_1.appendParts)(bridge.request(target.routerChannelId, target.targetNodeRid, target.spotId), parts)
             .timeout(timeoutMs ?? 0)
-            .submit();
+            .submit(onAdmitted);
         const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });
@@ -40,13 +40,13 @@ class ZLinkSpotRouteBridgeTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    requestRaw(target, request, timeoutMs, signal) {
+    requestRaw(target, request, timeoutMs, signal, onAdmitted) {
         const bridge = this.requireBridge(target.routerChannelId);
         const operation = bridge
             .request(target.routerChannelId, target.targetNodeRid, target.spotId)
             .message(request)
             .timeout(timeoutMs ?? this.defaultRequestTimeoutMs ?? 0)
-            .submit();
+            .submit(onAdmitted);
         return (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });