@zlink-systems/framework 0.30.0 → 0.30.1

package/src/runtime/backend/mesh-completion-table.ts

@@ -5,7 +5,7 @@ import type {
   ReceiveKindData,
   ReceiveRecord
 } from '../foundation/service-runtime-contracts';
-import { operationIdentityKey } from '../foundation/operation-identity';
+import { operationIdentityKey, validateOperationIdentity } from '../foundation/operation-identity';
 
 export interface ZLinkMeshCompletionDiagnostic {
   readonly kind: 'unknownOrLate';
@@ -21,10 +21,23 @@ export interface ZLinkMeshCompletion {
   readonly parts: Message[];
 }
 
-interface PendingCompletion {
-  readonly resolve: (completion: ZLinkMeshCompletion) => void;
-  readonly reject: (error: unknown) => void;
-  readonly removeAbort?: () => void;
+const COMPLETION_SLOT_BLOCK_SIZE = 64;
+const COMPLETION_HASH_BUCKETS_PER_SLOT = 2;
+const COMPLETION_HASH_WORD_SCALE = 0x1_0000;
+const COMPLETION_HASH_MULTIPLIER = 0x9e37_79b1;
+const COMPLETION_ABORT_OPTIONS = Object.freeze({ once: true });
+
+class CompletionSlot {
+  generation = 0;
+  next = -1;
+  high?: bigint;
+  low?: bigint;
+  hashNext = -1;
+  resolve?: (completion: ZLinkMeshCompletion) => void;
+  reject?: (error: unknown) => void;
+  signal?: AbortSignal;
+
+  constructor(readonly abort: () => void) {}
 }
 
 export type ZLinkMeshCompletionTerminal = Pick<ReceiveRecord, 'operationId' | 'terminalResult'>;
@@ -34,12 +47,97 @@ export type ZLinkMeshCompletionHandler = (
 ) => void;
 
 export class ZLinkMeshCompletionTable {
-  private readonly pending = new Map<string | symbol, PendingCompletion>();
+  private buckets = new Int32Array(0);
+  private readonly slots: CompletionSlot[] = [];
+  private free = -1;
+  private activeCount = 0;
   private disposed = false;
 
-  constructor(
-    private readonly onDiagnostic?: (diagnostic: ZLinkMeshCompletionDiagnostic) => void
-  ) {}
+  constructor(private readonly onDiagnostic?: (diagnostic: ZLinkMeshCompletionDiagnostic) => void) {
+    this.prepareSlots();
+  }
+
+  private prepareSlots(): void {
+    const start = this.slots.length;
+    for (let index = start; index < start + COMPLETION_SLOT_BLOCK_SIZE; index++) {
+      const slot = new CompletionSlot(() => {
+        const reject = slot.reject;
+        const signal = slot.signal;
+        if (reject === undefined) return;
+        this.releaseSlot(index);
+        reject(signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
+      });
+      slot.next = this.free;
+      this.slots.push(slot);
+      this.free = index;
+    }
+    const minimumBuckets = this.slots.length * COMPLETION_HASH_BUCKETS_PER_SLOT;
+    this.buckets = new Int32Array(2 ** Math.ceil(Math.log2(minimumBuckets))).fill(-1);
+    for (let index = 0; index < this.slots.length; index++) {
+      const slot = this.slots[index]!;
+      if (slot.high === undefined) continue;
+      this.indexSlot(index);
+    }
+  }
+
+  private bucket(high: bigint, low: bigint): number {
+    const highWord = Number(high);
+    const lowWord = Number(low);
+    // Bucket selection may collide; the stored 128-bit identity is compared exactly.
+    const hash =
+      Math.imul(
+        highWord ^ Math.trunc(highWord / COMPLETION_HASH_WORD_SCALE),
+        COMPLETION_HASH_MULTIPLIER
+      ) ^
+      lowWord ^
+      Math.trunc(lowWord / COMPLETION_HASH_WORD_SCALE);
+    return hash & (this.buckets.length - 1);
+  }
+
+  private indexSlot(index: number): void {
+    const slot = this.slots[index]!;
+    const bucket = this.bucket(slot.high!, slot.low!);
+    slot.hashNext = this.buckets[bucket]!;
+    this.buckets[bucket] = index;
+  }
+
+  private findSlot(operationId: MeshOperationId): number {
+    validateOperationIdentity(operationId);
+    for (
+      let index = this.buckets[this.bucket(operationId.high, operationId.low)]!;
+      index !== -1;
+      index = this.slots[index]!.hashNext
+    ) {
+      const slot = this.slots[index]!;
+      if (slot.high === operationId.high && slot.low === operationId.low) return index;
+    }
+    return -1;
+  }
+
+  private releaseSlot(index: number): void {
+    const slot = this.slots[index]!;
+    if (slot.high !== undefined) {
+      const bucket = this.bucket(slot.high, slot.low!);
+      let previous = -1;
+      let current = this.buckets[bucket]!;
+      while (current !== index) {
+        previous = current;
+        current = this.slots[current]!.hashNext;
+      }
+      if (previous === -1) this.buckets[bucket] = slot.hashNext;
+      else this.slots[previous]!.hashNext = slot.hashNext;
+    }
+    slot.signal?.removeEventListener('abort', slot.abort);
+    slot.high = undefined;
+    slot.low = undefined;
+    slot.hashNext = -1;
+    slot.signal = undefined;
+    slot.resolve = undefined;
+    slot.reject = undefined;
+    slot.next = this.free;
+    this.free = index;
+    this.activeCount--;
+  }
 
   /**
    * Reserves the dispatcher slot before transport submission. The backend
@@ -56,37 +154,30 @@ export class ZLinkMeshCompletionTable {
       );
     }
     return new Promise((resolve, reject) => {
-      let key: string | symbol = Symbol();
-      const abort = () => {
-        this.pending.delete(key);
-        reject(signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
-      };
-      if (signal?.aborted === true) {
-        abort();
-        return;
-      }
-      signal?.addEventListener('abort', abort, { once: true });
-      const entry: PendingCompletion = {
-        resolve,
-        reject,
-        removeAbort:
-          signal === undefined ? undefined : () => signal.removeEventListener('abort', abort)
-      };
-      this.pending.set(key, entry);
+      if (this.free === -1) this.prepareSlots();
+      const index = this.free;
+      const slot = this.slots[index]!;
+      this.free = slot.next;
+      const generation = ++slot.generation;
+      slot.resolve = resolve;
+      slot.reject = reject;
+      slot.signal = signal;
+      this.activeCount++;
       try {
+        signal?.addEventListener('abort', slot.abort, COMPLETION_ABORT_OPTIONS);
         const operationId = operation();
-        // dispose/abort can consume the reserved slot during submission.
-        if (!this.pending.delete(key)) return;
-        key = operationIdentityKey(operationId);
-        if (this.pending.has(key)) {
-          throw new Error(`Mesh operation '${key}' is already pending.`);
+        // A reentrant abort may release and reuse this slot during submission.
+        if (slot.generation !== generation || slot.resolve !== resolve) return;
+        if (this.findSlot(operationId) !== -1) {
+          throw new Error(
+            `Mesh operation '${operationIdentityKey(operationId)}' is already pending.`
+          );
         }
-        this.pending.set(key, entry);
+        slot.high = operationId.high;
+        slot.low = operationId.low;
+        this.indexSlot(index);
       } catch (error) {
-        // Remove only this submission's slot; a duplicate identity retains
-        // the original waiter.
-        if (this.pending.get(key) === entry) this.pending.delete(key);
-        entry.removeAbort?.();
+        if (slot.generation === generation && slot.resolve === resolve) this.releaseSlot(index);
         reject(error);
       }
     });
@@ -99,9 +190,8 @@ export class ZLinkMeshCompletionTable {
   complete(record: ReceiveRecord): void;
   complete(record: ZLinkMeshCompletionTerminal, materialize: () => ReceiveRecord): void;
   complete(record: ZLinkMeshCompletionTerminal, materialize?: () => ReceiveRecord): void {
-    const key = operationIdentityKey(record.operationId);
-    const pending = this.pending.get(key);
-    if (pending === undefined) {
+    const index = this.findSlot(record.operationId);
+    if (index === -1) {
       this.onDiagnostic?.({
         kind: 'unknownOrLate',
         operationId: Object.freeze({ ...record.operationId }),
@@ -109,14 +199,16 @@ export class ZLinkMeshCompletionTable {
       });
       return;
     }
-    this.pending.delete(key);
-    pending.removeAbort?.();
+    const slot = this.slots[index]!;
+    const resolve = slot.resolve!;
+    const reject = slot.reject!;
+    this.releaseSlot(index);
     try {
-      pending.resolve(
+      resolve(
         retainCompletion(materialize === undefined ? (record as ReceiveRecord) : materialize())
       );
     } catch (error) {
-      pending.reject(error);
+      reject(error);
     }
   }
 
@@ -125,36 +217,43 @@ export class ZLinkMeshCompletionTable {
       return;
     }
     this.disposed = true;
-    const pending = [...this.pending.values()];
-    this.pending.clear();
-    for (const entry of pending) {
-      entry.removeAbort?.();
-    }
-    for (const entry of pending) {
-      entry.reject(reason);
+    for (let index = 0; index < this.slots.length; index++) {
+      const reject = this.slots[index]!.reject;
+      if (reject === undefined) continue;
+      this.releaseSlot(index);
+      reject(reason);
     }
   }
 
   get pendingCount(): number {
-    return this.pending.size;
+    return this.activeCount;
   }
 }
 
 function retainCompletion(record: ReceiveRecord): ZLinkMeshCompletion {
+  const parts = retainCompletionParts(record.parts);
+  // The retention pass verifies every part is already a managed runtime message.
+  if (parts === record.parts) return record as unknown as ZLinkMeshCompletion;
   return {
     terminalResult: record.terminalResult,
     failureErrno: record.failureErrno,
     operationKind: record.operationKind,
     kindData: record.kindData,
-    parts: record.parts.map(retainCompletionPart)
+    parts
   };
 }
 
-function retainCompletionPart(part: ZLinkMessage): Message {
-  // A runtime message already owns a managed Buffer and close() is a no-op.
-  // Binding-native messages can expose native storage through data(), which
-  // becomes invalid when their owner closes; materialize that one boundary copy.
-  return part instanceof Message ? part : Message.fromOwned(Buffer.from(part.data()));
+function retainCompletionParts(parts: readonly ZLinkMessage[]): Message[] {
+  // Reuse managed messages and wrap binding payloads in the runtime representation.
+  let retained: Message[] | undefined;
+  for (let index = 0; index < parts.length; index++) {
+    const part = parts[index]!;
+    if (!(part instanceof Message)) {
+      retained ??= parts.slice() as Message[];
+      retained[index] = Message.fromOwned(Message.retainPayload(part));
+    }
+  }
+  return retained ?? (parts as Message[]);
 }
 
 export function closeMeshCompletion(completion: ZLinkMeshCompletion): void {

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

@@ -58,6 +58,7 @@ export interface ZLinkMeshDispatchFailureContext {
 }
 
 export class ZLinkMeshDispatchPump {
+  private readonly dispatchOwnedRecord = this.dispatchRecord.bind(this);
   private pendingDomains: number = ReadyDomain.None;
   private infrastructureScheduled = false;
   private disposed = false;
@@ -180,6 +181,36 @@ export class ZLinkMeshDispatchPump {
     return new Promise((resolve) => this.idleApplicationWorkers.add(resolve));
   }
 
+  private dispatchRecord(owner: ReadyRecord, record: ReceiveRecord): void | Promise<void> {
+    let result: void | Promise<void>;
+    try {
+      result = this.options.dispatch(owner, record);
+    } catch (error) {
+      this.reportDispatchError(error, meshDispatchFailureContext(record));
+      return;
+    }
+    return result === undefined
+      ? this.finishRecord(record)
+      : Promise.resolve(result).then(
+          () => this.finishRecord(record),
+          (error) => this.reportDispatchError(error, meshDispatchFailureContext(record))
+        );
+  }
+
+  private finishRecord(record: ReceiveRecord): void | Promise<void> {
+    let result: void | Promise<void>;
+    try {
+      result = record.onTerminalCompletion?.();
+    } catch (error) {
+      this.reportDispatchError(error, meshDispatchFailureContext(record));
+      return;
+    }
+    if (result !== undefined)
+      return Promise.resolve(result).catch((error) =>
+        this.reportDispatchError(error, meshDispatchFailureContext(record))
+      );
+  }
+
   private reportDispatchError(error: unknown, context?: ZLinkMeshDispatchFailureContext): void {
     this.options.reportError?.(error, context);
   }
@@ -304,16 +335,9 @@ export class ZLinkMeshDispatchPump {
                         );
                       }
                       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();
+                        const dispatched = this.dispatchRecord(owner, record);
+                        if (dispatched !== undefined) await dispatched;
                       } else {
                         if (
                           domain === ReadyDomain.Application &&
@@ -324,7 +348,13 @@ export class ZLinkMeshDispatchPump {
                         // 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 dispatched = runWithApplicationJobPermit(
+                          permit,
+                          this.dispatchOwnedRecord,
+                          owner,
+                          record
+                        );
+                        if (dispatched !== undefined) await dispatched;
                       }
                     }
                   } finally {

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

@@ -7,6 +7,7 @@ import {
 import { loadBinding } from '../node-backend-adapter';
 import { SubmitResult, ZLinkBackendResultError } from '../runtime-values';
 const nativeErrnoValues = osConstants.errno;
+const completedSend: Promise<void> = Promise.resolve();
 
 export type ZLinkBindingModule = typeof import('@zlink-systems/zlink');
 export const zlink = loadBinding() as ZLinkBindingModule;
@@ -119,12 +120,16 @@ export function submitBindingReply(operation: ZLinkBindingReplyOperation, payloa
   }
 }
 
-export async function submitBindingAsyncSend(
+export function submitBindingAsyncSend(
   operation: ZLinkBindingAsyncSendOperation,
   payload: unknown
 ): Promise<void> {
-  const submission = submitBindingSend(operation, payload);
-  if (submission.result === SubmitResult.Backpressured) await submission.admitted;
+  try {
+    const submission = submitBindingSend(operation, payload);
+    return submission.result === SubmitResult.Backpressured ? submission.admitted : completedSend;
+  } catch (error) {
+    return Promise.reject(error);
+  }
 }
 
 export function submitBindingSend(
@@ -152,7 +157,8 @@ export function submitBindingSend(
       })
     };
   }
-  return { result: SubmitResult.Ok, admitted: submission.admitted };
+  // Binding SendSubmission is the closed OK | BACKPRESSURED snapshot.
+  return submission as import('../raw-binding-port').ZLinkRawSendSubmission;
 }
 
 export function submitBindingSyncSend(
@@ -177,7 +183,8 @@ export async function submitBindingRequest(
   operation: ZLinkBindingRequestOperation,
   payload: unknown,
   timeoutMs: number | undefined,
-  recordReceived?: () => void
+  recordReceived?: () => void,
+  onAdmitted?: () => void
 ): Promise<readonly unknown[]> {
   const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
   try {
@@ -195,7 +202,7 @@ export async function submitBindingRequest(
     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);
   }
@@ -204,13 +211,14 @@ export async function submitBindingRequest(
 export async function bindingRequestReply(
   submission: import('@zlink-systems/zlink').RequestSubmission,
   deadlineMs: number | undefined,
-  recordReceived?: () => void
+  recordReceived?: () => void,
+  onAdmitted?: () => void
 ): 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]),
+        Promise.all([submission.admitted.then(() => onAdmitted?.()), reply]),
         'Request',
         deadlineMs
       );
@@ -227,6 +235,7 @@ export async function bindingRequestReply(
       throw error;
     }
   }
+  onAdmitted?.();
   const replies = await reply;
   recordReceived?.();
   return replies;

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

@@ -1,3 +1,4 @@
+import { bindingRequestReply } from './node-backend-adapter-support';
 import type { DealerSocket, Message, PubSocket } from '@zlink-systems/zlink';
 import { ZLinkConfigurationException } from '../../configuration';
 import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../../messaging/submission-result';
@@ -56,7 +57,8 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     request: Message,
     timeoutMs: number | undefined,
     signal?: AbortSignal,
-    metadata: ReadonlyMap<string, string> = EMPTY_METADATA
+    metadata: ReadonlyMap<string, string> = EMPTY_METADATA,
+    onAdmitted?: () => void
   ): Promise<TReply> {
     throwIfAborted(signal);
     const operation = runWithOutboundFlow(true, () =>
@@ -78,7 +80,15 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     );
     if (timeoutMs !== undefined) operation.timeout(timeoutMs);
     const reply = await submitRequestOperation(
-      { submit: () => operation.submit().reply },
+      {
+        submit: () =>
+          bindingRequestReply(
+            operation.submit(),
+            timeoutMs === undefined ? undefined : performance.now() + timeoutMs,
+            undefined,
+            onAdmitted
+          )
+      },
       'channel request'
     );
     try {

package/src/runtime/backend/node/node-raw-binding-port.ts

@@ -27,6 +27,7 @@ import {
 } from './node-backend-adapter-support';
 import { isEndpointCloseIgnorableError } from './node-socket-backend-adapter';
 import { ZLinkNodeEventLoopPoller } from './node-event-loop-poller';
+import { ZLinkBufferMessage } from '../runtime-message';
 import type {
   ZLinkRawBindingPort,
   ZLinkRawDealerPort,
@@ -226,6 +227,42 @@ abstract class NodeRawSocketPort<TSocket extends Socket> implements ZLinkRawSock
 
 class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLinkRawRouterPort {
   private nextIncomingRequestSequence = 1n;
+  private readonly routingIds = new Map<string, BindingRoutingId>();
+  private readonly nextRequestSequence = () => {
+    const current = this.nextIncomingRequestSequence;
+    this.nextIncomingRequestSequence =
+      current === BigInt(Number.MAX_SAFE_INTEGER) ? 1n : current + 1n;
+    return current;
+  };
+  private readonly replyParts = (
+    targetRid: string | Uint8Array,
+    replyToken: unknown,
+    parts: readonly Uint8Array[]
+  ) => {
+    appendReplyParts(
+      this.socket.reply(
+        this.preparedRoutingId(targetRid),
+        replyToken as Parameters<RouterSocket['reply']>[1]
+      ),
+      parts
+    ).submit();
+  };
+
+  private preparedRoutingId(routingId: string | Uint8Array): BindingRoutingId {
+    if (typeof routingId !== 'string') return bindingRoutingId(routingId);
+    let prepared = this.routingIds.get(routingId);
+    if (prepared === undefined)
+      this.routingIds.set(routingId, (prepared = bindingRoutingId(routingId)));
+    return prepared;
+  }
+
+  override close(): void {
+    try {
+      super.close();
+    } finally {
+      this.routingIds.clear();
+    }
+  }
 
   setReceiveFlowState(state: 'running' | 'paused'): void {
     this.requireOpen();
@@ -240,7 +277,7 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
       this.socket as RouterSocket & {
         disconnectRid(value: BindingRoutingId): void;
       }
-    ).disconnectRid(bindingRoutingId(routingId));
+    ).disconnectRid(this.preparedRoutingId(routingId));
   }
 
   constructor(socket: RouterSocket, receiveTimeoutMs?: number) {
@@ -260,46 +297,47 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
 
   setRoutingId(routingId: string): void {
     this.requireOpen();
-    this.socket.setRoutingId(bindingRoutingId(routingId));
+    this.socket.setRoutingId(this.preparedRoutingId(routingId));
   }
 
   connectToRoutingId(routingId: string, endpoint: string): void {
     this.requireOpen();
-    this.socket.options.setConnectRoutingId(bindingRoutingId(routingId));
+    this.socket.options.setConnectRoutingId(this.preparedRoutingId(routingId));
     this.connect(endpoint);
   }
 
   send(targetRid: string, parts: readonly Uint8Array[]): Promise<void> {
     this.requireOpen();
     requireParts(parts);
-    return submitBindingAsyncSend(this.socket.send(bindingRoutingId(targetRid)), parts);
+    return submitBindingAsyncSend(this.socket.send(this.preparedRoutingId(targetRid)), parts);
   }
 
   submitSend(targetRid: string, parts: readonly Uint8Array[]) {
     this.requireOpen();
     requireParts(parts);
-    return submitBindingSend(this.socket.send(bindingRoutingId(targetRid)), parts);
+    return submitBindingSend(this.socket.send(this.preparedRoutingId(targetRid)), parts);
   }
 
   async request(
     targetRid: string,
     parts: readonly Uint8Array[],
     timeoutMs: number,
-    recordReceived?: () => void
+    recordReceived?: () => void,
+    onAdmitted?: () => void
   ): Promise<readonly Buffer[]> {
     this.requireOpen();
     const deadlineMs = performance.now() + timeoutMs;
     let submission: ReturnType<RequestSubmitOperation['submit']>;
     try {
-      submission = appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
+      submission = appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts)
         .timeout(timeoutMs)
         .submit();
     } catch (error) {
       throw translateBindingResultError(error, 'submit');
     }
     try {
-      const replies = await bindingRequestReply(submission, deadlineMs, recordReceived);
-      return copyAndClose(replies);
+      const replies = await bindingRequestReply(submission, deadlineMs, recordReceived, onAdmitted);
+      return retainAndClose(replies);
     } catch (error) {
       throw translateBindingResultError(error, 'completion');
     }
@@ -315,22 +353,7 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
 
   receive(dontWait = false): ZLinkRawReceivedRecord | undefined {
     this.requireOpen();
-    return receiveRecord(
-      this.socket,
-      dontWait,
-      () => {
-        const current = this.nextIncomingRequestSequence;
-        this.nextIncomingRequestSequence =
-          current === BigInt(Number.MAX_SAFE_INTEGER) ? 1n : current + 1n;
-        return current;
-      },
-      (targetRid, replyToken, parts) => {
-        appendReplyParts(
-          this.socket.reply(bindingRoutingId(targetRid), replyToken),
-          parts
-        ).submit();
-      }
-    );
+    return receiveRecord(this.socket, dontWait, this.nextRequestSequence, this.replyParts);
   }
 }
 
@@ -350,7 +373,11 @@ class NodeRawDealerPort extends NodeRawSocketPort<DealerSocket> implements ZLink
     return submitBindingAsyncSend(this.socket.send(), parts);
   }
 
-  async request(parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]> {
+  async request(
+    parts: readonly Uint8Array[],
+    timeoutMs: number,
+    onAdmitted?: () => void
+  ): Promise<readonly Buffer[]> {
     this.requireOpen();
     const deadlineMs = performance.now() + timeoutMs;
     let submission: ReturnType<RequestSubmitOperation['submit']>;
@@ -360,8 +387,8 @@ class NodeRawDealerPort extends NodeRawSocketPort<DealerSocket> implements ZLink
       throw translateBindingResultError(error, 'submit');
     }
     try {
-      const replies = await bindingRequestReply(submission, deadlineMs);
-      return copyAndClose(replies);
+      const replies = await bindingRequestReply(submission, deadlineMs, undefined, onAdmitted);
+      return retainAndClose(replies);
     } catch (error) {
       throw translateBindingResultError(error, 'completion');
     }
@@ -493,9 +520,9 @@ function receiveRecord(
   }
 }
 
-function copyAndClose(messages: readonly Message[]): readonly Buffer[] {
+function retainAndClose(messages: readonly Message[]): readonly Buffer[] {
   try {
-    return messages.map((message) => message.toBytes());
+    return messages.map((message) => ZLinkBufferMessage.retainPayload(message));
   } finally {
     for (const message of messages) message.close();
   }