@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -21,3 +21,4 @@ export declare function appendParts<TNext extends ZLinkMultipartOperation<TNext>
 export declare function submitRequestOperation(operation: {
     submit(): Promise<readonly Message[]>;
 }, label: string): Promise<readonly Message[]>;
+export declare function mapRequestFailure(error: unknown, label: string): unknown;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.appendParts = appendParts;
 exports.submitRequestOperation = submitRequestOperation;
+exports.mapRequestFailure = mapRequestFailure;
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const runtime_values_1 = require("../backend/runtime-values");
 const configuration_1 = require("../configuration");
@@ -21,11 +22,14 @@ async function submitRequestOperation(operation, label) {
         return await operation.submit();
     }
     catch (error) {
-        //  Spec 32-framework-error-model:81-92 — classify the backend request
-        //  terminal rather than collapsing every failure to Unavailable.
-        if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'request') {
-            throw new contracts_1.ZLinkFrameworkException((0, framework_errors_internal_1.requestResultToPublicErrorKind)(error.result), `${label} failed with result ${error.result}.`, error);
-        }
-        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${label} failed before a reply was received.`, true, error);
+        throw mapRequestFailure(error, label);
     }
 }
+function mapRequestFailure(error, label) {
+    //  Spec 32-framework-error-model:81-92 — classify the backend request
+    //  terminal rather than collapsing every failure to Unavailable.
+    if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'request') {
+        return new contracts_1.ZLinkFrameworkException((0, framework_errors_internal_1.requestResultToPublicErrorKind)(error.result), `${label} failed with result ${error.result}.`, error);
+    }
+    return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${label} failed before a reply was received.`, true, error);
+}

package/dist/runtime/channels/channel-outbound-operations.d.ts

@@ -1,3 +1,5 @@
+import { RequestRuntime } from '../foundation/request-runtime';
+import type { PendingOperation } from '../foundation/operation-registry';
 import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import { type ZLinkRuntimeMessageFlowResult } from '../../contracts/Dispatch/ZLinkDispatchOptions';
 import { type ZLinkChannelEnvelopeCodecRegistry } from './channel-envelope';
@@ -7,13 +9,14 @@ export declare class ZLinkChannelOutboundOperations {
     private readonly sockets;
     private readonly codecs;
     private readonly dispatchServices;
+    private readonly requests;
     private readonly pendingRequests;
-    constructor(sockets: ZLinkChannelSocketRegistry, codecs: ZLinkChannelEnvelopeCodecRegistry, dispatchServices: ZLinkChannelDispatchServices);
+    constructor(sockets: ZLinkChannelSocketRegistry, codecs: ZLinkChannelEnvelopeCodecRegistry, dispatchServices: ZLinkChannelDispatchServices, requests?: RequestRuntime);
     pendingRequestCount(channelName: string): number;
     send(channelName: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     private sendScoped;
     private traceSend;
-    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>): Promise<TReply>;
     private requestScoped;
     tryPublish(channelName: string, topic: string, packetName: string | undefined, event: unknown, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     private tryPublishScoped;
@@ -22,15 +25,9 @@ export declare class ZLinkChannelOutboundOperations {
     routeSubmit(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
     private routeSubmitScoped;
     private traceRouteSend;
-    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>;
     private routeRequestScoped;
     private measureRequest;
 }
-/**
- * A ClientServer DEALER's request progress poller is intentionally unref'ed.
- * The public request promise is live work, however, so it needs its own
- * ref'ed handle until reply, cancellation, timeout, or failure settles it.
- */
-export declare function keepChannelRequestAlive<T>(request: Promise<T>): Promise<T>;
 export declare function requestTerminalResult(error: unknown, signal: AbortSignal | undefined): ZLinkRuntimeMessageFlowResult;
 export declare function isRemoteChannelErrorReply(error: unknown): boolean;

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkChannelOutboundOperations = void 0;
-exports.keepChannelRequestAlive = keepChannelRequestAlive;
 exports.requestTerminalResult = requestTerminalResult;
 exports.isRemoteChannelErrorReply = isRemoteChannelErrorReply;
+const request_runtime_1 = require("../foundation/request-runtime");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const request_deadline_1 = require("../messaging/request-deadline");
 const runtime_values_1 = require("../backend/runtime-values");
@@ -16,19 +16,18 @@ const channel_framework_packets_1 = require("./channel-framework-packets");
 const contracts_1 = require("../../contracts");
 const route_disconnected_error_1 = require("./route-disconnected-error");
 const flow_context_1 = require("../diagnostics/flow-context");
-const CHANNEL_REQUEST_LOOP_KEEPALIVE_MS = 0x7fff_ffff;
-//  Shared default for the dominant no-metadata call; avoids a Map allocation
-//  per outbound operation.
 const EMPTY_OUTBOUND_METADATA = new Map();
 class ZLinkChannelOutboundOperations {
     sockets;
     codecs;
     dispatchServices;
+    requests;
     pendingRequests = new Map();
-    constructor(sockets, codecs, dispatchServices) {
+    constructor(sockets, codecs, dispatchServices, requests = new request_runtime_1.RequestRuntime()) {
         this.sockets = sockets;
         this.codecs = codecs;
         this.dispatchServices = dispatchServices;
+        this.requests = requests;
     }
     pendingRequestCount(channelName) {
         return this.pendingRequests.get(channelName) ?? 0;
@@ -68,19 +67,13 @@ class ZLinkChannelOutboundOperations {
             correlationId: undefined
         });
     }
-    request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
-        return keepChannelRequestAlive((0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.requestScoped(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted)));
+    request(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.requestScoped(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation));
     }
-    async requestScoped(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
-        const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
-        const deadlineUnixMs = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
+    requestScoped(channelName, packetName, request, timeoutMs, signal, metadata, onAdmitted, existing) {
         let correlationId;
         let selectedServerRid;
-        let terminalRecorded = false;
         const traceTerminal = (result) => {
-            if (terminalRecorded)
-                return;
-            terminalRecorded = true;
             this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, result)?.trace({
                 surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.Channel,
                 messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
@@ -93,60 +86,68 @@ class ZLinkChannelOutboundOperations {
             });
         };
         try {
-            (0, abort_1.throwIfAborted)(signal);
-            const readyWait = new AbortController();
-            const readySignal = signal === undefined ? readyWait.signal : AbortSignal.any([signal, readyWait.signal]);
-            const dealer = await (0, request_deadline_1.waitRequestReply)(this.sockets.awaitClientDealerForOutbound(channelName, readySignal), `Channel request '${channelName}'`, deadlineMs, signal, () => readyWait.abort());
-            if (dealer === undefined) {
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `Channel '${channelName}' has no ready ClientServer server before its admission deadline.`);
-            }
-            const serverRid = this.sockets.selectedClientServerRid(channelName, dealer);
-            selectedServerRid = serverRid;
-            correlationId = (0, channel_envelope_1.newChannelCorrelationId)();
-            const parts = (0, channel_envelope_1.encodeChannelEnvelopePartsAtDeadline)(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, deadlineUnixMs, undefined, this.codecs, correlationId, this.dispatchServices.flowCreationEnabled(), metadata);
-            this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent)?.trace({
-                surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.Channel,
-                messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
-                channelName,
-                channelRouteKind: 'client_server',
-                serverRid,
-                packetName,
-                correlationId
-            });
-            const reply = await this.measureRequest(channelName, async () => {
-                let replyParts = [];
-                try {
-                    try {
-                        replyParts = await (0, abort_1.awaitWithAbort)(dealer.request(parts, (0, request_deadline_1.remainingRequestTimeout)(`Channel request '${channelName}'`, deadlineMs), onAdmitted), signal);
-                    }
-                    catch (error) {
-                        if (signal?.aborted === true)
-                            throw error;
-                        //  Spec 32-framework-error-model:81-92 — classify the backend request
-                        //  terminal (deadline -> DeadlineExceeded, lost route -> Unavailable,
-                        //  etc.) instead of collapsing every failure to Unavailable.
-                        if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'request') {
-                            throw new contracts_1.ZLinkFrameworkException((0, framework_errors_internal_1.requestResultToPublicErrorKind)(error.result), `Channel '${channelName}' request failed with result ${error.result}.`, error);
-                        }
-                        throw error;
+            signal?.throwIfAborted();
+            const operation = this.requests.begin(timeoutMs, signal, existing);
+            const reply = this.requests.run(operation, (receiver) => {
+                this.measureRequest(channelName, operation);
+                operation.mapCaller((value) => {
+                    traceTerminal('succeeded');
+                    return value;
+                }, (error) => {
+                    if (!isRemoteChannelErrorReply(error))
+                        traceTerminal(requestTerminalResult(error, signal));
+                    throw error;
+                });
+                void (async () => {
+                    const requestOperation = operation;
+                    const deadlineMs = requestOperation.deadlineMs;
+                    const deadlineUnixMs = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
+                    const readyWait = new AbortController();
+                    const readySignal = signal === undefined ? readyWait.signal : AbortSignal.any([signal, readyWait.signal]);
+                    const dealer = await (0, request_deadline_1.waitRequestReply)(this.sockets.awaitClientDealerForOutbound(channelName, readySignal), `Channel request '${channelName}'`, requestOperation, () => readyWait.abort());
+                    if (dealer === undefined) {
+                        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded, `Channel '${channelName}' has no ready ClientServer server before its admission deadline.`);
                     }
+                    const serverRid = this.sockets.selectedClientServerRid(channelName, dealer);
+                    selectedServerRid = serverRid;
+                    correlationId = (0, channel_envelope_1.newChannelCorrelationId)();
+                    const parts = (0, channel_envelope_1.encodeChannelEnvelopePartsAtDeadline)(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, deadlineUnixMs, undefined, this.codecs, correlationId, this.dispatchServices.flowCreationEnabled(), metadata);
+                    this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent)?.trace({
+                        surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.Channel,
+                        messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
+                        channelName,
+                        channelRouteKind: 'client_server',
+                        serverRid,
+                        packetName,
+                        correlationId
+                    });
+                    dealer.request(parts, (0, request_deadline_1.remainingRequestTimeout)(`Channel request '${channelName}'`, deadlineMs), onAdmitted, requestOperation, receiver);
+                })().catch((error) => receiver.operationFailed(operation.id, error, undefined));
+            }, (raw) => {
+                const replyParts = raw;
+                try {
                     return (0, channel_envelope_1.decodeChannelReply)(replyParts, this.codecs);
                 }
                 finally {
                     (0, channel_envelope_1.closeMessages)(replyParts);
                 }
+            }, (error) => {
+                if (signal?.aborted !== true &&
+                    (0, runtime_values_1.isZLinkBackendResultError)(error) &&
+                    error.operation === 'request') {
+                    return new contracts_1.ZLinkFrameworkException((0, framework_errors_internal_1.requestResultToPublicErrorKind)(error.result), `Channel '${channelName}' request failed with result ${error.result}.`, error);
+                }
+                return error;
             });
-            traceTerminal('succeeded');
             return reply;
         }
         catch (error) {
             // A framework peer has already made the terminal dispatch error record
             // before it sends an Error reply.  Do not turn that same remote dispatch
             // failure into a second local `reply_received` terminal at Errors level.
-            if (!isRemoteChannelErrorReply(error)) {
+            if (!isRemoteChannelErrorReply(error))
                 traceTerminal(requestTerminalResult(error, signal));
-            }
-            throw error;
+            return Promise.reject(error);
         }
     }
     tryPublish(channelName, topic, packetName, event, metadata = EMPTY_OUTBOUND_METADATA) {
@@ -205,17 +206,12 @@ class ZLinkChannelOutboundOperations {
             targetRid: targetNodeRid
         });
     }
-    routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.routeRequestScoped(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted));
+    routeRequest(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.dispatchServices.flowCreationEnabled(), () => this.routeRequestScoped(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, requestOperation));
     }
-    async routeRequestScoped(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+    routeRequestScoped(routerChannelId, targetNodeRid, packetName, request, timeoutMs, signal, metadata, onAdmitted, existing) {
         let correlationId;
-        let router;
-        let terminalRecorded = false;
         const traceTerminal = (result) => {
-            if (terminalRecorded)
-                return;
-            terminalRecorded = true;
             this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, result)?.trace({
                 surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.RouteMeshChannel,
                 messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
@@ -228,71 +224,77 @@ class ZLinkChannelOutboundOperations {
             });
         };
         try {
-            (0, abort_1.throwIfAborted)(signal);
-            router = this.sockets.routeRouter(routerChannelId);
-            if (this.sockets.routeMemberStatus(routerChannelId, targetNodeRid) === 'missing') {
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound, `Route channel '${routerChannelId}' has no member '${targetNodeRid}'.`);
-            }
-            correlationId = (0, channel_envelope_1.newChannelCorrelationId)();
-            const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, routerChannelId, packetName, request, timeoutMs, undefined, (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.codecs), correlationId, this.dispatchServices.flowCreationEnabled(), metadata);
-            this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent)?.trace({
-                surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.RouteMeshChannel,
-                messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
-                channelName: routerChannelId,
-                channelRouteKind: 'route_mesh',
-                packetName,
-                correlationId,
-                targetRid: targetNodeRid
-            });
-            const reply = await this.measureRequest(routerChannelId, async () => {
-                const replyParts = await (0, abort_1.awaitWithAbort)(router.request(targetNodeRid, parts, timeoutMs, onAdmitted), signal);
+            signal?.throwIfAborted();
+            const operation = this.requests.begin(timeoutMs, signal, existing);
+            const reply = this.requests.run(operation, (receiver) => {
+                this.measureRequest(routerChannelId, operation);
+                operation.mapCaller((value) => {
+                    traceTerminal('succeeded');
+                    return value;
+                }, (error) => {
+                    if (!isRemoteChannelErrorReply(error))
+                        traceTerminal(requestTerminalResult(error, signal));
+                    throw error;
+                });
+                const requestOperation = operation;
+                const router = this.sockets.routeRouter(routerChannelId);
+                if (this.sockets.routeMemberStatus(routerChannelId, targetNodeRid) === 'missing') {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound, `Route channel '${routerChannelId}' has no member '${targetNodeRid}'.`);
+                }
+                correlationId = (0, channel_envelope_1.newChannelCorrelationId)();
+                const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, routerChannelId, packetName, request, timeoutMs, undefined, (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.codecs), correlationId, this.dispatchServices.flowCreationEnabled(), metadata);
+                this.dispatchServices.beginOutbound(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent)?.trace({
+                    surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.RouteMeshChannel,
+                    messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
+                    channelName: routerChannelId,
+                    channelRouteKind: 'route_mesh',
+                    packetName,
+                    correlationId,
+                    targetRid: targetNodeRid
+                });
+                router.request(targetNodeRid, parts, timeoutMs, onAdmitted, requestOperation, receiver);
+            }, (raw) => {
+                const replyParts = raw;
                 try {
                     return (0, channel_envelope_1.decodeChannelReply)(replyParts, this.codecs);
                 }
                 finally {
                     (0, channel_envelope_1.closeMessages)(replyParts);
                 }
+            }, (error) => {
+                if (this.sockets.routeMemberStatus(routerChannelId, targetNodeRid) === 'disconnected' &&
+                    (isSubmitDeadline(error) || error instanceof route_disconnected_error_1.ZLinkRouteDisconnectedError)) {
+                    return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `Route channel '${routerChannelId}' member '${targetNodeRid}' is not connected.`, true, error);
+                }
+                return error;
             });
-            traceTerminal('succeeded');
             return reply;
         }
         catch (error) {
-            // See the ClientServer request path: the remote dispatch error owns this
-            // terminal record when the reply itself is an Error envelope.
-            if (!isRemoteChannelErrorReply(error)) {
+            if (!isRemoteChannelErrorReply(error))
                 traceTerminal(requestTerminalResult(error, signal));
-            }
-            if (this.sockets.routeMemberStatus(routerChannelId, targetNodeRid) === 'disconnected' &&
-                (isSubmitDeadline(error) || error instanceof route_disconnected_error_1.ZLinkRouteDisconnectedError)) {
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `Route channel '${routerChannelId}' member '${targetNodeRid}' is not connected.`, true, error);
-            }
-            throw error;
+            return Promise.reject(error);
         }
     }
-    async measureRequest(channel, operation) {
+    measureRequest(channel, operation) {
         this.pendingRequests.set(channel, this.pendingRequestCount(channel) + 1);
-        try {
-            return await operation();
-        }
-        finally {
+        const complete = () => {
             const remaining = this.pendingRequestCount(channel) - 1;
             if (remaining === 0)
                 this.pendingRequests.delete(channel);
             else
                 this.pendingRequests.set(channel, remaining);
-        }
+        };
+        operation.mapCaller((value) => {
+            complete();
+            return value;
+        }, (error) => {
+            complete();
+            throw error;
+        });
     }
 }
 exports.ZLinkChannelOutboundOperations = ZLinkChannelOutboundOperations;
-/**
- * A ClientServer DEALER's request progress poller is intentionally unref'ed.
- * The public request promise is live work, however, so it needs its own
- * ref'ed handle until reply, cancellation, timeout, or failure settles it.
- */
-function keepChannelRequestAlive(request) {
-    const keepalive = setTimeout(() => { }, CHANNEL_REQUEST_LOOP_KEEPALIVE_MS);
-    return request.finally(() => clearTimeout(keepalive));
-}
 function isSubmitDeadline(error) {
     return (error instanceof contracts_1.ZLinkFrameworkException &&
         (0, framework_errors_internal_1.internalFrameworkErrorKind)(error) === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded);

package/dist/runtime/channels/channel-receive-loops.d.ts

@@ -25,13 +25,13 @@ interface ZLinkChannelRequestDispatchLoop {
         readonly send?: () => ZLinkMultipartOperation<ZLinkMultipartAsyncSubmitOperation>;
     }, router: ZLinkBackendRouterSocket & {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader): Promise<boolean | void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, receivedAt?: Date): Promise<boolean | void>;
 }
 interface ZLinkChannelPublishDispatchLoop {
     dispatch(topicMessage: {
         readonly topic: string;
         readonly parts: readonly Message[];
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader): Promise<void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, receivedAt?: Date): Promise<void>;
 }
 interface ZLinkSubscriberInfrastructureResult {
     readonly consumed: boolean;
@@ -54,7 +54,7 @@ interface ZLinkRoutePacketDispatchLoop {
         readonly replyToken: unknown | null;
     }, router: {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, infrastructureChecked?: boolean): Promise<boolean | void>;
+    }, signal?: AbortSignal, decodedHeader?: ZLinkChannelEnvelopeHeader, infrastructureChecked?: boolean, receivedAt?: Date): Promise<boolean | void>;
 }
 interface ZLinkChannelInfrastructureHandler {
     (received: {
@@ -87,6 +87,7 @@ export declare class ZLinkChannelReceiveLoop {
     private readonly applicationJobQueue;
     private readonly roundRobin?;
     private readonly applicationDispatchQueue;
+    private readonly receivedAtClock;
     private stoppedFlag;
     private isStopped;
     private running?;
@@ -96,11 +97,10 @@ export declare class ZLinkChannelReceiveLoop {
     private readonly capacityStop;
     constructor(channelName: string, router: ZLinkBackendRouterSocket & {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, dispatcher: ZLinkChannelRequestDispatchLoop, spotRouteBridge: ZLinkBackendSpotRouteBridge | undefined, infrastructureHandler: ZLinkChannelInfrastructureHandler | undefined, poller: ZLinkBackendReadablePoller, applicationJobQueue: ApplicationJobQueue, reportError?: ZLinkReceiveTaskErrorReporter, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, applicationDispatchQueue?: ZLinkSerialExecutionQueue);
+    }, dispatcher: ZLinkChannelRequestDispatchLoop, spotRouteBridge: ZLinkBackendSpotRouteBridge | undefined, infrastructureHandler: ZLinkChannelInfrastructureHandler | undefined, poller: ZLinkBackendReadablePoller, applicationJobQueue: ApplicationJobQueue, reportError?: ZLinkReceiveTaskErrorReporter, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, applicationDispatchQueue?: ZLinkSerialExecutionQueue, receivedAtClock?: () => Date);
     run(signal?: AbortSignal): Promise<void>;
     private runLoop;
     stop(): Promise<void>;
-    private acquirePermit;
     private dispatchAndClose;
     private classify;
 }
@@ -112,6 +112,7 @@ export declare class ZLinkSubscriberReceiveLoop {
     private readonly infrastructureHandler?;
     private readonly roundRobin?;
     private readonly applicationDispatchQueue;
+    private readonly receivedAtClock;
     private stoppedFlag;
     private isStopped;
     private running?;
@@ -119,7 +120,7 @@ export declare class ZLinkSubscriberReceiveLoop {
     private readonly receiveOwner;
     private readonly rawReceiveReservations;
     private readonly capacityStop;
-    constructor(adapter: ZLinkChannelBackendAdapter, subscriber: ZLinkBackendSubscriberSocket, dispatcher: ZLinkChannelPublishDispatchLoop, applicationJobQueue: ApplicationJobQueue, infrastructureHandler?: ((topicMessage: ReturnType<ZLinkChannelBackendAdapter["createTopicMessage"]>) => boolean | ZLinkSubscriberInfrastructureResult) | undefined, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, reportError?: ZLinkReceiveTaskErrorReporter, applicationDispatchQueue?: ZLinkSerialExecutionQueue);
+    constructor(adapter: ZLinkChannelBackendAdapter, subscriber: ZLinkBackendSubscriberSocket, dispatcher: ZLinkChannelPublishDispatchLoop, applicationJobQueue: ApplicationJobQueue, infrastructureHandler?: ((topicMessage: ReturnType<ZLinkChannelBackendAdapter["createTopicMessage"]>) => boolean | ZLinkSubscriberInfrastructureResult) | undefined, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, reportError?: ZLinkReceiveTaskErrorReporter, applicationDispatchQueue?: ZLinkSerialExecutionQueue, receivedAtClock?: () => Date);
     private readonly poller;
     run(signal?: AbortSignal): Promise<void>;
     private runLoop;
@@ -135,6 +136,7 @@ export declare class ZLinkRouteReceiveLoop {
     private readonly applicationJobQueue;
     private readonly roundRobin?;
     private readonly applicationDispatchQueue;
+    private readonly receivedAtClock;
     private stoppedFlag;
     private isStopped;
     private running?;
@@ -144,7 +146,7 @@ export declare class ZLinkRouteReceiveLoop {
     private readonly capacityStop;
     constructor(router: ZLinkBackendRouterSocket & {
         reply(routingId: unknown, replyToken: unknown): ZLinkMultipartReplyOperation;
-    }, dispatcher: ZLinkRoutePacketDispatchLoop, poller: ZLinkBackendReadablePoller, applicationJobQueue: ApplicationJobQueue, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, reportError?: ZLinkReceiveTaskErrorReporter, applicationDispatchQueue?: ZLinkSerialExecutionQueue);
+    }, dispatcher: ZLinkRoutePacketDispatchLoop, poller: ZLinkBackendReadablePoller, applicationJobQueue: ApplicationJobQueue, roundRobin?: ZLinkReceiveRoundRobinCoordinator | undefined, reportError?: ZLinkReceiveTaskErrorReporter, applicationDispatchQueue?: ZLinkSerialExecutionQueue, receivedAtClock?: () => Date);
     run(signal?: AbortSignal): Promise<void>;
     private runLoop;
     stop(): Promise<void>;