@zlink-systems/framework 0.30.3 → 0.32.0

package/src/runtime/backend/node/node-dealer-channel-client-transport.ts

@@ -1,3 +1,10 @@
+import { RequestRuntime } from '../../foundation/request-runtime';
+import {
+  prepareZLinkRequestReply,
+  identityRequestReply,
+  rejectZLinkRequestReply,
+  type ZLinkRequestResult
+} from '../../messaging/request-result';
 import { bindingRequestReply } from './node-backend-adapter-support';
 import type { DealerSocket, Message, PubSocket } from '@zlink-systems/zlink';
 import { ZLinkConfigurationException } from '../../configuration';
@@ -8,7 +15,7 @@ import {
   ZLinkChannelMessageKind
 } from '../../channels/channel-envelope';
 import { throwIfAborted } from '../../abort';
-import { appendParts, submitRequestOperation } from '../../channels/channel-multipart';
+import { appendParts, mapRequestFailure } from '../../channels/channel-multipart';
 import type { ZLinkChannelClientTransport } from '../../channels/channel-transports';
 import { runWithOutboundFlow } from '../../diagnostics/flow-context';
 
@@ -18,7 +25,8 @@ const EMPTY_METADATA: ReadonlyMap<string, string> = new Map();
 export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTransport {
   constructor(
     private readonly dealer: DealerSocket,
-    private readonly publisher?: PubSocket
+    private readonly publisher?: PubSocket,
+    private readonly requests = new RequestRuntime()
   ) {}
 
   async send(
@@ -51,7 +59,7 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     return { status: ZLinkSubmitStatus.Submitted };
   }
 
-  async request<TReply>(
+  request<TReply>(
     channelName: string,
     packetName: string | undefined,
     request: Message,
@@ -59,42 +67,87 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     signal?: AbortSignal,
     metadata: ReadonlyMap<string, string> = EMPTY_METADATA,
     onAdmitted?: () => void
-  ): Promise<TReply> {
-    throwIfAborted(signal);
-    const operation = runWithOutboundFlow(true, () =>
-      appendParts(
-        this.dealer.request(),
-        encodeChannelEnvelopeParts(
-          ZLinkChannelMessageKind.Request,
-          channelName,
-          packetName,
-          request,
-          timeoutMs,
-          undefined,
-          undefined,
-          undefined,
-          true,
-          metadata
+  ): ZLinkRequestResult<TReply> {
+    try {
+      throwIfAborted(signal);
+    } catch (error) {
+      return rejectZLinkRequestReply(error);
+    }
+    const requestOperation = this.requests.begin(timeoutMs, signal);
+    try {
+      throwIfAborted(signal);
+      const operation = runWithOutboundFlow(true, () =>
+        appendParts(
+          this.dealer.request(),
+          encodeChannelEnvelopeParts(
+            ZLinkChannelMessageKind.Request,
+            channelName,
+            packetName,
+            request,
+            timeoutMs,
+            undefined,
+            undefined,
+            undefined,
+            true,
+            metadata
+          )
         )
-      )
-    );
-    if (timeoutMs !== undefined) operation.timeout(timeoutMs);
-    const reply = await submitRequestOperation(
-      {
-        submit: () =>
+      );
+      if (timeoutMs !== undefined) operation.timeout(timeoutMs);
+      const decode = (raw: unknown): TReply => {
+        const reply = raw as readonly Message[];
+        try {
+          return decodeChannelReply<TReply>(reply);
+        } finally {
+          closeReply(reply);
+        }
+      };
+      requestOperation.mapCaller(decode, identityRequestReply);
+      if (requestOperation.isPending()) {
+        const receiver = {
+          operationCompleted: (_id: bigint, raw: unknown) => {
+            if (requestOperation.complete(raw)) return;
+            try {
+              requestOperation.resolveCaller(decode(raw));
+            } catch (error) {
+              requestOperation.rejectCaller(error);
+            }
+          },
+          operationFailed: (_id: bigint, error: unknown) => {
+            let failure = error;
+            try {
+              failure = mapRequestFailure(error, 'channel request');
+            } catch (mapped) {
+              failure = mapped;
+            }
+            requestOperation.fail(failure);
+          }
+        };
+        try {
           bindingRequestReply(
             operation.submit(),
-            timeoutMs === undefined ? undefined : performance.now() + timeoutMs,
+            receiver,
+            requestOperation,
             undefined,
             onAdmitted
-          )
-      },
-      'channel request'
-    );
-    try {
-      return decodeChannelReply<TReply>(reply);
-    } finally {
-      for (const part of reply) part.close();
+          );
+        } catch (error) {
+          receiver.operationFailed(requestOperation.id, error);
+        }
+      }
+      return {
+        pending: requestOperation.promise,
+        decode: identityRequestReply<TReply>,
+        mapFailure: identityRequestReply,
+        operation:
+          requestOperation as import('../../foundation/operation-registry').PendingOperation<TReply>
+      };
+    } catch (error) {
+      requestOperation.fail(error);
+      return prepareZLinkRequestReply(
+        requestOperation.promise as Promise<TReply>,
+        identityRequestReply
+      );
     }
   }
 
@@ -140,3 +193,7 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     return this.tryPublish(channelName, topic, packetName, event, metadata);
   }
 }
+
+function closeReply(parts: readonly { close(): void }[]): void {
+  for (const part of parts) part.close();
+}

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

@@ -9,13 +9,17 @@ import { zlink } from './node-backend-adapter-support';
 export class ZLinkNodeEventLoopPoller {
   private readonly poller = zlink.createPoller();
   private readonly events = zlink.createPollEvents(1);
-  private readableHandler: (receiveReady: boolean, routeReady: boolean) => void;
+  private readableHandler: (
+    receiveReady: boolean,
+    routeReady: boolean,
+    connectReady: boolean
+  ) => void;
   private disposed = false;
 
   constructor(
     socket: Socket,
     pollCompletion: boolean,
-    readableHandler: (receiveReady: boolean, routeReady: boolean) => void,
+    readableHandler: (receiveReady: boolean, routeReady: boolean, connectReady: boolean) => void,
     pollRoute = false
   ) {
     this.readableHandler = readableHandler;
@@ -24,7 +28,8 @@ export class ZLinkNodeEventLoopPoller {
       if (pollCompletion) pollEvents.push(zlink.PollEventFlag.PollCompletion);
       // A ROUTER selected-route change (Core ROUTER §10.1) wakes the same
       // handler, whose owner is the socket's one route observer.
-      if (pollRoute) pollEvents.push(zlink.PollEventFlag.PollRoute);
+      if (pollRoute)
+        pollEvents.push(zlink.PollEventFlag.PollRoute, zlink.PollEventFlag.PollConnect);
       this.poller.add(socket as BaseSocket, pollEvents, 0);
       socket.setReadableHandler(this.onReady);
     } catch (error) {
@@ -34,7 +39,9 @@ export class ZLinkNodeEventLoopPoller {
     }
   }
 
-  setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean) => void): void {
+  setReadableHandler(
+    handler: (receiveReady: boolean, routeReady: boolean, connectReady: boolean) => void
+  ): void {
     this.readableHandler = handler;
   }
 
@@ -50,6 +57,8 @@ export class ZLinkNodeEventLoopPoller {
     const ready = this.poller.wait(this.events, 0);
     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);
+    const connectReady = ready > 0 && this.events.hasEvent(0, zlink.PollEventFlag.PollConnect);
+    if (receiveReady || routeReady || connectReady)
+      this.readableHandler(receiveReady, routeReady, connectReady);
   };
 }

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

@@ -26,7 +26,11 @@ export class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
     return new ZLinkNodeRawMeshBackend(
       options.meshName,
       options.routingId,
-      new ZLinkNodeRawBindingPort(bindingContext, options.receiveTimeoutMs),
+      new ZLinkNodeRawBindingPort(bindingContext, {
+        sendHighWaterMark: options.sendHighWaterMark,
+        receiveHighWaterMark: options.receiveHighWaterMark,
+        receiveTimeoutMs: options.receiveTimeoutMs
+      }),
       options.applicationJobQueue,
       options.applicationJobReceiveFlowFailureSink,
       options.peerAdmissionSealed,

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

@@ -1,3 +1,6 @@
+import { RequestRuntime } from '../../foundation/request-runtime';
+import type { OperationHandle } from '../../foundation/operation-registry';
+import { remainingRequestTimeout } from '../../messaging/request-deadline';
 import {
   Message,
   Received,
@@ -21,7 +24,6 @@ import {
 } from '@zlink-systems/zlink';
 import {
   translateBindingResultError,
-  bindingRequestReply,
   submitBindingAsyncSend,
   submitBindingSend
 } from './node-backend-adapter-support';
@@ -40,6 +42,13 @@ import type {
   ZLinkRawRouterRoute,
   ZLinkRawSocketPort
 } from '../raw-binding-port';
+
+interface ZLinkNodeRawRouterSocketOptions {
+  readonly sendHighWaterMark?: number;
+  readonly receiveHighWaterMark?: number;
+  readonly receiveTimeoutMs?: number;
+}
+
 export type {
   ZLinkRawBindingPort,
   ZLinkRawDealerPort,
@@ -55,14 +64,14 @@ export type {
 export class ZLinkNodeRawBindingPort implements ZLinkRawBindingPort {
   constructor(
     private readonly sharedContext?: Context,
-    private readonly routerReceiveTimeoutMs?: number
+    private readonly routerSocketOptions?: ZLinkNodeRawRouterSocketOptions
   ) {}
 
   createHost(): ZLinkRawHostPort {
     return new NodeRawHostPort(
       this.sharedContext ?? createContext(),
       this.sharedContext === undefined,
-      this.routerReceiveTimeoutMs
+      this.routerSocketOptions
     );
   }
 }
@@ -74,13 +83,13 @@ class NodeRawHostPort implements ZLinkRawHostPort {
   constructor(
     private readonly context: Context,
     private readonly ownsContext: boolean,
-    private readonly routerReceiveTimeoutMs?: number
+    private readonly routerSocketOptions?: ZLinkNodeRawRouterSocketOptions
   ) {}
 
   createRouter(): ZLinkRawRouterPort {
     this.requireOpen();
     return this.own(
-      new NodeRawRouterPort(createRouterSocket(this.context), this.routerReceiveTimeoutMs)
+      new NodeRawRouterPort(createRouterSocket(this.context), this.routerSocketOptions)
     );
   }
 
@@ -133,6 +142,8 @@ class NodeRawHostPort implements ZLinkRawHostPort {
 }
 
 abstract class NodeRawSocketPort<TSocket extends Socket> implements ZLinkRawSocketPort {
+  protected readonly requests = new RequestRuntime();
+  protected readonly received = new Received();
   private readonly endpoints = new Set<string>();
   private readonly monitors = new Set<NodeRawMonitorPort>();
   private readonly eventLoopPoller: ZLinkNodeEventLoopPoller;
@@ -145,7 +156,9 @@ abstract class NodeRawSocketPort<TSocket extends Socket> implements ZLinkRawSock
     this.eventLoopPoller = new ZLinkNodeEventLoopPoller(socket, true, () => {}, pollRoute);
   }
 
-  setReadableHandler(handler: (receiveReady: boolean, routeReady: boolean) => void): void {
+  setReadableHandler(
+    handler: (receiveReady: boolean, routeReady: boolean, connectReady: boolean) => void
+  ): void {
     this.requireOpen();
     this.eventLoopPoller.setReadableHandler(handler);
   }
@@ -183,6 +196,7 @@ abstract class NodeRawSocketPort<TSocket extends Socket> implements ZLinkRawSock
   }
 
   close(): void {
+    this.requests.close();
     if (this.closed) return;
     const failures: unknown[] = [];
     try {
@@ -214,6 +228,7 @@ abstract class NodeRawSocketPort<TSocket extends Socket> implements ZLinkRawSock
     }
     this.endpoints.clear();
     try {
+      this.received.close();
       this.socket.close();
     } catch (error) {
       throw new AggregateError([error], 'Raw socket cleanup failed.');
@@ -238,7 +253,7 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
   private readonly replyParts = (
     targetRid: BindingRoutingId,
     replyToken: ReplyToken,
-    parts: readonly Uint8Array[]
+    parts: readonly (Uint8Array | string)[]
   ) => {
     // The receive record keeps the binding RoutingId it was delivered with,
     // so the reply addresses that route without rebuilding the identity.
@@ -273,13 +288,19 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
     disconnectSocketPeer(this.socket, this.preparedRoutingId(routingId));
   }
 
-  constructor(socket: RouterSocket, receiveTimeoutMs?: number) {
+  constructor(socket: RouterSocket, options?: ZLinkNodeRawRouterSocketOptions) {
     super(socket, true);
     socket.options.handover = true;
     socket.options.mandatory = true;
     socket.options.probe = true;
-    if (receiveTimeoutMs !== undefined) {
-      socket.options.recvTimeout = receiveTimeoutMs;
+    if (options?.sendHighWaterMark !== undefined) {
+      socket.options.sendHwm = BigInt(options.sendHighWaterMark);
+    }
+    if (options?.receiveHighWaterMark !== undefined) {
+      socket.options.recvHwm = BigInt(options.receiveHighWaterMark);
+    }
+    if (options?.receiveTimeoutMs !== undefined) {
+      socket.options.recvTimeout = options.receiveTimeoutMs;
     }
   }
 
@@ -311,24 +332,55 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
     return submitBindingSend(this.socket.send(this.preparedRoutingId(targetRid)), parts);
   }
 
-  request(
+  request<T>(
     targetRid: string,
     parts: readonly Uint8Array[],
     timeoutMs: number,
+    onReply: (parts: readonly Buffer[]) => T,
+    onFailed: (error: unknown) => T,
     recordReceived?: () => void,
-    onAdmitted?: () => void
-  ): Promise<readonly Buffer[]> {
-    let submission: ReturnType<RequestSubmitOperation['submit']>;
-    const deadlineMs = performance.now() + timeoutMs;
-    try {
+    onAdmitted?: () => void,
+    existing?: Pick<OperationHandle<unknown>, 'id' | 'deadlineMs'>
+  ): Promise<T> {
+    if (existing !== undefined) {
       this.requireOpen();
-      submission = appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts)
-        .timeout(timeoutMs)
-        .submit();
-    } catch (error) {
-      return Promise.reject(translateBindingResultError(error, 'submit'));
+      const submission = submitRawRequest(
+        appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts).timeout(
+          remainingRequestTimeout('Request', existing.deadlineMs) ?? timeoutMs
+        )
+      );
+      return requestReply(submission, 0, onReply, onFailed, recordReceived, onAdmitted);
     }
-    return requestReply(submission, deadlineMs, recordReceived, onAdmitted);
+    return this.requests.observe<readonly Buffer[], T>(
+      timeoutMs,
+      (entry, receiver) => {
+        this.requireOpen();
+        const submission = submitRawRequest(
+          appendRequestParts(this.socket.request(this.preparedRoutingId(targetRid)), parts).timeout(
+            remainingRequestTimeout('Request', entry.deadlineMs) ?? timeoutMs
+          )
+        );
+        void requestReply(
+          submission,
+          0,
+          (value) => {
+            receiver.operationCompleted(entry.id, value, undefined);
+          },
+          (error) => {
+            receiver.operationFailed(entry.id, error, undefined);
+          },
+          recordReceived,
+          onAdmitted
+        );
+      },
+      onReply,
+      onFailed
+    );
+  }
+
+  connectionAttemptsSnapshot() {
+    this.requireOpen();
+    return this.socket.connectionAttemptsSnapshot();
   }
 
   routesSnapshot(): readonly ZLinkRawRouterRoute[] {
@@ -341,7 +393,13 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
 
   receive(dontWait = false): ZLinkRawReceivedRecord | undefined {
     this.requireOpen();
-    return receiveRecord(this.socket, dontWait, this.nextRequestSequence, this.replyParts);
+    return receiveRecord(
+      this.socket,
+      this.received,
+      dontWait,
+      this.nextRequestSequence,
+      this.replyParts
+    );
   }
 }
 
@@ -366,20 +424,36 @@ class NodeRawDealerPort extends NodeRawSocketPort<DealerSocket> implements ZLink
     timeoutMs: number,
     onAdmitted?: () => void
   ): Promise<readonly Buffer[]> {
-    let submission: ReturnType<RequestSubmitOperation['submit']>;
-    const deadlineMs = performance.now() + timeoutMs;
-    try {
-      this.requireOpen();
-      submission = appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit();
-    } catch (error) {
-      return Promise.reject(translateBindingResultError(error, 'submit'));
-    }
-    return requestReply(submission, deadlineMs, undefined, onAdmitted);
+    return this.requests.observe<readonly Buffer[]>(
+      timeoutMs,
+      (entry, receiver) => {
+        this.requireOpen();
+        const submission = submitRawRequest(
+          appendRequestParts(this.socket.request(), parts).timeout(
+            remainingRequestTimeout('Request', entry.deadlineMs) ?? timeoutMs
+          )
+        );
+        void requestReply(
+          submission,
+          0,
+          (value) => {
+            receiver.operationCompleted(entry.id, value, undefined);
+          },
+          (error) => {
+            receiver.operationFailed(entry.id, error, undefined);
+          },
+          undefined,
+          onAdmitted
+        );
+      },
+      (value) => value,
+      rethrowCompletion
+    );
   }
 
   receive(dontWait = false): ZLinkRawReceivedRecord | undefined {
     this.requireOpen();
-    return receiveRecord(this.socket, dontWait);
+    return receiveRecord(this.socket, this.received, dontWait);
   }
 }
 
@@ -429,7 +503,7 @@ function appendRequestParts(
 
 function appendReplyParts(
   operation: ReplyOperation,
-  parts: readonly Uint8Array[]
+  parts: readonly (Uint8Array | string)[]
 ): ReplySubmitOperation {
   requireParts(parts);
   let next = operation.message(parts[0]);
@@ -439,36 +513,35 @@ function appendReplyParts(
   return next;
 }
 
-function requireParts(parts: readonly Uint8Array[]): [Uint8Array, ...Uint8Array[]] {
+function requireParts<T extends Uint8Array | string>(parts: readonly T[]): [T, ...T[]] {
   if (parts.length === 0)
     throw new TypeError('Raw multipart operation requires at least one part.');
-  return parts as [Uint8Array, ...Uint8Array[]];
+  return parts as [T, ...T[]];
 }
 
 type RawReceivedReply = (
   targetRid: BindingRoutingId,
   replyToken: ReplyToken,
-  parts: readonly Uint8Array[]
+  parts: readonly (Uint8Array | string)[]
 ) => void;
 
 const EMPTY_SOURCE_ROUTE = Buffer.alloc(0);
 
 /**
  * One received binding record. The payload Buffers are the binding's own
- * `data()` storage, retained under the runtime payload policy instead of a
- * second Framework copy; closing the record releases the binding handles.
+ * `data()` storage, retained under the runtime payload policy. The socket owns
+ * the reusable binding envelope; snapshots survive its next receive or close.
  */
 class NodeRawReceivedRecord implements ZLinkRawReceivedRecord {
   readonly sourceRid: string;
   readonly sourceRoute: Uint8Array;
   readonly routeGeneration: bigint;
   readonly requestSeq?: bigint;
-  readonly reply?: (parts: readonly Uint8Array[]) => void;
+  readonly reply?: (parts: readonly (Uint8Array | string)[]) => void;
   readonly parts: readonly Buffer[];
-  private closed = false;
 
   constructor(
-    private readonly received: Received,
+    received: Received,
     nextRequestSequence: (() => bigint) | undefined,
     reply: RawReceivedReply | undefined
   ) {
@@ -495,21 +568,20 @@ class NodeRawReceivedRecord implements ZLinkRawReceivedRecord {
   }
 
   close(): void {
-    if (this.closed) return;
-    this.closed = true;
-    this.received.close();
+    // Reading each binding payload above retained JS-owned storage and released
+    // its native frame. The socket clears its reusable envelope; these record
+    // snapshots need no native cleanup.
   }
 }
 
 function receiveRecord(
   socket: Pick<RouterSocket | DealerSocket, 'recv'>,
+  received: Received,
   dontWait: boolean,
   nextRequestSequence?: () => bigint,
   reply?: RawReceivedReply
 ): ZLinkRawReceivedRecord | undefined {
-  const received = new Received();
   if (!socket.recv(received, dontWait ? RecvFlags.DontWait : RecvFlags.None)) {
-    received.close();
     return undefined;
   }
   try {
@@ -525,42 +597,71 @@ function receiveRecord(
  * confirmed in this turn; a backpressured submission keeps the admission
  * wait that bounds it by the request deadline.
  */
-function requestReply(
+function requestReply<T>(
   submission: ReturnType<RequestSubmitOperation['submit']>,
-  deadlineMs: number,
+  _deadlineMs: number,
+  onReply: (parts: readonly Buffer[]) => T,
+  onFailed: (error: unknown) => T,
   recordReceived: (() => void) | undefined,
   onAdmitted: (() => void) | undefined
-): Promise<readonly Buffer[]> {
+): Promise<T> {
+  const result = observeRequestReply(submission.reply, onReply, onFailed, recordReceived);
   if (submission.result === SubmitResult.Backpressured) {
-    return bindingRequestReply(submission, deadlineMs, recordReceived, onAdmitted).then(
-      retainAndClose,
-      rejectCompletion
+    void submission.admitted.then(
+      () => {
+        try {
+          onAdmitted?.();
+        } catch (error) {
+          onFailed(translateBindingResultError(error, 'completion'));
+        }
+      },
+      (error) => onFailed(translateBindingResultError(error, 'completion'))
     );
-  }
-  try {
-    onAdmitted?.();
-  } catch (error) {
-    return Promise.reject(translateBindingResultError(error, 'completion'));
-  }
-  return submission.reply.then((replies) => {
+  } else {
     try {
-      recordReceived?.();
-      return retainAndClose(replies);
+      onAdmitted?.();
     } catch (error) {
-      throw translateBindingResultError(error, 'completion');
+      onFailed(translateBindingResultError(error, 'completion'));
     }
-  }, rejectCompletion);
+  }
+  return result;
 }
 
-function rejectCompletion(error: unknown): never {
-  throw translateBindingResultError(error, 'completion');
+/** Consumes the binding reply and notifies its terminal in this continuation. */
+function observeRequestReply<T>(
+  reply: Promise<readonly Message[]>,
+  onReply: (parts: readonly Buffer[]) => T,
+  onFailed: (error: unknown) => T,
+  recordReceived?: () => void
+): Promise<T> {
+  return reply.then(
+    (replies) => {
+      try {
+        return onReply(retainAndClose(replies, recordReceived));
+      } catch (error) {
+        return onFailed(translateBindingResultError(error, 'completion'));
+      }
+    },
+    (error) => onFailed(translateBindingResultError(error, 'completion'))
+  );
+}
+
+function rethrowCompletion(error: unknown): never {
+  throw error;
 }
 
-function retainAndClose(messages: readonly Message[]): readonly Buffer[] {
+function retainAndClose(
+  messages: readonly Message[],
+  recordReceived?: () => void
+): readonly Buffer[] {
   try {
-    return messages.map((message) => ZLinkBufferMessage.retainPayload(message));
+    recordReceived?.();
+    const retained = new Array<Buffer>(messages.length);
+    for (let index = 0; index < messages.length; index++)
+      retained[index] = ZLinkBufferMessage.retainPayload(messages[index]!);
+    return retained;
   } finally {
-    for (const message of messages) message.close();
+    for (let index = 0; index < messages.length; index++) messages[index]!.close();
   }
 }
 
@@ -593,3 +694,13 @@ function copyMonitorEvent(event: MonitorEvent): ZLinkRawMonitorRecord {
     flags: event.flags
   };
 }
+
+function submitRawRequest(
+  operation: RequestSubmitOperation
+): ReturnType<RequestSubmitOperation['submit']> {
+  try {
+    return operation.submit();
+  } catch (error) {
+    throw translateBindingResultError(error, 'submit');
+  }
+}