@zlink-systems/framework 0.25.0 → 0.27.0

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}.`
     );
   }
 }
@@ -1591,6 +1599,7 @@ interface MutableClientCapabilityOptions {
 }
 
 interface MutablePublisherCapabilityOptions {
+  sendTimeoutMs?: number;
   bind?: string;
   bindHost?: string;
   advertiseHost?: string;
@@ -1705,8 +1714,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

@@ -198,6 +198,7 @@ export interface ZLinkClientCapabilityOptions {
 }
 
 export interface ZLinkPublisherCapabilityOptions {
+  readonly sendTimeoutMs?: number;
   readonly bind?: string;
   readonly bindHost?: string;
   readonly advertiseHost?: string;

package/src/contracts/Configuration/RegistrationValidators.ts

@@ -1,12 +1,16 @@
 import type { Type, ZLinkSpot } from '../../contracts';
+import { zlinkDefaultLocationOptions } from '../Locations';
 import { ZLinkConfigurationException } from './ConfigurationException';
+import { requirePublicFanoutTopic } from './FanoutTopic';
+import { RELOCATION_STATE_CHUNK_DATA_MAX_BYTES } from './InternalDefaults';
+import { requirePublicWeight } from './RegistrationBuilderPolicy';
 import { requirePositiveInteger } from './RegistrationNormalizers';
 import type {
   ZLinkFrameworkRegistration,
   ZLinkFrameworkRegistrationOptions,
+  ZLinkMeshChannelOptions,
   ZLinkRouteChannelOptions,
   ZLinkRouteMeshChannelOptions,
-  ZLinkMeshChannelOptions,
   ZLinkSpotNodeOptions,
   ZLinkSpotPubSubCapabilityOptions,
   ZLinkSpotRouterCapabilityOptions,
@@ -14,10 +18,9 @@ import type {
   ZLinkWorkerOptions
 } from './RegistrationTypes';
 import { isRouteClientEnabled, isRouteTransportDeclared } from './RouteChannelInternalState';
-import { validateTimerRegistration } from './TimerRegistrationValidator';
-import { zlinkDefaultLocationOptions } from '../Locations';
 import { requireValidSendTimeoutMs } from './SendTimeoutValidation';
-import { requirePublicFanoutTopic } from './FanoutTopic';
+import { validateTimerRegistration } from './TimerRegistrationValidator';
+const ROUTE_CACHE_FOLLOW_MARGIN_MS = 5000;
 
 export function validateFrameworkRegistration(
   registration: ZLinkFrameworkRegistration,
@@ -132,11 +135,12 @@ function validateLocationRegistration(registration: ZLinkFrameworkRegistration):
     }
   }
   if (
-    options.ownerLeaseRenewIntervalMs + options.ownerLeaseRenewTimeoutMs >=
+    Math.max(options.ownerLeaseRenewIntervalMs, options.ownerLeaseRenewTimeoutMs) +
+      options.ownerLeaseRenewTimeoutMs >=
     options.ownerLeaseTtlMs - options.ownerLeaseFencingMarginMs
   ) {
     throw new ZLinkConfigurationException(
-      'ownerLeaseRenewIntervalMs + ownerLeaseRenewTimeoutMs must be less than ownerLeaseTtlMs - ownerLeaseFencingMarginMs.'
+      'max(ownerLeaseRenewIntervalMs, ownerLeaseRenewTimeoutMs) + ownerLeaseRenewTimeoutMs must be less than ownerLeaseTtlMs - ownerLeaseFencingMarginMs.'
     );
   }
   for (const [name, value] of Object.entries({
@@ -147,9 +151,9 @@ function validateLocationRegistration(registration: ZLinkFrameworkRegistration):
       throw new ZLinkConfigurationException(`${name} must be a positive integer.`);
     }
   }
-  if (options.relocationPayloadChunkLimitBytes > 67_108_864) {
+  if (options.relocationPayloadChunkLimitBytes > RELOCATION_STATE_CHUNK_DATA_MAX_BYTES) {
     throw new ZLinkConfigurationException(
-      'relocationPayloadChunkLimitBytes must not exceed the 64 MiB wire chunk bound.'
+      `relocationPayloadChunkLimitBytes must not exceed the ${RELOCATION_STATE_CHUNK_DATA_MAX_BYTES / (1024 * 1024)} MiB wire chunk bound.`
     );
   }
   for (const [name, value] of Object.entries({
@@ -173,10 +177,10 @@ function validateLocationRegistration(registration: ZLinkFrameworkRegistration):
   if (
     options.routeCacheMaxAgeMs > 0 &&
     options.messageFollowDurationMs > 0 &&
-    options.routeCacheMaxAgeMs > options.messageFollowDurationMs - 5000
+    options.routeCacheMaxAgeMs > options.messageFollowDurationMs - ROUTE_CACHE_FOLLOW_MARGIN_MS
   ) {
     throw new ZLinkConfigurationException(
-      'routeCacheMaxAgeMs must be at least 5000 ms shorter than messageFollowDurationMs.'
+      `routeCacheMaxAgeMs must be at least ${ROUTE_CACHE_FOLLOW_MARGIN_MS} ms shorter than messageFollowDurationMs.`
     );
   }
 }
@@ -232,6 +236,10 @@ function validateChannelCapabilities(
       requireSocketOptions(`channel '${channelName}' server`, channel.server);
     }
     if (channel.publisher !== undefined) {
+      requireValidSendTimeoutMs(
+        `channel '${channelName}' publisher sendTimeoutMs`,
+        channel.publisher.sendTimeoutMs
+      );
       requireEndpoint(`channel '${channelName}' publisher`, channel.publisher.bind);
       validateListenerNetworkIdentity(
         `channel '${channelName}' publisher`,
@@ -714,9 +722,7 @@ function requirePeerWeight(label: string, value: number | undefined): void {
   if (value === undefined) {
     return;
   }
-  if (!Number.isInteger(value) || value < 0 || value > 10_000) {
-    throw new ZLinkConfigurationException(`${label} must be an integer in 0..10000.`);
-  }
+  requirePublicWeight(value, label);
 }
 
 function requireSocketOptions(

package/src/contracts/Configuration/TimerRegistrationValidator.ts

@@ -1,6 +1,8 @@
 import { ZLinkTimerOverrunPolicy, type ZLinkTimerOptions } from '../Timers';
 import { ZLinkConfigurationException } from './ConfigurationException';
 
+const MAX_TIMER_CATCH_UP_TICKS = 2_147_483_647;
+
 export function validateTimerRegistration(
   name: string,
   periodMs: number,
@@ -23,10 +25,10 @@ export function validateTimerRegistration(
     (options.maxCatchUpTicks === undefined ||
       !Number.isInteger(options.maxCatchUpTicks) ||
       options.maxCatchUpTicks < 1 ||
-      options.maxCatchUpTicks > 2_147_483_647)
+      options.maxCatchUpTicks > MAX_TIMER_CATCH_UP_TICKS)
   ) {
     throw new ZLinkConfigurationException(
-      'SPOT timer MaxCatchUpTicks must be an integer from 1 through 2,147,483,647.'
+      `SPOT timer MaxCatchUpTicks must be an integer from 1 through ${MAX_TIMER_CATCH_UP_TICKS.toLocaleString('en-US')}.`
     );
   }
 }

package/src/contracts/Dispatch/ZLinkDispatchOptions.ts

@@ -194,6 +194,7 @@ export type ZLinkDispatchErrorReason =
   | 'reply_path_missing'
   | 'unexpected_reply'
   | 'backpressure'
+  | 'target_closed'
   | 'stale_target'
   | 'shutdown';
 

package/src/contracts/Handlers/JsonContract.ts

@@ -1,3 +1,5 @@
+const MAX_CONTRACT_SCHEMA_DEPTH = 64;
+
 /** Describes the fields accepted by the default framework-json-v1 serializer. */
 export type ZLinkJsonSchema =
   | { readonly type: 'boolean' }
@@ -75,9 +77,13 @@ function normalizeJsonSchema(
   // Keep the runtime boundary defensive for JavaScript callers even though
   // the TypeScript signature describes the accepted shape.
   const runtimeSchema: unknown = schema;
-  if (typeof runtimeSchema !== 'object' || runtimeSchema === null || depth > 64) {
+  if (
+    typeof runtimeSchema !== 'object' ||
+    runtimeSchema === null ||
+    depth > MAX_CONTRACT_SCHEMA_DEPTH
+  ) {
     throw new TypeError(
-      'ZLink packet JSON schema must be an acyclic object with at most 64 levels.'
+      `ZLink packet JSON schema must be an acyclic object with at most ${MAX_CONTRACT_SCHEMA_DEPTH} levels.`
     );
   }
   const normalizedSchema = runtimeSchema as ZLinkJsonSchema;
@@ -147,7 +153,7 @@ function normalizeJsonSchema(
       for (const [name, property] of Object.entries(
         runtimeProperties as Record<string, ZLinkJsonSchema>
       )) {
-        if (name === '__proto__' || name === 'prototype' || name === 'constructor') {
+        if (isPrototypeKey(name)) {
           throw new TypeError(`ZLink packet JSON property '${name}' is not allowed.`);
         }
         properties[name] = normalizeJsonSchema(property, nextParents, depth + 1);
@@ -156,7 +162,7 @@ function normalizeJsonSchema(
         throw new TypeError('ZLink packet JSON required properties must be unique.');
       }
       for (const name of normalizedSchema.required) {
-        if (name === '__proto__' || name === 'prototype' || name === 'constructor') {
+        if (isPrototypeKey(name)) {
           throw new TypeError(`ZLink packet JSON property '${name}' is not allowed.`);
         }
         if (!Object.prototype.hasOwnProperty.call(properties, name)) {
@@ -204,3 +210,7 @@ function canonicalContract(value: unknown): string {
     .map(([key, item]) => `${JSON.stringify(key)}:${canonicalContract(item)}`)
     .join(',')}}`;
 }
+
+function isPrototypeKey(name: string): boolean {
+  return name === '__proto__' || name === 'prototype' || name === 'constructor';
+}

package/src/contracts/Locations/Authority.ts

@@ -70,7 +70,7 @@ export type ZLinkAuthorityMutation =
   | {
       readonly kind: 'put';
       readonly payload: Uint8Array;
-      readonly generationTransition: 'preserve';
+      readonly generationTransition: 'preserve' | 'reincarnate';
     }
   | {
       /** Rebinds an authority retained by the same owner after lease recovery. */
@@ -101,13 +101,17 @@ export interface ZLinkAuthorityEntry {
   readonly snapshot: ZLinkAuthoritySnapshot;
 }
 
+const ZLINK_AUTHORITY_MAX_SCAN_CURSOR_BYTES = 4096;
+
 export class ZLinkAuthorityScanCursor {
   private constructor(readonly encoded: string) {}
 
   static from(encoded: string): ZLinkAuthorityScanCursor {
     const byteLength = Buffer.byteLength(encoded, 'utf8');
-    if (byteLength < 1 || byteLength > 4096) {
-      throw new RangeError('Authority scan cursor must contain 1..4096 UTF-8 bytes.');
+    if (byteLength < 1 || byteLength > ZLINK_AUTHORITY_MAX_SCAN_CURSOR_BYTES) {
+      throw new RangeError(
+        `Authority scan cursor must contain 1..${ZLINK_AUTHORITY_MAX_SCAN_CURSOR_BYTES} UTF-8 bytes.`
+      );
     }
     return new ZLinkAuthorityScanCursor(encoded);
   }

package/src/contracts/Locations/Options.ts

@@ -26,7 +26,7 @@ export const zlinkRuntimeDefaultLocationOptions: Readonly<
   ownerLeaseRenewIntervalMs: 5000,
   ownerLeaseTtlMs: 15000,
   pollingIntervalMs: 1000,
-  listPageSize: 1000,
+  listPageSize: 100,
   storeFailureGraceMs: 30000,
   ownerLeaseFencingMarginMs: 5000,
   ownerLeaseRenewTimeoutMs: 3000,

package/src/contracts/Locations/Stores.ts

@@ -1,3 +1,12 @@
+export const ZLINK_PROVIDER_MAX_PAGE_SIZE = 1000;
+export const ZLINK_PROVIDER_MAX_KEY_BYTES = 1024;
+export const ZLINK_PROVIDER_MAX_VALUE_BYTES = 1024 * 1024;
+export const ZLINK_PROVIDER_MAX_VERSION_BYTES = 4096;
+export const ZLINK_PROVIDER_MAX_WRITE_KEYS = 2048;
+export const ZLINK_PROVIDER_MAX_WRITE_BYTES = 4 * 1024 * 1024;
+export const ZLINK_PROVIDER_MAX_ENCODED_PAGE_BYTES = 4 * 1024 * 1024;
+export const ZLINK_PROVIDER_MAX_SCAN_CURSOR_BYTES = 4096;
+
 declare const zlinkStoreKeyBrand: unique symbol;
 declare const zlinkStoreVersionBrand: unique symbol;
 declare const zlinkStoreScanCursorBrand: unique symbol;
@@ -34,6 +43,11 @@ export type ZLinkStoreCondition =
       readonly kind: 'version';
       readonly key: ZLinkStoreKey;
       readonly expected: ZLinkStoreVersion;
+    }
+  | {
+      readonly kind: 'value';
+      readonly key: ZLinkStoreKey;
+      readonly expected: Uint8Array;
     };
 
 export type ZLinkStoreMutation =

package/src/contracts/RouteMesh/RuntimeTopology.ts

@@ -142,12 +142,22 @@ export interface ZLinkHostCapacityStatus {
 
 export interface ZLinkFrameworkRuntime {
   readonly status: ZLinkFrameworkRuntimeStatus;
+  getListenerStatus(kind: ZLinkListenerKind, name: string): ZLinkListenerStatus;
   observe(signal?: AbortSignal): AsyncIterable<ZLinkObservedStatus<ZLinkFrameworkRuntimeStatus>>;
   resetCapacityMetrics(): void;
   relocate(options: ZLinkFrameworkRelocationOptions): Promise<ZLinkFrameworkRelocationResult>;
   shutdown(options?: ZLinkFrameworkLifecycleOptions): Promise<ZLinkFrameworkTerminationResult>;
 }
 
+export type ZLinkListenerKind = 'routeMesh' | 'clientServer' | 'fanout' | 'stream';
+
+export interface ZLinkListenerStatus {
+  readonly kind: ZLinkListenerKind;
+  readonly name: string;
+  readonly endpoint: string;
+  readonly observedAt: Date;
+}
+
 export type ZLinkClientServerRole = 'client' | 'server' | 'clientAndServer';
 
 export interface ZLinkClientServerTargetStatus {

package/src/contracts/Spots/Contracts.ts

@@ -32,7 +32,7 @@ export interface ZLinkWorkerCall<T> {
 export interface ZLinkSpotCommonContext<TSpot = ZLinkSpot> {
   readonly meshName: string;
   readonly spotId: SpotId;
-  readonly objectGeneration: number;
+  readonly objectGeneration: bigint;
   readonly nodeRid: RoutingId;
   readonly outbound: ZLinkSpotOutbound;
   addTimer<THandler extends ZLinkSpotTimerHandler<TSpot>>(

package/src/internal.ts

@@ -3,6 +3,7 @@ export * from './index';
 export * from './runtime/diagnostics';
 export * from './runtime/host';
 export * from './runtime/admission';
+export * from './runtime/activation-admission';
 export * from './runtime/streams';
 export * from './runtime/streams/protocol';
 export * from './runtime/actors';
@@ -28,3 +29,17 @@ export * from './runtime/foundation';
 export * from './runtime/foundation/service-authority-payload-codec';
 export * from './runtime/framework-errors-internal';
 export * from './contracts/Configuration/Registration';
+
+export * from './contracts/Locations/Stores';
+export { ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES } from './contracts/Configuration/InternalDefaults';
+export { ZLINK_MAX_STABLE_TYPE_BYTES } from './contracts/Common/CoreTypes';
+export {
+  MAX_LISTENER_PORT,
+  ZLINK_MAX_PUBLIC_WEIGHT,
+  ZLINK_MAX_CAPACITY,
+  isValidPublicWeight,
+  isValidPositiveCapacity,
+  isValidListenerPort,
+  isValidCapacity,
+  requirePublicWeight
+} from './contracts/Configuration/RegistrationBuilderPolicy';

package/src/nest-integration.ts

@@ -1,14 +1,17 @@
 export {
   ZLinkConfigurationException,
   createFrameworkRegistration,
+  normalizeFrameworkRegistration,
   hasActorManager,
   hasSpotNode,
   hasSpotPublisherClient
 } from './contracts/Configuration/Registration';
 export type * from './contracts/Configuration/RegistrationTypes';
 export type * from './contracts';
+export { ZLinkSpotActorSend, ZLinkSpotActorRequest } from './contracts/Handlers/Attributes';
 export {
   registerActorFactory,
+  registerRelocationStore,
   validateRoutingIdPrefix,
   registerEntrySpot,
   registerSpotFactory,
@@ -73,6 +76,10 @@ export {
   registerHandlerFilterScope as registerIntegrationHandlerFilterScope,
   type ZLinkHandlerFilterScopeRunner
 } from './runtime/channels/handler-filter-scope';
+export {
+  disposeOwnedInstance as disposeIntegrationHandler,
+  disposeOwnedInstances as disposeIntegrationHandlers
+} from './runtime/handlers/handler-instance-scope';
 
 export interface ZLinkNestIntegrationRuntimeHost extends Pick<
   import('./contracts').ZLinkFrameworkRuntime,
@@ -134,7 +141,13 @@ export function createIntegrationChannelClient(
   registration: ZLinkFrameworkRegistration,
   runtime: ZLinkNestIntegrationRuntimeHost
 ): ZLinkChannelClient {
-  return new DefaultZLinkChannelClient(registration, runtimeHost(runtime).channelTransport);
+  const host = runtimeHost(runtime);
+  return new DefaultZLinkChannelClient(
+    registration,
+    host.channelTransport,
+    host.routeTransport,
+    host.spotRouterChannelIdForMesh
+  );
 }
 
 export function createIntegrationFanoutClient(
@@ -152,7 +165,8 @@ export function createIntegrationRouteClient(
   return new DefaultZLinkRouteClient(
     registration,
     host.routeTransport,
-    host.spotRouterChannelIdForMesh
+    host.spotRouterChannelIdForMesh,
+    host.channelTransport
   );
 }
 
@@ -180,14 +194,17 @@ export function createIntegrationActorManager(
 ): ZLinkActorManager {
   const host = runtimeHost(runtime);
   const runtimeOptions = host.createActorManagerOptions();
-  const manager = new DefaultZLinkActorManager({
-    actorFactories: registration.actorFactories,
-    ...runtimeOptions,
-    boundSessionFactory:
-      runtimeOptions.boundSessionFactory ??
-      host.boundSessionFactory.create.bind(host.boundSessionFactory),
-    providerResolver
-  });
+  const manager = new DefaultZLinkActorManager(
+    {
+      actorFactories: registration.actorFactories,
+      ...runtimeOptions,
+      boundSessionFactory:
+        runtimeOptions.boundSessionFactory ??
+        host.boundSessionFactory.create.bind(host.boundSessionFactory),
+      providerResolver
+    },
+    host.detachedTaskRunner()
+  );
   host.setActorManager(manager);
   return manager;
 }
@@ -229,6 +246,7 @@ export function createIntegrationSpotManager(
       ...(spotNode.spotActorRequestHandlers ?? [])
     ]),
     ...runtimeOptions,
+    detachedTaskRunner: host.detachedTaskRunner(),
     spotRouteResolver: runtimeOptions.spotRouteResolver,
     routedTransport: host.routeTransport,
     providerResolver,