@zlink-systems/framework 0.10.0 → 0.12.0

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

@@ -1,8 +1,11 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { availableParallelism } from 'node:os';
 import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
 import {
   ReadyDomain,
+  type ReadyBatch,
   type ReadyRecord,
+  type ReceiveBatch,
   type ReceiveRecord
 } from '../foundation/service-runtime-contracts';
 import type { ZLinkBackendMeshNode } from './contracts';
@@ -13,9 +16,11 @@ import type {
 } from '../application-jobs/contracts';
 import { runWithApplicationJobPermit } from '../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, 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
@@ -52,13 +57,15 @@ class ZLinkMeshDispatchFailure extends Error {
 
 export class ZLinkMeshDispatchPump {
   private pendingDomains: number = ReadyDomain.None;
-  private scheduled = false;
   private infrastructureScheduled = false;
   private disposed = false;
-  private drainPromise?: Promise<void>;
   private infrastructureDrainPromise?: Promise<void>;
   private readonly activeDrains = new Set<Promise<void>>();
+  private readonly idleApplicationWorkers = new Set<() => void>();
+  private applicationWorkerCount = 0;
   private readonly capacityStop = new AbortController();
+  private recordsSinceYield = 0;
+  private yieldStartedAtMs = 0;
 
   constructor(
     private readonly node: ZLinkBackendMeshNode,
@@ -67,12 +74,12 @@ export class ZLinkMeshDispatchPump {
   }
 
   start(): void {
+    if (this.applicationWorkerCount === 0) this.startApplicationWorker();
     this.node.setReadyHandler((domains) => {
       if (this.disposed) {
         return ReadyDomain.None;
       }
-      this.pendingDomains |= domains;
-      this.schedule();
+      this.markReady(domains);
       return domains;
     });
   }
@@ -84,43 +91,102 @@ export class ZLinkMeshDispatchPump {
     this.disposed = true;
     this.capacityStop.abort();
     this.pendingDomains = ReadyDomain.None;
+    for (const wake of this.idleApplicationWorkers) wake();
+    this.idleApplicationWorkers.clear();
     while (this.activeDrains.size > 0) {
       await Promise.all([...this.activeDrains]);
     }
   }
 
-  private schedule(): void {
-    if ((this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
-      this.scheduleInfrastructure();
-    }
-    if ((this.pendingDomains & ReadyDomain.Application) === 0) {
+  private markReady(domains: number): void {
+    if (domains === ReadyDomain.None || this.disposed) return;
+    const previous = this.pendingDomains;
+    this.pendingDomains |= domains;
+    const startInfrastructure =
+      (domains & ReadyDomain.Infrastructure) !== 0
+      && (previous & ReadyDomain.Infrastructure) === 0;
+    const startApplication =
+      (domains & ReadyDomain.Application) !== 0
+      && (previous & ReadyDomain.Application) === 0;
+    if (startInfrastructure && startApplication) {
+      const startTurn = this.yieldIfNeeded() ?? Promise.resolve();
+      this.scheduleInfrastructure(startTurn);
       return;
     }
-    if (this.scheduled) {
+    if (startInfrastructure) this.scheduleInfrastructure();
+    if (startApplication) {
+      if ((domains & ReadyDomain.Infrastructure) !== 0) {
+        setImmediate(() => this.wakeApplicationWorker());
+      } else {
+        this.wakeApplicationWorker();
+      }
+    }
+  }
+
+  private wakeApplicationWorker(): void {
+    if (this.disposed || (this.pendingDomains & ReadyDomain.Application) === 0) return;
+    const idle = this.idleApplicationWorkers.values().next().value as (() => void) | undefined;
+    if (idle !== undefined) {
+      this.idleApplicationWorkers.delete(idle);
+      this.pendingDomains &= ~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();
+    }
+  }
+
+  private startApplicationWorker(): void {
+    this.applicationWorkerCount += 1;
+    let worker: Promise<void>;
+    worker = detachedMeshDispatchScope(() =>
+      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 !== ReadyDomain.None) {
-          this.schedule();
+    this.activeDrains.add(worker);
+  }
+
+  private async runApplicationWorker(): Promise<void> {
+    // 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(ReadyDomain.Application, readyBatch, receiveBatch);
+        } catch (error) {
+          this.reportDispatchError(error);
         }
       }
-    });
+    } finally {
+      receiveBatch.close();
+      readyBatch.close();
+    }
+  }
+
+  private waitForApplicationReady(): Promise<void> {
+    if (this.disposed) return Promise.resolve();
+    if ((this.pendingDomains & ReadyDomain.Application) !== 0) {
+      this.pendingDomains &= ~ReadyDomain.Application;
+      return Promise.resolve();
+    }
+    return new Promise(resolve => this.idleApplicationWorkers.add(resolve));
+  }
+
+  private reportDispatchError(error: unknown): void {
+    if (error instanceof ZLinkMeshDispatchFailure) {
+      this.options.reportError?.(error.dispatchCause, error.context);
+      return;
+    }
+    this.options.reportError?.(error);
   }
 
   /**
@@ -130,13 +196,14 @@ export class ZLinkMeshDispatchPump {
    * the infrastructure mailbox and prevent the relocation coordinator from
    * completing the drain that releases the application work.
    */
-  private scheduleInfrastructure(): void {
+  private scheduleInfrastructure(startTurn?: Promise<void>): void {
     if (this.infrastructureScheduled) {
       return;
     }
     this.infrastructureScheduled = true;
-    const drain = yieldToEventLoop()
-      .then(() => detachedMeshDispatchScope(() => this.drainInfrastructure()))
+    const drain = (startTurn ?? this.yieldIfNeeded() ?? Promise.resolve())
+      .then(() => detachedMeshDispatchScope(() =>
+        runZLinkExecutionArea('infrastructure', () => this.drainInfrastructure())))
       .catch((error) => {
         if (error instanceof ZLinkMeshDispatchFailure) {
           this.options.reportError?.(error.dispatchCause, error.context);
@@ -158,44 +225,45 @@ export class ZLinkMeshDispatchPump {
     });
   }
 
-  private async drain(): Promise<void> {
-    while (!this.disposed) {
-      if ((this.pendingDomains & ReadyDomain.Application) === 0) {
-        return;
-      }
-      this.pendingDomains &= ~ReadyDomain.Application;
-      await this.drainDomain(ReadyDomain.Application);
-    }
-  }
-
   private async drainInfrastructure(): Promise<void> {
-    while (!this.disposed) {
-      if ((this.pendingDomains & ReadyDomain.Infrastructure) === 0) {
-        return;
-      }
-      this.pendingDomains &= ~ReadyDomain.Infrastructure;
-      const lifecycleBudgetExhausted = await this.drainDomain(
-        ReadyDomain.Infrastructure,
-        MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
-      );
-      if (lifecycleBudgetExhausted) {
-        this.pendingDomains |= 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 & ReadyDomain.Infrastructure) === 0) {
+          return;
+        }
+        this.pendingDomains &= ~ReadyDomain.Infrastructure;
+        if ((this.pendingDomains & ReadyDomain.Application) !== 0) {
+          setImmediate(() => this.wakeApplicationWorker());
+        }
+        const lifecycleBudgetExhausted = await this.drainDomain(
+          ReadyDomain.Infrastructure,
+          readyBatch,
+          receiveBatch,
+          MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
+        );
+        if (lifecycleBudgetExhausted) {
+          this.pendingDomains |= ReadyDomain.Infrastructure;
+          await yieldToEventLoop();
+        }
       }
+    } finally {
+      receiveBatch.close();
+      readyBatch.close();
     }
   }
 
-  private async drainDomain(domain: number, claimBudget?: number): Promise<boolean> {
-    const readyCapacity = domain === 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();
+  private async drainDomain(
+    domain: number,
+    readyBatch: ReadyBatch,
+    receiveBatch: ReceiveBatch,
+    claimBudget?: number
+  ): Promise<boolean> {
     let claimsDrained = 0;
     try {
       for (;;) {
@@ -210,59 +278,46 @@ export class ZLinkMeshDispatchPump {
           return false;
         }
         if (domain === ReadyDomain.Application && drained.hasResidue) {
-          this.pendingDomains |= ReadyDomain.Application;
+          this.markReady(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 === ReadyDomain.Infrastructure
                 ? undefined
                 : await this.acquirePermit();
-              if (claimPermit === undefined
-                  && this.disposed
-                  && owner.terminalCompletion !== true
-                  && owner.ordinaryIngressPreAdmitted !== true) return false;
-              const received = claim.recvBatch(receiveBatch, 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, ZLINK_BACKEND_RECV_DONT_WAIT);
+                if (!received.ok) break;
+                // This owner keeps its claim while it drains. Other owners and
+                // infrastructure may progress if one of its handlers suspends.
+                if (domain === ReadyDomain.Infrastructure) {
+                  this.infrastructureScheduled = false;
+                  this.infrastructureDrainPromise = undefined;
+                  if ((this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
+                    this.scheduleInfrastructure();
+                  }
                 }
                 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 === ReadyDomain.Infrastructure) {
-                    this.infrastructureScheduled = false;
-                    this.infrastructureDrainPromise = undefined;
-                  }
-                  if (this.pendingDomains !== ReadyDomain.None) {
-                    this.schedule();
-                  }
-                  const dispatch = () => runZLinkExecutionArea(
-                    domain === ReadyDomain.Infrastructure ? 'infrastructure' : 'application',
-                    async () => {
+                  for (const record of received.records) {
+                    if (this.disposed) break;
+                    const permit = record.applicationJobPermit ?? claimPermit;
+                    if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
+                      throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
+                    }
+                    this.recordsSinceYield += 1;
+                    const dispatch = async () => {
                       try {
                         await this.options.dispatch(drained.records[index], record);
                       } catch (error) {
@@ -272,55 +327,67 @@ export class ZLinkMeshDispatchPump {
                         );
                       }
                       await record.onTerminalCompletion?.();
+                    };
+                    if (permit === undefined) {
+                      await dispatch();
+                    } else {
+                      if (
+                        domain === ReadyDomain.Application
+                        && record.applicationJobPermit === undefined
+                      ) permit.markApplicationQueued();
+                      // The scope now owns this reservation, including failure
+                      // and detached handler handoff. Only unused permits remain
+                      // owned by the receive attempt's finally block.
+                      if (permit === claimPermit) claimPermit = undefined;
+                      await runWithApplicationJobPermit(permit, dispatch);
                     }
-                  );
-                  if (permit === undefined) {
-                    await dispatch();
-                  } else {
-                    if (
-                      domain === ReadyDomain.Application
-                      && record.applicationJobPermit === undefined
-                    ) permit.markApplicationQueued();
-                    await 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?.();
                 }
+              } finally {
+                claimPermit?.releaseAfterInternalProcessing();
               }
-              // 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();
-              }
-              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();
     }
   }
 
+  private yieldIfNeeded(): Promise<void> | undefined {
+    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();
+    });
+  }
+
   private nowMs(): number {
     return this.options.monotonicNowMs?.() ?? performance.now();
   }
@@ -358,6 +425,7 @@ function yieldToEventLoop(): Promise<void> {
   return new Promise((resolve) => setImmediate(resolve));
 }
 
+
 function yieldToTimers(): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }

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

@@ -1,7 +1,6 @@
 import type {
   Context,
   CoreHwmBudgetSnapshot,
-  Received,
   TopicMessage
 } from '@zlink-systems/zlink';
 import type { ZLinkCoreHwmOptions } from '../../../contracts/Configuration';
@@ -11,6 +10,7 @@ import type {
   ZLinkBackendDealerSocket,
   ZLinkBackendPublisherSocket,
   ZLinkBackendReadablePoller,
+  ZLinkBackendReceived,
   ZLinkBackendRouterSocket,
   ZLinkBackendSocket,
   ZLinkBackendSocketMonitor,
@@ -24,18 +24,15 @@ import type {
 import {
   closeWithBusyRetry,
   isContextTerminatedError,
-  isPollerInterruptedError,
   zlink,
   type ZLinkBindingModule
 } from './node-backend-adapter-support';
 import { wrapMonitorSocket } from './node-monitor-backend-adapter';
-import { wrapSocket } from './node-socket-backend-adapter';
+import { nodeEventLoopPollerOf, wrapSocket } from './node-socket-backend-adapter';
 import { ZLinkNodeMeshBackendAdapter } from './node-mesh-backend-adapter';
 
-export { isDisconnectRouteNotFoundError } from './node-socket-backend-adapter';
-
 export class ZLinkNodeBackendAdapterFactory implements ZLinkBackendAdapterFactory {
-  createReceived(): Received {
+  createReceived(): ZLinkBackendReceived {
     return new zlink.Received();
   }
 
@@ -70,11 +67,17 @@ class ZLinkNodeChannelBackendAdapter implements ZLinkChannelBackendAdapter {
   }
 
   createDealerSocket(context: ZLinkBackendContext): ZLinkBackendDealerSocket {
-    return wrapSocket(zlink.createDealerSocket(asNodeContext(context))) as unknown as ZLinkBackendDealerSocket;
+    return wrapSocket(
+      zlink.createDealerSocket(asNodeContext(context)),
+      true
+    ) as unknown as ZLinkBackendDealerSocket;
   }
 
   createRouterSocket(context: ZLinkBackendContext): ZLinkBackendRouterSocket {
-    return wrapSocket(zlink.createRouterSocket(asNodeContext(context))) as unknown as ZLinkBackendRouterSocket;
+    return wrapSocket(
+      zlink.createRouterSocket(asNodeContext(context)),
+      true
+    ) as unknown as ZLinkBackendRouterSocket;
   }
 
   createPublisherSocket(context: ZLinkBackendContext): ZLinkBackendPublisherSocket {
@@ -82,7 +85,10 @@ class ZLinkNodeChannelBackendAdapter implements ZLinkChannelBackendAdapter {
   }
 
   createSubscriberSocket(context: ZLinkBackendContext): ZLinkBackendSubscriberSocket {
-    return wrapSocket(zlink.createSubSocket(asNodeContext(context))) as unknown as ZLinkBackendSubscriberSocket;
+    return wrapSocket(
+      zlink.createSubSocket(asNodeContext(context)),
+      false
+    ) as unknown as ZLinkBackendSubscriberSocket;
   }
 
   createReadablePoller(socket: ZLinkBackendSubscriberSocket): ZLinkBackendReadablePoller {
@@ -94,7 +100,7 @@ class ZLinkNodeStreamBackendAdapter implements ZLinkStreamBackendAdapter {
   createStreamSocket(context: ZLinkBackendContext): ZLinkBackendStreamSocket {
     const socket = zlink.createStreamSocket(asNodeContext(context));
     socket.options.recvMode = zlink.StreamRecvMode.Packet;
-    return wrapSocket(socket) as unknown as ZLinkBackendStreamSocket;
+    return wrapSocket(socket, true) as unknown as ZLinkBackendStreamSocket;
   }
 
   createStreamPacket(): ZLinkBackendStreamPacket {
@@ -167,38 +173,63 @@ function asNodeContext(context: ZLinkBackendContext): Context {
 function createNodeReadablePoller(
   socket: { readonly nativeInstance: unknown }
 ): ZLinkBackendReadablePoller {
-  const poller = zlink.createPoller();
-  const events = zlink.createPollEvents(1);
-  try {
-    poller.add(socket.nativeInstance as never, [zlink.PollEventFlag.PollIn], 0);
-  } catch (error) {
-    events.close();
-    poller.close();
-    throw error;
-  }
+  const eventLoopPoller = nodeEventLoopPollerOf(socket);
   let disposed = false;
+  let readable = false;
+  let pending: {
+    readonly promise: Promise<boolean>;
+    readonly resolve: (readable: boolean) => void;
+    readonly signal?: AbortSignal;
+    readonly onAbort?: () => void;
+  } | undefined;
+
+  const settlePending = (value: boolean): void => {
+    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: number): boolean {
-      try {
-        return poller.wait(events, timeoutMs) > 0
-          && events.hasEvent(0, zlink.PollEventFlag.PollIn);
-      } catch (error) {
-        if (isPollerInterruptedError(error)) return false;
-        throw error;
+    wait(_timeoutMs: number): boolean {
+      return !disposed && readable;
+    },
+    waitForReadable(signal?: AbortSignal): Promise<boolean> {
+      if (disposed || signal?.aborted === true) return Promise.resolve(false);
+      if (readable) return Promise.resolve(true);
+      if (pending !== undefined) return pending.promise;
+
+      let resolvePending!: (value: boolean) => void;
+      const promise = new Promise<boolean>((resolve) => {
+        resolvePending = resolve;
+      });
+      const onAbort = signal === undefined
+        ? undefined
+        : (): void => settlePending(false);
+      pending = { promise, resolve: resolvePending, signal, onAbort };
+      if (signal !== undefined && onAbort !== undefined) {
+        signal.addEventListener('abort', onAbort, { once: true });
       }
+      return promise;
+    },
+    markDrained(): void {
+      readable = false;
     },
     dispose(): void {
       if (disposed) return;
       disposed = true;
-      try {
-        poller.remove(socket.nativeInstance as never);
-      } finally {
-        try {
-          events.close();
-        } finally {
-          poller.close();
-        }
-      }
+      readable = false;
+      settlePending(false);
+      eventLoopPoller.setReadableHandler(() => {});
     }
   };
 }

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

@@ -30,7 +30,7 @@ interface ZLinkBindingReplySubmitOperation {
 
 interface ZLinkBindingAsyncSendSubmitOperation {
   message(message: unknown): ZLinkBindingAsyncSendSubmitOperation;
-  submit(): Promise<void>;
+  submit(): import('@zlink-systems/zlink').SendSubmission;
   submit_sync(): void;
 }
 
@@ -41,7 +41,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 function isBindingNotFound(error: unknown): boolean {
@@ -113,7 +113,7 @@ export async function submitBindingAsyncSend(
       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);
   }
@@ -156,7 +156,7 @@ export async function submitBindingRequest(
     if (timeoutMs !== undefined) {
       current = current.timeout(timeoutMs);
     }
-    return await current.submit();
+    return await current.submit().reply;
   } catch (error) {
     throw translateBindingResultError(error);
   }