@zlink-systems/framework 0.11.0 → 0.12.0

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

@@ -2,13 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkMeshDispatchPump = void 0;
 const node_async_hooks_1 = require("node:async_hooks");
+const node_os_1 = require("node:os");
 const runtime_values_1 = require("./runtime-values");
 const service_runtime_contracts_1 = require("../foundation/service-runtime-contracts");
 const execution_1 = require("../execution");
 const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
-const MESH_DISPATCH_TIMER_YIELD_BATCHES = 16;
-const MESH_DISPATCH_TIMER_YIELD_INTERVAL_MS = 2;
+const MESH_DISPATCH_YIELD_RECORDS = 16;
+const MESH_DISPATCH_YIELD_INTERVAL_MS = 2;
 const MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET = 4;
+const MESH_DISPATCH_RECEIVE_CAPACITY = 64;
+const MESH_DISPATCH_MAX_APPLICATION_WORKERS = Math.max(2, (0, node_os_1.availableParallelism)());
 // Captured while the runtime module is loaded, before any application owner
 // exists. A ready callback may run inside a Spot turn; the shared Mesh pump
 // must enter like an independent receive-loop task, without inheriting that
@@ -28,24 +31,27 @@ class ZLinkMeshDispatchPump {
     node;
     options;
     pendingDomains = service_runtime_contracts_1.ReadyDomain.None;
-    scheduled = false;
     infrastructureScheduled = false;
     disposed = false;
-    drainPromise;
     infrastructureDrainPromise;
     activeDrains = new Set();
+    idleApplicationWorkers = new Set();
+    applicationWorkerCount = 0;
     capacityStop = new AbortController();
+    recordsSinceYield = 0;
+    yieldStartedAtMs = 0;
     constructor(node, options) {
         this.node = node;
         this.options = options;
     }
     start() {
+        if (this.applicationWorkerCount === 0)
+            this.startApplicationWorker();
         this.node.setReadyHandler((domains) => {
             if (this.disposed) {
                 return service_runtime_contracts_1.ReadyDomain.None;
             }
-            this.pendingDomains |= domains;
-            this.schedule();
+            this.markReady(domains);
             return domains;
         });
     }
@@ -56,42 +62,100 @@ class ZLinkMeshDispatchPump {
         this.disposed = true;
         this.capacityStop.abort();
         this.pendingDomains = service_runtime_contracts_1.ReadyDomain.None;
+        for (const wake of this.idleApplicationWorkers)
+            wake();
+        this.idleApplicationWorkers.clear();
         while (this.activeDrains.size > 0) {
             await Promise.all([...this.activeDrains]);
         }
     }
-    schedule() {
-        if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0) {
+    markReady(domains) {
+        if (domains === service_runtime_contracts_1.ReadyDomain.None || this.disposed)
+            return;
+        const previous = this.pendingDomains;
+        this.pendingDomains |= domains;
+        const startInfrastructure = (domains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0
+            && (previous & service_runtime_contracts_1.ReadyDomain.Infrastructure) === 0;
+        const startApplication = (domains & service_runtime_contracts_1.ReadyDomain.Application) !== 0
+            && (previous & service_runtime_contracts_1.ReadyDomain.Application) === 0;
+        if (startInfrastructure && startApplication) {
+            const startTurn = this.yieldIfNeeded() ?? Promise.resolve();
+            this.scheduleInfrastructure(startTurn);
+            return;
+        }
+        if (startInfrastructure)
             this.scheduleInfrastructure();
+        if (startApplication) {
+            if ((domains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0) {
+                setImmediate(() => this.wakeApplicationWorker());
+            }
+            else {
+                this.wakeApplicationWorker();
+            }
         }
-        if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) === 0) {
+    }
+    wakeApplicationWorker() {
+        if (this.disposed || (this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) === 0)
             return;
-        }
-        if (this.scheduled) {
+        const idle = this.idleApplicationWorkers.values().next().value;
+        if (idle !== undefined) {
+            this.idleApplicationWorkers.delete(idle);
+            this.pendingDomains &= ~service_runtime_contracts_1.ReadyDomain.Application;
+            idle();
             return;
         }
-        this.scheduled = true;
-        const drain = yieldToEventLoop()
-            .then(() => detachedMeshDispatchScope(() => this.drain()))
-            .catch((error) => {
-            if (error instanceof ZLinkMeshDispatchFailure) {
-                this.options.reportError?.(error.dispatchCause, error.context);
-                return;
-            }
-            this.options.reportError?.(error);
+        if (this.applicationWorkerCount < MESH_DISPATCH_MAX_APPLICATION_WORKERS) {
+            this.startApplicationWorker();
+        }
+    }
+    startApplicationWorker() {
+        this.applicationWorkerCount += 1;
+        let worker;
+        worker = detachedMeshDispatchScope(() => (0, execution_1.runZLinkExecutionArea)('application', () => this.runApplicationWorker()))
+            .finally(() => {
+            this.applicationWorkerCount -= 1;
+            this.activeDrains.delete(worker);
         });
-        this.activeDrains.add(drain);
-        this.drainPromise = drain;
-        void drain.finally(() => {
-            this.activeDrains.delete(drain);
-            if (this.drainPromise === drain) {
-                this.drainPromise = undefined;
-                this.scheduled = false;
-                if (!this.disposed && this.pendingDomains !== service_runtime_contracts_1.ReadyDomain.None) {
-                    this.schedule();
+        this.activeDrains.add(worker);
+    }
+    async runApplicationWorker() {
+        // A worker claims one owner at a time so a suspended handler cannot hold
+        // unrelated owners. Each owner may supply up to 64 pre-admitted records.
+        const readyBatch = this.node.createReadyBatch(1);
+        const receiveBatch = this.node.createReceiveBatch(MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? 256);
+        try {
+            for (;;) {
+                await this.waitForApplicationReady();
+                if (this.disposed)
+                    return;
+                try {
+                    await this.drainDomain(service_runtime_contracts_1.ReadyDomain.Application, readyBatch, receiveBatch);
+                }
+                catch (error) {
+                    this.reportDispatchError(error);
                 }
             }
-        });
+        }
+        finally {
+            receiveBatch.close();
+            readyBatch.close();
+        }
+    }
+    waitForApplicationReady() {
+        if (this.disposed)
+            return Promise.resolve();
+        if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) !== 0) {
+            this.pendingDomains &= ~service_runtime_contracts_1.ReadyDomain.Application;
+            return Promise.resolve();
+        }
+        return new Promise(resolve => this.idleApplicationWorkers.add(resolve));
+    }
+    reportDispatchError(error) {
+        if (error instanceof ZLinkMeshDispatchFailure) {
+            this.options.reportError?.(error.dispatchCause, error.context);
+            return;
+        }
+        this.options.reportError?.(error);
     }
     /**
      * Infrastructure controls must not wait for an application permit. During
@@ -100,13 +164,13 @@ class ZLinkMeshDispatchPump {
      * the infrastructure mailbox and prevent the relocation coordinator from
      * completing the drain that releases the application work.
      */
-    scheduleInfrastructure() {
+    scheduleInfrastructure(startTurn) {
         if (this.infrastructureScheduled) {
             return;
         }
         this.infrastructureScheduled = true;
-        const drain = yieldToEventLoop()
-            .then(() => detachedMeshDispatchScope(() => this.drainInfrastructure()))
+        const drain = (startTurn ?? this.yieldIfNeeded() ?? Promise.resolve())
+            .then(() => detachedMeshDispatchScope(() => (0, execution_1.runZLinkExecutionArea)('infrastructure', () => this.drainInfrastructure())))
             .catch((error) => {
             if (error instanceof ZLinkMeshDispatchFailure) {
                 this.options.reportError?.(error.dispatchCause, error.context);
@@ -127,39 +191,31 @@ class ZLinkMeshDispatchPump {
             }
         });
     }
-    async drain() {
-        while (!this.disposed) {
-            if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) === 0) {
-                return;
-            }
-            this.pendingDomains &= ~service_runtime_contracts_1.ReadyDomain.Application;
-            await this.drainDomain(service_runtime_contracts_1.ReadyDomain.Application);
-        }
-    }
     async drainInfrastructure() {
-        while (!this.disposed) {
-            if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Infrastructure) === 0) {
-                return;
-            }
-            this.pendingDomains &= ~service_runtime_contracts_1.ReadyDomain.Infrastructure;
-            const lifecycleBudgetExhausted = await this.drainDomain(service_runtime_contracts_1.ReadyDomain.Infrastructure, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET);
-            if (lifecycleBudgetExhausted) {
-                this.pendingDomains |= service_runtime_contracts_1.ReadyDomain.Infrastructure;
+        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);
+        try {
+            while (!this.disposed) {
+                if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Infrastructure) === 0) {
+                    return;
+                }
+                this.pendingDomains &= ~service_runtime_contracts_1.ReadyDomain.Infrastructure;
+                if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Application) !== 0) {
+                    setImmediate(() => this.wakeApplicationWorker());
+                }
+                const lifecycleBudgetExhausted = await this.drainDomain(service_runtime_contracts_1.ReadyDomain.Infrastructure, readyBatch, receiveBatch, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET);
+                if (lifecycleBudgetExhausted) {
+                    this.pendingDomains |= service_runtime_contracts_1.ReadyDomain.Infrastructure;
+                    await yieldToEventLoop();
+                }
             }
         }
+        finally {
+            receiveBatch.close();
+            readyBatch.close();
+        }
     }
-    async drainDomain(domain, claimBudget) {
-        const readyCapacity = domain === service_runtime_contracts_1.ReadyDomain.Application
-            ? 1
-            : claimBudget === undefined
-                ? (this.options.readyCapacity ?? 32)
-                : Math.min(this.options.readyCapacity ?? 32, claimBudget);
-        const readyBatch = this.node.createReadyBatch(readyCapacity);
-        // One record per claim receive keeps one ordinary-ingress permit paired
-        // with exactly one dispatch turn. Terminal completion claims bypass it.
-        const receiveBatch = this.node.createReceiveBatch(1, this.options.partCapacity ?? 256);
-        let receiveBatchesSinceTimerYield = 0;
-        let timerYieldStartedAtMs = this.nowMs();
+    async drainDomain(domain, readyBatch, receiveBatch, claimBudget) {
         let claimsDrained = 0;
         try {
             for (;;) {
@@ -174,113 +230,124 @@ class ZLinkMeshDispatchPump {
                     return false;
                 }
                 if (domain === service_runtime_contracts_1.ReadyDomain.Application && drained.hasResidue) {
-                    this.pendingDomains |= service_runtime_contracts_1.ReadyDomain.Application;
+                    this.markReady(service_runtime_contracts_1.ReadyDomain.Application);
                 }
                 for (let index = 0; index < drained.records.length; index += 1) {
                     const claim = readyBatch.takeClaim(index);
                     claimsDrained += 1;
+                    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 {
-                        receiveBatch.reset();
+                        const capacity = owner.ordinaryIngressPreAdmitted === true
+                            ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
                         for (;;) {
-                            const owner = drained.records[index];
-                            const claimPermit = owner.terminalCompletion === true
+                            let claimPermit = owner.terminalCompletion === true
                                 || owner.ordinaryIngressPreAdmitted === true
                                 || domain === service_runtime_contracts_1.ReadyDomain.Infrastructure
                                 ? undefined
                                 : await this.acquirePermit();
-                            if (claimPermit === undefined
-                                && this.disposed
-                                && owner.terminalCompletion !== true
-                                && owner.ordinaryIngressPreAdmitted !== true)
-                                return false;
-                            const received = claim.recvBatch(receiveBatch, runtime_values_1.ZLINK_BACKEND_RECV_DONT_WAIT);
-                            if (!received.ok) {
-                                claimPermit?.releaseAfterInternalProcessing();
-                                break;
-                            }
-                            if (received.records.length === 0) {
-                                claimPermit?.releaseAfterInternalProcessing();
-                            }
-                            for (const record of received.records) {
-                                const permit = record.applicationJobPermit ?? claimPermit;
-                                if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
-                                    record.releaseRetainedIngress?.();
-                                    throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
+                            try {
+                                if (this.capacityStop.signal.aborted)
+                                    return false;
+                                receiveBatch.reset(capacity);
+                                const received = claim.recvBatch(receiveBatch, runtime_values_1.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 === service_runtime_contracts_1.ReadyDomain.Infrastructure) {
+                                    this.infrastructureScheduled = false;
+                                    this.infrastructureDrainPromise = undefined;
+                                    if ((this.pendingDomains & service_runtime_contracts_1.ReadyDomain.Infrastructure) !== 0) {
+                                        this.scheduleInfrastructure();
+                                    }
                                 }
                                 try {
-                                    // A handler may synchronously submit an operation whose
-                                    // control/completion is owned by this same MeshNode (e.g. a
-                                    // native Completion record fed back through this node's own
-                                    // Infrastructure claim). The active lane's scheduling state
-                                    // must be released here, or a nested re-entrant drain can
-                                    // never start to deliver that completion, and the awaiting
-                                    // handler deadlocks against its own claim (spec
-                                    // 46-internal-dispatch-loop, receive/dispatch wake/ordering).
-                                    this.scheduled = false;
-                                    this.drainPromise = undefined;
-                                    if (domain === service_runtime_contracts_1.ReadyDomain.Infrastructure) {
-                                        this.infrastructureScheduled = false;
-                                        this.infrastructureDrainPromise = undefined;
-                                    }
-                                    if (this.pendingDomains !== service_runtime_contracts_1.ReadyDomain.None) {
-                                        this.schedule();
-                                    }
-                                    const dispatch = () => (0, execution_1.runZLinkExecutionArea)(domain === service_runtime_contracts_1.ReadyDomain.Infrastructure ? 'infrastructure' : 'application', async () => {
-                                        try {
-                                            await this.options.dispatch(drained.records[index], record);
+                                    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.');
                                         }
-                                        catch (error) {
-                                            throw new ZLinkMeshDispatchFailure(meshDispatchFailureContext(record), error);
+                                        this.recordsSinceYield += 1;
+                                        const dispatch = async () => {
+                                            try {
+                                                await this.options.dispatch(drained.records[index], record);
+                                            }
+                                            catch (error) {
+                                                throw new ZLinkMeshDispatchFailure(meshDispatchFailureContext(record), error);
+                                            }
+                                            await record.onTerminalCompletion?.();
+                                        };
+                                        if (permit === undefined) {
+                                            await dispatch();
                                         }
-                                        await record.onTerminalCompletion?.();
-                                    });
-                                    if (permit === undefined) {
-                                        await dispatch();
-                                    }
-                                    else {
-                                        if (domain === service_runtime_contracts_1.ReadyDomain.Application
-                                            && record.applicationJobPermit === undefined)
-                                            permit.markApplicationQueued();
-                                        await (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, dispatch);
+                                        else {
+                                            if (domain === service_runtime_contracts_1.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 (0, application_job_queue_scope_1.runWithApplicationJobPermit)(permit, dispatch);
+                                        }
+                                        const yieldTurn = this.yieldIfNeeded();
+                                        if (yieldTurn !== undefined)
+                                            await yieldTurn;
                                     }
                                 }
                                 finally {
-                                    for (const part of record.parts) {
-                                        part.close();
+                                    // 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?.();
                                     }
-                                    record.releaseRetainedIngress?.();
                                 }
                             }
-                            // A continuously readable owner must not keep the timers phase
-                            // from running, but a timer turn for every single record adds a
-                            // Promise, closure, and timer allocation to the hot path.
-                            receiveBatchesSinceTimerYield += 1;
-                            if (receiveBatchesSinceTimerYield >= MESH_DISPATCH_TIMER_YIELD_BATCHES
-                                || this.nowMs() - timerYieldStartedAtMs >= MESH_DISPATCH_TIMER_YIELD_INTERVAL_MS) {
-                                receiveBatchesSinceTimerYield = 0;
-                                await yieldToTimers();
-                                timerYieldStartedAtMs = this.nowMs();
+                            finally {
+                                claimPermit?.releaseAfterInternalProcessing();
                             }
-                            receiveBatch.reset();
                         }
                     }
                     finally {
                         claim.release();
                     }
                 }
-                await yieldToTimers();
-                receiveBatchesSinceTimerYield = 0;
-                timerYieldStartedAtMs = this.nowMs();
+                if (claimBudget !== undefined && claimsDrained >= claimBudget) {
+                    this.wakeApplicationWorker();
+                    return true;
+                }
+                // Empty ready claims also count as work, so they cannot monopolize
+                // the microtask queue without giving I/O and deadlines a turn.
+                this.recordsSinceYield += 1;
+                const yieldTurn = this.yieldIfNeeded();
+                if (yieldTurn !== undefined)
+                    await yieldTurn;
                 if (!drained.hasResidue) {
                     return false;
                 }
             }
         }
         finally {
-            receiveBatch.close();
-            readyBatch.close();
+            readyBatch.reset();
         }
     }
+    yieldIfNeeded() {
+        const nowMs = this.nowMs();
+        if (this.recordsSinceYield < MESH_DISPATCH_YIELD_RECORDS
+            && nowMs - this.yieldStartedAtMs < MESH_DISPATCH_YIELD_INTERVAL_MS)
+            return undefined;
+        this.recordsSinceYield = 0;
+        return yieldToTimers().then(() => {
+            this.yieldStartedAtMs = this.nowMs();
+        });
+    }
     nowMs() {
         return this.options.monotonicNowMs?.() ?? performance.now();
     }

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

@@ -1,9 +1,8 @@
-import type { Received, TopicMessage } from '@zlink-systems/zlink';
-import type { ZLinkBackendAdapterFactory, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter, ZLinkStreamBackendAdapter } from '../contracts';
+import type { TopicMessage } from '@zlink-systems/zlink';
+import type { ZLinkBackendAdapterFactory, ZLinkBackendReceived, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter, ZLinkStreamBackendAdapter } from '../contracts';
 import { ZLinkNodeMeshBackendAdapter } from './node-mesh-backend-adapter';
-export { isDisconnectRouteNotFoundError } from './node-socket-backend-adapter';
 export declare class ZLinkNodeBackendAdapterFactory implements ZLinkBackendAdapterFactory {
-    createReceived(): Received;
+    createReceived(): ZLinkBackendReceived;
     createTopicMessage(): TopicMessage;
     createChannelAdapter(): ZLinkChannelBackendAdapter;
     createMeshAdapter(): ZLinkNodeMeshBackendAdapter;

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

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkNodeBackendAdapterFactory = exports.isDisconnectRouteNotFoundError = void 0;
+exports.ZLinkNodeBackendAdapterFactory = void 0;
 const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const node_monitor_backend_adapter_1 = require("./node-monitor-backend-adapter");
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
 const node_mesh_backend_adapter_1 = require("./node-mesh-backend-adapter");
-var node_socket_backend_adapter_2 = require("./node-socket-backend-adapter");
-Object.defineProperty(exports, "isDisconnectRouteNotFoundError", { enumerable: true, get: function () { return node_socket_backend_adapter_2.isDisconnectRouteNotFoundError; } });
 class ZLinkNodeBackendAdapterFactory {
     createReceived() {
         return new node_backend_adapter_support_1.zlink.Received();
@@ -36,16 +34,16 @@ class ZLinkNodeChannelBackendAdapter {
         return new node_backend_adapter_support_1.zlink.TopicMessage();
     }
     createDealerSocket(context) {
-        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createDealerSocket(asNodeContext(context)));
+        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)));
+        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createRouterSocket(asNodeContext(context)), true);
     }
     createPublisherSocket(context) {
         return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createPubSocket(asNodeContext(context)));
     }
     createSubscriberSocket(context) {
-        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createSubSocket(asNodeContext(context)));
+        return (0, node_socket_backend_adapter_1.wrapSocket)(node_backend_adapter_support_1.zlink.createSubSocket(asNodeContext(context)), false);
     }
     createReadablePoller(socket) {
         return createNodeReadablePoller(socket);
@@ -55,7 +53,7 @@ class ZLinkNodeStreamBackendAdapter {
     createStreamSocket(context) {
         const socket = node_backend_adapter_support_1.zlink.createStreamSocket(asNodeContext(context));
         socket.options.recvMode = node_backend_adapter_support_1.zlink.StreamRecvMode.Packet;
-        return (0, node_socket_backend_adapter_1.wrapSocket)(socket);
+        return (0, node_socket_backend_adapter_1.wrapSocket)(socket, true);
     }
     createStreamPacket() {
         return new node_backend_adapter_support_1.zlink.StreamPacket();
@@ -118,44 +116,60 @@ function asNodeContext(context) {
     return context.nativeInstance;
 }
 function createNodeReadablePoller(socket) {
-    const poller = node_backend_adapter_support_1.zlink.createPoller();
-    const events = node_backend_adapter_support_1.zlink.createPollEvents(1);
-    try {
-        poller.add(socket.nativeInstance, [node_backend_adapter_support_1.zlink.PollEventFlag.PollIn], 0);
-    }
-    catch (error) {
-        events.close();
-        poller.close();
-        throw error;
-    }
+    const eventLoopPoller = (0, node_socket_backend_adapter_1.nodeEventLoopPollerOf)(socket);
     let disposed = false;
+    let readable = false;
+    let pending;
+    const settlePending = (value) => {
+        const current = pending;
+        if (current === undefined)
+            return;
+        pending = undefined;
+        if (current.signal !== undefined && current.onAbort !== undefined) {
+            current.signal.removeEventListener('abort', current.onAbort);
+        }
+        current.resolve(value);
+    };
+    eventLoopPoller.setReadableHandler(() => {
+        if (disposed)
+            return;
+        readable = true;
+        settlePending(true);
+    });
     return {
-        wait(timeoutMs) {
-            try {
-                return poller.wait(events, timeoutMs) > 0
-                    && events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn);
-            }
-            catch (error) {
-                if ((0, node_backend_adapter_support_1.isPollerInterruptedError)(error))
-                    return false;
-                throw error;
+        wait(_timeoutMs) {
+            return !disposed && readable;
+        },
+        waitForReadable(signal) {
+            if (disposed || signal?.aborted === true)
+                return Promise.resolve(false);
+            if (readable)
+                return Promise.resolve(true);
+            if (pending !== undefined)
+                return pending.promise;
+            let resolvePending;
+            const promise = new Promise((resolve) => {
+                resolvePending = resolve;
+            });
+            const onAbort = signal === undefined
+                ? undefined
+                : () => settlePending(false);
+            pending = { promise, resolve: resolvePending, signal, onAbort };
+            if (signal !== undefined && onAbort !== undefined) {
+                signal.addEventListener('abort', onAbort, { once: true });
             }
+            return promise;
+        },
+        markDrained() {
+            readable = false;
         },
         dispose() {
             if (disposed)
                 return;
             disposed = true;
-            try {
-                poller.remove(socket.nativeInstance);
-            }
-            finally {
-                try {
-                    events.close();
-                }
-                finally {
-                    poller.close();
-                }
-            }
+            readable = false;
+            settlePending(false);
+            eventLoopPoller.setReadableHandler(() => { });
         }
     };
 }

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

@@ -22,7 +22,7 @@ interface ZLinkBindingReplySubmitOperation {
 }
 interface ZLinkBindingAsyncSendSubmitOperation {
     message(message: unknown): ZLinkBindingAsyncSendSubmitOperation;
-    submit(): Promise<void>;
+    submit(): import('@zlink-systems/zlink').SendSubmission;
     submit_sync(): void;
 }
 export interface ZLinkBindingRequestOperation {
@@ -31,7 +31,7 @@ export interface ZLinkBindingRequestOperation {
 interface ZLinkBindingRequestSubmitOperation {
     message(message: unknown): ZLinkBindingRequestSubmitOperation;
     timeout(timeoutMs: number): ZLinkBindingRequestSubmitOperation;
-    submit(): Promise<readonly unknown[]>;
+    submit(): import('@zlink-systems/zlink').RequestSubmission;
 }
 export declare function isBindingNotFound(error: unknown): boolean;
 export declare function isRouteRecvRetryable(error: unknown): boolean;

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

@@ -73,7 +73,7 @@ async function submitBindingAsyncSend(operation, payload) {
             current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
         }
         current ??= operation.message(Buffer.alloc(0));
-        await current.submit();
+        await current.submit().admitted;
     }
     catch (error) {
         throw translateBindingResultError(error);
@@ -110,7 +110,7 @@ async function submitBindingRequest(operation, payload, timeoutMs) {
         if (timeoutMs !== undefined) {
             current = current.timeout(timeoutMs);
         }
-        return await current.submit();
+        return await current.submit().reply;
     }
     catch (error) {
         throw translateBindingResultError(error);