@zlink-systems/framework 0.20.0 → 0.22.0

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

@@ -40,16 +40,13 @@ export function wrapSocket<T extends { close(): void }>(
     };
   };
   const hasRequest = typeof (nativeInstance as { request?: unknown }).request === 'function';
-  const hasRoutedPeer = hasRequest
-    && typeof (nativeInstance as { reply?: unknown }).reply === 'function';
+  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 eventLoopPoller =
+    pollCompletion === undefined
+      ? undefined
+      : new ZLinkNodeEventLoopPoller(nativeInstance as unknown as Socket, pollCompletion, () => {});
   const adapter = {
     nativeInstance,
     async dispose(): Promise<void> {
@@ -74,20 +71,24 @@ export function wrapSocket<T extends { close(): void }>(
       (nativeInstance as T & { disconnect(endpoint: string): void }).disconnect(endpoint);
     },
     setChannelName(channelName: string): void {
-      const setChannelName = (nativeInstance as T & { setChannelName?: (value: string) => void }).setChannelName;
+      const setChannelName = (nativeInstance as T & { setChannelName?: (value: string) => void })
+        .setChannelName;
       setChannelName?.call(nativeInstance, channelName);
     },
     setReceiveFlowState(state: 0 | 1): void {
-      (nativeInstance as T & { setReceiveFlowState(value: 0 | 1): void })
-        .setReceiveFlowState(state);
+      (nativeInstance as T & { setReceiveFlowState(value: 0 | 1): void }).setReceiveFlowState(
+        state
+      );
     },
     setProbe(enabled: boolean): void {
       requireSocketOptions(socket).probe = enabled;
     },
     setTlsServer(cert: string, key: string, requireClientCert?: boolean): void {
-      (nativeInstance as T & {
-        setTlsServer(cert: string, key: string, requireClientCert?: boolean): void;
-      }).setTlsServer(cert, key, requireClientCert);
+      (
+        nativeInstance as T & {
+          setTlsServer(cert: string, key: string, requireClientCert?: boolean): void;
+        }
+      ).setTlsServer(cert, key, requireClientCert);
     },
     setSubscription(topic: string): void {
       (nativeInstance as T & { setSubscription(topic: string): void }).setSubscription(topic);
@@ -96,15 +97,21 @@ export function wrapSocket<T extends { close(): void }>(
       (nativeInstance as T & { unsetSubscription(topic: string): void }).unsetSubscription(topic);
     },
     subscribe(result: unknown, flags?: number): boolean {
-      return Boolean((nativeInstance as T & {
-        subscribe(result: unknown, flags?: number): boolean;
-      }).subscribe(result, flags));
+      return Boolean(
+        (
+          nativeInstance as T & {
+            subscribe(result: unknown, flags?: number): boolean;
+          }
+        ).subscribe(result, flags)
+      );
     },
     get lastEndpoint(): string | undefined {
       return socket.options?.lastEndpoint;
     },
     setRoutingId(routingId: unknown): void {
-      (nativeInstance as T & { setRoutingId(value: unknown): void }).setRoutingId(toNativeRoutingId(routingId));
+      (nativeInstance as T & { setRoutingId(value: unknown): void }).setRoutingId(
+        toNativeRoutingId(routingId)
+      );
     },
     get peerWeight(): number {
       return socket.options?.peerWeight ?? 100;
@@ -151,17 +158,20 @@ export function wrapSocket<T extends { close(): void }>(
     send(...args: unknown[]): unknown {
       if (hasStream) {
         const [routingId, payload] = args as [unknown, unknown];
-        const operation = (nativeInstance as T & {
-          send(routingId: unknown): ZLinkBindingAsyncSendOperation;
-        }).send(toNativeRoutingId(routingId));
+        const operation = (
+          nativeInstance as T & {
+            send(routingId: unknown): ZLinkBindingAsyncSendOperation;
+          }
+        ).send(toNativeRoutingId(routingId));
         submitBindingSyncSend(operation, payload);
         return true;
       }
       if (hasRoutedPeer) {
         const [routingId, payload] = args as [unknown, unknown];
         return submitBindingAsyncSend(
-          (nativeInstance as T & { send(routingId: unknown): ZLinkBindingAsyncSendOperation })
-            .send(toNativeRoutingId(routingId)),
+          (nativeInstance as T & { send(routingId: unknown): ZLinkBindingAsyncSendOperation }).send(
+            toNativeRoutingId(routingId)
+          ),
           payload
         );
       }
@@ -172,9 +182,11 @@ export function wrapSocket<T extends { close(): void }>(
           payload
         );
       }
-      const operation = (nativeInstance as T & {
-        send(): ZLinkBindingAsyncSendOperation;
-      }).send();
+      const operation = (
+        nativeInstance as T & {
+          send(): ZLinkBindingAsyncSendOperation;
+        }
+      ).send();
       if ((flags ?? zlink.SendFlags.None) === zlink.SendFlags.DontWait) {
         submitBindingSyncSend(operation, payload);
         return true;
@@ -184,8 +196,9 @@ 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.');
       return submitBindingAsyncSend(
-        (nativeInstance as T & { send(routingId: unknown): ZLinkBindingAsyncSendOperation })
-          .send(toNativeRoutingId(routingId)),
+        (nativeInstance as T & { send(routingId: unknown): ZLinkBindingAsyncSendOperation }).send(
+          toNativeRoutingId(routingId)
+        ),
         payload
       );
     },
@@ -193,8 +206,9 @@ export function wrapSocket<T extends { close(): void }>(
       if (hasRoutedPeer) {
         const [routingId, payload, timeoutMs] = args as [unknown, unknown, number | undefined];
         return submitBindingRequest(
-          (nativeInstance as T & { request(routingId: unknown): ZLinkBindingRequestOperation })
-            .request(toNativeRoutingId(routingId)),
+          (
+            nativeInstance as T & { request(routingId: unknown): ZLinkBindingRequestOperation }
+          ).request(toNativeRoutingId(routingId)),
           payload,
           timeoutMs
         );
@@ -211,18 +225,22 @@ export function wrapSocket<T extends { close(): void }>(
     },
     reply(...args: unknown[]): unknown {
       const [routingId, replyToken, payload] = args as [unknown, unknown, unknown];
-      const operation = (nativeInstance as T & {
-        reply(routingId: unknown, replyToken: unknown): ZLinkBindingReplyOperation;
-      }).reply(toNativeRoutingId(routingId), replyToken);
+      const operation = (
+        nativeInstance as T & {
+          reply(routingId: unknown, replyToken: unknown): ZLinkBindingReplyOperation;
+        }
+      ).reply(toNativeRoutingId(routingId), replyToken);
       return args.length < 3 ? operation : submitBindingReply(operation, payload);
     },
     recv(flags?: number): unknown {
       const received = new zlink.Received();
       let ok = false;
       try {
-        ok = (nativeInstance as T & {
-          recv(result: unknown, flags?: number): boolean;
-        }).recv(received, flags);
+        ok = (
+          nativeInstance as T & {
+            recv(result: unknown, flags?: number): boolean;
+          }
+        ).recv(received, flags);
       } catch (error) {
         received.close();
         if (isRouteRecvRetryable(error)) {
@@ -239,9 +257,11 @@ export function wrapSocket<T extends { close(): void }>(
     recvPacket(packet: unknown, flags?: number): boolean {
       if (!hasStream) throw new TypeError('Packet receive requires a STREAM socket.');
       try {
-        return (nativeInstance as T & {
-          recvPacket(result: unknown, flags?: number): boolean;
-        }).recvPacket(packet, flags);
+        return (
+          nativeInstance as T & {
+            recvPacket(result: unknown, flags?: number): boolean;
+          }
+        ).recvPacket(packet, flags);
       } catch (error) {
         if (isRouteRecvRetryable(error)) return false;
         throw error;
@@ -251,7 +271,9 @@ export function wrapSocket<T extends { close(): void }>(
       if (args.length >= 2) {
         const [topic, payload] = args as [string, unknown];
         submitBindingPublish(
-          (nativeInstance as T & { publish(topic: string): ZLinkBindingPublishOperation }).publish(topic),
+          (nativeInstance as T & { publish(topic: string): ZLinkBindingPublishOperation }).publish(
+            topic
+          ),
           payload
         );
         return;
@@ -264,9 +286,11 @@ export function wrapSocket<T extends { close(): void }>(
       payload: unknown,
       _flags?: number
     ): Promise<void> {
-      const operation = (nativeInstance as T & {
-        sendToSpot(targetRid: unknown, targetSpot: unknown): ZLinkBindingAsyncSendOperation;
-      }).sendToSpot(toNativeRoutingId(targetRid), toNativeRoutingId(targetSpot));
+      const operation = (
+        nativeInstance as T & {
+          sendToSpot(targetRid: unknown, targetSpot: unknown): ZLinkBindingAsyncSendOperation;
+        }
+      ).sendToSpot(toNativeRoutingId(targetRid), toNativeRoutingId(targetSpot));
       await submitBindingAsyncSend(operation, payload);
     },
     requestToSpot(
@@ -276,27 +300,47 @@ export function wrapSocket<T extends { close(): void }>(
       timeoutMs?: number
     ): Promise<readonly unknown[]> {
       return submitBindingRequest(
-        (nativeInstance as T & {
-          requestToSpot(targetRid: unknown, targetSpot: unknown): ZLinkBindingRequestOperation;
-        }).requestToSpot(toNativeRoutingId(targetRid), toNativeRoutingId(targetSpot)),
+        (
+          nativeInstance as T & {
+            requestToSpot(targetRid: unknown, targetSpot: unknown): ZLinkBindingRequestOperation;
+          }
+        ).requestToSpot(toNativeRoutingId(targetRid), toNativeRoutingId(targetSpot)),
         payload,
         timeoutMs
       );
     },
     disconnectPeer(routingId: unknown): void {
-      disconnectStreamPeer(nativeInstance as T & { disconnectRid(value: unknown): void }, routingId);
+      disconnectStreamPeer(
+        nativeInstance as T & { disconnectRid(value: unknown): void },
+        routingId
+      );
     },
-    async bindActor(_sessionRid: unknown, _actor: unknown, _timeoutMs: number, _signal?: AbortSignal): Promise<void> {
+    async bindActor(
+      _sessionRid: unknown,
+      _actor: unknown,
+      _timeoutMs: number,
+      _signal?: AbortSignal
+    ): Promise<void> {
       throw new Error(
         'Session Actor dispatch requires enableActorDispatch() and a Framework MeshNode service route.'
       );
     },
-    async unbindActor(_sessionRid: unknown, _actorId: string, _timeoutMs: number, _signal?: AbortSignal): Promise<void> {
+    async unbindActor(
+      _sessionRid: unknown,
+      _actorId: string,
+      _timeoutMs: number,
+      _signal?: AbortSignal
+    ): Promise<void> {
       throw new Error(
         'Session Actor dispatch requires enableActorDispatch() and a Framework MeshNode service route.'
       );
     },
-    sendBoundActor(_sessionRid: unknown, _actorId: string, _parts: readonly unknown[], _flags: number): boolean {
+    sendBoundActor(
+      _sessionRid: unknown,
+      _actorId: string,
+      _parts: readonly unknown[],
+      _flags: number
+    ): boolean {
       return false;
     }
   };
@@ -333,8 +377,11 @@ function requireSocketOptions<TOptions>(socket: { readonly options?: TOptions })
 }
 
 export function isEndpointCloseIgnorableError(error: unknown): boolean {
-  return isContextTerminatedError(error) || (
-    error instanceof Error && 'code' in error &&
-    ((error as { code: unknown }).code === 604 || (error as { code: unknown }).code === zlink.ConnectResult.NotFound)
+  return (
+    isContextTerminatedError(error) ||
+    (error instanceof Error &&
+      'code' in error &&
+      ((error as { code: unknown }).code === 604 ||
+        (error as { code: unknown }).code === zlink.ConnectResult.NotFound))
   );
 }

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

@@ -45,7 +45,9 @@ export class ZLinkBufferMessage implements Message {
 }
 
 function isMessage(value: unknown): value is Message {
-  return typeof value === 'object'
-    && value !== null
-    && typeof (value as { data?: unknown }).data === 'function';
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { data?: unknown }).data === 'function'
+  );
 }

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

@@ -16,7 +16,7 @@ export const RequestResult = Object.freeze({
   NotSupported: 112,
   Backpressured: 113
 } as const);
-export type RequestResult = typeof RequestResult[keyof typeof RequestResult];
+export type RequestResult = (typeof RequestResult)[keyof typeof RequestResult];
 
 export const SubmitResult = Object.freeze({
   Ok: 0,
@@ -34,7 +34,7 @@ export const SubmitResult = Object.freeze({
   InternalError: 12,
   NotAdmitted: 13
 } as const);
-export type SubmitResult = typeof SubmitResult[keyof typeof SubmitResult];
+export type SubmitResult = (typeof SubmitResult)[keyof typeof SubmitResult];
 
 export type ZLinkBackendSendFlags = number;
 export type ZLinkBackendRecvFlags = number;
@@ -59,8 +59,9 @@ export function isZLinkBackendResultError(error: unknown): error is ZLinkBackend
 
 export function isBackendNotConnectedError(error: unknown): boolean {
   if (isZLinkBackendResultError(error)) {
-    return error.result === SubmitResult.NotConnected
-      || error.result === RequestResult.NotConnected;
+    return (
+      error.result === SubmitResult.NotConnected || error.result === RequestResult.NotConnected
+    );
   }
   if (typeof error !== 'object' || error === null || !('result' in error)) {
     return false;
@@ -70,9 +71,11 @@ export function isBackendNotConnectedError(error: unknown): boolean {
 }
 
 export function isBackendRequestTimeoutError(error: unknown): boolean {
-  return isZLinkBackendResultError(error)
-    && error.operation === 'request'
-    && error.result === RequestResult.TimedOut;
+  return (
+    isZLinkBackendResultError(error) &&
+    error.operation === 'request' &&
+    error.result === RequestResult.TimedOut
+  );
 }
 export type ZLinkBackendMessageLike = Message | Buffer | Uint8Array | string;
 /** Binding의 SendSubmission과 구조적으로 호환된다. binding 타입을 import 하지 않는다. */

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

@@ -1,9 +1,6 @@
 import type { ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { ZLinkDomainLocationStore as ZLinkLocationStore } from '../locations/domain-store-contract';
-import type {
-  ZLinkLocationEventSink,
-  ZLinkLocationRuntimeStores
-} from '../locations';
+import type { ZLinkLocationEventSink, ZLinkLocationRuntimeStores } from '../locations';
 import {
   ZLinkLocationRuntime,
   ZLinkOwnerLeaseTracker,

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

@@ -11,10 +11,7 @@ import type {
   ZLinkSpotPublisherClient
 } from '../../contracts';
 import type { SpotHandle } from '../spots/spot-handle';
-import {
-  ZLinkConfigurationException,
-  type ZLinkFrameworkRegistration
-} from '../configuration';
+import { ZLinkConfigurationException, type ZLinkFrameworkRegistration } from '../configuration';
 import {
   ZLinkFrameworkInternalErrorKind,
   createInternalFrameworkException
@@ -56,13 +53,9 @@ export class DefaultZLinkChannelClient implements ZLinkChannelClient {
     return new DefaultZLinkSendCall(
       () => this.requireChannel(channelName),
       async (packetName, metadata, signal) =>
-        normalizeSubmitResult(await this.requireTransport().send(
-          channelName,
-          packetName,
-          message,
-          signal,
-          metadata
-        ))
+        normalizeSubmitResult(
+          await this.requireTransport().send(channelName, packetName, message, signal, metadata)
+        )
     );
   }
 
@@ -83,9 +76,11 @@ export class DefaultZLinkChannelClient implements ZLinkChannelClient {
   }
 
   private defaultRequestTimeout(channelName: string): number {
-    return this.registration.channels.get(channelName)?.requestTimeoutMs
-      ?? this.registration.requestTimeoutMs
-      ?? 30_000;
+    return (
+      this.registration.channels.get(channelName)?.requestTimeoutMs ??
+      this.registration.requestTimeoutMs ??
+      30_000
+    );
   }
 
   private requireChannel(channelName: string): void {
@@ -105,9 +100,7 @@ export class DefaultZLinkChannelClient implements ZLinkChannelClient {
   }
 
   private requireTransport(): ZLinkChannelClientTransport {
-    const transport = typeof this.transport === 'function'
-      ? this.transport()
-      : this.transport;
+    const transport = typeof this.transport === 'function' ? this.transport() : this.transport;
     if (transport === undefined) {
       throw new ZLinkConfigurationException('Channel runtime is not started.');
     }
@@ -123,24 +116,24 @@ export class DefaultZLinkFanoutClient implements ZLinkFanoutClient {
 
   publish(channelName: string, event: unknown): ZLinkFanoutPublishCall;
   publish(channelName: string, topic: string, event: unknown): ZLinkFanoutPublishCall;
-  publish(channelName: string, topicOrEvent: string | unknown, explicitEvent?: unknown): ZLinkFanoutPublishCall {
+  publish(
+    channelName: string,
+    topicOrEvent: string | unknown,
+    explicitEvent?: unknown
+  ): ZLinkFanoutPublishCall {
     const hasExplicitTopic = arguments.length === 3;
     const event = hasExplicitTopic ? explicitEvent : topicOrEvent;
     const topic = hasExplicitTopic
-      ? topicOrEvent as string
+      ? (topicOrEvent as string)
       : resolveFrameworkPacketName(event, undefined, 'Fanout');
     requirePublicFanoutTopic(topic);
     const packetName = resolveFrameworkPacketName(event, undefined, 'Fanout');
     return new DefaultZLinkFanoutPublishCall(
       () => this.requirePublisherChannel(channelName),
       async (signal) => ({
-        status: (await this.requireTransport().publish(
-          channelName,
-          topic,
-          packetName,
-          event,
-          signal
-        )).status
+        status: (
+          await this.requireTransport().publish(channelName, topic, packetName, event, signal)
+        ).status
       })
     );
   }
@@ -158,14 +151,14 @@ export class DefaultZLinkFanoutClient implements ZLinkFanoutClient {
 
   private requirePublisherChannel(channelName: string): void {
     if (!this.registration.fanoutPublishers.has(channelName)) {
-      throw new ZLinkConfigurationException(`Channel '${channelName}' does not have a publisher capability.`);
+      throw new ZLinkConfigurationException(
+        `Channel '${channelName}' does not have a publisher capability.`
+      );
     }
   }
 
   private requireTransport(): ZLinkChannelClientTransport {
-    const transport = typeof this.transport === 'function'
-      ? this.transport()
-      : this.transport;
+    const transport = typeof this.transport === 'function' ? this.transport() : this.transport;
     if (transport === undefined) {
       throw new ZLinkConfigurationException('Channel runtime is not started.');
     }
@@ -177,21 +170,24 @@ export class DefaultZLinkRouteClient implements ZLinkRouteClient {
   constructor(
     private readonly registration: ZLinkFrameworkRegistration,
     private readonly transport?: ZLinkRouteClientTransport,
-    private readonly spotRouterChannelIdForMesh: (meshName: string) => string = (meshName) => meshName
+    private readonly spotRouterChannelIdForMesh: (meshName: string) => string = (meshName) =>
+      meshName
   ) {}
 
   sendToNode(meshName: string, targetNodeRid: string, message: unknown): ZLinkSendCall {
     return new DefaultZLinkSendCall(
       () => this.requireMesh(meshName),
       async (packetName, metadata, signal) =>
-        normalizeSubmitResult(await this.requireTransport().submit(
-          meshName,
-          targetNodeRid,
-          packetName,
-          message,
-          signal,
-          metadata
-        ))
+        normalizeSubmitResult(
+          await this.requireTransport().submit(
+            meshName,
+            targetNodeRid,
+            packetName,
+            message,
+            signal,
+            metadata
+          )
+        )
     );
   }
 
@@ -214,24 +210,30 @@ export class DefaultZLinkRouteClient implements ZLinkRouteClient {
 
   sendToChannel(channelName: string, message: unknown): ZLinkSendCall {
     return new DefaultZLinkSendCall(
-      () => { this.resolveMeshChannel(channelName); },
+      () => {
+        this.resolveMeshChannel(channelName);
+      },
       async (packetName, metadata, signal) => {
         const meshName = this.resolveMeshChannel(channelName);
-        return normalizeSubmitResult(await this.requireTransport().submitToChannel(
-          meshName,
-          channelName,
-          packetName,
-          message,
-          signal,
-          metadata
-        ));
+        return normalizeSubmitResult(
+          await this.requireTransport().submitToChannel(
+            meshName,
+            channelName,
+            packetName,
+            message,
+            signal,
+            metadata
+          )
+        );
       }
     );
   }
 
   requestToChannel(channelName: string, request: unknown): ZLinkChannelRequestCall {
     return new DefaultZLinkRequestCall(
-      () => { this.resolveMeshChannel(channelName); },
+      () => {
+        this.resolveMeshChannel(channelName);
+      },
       (packetName, timeoutMs, metadata, signal) => {
         const meshName = this.resolveMeshChannel(channelName);
         return this.requireTransport().requestToChannel(
@@ -250,7 +252,9 @@ export class DefaultZLinkRouteClient implements ZLinkRouteClient {
 
   sendToSpot(spot: SpotHandle, message: unknown): ZLinkSendCall {
     return new DefaultZLinkSendCall(
-      () => { this.requireSpotTransport(); },
+      () => {
+        this.requireSpotTransport();
+      },
       async (_packetName, metadata, signal) => {
         await sendToSpotHandle(this.requireSpotTransport(), spot, message, {
           signal,
@@ -264,38 +268,43 @@ export class DefaultZLinkRouteClient implements ZLinkRouteClient {
 
   requestToSpot(spot: SpotHandle, request: unknown): ZLinkRequestCall {
     return new DefaultZLinkRequestCall(
-      () => { this.requireSpotTransport(); },
-      (_packetName, timeoutMs, metadata, signal) => requestToSpotHandle(
-        this.requireSpotTransport(),
-        spot,
-        request,
-        {
+      () => {
+        this.requireSpotTransport();
+      },
+      (_packetName, timeoutMs, metadata, signal) =>
+        requestToSpotHandle(this.requireSpotTransport(), spot, request, {
           timeoutMs,
           signal,
           metadata,
           spotRouterChannelIdForMesh: this.spotRouterChannelIdForMesh
-        }
-      ),
+        }),
       this.registration.requestTimeoutMs ?? 30_000
     );
   }
 
   private defaultRequestTimeout(meshName: string): number {
-    return this.registration.spotNodes.get(meshName)?.requestTimeoutMs
-      ?? this.registration.routeChannelOptions.get(meshName)?.requestTimeoutMs
-      ?? this.registration.requestTimeoutMs
-      ?? 30_000;
+    return (
+      this.registration.spotNodes.get(meshName)?.requestTimeoutMs ??
+      this.registration.routeChannelOptions.get(meshName)?.requestTimeoutMs ??
+      this.registration.requestTimeoutMs ??
+      30_000
+    );
   }
 
   private requireMesh(meshName: string): void {
-    if (!this.registration.spotNodes.has(meshName) && !this.registration.routeChannels.has(meshName)) {
+    if (
+      !this.registration.spotNodes.has(meshName) &&
+      !this.registration.routeChannels.has(meshName)
+    ) {
       throw new ZLinkConfigurationException(`RouteMesh '${meshName}' is not registered.`);
     }
   }
 
   private resolveMeshChannel(channelName: string): string {
     const matches = [...this.registration.spotNodes.entries()]
-      .filter(([, mesh]) => Object.prototype.hasOwnProperty.call(mesh.meshChannels ?? {}, channelName))
+      .filter(([, mesh]) =>
+        Object.prototype.hasOwnProperty.call(mesh.meshChannels ?? {}, channelName)
+      )
       .map(([meshName]) => meshName);
     if (matches.length === 0) {
       throw createInternalFrameworkException(
@@ -312,11 +321,10 @@ export class DefaultZLinkRouteClient implements ZLinkRouteClient {
   }
 
   private defaultRequestTimeoutForChannel(channelName: string): number {
-    const match = [...this.registration.spotNodes.entries()]
-      .find(([, mesh]) => Object.prototype.hasOwnProperty.call(mesh.meshChannels ?? {}, channelName));
-    return match?.[1].requestTimeoutMs
-      ?? this.registration.requestTimeoutMs
-      ?? 30_000;
+    const match = [...this.registration.spotNodes.entries()].find(([, mesh]) =>
+      Object.prototype.hasOwnProperty.call(mesh.meshChannels ?? {}, channelName)
+    );
+    return match?.[1].requestTimeoutMs ?? this.registration.requestTimeoutMs ?? 30_000;
   }
 
   private requireTransport(): ZLinkRouteClientTransport {
@@ -329,11 +337,12 @@ export class DefaultZLinkRouteClient implements ZLinkRouteClient {
   private requireSpotTransport(): ZLinkSpotRoutedTransport {
     const transport = this.requireTransport();
     if (transport.sendToSpot === undefined || transport.requestToSpot === undefined) {
-      throw new ZLinkConfigurationException('Route channel runtime does not support SpotHandle messaging.');
+      throw new ZLinkConfigurationException(
+        'Route channel runtime does not support SpotHandle messaging.'
+      );
     }
     return transport as ZLinkSpotRoutedTransport;
   }
-
 }
 
 export class DefaultZLinkSpotPublisherClient implements ZLinkSpotPublisherClient {
@@ -346,13 +355,24 @@ export class DefaultZLinkSpotPublisherClient implements ZLinkSpotPublisherClient
     return new DefaultZLinkPublishCall(
       () => this.requireMeshChannel(meshName, channelName),
       (packetName, metadata, signal) =>
-        this.requireTransport().publish(meshName, channelName, topic, packetName, event, signal, metadata)
+        this.requireTransport().publish(
+          meshName,
+          channelName,
+          topic,
+          packetName,
+          event,
+          signal,
+          metadata
+        )
     );
   }
 
   private requireMeshChannel(meshName: string, channelName: string): void {
     const mesh = this.registration.spotNodes.get(meshName);
-    if (mesh === undefined || !Object.prototype.hasOwnProperty.call(mesh.meshChannels ?? {}, channelName)) {
+    if (
+      mesh === undefined ||
+      !Object.prototype.hasOwnProperty.call(mesh.meshChannels ?? {}, channelName)
+    ) {
       throw new ZLinkConfigurationException(
         `Channel '${channelName}' is not registered in RouteMesh '${meshName}'.`
       );