@zlink-systems/framework 0.26.0 → 0.28.0

package/dist/runtime/foundation/service-authority-payload-codec.js

@@ -8,7 +8,15 @@ exports.decodeServiceClosingSpotAuthority = decodeServiceClosingSpotAuthority;
 exports.decodeServiceInstanceAuthorityPayload = decodeServiceInstanceAuthorityPayload;
 exports.rewriteServiceAuthorityOwner = rewriteServiceAuthorityOwner;
 exports.rewriteServiceAuthorityRoute = rewriteServiceAuthorityRoute;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
+const contracts_1 = require("../../contracts");
+const actor_join_recovery_codec_1 = require("./actor-join-recovery-codec");
 const service_relocation_runtime_1 = require("./service-relocation-runtime");
+const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
+const SPOT_AUTHORITY_OBJECT_KIND = 2;
+const USER_SPOT_WIRE_KIND = (0, contracts_1.zlinkSpotKindToWire)(contracts_1.ZLinkSpotKind.User);
+const INSTANCE_SPOT_WIRE_KIND = (0, contracts_1.zlinkSpotKindToWire)(contracts_1.ZLinkSpotKind.Instance);
+const AUTHORITY_TEXT16_MAX_BYTES = 0xffff;
 const AUTHORITY_MAGIC = Buffer.from([0x5a, 0x4c, 0x41, 0x55]);
 const AUTHORITY_FORMAT_VERSION = 1;
 const AUTHORITY_FLAGS = 0;
@@ -171,7 +179,7 @@ function decodeSpotAuthority(payload) {
         const operationKind = body.u8();
         const objectKind = body.u8();
         const object = body.takeReader(body.u16());
-        if (objectKind !== 2)
+        if (objectKind !== SPOT_AUTHORITY_OBJECT_KIND)
             return undefined;
         const spotKind = object.u8();
         const spot = object.takeReader(object.u16());
@@ -181,13 +189,13 @@ function decodeSpotAuthority(payload) {
         let state;
         let stableType;
         let spotId;
-        if (spotKind === 2) {
+        if (spotKind === USER_SPOT_WIRE_KIND) {
             kind = 'user_spot';
             spotId = spot.rid();
             stableType = spot.text8();
             state = spot.u8();
         }
-        else if (spotKind === 3) {
+        else if (spotKind === INSTANCE_SPOT_WIRE_KIND) {
             kind = 'instance_spot';
             state = spot.u8();
             const instance = spot.takeReader(spot.u16());
@@ -279,21 +287,23 @@ function rid(value, name) {
 }
 function text16(value, name) {
     const bytes = Buffer.from(value);
-    if (bytes.byteLength < 1 || bytes.byteLength > 0xffff || bytes.includes(0)) {
-        throw new RangeError(`${name} must contain 1..65535 UTF-8 bytes without NUL.`);
+    if (bytes.byteLength < 1 || bytes.byteLength > AUTHORITY_TEXT16_MAX_BYTES || bytes.includes(0)) {
+        throw new RangeError(`${name} must contain 1..${AUTHORITY_TEXT16_MAX_BYTES} UTF-8 bytes without NUL.`);
     }
     return concat(u16(bytes.byteLength), bytes);
 }
 function sha256(value) {
-    if (value.byteLength !== 32) {
-        throw new RangeError('activationRecovery.sha256 must contain exactly 32 bytes.');
+    if (value.byteLength !== actor_join_recovery_codec_1.SHA256_DIGEST_BYTES) {
+        throw new RangeError(`activationRecovery.sha256 must contain exactly ${actor_join_recovery_codec_1.SHA256_DIGEST_BYTES} bytes.`);
     }
-    return concat(Buffer.of(32), value);
+    return concat(Buffer.of(actor_join_recovery_codec_1.SHA256_DIGEST_BYTES), value);
 }
 function sized8(value, name) {
     const bytes = Buffer.from(value);
-    if (bytes.byteLength < 1 || bytes.byteLength > 255 || bytes.includes(0)) {
-        throw new RangeError(`${name} must contain 1..255 UTF-8 bytes without NUL.`);
+    if (bytes.byteLength < 1 ||
+        bytes.byteLength > service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES ||
+        bytes.includes(0)) {
+        throw new RangeError(`${name} must contain 1..${service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES} UTF-8 bytes without NUL.`);
     }
     return concat(Buffer.of(bytes.byteLength), bytes);
 }
@@ -314,7 +324,7 @@ function boundedU32(value, name) {
     return u32(value);
 }
 function u64(value, name) {
-    if (value <= 0n || value > 0xffffffffffffffffn) {
+    if (value <= 0n || value > stream_wire_1.UINT64_MAX) {
         throw new RangeError(`${name} must be a non-zero u64.`);
     }
     const result = Buffer.alloc(8);
@@ -322,7 +332,7 @@ function u64(value, name) {
     return result;
 }
 function ordinalU64(value, name) {
-    if (value < 0n || value > 0xffffffffffffffffn) {
+    if (value < 0n || value > stream_wire_1.UINT64_MAX) {
         throw new RangeError(`${name} must be a u64.`);
     }
     const result = Buffer.alloc(8);

package/dist/runtime/foundation/service-discovery-registry.d.ts

@@ -23,6 +23,9 @@ export interface SelectedClientServer {
 }
 /** Dedicated discovery state; fanout publishers never reuse RouteMesh peer rows. */
 export declare class ServiceDiscoveryRegistry {
+    private readonly clientServerChanged;
+    onClientServerChanged(listener: (error?: Error) => void): () => void;
+    dispose(error: Error): void;
     private readonly clientServers;
     private readonly fanoutPublishers;
     private readonly clientServerSelections;
@@ -32,6 +35,7 @@ export declare class ServiceDiscoveryRegistry {
     selectClientServer(channelName: string): ClientServerDescriptor | undefined;
     selectClientServerConnection(channelName: string): SelectedClientServer | undefined;
     private selectClientServerConnectionCore;
+    hasReadyClientServer(channelName: string): boolean;
     clientServerDescriptors(channelName: string): readonly ClientServerDescriptor[];
     admitFanoutPublisher(descriptor: FanoutPublisherDescriptor, connectionId: string): boolean;
     removeFanoutPublisher(channelName: string, publisherRoutingId: string, connectionId: string): boolean;

package/dist/runtime/foundation/service-discovery-registry.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceDiscoveryRegistry = void 0;
+const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
+const service_weighted_selection_1 = require("./service-weighted-selection");
 /** Dedicated discovery state; fanout publishers never reuse RouteMesh peer rows. */
 class ServiceDiscoveryRegistry {
+    clientServerChanged = new Set();
+    onClientServerChanged(listener) {
+        this.clientServerChanged.add(listener);
+        return () => {
+            this.clientServerChanged.delete(listener);
+        };
+    }
+    dispose(error) {
+        for (const listener of this.clientServerChanged)
+            listener(error);
+        this.clientServerChanged.clear();
+    }
     clientServers = new Map();
     fanoutPublishers = new Map();
     clientServerSelections = new Map();
@@ -56,6 +70,10 @@ class ServiceDiscoveryRegistry {
         }
         return selection.select();
     }
+    hasReadyClientServer(channelName) {
+        return [...this.clientServers.values()].some(({ descriptor }) => descriptor.channelName === channelName &&
+            (descriptor.state === 'serving' || descriptor.state === 'retiring'));
+    }
     clientServerDescriptors(channelName) {
         return [...this.clientServers.values()]
             .map((value) => value.descriptor)
@@ -94,6 +112,8 @@ class ServiceDiscoveryRegistry {
         if (this.clientServerSelections.has(channelName)) {
             this.clientServerSelections.get(channelName).rebuild();
         }
+        for (const listener of this.clientServerChanged)
+            listener();
     }
     clientServerCandidates(channelName) {
         return [...this.clientServers.values()]
@@ -150,8 +170,8 @@ function validateClientServer(descriptor) {
     requireText(descriptor.securityIdentity, 'securityIdentity');
     requireText(descriptor.advertisedEndpoint, 'advertisedEndpoint');
     validateRevision(descriptor.lifecycleGeneration, descriptor.descriptorRevision);
-    if (!Number.isInteger(descriptor.weight) || descriptor.weight < 0 || descriptor.weight > 10_000) {
-        throw new RangeError('ClientServer weight must be an integer in 0..10000.');
+    if (!(0, RegistrationBuilderPolicy_1.isValidPublicWeight)(descriptor.weight)) {
+        throw new RangeError(`ClientServer weight must be an integer in 0..${RegistrationBuilderPolicy_1.ZLINK_MAX_PUBLIC_WEIGHT}.`);
     }
     if (!Number.isSafeInteger(descriptor.effectiveMaxMessageBytes) ||
         descriptor.effectiveMaxMessageBytes < 1) {
@@ -174,4 +194,3 @@ function requireText(value, field) {
         throw new TypeError(`${field} must be non-empty text without NUL.`);
     }
 }
-const service_weighted_selection_1 = require("./service-weighted-selection");

package/dist/runtime/foundation/service-instance-activation-recovery-codec.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeInstanceActivationRecoveryEnvelope = encodeInstanceActivationRecoveryEnvelope;
 exports.decodeInstanceActivationRecoveryEnvelope = decodeInstanceActivationRecoveryEnvelope;
+const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const service_relocation_runtime_1 = require("./service-relocation-runtime");
 const service_wire_m6a_codec_1 = require("./service-wire-m6a-codec");
 const service_metadata_codec_1 = require("./service-metadata-codec");
@@ -175,8 +177,10 @@ function requireOperation(value) {
 }
 function textBytes(value, name) {
     const bytes = Buffer.from(value, 'utf8');
-    if (bytes.byteLength < 1 || bytes.byteLength > 255 || bytes.includes(0)) {
-        throw new RangeError(`${name} must contain 1..255 UTF-8 bytes without NUL.`);
+    if (bytes.byteLength < 1 ||
+        bytes.byteLength > service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES ||
+        bytes.includes(0)) {
+        throw new RangeError(`${name} must contain 1..${service_wire_binary_primitives_1.SERVICE_WIRE_TEXT8_MAX_BYTES} UTF-8 bytes without NUL.`);
     }
     return bytes;
 }
@@ -189,12 +193,12 @@ function writeText8(target, offset, value) {
     return offset + 1 + value.byteLength;
 }
 function validatePositiveU64(value, name) {
-    if (value <= 0n || value > 0xffffffffffffffffn) {
+    if (value <= 0n || value > stream_wire_1.UINT64_MAX) {
         throw new RangeError(`${name} is out of range.`);
     }
 }
 function validateU64(value, name) {
-    if (value < 0n || value > 0xffffffffffffffffn) {
+    if (value < 0n || value > stream_wire_1.UINT64_MAX) {
         throw new RangeError(`${name} is out of range.`);
     }
 }

package/dist/runtime/foundation/service-liveness-registry.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceLivenessRegistry = exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS = exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS = void 0;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 exports.DEFAULT_SERVICE_PROBE_INTERVAL_MS = 5_000;
 exports.DEFAULT_SERVICE_PEER_TIMEOUT_MS = 15_000;
 /** Uses monotonic milliseconds and never treats application traffic as a probe ACK. */
@@ -101,7 +102,7 @@ class ServiceLivenessRegistry {
     }
     allocateProbeId() {
         const result = this.nextProbeId++;
-        if (this.nextProbeId > 0xffffffffffffffffn)
+        if (this.nextProbeId > stream_wire_1.UINT64_MAX)
             this.nextProbeId = 1n;
         return result;
     }

package/dist/runtime/foundation/service-maintenance-runtime.d.ts

@@ -42,4 +42,3 @@ export declare class ServiceMaintenanceRuntime {
     private publishCore;
     private notify;
 }
-export declare function classifyRelocationRecovery(publishedReference: boolean, payloadPresent: boolean, checksumMatches: boolean, inventoryMatches: boolean): 'resume' | 'orphan' | 'relocationDataLost';

package/dist/runtime/foundation/service-maintenance-runtime.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceMaintenanceRuntime = void 0;
-exports.classifyRelocationRecovery = classifyRelocationRecovery;
 const node_async_hooks_1 = require("node:async_hooks");
 const state_lane_1 = require("../execution/state-lane");
 const detachedStateLaneResource = new node_async_hooks_1.AsyncResource('zlink:service-maintenance-runtime');
@@ -210,8 +209,3 @@ exports.ServiceMaintenanceRuntime = ServiceMaintenanceRuntime;
 function startOutsideStateLane(work) {
     return detachedStateLaneResource.runInAsyncScope(work);
 }
-function classifyRelocationRecovery(publishedReference, payloadPresent, checksumMatches, inventoryMatches) {
-    if (!publishedReference)
-        return payloadPresent ? 'orphan' : 'resume';
-    return payloadPresent && checksumMatches && inventoryMatches ? 'resume' : 'relocationDataLost';
-}

package/dist/runtime/foundation/service-metadata-codec.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeServiceMetadataFrame = encodeServiceMetadataFrame;
 exports.validateServiceMetadataFrame = validateServiceMetadataFrame;
-const MAX_METADATA_BYTES = 1024;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
 function encodeServiceMetadataFrame(entries) {
     if (entries.size > 0xff) {
@@ -19,8 +19,8 @@ function encodeServiceMetadataFrame(entries) {
     return validateServiceMetadataFrame(Buffer.concat(encoded));
 }
 function validateServiceMetadataFrame(frame) {
-    if (frame.byteLength > MAX_METADATA_BYTES) {
-        throw new RangeError('Application metadata frame exceeds 1024 bytes.');
+    if (frame.byteLength > stream_wire_1.ZLINK_STREAM_MAX_METADATA_BYTES) {
+        throw new RangeError(`Application metadata frame exceeds ${stream_wire_1.ZLINK_STREAM_MAX_METADATA_BYTES} bytes.`);
     }
     const bytes = Buffer.from(frame);
     let offset = 0;

package/dist/runtime/foundation/service-relocation-aggregate-committer.d.ts

@@ -20,16 +20,13 @@ export interface ServicePreparedRelocationAggregate {
     readonly fence: ZLinkAggregateFence;
     readonly plan: ServiceRelocationAggregatePlan;
 }
-type AggregateStore = Pick<ZLinkObjectCreationStore, 'prepareAggregate' | 'commitAggregate' | 'abortAggregate'> & Pick<ZLinkAuthorityStore, 'readAuthority'>;
-/** Commits every owner and membership row through one Location Store fence. */
+type AggregateStore = Pick<ZLinkObjectCreationStore, 'prepareAggregate' | 'abortAggregate'> & Pick<ZLinkAuthorityStore, 'readAuthority'>;
+/** Prepares and aborts relocation through one Location Store fence. */
 export declare class ServiceRelocationAggregateCommitter {
     private readonly store;
     constructor(store: AggregateStore);
     prepare(plan: ServiceRelocationAggregatePlan, signal?: AbortSignal): Promise<ServicePreparedRelocationAggregate>;
     private authorityStoreVersionsUnchanged;
-    commit(prepared: ServicePreparedRelocationAggregate, signal?: AbortSignal): Promise<ReadonlyMap<string, ZLinkAuthoritySnapshot>>;
     abort(prepared: ServicePreparedRelocationAggregate, signal?: AbortSignal): Promise<void>;
-    private commitFence;
-    private readCommittedParticipants;
 }
 export {};

package/dist/runtime/foundation/service-relocation-aggregate-committer.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceRelocationAggregateCommitter = void 0;
 const service_relocation_runtime_1 = require("./service-relocation-runtime");
 const MAX_PREPARE_CONFLICT_ATTEMPTS = 8;
-/** Commits every owner and membership row through one Location Store fence. */
+/** Prepares and aborts relocation through one Location Store fence. */
 class ServiceRelocationAggregateCommitter {
     store;
     constructor(store) {
@@ -52,59 +52,12 @@ class ServiceRelocationAggregateCommitter {
         }
         return true;
     }
-    async commit(prepared, signal) {
-        try {
-            await this.commitFence(prepared.fence, signal);
-        }
-        catch (firstError) {
-            // A lost commit response is reconciled by repeating the exact durable fence.
-            try {
-                await this.commitFence(prepared.fence, signal);
-            }
-            catch {
-                throw firstError;
-            }
-        }
-        return await this.readCommittedParticipants(prepared.plan, signal);
-    }
     async abort(prepared, signal) {
         const result = await this.store.abortAggregate(prepared.fence, signal);
         if (result.kind !== 'aborted' && result.kind !== 'alreadyAborted') {
             throw new Error(`Location Store rejected relocation aggregate abort: ${result.kind}.`);
         }
     }
-    async commitFence(fence, signal) {
-        const result = await this.store.commitAggregate(fence, signal);
-        if (result.kind !== 'committed' && result.kind !== 'alreadyCommitted') {
-            throw new Error(`Location Store rejected relocation aggregate commit: ${result.kind}.`);
-        }
-    }
-    async readCommittedParticipants(plan, signal) {
-        const committed = new Map();
-        for (const participant of plan.participants) {
-            const current = await this.store.readAuthority(participant.key, signal);
-            if (current.kind !== 'snapshot' ||
-                current.objectGeneration !== participant.expected.objectGeneration ||
-                current.storeVersion.value === participant.expected.storeVersion.value ||
-                !Buffer.from(current.payload).equals(Buffer.from(participant.authorityPayload))) {
-                throw new Error('Committed relocation aggregate does not match its exact participant plan.');
-            }
-            if (participant.ownerTransition === 'newOwner') {
-                if (current.ownerId !== plan.targetOwner.ownerId ||
-                    current.ownerLeaseGeneration !== plan.targetOwner.leaseGeneration ||
-                    current.authorityOwnerGeneration <= participant.expected.authorityOwnerGeneration) {
-                    throw new Error('Committed relocation participant has a different owner fence.');
-                }
-            }
-            else if (current.ownerId !== participant.expected.ownerId ||
-                current.ownerLeaseGeneration !== participant.expected.ownerLeaseGeneration ||
-                current.authorityOwnerGeneration !== participant.expected.authorityOwnerGeneration) {
-                throw new Error('Preserved relocation participant changed its owner fence.');
-            }
-            committed.set(participant.key.value, current);
-        }
-        return committed;
-    }
 }
 exports.ServiceRelocationAggregateCommitter = ServiceRelocationAggregateCommitter;
 function validateAndEncodeParticipants(plan) {

package/dist/runtime/foundation/service-relocation-object-owner.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServiceRelocationObjectRestoreOwner = exports.ServiceRelocationObjectCaptureOwner = exports.ServiceCapturedObjectRelocation = void 0;
+const DEFAULT_RELOCATION_CALLBACK_CONCURRENCY = 8;
 class ServiceCapturedObjectRelocation {
     envelope;
     units;
@@ -56,7 +57,7 @@ exports.ServiceCapturedObjectRelocation = ServiceCapturedObjectRelocation;
 /** Captures the two valid relocation units: User Spot aggregate or one Actor. */
 class ServiceRelocationObjectCaptureOwner {
     maxConcurrentCallbacks;
-    constructor(maxConcurrentCallbacks = 8) {
+    constructor(maxConcurrentCallbacks = DEFAULT_RELOCATION_CALLBACK_CONCURRENCY) {
         this.maxConcurrentCallbacks = maxConcurrentCallbacks;
         requireCallbackConcurrency(maxConcurrentCallbacks);
     }
@@ -127,7 +128,7 @@ class ServiceRelocationObjectRestoreOwner {
     target;
     authorityKey;
     maxConcurrentCallbacks;
-    constructor(target, authorityKey, maxConcurrentCallbacks = 8) {
+    constructor(target, authorityKey, maxConcurrentCallbacks = DEFAULT_RELOCATION_CALLBACK_CONCURRENCY) {
         this.target = target;
         this.authorityKey = authorityKey;
         this.maxConcurrentCallbacks = maxConcurrentCallbacks;

package/dist/runtime/foundation/service-relocation-runtime.js

@@ -11,9 +11,18 @@ exports.encodeServiceRelocationEnvelope = encodeServiceRelocationEnvelope;
 exports.decodeServiceRelocationEnvelope = decodeServiceRelocationEnvelope;
 exports.inventoryDigest = inventoryDigest;
 exports.crc32c = crc32c;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
+const InternalDefaults_1 = require("../../contracts/Configuration/InternalDefaults");
 const authority_key_codec_1 = require("../locations/authority-key-codec");
+const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
 const service_wire_pilot_codec_generated_1 = require("../protocol/service_wire_pilot_codec.generated");
+const actor_join_recovery_codec_1 = require("./actor-join-recovery-codec");
+const MAX_RELOCATION_GENERATION = 0x7fffffffffffffffn;
+const RELOCATION_PREPARING_PHASE = (0, service_wire_codec_generated_1.enumWireRelocationPhase)('preparing');
+const RELOCATION_ACTIVATING_PHASE = (0, service_wire_codec_generated_1.enumWireRelocationPhase)('activating');
+const RELOCATION_COMPLETED_PHASE = (0, service_wire_codec_generated_1.enumWireRelocationPhase)('completed');
+const RELOCATION_LAST_PHASE = (0, service_wire_codec_generated_1.enumWireRelocationPhase)('aborted');
 /** Deterministic Location authority wrapper for one immutable relocation root. */
 class ServiceRelocationAuthorityPayloadCodec {
     publish(currentPayload, publication) {
@@ -109,7 +118,7 @@ function projectServiceRelocationAuthorityTargetReady(payload, target) {
         coordinatorNodeRid: target.nodeRid,
         coordinatorNodeGeneration: target.nodeGeneration,
         coordinatorExpectedStoreVersion: target.coordinatorExpectedStoreVersion,
-        phase: 5,
+        phase: RELOCATION_ACTIVATING_PHASE,
         sourceCleanupState: 0
     });
     return replaceCanonicalRelocationSlot(layout, slot);
@@ -150,7 +159,7 @@ function decodeCanonicalAuthorityPublication(payload) {
 function decodeCanonicalAuthorityLayout(payload) {
     try {
         const bytes = Buffer.from(payload);
-        if (bytes.byteLength < 20 || bytes.byteLength > 1024 * 1024)
+        if (bytes.byteLength < 20 || bytes.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES)
             return undefined;
         const reader = new CanonicalReader(bytes);
         reader.expect(Buffer.from('ZLAU'));
@@ -223,21 +232,21 @@ function decodeCanonicalRelocationSlot(payload, rootAggregateGeneration) {
         const sourceCleanupState = reader.u8();
         if (!reader.done ||
             aggregateGeneration > 0x7ffffffffffffffen ||
-            (aggregateGeneration === 0n && phase !== 1) ||
+            (aggregateGeneration === 0n && phase !== RELOCATION_PREPARING_PHASE) ||
             (rootAggregateGeneration !== undefined && aggregateGeneration !== rootAggregateGeneration) ||
-            targetAttemptGeneration > 0x7fffffffffffffffn ||
+            targetAttemptGeneration > MAX_RELOCATION_GENERATION ||
             sourceNodeGeneration === 0n ||
-            sourceNodeGeneration > 0x7fffffffffffffffn ||
+            sourceNodeGeneration > MAX_RELOCATION_GENERATION ||
             sourceOwnerLeaseGeneration === 0n ||
-            sourceOwnerLeaseGeneration > 0x7fffffffffffffffn ||
-            targetNodeGeneration > 0x7fffffffffffffffn ||
-            targetOwnerLeaseGeneration > 0x7fffffffffffffffn ||
+            sourceOwnerLeaseGeneration > MAX_RELOCATION_GENERATION ||
+            targetNodeGeneration > MAX_RELOCATION_GENERATION ||
+            targetOwnerLeaseGeneration > MAX_RELOCATION_GENERATION ||
             coordinatorLeaseGeneration === 0n ||
-            coordinatorLeaseGeneration > 0x7fffffffffffffffn ||
+            coordinatorLeaseGeneration > MAX_RELOCATION_GENERATION ||
             coordinatorNodeGeneration === 0n ||
-            coordinatorNodeGeneration > 0x7fffffffffffffffn ||
-            phase < 1 ||
-            phase > 9 ||
+            coordinatorNodeGeneration > MAX_RELOCATION_GENERATION ||
+            phase < RELOCATION_PREPARING_PHASE ||
+            phase > RELOCATION_LAST_PHASE ||
             applicationVersion < 0n ||
             sourceCleanupState > 2)
             return undefined;
@@ -276,10 +285,10 @@ function encodeCanonicalRelocationSlot(value) {
     if (aggregateGeneration > 0x7ffffffffffffffen) {
         throw new TypeError('Aggregate generation exceeds the issued range.');
     }
-    if (aggregateGeneration === 0n && value.phase !== 1) {
+    if (aggregateGeneration === 0n && value.phase !== RELOCATION_PREPARING_PHASE) {
         throw new TypeError('Zero aggregate generation is only valid while preparing.');
     }
-    if (targetAttemptGeneration > 0x7fffffffffffffffn) {
+    if (targetAttemptGeneration > MAX_RELOCATION_GENERATION) {
         throw new TypeError('Target attempt generation exceeds the ordinal range.');
     }
     const sourceNodeGeneration = canonicalNonZeroOrdinal(value.sourceNodeGeneration, 'source node generation');
@@ -288,7 +297,9 @@ function encodeCanonicalRelocationSlot(value) {
     const targetOwnerLeaseGeneration = canonicalOrdinal(value.targetOwnerLeaseGeneration, 'target owner lease generation');
     const coordinatorLeaseGeneration = canonicalNonZeroOrdinal(value.coordinatorLeaseGeneration, 'coordinator lease generation');
     const coordinatorNodeGeneration = canonicalNonZeroOrdinal(value.coordinatorNodeGeneration, 'coordinator node generation');
-    if (!Number.isInteger(value.phase) || value.phase < 1 || value.phase > 9) {
+    if (!Number.isInteger(value.phase) ||
+        value.phase < RELOCATION_PREPARING_PHASE ||
+        value.phase > RELOCATION_LAST_PHASE) {
         throw new TypeError('Canonical relocation phase is invalid.');
     }
     if (!Number.isInteger(value.sourceCleanupState) ||
@@ -348,7 +359,7 @@ function encodeCanonicalRelocationPublicationSlot(layout, publication) {
         coordinatorNodeRid: publication.coordinatorNodeRid ?? nodeRid,
         coordinatorNodeGeneration: publication.coordinatorNodeGeneration ?? layout.nodeGeneration,
         coordinatorExpectedStoreVersion: publication.coordinatorExpectedStoreVersion ?? '',
-        phase: publication.canonicalPhase ?? 8,
+        phase: publication.canonicalPhase ?? RELOCATION_COMPLETED_PHASE,
         applicationVersion,
         sourceCleanupState: publication.canonicalSourceCleanupState ?? 0
     });
@@ -370,8 +381,8 @@ function replaceCanonicalRelocationSlot(layout, slot) {
         body
     ]);
     const result = Buffer.concat([envelope, canonicalU32(crc32c(envelope))]);
-    if (result.byteLength > 1024 * 1024) {
-        throw new TypeError('Canonical authority payload exceeds 1 MiB.');
+    if (result.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+        throw new TypeError(`Canonical authority payload exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
     return result;
 }
@@ -721,8 +732,8 @@ function encodeAuthorityEnvelope(base, publication) {
     }
     const aggregateGeneration = positiveBigInt(publication.aggregateGeneration, 'aggregate generation');
     const targetOwnerLeaseGeneration = positiveBigInt(publication.targetOwnerLeaseGeneration, 'target owner lease generation');
-    if (aggregateGeneration > 0x7fffffffffffffffn ||
-        targetOwnerLeaseGeneration > 0x7fffffffffffffffn) {
+    if (aggregateGeneration > MAX_RELOCATION_GENERATION ||
+        targetOwnerLeaseGeneration > MAX_RELOCATION_GENERATION) {
         throw new TypeError('Relocation publication generations must fit signed 64-bit storage.');
     }
     const payload = Buffer.concat([
@@ -738,8 +749,8 @@ function encodeAuthorityEnvelope(base, publication) {
         i64le(targetOwnerLeaseGeneration),
         bytes32le(base)
     ]);
-    if (payload.byteLength > 1024 * 1024) {
-        throw new TypeError('Location authority relocation payload exceeds 1 MiB.');
+    if (payload.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+        throw new TypeError(`Location authority relocation payload exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
     return payload;
 }
@@ -759,8 +770,8 @@ function decodeAuthorityEnvelope(payload) {
         const base = reader.bytes32();
         if (!reader.done ||
             aggregateGeneration === 0n ||
-            aggregateGeneration > 0x7fffffffffffffffn ||
-            inventoryDigestBytes.byteLength !== 32 ||
+            aggregateGeneration > MAX_RELOCATION_GENERATION ||
+            inventoryDigestBytes.byteLength !== actor_join_recovery_codec_1.SHA256_DIGEST_BYTES ||
             targetOwnerLeaseGeneration <= 0n) {
             return undefined;
         }
@@ -852,8 +863,8 @@ function text16le(value) {
 }
 function bytes32le(value) {
     const bytes = Buffer.from(value);
-    if (bytes.byteLength > 1024 * 1024) {
-        throw new TypeError('Relocation byte field exceeds 1 MiB.');
+    if (bytes.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+        throw new TypeError(`Relocation byte field exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
     const length = Buffer.alloc(4);
     length.writeInt32LE(bytes.byteLength);
@@ -1001,7 +1012,7 @@ function canonicalU32(value) {
     return result;
 }
 function canonicalU64(value) {
-    if (value < 0n || value > 0xffffffffffffffffn) {
+    if (value < 0n || value > stream_wire_1.UINT64_MAX) {
         throw new TypeError('Canonical authority u64 is invalid.');
     }
     const result = Buffer.alloc(8);
@@ -1010,7 +1021,7 @@ function canonicalU64(value) {
 }
 function canonicalOrdinal(value, name) {
     const ordinal = nonNegativeBigInt(value, name);
-    if (ordinal > 0x7fffffffffffffffn) {
+    if (ordinal > MAX_RELOCATION_GENERATION) {
         throw new TypeError(`${name} exceeds the ordinal range.`);
     }
     return ordinal;
@@ -1022,7 +1033,7 @@ function canonicalNonZeroOrdinal(value, name) {
     return ordinal;
 }
 function canonicalI64(value) {
-    if (value < 0n || value > 0x7fffffffffffffffn) {
+    if (value < 0n || value > MAX_RELOCATION_GENERATION) {
         throw new TypeError('Canonical authority i64 is invalid.');
     }
     const result = Buffer.alloc(8);
@@ -1034,8 +1045,8 @@ class DotnetBinaryReader {
     offset = 0;
     constructor(payload) {
         this.bytes = Buffer.from(payload);
-        if (this.bytes.byteLength > 1024 * 1024) {
-            throw new TypeError('Location authority relocation payload exceeds 1 MiB.');
+        if (this.bytes.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+            throw new TypeError(`Location authority relocation payload exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
         }
     }
     get done() {
@@ -1066,7 +1077,7 @@ class DotnetBinaryReader {
     }
     bytes32() {
         const length = this.take(4).readInt32LE(0);
-        if (length < 0 || length > 1024 * 1024) {
+        if (length < 0 || length > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
             throw new TypeError('Location authority relocation byte field is invalid.');
         }
         return Buffer.from(this.take(length));