@zlink-systems/framework 0.26.0 → 0.28.0

package/src/contracts/Configuration/Registration.ts

@@ -1,8 +1,9 @@
+import { AutoHwmProfile } from '@zlink-systems/zlink';
 import type { ZLinkFrameworkOptions } from '../../contracts';
+import { ZLINK_MAX_IDENTITY_TEXT_BYTES } from '../Common/CoreTypes';
 import { ZLinkApplicationJobQueueProfile } from '../Dispatch';
-export { ZLinkConfigurationException } from './ConfigurationException';
+import { zlinkDefaultLocationOptions } from '../Locations/Options';
 import { createFrameworkOptions } from './RegistrationBuilders';
-export { createFrameworkOptions } from './RegistrationBuilders';
 import { createCodecRegistry } from './RegistrationCodecRegistry';
 import {
   actorFactoriesFromSpotNodes,
@@ -19,18 +20,22 @@ import {
   toSpotPublisherClientSet,
   toStreamNodeMap
 } from './RegistrationNormalizers';
+import type {
+  ZLinkFrameworkRegistration,
+  ZLinkFrameworkRegistrationOptions
+} from './RegistrationTypes';
+import { validateFrameworkRegistration } from './RegistrationValidators';
+
+export const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+export { ZLinkConfigurationException } from './ConfigurationException';
+export { createFrameworkOptions } from './RegistrationBuilders';
 export {
   hasActorManager,
   hasSpotNode,
   hasSpotPublisherClient,
   requirePositiveInteger
 } from './RegistrationNormalizers';
-import type {
-  ZLinkFrameworkRegistration,
-  ZLinkFrameworkRegistrationOptions
-} from './RegistrationTypes';
 export * from './RegistrationTypes';
-import { validateFrameworkRegistration } from './RegistrationValidators';
 export { validateFrameworkRegistration };
 export {
   normalizeEndpoint,
@@ -38,11 +43,18 @@ export {
   parseEndpointHostPort
 } from './EndpointNotation';
 
-const DEFAULT_MESSAGE_FOLLOW_DURATION_MS = 30_000;
-const DEFAULT_SESSION_REPLACEMENT_CALLBACK_TIMEOUT_MS = 30_000;
+export const DEFAULT_SESSION_REPLACEMENT_CALLBACK_TIMEOUT_MS = 30_000;
 
 export function createFrameworkRegistration(
   options: ZLinkFrameworkRegistrationOptions = {}
+): ZLinkFrameworkRegistration {
+  const registration = normalizeFrameworkRegistration(options);
+  validateFrameworkRegistration(registration, options);
+  return registration;
+}
+
+export function normalizeFrameworkRegistration(
+  options: ZLinkFrameworkRegistrationOptions
 ): ZLinkFrameworkRegistration {
   const codecRegistry = createCodecRegistry(options.codecs);
   const network = normalizeNetworkOptions(options.network);
@@ -66,7 +78,7 @@ export function createFrameworkRegistration(
     messageFollowDurationMs: normalizeNonNegativeInteger(
       options.messageFollowDurationMs,
       'messageFollowDurationMs',
-      DEFAULT_MESSAGE_FOLLOW_DURATION_MS
+      zlinkDefaultLocationOptions.messageFollowDurationMs
     ),
     sessionReplacementCallbackTimeoutMs: normalizePositiveInteger(
       options.sessionReplacementCallbackTimeoutMs,
@@ -94,53 +106,75 @@ export function createFrameworkRegistration(
     applicationJobQueue: normalizeApplicationJobQueue(options.applicationJobQueue),
     locations: normalizeLocationRegistration(options.locations)
   };
-  validateFrameworkRegistration(registration, options);
   return registration;
 }
 
-function normalizeApplicationJobQueue(
-  value: ZLinkFrameworkRegistrationOptions['applicationJobQueue']
-): NonNullable<ZLinkFrameworkRegistrationOptions['applicationJobQueue']> {
-  const profile = value?.profile ?? ZLinkApplicationJobQueueProfile.Balanced;
-  if (!Object.values(ZLinkApplicationJobQueueProfile).includes(profile)) {
-    throw new TypeError('applicationJobQueue.profile must be a supported profile.');
-  }
-  const maxQueuedApplicationJobs = value?.maxQueuedApplicationJobs;
+export const MAX_QUEUED_APPLICATION_JOBS = 2_147_483_647n;
+export const DEFAULT_PAUSE_THRESHOLD_PERCENT = 80;
+export const DEFAULT_RESUME_THRESHOLD_PERCENT = 60;
+export const APPLICATION_JOB_QUEUE_PERCENT_SCALE = 100;
+
+export function isKnownApplicationJobQueueProfile(
+  value: unknown
+): value is ZLinkApplicationJobQueueProfile {
+  return Object.values(ZLinkApplicationJobQueueProfile).includes(
+    value as ZLinkApplicationJobQueueProfile
+  );
+}
+
+export function validateApplicationJobQueueMaximum(
+  value: bigint | undefined,
+  createError: (message: string) => Error
+): void {
   if (
-    maxQueuedApplicationJobs !== undefined &&
-    (typeof maxQueuedApplicationJobs !== 'bigint' ||
-      maxQueuedApplicationJobs < 1n ||
-      maxQueuedApplicationJobs > 2_147_483_647n)
+    value !== undefined &&
+    (typeof value !== 'bigint' || value < 1n || value > MAX_QUEUED_APPLICATION_JOBS)
   ) {
-    throw new TypeError(
-      'applicationJobQueue.maxQueuedApplicationJobs must be a bigint in the range 1..2147483647.'
+    throw createError(
+      `maxQueuedApplicationJobs must be a bigint in the range 1..${MAX_QUEUED_APPLICATION_JOBS}.`
     );
   }
-  const pauseThresholdPercent = value?.pauseThresholdPercent ?? 80;
-  const resumeThresholdPercent = value?.resumeThresholdPercent ?? 60;
-  if (
-    !Number.isInteger(pauseThresholdPercent) ||
-    pauseThresholdPercent < 1 ||
-    pauseThresholdPercent > 100
-  ) {
-    throw new TypeError(
-      'applicationJobQueue.pauseThresholdPercent must be an integer in the range 1..100.'
+}
+
+export function validateApplicationJobQueuePressureThresholds(
+  pause: number,
+  resume: number,
+  createError: (message: string) => Error
+): void {
+  if (!Number.isInteger(pause) || pause < 1 || pause > APPLICATION_JOB_QUEUE_PERCENT_SCALE) {
+    throw createError(
+      `pauseThresholdPercent must be an integer in the range 1..${APPLICATION_JOB_QUEUE_PERCENT_SCALE}.`
     );
   }
-  if (
-    !Number.isInteger(resumeThresholdPercent) ||
-    resumeThresholdPercent < 0 ||
-    resumeThresholdPercent > 99
-  ) {
-    throw new TypeError(
-      'applicationJobQueue.resumeThresholdPercent must be an integer in the range 0..99.'
+  if (!Number.isInteger(resume) || resume < 0 || resume >= APPLICATION_JOB_QUEUE_PERCENT_SCALE) {
+    throw createError(
+      `resumeThresholdPercent must be an integer in the range 0..${APPLICATION_JOB_QUEUE_PERCENT_SCALE - 1}.`
     );
   }
-  if (resumeThresholdPercent >= pauseThresholdPercent) {
-    throw new TypeError(
-      'applicationJobQueue.resumeThresholdPercent must be less than pauseThresholdPercent.'
-    );
+  if (resume >= pause) {
+    throw createError('resumeThresholdPercent must be less than pauseThresholdPercent.');
   }
+}
+
+function normalizeApplicationJobQueue(
+  value: ZLinkFrameworkRegistrationOptions['applicationJobQueue']
+): NonNullable<ZLinkFrameworkRegistrationOptions['applicationJobQueue']> {
+  const profile = value?.profile ?? ZLinkApplicationJobQueueProfile.Balanced;
+  if (!isKnownApplicationJobQueueProfile(profile)) {
+    throw new TypeError('applicationJobQueue.profile must be a supported profile.');
+  }
+  const maxQueuedApplicationJobs = value?.maxQueuedApplicationJobs;
+  validateApplicationJobQueueMaximum(
+    maxQueuedApplicationJobs,
+    (message) => new TypeError(`applicationJobQueue.${message}`)
+  );
+  const pauseThresholdPercent = value?.pauseThresholdPercent ?? DEFAULT_PAUSE_THRESHOLD_PERCENT;
+  const resumeThresholdPercent = value?.resumeThresholdPercent ?? DEFAULT_RESUME_THRESHOLD_PERCENT;
+  validateApplicationJobQueuePressureThresholds(
+    pauseThresholdPercent,
+    resumeThresholdPercent,
+    (message) => new TypeError(`applicationJobQueue.${message}`)
+  );
   return Object.freeze({
     profile,
     maxQueuedApplicationJobs,
@@ -154,7 +188,10 @@ function normalizeCoreHwm(
 ): ZLinkFrameworkRegistrationOptions['coreHwm'] {
   if (value === undefined) return undefined;
   const { profile, memoryLimitBytes, budgetBytes } = value;
-  if (profile !== undefined && (!Number.isInteger(profile) || profile < 0 || profile > 3)) {
+  if (
+    profile !== undefined &&
+    (!Number.isInteger(profile) || profile < 0 || profile > AutoHwmProfile.Throughput)
+  ) {
     throw new TypeError('coreHwm.profile must be a Core Auto HWM profile value.');
   }
   for (const [name, bytes] of [
@@ -183,8 +220,15 @@ function normalizeApplicationVersion(value: bigint | undefined): bigint {
 function normalizeMaintenanceWave(value: string | undefined): string | undefined {
   if (value === undefined) return undefined;
   const byteLength = typeof value === 'string' ? new TextEncoder().encode(value).byteLength : 0;
-  if (typeof value !== 'string' || byteLength === 0 || byteLength > 255 || value.includes('\0')) {
-    throw new TypeError('maintenanceWave must be a 1..255 byte UTF-8 string without NUL.');
+  if (
+    typeof value !== 'string' ||
+    byteLength === 0 ||
+    byteLength > ZLINK_MAX_IDENTITY_TEXT_BYTES ||
+    value.includes('\0')
+  ) {
+    throw new TypeError(
+      `maintenanceWave must be a 1..${ZLINK_MAX_IDENTITY_TEXT_BYTES} byte UTF-8 string without NUL.`
+    );
   }
   return value;
 }

package/src/contracts/Configuration/RegistrationBuilderPolicy.ts

@@ -1,5 +1,44 @@
-import type { Type, ZLinkEntrySpot, ZLinkSpot } from '../../contracts';
+import type { Type, ZLinkEntrySpot, ZLinkSpot, ZLinkRelocationStore } from '../../contracts';
+import { ZLINK_MAX_ROUTING_ID_BYTES } from '../Common/CoreTypes';
 import { ZLinkConfigurationException } from './ConfigurationException';
+export const MAX_LISTENER_PORT = 65_535;
+
+export function registerRelocationStore(
+  options: { relocationStoreInstance?: ZLinkRelocationStore },
+  store: ZLinkRelocationStore
+): void {
+  if (options.relocationStoreInstance !== undefined) {
+    throw new ZLinkConfigurationException('Relocation Store is already registered.');
+  }
+  options.relocationStoreInstance = store;
+}
+export function isValidListenerPort(value: number): boolean {
+  return Number.isInteger(value) && value >= 0 && value <= MAX_LISTENER_PORT;
+}
+
+export const ZLINK_MAX_CAPACITY = 0x7fff_ffff;
+export function isValidPositiveCapacity(value: number): boolean {
+  return Number.isSafeInteger(value) && value > 0 && value <= ZLINK_MAX_CAPACITY;
+}
+export function isValidCapacity(value: number): boolean {
+  return Number.isSafeInteger(value) && value >= 0 && value <= ZLINK_MAX_CAPACITY;
+}
+
+export const ZLINK_DEFAULT_PUBLIC_WEIGHT = 100;
+export const ZLINK_MAX_PUBLIC_WEIGHT = 10_000;
+
+export function isValidPublicWeight(value: number): boolean {
+  return Number.isInteger(value) && value >= 0 && value <= ZLINK_MAX_PUBLIC_WEIGHT;
+}
+
+export function requirePublicWeight(value: number, label: string): number {
+  if (!isValidPublicWeight(value)) {
+    throw new ZLinkConfigurationException(
+      `${label} must be an integer in 0..${ZLINK_MAX_PUBLIC_WEIGHT}.`
+    );
+  }
+  return value;
+}
 
 export function validateMessageFollowDuration(timeoutMs: number): number {
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0) {
@@ -69,7 +108,10 @@ export function validateRoutingIdPrefix(prefix: string): string {
   if (prefix.trim().length === 0 || prefix !== prefix.trim()) {
     throw new ZLinkConfigurationException('Routing-id prefix must not be empty or padded.');
   }
-  if (Buffer.byteLength(`${prefix}-00000000-0000-0000-0000-000000000000`, 'utf8') > 255) {
+  if (
+    Buffer.byteLength(`${prefix}-00000000-0000-0000-0000-000000000000`, 'utf8') >
+    ZLINK_MAX_ROUTING_ID_BYTES
+  ) {
     throw new ZLinkConfigurationException(
       'Routing-id prefix is too long for a generated routing id.'
     );

package/src/contracts/Configuration/RegistrationBuilders.ts

@@ -1,64 +1,85 @@
+import { AutoHwmProfile } from '@zlink-systems/zlink';
 import type {
   RoutingId,
   Type,
   ZLinkActor,
   ZLinkActorFactory,
+  ZLinkClientServerChannelClientBuilder,
+  ZLinkClientServerChannelRoleBuilder,
+  ZLinkClientServerChannelServerBuilder,
   ZLinkEntrySpot,
   ZLinkFanoutChannelBuilder,
   ZLinkFrameworkOptions,
+  ZLinkHandlerFilter,
+  ZLinkInstanceSpot,
+  ZLinkLocationOptionValues,
   ZLinkMeshChannelBuilder,
   ZLinkMeshChannelClientBuilder,
   ZLinkMeshChannelServerBuilder,
   ZLinkMeshNodeBuilder,
+  ZLinkMeshNodeSocketConfig,
   ZLinkMeshObjectClientBuilder,
   ZLinkMeshObjectRoleBuilder,
   ZLinkMeshObjectServerBuilder,
-  ZLinkMeshNodeSocketConfig,
-  ZLinkNetworkOptions,
   ZLinkMeshPeerConnection,
   ZLinkMeshPeerConnections,
-  ZLinkLocationOptionValues,
-  ZLinkSpotPublisherConfig,
-  ZLinkHandlerFilter,
-  ZLinkInstanceSpot,
+  ZLinkNetworkOptions,
+  ZLinkSession,
+  ZLinkSessionFactory,
   ZLinkSpot,
-  ZLinkClientServerChannelClientBuilder,
-  ZLinkClientServerChannelRoleBuilder,
-  ZLinkClientServerChannelServerBuilder,
+  ZLinkSpotPublisherConfig,
   ZLinkStreamCompressionBuilder,
   ZLinkStreamCompressionCodec,
-  ZLinkStreamSocketConfig,
   ZLinkStreamNodeBuilder,
-  ZLinkSession,
-  ZLinkSessionFactory
+  ZLinkStreamSocketConfig
 } from '../../contracts';
-import type {
-  ZLinkActorFactoryBuilder,
-  ZLinkActorRelocationAdapter,
-  ZLinkInstanceSpotFactoryBuilder,
-  ZLinkSpotRelocationAdapter,
-  ZLinkUserSpotFactoryBuilder
-} from './ObjectRoles';
-import { ZLinkSpotRelocationCoordinationMode, ZLinkUserSpotExecutionMode } from './ObjectRoles';
-import type { ZLinkSpotNodeBuilder } from '../Spots/Builders';
-import { readZLinkDecoratorMetadata } from '../Handlers/Attributes';
 import type { ZLinkCodecRegistryBuilder } from '../Codecs';
-import type {
-  ZLinkDispatchOptions,
-  ZLinkDispatchOptionsBuilder,
-  ZLinkInboundDispatchOptions,
-  ZLinkMessageFlowLogMode
-} from '../Dispatch';
+import { ZLINK_MAX_STABLE_TYPE_BYTES } from '../Common/CoreTypes';
 import {
+  type ZLinkDispatchOptions,
+  type ZLinkDispatchOptionsBuilder,
+  type ZLinkInboundDispatchOptions,
+  type ZLinkMessageFlowLogMode,
   ZLinkApplicationJobQueueProfile,
   ZLinkCoreHwmProfile,
   ZLinkUnhandledDispatchAction
 } from '../Dispatch';
-import { AutoHwmProfile } from '@zlink-systems/zlink';
-import { endpointConnections } from './RuntimeEndpointConnections';
-import type { ZLinkEndpointConnections } from './Connections';
+
+import { readZLinkDecoratorMetadata } from '../Handlers/Attributes';
 import type { ZLinkLocationOptions, ZLinkLocationStore, ZLinkRelocationStore } from '../Locations';
+import type { ZLinkSpotNodeBuilder } from '../Spots/Builders';
 import { ZLinkConfigurationException } from './ConfigurationException';
+import type { ZLinkEndpointConnections } from './Connections';
+import { requireMessageFlowLogMode, requireTraceSampleRate } from './DiagnosticsValidation';
+import { normalizeEndpoint } from './EndpointNotation';
+import { requirePublicFanoutTopic } from './FanoutTopic';
+import { DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE } from './InternalDefaults';
+import {
+  type ZLinkActorFactoryBuilder,
+  type ZLinkActorRelocationAdapter,
+  type ZLinkInstanceSpotFactoryBuilder,
+  type ZLinkSpotRelocationAdapter,
+  type ZLinkUserSpotFactoryBuilder,
+  ZLinkSpotRelocationCoordinationMode,
+  ZLinkUserSpotExecutionMode
+} from './ObjectRoles';
+
+import {
+  MAX_LISTENER_PORT,
+  ZLINK_MAX_CAPACITY,
+  isValidCapacity,
+  isValidListenerPort,
+  isValidPositiveCapacity,
+  registerActorFactory,
+  registerEntrySpot,
+  registerRelocationStore,
+  registerSpotFactory,
+  requirePublicWeight,
+  validateActorTransferTimeout,
+  validateMessageFollowDuration,
+  validateRoutingIdPrefix,
+  validateSessionReplacementCallbackTimeout
+} from './RegistrationBuilderPolicy';
 import {
   RegistrationCodecRegistryBuilder,
   type MutableCodecRegistryOptions
@@ -68,14 +89,12 @@ import {
   normalizeOptionalPositiveInteger,
   typeMapToRecord
 } from './RegistrationNormalizers';
-import { normalizeEndpoint } from './EndpointNotation';
-import { DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE } from './InternalDefaults';
 import type {
-  ZLinkChannelPublishHandlerRegistration,
   ZLinkActorFactoryConfiguration,
   ZLinkApplicationJobQueueOptions,
-  ZLinkFrameworkRegistrationOptions,
+  ZLinkChannelPublishHandlerRegistration,
   ZLinkCoreHwmOptions,
+  ZLinkFrameworkRegistrationOptions,
   ZLinkInstanceSpotFactoryConfiguration,
   ZLinkRelocationConfiguration,
   ZLinkSpotRouterPeerConnectionOptions,
@@ -83,17 +102,7 @@ import type {
   ZLinkUserSpotFactoryConfiguration,
   ZLinkWorkerOptions
 } from './RegistrationTypes';
-import {
-  validateRoutingIdPrefix,
-  registerActorFactory,
-  registerEntrySpot,
-  registerSpotFactory,
-  validateActorTransferTimeout,
-  validateMessageFollowDuration,
-  validateSessionReplacementCallbackTimeout
-} from './RegistrationBuilderPolicy';
-import { requireMessageFlowLogMode, requireTraceSampleRate } from './DiagnosticsValidation';
-import { requirePublicFanoutTopic } from './FanoutTopic';
+import { endpointConnections } from './RuntimeEndpointConnections';
 
 export function createFrameworkOptions(
   configure: (options: ZLinkFrameworkOptions) => void
@@ -144,7 +153,7 @@ class ZLinkFrameworkOptionsBuilder implements ZLinkFrameworkOptions {
 
   addRelocationStore(store: ZLinkRelocationStore): this {
     this.options.locations ??= { options: {} };
-    this.options.locations.relocationStoreInstance = store;
+    registerRelocationStore(this.options.locations, store);
     return this;
   }
 
@@ -617,9 +626,9 @@ class DefaultClientServerChannelServerBuilder implements ZLinkClientServerChanne
   ) {}
 
   listen(port = 0): this {
-    if (!Number.isInteger(port) || port < 0 || port > 65_535) {
+    if (!isValidListenerPort(port)) {
       throw new ZLinkConfigurationException(
-        `ClientServer channel '${this.name}' port must be between 0 and 65535.`
+        `ClientServer channel '${this.name}' port must be between 0 and ${MAX_LISTENER_PORT}.`
       );
     }
     this.server.port = port;
@@ -894,9 +903,9 @@ class DefaultMeshNodeBuilder implements ZLinkMeshNodeBuilder {
       this.node.router.port = undefined;
       return this;
     }
-    if (!Number.isInteger(endpointOrPort) || endpointOrPort < 0 || endpointOrPort > 65_535) {
+    if (!isValidListenerPort(endpointOrPort)) {
       throw new ZLinkConfigurationException(
-        `RouteMesh '${this.name}' port must be between 0 and 65535.`
+        `RouteMesh '${this.name}' port must be between 0 and ${MAX_LISTENER_PORT}.`
       );
     }
     this.node.router.port = endpointOrPort;
@@ -1431,22 +1440,28 @@ function endpointList(endpoint: string | readonly string[]): string[] {
 
 function requireStableObjectType(value: string, label: string): string {
   const byteLength = Buffer.byteLength(value, 'utf8');
-  if (byteLength < 1 || byteLength > 255 || value.includes('\0')) {
-    throw new ZLinkConfigurationException(`${label} must contain 1..255 UTF-8 bytes and no NUL.`);
+  if (byteLength < 1 || byteLength > ZLINK_MAX_STABLE_TYPE_BYTES || value.includes('\0')) {
+    throw new ZLinkConfigurationException(
+      `${label} must contain 1..${ZLINK_MAX_STABLE_TYPE_BYTES} UTF-8 bytes and no NUL.`
+    );
   }
   return value;
 }
 
 function requirePositiveCapacity(value: number, label: string): number {
-  if (!Number.isSafeInteger(value) || value <= 0 || value > 0x7fff_ffff) {
-    throw new ZLinkConfigurationException(`${label} must be an integer in 1..2147483647.`);
+  if (!isValidPositiveCapacity(value)) {
+    throw new ZLinkConfigurationException(
+      `${label} must be an integer in 1..${ZLINK_MAX_CAPACITY}.`
+    );
   }
   return value;
 }
 
 function requireCapacity(value: number, label: string): number {
-  if (!Number.isSafeInteger(value) || value < 0 || value > 0x7fff_ffff) {
-    throw new ZLinkConfigurationException(`${label} must be an integer in 0..2147483647.`);
+  if (!isValidCapacity(value)) {
+    throw new ZLinkConfigurationException(
+      `${label} must be an integer in 0..${ZLINK_MAX_CAPACITY}.`
+    );
   }
   return value;
 }
@@ -1458,13 +1473,6 @@ function requireNonNegativeSafeInteger(value: number, label: string): number {
   return value;
 }
 
-function requirePublicWeight(value: number, label: string): number {
-  if (!Number.isInteger(value) || value < 0 || value > 10_000) {
-    throw new ZLinkConfigurationException(`${label} must be an integer in 0..10000.`);
-  }
-  return value;
-}
-
 function requireFactoryConfigure(
   configure: unknown
 ): asserts configure is (builder: unknown) => void {
@@ -1502,9 +1510,9 @@ function validateUserSpotFactoryOptions(
 }
 
 function validateStableTypeLimit(value: number | undefined): void {
-  if (value !== undefined && (!Number.isInteger(value) || value < 0 || value > 2_147_483_647)) {
+  if (value !== undefined && !isValidCapacity(value)) {
     throw new ZLinkConfigurationException(
-      'stableTypeLimit must be an integer from 0 through 2147483647.'
+      `stableTypeLimit must be an integer from 0 through ${ZLINK_MAX_CAPACITY}.`
     );
   }
 }
@@ -1578,7 +1586,6 @@ interface MutableServerCapabilityOptions {
   weight?: number;
   sendHighWaterMark?: number;
   receiveHighWaterMark?: number;
-  sendTimeoutMs?: number;
   maxMessageSize?: number;
 }
 
@@ -1586,11 +1593,11 @@ interface MutableClientCapabilityOptions {
   manualConnections?: string[];
   sendHighWaterMark?: number;
   receiveHighWaterMark?: number;
-  sendTimeoutMs?: number;
   maxMessageSize?: number;
 }
 
 interface MutablePublisherCapabilityOptions {
+  sendTimeoutMs?: number;
   bind?: string;
   bindHost?: string;
   advertiseHost?: string;
@@ -1681,7 +1688,6 @@ interface MutableSpotRouterCapabilityOptions {
   sendHighWaterMark?: number;
   receiveHighWaterMark?: number;
   receiveTimeoutMs?: number;
-  sendTimeoutMs?: number;
 }
 
 interface MutableSpotPubSubCapabilityOptions {
@@ -1705,8 +1711,8 @@ function requireRegistrationName(value: string, label: string): void {
 }
 
 function requireListenerPort(value: number, label: string): number {
-  if (!Number.isInteger(value) || value < 0 || value > 65_535) {
-    throw new ZLinkConfigurationException(`${label} must be between 0 and 65535.`);
+  if (!isValidListenerPort(value)) {
+    throw new ZLinkConfigurationException(`${label} must be between 0 and ${MAX_LISTENER_PORT}.`);
   }
   return value;
 }

package/src/contracts/Configuration/RegistrationTypes.ts

@@ -183,7 +183,6 @@ export interface ZLinkChannelOptions {
     readonly weight?: number;
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
     readonly maxMessageSize?: number;
   };
   readonly subscriber?: ZLinkClientCapabilityOptions;
@@ -193,11 +192,11 @@ export interface ZLinkClientCapabilityOptions {
   readonly manualConnections?: readonly string[];
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
-  readonly sendTimeoutMs?: number;
   readonly maxMessageSize?: number;
 }
 
 export interface ZLinkPublisherCapabilityOptions {
+  readonly sendTimeoutMs?: number;
   readonly bind?: string;
   readonly bindHost?: string;
   readonly advertiseHost?: string;
@@ -213,7 +212,6 @@ export interface ZLinkRouteMeshChannelOptions {
   readonly weight?: number;
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
-  readonly sendTimeoutMs?: number;
   readonly sendHandlers?: readonly ZLinkRouteChannelSendHandlerRegistration[];
   readonly requestHandlers?: readonly ZLinkRouteChannelRequestHandlerRegistration[];
   readonly handlers?: readonly ZLinkRouteChannelHandlerOptions[];
@@ -229,7 +227,6 @@ export interface ZLinkRouteChannelOptions {
   readonly weight?: number;
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
-  readonly sendTimeoutMs?: number;
   readonly sendHandlers?: readonly ZLinkRouteChannelSendHandlerRegistration[];
   readonly requestHandlers?: readonly ZLinkRouteChannelRequestHandlerRegistration[];
   readonly handlers?: readonly ZLinkRouteChannelHandlerOptions[];
@@ -429,7 +426,6 @@ export interface ZLinkSpotRouterCapabilityOptions {
   readonly sendHighWaterMark?: number;
   readonly receiveHighWaterMark?: number;
   readonly receiveTimeoutMs?: number;
-  readonly sendTimeoutMs?: number;
 }
 
 export interface ZLinkSpotRouterPeerConnectionOptions {