@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkRuntimeRouteTransport = void 0;
 exports.meshRequestFailure = meshRequestFailure;
+const request_runtime_1 = require("../foundation/request-runtime");
+const request_result_1 = require("../messaging/request-result");
 const contracts_1 = require("../../contracts");
 const Registration_1 = require("../../contracts/Configuration/Registration");
 const Spots_1 = require("../../contracts/Spots");
@@ -30,7 +32,8 @@ class ZLinkRuntimeRouteTransport {
     metrics;
     flowCreationEnabled;
     outboundFlow;
-    constructor(manager, routeChannelPredicate = undefined, meshRuntime = undefined, codecs, manualNodeTarget, localNodeSubmit, metrics, flowCreationEnabled = () => true, outboundFlow = () => undefined) {
+    requests;
+    constructor(manager, routeChannelPredicate = undefined, meshRuntime = undefined, codecs, manualNodeTarget, localNodeSubmit, metrics, flowCreationEnabled = () => true, outboundFlow = () => undefined, requests = new request_runtime_1.RequestRuntime()) {
         this.manager = manager;
         this.routeChannelPredicate = routeChannelPredicate;
         this.meshRuntime = meshRuntime;
@@ -40,6 +43,7 @@ class ZLinkRuntimeRouteTransport {
         this.metrics = metrics;
         this.flowCreationEnabled = flowCreationEnabled;
         this.outboundFlow = outboundFlow;
+        this.requests = requests;
     }
     canRouteChannel(routerChannelId) {
         const manager = this.manager();
@@ -95,45 +99,57 @@ class ZLinkRuntimeRouteTransport {
             throw mapMeshSubmissionError(error, `MeshNode '${meshName}' send to node '${targetNodeRid}'`);
         }
     }
-    request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+    request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation) {
         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));
+            return this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation));
     }
-    async requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+    requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, existing) {
         const node = this.meshNode(meshName);
         if (node === undefined) {
-            return this.requireManager().routeRequest(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted);
+            return this.requests.prepare(timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, signal, (operation) => {
+                this.requireManager().routeRequest(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, operation);
+            }, (value) => value, request_result_1.identityRequestReply, existing);
         }
         const correlationId = (0, channel_envelope_1.newChannelCorrelationId)();
-        try {
+        const result = this.requests.prepare(timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, signal, (requestOperation, receiver) => {
+            requestOperation.mapCaller((value) => {
+                this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, 'succeeded', meshName, targetNodeRid, packetName, correlationId);
+                return value;
+            }, (error) => {
+                if (!(0, channel_outbound_operations_1.isRemoteChannelErrorReply)(error))
+                    this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, (0, channel_outbound_operations_1.requestTerminalResult)(error, signal), meshName, targetNodeRid, packetName, correlationId, error);
+                throw error;
+            });
             (0, abort_1.throwIfAborted)(signal);
             if (node.isObjectClientNodeDirectTarget?.((0, routing_id_1.toBackendRoutingId)(targetNodeRid)) === true) {
                 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 requestOptions = { flags: 1, onAdmitted, timeoutMs: requestTimeoutBudget(timeoutMs) };
-            let completion;
+            let parts;
             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);
+                parts = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, meshName, packetName, request, timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, metadata, correlationId);
             }
             catch (error) {
-                throw mapMeshSubmissionError(error, `MeshNode '${meshName}' request to node '${targetNodeRid}'`);
+                requestOperation.fail(error);
+                return;
             }
-            const reply = this.decodeMeshReply(meshName, completion);
-            this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, 'succeeded', meshName, targetNodeRid, packetName, correlationId);
-            return reply;
-        }
-        catch (error) {
-            if (!(0, channel_outbound_operations_1.isRemoteChannelErrorReply)(error)) {
-                this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, (0, channel_outbound_operations_1.requestTerminalResult)(error, signal), meshName, targetNodeRid, packetName, correlationId, error);
+            try {
+                this.completionTable(meshName).submit((completion) => {
+                    const operationId = node.requestToNode((0, routing_id_1.toBackendRoutingId)(targetNodeRid), parts, {
+                        requestOperation,
+                        flags: 1,
+                        onAdmitted,
+                        timeoutMs: requestTimeoutBudget(timeoutMs)
+                    }, completion);
+                    this.traceNodeRequest(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, undefined, meshName, targetNodeRid, packetName, correlationId);
+                    return operationId;
+                }, signal, requestOperation, receiver);
             }
-            throw error;
-        }
+            finally {
+                parts = undefined;
+            }
+        }, (raw) => this.decodeMeshReply(meshName, raw), (error) => mapMeshSubmissionError(error, `MeshNode '${meshName}' request to '${targetNodeRid}'`), existing);
+        return result;
     }
     traceNodeRequest(outcome, result, meshName, targetRid, packetName, correlationId, error) {
         if (!this.flowCreationEnabled())
@@ -168,37 +184,49 @@ class ZLinkRuntimeRouteTransport {
             throw mapMeshSubmissionError(error, operation);
         }
     }
-    requestToChannel(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+    requestToChannel(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation) {
         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, 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 requestOptions = { flags: 1, timeoutMs: requestTimeoutBudget(timeoutMs), onAdmitted };
-            let completion;
+            return this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation);
+        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation));
+    }
+    requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, existing) {
+        let metric;
+        const result = this.requests.prepare(timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, signal, (requestOperation, receiver) => {
+            requestOperation.mapCaller((value) => {
+                metric?.complete('completed');
+                return value;
+            }, (error) => {
+                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;
+            });
+            (0, abort_1.throwIfAborted)(signal);
+            const node = this.requireMeshNode(meshName);
+            let parts;
             try {
-                completion = await this.completionTable(meshName).submit(() => node.requestToChannel(channelName, parts, requestOptions), signal);
+                parts = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, metadata);
             }
             catch (error) {
-                throw mapMeshSubmissionError(error, `MeshNode '${meshName}' request to channel '${channelName}'`);
+                requestOperation.fail(error);
+                return;
             }
-            const reply = this.decodeMeshReply(meshName, completion);
-            metric?.complete('completed');
-            return reply;
-        }
-        catch (error) {
-            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');
+            metric = this.metrics?.startRequest(meshName, 'channel');
+            try {
+                this.completionTable(meshName).submit((completion) => node.requestToChannel(channelName, parts, {
+                    requestOperation,
+                    flags: 1,
+                    timeoutMs: requestTimeoutBudget(timeoutMs),
+                    onAdmitted
+                }, completion), signal, requestOperation, receiver);
             }
-            throw error;
-        }
+            finally {
+                parts = undefined;
+            }
+        }, (raw) => this.decodeMeshReply(meshName, raw), (error) => mapMeshSubmissionError(error, `MeshNode '${meshName}' channel '${channelName}' request`), existing);
+        return result;
     }
     sendToSpot(spotRouteTarget, message, options) {
         return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.sendToSpotScoped(spotRouteTarget, message, options));
@@ -234,44 +262,46 @@ class ZLinkRuntimeRouteTransport {
         await this.requireManager().routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, message, options.metadata);
         return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
     }
-    requestToSpot(spotRouteTarget, request, options) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestToSpotScoped(spotRouteTarget, request, options));
+    requestToSpot(spotRouteTarget, request, options, destination) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestToSpotScoped(spotRouteTarget, request, options, destination));
     }
-    async requestToSpotScoped(spotRouteTarget, request, options) {
+    requestToSpotScoped(spotRouteTarget, request, options, destination) {
         const meshName = spotRouteTarget.routerChannelId;
         const node = this.meshNode(meshName);
         if (node === undefined) {
-            if (spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Instance) {
+            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, 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, 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
-                }), options.signal);
-        }
-        catch (error) {
-            throw mapMeshSubmissionError(error, `MeshNode '${meshName}' request to Spot '${spotRouteTarget.spotId}'`);
+            return this.requests.prepare(options.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options.signal, (operation, receiver) => {
+                this.requireManager().routeRequestToSpot(spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.metadata, options.onAdmitted, operation, receiver);
+            }, (value) => value, request_result_1.identityRequestReply, options.requestOperation, destination);
         }
-        return this.waitForMeshReply(meshName, completionPromise);
+        return this.requests.prepare(options.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options.signal, (requestOperation, receiver) => {
+            try {
+                (0, abort_1.throwIfAborted)(options.signal);
+                const encoded = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, meshName, options.packetName, request, options.timeoutMs, options.metadata);
+                this.completionTable(meshName).submit((completion) => spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Instance
+                    ? node.requestInstanceSpot(instanceSpotRouteFence(spotRouteTarget), encoded, options.timeoutMs, undefined, options.metadata, options.instanceSpot, options.onAdmitted, requestOperation, completion)
+                    : 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,
+                        requestOperation,
+                        routeFence: directSpotRouteFence(spotRouteTarget),
+                        entrySpot: spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Entry
+                    }, completion), options.signal, requestOperation, receiver);
+            }
+            catch (error) {
+                receiver.operationFailed(requestOperation.id, error, undefined);
+            }
+        }, (raw) => this.decodeMeshReply(meshName, raw), (error) => mapMeshSubmissionError(error, `MeshNode '${meshName}' request to Spot '${spotRouteTarget.spotId}'`), options.requestOperation, destination);
     }
-    async requestFromSpotToSpot(sourceSpot, spotRouteTarget, request, options) {
-        return this.requireManager().routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.onAdmitted);
+    requestFromSpotToSpot(sourceSpot, spotRouteTarget, request, options, destination) {
+        return this.requests.prepare(options.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options.signal, (operation, receiver) => {
+            this.requireManager().routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, options.packetName, request, options.timeoutMs, options.signal, options.onAdmitted, operation, receiver);
+        }, (value) => value, request_result_1.identityRequestReply, options.requestOperation, destination);
     }
     async requestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options) {
-        return this.requireManager().routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options.timeoutMs, options.signal, options.onAdmitted);
+        return this.requireManager().routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options.timeoutMs, options.signal, options.onAdmitted, options.requestOperation);
     }
     requestRawToSpot(spotRouteTarget, request, options) {
         return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestRawToSpotScoped(spotRouteTarget, request, options));
@@ -279,44 +309,29 @@ class ZLinkRuntimeRouteTransport {
     async requestRawToSpotScoped(spotRouteTarget, request, options) {
         const meshName = spotRouteTarget.routerChannelId;
         const node = this.meshNode(meshName);
-        if (node !== undefined) {
+        if (node === undefined)
+            return this.requireManager().routeRequestRawToSpot(spotRouteTarget, request, options.timeoutMs, options.signal, options.onAdmitted, options.requestOperation);
+        const operation = this.requests.begin(options.timeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS, options.signal, options.requestOperation);
+        return this.requests.run(operation, (receiver) => {
             (0, abort_1.throwIfAborted)(options.signal);
             const payload = JSON.parse(request.getString('utf8'));
             const packetName = typeof payload.packetName === 'string' ? payload.packetName : undefined;
             const parts = this.encodeMessage(1 /* ZLinkChannelMessageKind.Request */, meshName, packetName, payload, options.timeoutMs);
-            let completionPromise;
-            try {
-                completionPromise = this.completionTable(meshName).submit(() => node
-                    .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
-                }), options.signal);
-            }
-            catch (error) {
-                throw mapMeshSubmissionError(error, `MeshNode '${meshName}' raw request to Spot '${spotRouteTarget.spotId}'`);
-            }
-            const completion = await completionPromise;
-            if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
-                try {
-                    throw meshRequestFailure(meshName, completion.terminalResult, completion.failureErrno);
-                }
-                finally {
-                    (0, mesh_completion_table_1.closeMeshCompletion)(completion);
-                }
-            }
-            try {
-                const reply = (0, channel_envelope_1.decodeChannelReply)(completion.parts, this.codecs);
-                return [runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(JSON.stringify(reply)))];
-            }
-            finally {
-                (0, mesh_completion_table_1.closeMeshCompletion)(completion);
-            }
-        }
-        return this.requireManager().routeRequestRawToSpot(spotRouteTarget, request, options.timeoutMs, options.signal, options.onAdmitted);
+            this.completionTable(meshName).submit((completion) => node.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,
+                requestOperation: operation,
+                routeFence: directSpotRouteFence(spotRouteTarget),
+                entrySpot: spotRouteTarget.spotKind === Spots_1.ZLinkSpotKind.Entry
+            }, completion), options.signal, operation, receiver);
+        }, (raw) => {
+            const reply = this.decodeMeshReply(meshName, raw);
+            const parts = [runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(JSON.stringify(reply)))];
+            if (!operation.isPending())
+                (0, channel_envelope_1.closeMessages)(parts);
+            return parts;
+        }, (error) => mapMeshSubmissionError(error, `MeshNode '${meshName}' raw request to Spot '${spotRouteTarget.spotId}'`));
     }
     requireManager() {
         const manager = this.manager();
@@ -326,7 +341,10 @@ class ZLinkRuntimeRouteTransport {
         return manager;
     }
     meshNode(meshName) {
-        return this.meshRuntime?.()?.meshNode?.(meshName);
+        const runtime = this.meshRuntime?.();
+        if (runtime === undefined)
+            this.requireManager();
+        return runtime?.meshNode?.(meshName);
     }
     isKnownBackendPeer(node, targetNodeRid) {
         return node
@@ -357,10 +375,6 @@ class ZLinkRuntimeRouteTransport {
     encodeMessage(kind, channelName, packetName, message, timeoutMs, metadata, correlationId) {
         return (0, channel_envelope_1.encodeChannelEnvelopeParts)(kind, channelName, packetName, message, timeoutMs, undefined, this.codecs, correlationId, this.flowCreationEnabled(), metadata);
     }
-    async waitForMeshReply(meshName, completionPromise) {
-        const completion = await completionPromise;
-        return this.decodeMeshReply(meshName, completion);
-    }
     decodeMeshReply(meshName, completion) {
         try {
             if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
@@ -452,7 +466,13 @@ function mapMeshSubmissionError(error, operation) {
         }
         return new contracts_1.ZLinkFrameworkException((0, framework_errors_internal_1.requestResultToPublicErrorKind)(terminal), `${operation} failed with result ${error.result}.`, error);
     }
-    return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operation} failed before native submission completed: ${error instanceof Error ? error.message : String(error)}`, true, error);
+    if ((0, abort_1.isAbortError)(error) ||
+        error instanceof configuration_1.ZLinkConfigurationException ||
+        error instanceof TypeError ||
+        error instanceof RangeError) {
+        return error;
+    }
+    return new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.InternalFailure, `${operation} failed.`, error);
 }
 function meshRequestFailure(meshName, result, nativeErrno) {
     const canonical = (0, framework_errors_internal_1.isCanonicalWireReplyTerminal)(result, nativeErrno);

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

@@ -1,6 +1,6 @@
 import { type ZLinkDispatchFailure } from '../../contracts/Dispatch/ZLinkDispatchOptions';
-import { type ZLinkRuntimeMetrics, ZLinkMessageFlowTracer, type ZLinkDiagnosticsContext } from '../diagnostics';
-import type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
+import { ZLinkMessageFlowTracer, type ZLinkDiagnosticsContext } from '../diagnostics/message-flow';
+import { type ZLinkRuntimeMetrics } from '../diagnostics/runtime-metrics';
 export type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
 type ZLinkRuntimeDispatchFailure = ZLinkDispatchFailure & {
     readonly error?: unknown;
@@ -12,10 +12,10 @@ export declare class ZLinkDispatchErrorReporter {
     /**
      * Success-path tracer companion: every surface already receives a reporter, so
      * exposing the flow tracer here wires all dispatch sites without threading a new
-     * parameter. Shares the same diagnostics context (live mode) and error sink.
+     * parameter. Shares the diagnostics context and host submission lease.
      */
     readonly flow: ZLinkMessageFlowTracer;
-    constructor(_observerType: undefined, _providerResolver: unknown, errorSink: ZLinkDispatchErrorSink, ctx?: ZLinkDiagnosticsContext, metrics?: ZLinkRuntimeMetrics | undefined);
+    constructor(ctx?: ZLinkDiagnosticsContext, metrics?: ZLinkRuntimeMetrics | undefined);
     report(event: ZLinkRuntimeDispatchFailure): void;
     captureEnabled(): boolean;
     get reportedCount(): number;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkDispatchErrorReporter = void 0;
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
-const diagnostics_1 = require("../diagnostics");
+const message_flow_1 = require("../diagnostics/message-flow");
 const dispatch_error_details_1 = require("../diagnostics/dispatch-error-details");
 const runtime_metrics_1 = require("../diagnostics/runtime-metrics");
 class ZLinkDispatchErrorReporter {
@@ -11,17 +11,17 @@ class ZLinkDispatchErrorReporter {
     /**
      * Success-path tracer companion: every surface already receives a reporter, so
      * exposing the flow tracer here wires all dispatch sites without threading a new
-     * parameter. Shares the same diagnostics context (live mode) and error sink.
+     * parameter. Shares the diagnostics context and host submission lease.
      */
     flow;
-    constructor(_observerType, _providerResolver, errorSink, ctx, metrics) {
+    constructor(ctx, metrics) {
         this.metrics = metrics;
         const flowCtx = ctx ?? {
-            diagnostics: diagnostics_1.DEFAULT_ZLINK_DIAGNOSTICS,
+            diagnostics: message_flow_1.DEFAULT_ZLINK_DIAGNOSTICS,
             liveMode: { mode: 'errors' },
             sourceMeshGeneration: 0n
         };
-        this.flow = new diagnostics_1.ZLinkMessageFlowTracer(flowCtx, errorSink);
+        this.flow = new message_flow_1.ZLinkMessageFlowTracer(flowCtx);
     }
     report(event) {
         const normalized = normalizeDispatchFailure(event);

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" | "stopped" | "retiring";
+        state: "error" | "preparing" | "serving" | "retiring" | "stopped";
     }[] | undefined;
     private isAutomaticSubscriber;
     reclaimOwnerRows(signal?: AbortSignal): Promise<void>;

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

@@ -1,9 +1,12 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
 import type { RoutingId } from '../../contracts';
 import type { ZLinkLocalSpotRouteDispatcher } from './spot-route-dispatch-strategy';
 export declare class ZLinkLocalSpotRouteTransport {
     private readonly dispatcher;
     private readonly defaultRequestTimeoutMs;
-    constructor(dispatcher: ZLinkLocalSpotRouteDispatcher | undefined, defaultRequestTimeoutMs: number | undefined);
+    private readonly requests;
+    constructor(dispatcher: ZLinkLocalSpotRouteDispatcher | undefined, defaultRequestTimeoutMs: number | undefined, requests?: RequestRuntime);
     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, onAdmitted?: () => void): Promise<TReply>;
+    request<TReply>(routerChannelId: string, spotId: RoutingId, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, existing?: PendingOperation<unknown>, destination?: OperationObserver<unknown, unknown>): Promise<TReply>;
 }

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

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkLocalSpotRouteTransport = void 0;
+const request_runtime_1 = require("../foundation/request-runtime");
 const configuration_1 = require("../configuration");
 class ZLinkLocalSpotRouteTransport {
     dispatcher;
     defaultRequestTimeoutMs;
-    constructor(dispatcher, defaultRequestTimeoutMs) {
+    requests;
+    constructor(dispatcher, defaultRequestTimeoutMs, requests = new request_runtime_1.RequestRuntime()) {
         this.dispatcher = dispatcher;
         this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
+        this.requests = requests;
     }
     async send(routerChannelId, spotId, packetName, message, metadata) {
         if (this.dispatcher === undefined) {
@@ -18,28 +21,22 @@ class ZLinkLocalSpotRouteTransport {
             metadata
         });
     }
-    request(routerChannelId, spotId, packetName, request, timeoutMs, signal, onAdmitted) {
+    request(routerChannelId, spotId, packetName, request, timeoutMs, signal, onAdmitted, existing, destination) {
         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;
-        if (effectiveTimeoutMs === undefined)
-            return pending;
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => reject(new configuration_1.ZLinkConfigurationException(`Route channel '${routerChannelId}' local SPOT request timed out.`)), effectiveTimeoutMs);
-            pending.then((value) => {
-                clearTimeout(timeout);
-                resolve(value);
-            }, (error) => {
-                clearTimeout(timeout);
-                reject(error);
+        const dispatcher = this.dispatcher;
+        const operation = this.requests.begin(effectiveTimeoutMs, signal, existing);
+        return this.requests.run(operation, (receiver) => {
+            const work = dispatcher.request(spotId, packetName, request, {
+                channelName: routerChannelId,
+                onAdmitted,
+                signal,
+                requestOperation: operation
             });
-        });
+            void work.then((value) => receiver.operationCompleted(operation.id, value, undefined), (error) => receiver.operationFailed(operation.id, error, undefined));
+        }, (value) => value, (error) => error, destination);
     }
 }
 exports.ZLinkLocalSpotRouteTransport = ZLinkLocalSpotRouteTransport;

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

@@ -1,3 +1,5 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendSendFlags } from '../backend/contracts';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
@@ -5,8 +7,9 @@ import { type ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
 import type { ZLinkChannelSocketRegistry } from './channel-socket-registry';
 export declare class ZLinkRouterSocketSpotRouteTransport {
     private readonly sockets;
-    constructor(sockets: ZLinkChannelSocketRegistry);
+    private readonly requests;
+    constructor(sockets: ZLinkChannelSocketRegistry, requests?: RequestRuntime);
     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, onAdmitted?: () => void): Promise<TReply>;
-    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
+    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, flags: ZLinkBackendSendFlags, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, existing?: PendingOperation<unknown>, destination?: OperationObserver<unknown, unknown>): Promise<TReply>;
+    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, existing?: PendingOperation<unknown>): Promise<readonly Message[]>;
 }

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

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkRouterSocketSpotRouteTransport = void 0;
-const abort_1 = require("../abort");
+const request_runtime_1 = require("../foundation/request-runtime");
 const channel_envelope_1 = require("./channel-envelope");
 class ZLinkRouterSocketSpotRouteTransport {
     sockets;
-    constructor(sockets) {
+    requests;
+    constructor(sockets, requests = new request_runtime_1.RequestRuntime()) {
         this.sockets = sockets;
+        this.requests = requests;
     }
     async send(target, parts, flags) {
         const router = this.sockets.routeRouter(target.routerChannelId);
@@ -17,27 +19,39 @@ class ZLinkRouterSocketSpotRouteTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    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, onAdmitted);
-        const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
-            void operation.then(channel_envelope_1.closeMessages, () => undefined);
-        });
+    request(target, parts, codecs, flags, timeoutMs, signal, onAdmitted, existing, destination) {
         try {
-            return (0, channel_envelope_1.decodeChannelReply)(replyParts, codecs);
+            const operation = this.requests.begin(timeoutMs, signal, existing);
+            return this.requests.run(operation, (receiver) => {
+                const router = this.sockets.routeRouter(target.routerChannelId);
+                void flags;
+                router.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs, onAdmitted, operation, receiver);
+            }, (value) => {
+                const replyParts = value;
+                try {
+                    return (0, channel_envelope_1.decodeChannelReply)(replyParts, codecs);
+                }
+                finally {
+                    (0, channel_envelope_1.closeMessages)(replyParts);
+                    (0, channel_envelope_1.closeMessages)(parts);
+                }
+            }, (error) => error, destination);
         }
-        finally {
-            (0, channel_envelope_1.closeMessages)(replyParts);
-            (0, channel_envelope_1.closeMessages)(parts);
+        catch (error) {
+            return Promise.reject(error);
         }
     }
-    async requestRaw(target, request, timeoutMs, signal, onAdmitted) {
-        const router = this.sockets.routeRouter(target.routerChannelId);
-        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);
-        });
+    async requestRaw(target, request, timeoutMs, signal, onAdmitted, existing) {
+        const operation = this.requests.begin(timeoutMs, signal, existing);
+        return this.requests.run(operation, (receiver) => {
+            const router = this.sockets.routeRouter(target.routerChannelId);
+            router.requestToSpot(target.targetNodeRid, target.spotId, [request], timeoutMs, onAdmitted, operation, receiver);
+        }, (value) => {
+            const replyParts = value;
+            if (!operation.isPending())
+                (0, channel_envelope_1.closeMessages)(replyParts);
+            return replyParts;
+        }, (error) => error);
     }
 }
 exports.ZLinkRouterSocketSpotRouteTransport = ZLinkRouterSocketSpotRouteTransport;

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

@@ -1,10 +1,13 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendSpot } from '../backend/contracts';
 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, onAdmitted?: () => void): Promise<TReply>;
+    private readonly requests;
+    constructor(defaultRequestTimeoutMs: number | undefined, requests?: RequestRuntime);
+    request<TReply>(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, existing?: PendingOperation<unknown>, destination?: OperationObserver<unknown, unknown>): 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, onAdmitted?: () => void): Promise<readonly Message[]>;
+    requestRaw(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, existing?: PendingOperation<unknown>): Promise<readonly Message[]>;
 }