@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/backend/mesh-dispatch-pump.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkMeshDispatchPump = void 0;
 const node_async_hooks_1 = require("node:async_hooks");
+const abort_1 = require("../abort");
 const node_os_1 = require("node:os");
 const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
 const execution_1 = require("../execution");
@@ -33,6 +34,10 @@ class ZLinkMeshDispatchPump {
     capacityStop = new AbortController();
     recordsSinceYield = 0;
     yieldStartedAtMs = 0;
+    /** Drains in progress; the batch budget begins when work starts on an idle pump. */
+    draining = 0;
+    /** The macrotask boundary every drain waits for once the shared budget is spent. */
+    pendingYield;
     constructor(node, options) {
         this.node = node;
         this.options = options;
@@ -48,7 +53,7 @@ class ZLinkMeshDispatchPump {
             return domains;
         });
     }
-    async dispose() {
+    async dispose(signal) {
         if (this.disposed) {
             return;
         }
@@ -59,7 +64,7 @@ class ZLinkMeshDispatchPump {
             wake();
         this.idleApplicationWorkers.clear();
         while (this.activeDrains.size > 0) {
-            await Promise.all([...this.activeDrains]);
+            await (0, abort_1.awaitWithAbort)(Promise.all([...this.activeDrains]), signal);
         }
     }
     markReady(domains) {
@@ -116,14 +121,37 @@ class ZLinkMeshDispatchPump {
         try {
             for (;;) {
                 await this.waitForApplicationReady();
-                if (this.disposed)
-                    return;
+                this.beginDrain();
                 try {
-                    await this.drainDomain(service_runtime_contracts_1.ReadyDomain.Application, readyBatch, receiveBatch);
+                    while (!this.disposed) {
+                        readyBatch.reset();
+                        const drained = this.node.drainReady(service_runtime_contracts_1.ReadyDomain.Application, readyBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
+                        if (!drained.ok || drained.records.length === 0)
+                            break;
+                        if (drained.hasResidue)
+                            this.markReady(service_runtime_contracts_1.ReadyDomain.Application);
+                        for (let index = 0; index < drained.records.length; index += 1) {
+                            const claim = readyBatch.takeClaim(index);
+                            // Raw ingress already attached one host permit to each record.
+                            // A claim reserving admission may receive only that permit's record.
+                            await this.drainClaim(service_runtime_contracts_1.ReadyDomain.Application, drained.records[index], claim, receiveBatch);
+                        }
+                        // Empty ready claims count toward the shared pump budget too.
+                        this.recordsSinceYield += 1;
+                        const yieldTurn = this.yieldIfNeeded();
+                        if (yieldTurn !== undefined)
+                            await yieldTurn;
+                    }
                 }
                 catch (error) {
                     this.reportDispatchError(error);
                 }
+                finally {
+                    readyBatch.reset();
+                    this.draining -= 1;
+                }
+                if (this.disposed)
+                    return;
             }
         }
         finally {
@@ -140,6 +168,51 @@ class ZLinkMeshDispatchPump {
         }
         return new Promise((resolve) => this.idleApplicationWorkers.add(resolve));
     }
+    /**
+     * Starts one record in this worker's turn; a permit's scope covers the
+     * synchronous dispatch. Returns `false` when the dispatch threw (already
+     * reported), `true` when it returned synchronously, or the handler's pending
+     * completion, which the draining turn awaits itself before
+     * {@link finishRecord}.
+     */
+    dispatchRecord(owner, record, permit) {
+        const previous = permit === undefined ? undefined : (0, application_job_queue_scope_1.enterApplicationJobPermitScope)(permit);
+        let result;
+        try {
+            result = this.options.dispatch(owner, record);
+        }
+        catch (error) {
+            this.failRecord(error, record, permit);
+            return false;
+        }
+        finally {
+            if (permit !== undefined)
+                (0, application_job_queue_scope_1.leaveApplicationJobPermitScope)(previous);
+        }
+        return result ?? true;
+    }
+    failRecord(error, record, permit) {
+        (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
+        this.reportDispatchError(error, meshDispatchFailureContext(record));
+    }
+    /** Runs the record's terminal completion, then releases its permit turn. */
+    finishRecord(record, permit) {
+        let result = undefined;
+        try {
+            result = record.onTerminalCompletion?.();
+        }
+        catch (error) {
+            this.reportDispatchError(error, meshDispatchFailureContext(record));
+        }
+        if (result === undefined) {
+            (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
+            return;
+        }
+        return Promise.resolve(result).then(() => (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit), (error) => {
+            this.reportDispatchError(error, meshDispatchFailureContext(record));
+            (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
+        });
+    }
     reportDispatchError(error, context) {
         this.options.reportError?.(error, context);
     }
@@ -178,7 +251,7 @@ class ZLinkMeshDispatchPump {
                 if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) !== 0) {
                     setImmediate(() => this.wakeApplicationWorker());
                 }
-                const lifecycleBudgetExhausted = await this.drainDomain(service_runtime_contracts_1.ReadyDomain.Infrastructure, readyBatch, undefined, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET);
+                const lifecycleBudgetExhausted = await this.drainDomain(readyBatch);
                 if (lifecycleBudgetExhausted) {
                     this.pendingDomains |= service_runtime_contracts_1.ReadyDomain.Infrastructure;
                     await yieldToEventLoop();
@@ -189,116 +262,34 @@ class ZLinkMeshDispatchPump {
             readyBatch.close();
         }
     }
-    async drainDomain(domain, readyBatch, receiveBatch, claimBudget) {
+    async drainDomain(readyBatch) {
         let claimsDrained = 0;
+        this.beginDrain();
         try {
             while (!this.disposed) {
-                if (claimBudget !== undefined && claimsDrained >= claimBudget) {
+                if (claimsDrained >= MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET) {
                     // Lifecycle work has priority, but a bounded turn lets application
                     // work make progress when lifecycle records keep arriving.
                     return true;
                 }
                 readyBatch.reset();
-                const drained = this.node.drainReady(domain, readyBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
+                const drained = this.node.drainReady(service_runtime_contracts_1.ReadyDomain.Infrastructure, readyBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
                 if (!drained.ok || drained.records.length === 0) {
                     return false;
                 }
-                if (domain === service_runtime_contracts_1.ReadyDomain.Application && drained.hasResidue) {
-                    this.markReady(service_runtime_contracts_1.ReadyDomain.Application);
-                }
                 for (let index = 0; index < drained.records.length; index += 1) {
                     const claim = readyBatch.takeClaim(index);
                     claimsDrained += 1;
                     const owner = drained.records[index];
-                    // Raw ingress already attached one host permit to each record.
-                    // A claim that reserves admission here may receive only that permit's record.
-                    const drainClaim = async () => {
-                        let ownerReceiveBatch = receiveBatch;
-                        try {
-                            ownerReceiveBatch ??= this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY);
-                            const capacity = owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
-                            let claimPermit = owner.terminalCompletion === true ||
-                                owner.ordinaryIngressPreAdmitted === true ||
-                                domain === service_runtime_contracts_1.ReadyDomain.Infrastructure
-                                ? undefined
-                                : await this.acquirePermit();
-                            try {
-                                if (this.capacityStop.signal.aborted)
-                                    return;
-                                ownerReceiveBatch.reset(capacity);
-                                const received = claim.recvBatch(ownerReceiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
-                                if (received.ok) {
-                                    // The bounded batch stays in claim order until its records finish.
-                                    try {
-                                        for (const record of received.records) {
-                                            if (this.disposed)
-                                                break;
-                                            const permit = record.applicationJobPermit ?? claimPermit;
-                                            if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
-                                                throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
-                                            }
-                                            this.recordsSinceYield += 1;
-                                            const dispatch = async () => {
-                                                try {
-                                                    await this.options.dispatch(owner, record);
-                                                    await record.onTerminalCompletion?.();
-                                                }
-                                                catch (error) {
-                                                    this.reportDispatchError(error, meshDispatchFailureContext(record));
-                                                }
-                                            };
-                                            if (permit === undefined) {
-                                                await dispatch();
-                                            }
-                                            else {
-                                                if (domain === service_runtime_contracts_1.ReadyDomain.Application &&
-                                                    record.applicationJobPermit === undefined)
-                                                    permit.markApplicationQueued();
-                                                // The scope now owns this reservation, including failure
-                                                // and detached handler handoff. Only unused permits remain
-                                                // owned by the receive attempt's finally block.
-                                                if (permit === claimPermit)
-                                                    claimPermit = undefined;
-                                                await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, dispatch);
-                                            }
-                                        }
-                                    }
-                                    finally {
-                                        // Batch ownership includes records whose dispatch never began,
-                                        // including on failure or shutdown in the middle of the batch.
-                                        for (const record of received.records) {
-                                            for (const part of record.parts)
-                                                part.close();
-                                            record.releaseRetainedIngress?.();
-                                        }
-                                    }
-                                }
-                            }
-                            finally {
-                                claimPermit?.releaseAfterInternalProcessing();
-                            }
-                        }
-                        finally {
-                            claim.release();
-                            if (receiveBatch === undefined)
-                                ownerReceiveBatch?.close();
-                        }
-                        const yieldTurn = this.yieldIfNeeded();
-                        if (yieldTurn !== undefined)
-                            await yieldTurn;
-                    };
-                    // An application worker drains the one owner it claimed. Infrastructure owners
-                    // drain independently, so a suspended owner does not hold the other claims.
-                    if (receiveBatch !== undefined) {
-                        await drainClaim();
-                    }
-                    else {
-                        const drain = drainClaim().catch((error) => this.reportDispatchError(error));
-                        this.activeDrains.add(drain);
-                        void drain.finally(() => this.activeDrains.delete(drain));
-                    }
+                    this.beginDrain();
+                    const drain = this.drainClaim(service_runtime_contracts_1.ReadyDomain.Infrastructure, owner, claim, undefined).catch((error) => this.reportDispatchError(error));
+                    this.activeDrains.add(drain);
+                    void drain.finally(() => {
+                        this.draining -= 1;
+                        this.activeDrains.delete(drain);
+                    });
                 }
-                if (claimBudget !== undefined && claimsDrained >= claimBudget) {
+                if (claimsDrained >= MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET) {
                     this.wakeApplicationWorker();
                     return true;
                 }
@@ -313,17 +304,133 @@ class ZLinkMeshDispatchPump {
         }
         finally {
             readyBatch.reset();
+            this.draining -= 1;
+        }
+    }
+    /**
+     * Time the pump spent idle is not batch work: when work starts on an idle
+     * pump, its batch budget starts with it (spec 08 §6).
+     */
+    beginDrain() {
+        if (this.draining === 0) {
+            this.recordsSinceYield = 0;
+            this.yieldStartedAtMs = this.nowMs();
         }
+        this.draining += 1;
     }
+    /** Drains one claimed owner in this worker's turn, in claim order. */
+    async drainClaim(domain, owner, claim, receiveBatch) {
+        let ownerReceiveBatch = receiveBatch;
+        try {
+            ownerReceiveBatch ??= this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY);
+            const capacity = owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
+            let claimPermit = owner.terminalCompletion === true ||
+                owner.ordinaryIngressPreAdmitted === true ||
+                domain === service_runtime_contracts_1.ReadyDomain.Infrastructure
+                ? undefined
+                : await this.acquirePermit();
+            try {
+                if (this.capacityStop.signal.aborted)
+                    return;
+                ownerReceiveBatch.reset(capacity);
+                const received = claim.recvBatch(ownerReceiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
+                if (received.ok) {
+                    // The bounded batch stays in claim order until its records finish.
+                    try {
+                        for (const record of received.records) {
+                            if (this.disposed)
+                                break;
+                            const permit = record.applicationJobPermit ?? claimPermit;
+                            if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
+                                throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
+                            }
+                            this.recordsSinceYield += 1;
+                            if (permit !== undefined) {
+                                if (domain === service_runtime_contracts_1.ReadyDomain.Application && record.applicationJobPermit === undefined)
+                                    permit.markApplicationQueued();
+                                // The scope now owns this reservation, including failure
+                                // and detached handler handoff. Only unused permits remain
+                                // owned by the receive attempt's finally block.
+                                if (permit === claimPermit)
+                                    claimPermit = undefined;
+                            }
+                            // The record's terminal and the permit turn release follow the
+                            // handler in this turn's own continuation.
+                            if (record.prepareDispatch !== undefined) {
+                                try {
+                                    const stopSignal = this.capacityStop.signal;
+                                    const preparation = record.prepareDispatch(stopSignal);
+                                    const accepted = preparation instanceof Promise ? await preparation : preparation;
+                                    if (!accepted || stopSignal.aborted) {
+                                        (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
+                                        continue;
+                                    }
+                                }
+                                catch (error) {
+                                    this.failRecord(error, record, permit);
+                                    continue;
+                                }
+                            }
+                            const dispatched = this.dispatchRecord(owner, record, permit);
+                            if (dispatched === false)
+                                continue;
+                            if (dispatched !== true) {
+                                try {
+                                    await dispatched;
+                                }
+                                catch (error) {
+                                    this.failRecord(error, record, permit);
+                                    continue;
+                                }
+                            }
+                            const finished = this.finishRecord(record, permit);
+                            if (finished !== undefined)
+                                await finished;
+                        }
+                    }
+                    finally {
+                        // Batch ownership includes records whose dispatch never began,
+                        // including on failure or shutdown in the middle of the batch.
+                        for (const record of received.records) {
+                            for (const part of record.parts)
+                                part.close();
+                            record.releaseRetainedIngress?.();
+                        }
+                    }
+                }
+            }
+            finally {
+                claimPermit?.releaseAfterInternalProcessing();
+            }
+        }
+        finally {
+            claim.release();
+            if (receiveBatch === undefined)
+                ownerReceiveBatch?.close();
+        }
+        const yieldTurn = this.yieldIfNeeded();
+        if (yieldTurn !== undefined)
+            await yieldTurn;
+    }
+    /**
+     * The batch budget is shared by every drain of this pump, so once it is
+     * spent every drain waits for the same macrotask boundary; one drain that
+     * keeps running would otherwise hold the event loop the yield was for.
+     */
     yieldIfNeeded() {
+        if (this.pendingYield !== undefined)
+            return this.pendingYield;
         const nowMs = this.nowMs();
         if (this.recordsSinceYield < MESH_DISPATCH_YIELD_RECORDS &&
             nowMs - this.yieldStartedAtMs < MESH_DISPATCH_YIELD_INTERVAL_MS)
             return undefined;
         this.recordsSinceYield = 0;
-        return yieldToTimers().then(() => {
+        const pendingYield = yieldToTimers().then(() => {
+            this.pendingYield = undefined;
             this.yieldStartedAtMs = this.nowMs();
         });
+        this.pendingYield = pendingYield;
+        return pendingYield;
     }
     nowMs() {
         return this.options.monotonicNowMs?.() ?? performance.now();

package/dist/runtime/backend/node/node-backend-adapter-support.d.ts

@@ -40,8 +40,8 @@ export declare function submitBindingReply(operation: ZLinkBindingReplyOperation
 export declare function submitBindingAsyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): Promise<void>;
 export declare function submitBindingSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): import('../raw-binding-port').ZLinkRawSendSubmission;
 export declare function submitBindingSyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): void;
-export declare function submitBindingRequest(operation: ZLinkBindingRequestOperation, payload: unknown, timeoutMs: number | undefined, recordReceived?: () => void): Promise<readonly unknown[]>;
-export declare function bindingRequestReply(submission: import('@zlink-systems/zlink').RequestSubmission, deadlineMs: number | undefined, recordReceived?: () => void): Promise<import('@zlink-systems/zlink').Message[]>;
+export declare function submitBindingRequest(operation: ZLinkBindingRequestOperation, payload: unknown, timeoutMs: number | undefined, recordReceived?: () => void, onAdmitted?: () => void): Promise<readonly unknown[]>;
+export declare function bindingRequestReply(submission: import('@zlink-systems/zlink').RequestSubmission, deadlineMs: number | undefined, recordReceived?: () => void, onAdmitted?: () => void): Promise<import('@zlink-systems/zlink').Message[]>;
 export declare function closeBindingReply(replies: readonly import('@zlink-systems/zlink').Message[]): void;
 /**
  * Closes a binding handle once. An already closed or terminated handle counts as

package/dist/runtime/backend/node/node-backend-adapter-support.js

@@ -22,6 +22,7 @@ const submission_result_1 = require("../../messaging/submission-result");
 const node_backend_adapter_1 = require("../node-backend-adapter");
 const runtime_values_1 = require("../runtime-values");
 const nativeErrnoValues = node_os_1.constants.errno;
+const completedSend = Promise.resolve();
 exports.zlink = (0, node_backend_adapter_1.loadBinding)();
 function isBindingNotFound(error) {
     return error instanceof exports.zlink.ConnectError && error.result === exports.zlink.ConnectResult.NotFound;
@@ -75,10 +76,14 @@ function submitBindingReply(operation, payload) {
         throw translateBindingResultError(error);
     }
 }
-async function submitBindingAsyncSend(operation, payload) {
-    const submission = submitBindingSend(operation, payload);
-    if (submission.result === runtime_values_1.SubmitResult.Backpressured)
-        await submission.admitted;
+function submitBindingAsyncSend(operation, payload) {
+    try {
+        const submission = submitBindingSend(operation, payload);
+        return submission.result === runtime_values_1.SubmitResult.Backpressured ? submission.admitted : completedSend;
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
 }
 function submitBindingSend(operation, payload) {
     let submission;
@@ -103,7 +108,8 @@ function submitBindingSend(operation, payload) {
             })
         };
     }
-    return { result: runtime_values_1.SubmitResult.Ok, admitted: submission.admitted };
+    // Binding SendSubmission is the closed OK | BACKPRESSURED snapshot.
+    return submission;
 }
 function submitBindingSyncSend(operation, payload) {
     try {
@@ -120,7 +126,7 @@ function submitBindingSyncSend(operation, payload) {
         throw translateBindingResultError(error);
     }
 }
-async function submitBindingRequest(operation, payload, timeoutMs, recordReceived) {
+async function submitBindingRequest(operation, payload, timeoutMs, recordReceived, onAdmitted) {
     const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
     try {
         let current;
@@ -138,17 +144,17 @@ async function submitBindingRequest(operation, payload, timeoutMs, recordReceive
         if (timeoutMs !== undefined) {
             current = current.timeout(timeoutMs);
         }
-        return await bindingRequestReply(current.submit(), deadlineMs, recordReceived);
+        return await bindingRequestReply(current.submit(), deadlineMs, recordReceived, onAdmitted);
     }
     catch (error) {
         throw translateBindingResultError(error);
     }
 }
-async function bindingRequestReply(submission, deadlineMs, recordReceived) {
+async function bindingRequestReply(submission, deadlineMs, recordReceived, onAdmitted) {
     const reply = submission.reply;
     if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
         try {
-            const [, replies] = await (0, request_deadline_1.waitRequestReply)(Promise.all([submission.admitted, reply]), 'Request', deadlineMs);
+            const [, replies] = await (0, request_deadline_1.waitRequestReply)(Promise.all([submission.admitted.then(() => onAdmitted?.()), reply]), 'Request', deadlineMs);
             recordReceived?.();
             return replies;
         }
@@ -160,6 +166,7 @@ async function bindingRequestReply(submission, deadlineMs, recordReceived) {
             throw error;
         }
     }
+    onAdmitted?.();
     const replies = await reply;
     recordReceived?.();
     return replies;

package/dist/runtime/backend/node/node-dealer-channel-client-transport.d.ts

@@ -7,7 +7,7 @@ export declare class ZLinkDealerChannelClientTransport implements ZLinkChannelCl
     private readonly publisher?;
     constructor(dealer: DealerSocket, publisher?: PubSocket | undefined);
     send(channelName: string, packetName: string | undefined, message: Message, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
-    request<TReply>(channelName: string, packetName: string | undefined, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     tryPublish(channelName: string, topic: string, packetName: string | undefined, event: Message, metadata?: ReadonlyMap<string, string>): ZLinkSubmitResult;
     publish(channelName: string, topic: string, packetName: string | undefined, event: Message, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;
 }

package/dist/runtime/backend/node/node-dealer-channel-client-transport.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkDealerChannelClientTransport = void 0;
+const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const configuration_1 = require("../../configuration");
 const submission_result_1 = require("../../messaging/submission-result");
 const channel_envelope_1 = require("../../channels/channel-envelope");
@@ -22,12 +23,14 @@ class ZLinkDealerChannelClientTransport {
         await (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.dealer.send(), (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, undefined, undefined, undefined, true, metadata)).submit().admitted);
         return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
     }
-    async request(channelName, packetName, request, timeoutMs, signal, metadata = EMPTY_METADATA) {
+    async request(channelName, packetName, request, timeoutMs, signal, metadata = EMPTY_METADATA, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const operation = (0, flow_context_1.runWithOutboundFlow)(true, () => (0, channel_multipart_1.appendParts)(this.dealer.request(), (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, channelName, packetName, request, timeoutMs, undefined, undefined, undefined, true, metadata)));
         if (timeoutMs !== undefined)
             operation.timeout(timeoutMs);
-        const reply = await (0, channel_multipart_1.submitRequestOperation)({ submit: () => operation.submit().reply }, 'channel request');
+        const reply = await (0, channel_multipart_1.submitRequestOperation)({
+            submit: () => (0, node_backend_adapter_support_1.bindingRequestReply)(operation.submit(), timeoutMs === undefined ? undefined : performance.now() + timeoutMs, undefined, onAdmitted)
+        }, 'channel request');
         try {
             return (0, channel_envelope_1.decodeChannelReply)(reply);
         }