@zlink-systems/framework 0.21.0 → 0.22.0

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

@@ -1,8 +1,4 @@
-import type {
-  Context,
-  CoreHwmBudgetSnapshot,
-  TopicMessage
-} from '@zlink-systems/zlink';
+import type { Context, CoreHwmBudgetSnapshot, TopicMessage } from '@zlink-systems/zlink';
 import type { ZLinkCoreHwmOptions } from '../../../contracts/Configuration';
 import type {
   ZLinkBackendAdapterFactory,
@@ -81,7 +77,9 @@ class ZLinkNodeChannelBackendAdapter implements ZLinkChannelBackendAdapter {
   }
 
   createPublisherSocket(context: ZLinkBackendContext): ZLinkBackendPublisherSocket {
-    return wrapSocket(zlink.createPubSocket(asNodeContext(context))) as unknown as ZLinkBackendPublisherSocket;
+    return wrapSocket(
+      zlink.createPubSocket(asNodeContext(context))
+    ) as unknown as ZLinkBackendPublisherSocket;
   }
 
   createSubscriberSocket(context: ZLinkBackendContext): ZLinkBackendSubscriberSocket {
@@ -115,7 +113,9 @@ class ZLinkNodeStreamBackendAdapter implements ZLinkStreamBackendAdapter {
 class ZLinkNodeMonitoringBackendAdapter implements ZLinkMonitoringBackendAdapter {
   openSocketMonitor(socket: ZLinkBackendSocket): ZLinkBackendSocketMonitor {
     const nativeSocket = socket.nativeInstance as {
-      monitorOpen(): ReturnType<ZLinkBindingModule['createDealerSocket']>['monitorOpen'] extends (...args: never[]) => infer T
+      monitorOpen(): ReturnType<ZLinkBindingModule['createDealerSocket']>['monitorOpen'] extends (
+        ...args: never[]
+      ) => infer T
         ? T
         : never;
     };
@@ -133,8 +133,10 @@ class ZLinkNodeBackendContext implements ZLinkBackendContext {
   configureCoreHwm(options: ZLinkCoreHwmOptions | undefined): void {
     if (options === undefined) return;
     if (options.profile !== undefined) this.nativeInstance.options.coreHwmProfile = options.profile;
-    if (options.memoryLimitBytes !== undefined) this.nativeInstance.options.coreHwmMemoryLimitBytes = options.memoryLimitBytes;
-    if (options.budgetBytes !== undefined) this.nativeInstance.options.coreHwmBudgetBytes = options.budgetBytes;
+    if (options.memoryLimitBytes !== undefined)
+      this.nativeInstance.options.coreHwmMemoryLimitBytes = options.memoryLimitBytes;
+    if (options.budgetBytes !== undefined)
+      this.nativeInstance.options.coreHwmBudgetBytes = options.budgetBytes;
   }
 
   getCoreHwmBudgetSnapshot(): CoreHwmBudgetSnapshot {
@@ -170,18 +172,20 @@ function asNodeContext(context: ZLinkBackendContext): Context {
   return context.nativeInstance as Context;
 }
 
-function createNodeReadablePoller(
-  socket: { readonly nativeInstance: unknown }
-): ZLinkBackendReadablePoller {
+function createNodeReadablePoller(socket: {
+  readonly nativeInstance: unknown;
+}): ZLinkBackendReadablePoller {
   const eventLoopPoller = nodeEventLoopPollerOf(socket);
   let disposed = false;
   let readable = false;
-  let pending: {
-    readonly promise: Promise<boolean>;
-    readonly resolve: (readable: boolean) => void;
-    readonly signal?: AbortSignal;
-    readonly onAbort?: () => void;
-  } | undefined;
+  let pending:
+    | {
+        readonly promise: Promise<boolean>;
+        readonly resolve: (readable: boolean) => void;
+        readonly signal?: AbortSignal;
+        readonly onAbort?: () => void;
+      }
+    | undefined;
 
   const settlePending = (value: boolean): void => {
     const current = pending;
@@ -212,9 +216,7 @@ function createNodeReadablePoller(
       const promise = new Promise<boolean>((resolve) => {
         resolvePending = resolve;
       });
-      const onAbort = signal === undefined
-        ? undefined
-        : (): void => settlePending(false);
+      const onAbort = signal === undefined ? undefined : (): void => settlePending(false);
       pending = { promise, resolve: resolvePending, signal, onAbort };
       if (signal !== undefined && onAbort !== undefined) {
         signal.addEventListener('abort', onAbort, { once: true });

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

@@ -54,10 +54,13 @@ function isNonBlockingRecvEmpty(error: unknown): boolean {
 }
 
 export function isRouteRecvRetryable(error: unknown): boolean {
-  return isNonBlockingRecvEmpty(error) ||
+  return (
+    isNonBlockingRecvEmpty(error) ||
     (error instanceof zlink.RecvError &&
-      (error.result === zlink.RecvResult.InternalError || error.result === zlink.RecvResult.InvalidHandle) &&
-      isNativeBadAddress(error));
+      (error.result === zlink.RecvResult.InternalError ||
+        error.result === zlink.RecvResult.InvalidHandle) &&
+      isNativeBadAddress(error))
+  );
 }
 
 export function isPollerInterruptedError(error: unknown): boolean {
@@ -82,10 +85,12 @@ export function submitBindingPublish(
     current!.submit();
   } catch (error) {
     const translated = translateBindingResultError(error);
-    if (translated instanceof ZLinkBackendResultError
-        && translated.operation === 'submit'
-        && (translated.result === SubmitResult.Backpressured
-          || translated.result === SubmitResult.NotAdmitted)) {
+    if (
+      translated instanceof ZLinkBackendResultError &&
+      translated.operation === 'submit' &&
+      (translated.result === SubmitResult.Backpressured ||
+        translated.result === SubmitResult.NotAdmitted)
+    ) {
       requireOneWayCompletion(
         { status: ZLinkSubmitStatus.Backpressured },
         'Classic fanout publish'
@@ -95,10 +100,7 @@ export function submitBindingPublish(
   }
 }
 
-export function submitBindingReply(
-  operation: ZLinkBindingReplyOperation,
-  payload: unknown
-): void {
+export function submitBindingReply(operation: ZLinkBindingReplyOperation, payload: unknown): void {
   try {
     let current: ZLinkBindingReplySubmitOperation | undefined;
     const parts = Array.isArray(payload) ? payload : [payload];
@@ -158,7 +160,8 @@ export async function submitBindingRequest(
     if (Array.isArray(payload)) {
       for (const part of payload) {
         const nativePart = toNativeMessageLike(part);
-        current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+        current =
+          current === undefined ? operation.message(nativePart) : current.message(nativePart);
       }
     } else {
       current = operation.message(toNativeMessageLike(payload));
@@ -187,19 +190,26 @@ export async function closeWithBusyRetry(target: { close(): void }): Promise<voi
         throw error;
       }
       lastError = error;
-      await new Promise<void>(resolve => setImmediate(resolve));
+      await new Promise<void>((resolve) => setImmediate(resolve));
     }
   }
   throw lastError;
 }
 
 function isBusyCloseError(error: unknown): boolean {
-  return error instanceof Error && 'code' in error && [401, 404].includes((error as { code: number }).code);
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    [401, 404].includes((error as { code: number }).code)
+  );
 }
 
 function isSuccessfulOrAlreadyShutdownCloseError(error: unknown): boolean {
-  return isContextTerminatedError(error) || (
-    error instanceof Error && 'code' in error && [0, 402, 403].includes((error as { code: number }).code)
+  return (
+    isContextTerminatedError(error) ||
+    (error instanceof Error &&
+      'code' in error &&
+      [0, 402, 403].includes((error as { code: number }).code))
   );
 }
 
@@ -229,14 +239,16 @@ export function disableSocketLinger(target: unknown): void {
 export function toNativeRoutingId(routingId: unknown): unknown {
   if (typeof routingId === 'string') return zlink.RoutingId.from(routingId);
   const toHex = (routingId as { readonly toHex?: unknown } | null)?.toHex;
-  return typeof toHex === 'function'
-    ? zlink.RoutingId.fromHex(toHex.call(routingId))
-    : routingId;
+  return typeof toHex === 'function' ? zlink.RoutingId.fromHex(toHex.call(routingId)) : routingId;
 }
 
 function toNativeMessageLike(message: unknown): unknown {
-  if (message instanceof zlink.Message || Buffer.isBuffer(message)
-      || message instanceof Uint8Array || typeof message === 'string') {
+  if (
+    message instanceof zlink.Message ||
+    Buffer.isBuffer(message) ||
+    message instanceof Uint8Array ||
+    typeof message === 'string'
+  ) {
     return message;
   }
   const data = (message as { readonly data?: unknown } | null)?.data;
@@ -252,7 +264,9 @@ export function translateBindingResultError(error: unknown): unknown {
     return new ZLinkBackendResultError('submit', error.result, error.nativeErrno, { cause: error });
   }
   if (error instanceof zlink.RequestError) {
-    return new ZLinkBackendResultError('request', error.result, error.nativeErrno, { cause: error });
+    return new ZLinkBackendResultError('request', error.result, error.nativeErrno, {
+      cause: error
+    });
   }
   return error;
 }

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

@@ -1,23 +1,13 @@
-import type {
-  DealerSocket,
-  Message,
-  PubSocket
-} from '@zlink-systems/zlink';
+import type { DealerSocket, Message, PubSocket } from '@zlink-systems/zlink';
 import { ZLinkConfigurationException } from '../../configuration';
-import {
-  ZLinkSubmitStatus,
-  type ZLinkSubmitResult
-} from '../../messaging/submission-result';
+import { ZLinkSubmitStatus, type ZLinkSubmitResult } from '../../messaging/submission-result';
 import {
   decodeChannelReply,
   encodeChannelEnvelopeParts,
   ZLinkChannelMessageKind
 } from '../../channels/channel-envelope';
 import { throwIfAborted } from '../../abort';
-import {
-  appendParts,
-  submitRequestOperation
-} from '../../channels/channel-multipart';
+import { appendParts, submitRequestOperation } from '../../channels/channel-multipart';
 import type { ZLinkChannelClientTransport } from '../../channels/channel-transports';
 import { runWithOutboundFlow } from '../../diagnostics/flow-context';
 
@@ -40,21 +30,25 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     throwIfAborted(signal);
     // Call-scoped flow (spec 27 §4): the envelope flow pair does not outlive
     // this outbound call.
-    await runWithOutboundFlow(true, () => appendParts(
-      this.dealer.send(),
-      encodeChannelEnvelopeParts(
-        ZLinkChannelMessageKind.Command,
-        channelName,
-        packetName,
-        message,
-        undefined,
-        undefined,
-        undefined,
-        undefined,
-        true,
-        metadata
-      )
-    ).submit().admitted);
+    await runWithOutboundFlow(
+      true,
+      () =>
+        appendParts(
+          this.dealer.send(),
+          encodeChannelEnvelopeParts(
+            ZLinkChannelMessageKind.Command,
+            channelName,
+            packetName,
+            message,
+            undefined,
+            undefined,
+            undefined,
+            undefined,
+            true,
+            metadata
+          )
+        ).submit().admitted
+    );
     return { status: ZLinkSubmitStatus.Submitted };
   }
 
@@ -67,23 +61,28 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     metadata: ReadonlyMap<string, string> = EMPTY_METADATA
   ): Promise<TReply> {
     throwIfAborted(signal);
-    const operation = runWithOutboundFlow(true, () => appendParts(
-      this.dealer.request(),
-      encodeChannelEnvelopeParts(
-        ZLinkChannelMessageKind.Request,
-        channelName,
-        packetName,
-        request,
-        timeoutMs,
-        undefined,
-        undefined,
-        undefined,
-        true,
-        metadata
+    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: () => operation.submit().reply }, 'channel request');
+    const reply = await submitRequestOperation(
+      { submit: () => operation.submit().reply },
+      'channel request'
+    );
     try {
       return decodeChannelReply<TReply>(reply);
     } finally {
@@ -101,21 +100,23 @@ export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTran
     if (this.publisher === undefined) {
       throw new ZLinkConfigurationException('Channel publisher runtime is not started.');
     }
-    runWithOutboundFlow(true, () => appendParts(
-      this.publisher!.publish(topic),
-      encodeChannelEnvelopeParts(
-        ZLinkChannelMessageKind.Publish,
-        channelName,
-        packetName,
-        event,
-        undefined,
-        topic,
-        undefined,
-        undefined,
-        true,
-        metadata
-      )
-    ).submit());
+    runWithOutboundFlow(true, () =>
+      appendParts(
+        this.publisher!.publish(topic),
+        encodeChannelEnvelopeParts(
+          ZLinkChannelMessageKind.Publish,
+          channelName,
+          packetName,
+          event,
+          undefined,
+          topic,
+          undefined,
+          undefined,
+          true,
+          metadata
+        )
+      ).submit()
+    );
     return { status: ZLinkSubmitStatus.Submitted };
   }
 

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

@@ -1,8 +1,4 @@
-import type {
-  BaseSocket,
-  PollEventFlagValue,
-  Socket
-} from '@zlink-systems/zlink';
+import type { BaseSocket, PollEventFlagValue, Socket } from '@zlink-systems/zlink';
 import { zlink } from './node-backend-adapter-support';
 
 /**
@@ -16,11 +12,7 @@ export class ZLinkNodeEventLoopPoller {
   private readableHandler: () => void;
   private disposed = false;
 
-  constructor(
-    socket: Socket,
-    pollCompletion: boolean,
-    readableHandler: () => void
-  ) {
+  constructor(socket: Socket, pollCompletion: boolean, readableHandler: () => void) {
     this.readableHandler = readableHandler;
     try {
       const pollEvents: PollEventFlagValue[] = [zlink.PollEventFlag.PollIn];

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

@@ -21,11 +21,15 @@ export class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
     }
   ): ZLinkBackendMeshNode {
     if (options.trustProfile !== undefined) {
-      throw new Error('M6A raw MeshNode trust profiles require the service admission security runtime.');
+      throw new Error(
+        'M6A raw MeshNode trust profiles require the service admission security runtime.'
+      );
     }
     const bindingContext = context.nativeInstance;
     if (!isBindingContext(bindingContext)) {
-      throw new TypeError('Node MeshNode creation requires the Node binding Context owned by the host.');
+      throw new TypeError(
+        'Node MeshNode creation requires the Node binding Context owned by the host.'
+      );
     }
     return new ZLinkNodeRawMeshBackend(
       options.meshName,
@@ -39,7 +43,10 @@ export class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
 }
 
 function isBindingContext(value: unknown): value is Context {
-  return typeof value === 'object' && value !== null
-    && typeof (value as { shutdown?: unknown }).shutdown === 'function'
-    && typeof (value as { close?: unknown }).close === 'function';
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { shutdown?: unknown }).shutdown === 'function' &&
+    typeof (value as { close?: unknown }).close === 'function'
+  );
 }

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

@@ -2,9 +2,10 @@ import type { MonitorEvent } from '@zlink-systems/zlink';
 import type { ZLinkBackendSocketMonitor, ZLinkBackendSocketMonitorEvent } from '../contracts';
 import { zlink } from './node-backend-adapter-support';
 
-export function wrapMonitorSocket(
-  nativeInstance: { close(): void; recv(flags?: number): MonitorEvent | null }
-): ZLinkBackendSocketMonitor {
+export function wrapMonitorSocket(nativeInstance: {
+  close(): void;
+  recv(flags?: number): MonitorEvent | null;
+}): ZLinkBackendSocketMonitor {
   const handlers = new Set<(event: ZLinkBackendSocketMonitorEvent) => void>();
   return {
     nativeInstance,

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

@@ -73,10 +73,9 @@ class NodeRawHostPort implements ZLinkRawHostPort {
 
   createRouter(): ZLinkRawRouterPort {
     this.requireOpen();
-    return this.own(new NodeRawRouterPort(
-      createRouterSocket(this.context),
-      this.routerReceiveTimeoutMs
-    ));
+    return this.own(
+      new NodeRawRouterPort(createRouterSocket(this.context), this.routerReceiveTimeoutMs)
+    );
   }
 
   createDealer(): ZLinkRawDealerPort {
@@ -133,11 +132,7 @@ abstract class NodeRawSocketPort<TSocket extends Socket> implements ZLinkRawSock
   private closed = false;
 
   protected constructor(protected readonly socket: TSocket) {
-    this.eventLoopPoller = new ZLinkNodeEventLoopPoller(
-      socket,
-      true,
-      () => {}
-    );
+    this.eventLoopPoller = new ZLinkNodeEventLoopPoller(socket, true, () => {});
   }
 
   setReadableHandler(handler: () => void): void {
@@ -233,9 +228,11 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
   private nextIncomingRequestSequence = 1n;
   disconnectRid(routingId: string): void {
     this.requireOpen();
-    (this.socket as RouterSocket & {
-      disconnectRid(value: BindingRoutingId): void;
-    }).disconnectRid(bindingRoutingId(routingId));
+    (
+      this.socket as RouterSocket & {
+        disconnectRid(value: BindingRoutingId): void;
+      }
+    ).disconnectRid(bindingRoutingId(routingId));
   }
 
   constructor(socket: RouterSocket, receiveTimeoutMs?: number) {
@@ -282,7 +279,10 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
   ): Promise<readonly Buffer[]> {
     this.requireOpen();
     try {
-      const replies = await appendRequestParts(this.socket.request(bindingRoutingId(targetRid)), parts)
+      const replies = await appendRequestParts(
+        this.socket.request(bindingRoutingId(targetRid)),
+        parts
+      )
         .timeout(timeoutMs)
         .submit().reply;
       return copyAndClose(replies);
@@ -298,9 +298,8 @@ class NodeRawRouterPort extends NodeRawSocketPort<RouterSocket> implements ZLink
       dontWait,
       () => {
         const current = this.nextIncomingRequestSequence;
-        this.nextIncomingRequestSequence = current === BigInt(Number.MAX_SAFE_INTEGER)
-          ? 1n
-          : current + 1n;
+        this.nextIncomingRequestSequence =
+          current === BigInt(Number.MAX_SAFE_INTEGER) ? 1n : current + 1n;
         return current;
       },
       (targetRid, replyToken, parts) => {
@@ -333,7 +332,9 @@ class NodeRawDealerPort extends NodeRawSocketPort<DealerSocket> implements ZLink
 
   async request(parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]> {
     this.requireOpen();
-    const replies = await appendRequestParts(this.socket.request(), parts).timeout(timeoutMs).submit().reply;
+    const replies = await appendRequestParts(this.socket.request(), parts)
+      .timeout(timeoutMs)
+      .submit().reply;
     return copyAndClose(replies);
   }
 
@@ -412,7 +413,8 @@ function appendReplyParts(
 }
 
 function requireParts(parts: readonly Uint8Array[]): [Uint8Array, ...Uint8Array[]] {
-  if (parts.length === 0) throw new TypeError('Raw multipart operation requires at least one part.');
+  if (parts.length === 0)
+    throw new TypeError('Raw multipart operation requires at least one part.');
   return parts as [Uint8Array, ...Uint8Array[]];
 }
 
@@ -429,10 +431,7 @@ function receiveRecord(
   reply?: RawReceivedReply
 ): ZLinkRawReceivedRecord | undefined {
   const received = new Received();
-  if (!socket.recv(
-    received,
-    dontWait ? RecvFlags.DontWait : RecvFlags.None
-  )) {
+  if (!socket.recv(received, dontWait ? RecvFlags.DontWait : RecvFlags.None)) {
     received.close();
     return undefined;
   }
@@ -442,11 +441,12 @@ function receiveRecord(
     const sourceRoute = received.routingId?.toBytes() ?? Buffer.alloc(0);
     const requestSeq = received.replyToken === null ? undefined : nextRequestSequence?.();
     const replyToken = received.replyToken;
-    const receivedReply = replyToken === null
-      ? undefined
-      : reply === undefined
-        ? received.reply()
-        : (parts: readonly Uint8Array[]) => reply(sourceRoute, replyToken, parts);
+    const receivedReply =
+      replyToken === null
+        ? undefined
+        : reply === undefined
+          ? received.reply()
+          : (parts: readonly Uint8Array[]) => reply(sourceRoute, replyToken, parts);
     return {
       sourceRid,
       sourceRoute,
@@ -462,7 +462,7 @@ function receiveRecord(
               appendReplyParts(receivedReply, parts).submit();
             }
           }),
-      parts: received.parts.map(part => part.toBytes()),
+      parts: received.parts.map((part) => part.toBytes()),
       close: () => {
         if (closed) return;
         closed = true;
@@ -477,7 +477,7 @@ function receiveRecord(
 
 function copyAndClose(messages: readonly Message[]): readonly Buffer[] {
   try {
-    return messages.map(message => message.toBytes());
+    return messages.map((message) => message.toBytes());
   } finally {
     for (const message of messages) message.close();
   }