@zlink-systems/framework 0.26.0 → 0.27.0

package/src/runtime/admission.ts

@@ -2,6 +2,13 @@ import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
 } from './framework-errors-internal';
+const BACKING_ARRAY_COMPACTION_MIN_HEAD = 1024;
+
+/** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
+export function shouldCompactBackingArray(head: number, length: number): boolean {
+  return head >= BACKING_ARRAY_COMPACTION_MIN_HEAD && head * 2 >= length;
+}
+
 export class ZLinkRuntimeAdmissionGate {
   private readonly meshes = new Map<string, ZLinkMeshAdmissionState>();
 
@@ -192,7 +199,7 @@ function compactWaiters(state: ZLinkMeshAdmissionState): void {
   if (state.waiterCount === 0) {
     state.waiters.length = 0;
     state.waiterHead = 0;
-  } else if (state.waiterHead >= 1024 && state.waiterHead * 2 >= state.waiters.length) {
+  } else if (shouldCompactBackingArray(state.waiterHead, state.waiters.length)) {
     state.waiters.splice(0, state.waiterHead);
     state.waiterHead = 0;
   }

package/src/runtime/application-jobs/application-job-queue-scope.ts

@@ -43,12 +43,12 @@ export function hasApplicationJobPermit(): boolean {
 }
 
 /** Re-enters the captured permit scope when a serial executor runs later. */
-export function bindApplicationJobPermit<TResult>(
-  callback: () => Promise<TResult> | TResult
-): () => Promise<TResult> | TResult {
+export function bindApplicationJobPermit<TResult, TArgument>(
+  callback: (argument?: TArgument) => Promise<TResult> | TResult
+): (argument?: TArgument) => Promise<TResult> | TResult {
   const scope = applicationJobPermitScope.getStore();
   if (scope === undefined) return callback;
-  return () => applicationJobPermitScope.run(scope, callback);
+  return (argument?: TArgument) => applicationJobPermitScope.run(scope, callback, argument);
 }
 
 /**

package/src/runtime/backend/contracts/index.ts

@@ -141,14 +141,16 @@ export interface ZLinkBackendMeshNode {
     route: ServiceInstanceRouteFence,
     parts: MessageLike | readonly MessageLike[],
     sourceSpotId?: string,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    instanceIntent?: boolean
   ): Promise<SubmitResult>;
   requestInstanceSpot(
     route: ServiceInstanceRouteFence,
     parts: MessageLike | readonly MessageLike[],
     timeoutMs?: number,
     sourceSpotId?: string,
-    metadata?: ReadonlyMap<string, string>
+    metadata?: ReadonlyMap<string, string>,
+    instanceIntent?: boolean
   ): MeshOperationId;
   registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
   requestUserSpotCreate(
@@ -249,6 +251,12 @@ export interface ZLinkBackendMeshNode {
         readonly objectGeneration: bigint;
       }
     | undefined;
+  registerInstanceIntent?(
+    instanceType: string,
+    route: import('../../foundation/service-stateful-wire-codec').ServiceInstanceRouteFence,
+    expectedCurrentRoute?:
+      import('../../foundation/service-stateful-wire-codec').ServiceInstanceRouteFence | null
+  ): void;
   waitForInstanceApplicationQuiescence?(spotId: string, signal?: AbortSignal): Promise<void>;
   restoreUserSpotAuthority?(
     spotId: string,
@@ -269,7 +277,7 @@ export interface ZLinkBackendMeshNode {
     stableType: string,
     generation: bigint,
     authorityOwnerGeneration: bigint,
-    spotId: string,
+    spotId: string | undefined,
     spotGeneration: bigint,
     membershipEpoch: bigint
   ): ZLinkBackendActorRef;
@@ -435,27 +443,6 @@ export interface ZLinkBackendActorRecvInfo {
   readonly flags: number;
 }
 
-export interface ZLinkBackendActorJoinInfo {
-  readonly sourceActor: ZLinkBackendActorRef;
-  readonly targetActor: ZLinkBackendActorRef;
-  readonly sourceNodeRid: RoutingId;
-  readonly sourceSpotId: RoutingId;
-  readonly targetNodeRid: RoutingId;
-  readonly targetSpotId: RoutingId;
-  readonly joinEpoch: bigint;
-  readonly flags: number;
-}
-
-export interface ZLinkBackendActorJoinRequest {
-  readonly info: ZLinkBackendActorJoinInfo;
-  readonly message: Message;
-}
-
-export interface ZLinkBackendActorJoinReplyOperation {
-  message(message: Message): ZLinkBackendActorJoinReplyOperation;
-  submit(): void;
-}
-
 export interface ZLinkBackendSpotDispatchInfo {
   readonly event: ZLinkBackendSpotDispatchEvent;
   readonly subjectKind?: number;
@@ -465,6 +452,7 @@ export interface ZLinkBackendSpotDispatchInfo {
 
 export interface ZLinkBackendSocketMonitorEvent {
   readonly nativeEvent: MonitorEventType;
+  readonly readyEdge: boolean;
   readonly routingId?: unknown;
   readonly localAddr: string;
   readonly remoteAddr: string;
@@ -563,6 +551,7 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
 }
 
 export interface ZLinkBackendPublisherSocket extends ZLinkBackendSocket {
+  sendTimeoutMs: number;
   sendHighWaterMark: number;
   noDrop: boolean;
   publish(topic: string, message: Message | readonly Message[]): void;
@@ -734,11 +723,6 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     payload: Message | readonly Message[],
     timeoutMs?: number
   ): Promise<readonly Message[]>;
-  recvActorJoin(flags: ZLinkBackendRecvFlags): ZLinkBackendActorJoinRequest | null;
-  replyActorJoin(
-    request: ZLinkBackendActorJoinRequest,
-    joinResultCode: number
-  ): ZLinkBackendActorJoinReplyOperation;
   dispose(): Promise<void>;
 }
 

package/src/runtime/backend/mesh-actor-session-node-adapter.ts

@@ -1,5 +1,4 @@
-import { SubmitResult } from './runtime-values';
-import { ZLinkSubmitStatus } from '../messaging/submission-result';
+import { classifySubmitResult } from '../messaging/submission-result';
 import type { ZLinkBackendActorSessionNode, ZLinkBackendMeshNode } from './contracts';
 import { closeMeshCompletion, type ZLinkMeshCompletionTable } from './mesh-completion-table';
 
@@ -15,22 +14,7 @@ export function meshActorSessionNodeAdapter(
         parts as never,
         flags
       );
-      switch (result) {
-        case SubmitResult.Ok:
-          return { status: ZLinkSubmitStatus.Submitted };
-        case SubmitResult.Backpressured:
-        case SubmitResult.NotAdmitted:
-          return { status: ZLinkSubmitStatus.Backpressured };
-        case SubmitResult.NotFound:
-        case SubmitResult.InvalidState:
-          return { status: ZLinkSubmitStatus.TargetNotFound };
-        case SubmitResult.NotConnected:
-          return { status: ZLinkSubmitStatus.RouteNotConnected };
-        case SubmitResult.Terminated:
-          return { status: ZLinkSubmitStatus.Shutdown };
-        default:
-          throw new Error(`Actor bound-session send failed with result '${result}'.`);
-      }
+      return classifySubmitResult(result, 'Actor bound-session send');
     },
     async closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs, signal) {
       if (completions === undefined) {

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

@@ -1,6 +1,11 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { availableParallelism } from 'node:os';
-import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
+import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
+import type {
+  ApplicationJobPermitPort,
+  ApplicationJobQueuePort
+} from '../application-jobs/contracts';
+import { runZLinkExecutionArea } from '../execution';
 import {
   ReadyDomain,
   type ReadyBatch,
@@ -8,13 +13,20 @@ import {
   type ReceiveBatch,
   type ReceiveRecord
 } from '../foundation/service-runtime-contracts';
+import {
+  SERVICE_WIRE_COMMAND_OFFSET,
+  SERVICE_WIRE_MAJOR_OFFSET,
+  SERVICE_WIRE_PREFIX_SIZE
+} from '../foundation/service-wire-binary-primitives';
+import {
+  SERVICE_WIRE_MAGIC,
+  SERVICE_WIRE_MAJOR
+} from '../foundation/service-wire-constants.generated';
 import type { ZLinkBackendMeshNode } from './contracts';
-import { runZLinkExecutionArea } from '../execution';
-import type {
-  ApplicationJobPermitPort,
-  ApplicationJobQueuePort
-} from '../application-jobs/contracts';
-import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
+import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
+const DEFAULT_MESH_READY_CAPACITY = 32;
+
+const DEFAULT_MESH_PART_CAPACITY = 256;
 
 const MESH_DISPATCH_YIELD_RECORDS = 16;
 const MESH_DISPATCH_YIELD_INTERVAL_MS = 2;
@@ -45,21 +57,10 @@ export interface ZLinkMeshDispatchFailureContext {
   readonly commandId?: number;
 }
 
-class ZLinkMeshDispatchFailure extends Error {
-  constructor(
-    readonly context: ZLinkMeshDispatchFailureContext,
-    readonly dispatchCause: unknown
-  ) {
-    super('Mesh record dispatch failed.', { cause: dispatchCause });
-    this.name = 'ZLinkMeshDispatchFailure';
-  }
-}
-
 export class ZLinkMeshDispatchPump {
   private pendingDomains: number = ReadyDomain.None;
   private infrastructureScheduled = false;
   private disposed = false;
-  private infrastructureDrainPromise?: Promise<void>;
   private readonly activeDrains = new Set<Promise<void>>();
   private readonly idleApplicationWorkers = new Set<() => void>();
   private applicationWorkerCount = 0;
@@ -152,7 +153,7 @@ export class ZLinkMeshDispatchPump {
     const readyBatch = this.node.createReadyBatch(1);
     const receiveBatch = this.node.createReceiveBatch(
       MESH_DISPATCH_RECEIVE_CAPACITY,
-      this.options.partCapacity ?? 256
+      this.options.partCapacity ?? DEFAULT_MESH_PART_CAPACITY
     );
     try {
       for (;;) {
@@ -179,12 +180,8 @@ export class ZLinkMeshDispatchPump {
     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);
+  private reportDispatchError(error: unknown, context?: ZLinkMeshDispatchFailureContext): void {
+    this.options.reportError?.(error, context);
   }
 
   /**
@@ -205,34 +202,23 @@ export class ZLinkMeshDispatchPump {
           runZLinkExecutionArea('infrastructure', () => this.drainInfrastructure())
         )
       )
-      .catch((error) => {
-        if (error instanceof ZLinkMeshDispatchFailure) {
-          this.options.reportError?.(error.dispatchCause, error.context);
-          return;
-        }
-        this.options.reportError?.(error);
-      });
+      .catch((error) => this.reportDispatchError(error));
     this.activeDrains.add(drain);
-    this.infrastructureDrainPromise = drain;
     void drain.finally(() => {
       this.activeDrains.delete(drain);
-      if (this.infrastructureDrainPromise === drain) {
-        this.infrastructureDrainPromise = undefined;
-        this.infrastructureScheduled = false;
-        if (!this.disposed && (this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
-          this.scheduleInfrastructure();
-        }
+      this.infrastructureScheduled = false;
+      if (!this.disposed && (this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
+        this.scheduleInfrastructure();
       }
     });
   }
 
   private async drainInfrastructure(): Promise<void> {
     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
+      Math.min(
+        this.options.readyCapacity ?? DEFAULT_MESH_READY_CAPACITY,
+        MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
+      )
     );
     try {
       while (!this.disposed) {
@@ -246,7 +232,7 @@ export class ZLinkMeshDispatchPump {
         const lifecycleBudgetExhausted = await this.drainDomain(
           ReadyDomain.Infrastructure,
           readyBatch,
-          receiveBatch,
+          undefined,
           MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
         );
         if (lifecycleBudgetExhausted) {
@@ -255,7 +241,6 @@ export class ZLinkMeshDispatchPump {
         }
       }
     } finally {
-      receiveBatch.close();
       readyBatch.close();
     }
   }
@@ -263,7 +248,7 @@ export class ZLinkMeshDispatchPump {
   private async drainDomain(
     domain: number,
     readyBatch: ReadyBatch,
-    receiveBatch: ReceiveBatch,
+    receiveBatch: ReceiveBatch | undefined,
     claimBudget?: number
   ): Promise<boolean> {
     let claimsDrained = 0;
@@ -285,85 +270,91 @@ export class ZLinkMeshDispatchPump {
         for (let index = 0; index < drained.records.length; index += 1) {
           const claim = readyBatch.takeClaim(index);
           claimsDrained += 1;
-          const owner = drained.records[index];
+          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 {
-            const capacity =
-              owner.ordinaryIngressPreAdmitted === true ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
-            for (;;) {
-              let claimPermit =
-                owner.terminalCompletion === true ||
-                owner.ordinaryIngressPreAdmitted === true ||
-                domain === ReadyDomain.Infrastructure
-                  ? undefined
-                  : await this.acquirePermit();
-              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();
-                  }
-                }
+          const drainClaim = async () => {
+            let ownerReceiveBatch = receiveBatch;
+            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 === ReadyDomain.Infrastructure
+                    ? undefined
+                    : await this.acquirePermit();
                 try {
-                  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) {
-                        throw new ZLinkMeshDispatchFailure(
-                          meshDispatchFailureContext(record),
-                          error
+                  if (this.capacityStop.signal.aborted) return;
+                  ownerReceiveBatch.reset(capacity);
+                  const received = claim.recvBatch(ownerReceiveBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
+                  if (!received.ok) break;
+                  // This owner keeps its claim while it drains, so its records stay in FIFO order.
+                  try {
+                    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.'
                         );
                       }
-                      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);
+                      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();
+                      } 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);
+                      }
+                      const yieldTurn = this.yieldIfNeeded();
+                      if (yieldTurn !== undefined) await yieldTurn;
+                    }
+                  } finally {
+                    // 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?.();
                     }
-                    const yieldTurn = this.yieldIfNeeded();
-                    if (yieldTurn !== undefined) await yieldTurn;
                   }
                 } finally {
-                  // 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?.();
-                  }
+                  claimPermit?.releaseAfterInternalProcessing();
                 }
-              } finally {
-                claimPermit?.releaseAfterInternalProcessing();
               }
+            } finally {
+              claim.release();
+              if (receiveBatch === undefined) ownerReceiveBatch?.close();
             }
-          } finally {
-            claim.release();
+          };
+          // An application worker drains the one owner it claimed. Infrastructure owners
+          // drain independently, so a suspended owner does not hold the other claims.
+          if (receiveBatch !== undefined) {
+            await drainClaim();
+          } else {
+            const drain = drainClaim().catch((error) => this.reportDispatchError(error));
+            this.activeDrains.add(drain);
+            void drain.finally(() => this.activeDrains.delete(drain));
           }
         }
         if (claimBudget !== undefined && claimsDrained >= claimBudget) {
@@ -425,8 +416,11 @@ function meshDispatchFailureContext(record: ReceiveRecord): ZLinkMeshDispatchFai
 function serviceWireCommand(record: ReceiveRecord): number | undefined {
   if (record.parts.length !== 1) return undefined;
   const bytes = record.parts[0]!.data();
-  return bytes.byteLength >= 5 && bytes[0] === 0x5a && bytes[1] === 0x4d && bytes[2] === 1
-    ? bytes[3]
+  return bytes.byteLength >= SERVICE_WIRE_PREFIX_SIZE &&
+    bytes[0] === SERVICE_WIRE_MAGIC[0] &&
+    bytes[1] === SERVICE_WIRE_MAGIC[1] &&
+    bytes[SERVICE_WIRE_MAJOR_OFFSET] === SERVICE_WIRE_MAJOR
+    ? bytes[SERVICE_WIRE_COMMAND_OFFSET]
     : undefined;
 }
 

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

@@ -1,6 +1,8 @@
+import { constants as osConstants } from 'node:os';
+import { requireOneWayCompletion, ZLinkSubmitStatus } from '../../messaging/submission-result';
 import { loadBinding } from '../node-backend-adapter';
 import { SubmitResult, ZLinkBackendResultError } from '../runtime-values';
-import { requireOneWayCompletion, ZLinkSubmitStatus } from '../../messaging/submission-result';
+const nativeErrnoValues = osConstants.errno;
 
 export type ZLinkBindingModule = typeof import('@zlink-systems/zlink');
 export const zlink = loadBinding() as ZLinkBindingModule;
@@ -46,7 +48,7 @@ interface ZLinkBindingRequestSubmitOperation {
 }
 
 export function isBindingNotFound(error: unknown): boolean {
-  return error instanceof zlink.ConfigError && error.result === zlink.ConfigResult.NotFound;
+  return error instanceof zlink.ConnectError && error.result === zlink.ConnectResult.NotFound;
 }
 
 function isNonBlockingRecvEmpty(error: unknown): boolean {
@@ -64,7 +66,10 @@ export function isRouteRecvRetryable(error: unknown): boolean {
 }
 
 function isNativeBadAddress(error: { nativeErrno?: unknown; message?: unknown }): boolean {
-  return error.nativeErrno === 14 || /Bad address/i.test(String(error.message ?? ''));
+  return (
+    error.nativeErrno === nativeErrnoValues.EFAULT ||
+    /Bad address/i.test(String(error.message ?? ''))
+  );
 }
 
 export function submitBindingPublish(
@@ -189,7 +194,13 @@ function isSuccessfulOrAlreadyShutdownCloseError(error: unknown): boolean {
     isContextTerminatedError(error) ||
     (error instanceof Error &&
       'code' in error &&
-      [0, 402, 403].includes((error as { code: number }).code))
+      (
+        [
+          zlink.CloseResult.Ok,
+          zlink.CloseResult.Shutdown,
+          zlink.CloseResult.InvalidHandle
+        ] as readonly number[]
+      ).includes((error as { code: number }).code))
   );
 }
 
@@ -239,9 +250,15 @@ function toNativeMessageLike(message: unknown): unknown {
   return message;
 }
 
-export function translateBindingResultError(error: unknown): unknown {
+export function translateBindingResultError(
+  error: unknown,
+  phase: 'submit' | 'completion' = 'completion'
+): unknown {
   if (error instanceof zlink.SubmitError) {
-    return new ZLinkBackendResultError('submit', error.result, error.nativeErrno, { cause: error });
+    return new ZLinkBackendResultError('submit', error.result, error.nativeErrno, {
+      cause: error,
+      phase
+    });
   }
   if (error instanceof zlink.RequestError) {
     return new ZLinkBackendResultError('request', error.result, error.nativeErrno, {

package/src/runtime/backend/node/node-event-loop-poller.ts

@@ -9,13 +9,13 @@ import { zlink } from './node-backend-adapter-support';
 export class ZLinkNodeEventLoopPoller {
   private readonly poller = zlink.createPoller();
   private readonly events = zlink.createPollEvents(1);
-  private readableHandler: () => void;
+  private readableHandler: (receiveReady: boolean, routeReady: boolean) => void;
   private disposed = false;
 
   constructor(
     socket: Socket,
     pollCompletion: boolean,
-    readableHandler: () => void,
+    readableHandler: (receiveReady: boolean, routeReady: boolean) => void,
     pollRoute = false
   ) {
     this.readableHandler = readableHandler;
@@ -34,26 +34,22 @@ export class ZLinkNodeEventLoopPoller {
     }
   }
 
-  setReadableHandler(handler: () => void): void {
+  setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean) => void): void {
     this.readableHandler = handler;
   }
 
   dispose(): void {
     if (this.disposed) return;
-    this.disposed = true;
-    this.events.close();
     this.poller.close();
+    this.events.close();
+    this.disposed = true;
   }
 
   private readonly onReady = (): void => {
     if (this.disposed) return;
     const ready = this.poller.wait(this.events, 0);
-    if (
-      ready === 0 ||
-      this.events.hasEvent(0, zlink.PollEventFlag.PollIn) ||
-      this.events.hasEvent(0, zlink.PollEventFlag.PollRoute)
-    ) {
-      this.readableHandler();
-    }
+    const receiveReady = ready === 0 || this.events.hasEvent(0, zlink.PollEventFlag.PollIn);
+    const routeReady = ready > 0 && this.events.hasEvent(0, zlink.PollEventFlag.PollRoute);
+    if (receiveReady || routeReady) this.readableHandler(receiveReady, routeReady);
   };
 }

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

@@ -32,6 +32,7 @@ export function wrapMonitorSocket(nativeInstance: {
 function toBackendMonitorEvent(event: MonitorEvent): ZLinkBackendSocketMonitorEvent {
   return {
     nativeEvent: event.event,
+    readyEdge: (event.flags & zlink.MonitorEventFlag.ConnectionReadyEdge) !== 0,
     routingId: event.routingId ?? undefined,
     localAddr: event.localAddr,
     remoteAddr: event.remoteAddr,