@zlink-systems/framework 0.30.0 → 0.30.1

package/dist/runtime/backend/mesh-completion-table.js

@@ -4,12 +4,109 @@ exports.ZLinkMeshCompletionTable = void 0;
 exports.closeMeshCompletion = closeMeshCompletion;
 const runtime_message_1 = require("./runtime-message");
 const operation_identity_1 = require("../foundation/operation-identity");
+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 {
+    abort;
+    generation = 0;
+    next = -1;
+    high;
+    low;
+    hashNext = -1;
+    resolve;
+    reject;
+    signal;
+    constructor(abort) {
+        this.abort = abort;
+    }
+}
 class ZLinkMeshCompletionTable {
     onDiagnostic;
-    pending = new Map();
+    buckets = new Int32Array(0);
+    slots = [];
+    free = -1;
+    activeCount = 0;
     disposed = false;
     constructor(onDiagnostic) {
         this.onDiagnostic = onDiagnostic;
+        this.prepareSlots();
+    }
+    prepareSlots() {
+        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);
+        }
+    }
+    bucket(high, low) {
+        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);
+    }
+    indexSlot(index) {
+        const slot = this.slots[index];
+        const bucket = this.bucket(slot.high, slot.low);
+        slot.hashNext = this.buckets[bucket];
+        this.buckets[bucket] = index;
+    }
+    findSlot(operationId) {
+        (0, operation_identity_1.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;
+    }
+    releaseSlot(index) {
+        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
@@ -24,39 +121,32 @@ class ZLinkMeshCompletionTable {
             return Promise.reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
         }
         return new Promise((resolve, reject) => {
-            let key = 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 = {
-                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))
+                // A reentrant abort may release and reuse this slot during submission.
+                if (slot.generation !== generation || slot.resolve !== resolve)
                     return;
-                key = (0, operation_identity_1.operationIdentityKey)(operationId);
-                if (this.pending.has(key)) {
-                    throw new Error(`Mesh operation '${key}' is already pending.`);
+                if (this.findSlot(operationId) !== -1) {
+                    throw new Error(`Mesh operation '${(0, operation_identity_1.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);
             }
         });
@@ -65,9 +155,8 @@ class ZLinkMeshCompletionTable {
         return this.disposed;
     }
     complete(record, materialize) {
-        const key = (0, operation_identity_1.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 }),
@@ -75,13 +164,15 @@ 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(retainCompletion(materialize === undefined ? record : materialize()));
+            resolve(retainCompletion(materialize === undefined ? record : materialize()));
         }
         catch (error) {
-            pending.reject(error);
+            reject(error);
         }
     }
     dispose(reason = new Error('Mesh completion table is disposed.')) {
@@ -89,34 +180,43 @@ 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() {
-        return this.pending.size;
+        return this.activeCount;
     }
 }
 exports.ZLinkMeshCompletionTable = ZLinkMeshCompletionTable;
 function retainCompletion(record) {
+    const parts = retainCompletionParts(record.parts);
+    // The retention pass verifies every part is already a managed runtime message.
+    if (parts === record.parts)
+        return record;
     return {
         terminalResult: record.terminalResult,
         failureErrno: record.failureErrno,
         operationKind: record.operationKind,
         kindData: record.kindData,
-        parts: record.parts.map(retainCompletionPart)
+        parts
     };
 }
-function retainCompletionPart(part) {
-    // 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 runtime_message_1.ZLinkBufferMessage ? part : runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(part.data()));
+function retainCompletionParts(parts) {
+    // Reuse managed messages and wrap binding payloads in the runtime representation.
+    let retained;
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        if (!(part instanceof runtime_message_1.ZLinkBufferMessage)) {
+            retained ??= parts.slice();
+            retained[index] = runtime_message_1.ZLinkBufferMessage.fromOwned(runtime_message_1.ZLinkBufferMessage.retainPayload(part));
+        }
+    }
+    return retained ?? parts;
 }
 function closeMeshCompletion(completion) {
     closeParts(completion.parts);

package/dist/runtime/backend/mesh-dispatch-pump.d.ts

@@ -20,6 +20,7 @@ export interface ZLinkMeshDispatchFailureContext {
 export declare class ZLinkMeshDispatchPump {
     private readonly node;
     private readonly options;
+    private readonly dispatchOwnedRecord;
     private pendingDomains;
     private infrastructureScheduled;
     private disposed;
@@ -37,6 +38,8 @@ export declare class ZLinkMeshDispatchPump {
     private startApplicationWorker;
     private runApplicationWorker;
     private waitForApplicationReady;
+    private dispatchRecord;
+    private finishRecord;
     private reportDispatchError;
     /**
      * Infrastructure controls must not wait for an application permit. During

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

@@ -24,6 +24,7 @@ const detachedMeshDispatchScope = node_async_hooks_1.AsyncLocalStorage.snapshot(
 class ZLinkMeshDispatchPump {
     node;
     options;
+    dispatchOwnedRecord = this.dispatchRecord.bind(this);
     pendingDomains = service_runtime_contracts_1.ReadyDomain.None;
     infrastructureScheduled = false;
     disposed = false;
@@ -140,6 +141,31 @@ class ZLinkMeshDispatchPump {
         }
         return new Promise((resolve) => this.idleApplicationWorkers.add(resolve));
     }
+    dispatchRecord(owner, record) {
+        let result;
+        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)));
+    }
+    finishRecord(record) {
+        let result;
+        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)));
+    }
     reportDispatchError(error, context) {
         this.options.reportError?.(error, context);
     }
@@ -238,17 +264,10 @@ class ZLinkMeshDispatchPump {
                                                 throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
                                             }
                                             this.recordsSinceYield += 1;
-                                            const dispatch = async () => {
-                                                try {
-                                                    await this.options.dispatch(owner, record);
-                                                    await record.onTerminalCompletion?.();
-                                                }
-                                                catch (error) {
-                                                    this.reportDispatchError(error, meshDispatchFailureContext(record));
-                                                }
-                                            };
                                             if (permit === undefined) {
-                                                await dispatch();
+                                                const dispatched = this.dispatchRecord(owner, record);
+                                                if (dispatched !== undefined)
+                                                    await dispatched;
                                             }
                                             else {
                                                 if (domain === service_runtime_contracts_1.ReadyDomain.Application &&
@@ -259,7 +278,9 @@ class ZLinkMeshDispatchPump {
                                                 // owned by the receive attempt's finally block.
                                                 if (permit === claimPermit)
                                                     claimPermit = undefined;
-                                                await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, dispatch);
+                                                const dispatched = (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, this.dispatchOwnedRecord, owner, record);
+                                                if (dispatched !== undefined)
+                                                    await dispatched;
                                             }
                                         }
                                     }

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

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

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

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

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

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

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

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

package/dist/runtime/backend/node/node-raw-binding-port.js

@@ -5,6 +5,7 @@ const zlink_1 = require("@zlink-systems/zlink");
 const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
 const node_event_loop_poller_1 = require("./node-event-loop-poller");
+const runtime_message_1 = require("../runtime-message");
 class ZLinkNodeRawBindingPort {
     sharedContext;
     routerReceiveTimeoutMs;
@@ -174,13 +175,39 @@ class NodeRawSocketPort {
 }
 class NodeRawRouterPort extends NodeRawSocketPort {
     nextIncomingRequestSequence = 1n;
+    routingIds = new Map();
+    nextRequestSequence = () => {
+        const current = this.nextIncomingRequestSequence;
+        this.nextIncomingRequestSequence =
+            current === BigInt(Number.MAX_SAFE_INTEGER) ? 1n : current + 1n;
+        return current;
+    };
+    replyParts = (targetRid, replyToken, parts) => {
+        appendReplyParts(this.socket.reply(this.preparedRoutingId(targetRid), replyToken), parts).submit();
+    };
+    preparedRoutingId(routingId) {
+        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;
+    }
+    close() {
+        try {
+            super.close();
+        }
+        finally {
+            this.routingIds.clear();
+        }
+    }
     setReceiveFlowState(state) {
         this.requireOpen();
         this.socket.setReceiveFlowState(state === 'paused' ? zlink_1.ReceiveFlowState.PAUSED : zlink_1.ReceiveFlowState.RUNNING);
     }
     disconnectRid(routingId) {
         this.requireOpen();
-        this.socket.disconnectRid(bindingRoutingId(routingId));
+        this.socket.disconnectRid(this.preparedRoutingId(routingId));
     }
     constructor(socket, receiveTimeoutMs) {
         super(socket, true);
@@ -197,29 +224,29 @@ class NodeRawRouterPort extends NodeRawSocketPort {
     }
     setRoutingId(routingId) {
         this.requireOpen();
-        this.socket.setRoutingId(bindingRoutingId(routingId));
+        this.socket.setRoutingId(this.preparedRoutingId(routingId));
     }
     connectToRoutingId(routingId, endpoint) {
         this.requireOpen();
-        this.socket.options.setConnectRoutingId(bindingRoutingId(routingId));
+        this.socket.options.setConnectRoutingId(this.preparedRoutingId(routingId));
         this.connect(endpoint);
     }
     send(targetRid, parts) {
         this.requireOpen();
         requireParts(parts);
-        return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(bindingRoutingId(targetRid)), parts);
+        return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(this.preparedRoutingId(targetRid)), parts);
     }
     submitSend(targetRid, parts) {
         this.requireOpen();
         requireParts(parts);
-        return (0, node_backend_adapter_support_1.submitBindingSend)(this.socket.send(bindingRoutingId(targetRid)), parts);
+        return (0, node_backend_adapter_support_1.submitBindingSend)(this.socket.send(this.preparedRoutingId(targetRid)), parts);
     }
-    async request(targetRid, parts, timeoutMs, recordReceived) {
+    async request(targetRid, parts, timeoutMs, recordReceived, onAdmitted) {
         this.requireOpen();
         const deadlineMs = performance.now() + timeoutMs;
         let submission;
         try {
-            submission = appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
+            submission = appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts)
                 .timeout(timeoutMs)
                 .submit();
         }
@@ -227,8 +254,8 @@ class NodeRawRouterPort extends NodeRawSocketPort {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
         }
         try {
-            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs, recordReceived);
-            return copyAndClose(replies);
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs, recordReceived, onAdmitted);
+            return retainAndClose(replies);
         }
         catch (error) {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
@@ -243,14 +270,7 @@ class NodeRawRouterPort extends NodeRawSocketPort {
     }
     receive(dontWait = false) {
         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);
     }
 }
 class NodeRawDealerPort extends NodeRawSocketPort {
@@ -266,7 +286,7 @@ class NodeRawDealerPort extends NodeRawSocketPort {
         requireParts(parts);
         return (0, node_backend_adapter_support_1.submitBindingAsyncSend)(this.socket.send(), parts);
     }
-    async request(parts, timeoutMs) {
+    async request(parts, timeoutMs, onAdmitted) {
         this.requireOpen();
         const deadlineMs = performance.now() + timeoutMs;
         let submission;
@@ -277,8 +297,8 @@ class NodeRawDealerPort extends NodeRawSocketPort {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'submit');
         }
         try {
-            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs);
-            return copyAndClose(replies);
+            const replies = await (0, node_backend_adapter_support_1.bindingRequestReply)(submission, deadlineMs, undefined, onAdmitted);
+            return retainAndClose(replies);
         }
         catch (error) {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error, 'completion');
@@ -390,9 +410,9 @@ function receiveRecord(socket, dontWait, nextRequestSequence, reply) {
         throw error;
     }
 }
-function copyAndClose(messages) {
+function retainAndClose(messages) {
     try {
-        return messages.map((message) => message.toBytes());
+        return messages.map((message) => runtime_message_1.ZLinkBufferMessage.retainPayload(message));
     }
     finally {
         for (const message of messages)