@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -1,30 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSourceSpotRouter = void 0;
+const request_runtime_1 = require("../foundation/request-runtime");
 const abort_1 = require("../abort");
 const channel_envelope_1 = require("./channel-envelope");
 const spot_direct_envelope_1 = require("./spot-direct-envelope");
 class ZLinkSourceSpotRouter {
     defaultRequestTimeoutMs;
-    constructor(defaultRequestTimeoutMs) {
+    requests;
+    constructor(defaultRequestTimeoutMs, requests = new request_runtime_1.RequestRuntime()) {
         this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
+        this.requests = requests;
     }
-    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, onAdmitted);
-        const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
-            void operation.then(channel_envelope_1.closeMessages, () => undefined);
-        });
-        try {
-            return (0, spot_direct_envelope_1.decodeSpotDirectReply)(replyParts);
-        }
-        finally {
-            (0, channel_envelope_1.closeMessages)(replyParts);
-            (0, channel_envelope_1.closeMessages)(parts);
-        }
+    request(sourceSpot, target, packetName, request, timeoutMs, signal, onAdmitted, existing, destination) {
+        let parts;
+        const operation = this.requests.begin(timeoutMs ?? this.defaultRequestTimeoutMs, signal, existing);
+        return this.requests.run(operation, (receiver) => {
+            (0, abort_1.throwIfAborted)(signal);
+            parts = [
+                (0, spot_direct_envelope_1.encodeSpotDirectEnvelope)(1 /* ZLinkChannelMessageKind.Request */, target.routerChannelId, packetName, request)
+            ];
+            sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs ?? this.defaultRequestTimeoutMs, onAdmitted, operation, receiver);
+        }, (value) => {
+            const replyParts = value;
+            try {
+                return (0, spot_direct_envelope_1.decodeSpotDirectReply)(replyParts);
+            }
+            finally {
+                (0, channel_envelope_1.closeMessages)(replyParts);
+                (0, channel_envelope_1.closeMessages)(parts);
+            }
+        }, (error) => error, destination);
     }
     async send(sourceSpot, target, packetName, message, metadata) {
         const parts = [
@@ -37,12 +43,17 @@ class ZLinkSourceSpotRouter {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    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, onAdmitted);
-        return await (0, abort_1.awaitWithAbort)(operation, signal, () => {
-            void operation.then(channel_envelope_1.closeMessages, () => undefined);
-        });
+    async requestRaw(sourceSpot, target, request, timeoutMs, signal, onAdmitted, existing) {
+        const operation = this.requests.begin(timeoutMs ?? this.defaultRequestTimeoutMs, signal, existing);
+        return this.requests.run(operation, (receiver) => {
+            (0, abort_1.throwIfAborted)(signal);
+            sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, request, timeoutMs ?? this.defaultRequestTimeoutMs, onAdmitted, operation, receiver);
+        }, (value) => {
+            const replyParts = value;
+            if (!operation.isPending())
+                (0, channel_envelope_1.closeMessages)(replyParts);
+            return replyParts;
+        }, (error) => error);
     }
 }
 exports.ZLinkSourceSpotRouter = ZLinkSourceSpotRouter;

package/dist/runtime/channels/spot-node-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 { ZLinkFrameworkRegistration } from '../configuration';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
@@ -6,8 +8,9 @@ import { ZLinkSpotRouteTargetResolver } from './spot-route-target-resolver';
 export declare class ZLinkSpotNodeRouteTransport {
     private readonly registration;
     private readonly targets;
-    constructor(registration: ZLinkFrameworkRegistration, targets: ZLinkSpotRouteTargetResolver);
+    private readonly requests;
+    constructor(registration: ZLinkFrameworkRegistration, targets: ZLinkSpotRouteTargetResolver, requests?: RequestRuntime);
     send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<boolean>;
-    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;
+    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, existing?: PendingOperation<unknown>, destination?: OperationObserver<unknown, unknown>): Promise<TReply> | undefined;
+    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, existing?: PendingOperation<unknown>): Promise<readonly Message[]> | undefined;
 }

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

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotNodeRouteTransport = void 0;
-const Registration_1 = require("../../contracts/Configuration/Registration");
+const request_runtime_1 = require("../foundation/request-runtime");
 const abort_1 = require("../abort");
 const channel_envelope_1 = require("./channel-envelope");
 class ZLinkSpotNodeRouteTransport {
     registration;
     targets;
-    constructor(registration, targets) {
+    requests;
+    constructor(registration, targets, requests = new request_runtime_1.RequestRuntime()) {
         this.registration = registration;
         this.targets = targets;
+        this.requests = requests;
     }
     async send(target, parts) {
         const router = this.targets.spotNodeRouter(target.routerChannelId);
@@ -24,17 +26,17 @@ class ZLinkSpotNodeRouteTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    request(target, parts, codecs, timeoutMs, signal, onAdmitted) {
+    request(target, parts, codecs, timeoutMs, signal, onAdmitted, existing, destination) {
         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, onAdmitted);
-        return (0, abort_1.awaitWithAbort)(operation, signal, () => {
-            void operation.then(channel_envelope_1.closeMessages, () => undefined);
-        }).then((replyParts) => {
+        const operation = this.requests.begin(timeoutMs ?? this.registration.requestTimeoutMs, signal, existing);
+        return this.requests.run(operation, (receiver) => {
+            (0, abort_1.throwIfAborted)(signal);
+            router.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs ?? this.registration.requestTimeoutMs, onAdmitted, operation, receiver);
+        }, (value) => {
+            const replyParts = value;
             try {
                 return (0, channel_envelope_1.decodeChannelReply)(replyParts, codecs);
             }
@@ -42,19 +44,23 @@ class ZLinkSpotNodeRouteTransport {
                 (0, channel_envelope_1.closeMessages)(replyParts);
                 (0, channel_envelope_1.closeMessages)(parts);
             }
-        });
+        }, (error) => error, destination);
     }
-    requestRaw(target, request, timeoutMs, signal, onAdmitted) {
+    requestRaw(target, request, timeoutMs, signal, onAdmitted, existing) {
         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, onAdmitted);
-        return (0, abort_1.awaitWithAbort)(operation, signal, () => {
-            void operation.then(channel_envelope_1.closeMessages, () => undefined);
-        });
+        const operation = this.requests.begin(timeoutMs ?? this.registration.requestTimeoutMs, signal, existing);
+        return this.requests.run(operation, (receiver) => {
+            (0, abort_1.throwIfAborted)(signal);
+            router.requestToSpot(target.targetNodeRid, target.spotId, request, timeoutMs ?? this.registration.requestTimeoutMs, onAdmitted, operation, receiver);
+        }, (value) => {
+            const replyParts = value;
+            if (!operation.isPending())
+                (0, channel_envelope_1.closeMessages)(replyParts);
+            return replyParts;
+        }, (error) => error);
     }
 }
 exports.ZLinkSpotNodeRouteTransport = ZLinkSpotNodeRouteTransport;

package/dist/runtime/channels/spot-route-bridge-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 { ZLinkBackendSpotRouteBridge } from '../backend/contracts';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
@@ -5,10 +7,11 @@ import { type ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
 export declare class ZLinkSpotRouteBridgeTransport {
     private readonly bridges;
     private readonly defaultRequestTimeoutMs;
-    constructor(bridges: ReadonlyMap<string, ZLinkBackendSpotRouteBridge>, defaultRequestTimeoutMs: number | undefined);
+    private readonly requests;
+    constructor(bridges: ReadonlyMap<string, ZLinkBackendSpotRouteBridge>, defaultRequestTimeoutMs: number | undefined, requests?: RequestRuntime);
     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, 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, 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[]>;
     private requireBridge;
 }

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

@@ -1,16 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotRouteBridgeTransport = void 0;
+const request_runtime_1 = require("../foundation/request-runtime");
 const configuration_1 = require("../configuration");
 const channel_envelope_1 = require("./channel-envelope");
 const channel_multipart_1 = require("./channel-multipart");
-const abort_1 = require("../abort");
 class ZLinkSpotRouteBridgeTransport {
     bridges;
     defaultRequestTimeoutMs;
-    constructor(bridges, defaultRequestTimeoutMs) {
+    requests;
+    constructor(bridges, defaultRequestTimeoutMs, requests = new request_runtime_1.RequestRuntime()) {
         this.bridges = bridges;
         this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
+        this.requests = requests;
     }
     has(routerChannelId) {
         return this.bridges.has(routerChannelId);
@@ -24,32 +26,44 @@ class ZLinkSpotRouteBridgeTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    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(onAdmitted);
-        const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
-            void operation.then(channel_envelope_1.closeMessages, () => undefined);
-        });
+    request(target, parts, codecs, timeoutMs, signal, onAdmitted, existing, destination) {
         try {
-            return (0, channel_envelope_1.decodeChannelReply)(replyParts, codecs);
+            const operation = this.requests.begin(timeoutMs ?? this.defaultRequestTimeoutMs, signal, existing);
+            return this.requests.run(operation, (receiver) => {
+                const bridge = this.requireBridge(target.routerChannelId);
+                (0, channel_multipart_1.appendParts)(bridge.request(target.routerChannelId, target.targetNodeRid, target.spotId), parts)
+                    .timeout(timeoutMs ?? this.defaultRequestTimeoutMs ?? 0)
+                    .submit(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);
         }
     }
-    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(onAdmitted);
-        return (0, abort_1.awaitWithAbort)(operation, signal, () => {
-            void operation.then(channel_envelope_1.closeMessages, () => undefined);
-        });
+    requestRaw(target, request, timeoutMs, signal, onAdmitted, existing) {
+        const operation = this.requests.begin(timeoutMs ?? this.defaultRequestTimeoutMs, signal, existing);
+        return this.requests.run(operation, (receiver) => {
+            const bridge = this.requireBridge(target.routerChannelId);
+            (0, channel_multipart_1.appendParts)(bridge.request(target.routerChannelId, target.targetNodeRid, target.spotId), [
+                request
+            ])
+                .timeout(timeoutMs ?? this.defaultRequestTimeoutMs ?? 0)
+                .submit(onAdmitted, operation, receiver);
+        }, (value) => {
+            const replyParts = value;
+            if (!operation.isPending())
+                (0, channel_envelope_1.closeMessages)(replyParts);
+            return replyParts;
+        }, (error) => error);
     }
     requireBridge(routerChannelId) {
         const bridge = this.bridges.get(routerChannelId);

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

@@ -1,3 +1,5 @@
+import type { RequestRuntime } from '../foundation/request-runtime';
+import type { OperationObserver, PendingOperation } from '../foundation/operation-registry';
 import type { Message } from '../../contracts/Common/Message';
 import type { RoutingId } from '../../contracts';
 import type { ZLinkFrameworkRegistration } from '../configuration';
@@ -13,11 +15,13 @@ export interface ZLinkLocalSpotRouteDispatcher {
     request<TReply>(spotId: RoutingId, packetName: string | undefined, request: unknown, context: {
         readonly channelName: string;
         readonly signal?: AbortSignal;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly onAdmitted?: () => void;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<TReply>;
 }
 export interface ZLinkSpotRouteDispatchStrategyOptions {
+    readonly requests: RequestRuntime;
     readonly registration: ZLinkFrameworkRegistration;
     readonly sockets: ZLinkChannelSocketRegistry;
     readonly codecs: ZLinkChannelEnvelopeCodecRegistry;
@@ -40,10 +44,10 @@ export declare class ZLinkSpotRouteDispatchStrategy {
     canRoutePacketChannel(routerChannelId: string): boolean;
     routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     private routeSendToSpotScoped;
-    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
+    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>, destination?: OperationObserver<unknown, unknown>): Promise<TReply>;
     private routeRequestToSpotScoped;
-    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
+    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>, destination?: OperationObserver<unknown, unknown>): 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, onAdmitted?: () => void): Promise<readonly Message[]>;
-    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
+    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): Promise<readonly Message[]>;
+    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): Promise<readonly Message[]>;
 }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotRouteDispatchStrategy = void 0;
+const request_result_1 = require("../messaging/request-result");
 const channel_envelope_1 = require("./channel-envelope");
 const channel_framework_packets_1 = require("./channel-framework-packets");
 const abort_1 = require("../abort");
@@ -22,12 +23,12 @@ class ZLinkSpotRouteDispatchStrategy {
     bridgeTransport;
     constructor(options) {
         this.options = options;
-        this.sourceSpotRouter = new source_spot_router_1.ZLinkSourceSpotRouter(options.registration.requestTimeoutMs);
+        this.sourceSpotRouter = new source_spot_router_1.ZLinkSourceSpotRouter(options.registration.requestTimeoutMs, options.requests);
         this.targets = new spot_route_target_resolver_1.ZLinkSpotRouteTargetResolver(options.registration);
-        this.spotNodeTransport = new spot_node_route_transport_1.ZLinkSpotNodeRouteTransport(options.registration, this.targets);
-        this.routerSocketTransport = new router_socket_spot_route_transport_1.ZLinkRouterSocketSpotRouteTransport(options.sockets);
-        this.localTransport = new local_spot_route_transport_1.ZLinkLocalSpotRouteTransport(options.localSpotRouteDispatcher, options.registration.requestTimeoutMs);
-        this.bridgeTransport = new spot_route_bridge_transport_1.ZLinkSpotRouteBridgeTransport(options.spotRouteBridges, options.registration.requestTimeoutMs);
+        this.spotNodeTransport = new spot_node_route_transport_1.ZLinkSpotNodeRouteTransport(options.registration, this.targets, options.requests);
+        this.routerSocketTransport = new router_socket_spot_route_transport_1.ZLinkRouterSocketSpotRouteTransport(options.sockets, options.requests);
+        this.localTransport = new local_spot_route_transport_1.ZLinkLocalSpotRouteTransport(options.localSpotRouteDispatcher, options.registration.requestTimeoutMs, options.requests);
+        this.bridgeTransport = new spot_route_bridge_transport_1.ZLinkSpotRouteBridgeTransport(options.spotRouteBridges, options.registration.requestTimeoutMs, options.requests);
     }
     setSpotNodes(spotNodes) {
         this.targets.setSpotNodes(spotNodes);
@@ -70,58 +71,70 @@ class ZLinkSpotRouteDispatchStrategy {
         }
         await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
     }
-    routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted));
+    routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation, destination) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => {
+            if (requestOperation !== undefined) {
+                return this.options.requests.run(requestOperation, (receiver) => {
+                    this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation, receiver);
+                }, (value) => value, request_result_1.identityRequestReply, destination);
+            }
+            try {
+                return this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation, destination);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        });
     }
-    async routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+    routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation, receiver) {
         (0, abort_1.throwIfAborted)(signal);
         const localSpotRouteNode = this.targets.localRouteNode(spotRouteTarget);
         if (localSpotRouteNode !== undefined) {
-            return this.localTransport.request(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, request, timeoutMs, signal, onAdmitted);
+            return this.localTransport.request(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, request, timeoutMs, signal, onAdmitted, requestOperation, receiver);
         }
         const codecs = (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.options.codecs);
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, spotRouteTarget.routerChannelId, packetName, request, timeoutMs, undefined, codecs, undefined, this.options.flowCreationEnabled?.() ?? true, metadata);
         if (this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId)) {
-            const namedSpotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
+            const namedSpotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted, requestOperation, receiver);
             if (namedSpotNodeRequest !== undefined)
                 return namedSpotNodeRequest;
         }
         if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-            return this.bridgeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
+            return this.bridgeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted, requestOperation, receiver);
         }
         if (this.targets.hasBoundRouteRouter(spotRouteTarget.routerChannelId)) {
-            return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, ZLINK_SEND_DONT_WAIT, timeoutMs, signal, onAdmitted);
+            return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, ZLINK_SEND_DONT_WAIT, timeoutMs, signal, onAdmitted, requestOperation, receiver);
         }
-        const spotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
+        const spotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted, requestOperation, receiver);
         if (spotNodeRequest !== undefined) {
             return spotNodeRequest;
         }
-        return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, 0, timeoutMs, signal, onAdmitted);
+        return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, 0, timeoutMs, signal, onAdmitted, requestOperation, receiver);
     }
-    routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted) {
-        return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted);
+    routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted, requestOperation, destination) {
+        return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted, requestOperation, destination);
     }
     async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
         await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
-    routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
-        return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted);
+    routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation) {
+        return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation);
     }
-    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
+    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation) {
         (0, abort_1.throwIfAborted)(signal);
         if (this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId)) {
-            const namedSpotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
+            const namedSpotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation);
             if (namedSpotNodeRequest !== undefined)
                 return namedSpotNodeRequest;
         }
         if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-            return this.bridgeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
+            return this.bridgeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation);
         }
-        const spotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
+        const spotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation);
         if (spotNodeRequest !== undefined) {
             return spotNodeRequest;
         }
-        return this.routerSocketTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
+        return this.routerSocketTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation);
     }
 }
 exports.ZLinkSpotRouteDispatchStrategy = ZLinkSpotRouteDispatchStrategy;

package/dist/runtime/diagnostics/dispatch-error-details.js

@@ -12,15 +12,21 @@ function dispatchReasonFromError(error) {
     const origin = (0, framework_errors_internal_1.internalFrameworkErrorKind)(error);
     if (origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PayloadDecodeFailed)
         return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.PayloadDecodeFailed;
-    if (origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotGenerationStale ||
+    if (origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.HandlerNotFound ||
+        origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteHandlerNotFound ||
+        origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorDispatchHandlerNotFound)
+        return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerMissing;
+    if (origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound ||
+        origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotRouteNotFound ||
+        origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound ||
+        origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.MeshNotFound ||
+        origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotGenerationStale ||
         origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorGenerationStale ||
         origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving ||
         origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorMoving ||
         origin === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale)
         return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget;
     switch (error.kind) {
-        case ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.NotFound:
-            return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerMissing;
         case ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.ProtocolError:
             return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.InvalidFrame;
         case ZLinkFrameworkException_1.ZLinkFrameworkErrorKind.ShuttingDown:

package/dist/runtime/diagnostics/message-flow-bootstrap.d.ts

@@ -0,0 +1 @@
+export declare const initialLoggerProvider: import("@opentelemetry/api-logs").LoggerProvider;

package/dist/runtime/diagnostics/message-flow-bootstrap.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialLoggerProvider = void 0;
+const api_logs_1 = require("@opentelemetry/api-logs");
+// Loaded before the application's standard preloads in this worker only. The
+// public API returns this proxy until a logger provider is registered, then the
+// registered provider itself. No provider is changed or called to probe it.
+exports.initialLoggerProvider = api_logs_1.logs.getLoggerProvider();

package/dist/runtime/diagnostics/message-flow-delivery.d.ts

@@ -0,0 +1,47 @@
+export declare const MESSAGE_FLOW_PENDING_LIMIT = 8192;
+export declare const TELEMETRY_WORKER_AVAILABLE = "zlink.telemetry.available";
+export declare enum TelemetryState {
+    Pending = 0,
+    Enabled = 1,
+    Length = 2
+}
+export declare enum TelemetryCounter {
+    Overflow = 0,
+    LoggerFailures = 1,
+    TraceFailures = 2,
+    FallbackFailures = 3,
+    WorkerFailures = 4,
+    Length = 5
+}
+export declare const TELEMETRY_STATE_BYTES: number;
+export interface ZLinkTelemetryLease {
+    readonly retired: Int32Array;
+}
+export interface ZLinkTelemetryDelivery<T = unknown> {
+    readonly lease: SharedArrayBuffer;
+    readonly record: T;
+}
+export declare function openTelemetryLease(): ZLinkTelemetryLease;
+export declare function renewTelemetryLease(lease: ZLinkTelemetryLease | undefined): ZLinkTelemetryLease;
+export declare function messageFlowDelivery(): ZLinkMessageFlowDelivery;
+export declare function telemetryProviderFailureCount(): number;
+export declare function retireTelemetryLease(lease: ZLinkTelemetryLease): void;
+export declare class ZLinkMessageFlowDelivery {
+    private readonly sharedState;
+    readonly state: Int32Array<SharedArrayBuffer>;
+    readonly counters: BigUint64Array<SharedArrayBuffer>;
+    readonly ready: Promise<void>;
+    private readonly worker?;
+    private failure?;
+    private pending;
+    private executing;
+    private workerReady;
+    private scheduled?;
+    constructor();
+    private workerFailed;
+    enabled(): boolean;
+    accepts(lease: ZLinkTelemetryLease): boolean;
+    submit(lease: ZLinkTelemetryLease, record: unknown): void;
+    retire(lease: ZLinkTelemetryLease): void;
+    private flush;
+}