@zlink-systems/framework 0.21.0 → 0.23.0

package/src/contracts/Configuration/RegistrationCodecRegistry.ts

@@ -31,7 +31,9 @@ export function createCodecRegistry(
   });
 }
 
-export class RegistrationCodecRegistryBuilder implements ZLinkCodecRegistryBuilder, ZLinkCodecRegistrar {
+export class RegistrationCodecRegistryBuilder
+  implements ZLinkCodecRegistryBuilder, ZLinkCodecRegistrar
+{
   private readonly options: MutableCodecRegistryOptions;
 
   constructor(options: MutableCodecRegistryOptions = { serializers: [], streamCodecs: [] }) {
@@ -100,7 +102,9 @@ export class RegistrationCodecRegistryBuilder implements ZLinkCodecRegistryBuild
     canSerialize?: ZLinkMessageTypeSelector
   ): this {
     const normalized = normalizeCodecContentType(contentType);
-    const existing = this.options.serializers.findIndex((entry) => entry.contentType === normalized);
+    const existing = this.options.serializers.findIndex(
+      (entry) => entry.contentType === normalized
+    );
     const registration = { contentType: normalized, serializer, canSerialize };
     if (existing >= 0) this.options.serializers.splice(existing, 1);
     this.options.serializers.push(registration);
@@ -109,7 +113,9 @@ export class RegistrationCodecRegistryBuilder implements ZLinkCodecRegistryBuild
 
   addStreamCodec(contentType: string, codec: unknown): this {
     const normalized = normalizeCodecContentType(contentType);
-    const existing = this.options.streamCodecs.findIndex((entry) => entry.contentType === normalized);
+    const existing = this.options.streamCodecs.findIndex(
+      (entry) => entry.contentType === normalized
+    );
     const registration = { contentType: normalized, codec };
     if (existing >= 0) this.options.streamCodecs.splice(existing, 1);
     this.options.streamCodecs.push(registration);

package/src/contracts/Configuration/RegistrationNormalizers.ts

@@ -5,10 +5,7 @@ import type {
   ZLinkStreamCompressionCodec
 } from '../../contracts';
 import { ZLinkConfigurationException } from './ConfigurationException';
-import {
-  copyRouteInternalState,
-  markRouteTransportDeclared
-} from './RouteChannelInternalState';
+import { copyRouteInternalState, markRouteTransportDeclared } from './RouteChannelInternalState';
 import type {
   ZLinkChannelOptions,
   ZLinkFrameworkRegistration,
@@ -53,38 +50,49 @@ export function toChannelMap(
   channels: ZLinkFrameworkRegistrationOptions['channels'],
   network: ZLinkNetworkOptions
 ): Map<string, ZLinkChannelOptions> {
-  return new Map(Object.entries(channels ?? {}).map(([name, channel]) => {
-    const server = channel.server === undefined
-      ? undefined
-      : normalizeListener(channel.server, network);
-    const publisher = channel.publisher === undefined
-      ? undefined
-      : normalizeListener(channel.publisher, network);
-    // In-place: channel.client/subscriber.manualConnections can be the same
-    // array a live RuntimeEndpointConnections handle mutates, so this must
-    // not replace the array or the containing client/subscriber object.
-    normalizeEndpointList(channel.client?.manualConnections);
-    normalizeEndpointList(channel.subscriber?.manualConnections);
-    return [name, {
-      ...channel,
-      ...(server === undefined ? {} : { server }),
-      ...(publisher === undefined ? {} : { publisher }),
-      requestTimeoutMs: normalizeOptionalPositiveInteger(channel.requestTimeoutMs, `${name}.requestTimeoutMs`)
-    }];
-  }));
+  return new Map(
+    Object.entries(channels ?? {}).map(([name, channel]) => {
+      const server =
+        channel.server === undefined ? undefined : normalizeListener(channel.server, network);
+      const publisher =
+        channel.publisher === undefined ? undefined : normalizeListener(channel.publisher, network);
+      // In-place: channel.client/subscriber.manualConnections can be the same
+      // array a live RuntimeEndpointConnections handle mutates, so this must
+      // not replace the array or the containing client/subscriber object.
+      normalizeEndpointList(channel.client?.manualConnections);
+      normalizeEndpointList(channel.subscriber?.manualConnections);
+      return [
+        name,
+        {
+          ...channel,
+          ...(server === undefined ? {} : { server }),
+          ...(publisher === undefined ? {} : { publisher }),
+          requestTimeoutMs: normalizeOptionalPositiveInteger(
+            channel.requestTimeoutMs,
+            `${name}.requestTimeoutMs`
+          )
+        }
+      ];
+    })
+  );
 }
 
 export function toStreamNodeMap(
   streamNodes: ZLinkFrameworkRegistrationOptions['streamNodes'],
   network: ZLinkNetworkOptions
 ): Map<string, ZLinkStreamNodeOptions> {
-  return new Map(Object.entries(streamNodes ?? {}).map(([name, streamNode]) => {
-    const normalized = normalizeListener(streamNode, network);
-    return [name, {
-      ...normalized,
-      maxMessageSize: streamNode.maxMessageSize ?? DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE
-    }];
-  }));
+  return new Map(
+    Object.entries(streamNodes ?? {}).map(([name, streamNode]) => {
+      const normalized = normalizeListener(streamNode, network);
+      return [
+        name,
+        {
+          ...normalized,
+          maxMessageSize: streamNode.maxMessageSize ?? DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE
+        }
+      ];
+    })
+  );
 }
 
 export function toRouteChannelOptions(
@@ -112,7 +120,9 @@ export function toRouteChannelOptions(
       continue;
     }
     if (routeOptions.has(channelName)) {
-      throw new ZLinkConfigurationException(`Route mesh channel '${channelName}' is already registered.`);
+      throw new ZLinkConfigurationException(
+        `Route mesh channel '${channelName}' is already registered.`
+      );
     }
     const routeChannel = {
       routerChannelId: channelName,
@@ -139,7 +149,10 @@ export function requirePositiveInteger(label: string, value: number | undefined)
   }
 }
 
-export function normalizeOptionalPositiveInteger(value: number | undefined, label: string): number | undefined {
+export function normalizeOptionalPositiveInteger(
+  value: number | undefined,
+  label: string
+): number | undefined {
   requirePositiveInteger(label, value);
   return value;
 }
@@ -149,19 +162,18 @@ export function hasSpotNode(registration: ZLinkFrameworkRegistration): boolean {
 }
 
 export function hasActorManager(registration: ZLinkFrameworkRegistration): boolean {
-  const hasObjectCapability = [...registration.spotNodes.values()].some(node =>
-    node.objectRole === 'client'
-    || node.objectRole === 'server'
-    || (
-      node.actorFactories instanceof Map
+  const hasObjectCapability = [...registration.spotNodes.values()].some(
+    (node) =>
+      node.objectRole === 'client' ||
+      node.objectRole === 'server' ||
+      (node.actorFactories instanceof Map
         ? node.actorFactories.size > 0
-        : Object.keys(node.actorFactories ?? {}).length > 0
-    )
-    || Object.keys(node.actorFactoryRegistrations ?? {}).length > 0
+        : Object.keys(node.actorFactories ?? {}).length > 0) ||
+      Object.keys(node.actorFactoryRegistrations ?? {}).length > 0
   );
-  return hasObjectCapability && (
-    registration.locations.useInMemoryStores
-    || registration.locations.storeInstance !== undefined
+  return (
+    hasObjectCapability &&
+    (registration.locations.useInMemoryStores || registration.locations.storeInstance !== undefined)
   );
 }
 
@@ -179,7 +191,9 @@ export function toTypeMap(value: ZLinkSpotNodeOptions['actorFactories']): Map<st
   return new Map(Object.entries(value));
 }
 
-export function typeMapToRecord(value: ZLinkSpotNodeOptions['actorFactories']): Record<string, Type> {
+export function typeMapToRecord(
+  value: ZLinkSpotNodeOptions['actorFactories']
+): Record<string, Type> {
   if (value === undefined) {
     return {};
   }
@@ -193,8 +207,12 @@ function isTypeMap(value: ZLinkSpotNodeOptions['actorFactories']): value is Map<
   return value instanceof Map;
 }
 
-export function actorFactoriesFromSpotNodes(spotNodes: ReadonlyMap<string, ZLinkSpotNodeOptions>): Map<string, Type> {
-  const actorCapableNodes = [...spotNodes.values()].filter((spotNode) => toTypeMap(spotNode.actorFactories).size > 0);
+export function actorFactoriesFromSpotNodes(
+  spotNodes: ReadonlyMap<string, ZLinkSpotNodeOptions>
+): Map<string, Type> {
+  const actorCapableNodes = [...spotNodes.values()].filter(
+    (spotNode) => toTypeMap(spotNode.actorFactories).size > 0
+  );
   if (actorCapableNodes.length === 0) {
     return new Map();
   }
@@ -209,44 +227,49 @@ export function toSpotNodeMap(
     return new Map();
   }
   if (!Array.isArray(value)) {
-    return new Map(Object.entries(value).map(([name, spotNode]) => [
-      name,
-      normalizeSpotNodeOptions(spotNode, network)
-    ]));
+    return new Map(
+      Object.entries(value).map(([name, spotNode]) => [
+        name,
+        normalizeSpotNodeOptions(spotNode, network)
+      ])
+    );
   }
-  return new Map(value.map((spotNode) => {
-    if (typeof spotNode === 'string') {
-      return [spotNode, normalizeSpotNodeOptions({}, network)];
-    }
-    const { name, ...options } = spotNode;
-    return [name, normalizeSpotNodeOptions(options, network)];
-  }));
+  return new Map(
+    value.map((spotNode) => {
+      if (typeof spotNode === 'string') {
+        return [spotNode, normalizeSpotNodeOptions({}, network)];
+      }
+      const { name, ...options } = spotNode;
+      return [name, normalizeSpotNodeOptions(options, network)];
+    })
+  );
 }
 
 function normalizeSpotNodeOptions(
   spotNode: ZLinkSpotNodeOptions,
   network: ZLinkNetworkOptions
 ): ZLinkSpotNodeOptions {
-  const router = spotNode.router === undefined
-    ? undefined
-    : normalizeListener(spotNode.router, network);
+  const router =
+    spotNode.router === undefined ? undefined : normalizeListener(spotNode.router, network);
   return {
     ...spotNode,
-    router: router === undefined
-      ? undefined
-      : {
-          ...router,
-          routingId: router.routingId ?? spotNode.routingId,
-          manualConnections: normalizeEndpointList(router.manualConnections),
-          manualPeerConnections: normalizeManualPeerConnections(router.manualPeerConnections)
-        },
-    pubSub: spotNode.pubSub === undefined
-      ? undefined
-      : {
-          ...spotNode.pubSub,
-          routingId: spotNode.pubSub.routingId ?? spotNode.routingId,
-          manualConnections: normalizeEndpointList(spotNode.pubSub.manualConnections)
-        }
+    router:
+      router === undefined
+        ? undefined
+        : {
+            ...router,
+            routingId: router.routingId ?? spotNode.routingId,
+            manualConnections: normalizeEndpointList(router.manualConnections),
+            manualPeerConnections: normalizeManualPeerConnections(router.manualPeerConnections)
+          },
+    pubSub:
+      spotNode.pubSub === undefined
+        ? undefined
+        : {
+            ...spotNode.pubSub,
+            routingId: spotNode.pubSub.routingId ?? spotNode.routingId,
+            manualConnections: normalizeEndpointList(spotNode.pubSub.manualConnections)
+          }
   };
 }
 
@@ -257,15 +280,18 @@ function normalizeListener<
     readonly advertiseHost?: string;
     readonly port?: number;
   }
->(listener: T, network: ZLinkNetworkOptions): T & {
+>(
+  listener: T,
+  network: ZLinkNetworkOptions
+): T & {
   readonly bind: string;
   readonly bindHost?: string;
   readonly port: number;
 } {
   const usesConfiguredEndpoint = listener.bind !== undefined && listener.port === undefined;
   const port = listener.port ?? (usesConfiguredEndpoint ? endpointPort(listener.bind!) : 0);
-  const bindHost = listener.bindHost
-    ?? (usesConfiguredEndpoint ? endpointHost(listener.bind!) : network.bindHost);
+  const bindHost =
+    listener.bindHost ?? (usesConfiguredEndpoint ? endpointHost(listener.bind!) : network.bindHost);
   const bind = usesConfiguredEndpoint
     ? normalizeEndpoint(listener.bind!)
     : tcpEndpoint(bindHost ?? network.bindHost, port);
@@ -372,10 +398,14 @@ export function normalizeStreamCompression(
     return undefined;
   }
   if (value.disabled === true && value.codec !== undefined) {
-    throw new ZLinkConfigurationException('STREAM compression codec cannot be set when compression is disabled.');
+    throw new ZLinkConfigurationException(
+      'STREAM compression codec cannot be set when compression is disabled.'
+    );
   }
   if (value.codec !== undefined && !isStreamCompressionCodec(value.codec)) {
-    throw new ZLinkConfigurationException('STREAM compression codec must provide compress and decompress functions.');
+    throw new ZLinkConfigurationException(
+      'STREAM compression codec must provide compress and decompress functions.'
+    );
   }
   return {
     disabled: value.disabled,
@@ -384,10 +414,12 @@ export function normalizeStreamCompression(
 }
 
 export function isStreamCompressionCodec(value: unknown): value is ZLinkStreamCompressionCodec {
-  return typeof value === 'object'
-    && value !== null
-    && typeof (value as { compress?: unknown }).compress === 'function'
-    && typeof (value as { decompress?: unknown }).decompress === 'function';
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as { compress?: unknown }).compress === 'function' &&
+    typeof (value as { decompress?: unknown }).decompress === 'function'
+  );
 }
 
 export function normalizeLocationRegistration(

package/src/contracts/Configuration/RegistrationTypes.ts

@@ -17,17 +17,11 @@ import type {
 import type { AutoHwmProfileValue } from '@zlink-systems/zlink';
 import type { ZLinkMessageSerializer } from '../Codecs';
 import type { ZLinkMessageTypeSelector } from '../Codecs';
-import type {
-  ZLinkApplicationJobQueueProfile,
-  ZLinkDispatchOptions
-} from '../Dispatch';
+import type { ZLinkApplicationJobQueueProfile, ZLinkDispatchOptions } from '../Dispatch';
 import type { ZLinkLocationStore, ZLinkRelocationStore } from '../Locations';
 import type { ZLinkNetworkOptions } from './Builders';
 import type { ZLinkLocationOptionValues } from '../RouteMesh';
-import {
-  ZLinkSpotRelocationCoordinationMode,
-  ZLinkUserSpotExecutionMode
-} from './ObjectRoles';
+import { ZLinkSpotRelocationCoordinationMode, ZLinkUserSpotExecutionMode } from './ObjectRoles';
 
 declare const zlinkRelocationConfigurationBrand: unique symbol;
 
@@ -150,8 +144,9 @@ export interface ZLinkFrameworkRegistrationOptions {
   readonly routeChannels?: readonly (string | ZLinkRouteChannelOptions)[];
   readonly streamNodes?: Readonly<Record<string, ZLinkStreamNodeOptions>>;
   readonly streamCompression?: ZLinkStreamCompressionOptions;
-  readonly spotNodes?: readonly (string | ZLinkSpotNodeRegistrationOptions)[] |
-    Readonly<Record<string, ZLinkSpotNodeOptions>>;
+  readonly spotNodes?:
+    | readonly (string | ZLinkSpotNodeRegistrationOptions)[]
+    | Readonly<Record<string, ZLinkSpotNodeOptions>>;
   readonly spotPublisherClients?: readonly string[];
   readonly filters?: readonly Type<ZLinkHandlerFilter>[];
   readonly worker?: ZLinkWorkerOptions;
@@ -275,27 +270,28 @@ export interface ZLinkSpotNodeOptions {
   readonly entrySpotType?: Type<ZLinkEntrySpot>;
   readonly spotFactories?: readonly Type<ZLinkSpot>[];
   readonly spotFactoryRegistrations?: Readonly<
-    Record<string, ZLinkObjectFactoryRegistration<
-      ZLinkSpot,
-      ZLinkSpot,
-      ZLinkUserSpotFactoryConfiguration
-    >>
+    Record<
+      string,
+      ZLinkObjectFactoryRegistration<ZLinkSpot, ZLinkSpot, ZLinkUserSpotFactoryConfiguration>
+    >
   >;
   readonly instanceSpotFactories?: Readonly<Record<string, Type<ZLinkInstanceSpot>>>;
   readonly instanceSpotFactoryRegistrations?: Readonly<
-    Record<string, ZLinkObjectFactoryRegistration<
-      ZLinkInstanceSpot,
-      ZLinkInstanceSpot,
-      ZLinkInstanceSpotFactoryConfiguration
-    >>
+    Record<
+      string,
+      ZLinkObjectFactoryRegistration<
+        ZLinkInstanceSpot,
+        ZLinkInstanceSpot,
+        ZLinkInstanceSpotFactoryConfiguration
+      >
+    >
   >;
   readonly actorFactories?: Readonly<Record<string, Type> | Map<string, Type>>;
   readonly actorFactoryRegistrations?: Readonly<
-    Record<string, ZLinkObjectFactoryRegistration<
-      ZLinkActor,
-      ZLinkActorFactory,
-      ZLinkActorFactoryConfiguration
-    >>
+    Record<
+      string,
+      ZLinkObjectFactoryRegistration<ZLinkActor, ZLinkActorFactory, ZLinkActorFactoryConfiguration>
+    >
   >;
   readonly meshChannels?: Readonly<Record<string, ZLinkMeshChannelOptions>>;
   readonly routeSendHandlers?: readonly ZLinkRouteMeshSendHandlerRegistration[];