@zlink-systems/framework 0.26.0 → 0.28.0

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 ||

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

@@ -9,6 +9,17 @@ import type {
   ZLinkStoreWriteRequest,
   ZLinkStoreWriteResult
 } from '../../contracts';
+import {
+  ZLINK_PROVIDER_MAX_KEY_BYTES,
+  ZLINK_PROVIDER_MAX_ENCODED_PAGE_BYTES,
+  ZLINK_PROVIDER_MAX_PAGE_SIZE,
+  ZLINK_PROVIDER_MAX_SCAN_CURSOR_BYTES,
+  ZLINK_PROVIDER_MAX_VALUE_BYTES,
+  ZLINK_PROVIDER_MAX_VERSION_BYTES,
+  ZLINK_PROVIDER_MAX_WRITE_BYTES,
+  ZLINK_PROVIDER_MAX_WRITE_KEYS
+} from '../../contracts/Locations/Stores';
+export const PROVIDER_STORAGE_NAMESPACE_PREFIX = 'zlink:v11:';
 
 interface StoredValue {
   readonly bytes: Uint8Array;
@@ -59,6 +70,13 @@ export class ZLinkInMemoryProviderLocationStore implements ZLinkLocationStore {
       const current = this.liveValue(condition.key.value, storeNow);
       if (condition.kind === 'missing') {
         if (current !== undefined) return { kind: 'conflict', storeNow };
+      } else if (condition.kind === 'value') {
+        if (
+          current === undefined ||
+          !Buffer.from(current.bytes).equals(Buffer.from(condition.expected))
+        ) {
+          return { kind: 'conflict', storeNow };
+        }
       } else if (current?.version.value !== condition.expected.value) {
         return { kind: 'conflict', storeNow };
       }
@@ -70,7 +88,8 @@ export class ZLinkInMemoryProviderLocationStore implements ZLinkLocationStore {
         this.values.delete(mutation.key.value);
         continue;
       }
-      const retentionMs = requireValue(mutation.bytes, mutation.retentionMs);
+      const retentionMs =
+        mutation.retentionMs === undefined ? undefined : Math.ceil(mutation.retentionMs);
       const version = storeVersion((++this.nextVersion).toString());
       const expiresAt =
         retentionMs === undefined ? undefined : new Date(storeNow.getTime() + retentionMs);
@@ -103,13 +122,26 @@ export class ZLinkInMemoryProviderLocationStore implements ZLinkLocationStore {
       };
       this.scans.set(snapshotId, snapshot);
     } else {
-      [snapshotId, offset] = parseCursor(request.cursor);
+      const cursor = parseCursor(request.cursor);
+      snapshotId = cursor?.[0] ?? '';
+      offset = cursor?.[1] ?? 0;
       snapshot = this.scans.get(snapshotId);
-      if (snapshot === undefined) return { kind: 'expired' };
+      if (snapshot === undefined || offset > snapshot.items.length) return { kind: 'expired' };
     }
 
-    const selected = snapshot.items.slice(offset, offset + request.limit);
-    const nextOffset = offset + selected.length;
+    let nextOffset = offset;
+    let encodedBytes = 0;
+    while (nextOffset < snapshot.items.length && nextOffset - offset < request.limit) {
+      const item = snapshot.items[nextOffset];
+      const itemBytes =
+        Buffer.byteLength(item.key.value, 'utf8') +
+        Buffer.byteLength(item.value.version.value, 'utf8') +
+        item.value.bytes.byteLength;
+      if (encodedBytes + itemBytes > ZLINK_PROVIDER_MAX_ENCODED_PAGE_BYTES) break;
+      encodedBytes += itemBytes;
+      nextOffset += 1;
+    }
+    const selected = snapshot.items.slice(offset, nextOffset);
     const nextCursor =
       nextOffset < snapshot.items.length ? scanCursor(`${snapshotId}:${nextOffset}`) : undefined;
     if (nextCursor === undefined) this.scans.delete(snapshotId);
@@ -153,12 +185,13 @@ function scanCursor(value: string): ZLinkStoreScanCursor {
   return { value } as ZLinkStoreScanCursor;
 }
 
-function parseCursor(cursor: ZLinkStoreScanCursor): [string, number] {
+function parseCursor(cursor: ZLinkStoreScanCursor): [string, number] | undefined {
   const separator = cursor.value.indexOf(':');
   const snapshotId = cursor.value.slice(0, separator);
-  const offset = Number(cursor.value.slice(separator + 1));
-  if (separator < 1 || !Number.isSafeInteger(offset) || offset < 0) {
-    throw new RangeError('Location Store scan cursor is invalid.');
+  const encodedOffset = cursor.value.slice(separator + 1);
+  const offset = Number(encodedOffset);
+  if (separator < 1 || !/^(0|[1-9][0-9]*)$/.test(encodedOffset) || !Number.isSafeInteger(offset)) {
+    return undefined;
   }
   return [snapshotId, offset];
 }
@@ -170,32 +203,72 @@ function requireWriteRequest(request: ZLinkStoreWriteRequest): void {
   if (
     new Set(conditionKeys).size !== conditionKeys.length ||
     new Set(mutationKeys).size !== mutationKeys.length ||
-    keys.length > 2_048
+    keys.length > ZLINK_PROVIDER_MAX_WRITE_KEYS
   ) {
-    throw new RangeError('Location Store write keys must be unique and bounded to 2,048.');
+    throw new RangeError(
+      `Location Store write keys must be unique and bounded to ${ZLINK_PROVIDER_MAX_WRITE_KEYS.toLocaleString('en-US')}.`
+    );
   }
   for (const key of keys) requireKey(key);
-  const encodedSize = request.mutations.reduce(
-    (sum, mutation) => sum + (mutation.kind === 'put' ? mutation.bytes.byteLength : 0),
-    0
-  );
-  if (encodedSize > 4 * 1024 * 1024) {
-    throw new RangeError('Location Store write exceeds 4 MiB.');
+  const encodedSize =
+    request.conditions.reduce((sum, condition) => {
+      const keyBytes = Buffer.byteLength(condition.key.value, 'utf8');
+      if (condition.kind === 'missing') return sum + keyBytes;
+      if (condition.kind === 'value') {
+        requireValue(condition.expected, undefined);
+        return sum + keyBytes + condition.expected.byteLength;
+      }
+      const versionBytes = Buffer.byteLength(condition.expected.value, 'utf8');
+      if (versionBytes < 1 || versionBytes > ZLINK_PROVIDER_MAX_VERSION_BYTES) {
+        throw new RangeError(
+          `Location Store version must contain 1..${ZLINK_PROVIDER_MAX_VERSION_BYTES.toLocaleString('en-US')} UTF-8 bytes.`
+        );
+      }
+      return sum + keyBytes + versionBytes;
+    }, 0) +
+    request.mutations.reduce((sum, mutation) => {
+      const keyBytes = Buffer.byteLength(mutation.key.value, 'utf8');
+      if (mutation.kind !== 'put') return sum + keyBytes;
+      requireValue(mutation.bytes, mutation.retentionMs);
+      return sum + keyBytes + mutation.bytes.byteLength;
+    }, 0);
+  if (encodedSize > ZLINK_PROVIDER_MAX_WRITE_BYTES) {
+    throw new RangeError(
+      `Location Store write exceeds ${ZLINK_PROVIDER_MAX_WRITE_BYTES / (1024 * 1024)} MiB.`
+    );
   }
 }
 
 function requireScanRequest(request: ZLinkStoreScanRequest): void {
-  if (Buffer.byteLength(request.prefix, 'utf8') > 1_024) {
-    throw new RangeError('Location Store scan prefix exceeds 1,024 UTF-8 bytes.');
+  if (request.cursor !== undefined) {
+    const bytes = Buffer.byteLength(request.cursor.value, 'utf8');
+    if (bytes < 1 || bytes > ZLINK_PROVIDER_MAX_SCAN_CURSOR_BYTES) {
+      throw new RangeError(
+        `Location Store cursor must contain 1..${ZLINK_PROVIDER_MAX_SCAN_CURSOR_BYTES.toLocaleString('en-US')} UTF-8 bytes.`
+      );
+    }
   }
-  if (!Number.isSafeInteger(request.limit) || request.limit < 1 || request.limit > 1_000) {
-    throw new RangeError('Location Store scan limit must be in 1..1000.');
+  if (Buffer.byteLength(request.prefix, 'utf8') > ZLINK_PROVIDER_MAX_KEY_BYTES) {
+    throw new RangeError(
+      `Location Store scan prefix exceeds ${ZLINK_PROVIDER_MAX_KEY_BYTES.toLocaleString('en-US')} UTF-8 bytes.`
+    );
+  }
+  if (
+    !Number.isSafeInteger(request.limit) ||
+    request.limit < 1 ||
+    request.limit > ZLINK_PROVIDER_MAX_PAGE_SIZE
+  ) {
+    throw new RangeError(
+      `Location Store scan limit must be in 1..${ZLINK_PROVIDER_MAX_PAGE_SIZE}.`
+    );
   }
 }
 
 function requireValue(bytes: Uint8Array, retentionMs: number | undefined): number | undefined {
-  if (bytes.byteLength > 1024 * 1024) {
-    throw new RangeError('Location Store value exceeds 1 MiB.');
+  if (bytes.byteLength > ZLINK_PROVIDER_MAX_VALUE_BYTES) {
+    throw new RangeError(
+      `Location Store value exceeds ${ZLINK_PROVIDER_MAX_VALUE_BYTES / (1024 * 1024)} MiB.`
+    );
   }
   if (
     retentionMs !== undefined &&
@@ -210,7 +283,9 @@ function requireValue(bytes: Uint8Array, retentionMs: number | undefined): numbe
 
 function requireKey(value: string): void {
   const bytes = Buffer.byteLength(value, 'utf8');
-  if (bytes < 1 || bytes > 1_024) {
-    throw new RangeError('Location Store key must contain 1..1,024 UTF-8 bytes.');
+  if (bytes < 1 || bytes > ZLINK_PROVIDER_MAX_KEY_BYTES) {
+    throw new RangeError(
+      `Location Store key must contain 1..${ZLINK_PROVIDER_MAX_KEY_BYTES.toLocaleString('en-US')} UTF-8 bytes.`
+    );
   }
 }

package/src/runtime/locations/key-codec.ts

@@ -1,3 +1,4 @@
+import { ZLINK_MAX_SPOT_ID_BYTES } from '../../contracts/Common/CoreTypes';
 import type { RoutingId } from '../../contracts/Common';
 import {
   type ZLinkActorLocationKey,
@@ -49,8 +50,8 @@ function encodeSegments(...segments: readonly string[]): string {
 
 function requireSpotId(value: string): string {
   const bytes = Buffer.byteLength(value, 'utf8');
-  if (bytes < 1 || bytes > 255) {
-    throw new TypeError('SpotId must contain 1..255 UTF-8 bytes.');
+  if (bytes < 1 || bytes > ZLINK_MAX_SPOT_ID_BYTES) {
+    throw new TypeError(`SpotId must contain 1..${ZLINK_MAX_SPOT_ID_BYTES} UTF-8 bytes.`);
   }
   return value;
 }

package/src/runtime/locations/lease-tracker.ts

@@ -79,6 +79,10 @@ export class ZLinkOwnerLeaseTracker {
     );
   }
 
+  async isOwnerTokenLive(owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<boolean> {
+    return (await this.remainingOwnerTokenLeaseMs(owner, signal)) > 0;
+  }
+
   async getLiveOwnerSetVersion(signal?: AbortSignal): Promise<number> {
     const owners = await this.lane.run(() => [...this.snapshots.keys()]);
     const refreshed = await Promise.all(owners.map((ownerId) => this.getSnapshot(ownerId, signal)));
@@ -187,17 +191,15 @@ export class ZLinkOwnerLeaseTracker {
 }
 
 export class ZLinkLiveRowFilter {
-  constructor(private readonly leaseTracker: ZLinkOwnerLeaseTracker) {}
-
   async filter<TRow>(
     rows: readonly TRow[],
-    ownerIdOf: (row: TRow) => string,
+    isLive: (row: TRow, signal?: AbortSignal) => Promise<boolean>,
     signal?: AbortSignal,
     include?: (row: TRow) => boolean
   ): Promise<TRow[]> {
     const live: TRow[] = [];
     for (const row of rows) {
-      if ((include === undefined || include(row)) && (await this.isLive(row, ownerIdOf, signal))) {
+      if ((include === undefined || include(row)) && (await isLive(row, signal))) {
         live.push(row);
       }
     }
@@ -206,22 +208,14 @@ export class ZLinkLiveRowFilter {
 
   async resolve<TRow>(
     row: TRow | undefined,
-    ownerIdOf: (row: TRow) => string,
+    isLive: (row: TRow, signal?: AbortSignal) => Promise<boolean>,
     signal?: AbortSignal,
     include?: (row: TRow) => boolean
   ): Promise<TRow | undefined> {
     if (row === undefined || (include !== undefined && !include(row))) {
       return undefined;
     }
-    return (await this.isLive(row, ownerIdOf, signal)) ? row : undefined;
-  }
-
-  private async isLive<TRow>(
-    row: TRow,
-    ownerIdOf: (row: TRow) => string,
-    signal?: AbortSignal
-  ): Promise<boolean> {
-    return await this.leaseTracker.isOwnerLive(ownerIdOf(row), signal);
+    return (await isLive(row, signal)) ? row : undefined;
   }
 }
 

package/src/runtime/locations/lifecycle.ts

@@ -1,33 +1,34 @@
 import type { ActorRef, RoutingId } from '../../contracts/Common';
-import type { ZLinkActorLocation, ZLinkLocationWriteStatus } from './internal-location-contracts';
-import type { ZLinkActorLocationStore, ZLinkSpotLocationStore } from './internal-store-contracts';
 import { ZLinkSpotKind } from '../../contracts/Spots';
 import {
   ZLinkActorLocationClaims,
   type ZLinkActorClaimActivation,
   type ZLinkActorClaimResult
 } from './actor-location-claims';
+import { ZLinkActorSessionRouteClaims } from './actor-session-route-claims';
+import type { ZLinkActorLocation, ZLinkLocationWriteStatus } from './internal-location-contracts';
+import type {
+  ZLinkActorLocationStore,
+  ZLinkAuthorityStore,
+  ZLinkSpotLocationStore
+} from './internal-store-contracts';
+import type { IZLinkLocationLifecycleRuntime, ZLinkOwnershipLostEvent } from './lifecycle-runtime';
+import {
+  type ZLinkInstanceClosingAuthority,
+  type ZLinkTrackedInstanceAuthority,
+  ZLinkSpotLocationClaims
+} from './spot-location-claims';
 export {
   ZLinkActorClaimStatus,
   type ZLinkActorClaimActivation,
   type ZLinkActorClaimResult
 } from './actor-location-claims';
-import { ZLinkActorSessionRouteClaims } from './actor-session-route-claims';
-import { ZLinkSpotLocationClaims } from './spot-location-claims';
-import type {
-  ZLinkInstanceClosingAuthority,
-  ZLinkTrackedInstanceAuthority
-} from './spot-location-claims';
-import type { ZLinkAuthorityStore } from './internal-store-contracts';
-import type { IZLinkLocationLifecycleRuntime, ZLinkOwnershipLostEvent } from './lifecycle-runtime';
 export type { IZLinkLocationLifecycleRuntime, ZLinkOwnershipLostEvent } from './lifecycle-runtime';
 
 export class ZLinkLocationLifecycle {
   private readonly actorClaims: ZLinkActorLocationClaims;
-  private readonly actorCleanupTasks = new Map<string, Promise<void>>();
   private readonly spotClaims: ZLinkSpotLocationClaims;
   private readonly actorSessionRoutes: ZLinkActorSessionRouteClaims;
-  private disposed = false;
   private readonly ownershipLostHandler = (event: ZLinkOwnershipLostEvent) =>
     this.onOwnershipLost(event);
 
@@ -56,7 +57,6 @@ export class ZLinkLocationLifecycle {
   }
 
   dispose(): void {
-    this.disposed = true;
     this.runtime.removeOwnershipLostHandler(this.ownershipLostHandler);
   }
 
@@ -160,18 +160,6 @@ export class ZLinkLocationLifecycle {
     await this.actorClaims.release(actorType, actorId, actorRef);
   }
 
-  releaseActorEventually(actorType: string, actorId: string): Promise<void> {
-    const existing = this.actorCleanupTasks.get(actorId);
-    if (existing !== undefined) {
-      return existing;
-    }
-    const cleanup = this.retryActorRelease(actorType, actorId).finally(() =>
-      this.actorCleanupTasks.delete(actorId)
-    );
-    this.actorCleanupTasks.set(actorId, cleanup);
-    return cleanup;
-  }
-
   ownsActor(actorType: string, actorId: string): boolean {
     return this.actorClaims.owns(actorType, actorId);
   }
@@ -180,20 +168,6 @@ export class ZLinkLocationLifecycle {
     return this.actorClaims.snapshot(actorId);
   }
 
-  private async retryActorRelease(actorType: string, actorId: string): Promise<void> {
-    let retryDelayMs = 50;
-    while (!this.disposed) {
-      try {
-        await this.actorClaims.release(actorType, actorId);
-        return;
-      } catch {
-        await waitForRetry(retryDelayMs);
-        retryDelayMs = Math.min(retryDelayMs * 2, 1_000);
-      }
-    }
-    return;
-  }
-
   async claimSpot(
     meshName: string,
     spotId: RoutingId,
@@ -272,7 +246,3 @@ function inferSpotStore(actorStore: ZLinkActorLocationStore): ZLinkSpotLocationS
   }
   return undefined;
 }
-
-function waitForRetry(delayMs: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, delayMs));
-}