@zlink-systems/framework 0.26.0 → 0.28.0

package/src/runtime/backend/contracts/index.ts

@@ -141,14 +141,16 @@ export interface ZLinkBackendMeshNode {
     route: ServiceInstanceRouteFence,
     parts: MessageLike | readonly MessageLike[],
     sourceSpotId?: string,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    instanceIntent?: boolean
   ): Promise<SubmitResult>;
   requestInstanceSpot(
     route: ServiceInstanceRouteFence,
     parts: MessageLike | readonly MessageLike[],
     timeoutMs?: number,
     sourceSpotId?: string,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    instanceIntent?: boolean
   ): MeshOperationId;
   registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
   requestUserSpotCreate(
@@ -249,6 +251,12 @@ export interface ZLinkBackendMeshNode {
         readonly objectGeneration: bigint;
       }
     | undefined;
+  registerInstanceIntent?(
+    instanceType: string,
+    route: import('../../foundation/service-stateful-wire-codec').ServiceInstanceRouteFence,
+    expectedCurrentRoute?:
+      import('../../foundation/service-stateful-wire-codec').ServiceInstanceRouteFence | null
+  ): void;
   waitForInstanceApplicationQuiescence?(spotId: string, signal?: AbortSignal): Promise<void>;
   restoreUserSpotAuthority?(
     spotId: string,
@@ -269,7 +277,7 @@ export interface ZLinkBackendMeshNode {
     stableType: string,
     generation: bigint,
     authorityOwnerGeneration: bigint,
-    spotId: string,
+    spotId: string | undefined,
     spotGeneration: bigint,
     membershipEpoch: bigint
   ): ZLinkBackendActorRef;
@@ -435,27 +443,6 @@ export interface ZLinkBackendActorRecvInfo {
   readonly flags: number;
 }
 
-export interface ZLinkBackendActorJoinInfo {
-  readonly sourceActor: ZLinkBackendActorRef;
-  readonly targetActor: ZLinkBackendActorRef;
-  readonly sourceNodeRid: RoutingId;
-  readonly sourceSpotId: RoutingId;
-  readonly targetNodeRid: RoutingId;
-  readonly targetSpotId: RoutingId;
-  readonly joinEpoch: bigint;
-  readonly flags: number;
-}
-
-export interface ZLinkBackendActorJoinRequest {
-  readonly info: ZLinkBackendActorJoinInfo;
-  readonly message: Message;
-}
-
-export interface ZLinkBackendActorJoinReplyOperation {
-  message(message: Message): ZLinkBackendActorJoinReplyOperation;
-  submit(): void;
-}
-
 export interface ZLinkBackendSpotDispatchInfo {
   readonly event: ZLinkBackendSpotDispatchEvent;
   readonly subjectKind?: number;
@@ -465,6 +452,7 @@ export interface ZLinkBackendSpotDispatchInfo {
 
 export interface ZLinkBackendSocketMonitorEvent {
   readonly nativeEvent: MonitorEventType;
+  readonly readyEdge: boolean;
   readonly routingId?: unknown;
   readonly localAddr: string;
   readonly remoteAddr: string;
@@ -504,7 +492,6 @@ export interface ZLinkBackendDealerSocket extends ZLinkBackendConnectableSocket
   sendHighWaterMark: number;
   receiveHighWaterMark: number;
   receiveTimeoutMs: number;
-  sendTimeoutMs: number;
   maxMessageSize: number;
   send(message: Message | readonly Message[]): Promise<void>;
   request(message: Message | readonly Message[], timeoutMs?: number): Promise<readonly Message[]>;
@@ -535,7 +522,6 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
   sendHighWaterMark: number;
   receiveHighWaterMark: number;
   receiveTimeoutMs: number;
-  sendTimeoutMs: number;
   maxMessageSize: number;
   setRoutingId(routingId: RoutingId): void;
   recv(flags?: ZLinkBackendRecvFlags): Received | undefined;
@@ -563,6 +549,7 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
 }
 
 export interface ZLinkBackendPublisherSocket extends ZLinkBackendSocket {
+  sendTimeoutMs: number;
   sendHighWaterMark: number;
   noDrop: boolean;
   publish(topic: string, message: Message | readonly Message[]): void;
@@ -588,7 +575,6 @@ export interface ZLinkBackendStreamPacket {
 }
 
 export interface ZLinkBackendStreamSocket extends ZLinkBackendSocket {
-  readonly sendTimeoutMs: number;
   readonly sendHighWaterMark: number;
   /** Framework stream ingress uses this bound for packet payload validation. */
   maxMessageSize: number;
@@ -599,11 +585,7 @@ export interface ZLinkBackendStreamSocket extends ZLinkBackendSocket {
     payload: Message | readonly Message[],
     flags: ZLinkBackendSendFlags
   ): boolean;
-  submit(
-    routingId: RoutingId,
-    payload: Message | readonly Message[],
-    timeoutMs?: number
-  ): Promise<void>;
+  submit(routingId: RoutingId, payload: Message | readonly Message[]): Promise<void>;
   disconnectPeer(routingId: RoutingId): void;
   bindActor(
     sessionRid: RoutingId,
@@ -734,11 +716,6 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     payload: Message | readonly Message[],
     timeoutMs?: number
   ): Promise<readonly Message[]>;
-  recvActorJoin(flags: ZLinkBackendRecvFlags): ZLinkBackendActorJoinRequest | null;
-  replyActorJoin(
-    request: ZLinkBackendActorJoinRequest,
-    joinResultCode: number
-  ): ZLinkBackendActorJoinReplyOperation;
   dispose(): Promise<void>;
 }
 

package/src/runtime/backend/mesh-actor-session-node-adapter.ts

@@ -1,5 +1,4 @@
-import { SubmitResult } from './runtime-values';
-import { ZLinkSubmitStatus } from '../messaging/submission-result';
+import { classifySubmitResult } from '../messaging/submission-result';
 import type { ZLinkBackendActorSessionNode, ZLinkBackendMeshNode } from './contracts';
 import { closeMeshCompletion, type ZLinkMeshCompletionTable } from './mesh-completion-table';
 
@@ -15,22 +14,7 @@ export function meshActorSessionNodeAdapter(
         parts as never,
         flags
       );
-      switch (result) {
-        case SubmitResult.Ok:
-          return { status: ZLinkSubmitStatus.Submitted };
-        case SubmitResult.Backpressured:
-        case SubmitResult.NotAdmitted:
-          return { status: ZLinkSubmitStatus.Backpressured };
-        case SubmitResult.NotFound:
-        case SubmitResult.InvalidState:
-          return { status: ZLinkSubmitStatus.TargetNotFound };
-        case SubmitResult.NotConnected:
-          return { status: ZLinkSubmitStatus.RouteNotConnected };
-        case SubmitResult.Terminated:
-          return { status: ZLinkSubmitStatus.Shutdown };
-        default:
-          throw new Error(`Actor bound-session send failed with result '${result}'.`);
-      }
+      return classifySubmitResult(result, 'Actor bound-session send');
     },
     async closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs, signal) {
       if (completions === undefined) {

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

@@ -1,6 +1,11 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { availableParallelism } from 'node:os';
-import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
+import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
+import type {
+  ApplicationJobPermitPort,
+  ApplicationJobQueuePort
+} from '../application-jobs/contracts';
+import { runZLinkExecutionArea } from '../execution';
 import {
   ReadyDomain,
   type ReadyBatch,
@@ -8,13 +13,20 @@ import {
   type ReceiveBatch,
   type ReceiveRecord
 } from '../foundation/service-runtime-contracts';
+import {
+  SERVICE_WIRE_COMMAND_OFFSET,
+  SERVICE_WIRE_MAJOR_OFFSET,
+  SERVICE_WIRE_PREFIX_SIZE
+} from '../foundation/service-wire-binary-primitives';
+import {
+  SERVICE_WIRE_MAGIC,
+  SERVICE_WIRE_MAJOR
+} from '../foundation/service-wire-constants.generated';
 import type { ZLinkBackendMeshNode } from './contracts';
-import { runZLinkExecutionArea } from '../execution';
-import type {
-  ApplicationJobPermitPort,
-  ApplicationJobQueuePort
-} from '../application-jobs/contracts';
-import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
+import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
+const DEFAULT_MESH_READY_CAPACITY = 32;
+
+const DEFAULT_MESH_PART_CAPACITY = 256;
 
 const MESH_DISPATCH_YIELD_RECORDS = 16;
 const MESH_DISPATCH_YIELD_INTERVAL_MS = 2;
@@ -45,21 +57,10 @@ export interface ZLinkMeshDispatchFailureContext {
   readonly commandId?: number;
 }
 
-class ZLinkMeshDispatchFailure extends Error {
-  constructor(
-    readonly context: ZLinkMeshDispatchFailureContext,
-    readonly dispatchCause: unknown
-  ) {
-    super('Mesh record dispatch failed.', { cause: dispatchCause });
-    this.name = 'ZLinkMeshDispatchFailure';
-  }
-}
-
 export class ZLinkMeshDispatchPump {
   private pendingDomains: number = ReadyDomain.None;
   private infrastructureScheduled = false;
   private disposed = false;
-  private infrastructureDrainPromise?: Promise<void>;
   private readonly activeDrains = new Set<Promise<void>>();
   private readonly idleApplicationWorkers = new Set<() => void>();
   private applicationWorkerCount = 0;
@@ -152,7 +153,7 @@ export class ZLinkMeshDispatchPump {
     const readyBatch = this.node.createReadyBatch(1);
     const receiveBatch = this.node.createReceiveBatch(
       MESH_DISPATCH_RECEIVE_CAPACITY,
-      this.options.partCapacity ?? 256
+      this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY
     );
     try {
       for (;;) {
@@ -179,12 +180,8 @@ export class ZLinkMeshDispatchPump {
     return new Promise((resolve) => this.idleApplicationWorkers.add(resolve));
   }
 
-  private reportDispatchError(error: unknown): void {
-    if (error instanceof ZLinkMeshDispatchFailure) {
-      this.options.reportError?.(error.dispatchCause, error.context);
-      return;
-    }
-    this.options.reportError?.(error);
+  private reportDispatchError(error: unknown, context?: ZLinkMeshDispatchFailureContext): void {
+    this.options.reportError?.(error, context);
   }
 
   /**
@@ -205,34 +202,23 @@ export class ZLinkMeshDispatchPump {
           runZLinkExecutionArea('infrastructure', () => this.drainInfrastructure())
         )
       )
-      .catch((error) => {
-        if (error instanceof ZLinkMeshDispatchFailure) {
-          this.options.reportError?.(error.dispatchCause, error.context);
-          return;
-        }
-        this.options.reportError?.(error);
-      });
+      .catch((error) => this.reportDispatchError(error));
     this.activeDrains.add(drain);
-    this.infrastructureDrainPromise = drain;
     void drain.finally(() => {
       this.activeDrains.delete(drain);
-      if (this.infrastructureDrainPromise === drain) {
-        this.infrastructureDrainPromise = undefined;
-        this.infrastructureScheduled = false;
-        if (!this.disposed && (this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
-          this.scheduleInfrastructure();
-        }
+      this.infrastructureScheduled = false;
+      if (!this.disposed && (this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
+        this.scheduleInfrastructure();
       }
     });
   }
 
   private async drainInfrastructure(): Promise<void> {
     const readyBatch = this.node.createReadyBatch(
-      Math.min(this.options.readyCapacity ?? 32, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET)
-    );
-    const receiveBatch = this.node.createReceiveBatch(
-      MESH_DISPATCH_RECEIVE_CAPACITY,
-      this.options.partCapacity ?? 256
+      Math.min(
+        this.options.readyCapacity ?? DEFAULT_MESH_READY_CAPACITY,
+        MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
+      )
     );
     try {
       while (!this.disposed) {
@@ -246,7 +232,7 @@ export class ZLinkMeshDispatchPump {
         const lifecycleBudgetExhausted = await this.drainDomain(
           ReadyDomain.Infrastructure,
           readyBatch,
-          receiveBatch,
+          undefined,
           MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
         );
         if (lifecycleBudgetExhausted) {
@@ -255,7 +241,6 @@ export class ZLinkMeshDispatchPump {
         }
       }
     } finally {
-      receiveBatch.close();
       readyBatch.close();
     }
   }
@@ -263,7 +248,7 @@ export class ZLinkMeshDispatchPump {
   private async drainDomain(
     domain: number,
     readyBatch: ReadyBatch,
-    receiveBatch: ReceiveBatch,
+    receiveBatch: ReceiveBatch | undefined,
     claimBudget?: number
   ): Promise<boolean> {
     let claimsDrained = 0;
@@ -285,85 +270,91 @@ export class ZLinkMeshDispatchPump {
         for (let index = 0; index < drained.records.length; index += 1) {
           const claim = readyBatch.takeClaim(index);
           claimsDrained += 1;
-          const owner = drained.records[index];
+          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.
-          try {
-            const capacity =
-              owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
-            for (;;) {
-              let claimPermit =
-                owner.terminalCompletion === true ||
-                owner.ordinaryIngressPreAdmitted === true ||
-                domain === ReadyDomain.Infrastructure
-                  ? undefined
-                  : await this.acquirePermit();
-              try {
-                if (this.capacityStop.signal.aborted) return false;
-                receiveBatch.reset(capacity);
-                const received = claim.recvBatch(receiveBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
-                if (!received.ok) break;
-                // This owner keeps its claim while it drains. Other owners and
-                // infrastructure may progress if one of its handlers suspends.
-                if (domain === ReadyDomain.Infrastructure) {
-                  this.infrastructureScheduled = false;
-                  this.infrastructureDrainPromise = undefined;
-                  if ((this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
-                    this.scheduleInfrastructure();
-                  }
-                }
+          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;
+              for (;;) {
+                let claimPermit =
+                  owner.terminalCompletion === true ||
+                  owner.ordinaryIngressPreAdmitted === true ||
+                  domain === ReadyDomain.Infrastructure
+                    ? undefined
+                    : await this.acquirePermit();
                 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(drained.records[index], record);
-                      } catch (error) {
-                        throw new ZLinkMeshDispatchFailure(
-                          meshDispatchFailureContext(record),
-                          error
+                  if (this.capacityStop.signal.aborted) return;
+                  ownerReceiveBatch.reset(capacity);
+                  const received = claim.recvBatch(ownerReceiveBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
+                  if (!received.ok) break;
+                  // This owner keeps its claim while it drains, so its records stay in FIFO order.
+                  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.'
                         );
                       }
-                      await record.onTerminalCompletion?.();
-                    };
-                    if (permit === undefined) {
-                      await dispatch();
-                    } else {
-                      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;
-                      await runWithApplicationJobPermit(permit, dispatch);
+                      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 === 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 runWithApplicationJobPermit(permit, dispatch);
+                      }
+                      const yieldTurn = this.yieldIfNeeded();
+                      if (yieldTurn !== undefined) await yieldTurn;
+                    }
+                  } 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?.();
                     }
-                    const yieldTurn = this.yieldIfNeeded();
-                    if (yieldTurn !== undefined) await yieldTurn;
                   }
                 } 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?.();
-                  }
+                  claimPermit?.releaseAfterInternalProcessing();
                 }
-              } finally {
-                claimPermit?.releaseAfterInternalProcessing();
               }
+            } finally {
+              claim.release();
+              if (receiveBatch === undefined) ownerReceiveBatch?.close();
             }
-          } finally {
-            claim.release();
+          };
+          // 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));
           }
         }
         if (claimBudget !== undefined && claimsDrained >= claimBudget) {
@@ -425,8 +416,11 @@ function meshDispatchFailureContext(record: ReceiveRecord): ZLinkMeshDispatchFai
 function serviceWireCommand(record: ReceiveRecord): number | undefined {
   if (record.parts.length !== 1) return undefined;
   const bytes = record.parts[0]!.data();
-  return bytes.byteLength >= 5 && bytes[0] === 0x5a && bytes[1] === 0x4d && bytes[2] === 1
-    ? bytes[3]
+  return bytes.byteLength >= SERVICE_WIRE_PREFIX_SIZE &&
+    bytes[0] === SERVICE_WIRE_MAGIC[0] &&
+    bytes[1] === SERVICE_WIRE_MAGIC[1] &&
+    bytes[SERVICE_WIRE_MAJOR_OFFSET] === SERVICE_WIRE_MAJOR
+    ? bytes[SERVICE_WIRE_COMMAND_OFFSET]
     : undefined;
 }
 

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

@@ -1,6 +1,12 @@
+import { constants as osConstants } from 'node:os';
+import { waitRequestReply } from '../../messaging/request-deadline';
+import {
+  requireClassicFanoutCompletion,
+  ZLinkSubmitStatus
+} from '../../messaging/submission-result';
 import { loadBinding } from '../node-backend-adapter';
 import { SubmitResult, ZLinkBackendResultError } from '../runtime-values';
-import { requireOneWayCompletion, ZLinkSubmitStatus } from '../../messaging/submission-result';
+const nativeErrnoValues = osConstants.errno;
 
 export type ZLinkBindingModule = typeof import('@zlink-systems/zlink');
 export const zlink = loadBinding() as ZLinkBindingModule;
@@ -46,7 +52,7 @@ interface ZLinkBindingRequestSubmitOperation {
 }
 
 export function isBindingNotFound(error: unknown): boolean {
-  return error instanceof zlink.ConfigError && error.result === zlink.ConfigResult.NotFound;
+  return error instanceof zlink.ConnectError && error.result === zlink.ConnectResult.NotFound;
 }
 
 function isNonBlockingRecvEmpty(error: unknown): boolean {
@@ -64,7 +70,10 @@ export function isRouteRecvRetryable(error: unknown): boolean {
 }
 
 function isNativeBadAddress(error: { nativeErrno?: unknown; message?: unknown }): boolean {
-  return error.nativeErrno === 14 || /Bad address/i.test(String(error.message ?? ''));
+  return (
+    error.nativeErrno === nativeErrnoValues.EFAULT ||
+    /Bad address/i.test(String(error.message ?? ''))
+  );
 }
 
 export function submitBindingPublish(
@@ -87,7 +96,7 @@ export function submitBindingPublish(
       (translated.result === SubmitResult.Backpressured ||
         translated.result === SubmitResult.NotAdmitted)
     ) {
-      requireOneWayCompletion(
+      requireClassicFanoutCompletion(
         { status: ZLinkSubmitStatus.Backpressured },
         'Classic fanout publish'
       );
@@ -114,6 +123,7 @@ export async function submitBindingAsyncSend(
   operation: ZLinkBindingAsyncSendOperation,
   payload: unknown
 ): Promise<void> {
+  let submission: import('@zlink-systems/zlink').SendSubmission;
   try {
     let current: ZLinkBindingAsyncSendSubmitOperation | undefined;
     const parts = Array.isArray(payload) ? payload : [payload];
@@ -122,9 +132,16 @@ export async function submitBindingAsyncSend(
       current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
     }
     current ??= operation.message(Buffer.alloc(0));
-    await current.submit().admitted;
+    submission = current.submit();
   } catch (error) {
-    throw translateBindingResultError(error);
+    throw translateBindingResultError(error, 'submit');
+  }
+  if (submission.result === SubmitResult.Backpressured) {
+    try {
+      await submission.admitted;
+    } catch (error) {
+      throw translateBindingResultError(error, 'completion');
+    }
   }
 }
 
@@ -151,6 +168,7 @@ export async function submitBindingRequest(
   payload: unknown,
   timeoutMs: number | undefined
 ): Promise<readonly unknown[]> {
+  const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
   try {
     let current: ZLinkBindingRequestSubmitOperation | undefined;
     if (Array.isArray(payload)) {
@@ -166,12 +184,39 @@ export async function submitBindingRequest(
     if (timeoutMs !== undefined) {
       current = current.timeout(timeoutMs);
     }
-    return await current.submit().reply;
+    return await bindingRequestReply(current.submit(), deadlineMs);
   } catch (error) {
     throw translateBindingResultError(error);
   }
 }
 
+export async function bindingRequestReply(
+  submission: import('@zlink-systems/zlink').RequestSubmission,
+  deadlineMs: number | undefined
+): Promise<import('@zlink-systems/zlink').Message[]> {
+  const reply = submission.reply;
+  if (submission.result === SubmitResult.Backpressured) {
+    try {
+      const [, replies] = await waitRequestReply(
+        Promise.all([submission.admitted, reply]),
+        'Request',
+        deadlineMs
+      );
+      return replies;
+    } catch (error) {
+      void reply.then(closeBindingReply, () => undefined);
+      throw error;
+    }
+  }
+  return reply;
+}
+
+export function closeBindingReply(
+  replies: readonly import('@zlink-systems/zlink').Message[]
+): void {
+  for (const reply of replies) reply.close();
+}
+
 /**
  * Closes a binding handle once. An already closed or terminated handle counts as
  * closed. A busy close propagates to the caller.
@@ -189,7 +234,13 @@ function isSuccessfulOrAlreadyShutdownCloseError(error: unknown): boolean {
     isContextTerminatedError(error) ||
     (error instanceof Error &&
       'code' in error &&
-      [0, 402, 403].includes((error as { code: number }).code))
+      (
+        [
+          zlink.CloseResult.Ok,
+          zlink.CloseResult.Shutdown,
+          zlink.CloseResult.InvalidHandle
+        ] as readonly number[]
+      ).includes((error as { code: number }).code))
   );
 }
 
@@ -239,9 +290,15 @@ function toNativeMessageLike(message: unknown): unknown {
   return message;
 }
 
-export function translateBindingResultError(error: unknown): unknown {
+export function translateBindingResultError(
+  error: unknown,
+  phase: 'submit' | 'completion' = 'completion'
+): unknown {
   if (error instanceof zlink.SubmitError) {
-    return new ZLinkBackendResultError('submit', error.result, error.nativeErrno, { cause: error });
+    return new ZLinkBackendResultError('submit', error.result, error.nativeErrno, {
+      cause: error,
+      phase
+    });
   }
   if (error instanceof zlink.RequestError) {
     return new ZLinkBackendResultError('request', error.result, error.nativeErrno, {

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

@@ -24,10 +24,8 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     channelName: string,
     packetName: string | undefined,
     message: Message,
-    signal?: AbortSignal,
     metadata: ReadonlyMap<string, string> = EMPTY_METADATA
   ): Promise<ZLinkSubmitResult> {
-    throwIfAborted(signal);
     // Call-scoped flow (spec 27 §4): the envelope flow pair does not outlive
     // this outbound call.
     await runWithOutboundFlow(