@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/backend/mesh-dispatch-pump.ts

@@ -1,4 +1,3 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { awaitWithAbort } from '../abort';
 import { availableParallelism } from 'node:os';
 import {
@@ -10,9 +9,10 @@ import type {
   ApplicationJobPermitPort,
   ApplicationJobQueuePort
 } from '../application-jobs/contracts';
-import { runZLinkExecutionArea } from '../execution';
+import { detachedMeshDispatchScope, runZLinkExecutionArea } from '../execution';
 import {
   ReadyDomain,
+  ReceiveKind,
   type Claim,
   type ReadyBatch,
   type ReadyRecord,
@@ -39,15 +39,9 @@ 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, 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 = AsyncLocalStorage.snapshot();
 
 export interface ZLinkMeshDispatchPumpOptions {
   readonly readyCapacity?: number;
-  readonly messageCapacity?: number;
   readonly partCapacity?: number;
   readonly dispatch: (owner: ReadyRecord, record: ReceiveRecord) => void | Promise<void>;
   readonly applicationJobQueue: ApplicationJobQueuePort;
@@ -63,12 +57,26 @@ export interface ZLinkMeshDispatchFailureContext {
   readonly commandId?: number;
 }
 
+interface MeshClaimDrainState {
+  readonly suppliedReceiveBatch: ReceiveBatch | undefined;
+  receiveBatch: ReceiveBatch | undefined;
+  domain: number;
+  owner: ReadyRecord | undefined;
+  claim: Claim | undefined;
+  claimPermit: ApplicationJobPermitPort | undefined;
+  records: readonly ReceiveRecord[] | undefined;
+  index: number;
+  readonly receive: (permit?: ApplicationJobPermitPort) => Promise<void> | undefined;
+  readonly dispatchRecords: () => Promise<void> | undefined;
+  readonly finish: () => void;
+}
+
 export class ZLinkMeshDispatchPump {
   private pendingDomains: number = ReadyDomain.None;
   private infrastructureScheduled = false;
   private disposed = false;
   private readonly activeDrains = new Set<Promise<void>>();
-  private readonly idleApplicationWorkers = new Set<() => void>();
+  private readonly idleApplicationWorkers: Array<() => void> = [];
   private applicationWorkerCount = 0;
   private readonly capacityStop = new AbortController();
   private recordsSinceYield = 0;
@@ -102,7 +110,7 @@ export class ZLinkMeshDispatchPump {
     this.capacityStop.abort();
     this.pendingDomains = ReadyDomain.None;
     for (const wake of this.idleApplicationWorkers) wake();
-    this.idleApplicationWorkers.clear();
+    this.idleApplicationWorkers.length = 0;
     while (this.activeDrains.size > 0) {
       await awaitWithAbort(Promise.all([...this.activeDrains]), signal);
     }
@@ -124,18 +132,21 @@ export class ZLinkMeshDispatchPump {
     if (startInfrastructure) this.scheduleInfrastructure();
     if (startApplication) {
       if ((domains & ReadyDomain.Infrastructure) !== 0) {
-        setImmediate(() => this.wakeApplicationWorker());
+        this.scheduleApplicationWorker();
       } else {
         this.wakeApplicationWorker();
       }
     }
   }
 
+  private scheduleApplicationWorker(): void {
+    setImmediate(() => this.wakeApplicationWorker());
+  }
+
   private wakeApplicationWorker(): void {
     if (this.disposed || (this.pendingDomains & ReadyDomain.Application) === 0) return;
-    const idle = this.idleApplicationWorkers.values().next().value as (() => void) | undefined;
+    const idle = this.idleApplicationWorkers.shift();
     if (idle !== undefined) {
-      this.idleApplicationWorkers.delete(idle);
       this.pendingDomains &= ~ReadyDomain.Application;
       idle();
       return;
@@ -157,79 +168,61 @@ export class ZLinkMeshDispatchPump {
     this.activeDrains.add(worker);
   }
 
-  private async runApplicationWorker(): Promise<void> {
-    // 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(
-              ReadyDomain.Application,
-              readyBatch,
-              ZLINK_BACKEND_RECV_DONT_WAIT
-            );
-            if (!drained.ok || drained.records.length === 0) break;
-            if (drained.hasResidue) this.markReady(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(
-                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();
-    }
-  }
-
   private waitForApplicationReady(): Promise<void> {
     if (this.disposed) return Promise.resolve();
     if ((this.pendingDomains & ReadyDomain.Application) !== 0) {
       this.pendingDomains &= ~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}.
    */
   private dispatchRecord(
     owner: ReadyRecord,
     record: ReceiveRecord,
     permit: ApplicationJobPermitPort | undefined
+  ): boolean | PromiseLike<void | boolean> {
+    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;
+    }
+  }
+
+  private continuePreparingRecord(
+    owner: ReadyRecord,
+    record: ReceiveRecord,
+    permit: ApplicationJobPermitPort | undefined,
+    preparation: Promise<boolean>
+  ): Promise<void | boolean> {
+    return preparation.then<void | boolean>((accepted) =>
+      this.invokeRecord(owner, record, permit, accepted)
+    );
+  }
+
+  private invokeRecord(
+    owner: ReadyRecord,
+    record: ReceiveRecord,
+    permit: ApplicationJobPermitPort | undefined,
+    accepted = true
   ): boolean | PromiseLike<void> {
+    if (!accepted || this.capacityStop.signal.aborted) {
+      releaseApplicationJobPermitTurn(permit);
+      return false;
+    }
     const previous = permit === undefined ? undefined : enterApplicationJobPermitScope(permit);
     let result: void | PromiseLike<void>;
     try {
@@ -267,6 +260,14 @@ export class ZLinkMeshDispatchPump {
       releaseApplicationJobPermitTurn(permit);
       return;
     }
+    return this.finishPendingRecord(result, record, permit);
+  }
+
+  private finishPendingRecord(
+    result: Promise<void>,
+    record: ReceiveRecord,
+    permit: ApplicationJobPermitPort | undefined
+  ): Promise<void> {
     return Promise.resolve(result).then(
       () => releaseApplicationJobPermitTurn(permit),
       (error) => {
@@ -323,7 +324,7 @@ export class ZLinkMeshDispatchPump {
         }
         this.pendingDomains &= ~ReadyDomain.Infrastructure;
         if ((this.pendingDomains & ReadyDomain.Application) !== 0) {
-          setImmediate(() => this.wakeApplicationWorker());
+          this.scheduleApplicationWorker();
         }
         const lifecycleBudgetExhausted = await this.drainDomain(readyBatch);
         if (lifecycleBudgetExhausted) {
@@ -360,9 +361,7 @@ export class ZLinkMeshDispatchPump {
           claimsDrained += 1;
           const owner = drained.records[index]!;
           this.beginDrain();
-          const drain = this.drainClaim(ReadyDomain.Infrastructure, owner, claim, undefined).catch(
-            (error) => this.reportDispatchError(error)
-          );
+          const drain = this.drainClaim(ReadyDomain.Infrastructure, owner, claim);
           this.activeDrains.add(drain);
           void drain.finally(() => {
             this.draining -= 1;
@@ -398,98 +397,238 @@ export 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. */
+  private async runApplicationWorker(): Promise<void> {
+    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(
+              ReadyDomain.Application,
+              readyBatch,
+              ZLINK_BACKEND_RECV_DONT_WAIT
+            );
+            if (!drained.ok || drained.records.length === 0) break;
+            if (drained.hasResidue) this.markReady(ReadyDomain.Application);
+            const pending = this.dispatchClaim(
+              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();
+    }
+  }
+
   private async drainClaim(
     domain: number,
     owner: ReadyRecord,
     claim: Claim,
-    receiveBatch: ReceiveBatch | undefined
+    receiveBatch?: ReceiveBatch
   ): Promise<void> {
-    let ownerReceiveBatch = receiveBatch;
     try {
-      ownerReceiveBatch ??= this.node.createReceiveBatch(
+      const pending = this.dispatchClaim(domain, owner, claim, this.createClaimDrain(receiveBatch));
+      if (pending !== undefined) await pending;
+      await this.yieldIfNeeded();
+    } catch (error) {
+      this.reportDispatchError(error);
+    }
+  }
+
+  private createClaimDrain(suppliedReceiveBatch?: ReceiveBatch): MeshClaimDrainState {
+    const state: MeshClaimDrainState = {
+      suppliedReceiveBatch,
+      receiveBatch: suppliedReceiveBatch,
+      domain: 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. */
+  private dispatchClaim(
+    domain: number,
+    owner: ReadyRecord,
+    claim: Claim,
+    state: MeshClaimDrainState = this.createClaimDrain()
+  ): Promise<void> | undefined {
+    state.domain = domain;
+    state.owner = owner;
+    state.claim = claim;
+    state.index = 0;
+    let pending: Promise<void> | undefined;
+    try {
+      state.receiveBatch ??= 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 =
+      pending =
         owner.terminalCompletion === true ||
         owner.ordinaryIngressPreAdmitted === true ||
         domain === ReadyDomain.Infrastructure
-          ? undefined
-          : await this.acquirePermit();
+          ? state.receive()
+          : this.acquirePermit().then(state.receive);
+      if (pending !== undefined) return pending.finally(state.finish);
+      return undefined;
+    } finally {
+      if (pending === undefined) state.finish();
+    }
+  }
+
+  private receiveClaim(
+    state: MeshClaimDrainState,
+    permit?: ApplicationJobPermitPort
+  ): Promise<void> | undefined {
+    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!, ZLINK_BACKEND_RECV_DONT_WAIT);
+    if (!received.ok) return undefined;
+    state.records = received.records;
+    return this.dispatchClaimRecords(state);
+  }
+
+  private dispatchClaimRecords(state: MeshClaimDrainState): Promise<void> | undefined {
+    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 === 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: Promise<void>;
+      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;
+  }
+
+  private observeRecordTerminal(terminal: Promise<void>, record: ReceiveRecord): void {
+    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));
+      }
+    );
+  }
+
+  private continuePendingClaim(
+    dispatched: PromiseLike<void | boolean>,
+    record: ReceiveRecord,
+    permit: ApplicationJobPermitPort | undefined
+  ): Promise<void> {
+    return Promise.resolve(dispatched).then(
+      (accepted) => {
+        if (accepted !== false) return this.finishRecord(record, permit);
+      },
+      (error) => this.failRecord(error, record, permit)
+    );
+  }
+
+  private releaseRecord(record: ReceiveRecord): void {
+    for (let index = 0; index < record.parts.length; index++) record.parts[index]!.close();
+    record.releaseRetainedIngress?.();
+  }
+
+  private finishClaim(state: MeshClaimDrainState): void {
+    try {
       try {
-        if (this.capacityStop.signal.aborted) return;
-        ownerReceiveBatch.reset(capacity);
-        const received = claim.recvBatch(ownerReceiveBatch, 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 === 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) {
-                    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;
   }
 
   /**
@@ -557,3 +696,12 @@ function yieldToEventLoop(): Promise<void> {
 function yieldToTimers(): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
+
+function isNodeOrChannelRecord(record: ReceiveRecord): boolean {
+  return (
+    record.kind === ReceiveKind.NodeSend ||
+    record.kind === ReceiveKind.NodeRequest ||
+    record.kind === ReceiveKind.ChannelSend ||
+    record.kind === ReceiveKind.ChannelRequest
+  );
+}

package/src/runtime/backend/node/node-backend-adapter-support.ts

@@ -1,5 +1,6 @@
 import { constants as osConstants } from 'node:os';
-import { waitRequestReply } from '../../messaging/request-deadline';
+import type { PendingOperation } from '../../foundation/operation-registry';
+import { remainingRequestTimeout } from '../../messaging/request-deadline';
 import {
   requireClassicFanoutCompletion,
   ZLinkSubmitStatus
@@ -179,14 +180,15 @@ export function submitBindingSyncSend(
   }
 }
 
-export async function submitBindingRequest(
+export function submitBindingRequest(
   operation: ZLinkBindingRequestOperation,
   payload: unknown,
   timeoutMs: number | undefined,
-  recordReceived?: () => void,
-  onAdmitted?: () => void
-): Promise<readonly unknown[]> {
-  const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
+  recordReceived: (() => void) | undefined,
+  onAdmitted: (() => void) | undefined,
+  pending: PendingOperation<unknown>,
+  receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>
+): void {
   try {
     let current: ZLinkBindingRequestSubmitOperation | undefined;
     if (Array.isArray(payload)) {
@@ -200,45 +202,53 @@ export async function submitBindingRequest(
     }
     current ??= operation.message(Buffer.alloc(0));
     if (timeoutMs !== undefined) {
-      current = current.timeout(timeoutMs);
+      current = current.timeout(
+        Math.min(timeoutMs, 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);
   }
 }
 
-export async function bindingRequestReply(
+export function bindingRequestReply(
   submission: import('@zlink-systems/zlink').RequestSubmission,
-  deadlineMs: number | undefined,
+  receiver: import('../../foundation/operation-registry').OperationObserver<unknown, unknown>,
+  pending: PendingOperation<unknown>,
   recordReceived?: () => void,
   onAdmitted?: () => void
-): Promise<import('@zlink-systems/zlink').Message[]> {
-  const reply = submission.reply;
+): void {
+  // The physical receiver remains reachable independently of admission failure.
+  void submission.reply.then(
+    (replies) => {
+      try {
+        recordReceived?.();
+      } catch (error) {
+        receiver.operationFailed(pending.id, error, undefined);
+      }
+      receiver.operationCompleted(pending.id, replies, undefined);
+    },
+    (error) => receiver.operationFailed(pending.id, translateBindingResultError(error), undefined)
+  );
   if (submission.result === 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 {
-      const [, replies] = await waitRequestReply(
-        Promise.all([submission.admitted.then(() => onAdmitted?.()), reply]),
-        'Request',
-        deadlineMs
-      );
-      recordReceived?.();
-      return replies;
+      onAdmitted?.();
     } catch (error) {
-      void reply.then(
-        (parts) => {
-          recordReceived?.();
-          closeBindingReply(parts);
-        },
-        () => undefined
-      );
-      throw error;
+      receiver.operationFailed(pending.id, error, undefined);
     }
   }
-  onAdmitted?.();
-  const replies = await reply;
-  recordReceived?.();
-  return replies;
 }
 
 export function closeBindingReply(