@zlink-systems/framework 0.25.0 → 0.27.0

package/src/runtime/locations/auto-connect-reconciler.ts

@@ -13,6 +13,8 @@ import { ZLinkLocationKeyCodec } from './key-codec';
 import { normalizeEndpoint } from '../../contracts/Configuration/EndpointNotation';
 import { ZLinkAutoConnectPlanner } from './auto-connect-planner';
 import { ZLinkStateLane } from '../execution/state-lane';
+import { ConnectError } from '@zlink-systems/zlink';
+import type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
 import type {
   IZLinkAutoConnectExecutor,
   IZLinkAutoConnectPeerPublisher,
@@ -33,6 +35,7 @@ export interface ZLinkAutoConnectReconcilerOptions {
   readonly events?: ZLinkAutoConnectEventSink;
   readonly options?: ZLinkLocationOptionOverrides;
   readonly monotonicNowMs?: () => number;
+  readonly errorSink: ZLinkDispatchErrorSink;
 }
 
 export class ZLinkAutoConnectReconciler {
@@ -46,6 +49,7 @@ export class ZLinkAutoConnectReconciler {
   private readonly events?: ZLinkAutoConnectEventSink;
   private readonly options: Required<ZLinkLocationOptionOverrides>;
   private readonly monotonicNowMs: () => number;
+  private readonly errorSink: ZLinkDispatchErrorSink;
   private readonly active = new Map<string, ZLinkAutoConnectTarget>();
   private readonly pendingDisconnects = new Map<string, ZLinkAutoConnectTarget>();
   private readonly failedEndpoints = new Set<string>();
@@ -73,6 +77,7 @@ export class ZLinkAutoConnectReconciler {
     this.events = options.events;
     this.options = { ...zlinkRuntimeDefaultLocationOptions, ...options.options };
     this.monotonicNowMs = options.monotonicNowMs ?? (() => performance.now());
+    this.errorSink = options.errorSink;
     this.executor.onDisconnected?.((endpoint) => this.recordDisconnectedEndpoint(endpoint));
   }
 
@@ -155,13 +160,6 @@ export class ZLinkAutoConnectReconciler {
       await this.lane.run(() => {
         this.storeFailedValue = false;
         this.storeFailureStartedAtMs = undefined;
-        // After a store restart, owners may need one full lease interval to
-        // reclaim their token and republish a descriptor. Do not interpret the
-        // incomplete post-restart scan as a definitive removal.
-        // Keep the existing transport set through one lease interval while
-        // owners reclaim their tokens and republish descriptors. This deferral
-        // applies only after a Store operation failed; a successful empty scan
-        // is authoritative and must remove stale peers promptly.
         this.recoveryDeferUntilMs = this.monotonicNowMs() + this.options.ownerLeaseTtlMs;
       });
     }
@@ -175,7 +173,6 @@ export class ZLinkAutoConnectReconciler {
       );
     });
     const candidates = ZLinkAutoConnectPlanner.computeCandidates(this.local, rows);
-    const nowMs = this.monotonicNowMs();
     this.executor.expectPeers?.([...candidates.values()]);
     this.executor.replaceNotRequired?.(
       ZLinkAutoConnectPlanner.computeNotRequired(this.local, rows)
@@ -196,6 +193,18 @@ export class ZLinkAutoConnectReconciler {
     for (const [key, target] of existingTargets) {
       if (activeKeys.has(key)) desired.set(key, target);
     }
+    const deferringMissingTargets =
+      this.monotonicNowMs() < (await this.lane.run(() => this.recoveryDeferUntilMs));
+    let staleCandidates = candidates;
+    if (deferringMissingTargets) {
+      const retainedCandidates = new Map(candidates);
+      const lastDesired = await this.lane.run(() => [...this.lastDesired]);
+      for (const [key, target] of lastDesired) {
+        if (!desired.has(key)) desired.set(key, target);
+        if (!retainedCandidates.has(key)) retainedCandidates.set(key, target);
+      }
+      staleCandidates = retainedCandidates;
+    }
     await this.lane.run(() => {
       this.lastDesired = new Map(desired);
     });
@@ -226,14 +235,13 @@ export class ZLinkAutoConnectReconciler {
         await this.lane.run(() => {
           this.pendingDisconnects.delete(key);
         });
-        const connected = await this.executor.connect(target);
-        if (connected) {
+        await this.connectTarget(target, async () => {
           connectedEndpoints.push(target.endpoint);
           await this.lane.run(() => {
             this.active.set(key, target);
             this.failedEndpoints.delete(target.endpoint);
           });
-        }
+        });
         continue;
       }
 
@@ -252,27 +260,17 @@ export class ZLinkAutoConnectReconciler {
         await this.lane.run(() => {
           this.pendingDisconnects.delete(key);
         });
-        const connected = await this.executor.connect(target);
-        if (connected) {
+        await this.connectTarget(target, async () => {
           connectedEndpoints.push(target.endpoint);
           await this.lane.run(() => {
             this.active.set(key, target);
             this.failedEndpoints.delete(target.endpoint);
           });
-        }
+        });
       }
     }
 
-    if (nowMs < (await this.lane.run(() => this.recoveryDeferUntilMs))) {
-      this.publishDesiredSetChange(connectedEndpoints, disconnectedEndpoints);
-      return;
-    }
-
-    // A store restart can expose an incomplete descriptor set while peers are
-    // reclaiming their owner leases. Preserve existing transport connections
-    // during that recovery window; stale-peer cleanup is safe after the
-    // deferred reconciliation has completed.
-    this.executor.disconnectStalePeers?.([...candidates.values()]);
+    this.executor.disconnectStalePeers?.([...staleCandidates.values()]);
 
     const activeTargets = await this.lane.run(() => [...this.active]);
     for (const [key, target] of activeTargets) {
@@ -409,10 +407,25 @@ export class ZLinkAutoConnectReconciler {
     const retryTargets = await this.lane.run(() => this.beginStoreFailureCore());
     if (retryTargets === undefined) return;
     for (const [key, target] of retryTargets) {
-      if (await this.executor.connect(target)) {
+      await this.connectTarget(target, async () => {
         await this.lane.run(() => this.completeStoreFailureConnectCore(key, target));
-      }
+      });
+    }
+  }
+
+  private async connectTarget(
+    target: ZLinkAutoConnectTarget,
+    accept: () => Promise<void>
+  ): Promise<void> {
+    let accepted: boolean;
+    try {
+      accepted = await this.executor.connect(target);
+    } catch (error) {
+      if (!(error instanceof ConnectError)) throw error;
+      this.errorSink.reportRuntimeTaskException('auto-connect', error);
+      return;
     }
+    if (accepted) await accept();
   }
 
   private beginStoreFailureCore():

package/src/runtime/locations/creation-operation-id.ts

@@ -1,12 +1,15 @@
+import { UINT64_BYTES } from '@zlink-systems/stream-wire';
+import { OPERATION_IDENTITY_BYTES } from '../foundation/operation-identity';
 import { randomBytes } from 'node:crypto';
 
-export function randomOperationId(entropy: Uint8Array = randomBytes(16)): {
+export function randomOperationId(entropy: Uint8Array = randomBytes(OPERATION_IDENTITY_BYTES)): {
   readonly high: bigint;
   readonly low: bigint;
 } {
-  if (entropy.byteLength !== 16) throw new RangeError('Operation ID entropy must be 16 bytes.');
+  if (entropy.byteLength !== OPERATION_IDENTITY_BYTES)
+    throw new RangeError(`Operation ID entropy must be ${OPERATION_IDENTITY_BYTES} bytes.`);
   const bytes = Buffer.from(entropy);
   const high = bytes.readBigUInt64BE(0);
-  const low = bytes.readBigUInt64BE(8);
+  const low = bytes.readBigUInt64BE(UINT64_BYTES);
   return high === 0n && low === 0n ? { high, low: 1n } : { high, low };
 }

package/src/runtime/locations/domain-store-contract.ts

@@ -128,14 +128,23 @@ export interface ZLinkDomainLocationStore {
   ): Promise<ZLinkCreationTerminalReadResult>;
   reserve(
     request: ZLinkObjectReserveRequest,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    deadlineUnixMs?: bigint
   ): Promise<ZLinkObjectReserveResult>;
-  commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal): Promise<ZLinkObjectCommitResult>;
+  commit(
+    request: ZLinkObjectCommitRequest,
+    signal?: AbortSignal,
+    deadlineUnixMs?: bigint
+  ): Promise<ZLinkObjectCommitResult>;
   completeCreation(
     request: ZLinkObjectCreationCompleteRequest,
     signal?: AbortSignal
   ): Promise<ZLinkObjectCreationCompleteResult>;
-  abort(request: ZLinkObjectAbortRequest, signal?: AbortSignal): Promise<ZLinkObjectAbortResult>;
+  abort(
+    request: ZLinkObjectAbortRequest,
+    signal?: AbortSignal,
+    deadlineUnixMs?: bigint
+  ): Promise<ZLinkObjectAbortResult>;
 
   prepareAggregate(
     request: ZLinkAggregatePrepareRequest,

package/src/runtime/locations/in-memory-authority-store.ts

@@ -1,4 +1,13 @@
+import {
+  AUTHORITY_ENVELOPE_MAX_BYTES,
+  CREATION_INTENT_MAX_BYTES,
+  CREATION_TERMINAL_ENVELOPE_MAX_BYTES
+} from '../../contracts/Configuration/InternalDefaults';
+import { UINT64_MAX } from '@zlink-systems/stream-wire';
+import { ZLINK_MAX_ROUTING_ID_BYTES } from '../../contracts/Common/CoreTypes';
+import { ZLINK_PROVIDER_MAX_PAGE_SIZE } from '../../contracts/Locations/Stores';
 import { randomUUID } from 'node:crypto';
+import { SHA256_DIGEST_BYTES } from '../foundation/actor-join-recovery-codec';
 import type {
   ZLinkAggregateAbortResult,
   ZLinkAggregateCommitResult,
@@ -34,9 +43,9 @@ import { encodeAuthorityKey } from './authority-key-codec';
 import { creationTerminalPreimage } from './opaque-record-key';
 
 const MAX_GENERATION = 0x7fff_ffff_ffff_ffffn;
-const MAX_PAYLOAD_BYTES = 1024 * 1024;
+
 const CREATION_TERMINAL_RETENTION_MS = 5 * 60 * 1000;
-const MAX_U64 = 0xffff_ffff_ffff_ffffn;
+const MAX_U64 = UINT64_MAX;
 
 export interface ZLinkInMemoryAuthorityValidation {
   isTargetLive(
@@ -190,10 +199,22 @@ export class ZLinkInMemoryAuthorityStore {
     if (!this.isOwnerLive(row.snapshot)) {
       return { kind: 'conflict', current: this.read(keyValue) };
     }
+    if (
+      mutation.generationTransition === 'reincarnate' &&
+      (this.objectGeneration >= MAX_GENERATION || this.ownerGeneration >= MAX_GENERATION)
+    ) {
+      return { kind: 'generationExhausted' };
+    }
     const nextVersion = this.tryNextStoreVersion();
     if (nextVersion === undefined) return { kind: 'generationExhausted' };
     row.snapshot = {
       ...row.snapshot,
+      ...(mutation.generationTransition === 'reincarnate'
+        ? {
+            objectGeneration: ++this.objectGeneration,
+            authorityOwnerGeneration: ++this.ownerGeneration
+          }
+        : {}),
       storeVersion: version(nextVersion),
       payload: Buffer.from(mutation.payload)
     };
@@ -208,8 +229,8 @@ export class ZLinkInMemoryAuthorityStore {
     signal?: AbortSignal
   ): Promise<ZLinkAuthorityScanResult> {
     signal?.throwIfAborted();
-    if (!Number.isInteger(limit) || limit < 1 || limit > 1000) {
-      throw new RangeError('Authority scan limit must be in 1..1000.');
+    if (!Number.isInteger(limit) || limit < 1 || limit > ZLINK_PROVIDER_MAX_PAGE_SIZE) {
+      throw new RangeError(`Authority scan limit must be in 1..${ZLINK_PROVIDER_MAX_PAGE_SIZE}.`);
     }
     const decoded =
       cursor === undefined
@@ -814,7 +835,7 @@ function validateAuthorityMutation(mutation: ZLinkAuthorityMutation): void {
   }
   const generationTransition = (mutation as { readonly generationTransition?: unknown })
     .generationTransition;
-  if (generationTransition !== 'preserve') {
+  if (generationTransition !== 'preserve' && generationTransition !== 'reincarnate') {
     throw new TypeError('Authority owner transitions require an aggregate CAS.');
   }
 }
@@ -826,9 +847,9 @@ function validateReserve(request: ZLinkObjectReserveRequest): void {
   validatePayload(request.creatingPayload);
   validateCapacityVector(request.capacity);
   if (
-    request.intent.requestSha256.byteLength !== 32 ||
+    request.intent.requestSha256.byteLength !== SHA256_DIGEST_BYTES ||
     request.intent.requestEncodedSize < 0n ||
-    request.intent.requestEncodedSize > BigInt(MAX_PAYLOAD_BYTES)
+    request.intent.requestEncodedSize > BigInt(CREATION_INTENT_MAX_BYTES)
   ) {
     throw new TypeError('Object creation content receipt is invalid.');
   }
@@ -837,9 +858,13 @@ function validateReserve(request: ZLinkObjectReserveRequest): void {
 function validateCreationOperation(operation: ZLinkCreationOperationIdentity): void {
   const sourceRid = String(operation.sourceNodeRid);
   const sourceRidBytes = Buffer.byteLength(sourceRid, 'utf8');
-  if (sourceRidBytes < 1 || sourceRidBytes > 255 || sourceRid.includes('\0')) {
+  if (
+    sourceRidBytes < 1 ||
+    sourceRidBytes > ZLINK_MAX_ROUTING_ID_BYTES ||
+    sourceRid.includes('\0')
+  ) {
     throw new TypeError(
-      'Creation terminal source node RID must contain 1..255 UTF-8 bytes without NUL.'
+      `Creation terminal source node RID must contain 1..${ZLINK_MAX_ROUTING_ID_BYTES} UTF-8 bytes without NUL.`
     );
   }
   if (
@@ -861,8 +886,10 @@ function validateTerminalForMutation(
 ): ZLinkCreationTerminalRecord | undefined {
   if (publication === undefined) return undefined;
   validateCreationOperation(publication.operation);
-  if (publication.terminalEnvelope.byteLength > MAX_PAYLOAD_BYTES) {
-    throw new RangeError('Creation terminal envelope must not exceed 1 MiB.');
+  if (publication.terminalEnvelope.byteLength > CREATION_TERMINAL_ENVELOPE_MAX_BYTES) {
+    throw new RangeError(
+      `Creation terminal envelope must not exceed ${CREATION_TERMINAL_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`
+    );
   }
   const deadlineMs = publication.operationDeadline.getTime();
   const expiresAtMs = deadlineMs + CREATION_TERMINAL_RETENTION_MS;
@@ -915,8 +942,8 @@ function validateAggregateRequest(request: ZLinkAggregatePrepareRequest): void {
   if (request.aggregateGeneration < 1n || request.participants.length < 1) {
     throw new RangeError('Aggregate generation and participant count are invalid.');
   }
-  if (request.inventoryDigest.byteLength !== 32) {
-    throw new TypeError('Aggregate inventory digest must contain 32 bytes.');
+  if (request.inventoryDigest.byteLength !== SHA256_DIGEST_BYTES) {
+    throw new TypeError(`Aggregate inventory digest must contain ${SHA256_DIGEST_BYTES} bytes.`);
   }
   validateCapacityVector(request.capacity);
   const keys = request.participants.map((participant) => participant.authorityKey.value);
@@ -927,8 +954,10 @@ function validateAggregateRequest(request: ZLinkAggregatePrepareRequest): void {
 }
 
 function validatePayload(payload: Uint8Array): void {
-  if (payload.byteLength > MAX_PAYLOAD_BYTES) {
-    throw new RangeError('Authority payload exceeds 1 MiB.');
+  if (payload.byteLength > AUTHORITY_ENVELOPE_MAX_BYTES) {
+    throw new RangeError(
+      `Authority payload exceeds ${AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`
+    );
   }
 }
 

package/src/runtime/locations/in-memory-location-store.ts

@@ -1,11 +1,33 @@
 import type { RoutingId } from '../../contracts/Common';
+import { ZLINK_MAX_IDENTITY_TEXT_BYTES } from '../../contracts/Common/CoreTypes';
+import {
+  isValidPublicWeight,
+  ZLINK_MAX_PUBLIC_WEIGHT
+} from '../../contracts/Configuration/RegistrationBuilderPolicy';
+import type {
+  ZLinkActorTransferPrepareRequest,
+  ZLinkActorTransferRecord,
+  ZLinkActorTransferState,
+  ZLinkActorTransferWriteResult
+} from '../../contracts/Locations/ActorTransfer';
+import {
+  matchesActorLocation,
+  matchesPeerLocation,
+  matchesRouteLocation,
+  matchesSpotLocation
+} from '../../location-store-integration';
+import { encodeAuthorityKey } from './authority-key-codec';
+import type { ZLinkDomainLocationStore } from './domain-store-contract';
+import { ZLinkInMemoryAuthorityStore } from './in-memory-authority-store';
 import {
-  ZLinkLocationKind,
   ZLinkFrameworkRuntimeState,
+  ZLinkLocationKind,
   ZLinkLocationWriteIntent,
   ZLinkLocationWriteStatus,
   ZLinkObjectRole,
   type ZLinkActorLocation,
+  type ZLinkActorLocationFilter,
+  type ZLinkActorLocationKey,
   type ZLinkAggregateAbortResult,
   type ZLinkAggregateCommitResult,
   type ZLinkAggregateFence,
@@ -18,22 +40,18 @@ import {
   type ZLinkAuthorityScanCursor,
   type ZLinkAuthorityScanResult,
   type ZLinkAuthorityStoreVersion,
-  type ZLinkActorLocationFilter,
-  type ZLinkActorLocationKey,
+  type ZLinkClientServerServerDescriptor,
+  type ZLinkClientServerServerDescriptorKey,
+  type ZLinkCreationOperationIdentity,
+  type ZLinkCreationTerminalReadResult,
+  type ZLinkFanoutPublisherDescriptor,
+  type ZLinkFanoutPublisherDescriptorKey,
   type ZLinkLocationChangeStampScope,
   type ZLinkLocationOwnerToken,
   type ZLinkLocationPage,
   type ZLinkLocationWriteResult,
   type ZLinkMeshNodeDescriptor,
   type ZLinkMeshNodeDescriptorKey,
-  type ZLinkClientServerServerDescriptor,
-  type ZLinkClientServerServerDescriptorKey,
-  type ZLinkFanoutPublisherDescriptor,
-  type ZLinkFanoutPublisherDescriptorKey,
-  type ZLinkOwnerLeaseClaimResult,
-  type ZLinkOwnerLeaseReadResult,
-  type ZLinkOwnerLeaseReleaseResult,
-  type ZLinkOwnerLeaseRenewResult,
   type ZLinkObjectAbortRequest,
   type ZLinkObjectAbortResult,
   type ZLinkObjectCommitRequest,
@@ -42,8 +60,10 @@ import {
   type ZLinkObjectCreationCompleteResult,
   type ZLinkObjectReserveRequest,
   type ZLinkObjectReserveResult,
-  type ZLinkCreationOperationIdentity,
-  type ZLinkCreationTerminalReadResult,
+  type ZLinkOwnerLeaseClaimResult,
+  type ZLinkOwnerLeaseReadResult,
+  type ZLinkOwnerLeaseReleaseResult,
+  type ZLinkOwnerLeaseRenewResult,
   type ZLinkPageRequest,
   type ZLinkPeerLocation,
   type ZLinkPeerLocationFilter,
@@ -55,23 +75,11 @@ import {
   type ZLinkSpotLocationFilter,
   type ZLinkSpotLocationKey
 } from './internal-location-contracts';
-import type {
-  ZLinkActorTransferPrepareRequest,
-  ZLinkActorTransferRecord,
-  ZLinkActorTransferState,
-  ZLinkActorTransferWriteResult
-} from '../../contracts/Locations/ActorTransfer';
 import type { ZLinkFanoutLocationStore } from './internal-store-contracts';
-import type { ZLinkDomainLocationStore } from './domain-store-contract';
-import { ZLinkInMemoryAuthorityStore } from './in-memory-authority-store';
-import { encodeAuthorityKey } from './authority-key-codec';
 import { ZLinkLocationKeyCodec } from './key-codec';
-import {
-  matchesActorLocation,
-  matchesPeerLocation,
-  matchesRouteLocation,
-  matchesSpotLocation
-} from '../../location-store-integration';
+const MAX_LOCATION_GENERATION = 0x7fff_ffff_ffff_ffffn;
+
+const MAX_DESCRIPTOR_OBJECT_CAPABILITIES = 1024;
 
 export class ZLinkInMemoryLocationStore
   implements ZLinkDomainLocationStore, ZLinkFanoutLocationStore
@@ -955,7 +963,7 @@ export class ZLinkInMemoryLocationStore
     if (current !== undefined && current.leaseExpiresAt.getTime() > storeNow.getTime()) {
       return { kind: 'conflict' };
     }
-    if (this.ownerLeaseGeneration >= 0x7fff_ffff_ffff_ffffn) {
+    if (this.ownerLeaseGeneration >= MAX_LOCATION_GENERATION) {
       return { kind: 'generationExhausted' };
     }
     const token = { ownerId, leaseGeneration: ++this.ownerLeaseGeneration };
@@ -1282,12 +1290,14 @@ function validateMeshNodeDescriptor(descriptor: ZLinkMeshNodeDescriptor): void {
   }
   if (descriptor.objectRole === ZLinkObjectRole.Server) {
     if (descriptor.entrySpotId !== undefined && !validDescriptorText(descriptor.entrySpotId)) {
-      throw new TypeError('MeshNode Entry Spot ID must contain 1..255 UTF-8 bytes.');
+      throw new TypeError(
+        `MeshNode Entry Spot ID must contain 1..${ZLINK_MAX_IDENTITY_TEXT_BYTES} UTF-8 bytes.`
+      );
     }
   } else if (descriptor.entrySpotId !== undefined) {
     throw new TypeError('Only Object Server descriptors may publish an Entry Spot ID.');
   }
-  const maxGeneration = 0x7fff_ffff_ffff_ffffn;
+  const maxGeneration = MAX_LOCATION_GENERATION;
   if (
     descriptor.lifecycleGeneration < 1n ||
     descriptor.lifecycleGeneration > maxGeneration ||
@@ -1320,9 +1330,8 @@ function validateMeshNodeDescriptor(descriptor: ZLinkMeshNodeDescriptor): void {
     !Number.isSafeInteger(descriptor.activationConcurrency.limit) ||
     descriptor.activationConcurrency.limit < 1 ||
     descriptor.activationConcurrency.active > descriptor.activationConcurrency.limit ||
-    descriptor.placementWeight < 0 ||
-    descriptor.placementWeight > 10_000 ||
-    descriptor.objectCapabilities.length > 1024 ||
+    !isValidPublicWeight(descriptor.placementWeight) ||
+    descriptor.objectCapabilities.length > MAX_DESCRIPTOR_OBJECT_CAPABILITIES ||
     (descriptor.objectRole !== ZLinkObjectRole.Server && descriptor.objectCapabilities.length !== 0)
   ) {
     throw new RangeError('MeshNode object capacity is invalid.');
@@ -1350,7 +1359,7 @@ function validateMeshNodeDescriptor(descriptor: ZLinkMeshNodeDescriptor): void {
 
 function validDescriptorText(value: string): boolean {
   const size = Buffer.byteLength(value, 'utf8');
-  return size >= 1 && size <= 255 && !value.includes('\0');
+  return size >= 1 && size <= ZLINK_MAX_IDENTITY_TEXT_BYTES && !value.includes('\0');
 }
 
 function meshNodeImmutableFingerprint(descriptor: ZLinkMeshNodeDescriptor): string {
@@ -1436,7 +1445,7 @@ function validateClientServerDescriptor(descriptor: ZLinkClientServerServerDescr
   ) {
     throw new TypeError('ClientServer descriptor identity and endpoint are required.');
   }
-  const maxGeneration = 0x7fff_ffff_ffff_ffffn;
+  const maxGeneration = MAX_LOCATION_GENERATION;
   if (
     descriptor.lifecycleGeneration < 1n ||
     descriptor.lifecycleGeneration > maxGeneration ||
@@ -1447,8 +1456,10 @@ function validateClientServerDescriptor(descriptor: ZLinkClientServerServerDescr
   ) {
     throw new RangeError('ClientServer descriptor generations are invalid.');
   }
-  if (!Number.isInteger(descriptor.weight) || descriptor.weight < 0 || descriptor.weight > 10_000) {
-    throw new RangeError('ClientServer descriptor weight must be an integer in 0..10000.');
+  if (!isValidPublicWeight(descriptor.weight)) {
+    throw new RangeError(
+      `ClientServer descriptor weight must be an integer in 0..${ZLINK_MAX_PUBLIC_WEIGHT}.`
+    );
   }
 }
 
@@ -1483,7 +1494,7 @@ function validateFanoutPublisherDescriptor(descriptor: ZLinkFanoutPublisherDescr
   ) {
     throw new TypeError('Fanout publisher descriptor identity and endpoint are required.');
   }
-  const maxGeneration = 0x7fff_ffff_ffff_ffffn;
+  const maxGeneration = MAX_LOCATION_GENERATION;
   if (
     descriptor.lifecycleGeneration < 1n ||
     descriptor.lifecycleGeneration > maxGeneration ||