@zlink-systems/framework 0.30.0 → 0.30.2

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

@@ -126,11 +126,11 @@ class ZLinkChannelRuntimeManager {
     prepareMeshDispatch(taskRunner) {
         this.lifecycle.prepareMeshDispatch(taskRunner);
     }
-    dispatchMeshChannel(meshName, record, signal) {
-        return this.lifecycle.dispatchMeshChannel(meshName, record, signal);
+    dispatchMeshChannel(meshName, record, signal, admit) {
+        return this.lifecycle.dispatchMeshChannel(meshName, record, signal, admit);
     }
-    dispatchMeshRoute(meshName, record, signal) {
-        return this.lifecycle.dispatchMeshRoute(meshName, record, signal);
+    dispatchMeshRoute(meshName, record, signal, admit) {
+        return this.lifecycle.dispatchMeshRoute(meshName, record, signal, admit);
     }
     dispatchLocalMeshRoute(meshName, sourceNodeRid, parts, signal) {
         return this.lifecycle.dispatchLocalMeshRoute(meshName, sourceNodeRid, parts, signal);
@@ -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,22 +64,21 @@ 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>;
     private sendToSpotScoped;
     sendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
@@ -91,19 +91,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 {
@@ -100,14 +112,18 @@ class ZLinkRuntimeRouteTransport {
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound, `MeshNode '${meshName}' target '${targetNodeRid}' is an Object Client.`);
             }
             const parts = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, meshName, packetName, request, timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, metadata, correlationId);
-            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,
-                    timeoutMs: remainingTimeoutMs
-                });
-                this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, undefined, meshName, targetNodeRid, packetName, correlationId);
-                return operationId;
-            });
+            const requestOptions = { flags: 1, onAdmitted, timeoutMs: requestTimeoutBudget(timeoutMs) };
+            let completion;
+            try {
+                completion = await this.completionTable(meshName).submit(() => {
+                    const operationId = node.requestToNode((0, routing_id_1.toBackendRoutingId)(targetNodeRid), parts, requestOptions);
+                    this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, undefined, meshName, targetNodeRid, packetName, correlationId);
+                    return operationId;
+                }, signal);
+            }
+            catch (error) {
+                throw mapMeshSubmissionError(error, `MeshNode '${meshName}' request to node '${targetNodeRid}'`);
+            }
             const reply = this.decodeMeshReply(meshName, completion);
             this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, 'succeeded', meshName, targetNodeRid, packetName, correlationId);
             return reply;
@@ -142,7 +158,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,42 +168,38 @@ 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 requestOptions = { flags: 1, timeoutMs: requestTimeoutBudget(timeoutMs), onAdmitted };
+            let completion;
+            try {
+                completion = await this.completionTable(meshName).submit(() => node.requestToChannel(channelName, parts, requestOptions), signal);
+            }
+            catch (error) {
+                throw mapMeshSubmissionError(error, `MeshNode '${meshName}' request to channel '${channelName}'`);
+            }
             const reply = this.decodeMeshReply(meshName, completion);
             metric?.complete('completed');
             return reply;
         }
         catch (error) {
-            metric?.complete(requestMetricOutcome(error));
-            if (requestMetricOutcome(error) === 'target_not_found') {
+            metric?.complete(requestMetricOutcome(error, signal));
+            if (error instanceof contracts_1.ZLinkFrameworkException &&
+                (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound) {
                 this.metrics?.recordChannelSelectionFailure(meshName, channelName, 'no_ready_target');
             }
             throw error;
         }
     }
-    async submitRequestOperation(meshName, timeoutMs, signal, operation, attempt) {
-        const effectiveTimeoutMs = Math.max(1, timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS);
-        const deadlineMs = performance.now() + effectiveTimeoutMs;
-        const remainingTimeoutMs = deadlineMs - performance.now();
-        if (remainingTimeoutMs <= 0) {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `${operation} timed out before submission.`);
-        }
-        try {
-            return await this.completionTable(meshName).submit(() => attempt(Math.max(1, Math.ceil(remainingTimeoutMs))), signal);
-        }
-        catch (error) {
-            throw mapMeshSubmissionError(error, operation);
-        }
-    }
     sendToSpot(spotRouteTarget, message, options) {
         return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.sendToSpotScoped(spotRouteTarget, message, options));
     }
@@ -232,18 +244,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 +268,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 +290,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 +316,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 +326,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
@@ -411,6 +421,13 @@ function instanceSpotRouteFence(target) {
         storeVersion: target.authorityStoreVersion
     };
 }
+/**
+ * The binding request timeout for one submission. The binding owns the
+ * deadline after submit; the completion table slot only waits for it.
+ */
+function requestTimeoutBudget(timeoutMs) {
+    return Math.max(1, Math.ceil(timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS));
+}
 function mapMeshSubmitResult(result) {
     return (0, submission_result_1.classifySubmitResult)(result, 'Mesh submission');
 }
@@ -469,14 +486,16 @@ function meshRequestFailure(meshName, result, nativeErrno) {
     });
     return error;
 }
-function requestMetricOutcome(error) {
+function requestMetricOutcome(error, signal) {
     if (error instanceof contracts_1.ZLinkFrameworkException) {
-        if ((0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound)
-            return 'target_not_found';
         if ((0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded)
             return 'timed_out';
         if ((0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown)
             return 'shutdown';
     }
+    if (signal?.aborted === true &&
+        (error === signal.reason ||
+            (error instanceof Error && (error.cause === signal.reason || error.name === 'AbortError'))))
+        return 'cancelled';
     return 'failed';
 }

package/dist/runtime/channels/client-server-location-runtime.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkClientServerLocationRuntime = void 0;
+const routing_id_1 = require("../routing-id");
 const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
 const Locations_1 = require("../../contracts/Locations");
 const Options_1 = require("../../contracts/Locations/Options");
@@ -91,7 +92,7 @@ class ZLinkClientServerLocationRuntime {
                 ownerId: owner.ownerId,
                 leaseGeneration: owner.leaseGeneration
             };
-            const result = await this.store.updateClientServer(candidate, Locations_1.ZLinkLocationWriteIntent.Takeover, signal);
+            const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateClientServer(candidate, Locations_1.ZLinkLocationWriteIntent.Takeover, writeSignal), signal);
             if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                 throw new configuration_1.ZLinkConfigurationException(`ClientServer server '${channelName}' descriptor recovery was fenced.`);
             }
@@ -115,7 +116,7 @@ class ZLinkClientServerLocationRuntime {
                         descriptorRevision: current.descriptorRevision + 1n,
                         weight: runtimeWeight
                     };
-                const result = await this.store.updateClientServer(candidate, Locations_1.ZLinkLocationWriteIntent.Renew, signal);
+                const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateClientServer(candidate, Locations_1.ZLinkLocationWriteIntent.Renew, writeSignal), signal);
                 if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                     throw new configuration_1.ZLinkConfigurationException(`ClientServer server '${channelName}' descriptor renewal was fenced.`);
                 }
@@ -138,7 +139,7 @@ class ZLinkClientServerLocationRuntime {
                 leaseGeneration: owner.leaseGeneration,
                 updatedAt: new Date(0)
             };
-            const result = await this.store.updateClientServer(descriptor, Locations_1.ZLinkLocationWriteIntent.NewClaim, signal);
+            const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateClientServer(descriptor, Locations_1.ZLinkLocationWriteIntent.NewClaim, writeSignal), signal);
             if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                 throw new configuration_1.ZLinkConfigurationException(`ClientServer server '${channelName}' descriptor claim failed with '${result.status}'.`);
             }
@@ -452,7 +453,7 @@ function requestAdmission(dealer, descriptor, timeoutMs) {
 }
 function requireMatchingAdmission(expected, actual) {
     if (actual.channelName !== expected.channelName ||
-        actual.serverRid !== String(expected.serverRid) ||
+        !(0, routing_id_1.routingIdsEqual)(actual.serverRid, expected.serverRid) ||
         actual.lifecycleGeneration !== expected.lifecycleGeneration ||
         actual.descriptorRevision !== expected.descriptorRevision ||
         actual.weight !== expected.weight ||

package/dist/runtime/channels/dispatch-error-reporter.d.ts

@@ -4,9 +4,10 @@ import type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port'
 export type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
 type ZLinkRuntimeDispatchFailure = ZLinkDispatchFailure & {
     readonly error?: unknown;
+    readonly severity?: 'warning';
 };
 export declare class ZLinkDispatchErrorReporter {
-    private readonly metrics?;
+    readonly metrics?: ZLinkRuntimeMetrics | undefined;
     private reportedEvents;
     /**
      * Success-path tracer companion: every surface already receives a reporter, so

package/dist/runtime/channels/dispatch-error-reporter.js

@@ -63,7 +63,8 @@ class ZLinkDispatchErrorReporter {
             errorType: errorInfo.errorType,
             errorMessage: errorInfo.errorMessage,
             errorCauseType: errorInfo.errorCauseType,
-            errorCauseMessage: errorInfo.errorCauseMessage
+            errorCauseMessage: errorInfo.errorCauseMessage,
+            severity: normalized.severity
         });
     }
     captureEnabled() {

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

@@ -30,7 +30,7 @@ export declare class ZLinkFanoutLocationRuntime {
         lifecycleGeneration: bigint;
         descriptorRevision: bigint;
         advertisedEndpoint: string;
-        state: "error" | "preparing" | "serving" | "retiring" | "stopped";
+        state: "error" | "preparing" | "serving" | "stopped" | "retiring";
     }[] | undefined;
     private isAutomaticSubscriber;
     reclaimOwnerRows(signal?: AbortSignal): Promise<void>;

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

@@ -112,7 +112,7 @@ class ZLinkFanoutLocationRuntime {
                 ownerId: owner.ownerId,
                 leaseGeneration: owner.leaseGeneration
             };
-            const result = await this.store.updateFanoutPublisher(candidate, Locations_1.ZLinkLocationWriteIntent.Takeover, signal);
+            const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateFanoutPublisher(candidate, Locations_1.ZLinkLocationWriteIntent.Takeover, writeSignal), signal);
             if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                 throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor recovery was fenced.`);
             }
@@ -135,7 +135,7 @@ class ZLinkFanoutLocationRuntime {
             }
             const current = await this.lane.run(() => this.localDescriptors.get(channelName));
             if (current !== undefined) {
-                const result = await this.store.updateFanoutPublisher(current, Locations_1.ZLinkLocationWriteIntent.Renew, signal);
+                const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateFanoutPublisher(current, Locations_1.ZLinkLocationWriteIntent.Renew, writeSignal), signal);
                 if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                     throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor renewal was fenced.`);
                 }
@@ -169,7 +169,7 @@ class ZLinkFanoutLocationRuntime {
                 leaseGeneration: owner.leaseGeneration,
                 updatedAt: new Date(0)
             };
-            const result = await this.store.updateFanoutPublisher(descriptor, Locations_1.ZLinkLocationWriteIntent.NewClaim, signal);
+            const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateFanoutPublisher(descriptor, Locations_1.ZLinkLocationWriteIntent.NewClaim, writeSignal), signal);
             if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                 throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor claim failed with '${result.status}'.`);
             }

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);
         });