@zlink-systems/framework 0.10.0

package/src/contracts/Configuration/RouteChannelInternalState.ts

@@ -0,0 +1,50 @@
+import type { ZLinkRouteChannelOptions, ZLinkRouteMeshChannelOptions } from './RegistrationTypes';
+
+export interface RouteChannelInternalState {
+  readonly transportDeclared?: boolean;
+  readonly clientEnabled?: boolean;
+}
+
+export function markRouteTransportDeclared(routeChannel: object): void {
+  defineRouteInternalFlag(routeChannel, 'transportDeclared');
+}
+
+export function markRouteClientEnabled(routeChannel: object): void {
+  defineRouteInternalFlag(routeChannel, 'clientEnabled');
+}
+
+export function copyRouteInternalState(source: object, target: object): void {
+  const state = routeInternalState(source);
+  if (state.transportDeclared === true) {
+    markRouteTransportDeclared(target);
+  }
+  if (state.clientEnabled === true) {
+    markRouteClientEnabled(target);
+  }
+}
+
+export function isRouteTransportDeclared(routeChannel: ZLinkRouteChannelOptions): boolean {
+  return routeInternalState(routeChannel).transportDeclared === true;
+}
+
+export function isRouteClientEnabled(
+  routeChannel: ZLinkRouteChannelOptions | ZLinkRouteMeshChannelOptions
+): boolean {
+  return routeInternalState(routeChannel).clientEnabled === true;
+}
+
+function routeInternalState(routeChannel: object): RouteChannelInternalState {
+  return routeChannel as RouteChannelInternalState;
+}
+
+function defineRouteInternalFlag(
+  routeChannel: object,
+  key: keyof RouteChannelInternalState
+): void {
+  Object.defineProperty(routeChannel, key, {
+    value: true,
+    configurable: true,
+    enumerable: false,
+    writable: true
+  });
+}

package/src/contracts/Configuration/RuntimeEndpointConnections.ts

@@ -0,0 +1,91 @@
+import type { ZLinkEndpointConnections } from './Connections';
+import { normalizeEndpoint } from './EndpointNotation';
+
+interface ConnectableEndpointSocket {
+  connect(endpoint: string): void;
+  disconnect(endpoint: string): void;
+}
+
+const controllers = new WeakMap<object, RuntimeEndpointConnections>();
+
+class RuntimeEndpointConnections implements ZLinkEndpointConnections {
+  private socket?: ConnectableEndpointSocket;
+  private readonly endpoints: string[];
+
+  constructor(endpoints: readonly string[]) {
+    if (Array.isArray(endpoints) && Object.isExtensible(endpoints)) {
+      // Builder registration and the public handle must observe one mutable
+      // endpoint set. A frozen, sealed or external readonly array uses a
+      // private snapshot because it cannot safely be updated in place.
+      this.endpoints = endpoints as string[];
+      // Normalize in place -- callers (and the builder that shares this
+      // array) must keep observing the same array identity.
+      for (let index = 0; index < this.endpoints.length; index += 1) {
+        this.endpoints[index] = normalizeEndpoint(this.endpoints[index]);
+      }
+      for (let index = this.endpoints.length - 1; index >= 0; index -= 1) {
+        if (this.endpoints.indexOf(this.endpoints[index]) !== index) {
+          this.endpoints.splice(index, 1);
+        }
+      }
+    } else {
+      this.endpoints = [];
+      for (const endpoint of endpoints) {
+        const normalizedEndpoint = normalizeEndpoint(endpoint);
+        if (!this.endpoints.includes(normalizedEndpoint)) {
+          this.endpoints.push(normalizedEndpoint);
+        }
+      }
+    }
+  }
+
+  connect(endpoint: string): void {
+    const normalizedEndpoint = normalizeEndpoint(endpoint);
+    if (!this.endpoints.includes(normalizedEndpoint)) {
+      this.endpoints.push(normalizedEndpoint);
+      this.socket?.connect(normalizedEndpoint);
+    }
+  }
+
+  disconnect(endpoint: string): void {
+    // Normalize so a caller using a different (but equivalent) notation than
+    // the one recorded at connect() time still matches -- otherwise this is
+    // a silent no-op from the caller's perspective.
+    const normalizedEndpoint = normalizeEndpoint(endpoint);
+    const index = this.endpoints.indexOf(normalizedEndpoint);
+    if (index >= 0) {
+      this.endpoints.splice(index, 1);
+      this.socket?.disconnect(normalizedEndpoint);
+    }
+  }
+
+  listConnections(): readonly string[] {
+    return Object.freeze([...this.endpoints]);
+  }
+
+  attach(socket: ConnectableEndpointSocket): void {
+    this.socket = socket;
+  }
+
+  detach(): void {
+    this.socket = undefined;
+  }
+}
+
+export function endpointConnections(owner: object, endpoints: readonly string[]): ZLinkEndpointConnections {
+  let controller = controllers.get(owner);
+  if (controller === undefined) {
+    controller = new RuntimeEndpointConnections(endpoints);
+    controllers.set(owner, controller);
+  }
+  return controller;
+}
+
+export function attachEndpointConnections(owner: object, socket: ConnectableEndpointSocket): void {
+  const controller = controllers.get(owner);
+  controller?.attach(socket);
+}
+
+export function detachEndpointConnections(owner: object): void {
+  controllers.get(owner)?.detach();
+}

package/src/contracts/Configuration/SendTimeoutValidation.ts

@@ -0,0 +1,15 @@
+import { ZLinkConfigurationException } from './ConfigurationException';
+
+export const ZLINK_MAX_SEND_TIMEOUT_MS = 2_147_483_647;
+
+export function requireValidSendTimeoutMs(label: string, value: number | undefined): void {
+  if (value === undefined) return;
+  if (!Number.isFinite(value)
+    || !Number.isInteger(value)
+    || value < 1
+    || value > ZLINK_MAX_SEND_TIMEOUT_MS) {
+    throw new ZLinkConfigurationException(
+      `${label} must be an integer between 1 and ${ZLINK_MAX_SEND_TIMEOUT_MS} milliseconds.`
+    );
+  }
+}

package/src/contracts/Configuration/TimerRegistrationValidator.ts

@@ -0,0 +1,37 @@
+import {
+  ZLinkTimerOverrunPolicy,
+  type ZLinkTimerOptions
+} from '../Timers';
+import { ZLinkConfigurationException } from './ConfigurationException';
+
+export function validateTimerRegistration(
+  name: string,
+  periodMs: number,
+  options: ZLinkTimerOptions | undefined
+): void {
+  if (name.trim().length === 0) {
+    throw new ZLinkConfigurationException('SPOT timer name must not be empty.');
+  }
+  if (!Number.isFinite(periodMs) || periodMs <= 0) {
+    throw new ZLinkConfigurationException('SPOT timer period must be greater than zero.');
+  }
+  if (
+    options?.overrunPolicy !== undefined
+    && !Object.values(ZLinkTimerOverrunPolicy).includes(options.overrunPolicy)
+  ) {
+    throw new ZLinkConfigurationException('SPOT timer overrun policy is not supported.');
+  }
+  if (
+    options?.overrunPolicy === ZLinkTimerOverrunPolicy.CatchUpBounded
+    && (
+      options.maxCatchUpTicks === undefined
+      || !Number.isInteger(options.maxCatchUpTicks)
+      || options.maxCatchUpTicks < 1
+      || options.maxCatchUpTicks > 2_147_483_647
+    )
+  ) {
+    throw new ZLinkConfigurationException(
+      'SPOT timer MaxCatchUpTicks must be an integer from 1 through 2,147,483,647.'
+    );
+  }
+}

package/src/contracts/Configuration/index.ts

@@ -0,0 +1,35 @@
+export type {
+  ZLinkClientServerChannelClientBuilder,
+  ZLinkClientServerChannelRoleBuilder,
+  ZLinkClientServerChannelServerBuilder,
+  ZLinkFanoutChannelBuilder,
+  ZLinkFrameworkOptions,
+  ZLinkMeshChannelBuilder,
+  ZLinkMeshChannelClientBuilder,
+  ZLinkMeshChannelServerBuilder,
+  ZLinkMeshObjectClientBuilder,
+  ZLinkMeshObjectRoleBuilder,
+  ZLinkMeshObjectServerBuilder,
+  ZLinkMeshNodeBuilder,
+  ZLinkMeshNodeSocketConfig,
+  ZLinkMeshPeerConnection,
+  ZLinkMeshPeerConnections,
+  ZLinkNetworkOptions,
+  ZLinkMetadataPolicyBuilder,
+  ZLinkStreamCompressionBuilder,
+  ZLinkStreamSocketConfig,
+  ZLinkStreamNodeBuilder
+} from './Builders';
+export type {
+  ZLinkOutboundRouteConfig,
+  ZLinkRouteConfig,
+  ZLinkSocketConfig,
+  ZLinkSpotPublisherConfig
+} from './Configs';
+export * from './Connections';
+export * from './ObjectRoles';
+export type {
+  ZLinkApplicationJobQueueOptions,
+  ZLinkCoreHwmOptions,
+  ZLinkWorkerOptions
+} from './RegistrationTypes';

package/src/contracts/Dispatch/ZLinkDispatchOptions.ts

@@ -0,0 +1,222 @@
+import type { ZLinkFlowOrigin } from './ZLinkFlowOrigin';
+
+export enum ZLinkCoreHwmProfile {
+  Compact = 'compact',
+  LowLatency = 'low_latency',
+  Balanced = 'balanced',
+  Throughput = 'throughput'
+}
+
+export enum ZLinkApplicationJobQueueProfile {
+  Compact = 'compact',
+  LowLatency = 'low_latency',
+  Balanced = 'balanced',
+  Throughput = 'throughput'
+}
+
+export interface ZLinkInboundDispatchOptions {
+  coreHwmMemoryLimitBytes(value: bigint | undefined): this;
+  coreHwmBudgetBytes(value: bigint | undefined): this;
+  coreHwmProfile(value: ZLinkCoreHwmProfile): this;
+  applicationJobQueueProfile(value: ZLinkApplicationJobQueueProfile): this;
+  maxQueuedApplicationJobs(value: bigint | undefined): this;
+  applicationJobQueuePauseThresholdPercent(value: number): this;
+  applicationJobQueueResumeThresholdPercent(value: number): this;
+}
+
+export interface ZLinkDispatchOptions {
+  readonly unhandled: ZLinkUnhandledDispatchOptions;
+  readonly diagnostics: ZLinkDiagnosticsOptions;
+}
+
+export interface ZLinkDispatchOptionsBuilder {
+  messageFlow(mode: ZLinkMessageFlowLogMode): this;
+  traceSampleRate(rate: number): this;
+  includeMessageSizes(include: boolean): this;
+}
+
+/**
+ * A message lifecycle outcome. Error outcomes carry the dispatch error fields on the
+ * same typed event used by the success path.
+ */
+export enum ZLinkRuntimeMessageFlowOutcome {
+  Received = 'received',
+  Admitted = 'admitted',
+  Dispatched = 'dispatched',
+  Completed = 'completed',
+  Replied = 'replied',
+  Dropped = 'dropped',
+  Sent = 'sent',
+  ReplyReceived = 'replyReceived',
+  Backpressured = 'backpressured',
+  Error = 'error'
+}
+
+export type ZLinkRuntimeMessageFlowResult =
+  | 'succeeded'
+  | 'failed'
+  | 'backpressured'
+  | 'dropped'
+  | 'cancelled'
+  | 'shutdown';
+
+export interface ZLinkRuntimeMessageFlowEvent {
+  readonly outcome: ZLinkRuntimeMessageFlowOutcome;
+  readonly result?: ZLinkRuntimeMessageFlowResult;
+  readonly surface: ZLinkDispatchErrorSurface;
+  readonly messageKind: ZLinkDispatchMessageKind;
+  readonly packetName?: string;
+  readonly channelName?: string;
+  readonly channelRouteKind?: 'route_mesh' | 'client_server';
+  readonly meshName?: string;
+  readonly topic?: string;
+  readonly correlationId?: string;
+  readonly sourceRid?: string;
+  readonly targetRid?: string;
+  readonly serverRid?: string;
+  readonly peerRid?: string;
+  readonly socketRole?: string;
+  readonly effectiveMode: ZLinkMessageFlowLogMode;
+  readonly flowId?: string;
+  readonly flowOrigin?: ZLinkFlowOrigin;
+  /** Source MeshNode lifecycle generation used only for flow-less sampling. */
+  readonly sourceMeshGeneration?: bigint | string;
+  readonly spotId?: string;
+  readonly instanceSpotType?: string;
+  readonly activationState?: 'activating' | 'ready' | 'closing';
+  readonly actorId?: string;
+  /** Internal service-wire command carried by a RouteMesh control record. */
+  readonly commandId?: number;
+  readonly messageSize?: number;
+  readonly durationSeconds?: number;
+  readonly errorReason?: ZLinkDispatchErrorReason;
+  readonly errorAction?: ZLinkDispatchErrorAction;
+  readonly errorType?: string;
+  readonly errorMessage?: string;
+  readonly errorCauseType?: string;
+  readonly errorCauseMessage?: string;
+}
+
+/**
+ * Resolve from the runtime to turn message-flow tracing on/off (or change verbosity)
+ * at runtime without a restart. Read live by every dispatch surface.
+ */
+export interface ZLinkMessageFlowControl {
+  /**
+   * Synchronous compatibility bridge. Do not call from a framework execution
+   * context such as a handler or callback; use setMessageFlowModeAsync there.
+   */
+  setMessageFlowMode(mode: ZLinkMessageFlowLogMode): void;
+  setMessageFlowModeAsync(mode: ZLinkMessageFlowLogMode): Promise<void>;
+  messageFlowMode(): ZLinkMessageFlowLogMode;
+}
+
+export interface ZLinkDispatchFailure {
+  readonly surface: ZLinkDispatchErrorSurface;
+  readonly messageKind: ZLinkDispatchMessageKind;
+  readonly reason: ZLinkDispatchErrorReason;
+  readonly action: ZLinkDispatchErrorAction;
+  readonly packetName?: string;
+  readonly channelName?: string;
+  readonly channelRouteKind?: 'route_mesh' | 'client_server';
+  readonly meshName?: string;
+  readonly topic?: string;
+  readonly spotId?: string;
+  readonly instanceSpotType?: string;
+  readonly activationState?: 'activating' | 'ready' | 'closing';
+  readonly actorId?: string;
+  readonly commandId?: number;
+  readonly sourceRid?: string;
+  readonly targetRid?: string;
+  readonly serverRid?: string;
+  readonly correlationId?: string;
+  readonly flowId?: string;
+  readonly flowOrigin?: ZLinkFlowOrigin;
+  readonly errorType?: string;
+  readonly errorMessage?: string;
+  readonly errorCauseType?: string;
+  readonly errorCauseMessage?: string;
+}
+
+export interface ZLinkUnhandledDispatchOptions {
+  request: ZLinkUnhandledDispatchAction;
+  send: ZLinkUnhandledDispatchAction;
+  publish: ZLinkUnhandledDispatchAction;
+}
+
+export interface ZLinkDiagnosticsOptions {
+  messageFlow: ZLinkMessageFlowLogMode;
+  sampleRate: number;
+  includeMessageSizes: boolean;
+}
+
+export enum ZLinkUnhandledDispatchAction {
+  ReplyError = 'replyError',
+  LogAndDrop = 'logAndDrop',
+  Drop = 'drop',
+  Throw = 'throw'
+}
+
+export type ZLinkMessageFlowLogMode = 'off' | 'errors' | 'normal' | 'detailed';
+
+export const MESSAGE_FLOW_MODE_RANK: Record<ZLinkMessageFlowLogMode, number> = {
+  off: 0,
+  errors: 1,
+  normal: 2,
+  detailed: 3
+};
+
+export enum ZLinkDispatchErrorSurface {
+  Node = 'node',
+  Channel = 'channel',
+  RouteMeshChannel = 'routeMeshChannel',
+  SpotRoute = 'spotRoute',
+  InstanceSpot = 'instance_spot',
+  SpotSubscription = 'spotSubscription',
+  SpotActor = 'spotActor',
+  StreamSession = 'streamSession',
+  ActorRelocation = 'actorRelocation',
+  ClassicFanout = 'classicFanout'
+}
+
+export enum ZLinkDispatchMessageKind {
+  Request = 'request',
+  Send = 'send',
+  Publish = 'publish',
+  Response = 'response',
+  Error = 'error',
+  Control = 'control',
+  ActorRequest = 'actorRequest',
+  ActorSend = 'actorSend'
+}
+
+export type ZLinkDispatchErrorReason =
+  | 'no_handler'
+  | 'decode_error'
+  | 'handler_exception'
+  | 'invalid_frame'
+  | 'reply_path_missing'
+  | 'unexpected_reply'
+  | 'backpressure'
+  | 'stale_target'
+  | 'shutdown';
+
+export type ZLinkDispatchErrorAction = 'reply_error' | 'fail_caller' | 'drop';
+
+export enum ZLinkRuntimeDispatchErrorReason {
+  HandlerMissing = 'no_handler',
+  PayloadDecodeFailed = 'decode_error',
+  HandlerException = 'handler_exception',
+  InvalidFrame = 'invalid_frame',
+  ReplyPathMissing = 'reply_path_missing',
+  UnexpectedReply = 'unexpected_reply',
+  Backpressure = 'backpressure',
+  StaleTarget = 'stale_target',
+  Shutdown = 'shutdown'
+}
+
+export enum ZLinkRuntimeDispatchErrorAction {
+  ReplyError = 'reply_error',
+  FailCaller = 'fail_caller',
+  Drop = 'drop'
+}

package/src/contracts/Dispatch/ZLinkFlowOrigin.ts

@@ -0,0 +1 @@
+export type ZLinkFlowOrigin = 'Inbound' | 'Timer' | 'Application' | 'Lifecycle';

package/src/contracts/Dispatch/index.ts

@@ -0,0 +1,2 @@
+export * from './ZLinkDispatchOptions';
+export * from './ZLinkFlowOrigin';

package/src/contracts/Errors/ZLinkFrameworkException.ts

@@ -0,0 +1,27 @@
+/** Application-visible Framework error categories. */
+export enum ZLinkFrameworkErrorKind {
+  NotFound = 0,
+  AlreadyExists = 1,
+  TypeMismatch = 2,
+  NotConfigured = 3,
+  Rejected = 4,
+  Unavailable = 5,
+  CapacityExceeded = 6,
+  DeadlineExceeded = 7,
+  ShuttingDown = 8,
+  ProtocolError = 9,
+  InvalidOperation = 10,
+  DataLost = 11,
+  InternalFailure = 12
+}
+
+export class ZLinkFrameworkException extends Error {
+  constructor(
+    public readonly kind: ZLinkFrameworkErrorKind,
+    message: string,
+    cause?: unknown
+  ) {
+    super(message, { cause });
+    this.name = 'ZLinkFrameworkException';
+  }
+}

package/src/contracts/Errors/index.ts

@@ -0,0 +1,4 @@
+export {
+  ZLinkFrameworkErrorKind,
+  ZLinkFrameworkException
+} from './ZLinkFrameworkException';

package/src/contracts/Eventing/Metrics.ts

@@ -0,0 +1,27 @@
+export const ZLinkMeters = Object.freeze({ Framework: 'zlink.framework' } as const);
+
+export interface ZLinkMetricAttributes {
+  readonly [name: string]: string | number | boolean;
+}
+
+export interface ZLinkMetricInstrument {
+  add(value: number, attributes?: ZLinkMetricAttributes): void;
+}
+
+export interface ZLinkMetricHistogram {
+  record(value: number, attributes?: ZLinkMetricAttributes): void;
+}
+
+export interface ZLinkMeter {
+  createCounter(name: string, options?: { readonly unit?: string }): ZLinkMetricInstrument;
+  createUpDownCounter(name: string, options?: { readonly unit?: string }): ZLinkMetricInstrument;
+  createHistogram(name: string, options?: { readonly unit?: string }): ZLinkMetricHistogram;
+}
+
+export interface ZLinkMeterProvider {
+  getMeter(name: string): ZLinkMeter;
+}
+
+export interface ZLinkMetricsOptions {
+  readonly meterProvider?: ZLinkMeterProvider;
+}

package/src/contracts/Eventing/index.ts

@@ -0,0 +1 @@
+export * from './Metrics';

package/src/contracts/Handlers/Attributes.ts

@@ -0,0 +1,111 @@
+import {
+  defineZLinkPacketJsonContract,
+  readZLinkPacketJsonContract as readDefinedZLinkPacketJsonContract,
+  type ZLinkPacketJsonContract
+} from './JsonContract';
+
+export const ZLINK_DECORATOR_METADATA = Symbol.for('@zlink-systems/framework:decorator');
+
+export interface ZLinkDecoratorMetadata {
+  readonly kind: string;
+  readonly packetName?: string;
+  readonly groupName?: string;
+  readonly methodName?: string;
+  readonly meshName?: string;
+  readonly channelName?: string;
+  readonly topic?: string;
+  readonly jsonContract?: ZLinkPacketJsonContract;
+}
+
+export function ZLinkHandlerGroup(groupName: string): ClassDecorator {
+  return classDecorator({ kind: 'handlerGroup', groupName });
+}
+
+export function ZLinkRequest(packetName?: string): MethodDecorator {
+  return methodDecorator({ kind: 'request', packetName });
+}
+
+export function ZLinkSend(packetName?: string): MethodDecorator {
+  return methodDecorator({ kind: 'send', packetName });
+}
+
+export function ZLinkPublish(packetName?: string): MethodDecorator {
+  return methodDecorator({ kind: 'publish', packetName });
+}
+
+/** @internal Generated schema registration overload. */
+export function ZLinkPacket(
+  packetName: string,
+  jsonContract?: ZLinkPacketJsonContract
+): ClassDecorator;
+
+export function ZLinkPacket(packetName: string): ClassDecorator;
+
+export function ZLinkPacket(
+  packetName: string,
+  jsonContract?: ZLinkPacketJsonContract
+): ClassDecorator {
+  return (target) => {
+    const normalized = jsonContract === undefined
+      ? undefined
+      : defineZLinkPacketJsonContract(packetName, jsonContract);
+    appendMetadata(target, { kind: 'packet', packetName, jsonContract: normalized });
+  };
+}
+
+/** @internal */
+export function readZLinkPacketJsonContract(packetName: string): ZLinkPacketJsonContract | undefined {
+  return readDefinedZLinkPacketJsonContract(packetName);
+}
+
+export function ZLinkSpotRequest(packetName?: string): MethodDecorator {
+  return methodDecorator({ kind: 'spotRequest', packetName });
+}
+
+export function ZLinkSpotSubscription(channelName: string, topic: string): MethodDecorator {
+  return methodDecorator({ kind: 'spotSubscription', channelName, topic });
+}
+
+export function ZLinkSpotActorSend(packetName?: string): MethodDecorator {
+  return methodDecorator({ kind: 'spotActorSend', packetName });
+}
+
+export function ZLinkSpotActorRequest(packetName?: string): MethodDecorator {
+  return methodDecorator({ kind: 'spotActorRequest', packetName });
+}
+
+export function ZLinkStreamPacket(): MethodDecorator {
+  return methodDecorator({ kind: 'streamPacket' });
+}
+
+export function ZLinkStreamRaw(): MethodDecorator {
+  return methodDecorator({ kind: 'streamRaw' });
+}
+
+function classDecorator(metadata: ZLinkDecoratorMetadata): ClassDecorator {
+  return (target) => appendMetadata(target, metadata);
+}
+
+function methodDecorator(metadata: ZLinkDecoratorMetadata): MethodDecorator {
+  return (target, propertyKey) => appendMetadata(target.constructor, {
+    ...metadata,
+    methodName: String(propertyKey)
+  });
+}
+
+function appendMetadata(target: object, metadata: ZLinkDecoratorMetadata): void {
+  const current = readZLinkDecoratorMetadata(target);
+  Object.defineProperty(target, ZLINK_DECORATOR_METADATA, {
+    configurable: true,
+    enumerable: false,
+    value: [...current, metadata],
+    writable: false
+  });
+}
+
+export function readZLinkDecoratorMetadata(target: object): readonly ZLinkDecoratorMetadata[] {
+  if (!Object.prototype.hasOwnProperty.call(target, ZLINK_DECORATOR_METADATA)) {
+    return [];
+  }
+  return (target as Record<symbol, unknown>)[ZLINK_DECORATOR_METADATA] as readonly ZLinkDecoratorMetadata[];
+}

package/src/contracts/Handlers/Contexts.ts

@@ -0,0 +1,21 @@
+import type { RoutingId, ZLinkMessageMetadata } from '../Common';
+
+export interface ZLinkMessageContext {
+  readonly meshName?: string;
+  readonly channelName?: string;
+  readonly packetName: string;
+  readonly contentType?: string;
+  readonly metadata: ZLinkMessageMetadata;
+  readonly correlationId?: string;
+}
+
+export interface ZLinkPublishMessageContext extends ZLinkMessageContext {
+  readonly channelName: string;
+  readonly topic: string;
+  readonly source?: string;
+}
+
+export interface ZLinkRouteMessageContext extends ZLinkMessageContext {
+  readonly meshName: string;
+  readonly sourceNodeRid: RoutingId;
+}