@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -1,4 +1,7 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
 import type { ZLinkMeshDispatchAdmission } from '../admission';
+import { type ZLinkRequestResult } from '../messaging/request-result';
 import type { ZLinkListenerRecords } from '../foundation/listener-records';
 import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { RoutingId } from '../../contracts';
@@ -6,6 +9,7 @@ import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProvider
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 import type { ZLinkMessageFlowModeCell } from '../diagnostics';
+import type { ZLinkTelemetryLease } from '../diagnostics/message-flow-delivery';
 import type { Message } from '../../contracts/Common/Message';
 import type { ReceiveRecord } from '../foundation/service-runtime-contracts';
 import { type ZLinkFrameworkRegistration } from '../configuration';
@@ -15,6 +19,7 @@ import { ZLinkLocationRuntime, type ZLinkLocationEventSink, type ZLinkLocationRu
 import { type ZLinkRouteRuntimeRequestHandler, type ZLinkRouteRuntimeSendHandler } from './channel-dispatchers';
 import { ApplicationJobQueue } from '../host/application-job-queue';
 export declare class ZLinkChannelRuntimeManager {
+    private readonly requests;
     private readonly registration;
     private readonly sockets;
     private readonly spotRoutes;
@@ -46,22 +51,23 @@ export declare class ZLinkChannelRuntimeManager {
     dispatchLocalMeshRoute(meshName: string, sourceNodeRid: RoutingId, parts: readonly Message[], signal?: AbortSignal): Promise<void>;
     canDispatchLocalMeshRoute(meshName: string): boolean;
     send(channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): ZLinkRequestResult<TReply>;
     tryPublish(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
+    routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): Promise<TReply>;
     routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
-    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
-    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, 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>;
+    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[]>;
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
     dispose(signal?: AbortSignal): Promise<void>;
 }
 export interface ZLinkChannelRuntimeManagerOptions {
+    readonly requests?: RequestRuntime;
     readonly listenerRecords?: ZLinkListenerRecords;
     readonly internalRouteSendHandlers?: ReadonlyMap<string, ZLinkRouteRuntimeSendHandler>;
     readonly internalRouteRequestHandlers?: ReadonlyMap<string, ZLinkRouteRuntimeRequestHandler>;
@@ -77,6 +83,7 @@ export interface ZLinkChannelRuntimeManagerOptions {
         }): Promise<TReply>;
     };
     readonly messageFlowModeCell?: ZLinkMessageFlowModeCell;
+    readonly telemetryLease?: ZLinkTelemetryLease;
     readonly oneWayFailureSink?: (error: unknown) => void;
     readonly applicationJobQueue?: ApplicationJobQueue;
 }

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkChannelRuntimeManager = void 0;
+const request_runtime_1 = require("../foundation/request-runtime");
+const request_result_1 = require("../messaging/request-result");
 const configuration_1 = require("../configuration");
 const channel_socket_registry_1 = require("./channel-socket-registry");
 const channel_dispatch_services_1 = require("./channel-dispatch-services");
@@ -9,6 +11,7 @@ const channel_runtime_lifecycle_1 = require("./channel-runtime-lifecycle");
 const spot_route_dispatch_strategy_1 = require("./spot-route-dispatch-strategy");
 const application_job_queue_1 = require("../host/application-job-queue");
 class ZLinkChannelRuntimeManager {
+    requests;
     registration;
     sockets;
     spotRoutes;
@@ -16,15 +19,17 @@ class ZLinkChannelRuntimeManager {
     lifecycle;
     constructor(registration, adapter, context, providerResolver, options = {}) {
         this.registration = registration;
+        this.requests = options.requests ?? new request_runtime_1.RequestRuntime();
         const applicationJobQueue = options.applicationJobQueue ??
             new application_job_queue_1.ApplicationJobQueue((0, application_job_queue_1.resolveApplicationJobQueueConfiguration)());
         this.sockets = new channel_socket_registry_1.ZLinkChannelSocketRegistry(registration, adapter, context, options.monitoringAdapter, options.oneWayFailureSink, applicationJobQueue, options.listenerRecords);
         const codecs = {
             serializers: registration.messageSerializers
         };
-        const dispatchServices = new channel_dispatch_services_1.ZLinkChannelDispatchServices(registration, providerResolver, options.messageFlowModeCell);
+        const dispatchServices = new channel_dispatch_services_1.ZLinkChannelDispatchServices(registration, providerResolver, options.messageFlowModeCell, options.telemetryLease);
         const spotRouteBridges = new Map();
         this.spotRoutes = new spot_route_dispatch_strategy_1.ZLinkSpotRouteDispatchStrategy({
+            requests: this.requests,
             registration,
             sockets: this.sockets,
             codecs,
@@ -32,7 +37,7 @@ class ZLinkChannelRuntimeManager {
             localSpotRouteDispatcher: options.localSpotRouteDispatcher,
             flowCreationEnabled: () => dispatchServices.flowCreationEnabled()
         });
-        this.outbound = new channel_outbound_operations_1.ZLinkChannelOutboundOperations(this.sockets, codecs, dispatchServices);
+        this.outbound = new channel_outbound_operations_1.ZLinkChannelOutboundOperations(this.sockets, codecs, dispatchServices, this.requests);
         this.lifecycle = new channel_runtime_lifecycle_1.ZLinkChannelRuntimeLifecycle({
             registration,
             adapter,
@@ -141,8 +146,20 @@ class ZLinkChannelRuntimeManager {
     send(channelName, packetName, message, metadata) {
         return this.outbound.send(channelName, packetName, message, metadata);
     }
-    async request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
-        return this.outbound.request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted);
+    request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation) {
+        try {
+            const operation = this.requests.begin(timeoutMs, signal, requestOperation);
+            const pending = this.outbound.request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, operation);
+            return {
+                pending,
+                decode: (request_result_1.identityRequestReply),
+                mapFailure: request_result_1.identityRequestReply,
+                operation: operation
+            };
+        }
+        catch (error) {
+            return (0, request_result_1.rejectZLinkRequestReply)(error);
+        }
     }
     tryPublish(channelName, topic, packetName, event, metadata) {
         return this.outbound.tryPublish(channelName, topic, packetName, event, metadata);
@@ -153,26 +170,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, onAdmitted) {
-        return this.outbound.routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted);
+    routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation) {
+        return this.outbound.routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation);
     }
     async routeSendToSpot(spotRouteTarget, packetName, message, metadata) {
         return this.spotRoutes.routeSendToSpot(spotRouteTarget, packetName, message, metadata);
     }
-    async routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
-        return this.spotRoutes.routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted);
+    routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation, destination) {
+        return this.spotRoutes.routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation, destination);
     }
-    async routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted) {
-        return this.spotRoutes.routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted);
+    routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted, requestOperation, destination) {
+        return this.spotRoutes.routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted, requestOperation, destination);
     }
     async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
         return this.spotRoutes.routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
-    async routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
-        return this.spotRoutes.routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted);
+    async routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation) {
+        return this.spotRoutes.routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation);
     }
-    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
-        return this.spotRoutes.routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
+    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation) {
+        return this.spotRoutes.routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted, requestOperation);
     }
     canRouteChannel(routerChannelId) {
         return this.spotRoutes.canRouteChannel(routerChannelId);
@@ -181,6 +198,7 @@ class ZLinkChannelRuntimeManager {
         return this.spotRoutes.canRoutePacketChannel(routerChannelId);
     }
     async dispose(signal) {
+        this.requests.close();
         await this.lifecycle.dispose(signal);
     }
 }

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

@@ -1,12 +1,14 @@
+import { inspectRuntime } from '../internal-observation';
 import { type RoutingId, type ZLinkClientServerServerDescriptor, type ZLinkFanoutPublisherDescriptor } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import type { ZLinkBackendContext, ZLinkBackendDealerSocket, ZLinkBackendPublisherSocket, ZLinkBackendRouterSocket, ZLinkBackendSocketMonitor, ZLinkBackendSubscriberSocket, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
+import type { ZLinkBackendContext, ZLinkBackendDealerSocket, ZLinkBackendPublisherSocket, ZLinkBackendReadablePoller, ZLinkBackendRouterSocket, ZLinkBackendSocketMonitor, ZLinkBackendSubscriberSocket, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter } from '../backend/contracts';
 import { type ZLinkFrameworkRegistration } from '../configuration';
 import { ZLinkListenerRecords } from '../foundation/listener-records';
 import { ServiceDiscoveryRegistry } from '../foundation/service-discovery-registry';
 import { ServiceLivenessConnection } from '../foundation/service-liveness-registry';
 import type { ApplicationJobQueue } from '../host/application-job-queue';
 import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
+import { type ZLinkClientServerAdmission } from './client-server-service-wire';
 export interface ZLinkClientServerServerSocketIdentity {
     readonly serverRid: string;
     readonly lifecycleGeneration: bigint;
@@ -17,6 +19,20 @@ export interface ZLinkClientServerConnectionCallbacks {
     readonly onTerminated: (routingId: string | undefined, endpoint: string) => void;
 }
 type ClientServerDiscoveryDescriptor = Parameters<ServiceDiscoveryRegistry['admitClientServer']>[0];
+interface ClientServerPhysicalConnection {
+    readonly channelName: string;
+    readonly endpoint: string;
+    readonly dealer: ZLinkBackendDealerSocket;
+    readablePoller?: ZLinkBackendReadablePoller;
+    monitor?: ZLinkBackendSocketMonitor;
+    readonly aliases: Set<string>;
+    readonly callbacksByAlias: Map<string, ZLinkClientServerConnectionCallbacks>;
+    physicalConnectionId: symbol;
+    readyConnectionId?: string;
+    admittedDescriptor?: ClientServerDiscoveryDescriptor;
+    liveness?: ServiceLivenessConnection;
+    admissionAttempt?: symbol;
+}
 export interface ZLinkFanoutConnectionCallbacks {
     readonly onReady: () => void;
     readonly onTerminated: (reason: 'disconnect' | 'deadline' | 'protocol') => void;
@@ -34,13 +50,18 @@ export declare class ZLinkChannelSocketRegistry {
     private readonly monitoringAdapter?;
     private readonly oneWayFailureSink?;
     private readonly applicationJobQueue?;
+    [inspectRuntime](): Readonly<{
+        clientServerConnections: number;
+        fanoutConnections: number;
+        clientServerObservers: number;
+    }>;
     private readonly clientDealers;
     private readonly channelRouters;
     private readonly publishers;
     private readonly routeRouters;
     private readonly routeMembers;
     private readonly clientServerIdentities;
-    private readonly clientServerConnections;
+    readonly clientServerConnections: Map<string, ClientServerPhysicalConnection>;
     private readonly clientServerDiscovery;
     private readonly clientServerReadyIdentities;
     private readonly clientServerServerDescriptors;
@@ -137,9 +158,12 @@ export declare class ZLinkChannelSocketRegistry {
      * the existing admission path.
      */
     private restartClientServerAdmission;
-    private applyClientServerDescriptorUpdate;
+    applyClientServerDescriptorUpdate(connectionId: string, connection: {
+        readonly channelName: string;
+        readonly physicalConnectionId: symbol;
+    }, admission: ZLinkClientServerAdmission): void;
     private ensureClientServerLivenessTimer;
-    private drainSocketMonitors;
+    drainSocketMonitors(): void;
     private removeReadyConnection;
     private requestClientServerLiveness;
     private admitClientServerServerPeer;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkChannelSocketRegistry = void 0;
+const internal_observation_1 = require("../internal-observation");
 const disposal_1 = require("../disposal");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
@@ -35,6 +36,13 @@ class ZLinkChannelSocketRegistry {
     monitoringAdapter;
     oneWayFailureSink;
     applicationJobQueue;
+    [internal_observation_1.inspectRuntime]() {
+        return Object.freeze({
+            clientServerConnections: this.clientServerConnections.size,
+            fanoutConnections: this.fanoutConnections.size,
+            clientServerObservers: this.clientServerDiscovery[internal_observation_1.inspectRuntime]().clientServerObservers
+        });
+    }
     clientDealers = new Map();
     channelRouters = new Map();
     publishers = new Map();
@@ -1294,7 +1302,7 @@ class ZLinkChannelSocketRegistry {
         applySocketConfig(router, routeChannel);
         this.trackRouteMonitor(routerChannelId, router);
         if ((routeChannel.manualConnections ?? []).length > 0) {
-            for (const endpoint of routeChannel.manualConnections ?? []) {
+            for (const endpoint of (0, RuntimeEndpointConnections_1.endpointConnections)(routeChannel, routeChannel.manualConnections ?? []).listConnections()) {
                 router.connect(endpoint);
             }
         }

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

@@ -1,3 +1,6 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
+import { type ZLinkRequestResult } from '../messaging/request-result';
 import { ZLinkFrameworkException } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendMeshNode, ZLinkBackendSpot } from '../backend/contracts';
@@ -11,7 +14,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>, onAdmitted?: () => void): Promise<TReply>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): ZLinkRequestResult<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 +25,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>, onAdmitted?: () => void): Promise<TReply>;
+    request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): ZLinkRequestResult<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>, onAdmitted?: () => void): Promise<TReply>;
+    requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): ZLinkRequestResult<TReply>;
     sendToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
         readonly packetName?: string;
         readonly metadata?: ReadonlyMap<string, string>;
@@ -32,26 +35,27 @@ export interface ZLinkRouteClientTransport {
     requestToSpot?<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
         readonly packetName?: string;
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
         readonly metadata?: ReadonlyMap<string, string>;
-    }): Promise<TReply>;
+    }): ZLinkRequestResult<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>, onAdmitted?: () => void): Promise<TReply>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): ZLinkRequestResult<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>, onAdmitted?: () => void): Promise<TReply>;
+    routeRequest<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): 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>, 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[]>;
+    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>;
+    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>;
+    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[]>;
 }
 export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     private readonly manager;
@@ -63,21 +67,22 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
     private readonly metrics?;
     private readonly flowCreationEnabled;
     private readonly outboundFlow;
+    private readonly requests;
     constructor(manager: () => ZLinkChannelTransportRuntime | undefined, routeChannelPredicate?: ((routerChannelId: string) => boolean) | undefined, meshRuntime?: (() => {
         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);
+    } | 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, requests?: RequestRuntime);
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
     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>, onAdmitted?: () => void): Promise<TReply>;
+    request<TReply>(meshName: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): ZLinkRequestResult<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>, onAdmitted?: () => void): Promise<TReply>;
+    requestToChannel<TReply>(meshName: string, channelName: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void, requestOperation?: PendingOperation<unknown>): ZLinkRequestResult<TReply>;
     private requestToChannelScoped;
     sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: ZLinkSpotRoutedSendOptions): Promise<ZLinkSubmitResult>;
     private sendToSpotScoped;
@@ -85,21 +90,24 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
         readonly packetName?: string;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<ZLinkSubmitResult>;
-    requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: ZLinkSpotRoutedRequestOptions): Promise<TReply>;
+    requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: ZLinkSpotRoutedRequestOptions, destination?: OperationObserver<unknown, unknown>): ZLinkRequestResult<TReply>;
     private requestToSpotScoped;
     requestFromSpotToSpot<TReply = unknown>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
         readonly packetName?: string;
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
-    }): Promise<TReply>;
+    }, destination?: OperationObserver<unknown, unknown>): ZLinkRequestResult<TReply>;
     requestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
     requestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
@@ -111,7 +119,6 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
     private requireMeshNode;
     private completionTable;
     private encodeMessage;
-    private waitForMeshReply;
     private decodeMeshReply;
 }
 export declare function meshRequestFailure(meshName: string, result: number, nativeErrno: number): ZLinkFrameworkException;