@zlink-systems/framework 0.30.3 → 0.32.0

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

@@ -1,7 +1,6 @@
 "use strict";
 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");
@@ -17,11 +16,6 @@ const MESH_DISPATCH_YIELD_INTERVAL_MS = 2;
 const MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET = 4;
 const MESH_DISPATCH_RECEIVE_CAPACITY = 64;
 const MESH_DISPATCH_MAX_APPLICATION_WORKERS = Math.max(2, (0, node_os_1.availableParallelism)());
-// Captured while the runtime module is loaded, before any application owner
-// exists. A ready callback may run inside a Spot turn; the shared Mesh pump
-// must enter like an independent receive-loop task, without inheriting that
-// owner's AsyncLocalStorage identity.
-const detachedMeshDispatchScope = node_async_hooks_1.AsyncLocalStorage.snapshot();
 class ZLinkMeshDispatchPump {
     node;
     options;
@@ -29,7 +23,7 @@ class ZLinkMeshDispatchPump {
     infrastructureScheduled = false;
     disposed = false;
     activeDrains = new Set();
-    idleApplicationWorkers = new Set();
+    idleApplicationWorkers = [];
     applicationWorkerCount = 0;
     capacityStop = new AbortController();
     recordsSinceYield = 0;
@@ -62,7 +56,7 @@ class ZLinkMeshDispatchPump {
         this.pendingDomains = service_runtime_contracts_1.ReadyDomain.None;
         for (const wake of this.idleApplicationWorkers)
             wake();
-        this.idleApplicationWorkers.clear();
+        this.idleApplicationWorkers.length = 0;
         while (this.activeDrains.size > 0) {
             await (0, abort_1.awaitWithAbort)(Promise.all([...this.activeDrains]), signal);
         }
@@ -83,19 +77,21 @@ class ZLinkMeshDispatchPump {
             this.scheduleInfrastructure();
         if (startApplication) {
             if ((domains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0) {
-                setImmediate(() => this.wakeApplicationWorker());
+                this.scheduleApplicationWorker();
             }
             else {
                 this.wakeApplicationWorker();
             }
         }
     }
+    scheduleApplicationWorker() {
+        setImmediate(() => this.wakeApplicationWorker());
+    }
     wakeApplicationWorker() {
         if (this.disposed || (this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) === 0)
             return;
-        const idle = this.idleApplicationWorkers.values().next().value;
+        const idle = this.idleApplicationWorkers.shift();
         if (idle !== undefined) {
-            this.idleApplicationWorkers.delete(idle);
             this.pendingDomains &= ~service_runtime_contracts_1.ReadyDomain.Application;
             idle();
             return;
@@ -107,58 +103,12 @@ class ZLinkMeshDispatchPump {
     startApplicationWorker() {
         this.applicationWorkerCount += 1;
         let worker;
-        worker = detachedMeshDispatchScope(() => (0, execution_1.runZLinkExecutionArea)('application', () => this.runApplicationWorker())).finally(() => {
+        worker = (0, execution_1.detachedMeshDispatchScope)(() => (0, execution_1.runZLinkExecutionArea)('application', () => this.runApplicationWorker())).finally(() => {
             this.applicationWorkerCount -= 1;
             this.activeDrains.delete(worker);
         });
         this.activeDrains.add(worker);
     }
-    async runApplicationWorker() {
-        // A worker claims one owner at a time so a suspended handler cannot hold
-        // unrelated owners. Each owner may supply up to 64 pre-admitted records.
-        const readyBatch = this.node.createReadyBatch(1);
-        const receiveBatch = this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY);
-        try {
-            for (;;) {
-                await this.waitForApplicationReady();
-                this.beginDrain();
-                try {
-                    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 {
-            receiveBatch.close();
-            readyBatch.close();
-        }
-    }
     waitForApplicationReady() {
         if (this.disposed)
             return Promise.resolve();
@@ -166,16 +116,38 @@ class ZLinkMeshDispatchPump {
             this.pendingDomains &= ~service_runtime_contracts_1.ReadyDomain.Application;
             return Promise.resolve();
         }
-        return new Promise((resolve) => this.idleApplicationWorkers.add(resolve));
+        return new Promise((resolve) => this.idleApplicationWorkers.push(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
+     * synchronous dispatch. Returns `false` when preparation rejects the record,
+     * shutdown starts, or dispatch throws (already reported), `true` when dispatch
+     * returns synchronously, or the pending preparation/handler completion,
+     * which the draining turn awaits itself before
      * {@link finishRecord}.
      */
     dispatchRecord(owner, record, permit) {
+        if (record.prepareDispatch === undefined)
+            return this.invokeRecord(owner, record, permit);
+        try {
+            const preparation = record.prepareDispatch(this.capacityStop.signal);
+            return preparation instanceof Promise
+                ? this.continuePreparingRecord(owner, record, permit, preparation)
+                : this.invokeRecord(owner, record, permit, preparation);
+        }
+        catch (error) {
+            this.failRecord(error, record, permit);
+            return false;
+        }
+    }
+    continuePreparingRecord(owner, record, permit, preparation) {
+        return preparation.then((accepted) => this.invokeRecord(owner, record, permit, accepted));
+    }
+    invokeRecord(owner, record, permit, accepted = true) {
+        if (!accepted || this.capacityStop.signal.aborted) {
+            (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
+            return false;
+        }
         const previous = permit === undefined ? undefined : (0, application_job_queue_scope_1.enterApplicationJobPermitScope)(permit);
         let result;
         try {
@@ -208,6 +180,9 @@ class ZLinkMeshDispatchPump {
             (0, application_job_queue_scope_1.releaseApplicationJobPermitTurn)(permit);
             return;
         }
+        return this.finishPendingRecord(result, record, permit);
+    }
+    finishPendingRecord(result, record, permit) {
         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);
@@ -229,7 +204,7 @@ class ZLinkMeshDispatchPump {
         }
         this.infrastructureScheduled = true;
         const drain = (startTurn ?? this.yieldIfNeeded() ?? Promise.resolve())
-            .then(() => detachedMeshDispatchScope(() => (0, execution_1.runZLinkExecutionArea)('infrastructure', () => this.drainInfrastructure())))
+            .then(() => (0, execution_1.detachedMeshDispatchScope)(() => (0, execution_1.runZLinkExecutionArea)('infrastructure', () => this.drainInfrastructure())))
             .catch((error) => this.reportDispatchError(error));
         this.activeDrains.add(drain);
         void drain.finally(() => {
@@ -249,7 +224,7 @@ class ZLinkMeshDispatchPump {
                 }
                 this.pendingDomains &= ~service_runtime_contracts_1.ReadyDomain.Infrastructure;
                 if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) !== 0) {
-                    setImmediate(() => this.wakeApplicationWorker());
+                    this.scheduleApplicationWorker();
                 }
                 const lifecycleBudgetExhausted = await this.drainDomain(readyBatch);
                 if (lifecycleBudgetExhausted) {
@@ -282,7 +257,7 @@ class ZLinkMeshDispatchPump {
                     claimsDrained += 1;
                     const owner = drained.records[index];
                     this.beginDrain();
-                    const drain = this.drainClaim(service_runtime_contracts_1.ReadyDomain.Infrastructure, owner, claim, undefined).catch((error) => this.reportDispatchError(error));
+                    const drain = this.drainClaim(service_runtime_contracts_1.ReadyDomain.Infrastructure, owner, claim);
                     this.activeDrains.add(drain);
                     void drain.finally(() => {
                         this.draining -= 1;
@@ -318,99 +293,217 @@ class ZLinkMeshDispatchPump {
         }
         this.draining += 1;
     }
-    /** Drains one claimed owner in this worker's turn, in claim order. */
+    /** Each worker owns claim continuations for its entire lifetime. */
+    async runApplicationWorker() {
+        const readyBatch = this.node.createReadyBatch(1);
+        const receiveBatch = this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY);
+        const claimDrain = this.createClaimDrain(receiveBatch);
+        try {
+            for (;;) {
+                // This boundary also keeps the first handler off the receive stack.
+                await this.waitForApplicationReady();
+                this.beginDrain();
+                try {
+                    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);
+                        const pending = this.dispatchClaim(service_runtime_contracts_1.ReadyDomain.Application, drained.records[0], readyBatch.takeClaim(0), claimDrain);
+                        if (pending !== undefined)
+                            await pending;
+                        // Returning a claim remains an asynchronous worker boundary without
+                        // allocating a separate async drain task for a synchronous claim.
+                        await this.yieldIfNeeded();
+                        // Empty ready claims count toward the shared pump budget too.
+                        this.recordsSinceYield += 1;
+                        const nextTurn = this.yieldIfNeeded();
+                        if (nextTurn !== undefined)
+                            await nextTurn;
+                    }
+                }
+                catch (error) {
+                    this.reportDispatchError(error);
+                }
+                finally {
+                    readyBatch.reset();
+                    this.draining -= 1;
+                }
+                if (this.disposed)
+                    return;
+            }
+        }
+        finally {
+            receiveBatch.close();
+            readyBatch.close();
+        }
+    }
     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();
+            const pending = this.dispatchClaim(domain, owner, claim, this.createClaimDrain(receiveBatch));
+            if (pending !== undefined)
+                await pending;
+            await this.yieldIfNeeded();
+        }
+        catch (error) {
+            this.reportDispatchError(error);
+        }
+    }
+    createClaimDrain(suppliedReceiveBatch) {
+        const state = {
+            suppliedReceiveBatch,
+            receiveBatch: suppliedReceiveBatch,
+            domain: service_runtime_contracts_1.ReadyDomain.None,
+            owner: undefined,
+            claim: undefined,
+            claimPermit: undefined,
+            records: undefined,
+            index: 0,
+            receive: (permit) => this.receiveClaim(state, permit),
+            dispatchRecords: () => this.dispatchClaimRecords(state),
+            finish: () => this.finishClaim(state)
+        };
+        return state;
+    }
+    /** A synchronous claim finishes without an async wrapper or a Promise. */
+    dispatchClaim(domain, owner, claim, state = this.createClaimDrain()) {
+        state.domain = domain;
+        state.owner = owner;
+        state.claim = claim;
+        state.index = 0;
+        let pending;
+        try {
+            state.receiveBatch ??= this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY);
+            pending =
+                owner.terminalCompletion === true ||
+                    owner.ordinaryIngressPreAdmitted === true ||
+                    domain === service_runtime_contracts_1.ReadyDomain.Infrastructure
+                    ? state.receive()
+                    : this.acquirePermit().then(state.receive);
+            if (pending !== undefined)
+                return pending.finally(state.finish);
+            return undefined;
+        }
+        finally {
+            if (pending === undefined)
+                state.finish();
+        }
+    }
+    receiveClaim(state, permit) {
+        state.claimPermit = permit;
+        if (this.capacityStop.signal.aborted)
+            return undefined;
+        const capacity = state.owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
+        state.receiveBatch.reset(capacity);
+        const received = state.claim.recvBatch(state.receiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
+        if (!received.ok)
+            return undefined;
+        state.records = received.records;
+        return this.dispatchClaimRecords(state);
+    }
+    dispatchClaimRecords(state) {
+        const records = state.records;
+        const owner = state.owner;
+        while (state.index < records.length && !this.disposed) {
+            const record = records[state.index++];
+            const permit = record.applicationJobPermit ?? state.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 (state.domain === service_runtime_contracts_1.ReadyDomain.Application && record.applicationJobPermit === undefined)
+                    permit.markApplicationQueued();
+                // Only reservations not transferred to a record remain claim-owned.
+                if (permit === state.claimPermit)
+                    state.claimPermit = undefined;
+            }
+            const dispatched = this.dispatchRecord(owner, record, permit);
+            if (dispatched === false) {
+                if (isNodeOrChannelRecord(record))
+                    this.releaseRecord(record);
+                continue;
+            }
+            let terminal;
+            if (dispatched === true) {
+                const finished = this.finishRecord(record, permit);
+                if (finished === undefined) {
+                    if (isNodeOrChannelRecord(record))
+                        this.releaseRecord(record);
+                    continue;
+                }
+                terminal = finished;
+            }
+            else {
+                terminal = this.continuePendingClaim(dispatched, record, permit);
+            }
+            if (isNodeOrChannelRecord(record)) {
+                // Return the receive claim for the next batch; the existing terminal observer owns record lifetime.
+                this.observeRecordTerminal(terminal, record);
+                continue;
+            }
+            return terminal.then(state.dispatchRecords);
+        }
+        return undefined;
+    }
+    observeRecordTerminal(terminal, record) {
+        const tracked = terminal.finally(() => this.releaseRecord(record));
+        this.activeDrains.add(tracked);
+        void tracked.then(() => this.activeDrains.delete(tracked), (error) => {
+            this.activeDrains.delete(tracked);
+            this.reportDispatchError(error, meshDispatchFailureContext(record));
+        });
+    }
+    continuePendingClaim(dispatched, record, permit) {
+        return Promise.resolve(dispatched).then((accepted) => {
+            if (accepted !== false)
+                return this.finishRecord(record, permit);
+        }, (error) => this.failRecord(error, record, permit));
+    }
+    releaseRecord(record) {
+        for (let index = 0; index < record.parts.length; index++)
+            record.parts[index].close();
+        record.releaseRetainedIngress?.();
+    }
+    finishClaim(state) {
+        try {
             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?.();
-                        }
+                // Ownership includes records whose dispatch never began on failure or shutdown.
+                const records = state.records;
+                if (records !== undefined) {
+                    for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+                        const record = records[recordIndex];
+                        // Started Node and Channel records are cleaned up at their own terminals.
+                        if (recordIndex < state.index && isNodeOrChannelRecord(record))
+                            continue;
+                        this.releaseRecord(record);
                     }
                 }
             }
             finally {
-                claimPermit?.releaseAfterInternalProcessing();
+                state.claimPermit?.releaseAfterInternalProcessing();
             }
         }
         finally {
-            claim.release();
-            if (receiveBatch === undefined)
-                ownerReceiveBatch?.close();
+            try {
+                state.claim.release();
+            }
+            finally {
+                try {
+                    if (state.suppliedReceiveBatch === undefined)
+                        state.receiveBatch?.close();
+                }
+                finally {
+                    // An idle worker must not retain the previous claim's payload or owner.
+                    state.records = undefined;
+                    state.owner = undefined;
+                    state.claim = undefined;
+                    state.claimPermit = undefined;
+                }
+            }
         }
-        const yieldTurn = this.yieldIfNeeded();
-        if (yieldTurn !== undefined)
-            await yieldTurn;
     }
     /**
      * The batch budget is shared by every drain of this pump, so once it is
@@ -474,3 +567,9 @@ function yieldToEventLoop() {
 function yieldToTimers() {
     return new Promise((resolve) => setTimeout(resolve, 0));
 }
+function isNodeOrChannelRecord(record) {
+    return (record.kind === service_runtime_contracts_1.ReceiveKind.NodeSend ||
+        record.kind === service_runtime_contracts_1.ReceiveKind.NodeRequest ||
+        record.kind === service_runtime_contracts_1.ReceiveKind.ChannelSend ||
+        record.kind === service_runtime_contracts_1.ReceiveKind.ChannelRequest);
+}

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

@@ -1,3 +1,4 @@
+import type { PendingOperation } from '../../foundation/operation-registry';
 export type ZLinkBindingModule = typeof import('@zlink-systems/zlink');
 export declare const zlink: ZLinkBindingModule;
 export type ZLinkBindingOperation = {
@@ -40,8 +41,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, 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 submitBindingRequest(operation: ZLinkBindingRequestOperation, payload: unknown, timeoutMs: number | undefined, recordReceived: (() => void) | undefined, onAdmitted: (() => void) | undefined, pending: PendingOperation<unknown>, receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>): void;
+export declare function bindingRequestReply(submission: import('@zlink-systems/zlink').RequestSubmission, receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>, pending: PendingOperation<unknown>, recordReceived?: () => void, onAdmitted?: () => void): void;
 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

@@ -126,8 +126,7 @@ function submitBindingSyncSend(operation, payload) {
         throw translateBindingResultError(error);
     }
 }
-async function submitBindingRequest(operation, payload, timeoutMs, recordReceived, onAdmitted) {
-    const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
+function submitBindingRequest(operation, payload, timeoutMs, recordReceived, onAdmitted, pending, receiver) {
     try {
         let current;
         if (Array.isArray(payload)) {
@@ -142,34 +141,43 @@ async function submitBindingRequest(operation, payload, timeoutMs, recordReceive
         }
         current ??= operation.message(Buffer.alloc(0));
         if (timeoutMs !== undefined) {
-            current = current.timeout(timeoutMs);
+            current = current.timeout(Math.min(timeoutMs, (0, request_deadline_1.remainingRequestTimeout)('Request', pending.deadlineMs) ?? timeoutMs));
         }
-        return await bindingRequestReply(current.submit(), deadlineMs, recordReceived, onAdmitted);
+        bindingRequestReply(current.submit(), receiver, pending, recordReceived, onAdmitted);
     }
     catch (error) {
-        throw translateBindingResultError(error);
+        receiver.operationFailed(pending.id, translateBindingResultError(error), undefined);
     }
 }
-async function bindingRequestReply(submission, deadlineMs, recordReceived, onAdmitted) {
-    const reply = submission.reply;
-    if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
+function bindingRequestReply(submission, receiver, pending, recordReceived, onAdmitted) {
+    // The physical receiver remains reachable independently of admission failure.
+    void submission.reply.then((replies) => {
         try {
-            const [, replies] = await (0, request_deadline_1.waitRequestReply)(Promise.all([submission.admitted.then(() => onAdmitted?.()), reply]), 'Request', deadlineMs);
             recordReceived?.();
-            return replies;
         }
         catch (error) {
-            void reply.then((parts) => {
-                recordReceived?.();
-                closeBindingReply(parts);
-            }, () => undefined);
-            throw error;
+            receiver.operationFailed(pending.id, error, undefined);
+        }
+        receiver.operationCompleted(pending.id, replies, undefined);
+    }, (error) => receiver.operationFailed(pending.id, translateBindingResultError(error), undefined));
+    if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
+        void submission.admitted.then(() => {
+            try {
+                onAdmitted?.();
+            }
+            catch (error) {
+                receiver.operationFailed(pending.id, error, undefined);
+            }
+        }, (error) => receiver.operationFailed(pending.id, error, undefined));
+    }
+    else {
+        try {
+            onAdmitted?.();
+        }
+        catch (error) {
+            receiver.operationFailed(pending.id, error, undefined);
         }
     }
-    onAdmitted?.();
-    const replies = await reply;
-    recordReceived?.();
-    return replies;
 }
 function closeBindingReply(replies) {
     for (const reply of replies)

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

@@ -1,3 +1,5 @@
+import { RequestRuntime } from '../../foundation/request-runtime';
+import { type ZLinkRequestResult } from '../../messaging/request-result';
 import type { DealerSocket, Message, PubSocket } from '@zlink-systems/zlink';
 import { type ZLinkSubmitResult } from '../../messaging/submission-result';
 import type { ZLinkChannelClientTransport } from '../../channels/channel-transports';
@@ -5,9 +7,10 @@ import type { ZLinkChannelClientTransport } from '../../channels/channel-transpo
 export declare class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTransport {
     private readonly dealer;
     private readonly publisher?;
-    constructor(dealer: DealerSocket, publisher?: PubSocket | undefined);
+    private readonly requests;
+    constructor(dealer: DealerSocket, publisher?: PubSocket | undefined, requests?: RequestRuntime);
     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>, onAdmitted?: () => void): Promise<TReply>;
+    request<TReply>(channelName: string, packetName: string | undefined, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): ZLinkRequestResult<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>;
 }