@zlink-systems/framework 0.10.0 → 0.12.0

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

@@ -1,3 +1,4 @@
+import type { Socket } from '@zlink-systems/zlink';
 import type { ZLinkBackendObject } from '../contracts';
 import {
   closeWithBusyRetry,
@@ -17,14 +18,14 @@ import {
   type ZLinkBindingReplyOperation,
   type ZLinkBindingAsyncSendOperation
 } from './node-backend-adapter-support';
+import { ZLinkNodeEventLoopPoller } from './node-event-loop-poller';
 
+const eventLoopPollers = new WeakMap<object, ZLinkNodeEventLoopPoller>();
 
 export function wrapSocket<T extends { close(): void }>(
-  nativeInstance: T
+  nativeInstance: T,
+  pollCompletion?: boolean
 ): T & ZLinkBackendObject {
-  const boundEndpoints = new Set<string>();
-  const connectedEndpoints = new Set<string>();
-  const peerRoutingIds = new Set<unknown>();
   const socket = nativeInstance as T & {
     options?: {
       probe?: boolean;
@@ -40,32 +41,35 @@ export function wrapSocket<T extends { close(): void }>(
   const hasRoutedPeer = hasRequest
     && typeof (nativeInstance as { reply?: unknown }).reply === 'function';
   const hasStream = typeof (nativeInstance as { recvPacket?: unknown }).recvPacket === 'function';
+  const eventLoopPoller = pollCompletion === undefined
+    ? undefined
+    : new ZLinkNodeEventLoopPoller(
+      nativeInstance as unknown as Socket,
+      pollCompletion,
+      () => {}
+    );
   const adapter = {
     nativeInstance,
     async dispose(): Promise<void> {
+      eventLoopPoller?.dispose();
       disableSocketLinger(nativeInstance);
-      closeSocketRoutes(nativeInstance, peerRoutingIds);
-      closeSocketEndpoints(nativeInstance, boundEndpoints, connectedEndpoints);
       await closeWithBusyRetry(nativeInstance);
     },
     close(): void {
+      eventLoopPoller?.dispose();
       nativeInstance.close();
     },
     bind(endpoint: string): void {
       (nativeInstance as T & { bind(endpoint: string): void }).bind(endpoint);
-      boundEndpoints.add(endpoint);
     },
     unbind(endpoint: string): void {
       (nativeInstance as T & { unbind(endpoint: string): void }).unbind(endpoint);
-      boundEndpoints.delete(endpoint);
     },
     connect(endpoint: string): void {
       (nativeInstance as T & { connect(endpoint: string): void }).connect(endpoint);
-      connectedEndpoints.add(endpoint);
     },
     disconnect(endpoint: string): void {
       (nativeInstance as T & { disconnect(endpoint: string): void }).disconnect(endpoint);
-      connectedEndpoints.delete(endpoint);
     },
     setChannelName(channelName: string): void {
       const setChannelName = (nativeInstance as T & { setChannelName?: (value: string) => void }).setChannelName;
@@ -133,7 +137,6 @@ export function wrapSocket<T extends { close(): void }>(
     send(...args: unknown[]): unknown {
       if (hasStream) {
         const [routingId, payload] = args as [unknown, unknown];
-        peerRoutingIds.add(routingId);
         const operation = (nativeInstance as T & {
           send(routingId: unknown): ZLinkBindingAsyncSendOperation;
         }).send(toNativeRoutingId(routingId));
@@ -142,7 +145,6 @@ export function wrapSocket<T extends { close(): void }>(
       }
       if (hasRoutedPeer) {
         const [routingId, payload] = args as [unknown, unknown];
-        peerRoutingIds.add(routingId);
         return submitBindingAsyncSend(
           (nativeInstance as T & { send(routingId: unknown): ZLinkBindingAsyncSendOperation })
             .send(toNativeRoutingId(routingId)),
@@ -167,7 +169,6 @@ export function wrapSocket<T extends { close(): void }>(
     },
     submit(routingId: unknown, payload: unknown, _timeoutMs?: number): Promise<void> {
       if (!hasStream) throw new TypeError('Async stream send requires a STREAM socket.');
-      peerRoutingIds.add(routingId);
       return submitBindingAsyncSend(
         (nativeInstance as T & { send(routingId: unknown): ZLinkBindingAsyncSendOperation })
           .send(toNativeRoutingId(routingId)),
@@ -177,7 +178,6 @@ export function wrapSocket<T extends { close(): void }>(
     request(...args: unknown[]): unknown {
       if (hasRoutedPeer) {
         const [routingId, payload, timeoutMs] = args as [unknown, unknown, number | undefined];
-        peerRoutingIds.add(routingId);
         return submitBindingRequest(
           (nativeInstance as T & { request(routingId: unknown): ZLinkBindingRequestOperation })
             .request(toNativeRoutingId(routingId)),
@@ -197,7 +197,6 @@ export function wrapSocket<T extends { close(): void }>(
     },
     reply(...args: unknown[]): unknown {
       const [routingId, replyToken, payload] = args as [unknown, unknown, unknown];
-      peerRoutingIds.add(routingId);
       const operation = (nativeInstance as T & {
         reply(routingId: unknown, replyToken: unknown): ZLinkBindingReplyOperation;
       }).reply(toNativeRoutingId(routingId), replyToken);
@@ -287,9 +286,18 @@ export function wrapSocket<T extends { close(): void }>(
       return false;
     }
   };
+  if (eventLoopPoller !== undefined) eventLoopPollers.set(adapter, eventLoopPoller);
   return adapter as unknown as T & ZLinkBackendObject;
 }
 
+export function nodeEventLoopPollerOf(socket: object): ZLinkNodeEventLoopPoller {
+  const poller = eventLoopPollers.get(socket);
+  if (poller === undefined) {
+    throw new TypeError('Node backend socket does not own an event-loop poller.');
+  }
+  return poller;
+}
+
 export function disconnectStreamPeer(
   socket: { disconnectRid(routingId: unknown): void },
   routingId: unknown
@@ -310,60 +318,6 @@ function requireSocketOptions<TOptions>(socket: { readonly options?: TOptions })
   return socket.options;
 }
 
-function closeSocketRoutes(target: unknown, peerRoutingIds: Set<unknown>): void {
-  if (peerRoutingIds.size === 0 || !hasDisconnectRid(target)) {
-    return;
-  }
-  for (const routingId of peerRoutingIds) {
-    try {
-      target.disconnectRid(toNativeRoutingId(routingId));
-    } catch (error) {
-      if (!isDisconnectRouteNotFoundError(error)) {
-        throw error;
-      }
-    }
-    peerRoutingIds.delete(routingId);
-  }
-}
-
-export function isDisconnectRouteNotFoundError(error: unknown): boolean {
-  return isBindingNotFound(error) || isContextTerminatedError(error) || (
-    error instanceof Error && 'code' in error &&
-    ((error as { code: unknown }).code === zlink.ConnectResult.NotFound ||
-      (error as { code: unknown }).code === zlink.ConnectResult.Busy ||
-      ((error as { code: unknown }).code === zlink.ConnectResult.InternalError &&
-        /current state/i.test(error.message)))
-  );
-}
-
-function hasDisconnectRid(target: unknown): target is { disconnectRid(routingId: unknown): void } {
-  return target !== null && typeof target === 'object' && 'disconnectRid' in target &&
-    typeof (target as { disconnectRid: unknown }).disconnectRid === 'function';
-}
-
-function closeSocketEndpoints(target: unknown, boundEndpoints: Set<string>, connectedEndpoints: Set<string>): void {
-  for (const endpoint of connectedEndpoints) {
-    try {
-      (target as { disconnect(endpoint: string): void }).disconnect(endpoint);
-    } catch (error) {
-      if (!isEndpointCloseIgnorableError(error)) {
-        throw error;
-      }
-    }
-    connectedEndpoints.delete(endpoint);
-  }
-  for (const endpoint of boundEndpoints) {
-    try {
-      (target as { unbind(endpoint: string): void }).unbind(endpoint);
-    } catch (error) {
-      if (!isEndpointCloseIgnorableError(error)) {
-        throw error;
-      }
-    }
-    boundEndpoints.delete(endpoint);
-  }
-}
-
 export function isEndpointCloseIgnorableError(error: unknown): boolean {
   return isContextTerminatedError(error) || (
     error instanceof Error && 'code' in error &&

package/src/runtime/backend/raw-binding-port.ts

@@ -21,6 +21,7 @@ export interface ZLinkRawMonitorRecord {
 }
 
 export interface ZLinkRawSocketPort {
+  setReadableHandler(handler: () => void): void;
   bind(endpoint: string): void;
   unbind(endpoint: string): void;
   connect(endpoint: string): void;

package/src/runtime/backend/runtime-values.ts

@@ -68,10 +68,22 @@ export function isBackendNotConnectedError(error: unknown): boolean {
   const result = error.result;
   return result === SubmitResult.NotConnected || result === RequestResult.NotConnected;
 }
+
+export function isBackendRequestTimeoutError(error: unknown): boolean {
+  return isZLinkBackendResultError(error)
+    && error.operation === 'request'
+    && error.result === RequestResult.TimedOut;
+}
 export type ZLinkBackendMessageLike = Message | Buffer | Uint8Array | string;
+/** Binding의 SendSubmission과 구조적으로 호환된다. binding 타입을 import 하지 않는다. */
+export interface ZLinkBackendSendSubmission {
+  readonly admitted: Promise<void>;
+}
+
 export interface ZLinkBackendSendSubmitBuilder {
   message(message: ZLinkBackendMessageLike): ZLinkBackendSendSubmitBuilder;
-  submit(): Promise<void>;
+  // 제출 스냅샷을 그대로 돌려준다. admission을 기다리려면 .admitted를 await 한다.
+  submit(): ZLinkBackendSendSubmission;
 }
 
 export interface ZLinkBackendSendBuilder {

package/src/runtime/channels/channel-dispatchers.ts

@@ -115,7 +115,7 @@ export class ZLinkChannelRequestDispatcher {
       if (received.send === undefined) {
         throw new ZLinkConfigurationException('Routed SPOT packet is missing a local SPOT delivery context.');
       }
-      await appendParts(received.send(), received.parts).submit();
+      await appendParts(received.send(), received.parts).submit().admitted;
       return true;
     }
     if (received.parts.length === 0 || received.parts[0].data().length === 0) {
@@ -523,7 +523,7 @@ export class ZLinkRoutePacketDispatcher {
       if (received.send === undefined) {
         throw new ZLinkConfigurationException('Routed SPOT packet is missing a local SPOT delivery context.');
       }
-      return appendParts(received.send(), received.parts).submit();
+      return appendParts(received.send(), received.parts).submit().admitted;
     }
     return false;
   }