@zlink-systems/framework 0.29.1 → 0.30.1

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

@@ -4,18 +4,114 @@ 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--;
     }
     /**
-     * Submits and registers without yielding control to the event loop. Mesh
-     * completion dispatch is asynchronous, so a completion cannot overtake the
-     * registration. The table therefore does not need to retain responses that
-     * arrived before their waiter.
+     * Reserves the dispatcher slot before transport submission. The backend
+     * observes native terminals through Promises, so identity binding finishes
+     * before the terminal callback can run, without an infrastructure pump.
      */
     submit(operation, signal) {
         if (this.isDisposed()) {
@@ -24,40 +120,43 @@ class ZLinkMeshCompletionTable {
         if (signal?.aborted === true) {
             return Promise.reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
         }
-        const operationId = operation();
-        // The backend submission callback can synchronously re-enter `dispose()`.
-        // TypeScript's control-flow analysis cannot observe mutation through it.
-        if (this.disposed) {
-            return Promise.reject(new Error('Mesh completion table is disposed.'));
-        }
-        const key = (0, operation_identity_1.operationIdentityKey)(operationId);
-        if (this.pending.has(key)) {
-            return Promise.reject(new Error(`Mesh operation '${key}' is already pending.`));
-        }
         return new Promise((resolve, reject) => {
-            const abort = () => {
-                this.pending.delete(key);
-                reject(signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
-            };
-            if (signal?.aborted === true) {
-                abort();
-                return;
+            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();
+                // 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 '${(0, operation_identity_1.operationIdentityKey)(operationId)}' is already pending.`);
+                }
+                slot.high = operationId.high;
+                slot.low = operationId.low;
+                this.indexSlot(index);
+            }
+            catch (error) {
+                if (slot.generation === generation && slot.resolve === resolve)
+                    this.releaseSlot(index);
+                reject(error);
             }
-            signal?.addEventListener('abort', abort, { once: true });
-            this.pending.set(key, {
-                resolve,
-                reject,
-                removeAbort: signal === undefined ? undefined : () => signal.removeEventListener('abort', abort)
-            });
         });
     }
     isDisposed() {
         return this.disposed;
     }
-    complete(record) {
-        const key = (0, operation_identity_1.operationIdentityKey)(record.operationId);
-        const pending = this.pending.get(key);
-        if (pending === undefined) {
+    complete(record, materialize) {
+        const index = this.findSlot(record.operationId);
+        if (index === -1) {
             this.onDiagnostic?.({
                 kind: 'unknownOrLate',
                 operationId: Object.freeze({ ...record.operationId }),
@@ -65,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(record));
+            resolve(retainCompletion(materialize === undefined ? record : materialize()));
         }
         catch (error) {
-            pending.reject(error);
+            reject(error);
         }
     }
     dispose(reason = new Error('Mesh completion table is disposed.')) {
@@ -79,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);
     }
@@ -192,7 +218,7 @@ class ZLinkMeshDispatchPump {
     async drainDomain(domain, readyBatch, receiveBatch, claimBudget) {
         let claimsDrained = 0;
         try {
-            for (;;) {
+            while (!this.disposed) {
                 if (claimBudget !== undefined && claimsDrained >= claimBudget) {
                     // Lifecycle work has priority, but a bounded turn lets application
                     // work make progress when lifecycle records keep arriving.
@@ -217,20 +243,18 @@ class ZLinkMeshDispatchPump {
                         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 === service_runtime_contracts_1.ReadyDomain.Infrastructure
-                                    ? undefined
-                                    : await this.acquirePermit();
-                                try {
-                                    if (this.capacityStop.signal.aborted)
-                                        return;
-                                    ownerReceiveBatch.reset(capacity);
-                                    const received = claim.recvBatch(ownerReceiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
-                                    if (!received.ok)
-                                        break;
-                                    // This owner keeps its claim while it drains, so its records stay in FIFO order.
+                            let claimPermit = owner.terminalCompletion === true ||
+                                owner.ordinaryIngressPreAdmitted === true ||
+                                domain === service_runtime_contracts_1.ReadyDomain.Infrastructure
+                                ? undefined
+                                : await this.acquirePermit();
+                            try {
+                                if (this.capacityStop.signal.aborted)
+                                    return;
+                                ownerReceiveBatch.reset(capacity);
+                                const received = claim.recvBatch(ownerReceiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
+                                if (received.ok) {
+                                    // The bounded batch stays in claim order until its records finish.
                                     try {
                                         for (const record of received.records) {
                                             if (this.disposed)
@@ -240,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 &&
@@ -261,11 +278,10 @@ 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;
                                             }
-                                            const yieldTurn = this.yieldIfNeeded();
-                                            if (yieldTurn !== undefined)
-                                                await yieldTurn;
                                         }
                                     }
                                     finally {
@@ -278,9 +294,9 @@ class ZLinkMeshDispatchPump {
                                         }
                                     }
                                 }
-                                finally {
-                                    claimPermit?.releaseAfterInternalProcessing();
-                                }
+                            }
+                            finally {
+                                claimPermit?.releaseAfterInternalProcessing();
                             }
                         }
                         finally {
@@ -288,6 +304,9 @@ class ZLinkMeshDispatchPump {
                             if (receiveBatch === undefined)
                                 ownerReceiveBatch?.close();
                         }
+                        const yieldTurn = this.yieldIfNeeded();
+                        if (yieldTurn !== undefined)
+                            await yieldTurn;
                     };
                     // An application worker drains the one owner it claimed. Infrastructure owners
                     // drain independently, so a suspended owner does not hold the other claims.
@@ -310,10 +329,8 @@ class ZLinkMeshDispatchPump {
                 const yieldTurn = this.yieldIfNeeded();
                 if (yieldTurn !== undefined)
                     await yieldTurn;
-                if (!drained.hasResidue) {
-                    return false;
-                }
             }
+            return false;
         }
         finally {
             readyBatch.reset();
@@ -334,7 +351,7 @@ class ZLinkMeshDispatchPump {
     }
     async acquirePermit() {
         try {
-            return await this.options.applicationJobQueue.acquire(this.capacityStop.signal);
+            return await this.options.applicationJobQueue.acquire(this.capacityStop.signal, 'remote');
         }
         catch (error) {
             if (this.disposed || this.capacityStop.signal.aborted)

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

@@ -34,7 +34,12 @@ class ZLinkNodeChannelBackendAdapter {
         return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createDealerSocket(asNodeContext(context)), true);
     }
     createRouterSocket(context) {
-        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createRouterSocket(asNodeContext(context)), true);
+        const socket = node_backend_adapter_support_1.zlink.createRouterSocket(asNodeContext(context));
+        const adapter = (0, node_socket_backend_adapter_1.wrapSocket)(socket, true);
+        adapter.setReceiveFlowState = (state) => {
+            socket.setReceiveFlowState(state);
+        };
+        return adapter;
     }
     createPublisherSocket(context) {
         return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createPubSocket(asNodeContext(context)));

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

@@ -38,9 +38,10 @@ export declare function isRouteRecvRetryable(error: unknown): boolean;
 export declare function submitBindingPublish(operation: ZLinkBindingPublishOperation, payload: unknown): void;
 export declare function submitBindingReply(operation: ZLinkBindingReplyOperation, payload: unknown): void;
 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): Promise<readonly unknown[]>;
-export declare function bindingRequestReply(submission: import('@zlink-systems/zlink').RequestSubmission, deadlineMs: number | undefined): 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
@@ -50,7 +51,6 @@ export declare function closeBindingHandle(target: {
     close(): void;
 }): void;
 export declare function isContextTerminatedError(error: unknown): boolean;
-export declare function disableSocketLinger(target: unknown): void;
 export declare function toNativeRoutingId(routingId: unknown): unknown;
 export declare function translateBindingResultError(error: unknown, phase?: 'submit' | 'completion'): unknown;
 export declare function toNativeActorRef(actor: unknown): unknown;

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

@@ -6,13 +6,13 @@ exports.isRouteRecvRetryable = isRouteRecvRetryable;
 exports.submitBindingPublish = submitBindingPublish;
 exports.submitBindingReply = submitBindingReply;
 exports.submitBindingAsyncSend = submitBindingAsyncSend;
+exports.submitBindingSend = submitBindingSend;
 exports.submitBindingSyncSend = submitBindingSyncSend;
 exports.submitBindingRequest = submitBindingRequest;
 exports.bindingRequestReply = bindingRequestReply;
 exports.closeBindingReply = closeBindingReply;
 exports.closeBindingHandle = closeBindingHandle;
 exports.isContextTerminatedError = isContextTerminatedError;
-exports.disableSocketLinger = disableSocketLinger;
 exports.toNativeRoutingId = toNativeRoutingId;
 exports.translateBindingResultError = translateBindingResultError;
 exports.toNativeActorRef = toNativeActorRef;
@@ -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,7 +76,16 @@ function submitBindingReply(operation, payload) {
         throw translateBindingResultError(error);
     }
 }
-async function submitBindingAsyncSend(operation, payload) {
+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;
     try {
         let current;
@@ -91,13 +101,15 @@ async function submitBindingAsyncSend(operation, payload) {
         throw translateBindingResultError(error, 'submit');
     }
     if (submission.result === runtime_values_1.SubmitResult.Backpressured) {
-        try {
-            await submission.admitted;
-        }
-        catch (error) {
-            throw translateBindingResultError(error, 'completion');
-        }
+        return {
+            result: submission.result,
+            admitted: submission.admitted.catch((error) => {
+                throw translateBindingResultError(error, 'completion');
+            })
+        };
     }
+    // Binding SendSubmission is the closed OK | BACKPRESSURED snapshot.
+    return submission;
 }
 function submitBindingSyncSend(operation, payload) {
     try {
@@ -114,7 +126,7 @@ function submitBindingSyncSend(operation, payload) {
         throw translateBindingResultError(error);
     }
 }
-async function submitBindingRequest(operation, payload, timeoutMs) {
+async function submitBindingRequest(operation, payload, timeoutMs, recordReceived, onAdmitted) {
     const deadlineMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
     try {
         let current;
@@ -132,25 +144,32 @@ async function submitBindingRequest(operation, payload, timeoutMs) {
         if (timeoutMs !== undefined) {
             current = current.timeout(timeoutMs);
         }
-        return await bindingRequestReply(current.submit(), deadlineMs);
+        return await bindingRequestReply(current.submit(), deadlineMs, recordReceived, onAdmitted);
     }
     catch (error) {
         throw translateBindingResultError(error);
     }
 }
-async function bindingRequestReply(submission, deadlineMs) {
+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;
         }
         catch (error) {
-            void reply.then(closeBindingReply, () => undefined);
+            void reply.then((parts) => {
+                recordReceived?.();
+                closeBindingReply(parts);
+            }, () => undefined);
             throw error;
         }
     }
-    return reply;
+    onAdmitted?.();
+    const replies = await reply;
+    recordReceived?.();
+    return replies;
 }
 function closeBindingReply(replies) {
     for (const reply of replies)
@@ -182,23 +201,6 @@ function isSuccessfulOrAlreadyShutdownCloseError(error) {
 function isContextTerminatedError(error) {
     return error instanceof Error && /context was terminated/i.test(error.message);
 }
-function disableSocketLinger(target) {
-    if (target !== null &&
-        typeof target === 'object' &&
-        'options' in target &&
-        typeof target.options === 'object' &&
-        target.options !== null &&
-        'linger' in target.options) {
-        try {
-            target.options.linger = 0;
-        }
-        catch (error) {
-            if (!isContextTerminatedError(error)) {
-                throw error;
-            }
-        }
-    }
-}
 function toNativeRoutingId(routingId) {
     if (typeof routingId === 'string')
         return exports.zlink.RoutingId.from(routingId);

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);
         }