@zlink-systems/framework 0.11.0 → 0.13.0

package/src/runtime/backend/node/node-raw-mesh-backend.ts

@@ -1,4 +1,5 @@
 import { randomBytes } from 'node:crypto';
+import { setImmediate as yieldToIO } from 'node:timers/promises';
 import { disconnectStreamPeer } from './node-socket-backend-adapter';
 import { ZLinkFrameworkException } from '../../../contracts';
 import { internalFrameworkWireReply } from '../../framework-errors-internal';
@@ -17,6 +18,8 @@ import {
   ZLinkBackendResultError,
   type ZLinkBackendMessageLike as MessageLike
 } from '../runtime-values';
+import { ZLinkBufferMessage } from '../runtime-message';
+import type { Message as FrameworkMessage } from '../../../contracts/Common/Message';
 import type {
   MeshOperationId,
   MeshPeerEntry,
@@ -113,12 +116,9 @@ const MULTIPART_PACKET_NAME = SERVICE_FRAMEWORK_MULTIPART_PACKET_NAME;
 const MULTIPART_CONTENT_TYPE = SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE;
 const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
 const MAX_DRAIN_RECORDS = 64;
-// A timer is only a no-data backoff.  Once the binding has reported readable
-// work, continue from the next event-loop turn so a full socket does not wait
-// for an arbitrary timer cadence between batches.
-const MESH_BACKEND_IDLE_POLL_INTERVAL_MS = 1;
-const MESH_RECEIVE_BATCH_BYTE_LIMIT = 4 * 1024 * 1024;
-const MESH_RECEIVE_BATCH_TIME_LIMIT_MS = 2;
+// Preserve the existing monitor/admission/liveness cadence. Only the binding
+// readable handler admits receive work; this timer never probes the socket.
+const MESH_BACKEND_MAINTENANCE_INTERVAL_MS = 1;
 /**
  * Conservative Actor Join admission cap for relocation state chunks (spec 15
  * §4.2): a stable lower bound safe on any deployment, never lowered on
@@ -126,28 +126,6 @@ const MESH_RECEIVE_BATCH_TIME_LIMIT_MS = 2;
  */
 const ACTOR_JOIN_ADVERTISED_RECEIVE_CHUNK_LIMIT_BYTES = 32 * 1024;
 
-class ZLinkMeshReceiveBatchBudget {
-  private readonly peerMessages = new Map<string, number>();
-  private readonly peerBytes = new Map<string, number>();
-  private startedAtMs = 0;
-
-  reset(nowMs: number): void {
-    this.peerMessages.clear();
-    this.peerBytes.clear();
-    this.startedAtMs = nowMs;
-  }
-
-  record(peer: string, byteCount: number, nowMs: number): boolean {
-    const messages = (this.peerMessages.get(peer) ?? 0) + 1;
-    const bytes = (this.peerBytes.get(peer) ?? 0) + byteCount;
-    this.peerMessages.set(peer, messages);
-    this.peerBytes.set(peer, bytes);
-    return messages >= MAX_DRAIN_RECORDS
-      || bytes >= MESH_RECEIVE_BATCH_BYTE_LIMIT
-      || nowMs - this.startedAtMs >= MESH_RECEIVE_BATCH_TIME_LIMIT_MS;
-  }
-}
-
 /**
  * M6A MeshNode backend. Stateful Spot/Actor entry points stay explicit until
  * their owning M6B runtime is connected; topology and node/channel dispatch do
@@ -172,7 +150,17 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   private runtime?: RawServiceMeshRuntime;
   private stateful?: ServiceStatefulRuntime;
   private readyHandler?: (domains: number) => number;
-  private pollTimer?: NodeJS.Timeout;
+  private maintenanceTimer?: NodeJS.Timeout;
+  private pumping = false;
+  private readable = false;
+  private readonly onReadable = (): void => {
+    this.readable = true;
+    if (!this.closed && !this.pumping) void this.pump();
+  };
+  private readonly onMaintenance = (): void => {
+    this.maintenanceTimer = undefined;
+    void this.pump();
+  };
   private nextPeerIntent = 1n;
   private closed = false;
   private objectRole: ServiceNodeDescriptor['objectRole'] = 'none';
@@ -195,20 +183,6 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     record: import('../../foundation/service-stateful-wire-codec').ServiceMessageFollowRecord
   ) => void;
   private readonly peerDisconnectedHandlers = new Set<(endpoint: string) => void>();
-  private readonly receiveBatchBudget = new ZLinkMeshReceiveBatchBudget();
-  private observedPumpSourceRoutingId?: string;
-  private observedPumpByteCount = 0;
-  private readonly observePump = (sourceRoutingId: string, byteCount: number): void => {
-    this.observedPumpSourceRoutingId = sourceRoutingId;
-    this.observedPumpByteCount = byteCount;
-  };
-
-  private takePumpObservation(): { readonly sourceRoutingId: string; readonly byteCount: number } | undefined {
-    const sourceRoutingId = this.observedPumpSourceRoutingId;
-    if (sourceRoutingId === undefined) return undefined;
-    return { sourceRoutingId, byteCount: this.observedPumpByteCount };
-  }
-
   constructor(
     private readonly meshName: string,
     routingId: string | undefined,
@@ -414,7 +388,13 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     }
     this.stateful.setMessageFollowHandler((record) => this.messageFollowHandler?.(record));
     this.runtime = runtime;
-    this.schedulePoll();
+    try {
+      runtime.setReadableHandler(this.onReadable);
+    } catch (error) {
+      this.close();
+      throw error;
+    }
+    this.scheduleMaintenance();
   }
 
   setMessageFollowHandler(handler: (
@@ -446,8 +426,8 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   close(): void {
     if (this.closed) return;
     this.closed = true;
-    if (this.pollTimer !== undefined) clearTimeout(this.pollTimer);
-    this.pollTimer = undefined;
+    if (this.maintenanceTimer !== undefined) clearTimeout(this.maintenanceTimer);
+    this.maintenanceTimer = undefined;
     this.stateful?.close();
     this.stateful = undefined;
     this.runtime?.close();
@@ -614,7 +594,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   ): Promise<SubmitResultValue> {
     return await this.requireRuntime().sendToNode(
       String(targetRid),
-      encodeMultipart(parts)
+      encodeMultipartApplicationFrame(parts)
     ) ? SubmitResult.Ok : SubmitResult.NotConnected;
   }
 
@@ -657,7 +637,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   ): MeshOperationId {
     const pending = this.requireRuntime().requestToNode(
       String(targetRid),
-      encodeMultipart(parts),
+      encodeMultipartApplicationFrame(parts),
       options?.timeoutMs ?? 30_000
     );
     return this.observeCompletion(pending.id, OperationKind.NodeRequest, pending.promise);
@@ -669,7 +649,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   ): Promise<SubmitResultValue> {
     return await this.requireRuntime().sendToChannel(
       channelName,
-      encodeMultipart(parts)
+      encodeMultipartApplicationFrame(parts)
     ) ? SubmitResult.Ok : SubmitResult.NotConnected;
   }
 
@@ -680,7 +660,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
   ): MeshOperationId {
     const pending = this.requireRuntime().requestToChannel(
       channelName,
-      encodeMultipart(parts),
+      encodeMultipartApplicationFrame(parts),
       options?.timeoutMs ?? 30_000
     );
     if (pending === undefined) {
@@ -1501,49 +1481,39 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     return result;
   }
 
-  private schedulePoll(delayMs = MESH_BACKEND_IDLE_POLL_INTERVAL_MS): void {
-    if (this.closed || this.pollTimer !== undefined) return;
-    this.pollTimer = setTimeout(async () => {
-      this.pollTimer = undefined;
-      try {
-        const received = await this.poll();
-        // A zero-delay timer yields to I/O and other ready work first without
-        // inserting the idle polling interval between readable batches.
-        delayMs = received ? 0 : MESH_BACKEND_IDLE_POLL_INTERVAL_MS;
-      } finally {
-        if (!this.closed) this.schedulePoll(delayMs);
-      }
-    }, delayMs);
+  private scheduleMaintenance(): void {
+    if (this.closed || this.maintenanceTimer !== undefined) return;
+    this.maintenanceTimer = setTimeout(
+      this.onMaintenance,
+      MESH_BACKEND_MAINTENANCE_INTERVAL_MS
+    );
   }
 
-  private async poll(): Promise<boolean> {
-    const runtime = this.runtime;
-    if (runtime === undefined) return false;
-    let received = false;
-    await runtime.drainMonitorEvents();
-    this.receiveBatchBudget.reset(performance.now());
-    for (;;) {
-      this.observedPumpSourceRoutingId = undefined;
-      const result = await runtime.pumpOne(performance.now(), this.observePump);
-      if (result === 'noData') break;
-      received = true;
-      if (result === 'application') this.readyHandler?.(ReadyDomain.Application);
-      const observation = this.takePumpObservation();
-      // Core ROUTER advances its fair-queue cursor after each complete
-      // multipart message, so the next poll resumes from the following pipe.
-      if (
-        observation !== undefined
-        && this.receiveBatchBudget.record(
-          observation.sourceRoutingId,
-          observation.byteCount,
-          performance.now()
-        )
-      ) break;
+  private async pump(): Promise<void> {
+    if (this.isClosed() || this.pumping) return;
+    this.pumping = true;
+    if (this.maintenanceTimer !== undefined) clearTimeout(this.maintenanceTimer);
+    this.maintenanceTimer = undefined;
+    try {
+      do {
+        const receiveReady = this.readable;
+        this.readable = false;
+        const more = await this.requireRuntime().pumpBatch(receiveReady);
+        if (more) {
+          // Yield only after actual progress, retaining readiness across the
+          // existing batch limits until receive reports no data.
+          this.readable = true;
+          await yieldToIO();
+        }
+      } while (!this.closed && this.readable);
+    } finally {
+      this.pumping = false;
+      this.scheduleMaintenance();
     }
-    await runtime.announceExpectedPeers();
-    await runtime.tickLiveness();
-    this.notifyReady();
-    return received;
+  }
+
+  private isClosed(): boolean {
+    return this.closed;
   }
 
   private notifyReady(): void {
@@ -1654,16 +1624,7 @@ export class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
       const owner = readyOwner(claim.owner, this.routingId, this.stateful, domain);
       batch.push(
         owner,
-        new MailboxClaim(runtime, claim, () => {
-          // A receive batch may intentionally consume fewer records than the
-          // mailbox claim. Releasing the claim re-queues the remainder, so
-          // expose that newly ready work to the dispatch pump.
-          if (runtime.mailbox.pendingMessages(domain) > 0) {
-            this.readyHandler?.(
-              domain === 'infrastructure' ? ReadyDomain.Infrastructure : ReadyDomain.Application
-            );
-          }
-        })
+        new MailboxClaim(runtime, claim)
       );
     }
   }
@@ -2013,7 +1974,7 @@ class RawStreamSessionService implements StreamSessionService {
       submit = submit.message(parts[index]!);
     }
     try {
-      await submit.submit();
+      await submit.submit().admitted;
       return true;
     } catch (error) {
       if (!(error instanceof SubmitError)) throw error;
@@ -2087,16 +2048,28 @@ class RawReadyBatch implements ReadyBatch {
 }
 
 class RawReceiveBatch implements ReceiveBatch {
+  private receiveCapacity: number;
+
   constructor(
-    readonly messageCapacity: number,
+    private readonly capacity: number,
     readonly partCapacity: number
   ) {
-    if ([messageCapacity, partCapacity].some(value => !Number.isInteger(value) || value < 1)) {
+    if ([capacity, partCapacity].some(value => !Number.isInteger(value) || value < 1)) {
       throw new RangeError('Receive batch capacities must be positive.');
     }
+    this.receiveCapacity = capacity;
   }
 
-  reset(): void {}
+  get messageCapacity(): number {
+    return this.receiveCapacity;
+  }
+
+  reset(messageCapacity = this.capacity): void {
+    if (!Number.isInteger(messageCapacity) || messageCapacity < 1 || messageCapacity > this.capacity) {
+      throw new RangeError('Receive limit must be within the batch capacity.');
+    }
+    this.receiveCapacity = messageCapacity;
+  }
   close(): void {}
 }
 
@@ -2107,8 +2080,7 @@ class MailboxClaim implements RawClaim {
 
   constructor(
     private readonly runtime: RawServiceMeshRuntime,
-    private readonly claim: ServiceMailboxClaim,
-    private readonly onRelease?: () => void
+    private readonly claim: ServiceMailboxClaim
   ) {}
 
   recvBatch(batch: ReceiveBatch) {
@@ -2130,6 +2102,12 @@ class MailboxClaim implements RawClaim {
         }
         this.runtime.mailbox.releaseClaimedPayload(record);
         this.remaining = this.claim.records.slice(index + 1);
+        // Nothing was transferred to the receive caller when decoding throws.
+        // Earlier records therefore still belong to this failed batch.
+        for (const decoded of records) {
+          for (const part of decoded.parts) part.close();
+          decoded.releaseRetainedIngress?.();
+        }
         throw error;
       }
       const nextParts = decoded.parts.length;
@@ -2152,7 +2130,6 @@ class MailboxClaim implements RawClaim {
     if (this.released) return;
     this.released = true;
     this.runtime.mailbox.release(this.claim, this.remaining);
-    this.onRelease?.();
   }
 }
 
@@ -2297,7 +2274,7 @@ function decodeMultipartRecord(
     parts: decodeMultipart(application.payload),
     reply(parts) {
       if (record.correlation === undefined) return SubmitResult.InvalidState;
-      runtime.reply(record, encodeMultipart(parts));
+      runtime.reply(record, encodeMultipartApplicationFrame(parts));
       return SubmitResult.Ok;
     },
     replyActorJoin: () => SubmitResult.NotSupported
@@ -2585,9 +2562,19 @@ function decodeApplicationEnvelope(frame: Uint8Array) {
   return { packetName, contentType, payload: bytes.subarray(offset) };
 }
 
-function decodeMultipart(payload: Uint8Array): Message[] {
+function decodeMultipart(payload: Uint8Array): FrameworkMessage[] {
   const buffers = decodeMultipartBuffers(payload);
-  return buffers.map(part => Message.from(part));
+  const parts = new Array<FrameworkMessage>(buffers.length);
+  let materialized = 0;
+  try {
+    for (; materialized < buffers.length; materialized += 1) {
+      parts[materialized] = ZLinkBufferMessage.fromOwned(buffers[materialized]!);
+    }
+    return parts;
+  } catch (error) {
+    for (let index = 0; index < materialized; index += 1) parts[index]!.close();
+    throw error;
+  }
 }
 
 function decodeMultipartBuffers(payload: Uint8Array): Buffer[] {

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

@@ -75,9 +75,15 @@ export function isBackendRequestTimeoutError(error: unknown): boolean {
     && 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;
   }