@zlink-systems/framework 0.26.0 → 0.28.0

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(
@@ -724,14 +730,12 @@ function requireSocketOptions(
   options: {
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
     readonly maxMessageSize?: number;
   }
 ): void {
   requireNonNegativeInteger(`${label} sendHighWaterMark`, options.sendHighWaterMark);
   requireNonNegativeInteger(`${label} receiveHighWaterMark`, options.receiveHighWaterMark);
   requireNonNegativeInteger(`${label} maxMessageSize`, options.maxMessageSize);
-  requireValidSendTimeoutMs(`${label} sendTimeoutMs`, options.sendTimeoutMs);
 }
 
 function requireRouteMeshSocketOptions(
@@ -739,10 +743,8 @@ function requireRouteMeshSocketOptions(
   options: {
     readonly sendHighWaterMark?: number;
     readonly receiveHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
   }
 ): void {
   requireNonNegativeInteger(`${label} sendHighWaterMark`, options.sendHighWaterMark);
   requireNonNegativeInteger(`${label} receiveHighWaterMark`, options.receiveHighWaterMark);
-  requireValidSendTimeoutMs(`${label} sendTimeoutMs`, options.sendTimeoutMs);
 }

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/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>>(
@@ -96,7 +96,7 @@ export interface ZLinkSpotSendCall {
   instanceSpot(): this;
   instanceSpot(instanceSpotType: string): this;
   inMesh(meshName: string): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }
 
 export interface ZLinkSpotRequestCall {

package/src/contracts/Streams/BoundSessionContracts.ts

@@ -5,5 +5,5 @@ export interface ZLinkBoundSession {
 
 export interface ZLinkBoundSessionSendCall {
   metadata(key: string, value: string): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }

package/src/contracts/Streams/IZLinkSession.ts

@@ -42,11 +42,10 @@ export interface ZLinkSessionClient {
 export interface ZLinkSessionSendCall {
   metadata(key: string, value: string): this;
   compress(enabled?: boolean): this;
-  timeout(timeoutMs: number): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }
 
 export interface ZLinkSessionReplyCall {
   compress(enabled?: boolean): this;
-  submit(signal?: AbortSignal): Promise<void>;
+  submit(): Promise<void>;
 }

package/src/contracts/Streams/IZLinkSessionActor.ts

@@ -11,11 +11,7 @@ export interface ZLinkSessionActors {
 export interface ZLinkSessionActor {
   readonly actorId: string;
   readonly ref: ActorRef;
-  relay(payload: ZLinkMessage, signal?: AbortSignal): Promise<void>;
-  relay(
-    dispatch: ZLinkSessionDispatchContext,
-    payload: ZLinkMessage,
-    signal?: AbortSignal
-  ): Promise<void>;
+  relay(payload: ZLinkMessage): Promise<void>;
+  relay(dispatch: ZLinkSessionDispatchContext, payload: ZLinkMessage): Promise<void>;
   notifyDisconnected(signal?: AbortSignal): Promise<void>;
 }

package/src/internal.ts

@@ -29,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,

package/src/runtime/abort.ts

@@ -38,15 +38,15 @@ export function throwIfAborted(signal: AbortSignal | undefined): void {
   }
 }
 
+export function macrotaskBoundary(): Promise<void> {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
 export function awaitWithAbort<T>(
   operation: Promise<T>,
   signal: AbortSignal | undefined,
   abortOperation?: () => void
 ): Promise<T> {
-  if (signal?.aborted === true) {
-    abortOperation?.();
-    throw createAbortError();
-  }
   if (signal === undefined) {
     return operation;
   }
@@ -63,7 +63,6 @@ export function awaitWithAbort<T>(
       abortOperation?.();
       reject(createAbortError());
     };
-    signal.addEventListener('abort', abort, { once: true });
     operation.then(
       (value) => {
         if (settle()) resolve(value);
@@ -72,5 +71,7 @@ export function awaitWithAbort<T>(
         if (settle()) reject(error);
       }
     );
+    if (signal.aborted) abort();
+    else signal.addEventListener('abort', abort, { once: true });
   });
 }

package/src/runtime/activation-admission.ts

@@ -10,7 +10,6 @@ export interface ZLinkActivationConcurrency {
 }
 
 interface ZLinkActivationRecord {
-  readonly meshName: string;
   readonly limit: number;
   active: number;
 }
@@ -27,10 +26,7 @@ interface ZLinkActivationRecord {
 export class ZLinkActivationAdmission {
   private readonly records = new Map<string, ZLinkActivationRecord>();
 
-  constructor(
-    private readonly limitOf: (meshName: string) => number,
-    private readonly changed?: (meshName: string) => void
-  ) {}
+  constructor(private readonly limitOf: (meshName: string) => number) {}
 
   current(meshName: string): ZLinkActivationConcurrency {
     const record = this.records.get(meshName);
@@ -57,20 +53,18 @@ export class ZLinkActivationAdmission {
       );
     }
     record.active += 1;
-    this.changed?.(meshName);
     let released = false;
     return () => {
       if (released) return;
       released = true;
       record.active -= 1;
-      this.changed?.(meshName);
     };
   }
 
   private record(meshName: string): ZLinkActivationRecord {
     let record = this.records.get(meshName);
     if (record === undefined) {
-      record = { meshName, limit: this.limitOf(meshName), active: 0 };
+      record = { limit: this.limitOf(meshName), active: 0 };
       this.records.set(meshName, record);
     }
     return record;

package/src/runtime/actors/actor-authority-payload-codec.ts

@@ -1,13 +1,29 @@
-import type { RoutingId } from '../../contracts';
-import { ZLinkSpotKind, zlinkSpotKindFromWire, zlinkSpotKindToWire } from '../../contracts';
+import { UINT64_MAX } from '@zlink-systems/stream-wire';
+import {
+  type RoutingId,
+  ZLinkSpotKind,
+  zlinkSpotKindFromWire,
+  zlinkSpotKindToWire
+} from '../../contracts';
+
+import { ZLINK_MAX_ROUTING_ID_BYTES } from '../../contracts/Common/CoreTypes';
+import { AUTHORITY_ENVELOPE_MAX_BYTES } from '../../contracts/Configuration/InternalDefaults';
 import { crc32c } from '../foundation/service-relocation-runtime';
+import { SERVICE_WIRE_TEXT8_MAX_BYTES } from '../foundation/service-wire-binary-primitives';
 import { decodeRoutingId, encodeRoutingIdStorageHex } from '../routing-id';
 
 const AUTHORITY_MAGIC = Buffer.from([0x5a, 0x4c, 0x41, 0x55]);
 const AUTHORITY_VERSION = 1;
 const AUTHORITY_FLAGS = 0;
 const ACTOR_RELOCATION_MAGIC = Buffer.from([0x5a, 0x4c, 0x41, 0x50]);
-const MAXIMUM_BYTES = 1024 * 1024;
+const AUTHORITY_MINIMUM_BYTES = 15;
+const ACTOR_RELOCATION_MINIMUM_BYTES = 32;
+const ACTOR_RELOCATION_VERSION_WITHOUT_SESSION_FENCE = 5;
+const ACTOR_RELOCATION_VERSION_WITH_SESSION_FENCE = 6;
+const ACTOR_RELOCATION_FIRST_PHASE = 1;
+const ACTOR_RELOCATION_STEADY_PHASE = 4;
+const ENTRY_SPOT_WIRE_KIND = zlinkSpotKindToWire(ZLinkSpotKind.Entry);
+const USER_SPOT_WIRE_KIND = zlinkSpotKindToWire(ZLinkSpotKind.User);
 const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
 
 export type ZLinkActorAuthorityState = 'creating' | 'ready';
@@ -47,8 +63,10 @@ export function encodeCanonicalAuthorityPayload(value: ZLinkCanonicalAuthorityPa
     body
   );
   const encoded = concat(envelope, u32be(crc32c(envelope)));
-  if (encoded.byteLength > MAXIMUM_BYTES) {
-    throw new RangeError('Actor authority payload exceeds 1 MiB.');
+  if (encoded.byteLength > AUTHORITY_ENVELOPE_MAX_BYTES) {
+    throw new RangeError(
+      `Actor authority payload exceeds ${AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`
+    );
   }
   return encoded;
 }
@@ -59,7 +77,10 @@ export function decodeCanonicalAuthorityPayload(
 ): ZLinkCanonicalAuthorityPayload | undefined {
   try {
     const reader = new BigEndianReader(payload);
-    if (reader.bytes.byteLength < 15 || reader.bytes.byteLength > MAXIMUM_BYTES) {
+    if (
+      reader.bytes.byteLength < AUTHORITY_MINIMUM_BYTES ||
+      reader.bytes.byteLength > AUTHORITY_ENVELOPE_MAX_BYTES
+    ) {
       return undefined;
     }
     reader.expect(AUTHORITY_MAGIC);
@@ -81,7 +102,7 @@ export function decodeCanonicalAuthorityPayload(
 /** Byte-exact Node counterpart of .NET ZLinkActorAuthorityPayloadCodec.Encode. */
 export function encodeActorAuthorityPayload(value: ZLinkActorAuthorityPayload): Buffer {
   const spotKind = zlinkSpotKindToWire(value.currentSpotKind);
-  if (spotKind !== 1 && spotKind !== 2) {
+  if (spotKind !== ENTRY_SPOT_WIRE_KIND && spotKind !== USER_SPOT_WIRE_KIND) {
     throw new RangeError('Actor currentSpotKind must be Entry or User.');
   }
   const actor = concat(
@@ -173,7 +194,7 @@ export function actorRelocationAuthorityApplicationPayload(
   const current = decodeActorRelocationEnvelope(payload);
   return current === undefined
     ? Buffer.from(payload)
-    : current.phase === 4
+    : current.phase === ACTOR_RELOCATION_STEADY_PHASE
       ? Buffer.from(current.applicationPayload)
       : undefined;
 }
@@ -196,8 +217,10 @@ export function replaceActorRelocationAuthorityApplicationPayload(
     applicationPayload
   );
   const encoded = concat(withoutChecksum, u32le(crc32c(withoutChecksum)));
-  if (encoded.byteLength > MAXIMUM_BYTES) {
-    throw new RangeError('Actor relocation authority payload exceeds 1 MiB.');
+  if (encoded.byteLength > AUTHORITY_ENVELOPE_MAX_BYTES) {
+    throw new RangeError(
+      `Actor relocation authority payload exceeds ${AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`
+    );
   }
   return encoded;
 }
@@ -205,7 +228,11 @@ export function replaceActorRelocationAuthorityApplicationPayload(
 function decodeActorRelocationEnvelope(payload: Uint8Array): ActorRelocationEnvelope | undefined {
   try {
     const bytes = Buffer.from(payload);
-    if (bytes.byteLength < 32 || bytes.byteLength > MAXIMUM_BYTES) return undefined;
+    if (
+      bytes.byteLength < ACTOR_RELOCATION_MINIMUM_BYTES ||
+      bytes.byteLength > AUTHORITY_ENVELOPE_MAX_BYTES
+    )
+      return undefined;
     const checksumOffset = bytes.byteLength - 4;
     if (bytes.readUInt32LE(checksumOffset) !== crc32c(bytes.subarray(0, checksumOffset))) {
       return undefined;
@@ -213,10 +240,15 @@ function decodeActorRelocationEnvelope(payload: Uint8Array): ActorRelocationEnve
     const reader = new LittleEndianReader(bytes.subarray(0, checksumOffset));
     reader.expect(ACTOR_RELOCATION_MAGIC);
     const version = reader.u16();
-    if (version !== 5 && version !== 6) return undefined;
+    if (
+      version !== ACTOR_RELOCATION_VERSION_WITHOUT_SESSION_FENCE &&
+      version !== ACTOR_RELOCATION_VERSION_WITH_SESSION_FENCE
+    )
+      return undefined;
     if (reader.take(16).every((byte) => byte === 0)) return undefined;
     const phase = reader.u8();
-    if (phase < 1 || phase > 4) return undefined;
+    if (phase < ACTOR_RELOCATION_FIRST_PHASE || phase > ACTOR_RELOCATION_STEADY_PHASE)
+      return undefined;
     const isBound = reader.bool();
     if (isBound) {
       reader.bytes8();
@@ -230,7 +262,7 @@ function decodeActorRelocationEnvelope(payload: Uint8Array): ActorRelocationEnve
       const ownerLeaseGeneration = reader.u64();
       const sessionOwnerNodeGeneration = reader.u64();
       reader.u64();
-      if (version === 6) {
+      if (version === ACTOR_RELOCATION_VERSION_WITH_SESSION_FENCE) {
         reader.text16();
         reader.u64();
       }
@@ -247,7 +279,7 @@ function decodeActorRelocationEnvelope(payload: Uint8Array): ActorRelocationEnve
     }
     const prefix = Buffer.from(reader.bytes.subarray(0, reader.offset));
     const applicationLength = reader.i32();
-    if (applicationLength < 1 || applicationLength > MAXIMUM_BYTES) return undefined;
+    if (applicationLength < 1 || applicationLength > AUTHORITY_ENVELOPE_MAX_BYTES) return undefined;
     const applicationPayload = Buffer.from(reader.take(applicationLength));
     if (!reader.done) return undefined;
     return { prefix, phase, applicationPayload };
@@ -258,22 +290,28 @@ function decodeActorRelocationEnvelope(payload: Uint8Array): ActorRelocationEnve
 
 function text8(value: string, name: string): Buffer {
   const bytes = Buffer.from(value, 'utf8');
-  if (bytes.byteLength < 1 || bytes.byteLength > 0xff || bytes.includes(0)) {
-    throw new RangeError(`${name} must contain 1..255 UTF-8 bytes without NUL.`);
+  if (
+    bytes.byteLength < 1 ||
+    bytes.byteLength > SERVICE_WIRE_TEXT8_MAX_BYTES ||
+    bytes.includes(0)
+  ) {
+    throw new RangeError(
+      `${name} must contain 1..${SERVICE_WIRE_TEXT8_MAX_BYTES} UTF-8 bytes without NUL.`
+    );
   }
   return concat(Buffer.of(bytes.byteLength), bytes);
 }
 
 function rid(value: RoutingId, name: string): Buffer {
   const bytes = Buffer.from(encodeRoutingIdStorageHex(value), 'hex');
-  if (bytes.byteLength < 1 || bytes.byteLength > 0xff) {
-    throw new RangeError(`${name} must contain 1..255 bytes.`);
+  if (bytes.byteLength < 1 || bytes.byteLength > ZLINK_MAX_ROUTING_ID_BYTES) {
+    throw new RangeError(`${name} must contain 1..${ZLINK_MAX_ROUTING_ID_BYTES} bytes.`);
   }
   return concat(Buffer.of(bytes.byteLength), bytes);
 }
 
 function nonzeroU64be(value: bigint, name: string): Buffer {
-  if (value === 0n || value < 0n || value > 0xffff_ffff_ffff_ffffn) {
+  if (value === 0n || value < 0n || value > UINT64_MAX) {
     throw new RangeError(`${name} must be a non-zero u64.`);
   }
   const result = Buffer.alloc(8);