@zlink-systems/framework 0.10.0

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

@@ -0,0 +1,204 @@
+import type {
+  Context,
+  CoreHwmBudgetSnapshot,
+  Received,
+  TopicMessage
+} from '@zlink-systems/zlink';
+import type { ZLinkCoreHwmOptions } from '../../../contracts/Configuration';
+import type {
+  ZLinkBackendAdapterFactory,
+  ZLinkBackendContext,
+  ZLinkBackendDealerSocket,
+  ZLinkBackendPublisherSocket,
+  ZLinkBackendReadablePoller,
+  ZLinkBackendRouterSocket,
+  ZLinkBackendSocket,
+  ZLinkBackendSocketMonitor,
+  ZLinkBackendStreamPacket,
+  ZLinkBackendStreamSocket,
+  ZLinkBackendSubscriberSocket,
+  ZLinkChannelBackendAdapter,
+  ZLinkMonitoringBackendAdapter,
+  ZLinkStreamBackendAdapter
+} from '../contracts';
+import {
+  closeWithBusyRetry,
+  isContextTerminatedError,
+  isPollerInterruptedError,
+  zlink,
+  type ZLinkBindingModule
+} from './node-backend-adapter-support';
+import { wrapMonitorSocket } from './node-monitor-backend-adapter';
+import { wrapSocket } from './node-socket-backend-adapter';
+import { ZLinkNodeMeshBackendAdapter } from './node-mesh-backend-adapter';
+
+export { isDisconnectRouteNotFoundError } from './node-socket-backend-adapter';
+
+export class ZLinkNodeBackendAdapterFactory implements ZLinkBackendAdapterFactory {
+  createReceived(): Received {
+    return new zlink.Received();
+  }
+
+  createTopicMessage(): TopicMessage {
+    return new zlink.TopicMessage();
+  }
+
+  createChannelAdapter(): ZLinkChannelBackendAdapter {
+    return new ZLinkNodeChannelBackendAdapter();
+  }
+
+  createMeshAdapter(): ZLinkNodeMeshBackendAdapter {
+    return new ZLinkNodeMeshBackendAdapter();
+  }
+
+  createStreamAdapter(): ZLinkStreamBackendAdapter {
+    return new ZLinkNodeStreamBackendAdapter();
+  }
+
+  createMonitoringAdapter(): ZLinkMonitoringBackendAdapter {
+    return new ZLinkNodeMonitoringBackendAdapter();
+  }
+}
+
+class ZLinkNodeChannelBackendAdapter implements ZLinkChannelBackendAdapter {
+  createContext(): ZLinkBackendContext {
+    return new ZLinkNodeBackendContext(zlink.createContext());
+  }
+
+  createTopicMessage(): TopicMessage {
+    return new zlink.TopicMessage();
+  }
+
+  createDealerSocket(context: ZLinkBackendContext): ZLinkBackendDealerSocket {
+    return wrapSocket(zlink.createDealerSocket(asNodeContext(context))) as unknown as ZLinkBackendDealerSocket;
+  }
+
+  createRouterSocket(context: ZLinkBackendContext): ZLinkBackendRouterSocket {
+    return wrapSocket(zlink.createRouterSocket(asNodeContext(context))) as unknown as ZLinkBackendRouterSocket;
+  }
+
+  createPublisherSocket(context: ZLinkBackendContext): ZLinkBackendPublisherSocket {
+    return wrapSocket(zlink.createPubSocket(asNodeContext(context))) as unknown as ZLinkBackendPublisherSocket;
+  }
+
+  createSubscriberSocket(context: ZLinkBackendContext): ZLinkBackendSubscriberSocket {
+    return wrapSocket(zlink.createSubSocket(asNodeContext(context))) as unknown as ZLinkBackendSubscriberSocket;
+  }
+
+  createReadablePoller(socket: ZLinkBackendSubscriberSocket): ZLinkBackendReadablePoller {
+    return createNodeReadablePoller(socket);
+  }
+}
+
+class ZLinkNodeStreamBackendAdapter implements ZLinkStreamBackendAdapter {
+  createStreamSocket(context: ZLinkBackendContext): ZLinkBackendStreamSocket {
+    const socket = zlink.createStreamSocket(asNodeContext(context));
+    socket.options.recvMode = zlink.StreamRecvMode.Packet;
+    return wrapSocket(socket) as unknown as ZLinkBackendStreamSocket;
+  }
+
+  createStreamPacket(): ZLinkBackendStreamPacket {
+    return new zlink.StreamPacket() as ZLinkBackendStreamPacket;
+  }
+
+  createReadablePoller(socket: ZLinkBackendStreamSocket): ZLinkBackendReadablePoller {
+    return createNodeReadablePoller(socket);
+  }
+}
+
+class ZLinkNodeMonitoringBackendAdapter implements ZLinkMonitoringBackendAdapter {
+  openSocketMonitor(socket: ZLinkBackendSocket): ZLinkBackendSocketMonitor {
+    const nativeSocket = socket.nativeInstance as {
+      monitorOpen(): ReturnType<ZLinkBindingModule['createDealerSocket']>['monitorOpen'] extends (...args: never[]) => infer T
+        ? T
+        : never;
+    };
+    return wrapMonitorSocket(nativeSocket.monitorOpen());
+  }
+}
+
+class ZLinkNodeBackendContext implements ZLinkBackendContext {
+  constructor(readonly nativeInstance: Context) {}
+
+  shutdown(): void {
+    this.nativeInstance.shutdown();
+  }
+
+  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;
+  }
+
+  getCoreHwmBudgetSnapshot(): CoreHwmBudgetSnapshot {
+    return this.nativeInstance.getCoreHwmBudgetSnapshot();
+  }
+
+  resetCoreHwmBudgetMetrics(): void {
+    this.nativeInstance.resetCoreHwmBudgetMetrics();
+  }
+
+  async dispose(): Promise<void> {
+    // Terminal cleanup shuts the context down before terminating it, the same
+    // sequence the .NET reference binding runs inside `Context.Dispose()`
+    // (`zlink_ctx_shutdown` then `zlink_ctx_term`). Without the shutdown signal
+    // termination can block forever waiting on the reaper even after every
+    // socket this runtime owns has been closed.
+    try {
+      this.nativeInstance.shutdown();
+    } catch (error) {
+      if (!isContextTerminatedError(error)) {
+        throw error;
+      }
+    }
+    await closeWithBusyRetry(this.nativeInstance);
+  }
+
+  close(): void {
+    this.nativeInstance.close();
+  }
+}
+
+function asNodeContext(context: ZLinkBackendContext): Context {
+  return context.nativeInstance as Context;
+}
+
+function createNodeReadablePoller(
+  socket: { readonly nativeInstance: unknown }
+): ZLinkBackendReadablePoller {
+  const poller = zlink.createPoller();
+  const events = zlink.createPollEvents(1);
+  try {
+    poller.add(socket.nativeInstance as never, [zlink.PollEventFlag.PollIn], 0);
+  } catch (error) {
+    events.close();
+    poller.close();
+    throw error;
+  }
+  let disposed = false;
+  return {
+    wait(timeoutMs: number): boolean {
+      try {
+        return poller.wait(events, timeoutMs) > 0
+          && events.hasEvent(0, zlink.PollEventFlag.PollIn);
+      } catch (error) {
+        if (isPollerInterruptedError(error)) return false;
+        throw error;
+      }
+    },
+    dispose(): void {
+      if (disposed) return;
+      disposed = true;
+      try {
+        poller.remove(socket.nativeInstance as never);
+      } finally {
+        try {
+          events.close();
+        } finally {
+          poller.close();
+        }
+      }
+    }
+  };
+}

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

@@ -0,0 +1,257 @@
+import { loadBinding } from '../node-backend-adapter';
+import { ZLinkBackendResultError } from '../runtime-values';
+
+export type ZLinkBindingModule = typeof import('@zlink-systems/zlink');
+export const zlink = loadBinding() as ZLinkBindingModule;
+
+export type ZLinkBindingOperation = { [key: string]: (...args: unknown[]) => unknown };
+
+export interface ZLinkBindingAsyncSendOperation {
+  message(message: unknown): ZLinkBindingAsyncSendSubmitOperation;
+}
+
+export interface ZLinkBindingPublishOperation {
+  message(message: unknown): ZLinkBindingPublishSubmitOperation;
+}
+
+export interface ZLinkBindingReplyOperation {
+  message(message: unknown): ZLinkBindingReplySubmitOperation;
+}
+
+interface ZLinkBindingPublishSubmitOperation {
+  message(message: unknown): ZLinkBindingPublishSubmitOperation;
+  submit(): void;
+}
+
+interface ZLinkBindingReplySubmitOperation {
+  message(message: unknown): ZLinkBindingReplySubmitOperation;
+  submit(): void;
+}
+
+interface ZLinkBindingAsyncSendSubmitOperation {
+  message(message: unknown): ZLinkBindingAsyncSendSubmitOperation;
+  submit(): Promise<void>;
+  submit_sync(): void;
+}
+
+export interface ZLinkBindingRequestOperation {
+  message(message: unknown): ZLinkBindingRequestSubmitOperation;
+}
+
+interface ZLinkBindingRequestSubmitOperation {
+  message(message: unknown): ZLinkBindingRequestSubmitOperation;
+  timeout(timeoutMs: number): ZLinkBindingRequestSubmitOperation;
+  submit(): Promise<readonly unknown[]>;
+}
+
+export function isBindingNotFound(error: unknown): boolean {
+  return error instanceof zlink.ConfigError && error.result === zlink.ConfigResult.NotFound;
+}
+
+function isNonBlockingRecvEmpty(error: unknown): boolean {
+  return error instanceof zlink.RecvError && error.result === zlink.RecvResult.NoData;
+}
+
+export function isRouteRecvRetryable(error: unknown): boolean {
+  return isNonBlockingRecvEmpty(error) ||
+    (error instanceof zlink.RecvError &&
+      (error.result === zlink.RecvResult.InternalError || error.result === zlink.RecvResult.InvalidHandle) &&
+      isNativeBadAddress(error));
+}
+
+export function isPollerInterruptedError(error: unknown): boolean {
+  return error instanceof zlink.RecvError && error.nativeErrno === 4;
+}
+
+function isNativeBadAddress(error: { nativeErrno?: unknown; message?: unknown }): boolean {
+  return error.nativeErrno === 14 || /Bad address/i.test(String(error.message ?? ''));
+}
+
+export function submitBindingPublish(
+  operation: ZLinkBindingPublishOperation,
+  payload: unknown
+): void {
+  try {
+    let current: ZLinkBindingPublishSubmitOperation | undefined;
+    const parts = Array.isArray(payload) ? payload : [payload];
+    for (const part of parts.length === 0 ? [Buffer.alloc(0)] : parts) {
+      const nativePart = toNativeMessageLike(part);
+      current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+    }
+    current!.submit();
+  } catch (error) {
+    throw translateBindingResultError(error);
+  }
+}
+
+export function submitBindingReply(
+  operation: ZLinkBindingReplyOperation,
+  payload: unknown
+): void {
+  try {
+    let current: ZLinkBindingReplySubmitOperation | undefined;
+    const parts = Array.isArray(payload) ? payload : [payload];
+    for (const part of parts.length === 0 ? [Buffer.alloc(0)] : parts) {
+      const nativePart = toNativeMessageLike(part);
+      current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+    }
+    current!.submit();
+  } catch (error) {
+    throw translateBindingResultError(error);
+  }
+}
+
+export async function submitBindingAsyncSend(
+  operation: ZLinkBindingAsyncSendOperation,
+  payload: unknown
+): Promise<void> {
+  try {
+    let current: ZLinkBindingAsyncSendSubmitOperation | undefined;
+    const parts = Array.isArray(payload) ? payload : [payload];
+    for (const part of parts) {
+      const nativePart = toNativeMessageLike(part);
+      current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+    }
+    current ??= operation.message(Buffer.alloc(0));
+    await current.submit();
+  } catch (error) {
+    throw translateBindingResultError(error);
+  }
+}
+
+export function submitBindingSyncSend(
+  operation: ZLinkBindingAsyncSendOperation,
+  payload: unknown
+): void {
+  try {
+    let current: ZLinkBindingAsyncSendSubmitOperation | undefined;
+    const parts = Array.isArray(payload) ? payload : [payload];
+    for (const part of parts) {
+      const nativePart = toNativeMessageLike(part);
+      current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+    }
+    current ??= operation.message(Buffer.alloc(0));
+    current.submit_sync();
+  } catch (error) {
+    throw translateBindingResultError(error);
+  }
+}
+
+export async function submitBindingRequest(
+  operation: ZLinkBindingRequestOperation,
+  payload: unknown,
+  timeoutMs: number | undefined
+): Promise<readonly unknown[]> {
+  try {
+    let current: ZLinkBindingRequestSubmitOperation | undefined;
+    if (Array.isArray(payload)) {
+      for (const part of payload) {
+        const nativePart = toNativeMessageLike(part);
+        current = current === undefined ? operation.message(nativePart) : current.message(nativePart);
+      }
+    } else {
+      current = operation.message(toNativeMessageLike(payload));
+    }
+    current ??= operation.message(Buffer.alloc(0));
+    if (timeoutMs !== undefined) {
+      current = current.timeout(timeoutMs);
+    }
+    return await current.submit();
+  } catch (error) {
+    throw translateBindingResultError(error);
+  }
+}
+
+export async function closeWithBusyRetry(target: { close(): void }): Promise<void> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt < 8; attempt++) {
+    try {
+      target.close();
+      return;
+    } catch (error) {
+      if (isSuccessfulOrAlreadyShutdownCloseError(error)) {
+        return;
+      }
+      if (!isBusyCloseError(error)) {
+        throw error;
+      }
+      lastError = error;
+      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);
+}
+
+function isSuccessfulOrAlreadyShutdownCloseError(error: unknown): boolean {
+  return isContextTerminatedError(error) || (
+    error instanceof Error && 'code' in error && [0, 402, 403].includes((error as { code: number }).code)
+  );
+}
+
+export function isContextTerminatedError(error: unknown): boolean {
+  return error instanceof Error && /context was terminated/i.test(error.message);
+}
+
+export function disableSocketLinger(target: unknown): void {
+  if (
+    target !== null &&
+    typeof target === 'object' &&
+    'options' in target &&
+    typeof target.options === 'object' &&
+    target.options !== null &&
+    'linger' in target.options
+  ) {
+    try {
+      (target.options as { linger: number }).linger = 0;
+    } catch (error) {
+      if (!isContextTerminatedError(error)) {
+        throw error;
+      }
+    }
+  }
+}
+
+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;
+}
+
+function toNativeMessageLike(message: unknown): unknown {
+  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;
+  if (typeof data === 'function') {
+    const bytes = data.call(message);
+    if (bytes instanceof Uint8Array) return Buffer.from(bytes);
+  }
+  return message;
+}
+
+export function translateBindingResultError(error: unknown): unknown {
+  if (error instanceof zlink.SubmitError) {
+    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 error;
+}
+
+export function toNativeActorRef(actor: unknown): unknown {
+  if (typeof actor !== 'object' || actor === null || !('nodeRid' in actor)) {
+    return actor;
+  }
+  return {
+    ...(actor as Record<string, unknown>),
+    nodeRid: toNativeRoutingId((actor as { nodeRid: unknown }).nodeRid)
+  };
+}

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

@@ -0,0 +1,133 @@
+import type {
+  DealerSocket,
+  Message,
+  PubSocket
+} from '@zlink-systems/zlink';
+import { ZLinkConfigurationException } from '../../configuration';
+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 type { ZLinkChannelClientTransport } from '../../channels/channel-transports';
+import { runWithOutboundFlow } from '../../diagnostics/flow-context';
+
+const EMPTY_METADATA: ReadonlyMap<string, string> = new Map();
+
+/** Adapter used by direct binding-socket integration and its contract tests. */
+export class ZLinkDealerChannelClientTransport implements ZLinkChannelClientTransport {
+  constructor(
+    private readonly dealer: DealerSocket,
+    private readonly publisher?: PubSocket
+  ) {}
+
+  async send(
+    channelName: string,
+    packetName: string | undefined,
+    message: Message,
+    signal?: AbortSignal,
+    metadata: ReadonlyMap<string, string> = EMPTY_METADATA
+  ): Promise<ZLinkSubmitResult> {
+    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());
+    return { status: ZLinkSubmitStatus.Submitted };
+  }
+
+  async request<TReply>(
+    channelName: string,
+    packetName: string | undefined,
+    request: Message,
+    timeoutMs: number | undefined,
+    signal?: AbortSignal,
+    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
+      )
+    ));
+    if (timeoutMs !== undefined) operation.timeout(timeoutMs);
+    const reply = await submitRequestOperation(operation, 'channel request');
+    try {
+      return decodeChannelReply<TReply>(reply);
+    } finally {
+      for (const part of reply) part.close();
+    }
+  }
+
+  tryPublish(
+    channelName: string,
+    topic: string,
+    packetName: string | undefined,
+    event: Message,
+    metadata: ReadonlyMap<string, string> = EMPTY_METADATA
+  ): ZLinkSubmitResult {
+    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());
+    return { status: ZLinkSubmitStatus.Submitted };
+  }
+
+  async publish(
+    channelName: string,
+    topic: string,
+    packetName: string | undefined,
+    event: Message,
+    signal?: AbortSignal,
+    metadata: ReadonlyMap<string, string> = EMPTY_METADATA
+  ): Promise<ZLinkSubmitResult> {
+    throwIfAborted(signal);
+    return this.tryPublish(channelName, topic, packetName, event, metadata);
+  }
+}

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

@@ -0,0 +1,44 @@
+import type {
+  ZLinkBackendContext,
+  ZLinkBackendMeshNode,
+  ZLinkMeshBackendAdapter
+} from '../contracts';
+import { ZLinkNodeRawMeshBackend } from './node-raw-mesh-backend';
+import { ZLinkNodeRawBindingPort } from './node-raw-binding-port';
+import type { Context } from '@zlink-systems/zlink';
+
+export class ZLinkNodeMeshBackendAdapter implements ZLinkMeshBackendAdapter {
+  createMeshNode(
+    context: ZLinkBackendContext,
+    options: {
+      readonly meshName: string;
+      readonly routingId?: string;
+      readonly trustProfile?: string;
+      readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;
+      readonly applicationJobReceiveFlowFailureSink?: (error: unknown) => void;
+      readonly peerAdmissionSealed?: () => boolean;
+    }
+  ): ZLinkBackendMeshNode {
+    if (options.trustProfile !== undefined) {
+      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.');
+    }
+    return new ZLinkNodeRawMeshBackend(
+      options.meshName,
+      options.routingId,
+      new ZLinkNodeRawBindingPort(bindingContext),
+      options.applicationJobQueue,
+      options.applicationJobReceiveFlowFailureSink,
+      options.peerAdmissionSealed
+    );
+  }
+}
+
+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';
+}

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

@@ -0,0 +1,39 @@
+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 {
+  const handlers = new Set<(event: ZLinkBackendSocketMonitorEvent) => void>();
+  return {
+    nativeInstance,
+    async dispose(): Promise<void> {
+      handlers.clear();
+      nativeInstance.close();
+    },
+    drain() {
+      let count = 0;
+      for (;;) {
+        const event = nativeInstance.recv(zlink.RecvFlags.DontWait);
+        if (event === null) return count;
+        const value = toBackendMonitorEvent(event);
+        for (const registered of handlers) registered(value);
+        count += 1;
+      }
+    },
+    onEvent(handler): void {
+      handlers.add(handler);
+    }
+  };
+}
+
+function toBackendMonitorEvent(event: MonitorEvent): ZLinkBackendSocketMonitorEvent {
+  return {
+    nativeEvent: event.event,
+    routingId: event.routingId ?? undefined,
+    localAddr: event.localAddr,
+    remoteAddr: event.remoteAddr,
+    value: event.value
+  };
+}

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

@@ -0,0 +1,21 @@
+import type { ZLinkFrameworkRegistration } from '../../../contracts/Configuration/Registration';
+import {
+  ZLinkNodeRawBindingPort,
+  type ZLinkRawBindingPort,
+  type ZLinkRawHostPort
+} from './node-raw-binding-port';
+
+const port: ZLinkRawBindingPort = new ZLinkNodeRawBindingPort();
+
+export function compilePublicHostConnection(
+  _registration: ZLinkFrameworkRegistration,
+  host: ZLinkRawHostPort = port.createHost()
+): void {
+  const router = host.createRouter();
+  router.setRoutingId('node-a');
+  const dealer = host.createDealer();
+  dealer.setRoutingId('node-b');
+  router.close();
+  dealer.close();
+  host.close();
+}