@zlink-systems/framework 0.26.0 → 0.27.0

package/dist/runtime/locations/auto-connect-reconciler.d.ts

@@ -1,6 +1,7 @@
 import { type ZLinkLocationOptionOverrides } from '../../contracts/Locations/Options';
 import type { RoutingId } from '../../contracts/Common';
 import { type ZLinkPeerLocationResolver, type ZLinkPeerLocation } from './internal-location-contracts';
+import type { ZLinkDispatchErrorSink } from '../diagnostics/dispatch-error-port';
 import type { IZLinkAutoConnectExecutor, IZLinkAutoConnectPeerPublisher, ZLinkAutoConnectEventSink, ZLinkAutoConnectLocal, ZLinkAutoConnectTarget } from './auto-connect-types';
 export interface ZLinkAutoConnectReconcilerOptions {
     readonly local: ZLinkAutoConnectLocal;
@@ -12,6 +13,7 @@ export interface ZLinkAutoConnectReconcilerOptions {
     readonly events?: ZLinkAutoConnectEventSink;
     readonly options?: ZLinkLocationOptionOverrides;
     readonly monotonicNowMs?: () => number;
+    readonly errorSink: ZLinkDispatchErrorSink;
 }
 export declare class ZLinkAutoConnectReconciler {
     private readonly lane;
@@ -24,6 +26,7 @@ export declare class ZLinkAutoConnectReconciler {
     private readonly events?;
     private readonly options;
     private readonly monotonicNowMs;
+    private readonly errorSink;
     private readonly active;
     private readonly pendingDisconnects;
     private readonly failedEndpoints;
@@ -50,6 +53,7 @@ export declare class ZLinkAutoConnectReconciler {
     private completePublishClaimCore;
     private preparePublishRenewalCore;
     private recordStoreFailure;
+    private connectTarget;
     private beginStoreFailureCore;
     private completeStoreFailureConnectCore;
     private recordDisconnectedEndpoint;

package/dist/runtime/locations/auto-connect-reconciler.js

@@ -7,6 +7,7 @@ const key_codec_1 = require("./key-codec");
 const EndpointNotation_1 = require("../../contracts/Configuration/EndpointNotation");
 const auto_connect_planner_1 = require("./auto-connect-planner");
 const state_lane_1 = require("../execution/state-lane");
+const zlink_1 = require("@zlink-systems/zlink");
 const encodeRoutingIdHex = key_codec_1.ZLinkLocationKeyCodec.encodeRoutingIdHex;
 class ZLinkAutoConnectReconciler {
     lane = new state_lane_1.ZLinkStateLane();
@@ -19,6 +20,7 @@ class ZLinkAutoConnectReconciler {
     events;
     options;
     monotonicNowMs;
+    errorSink;
     active = new Map();
     pendingDisconnects = new Map();
     failedEndpoints = new Set();
@@ -45,6 +47,7 @@ class ZLinkAutoConnectReconciler {
         this.events = options.events;
         this.options = { ...Options_1.zlinkRuntimeDefaultLocationOptions, ...options.options };
         this.monotonicNowMs = options.monotonicNowMs ?? (() => performance.now());
+        this.errorSink = options.errorSink;
         this.executor.onDisconnected?.((endpoint) => this.recordDisconnectedEndpoint(endpoint));
     }
     get storeFailed() {
@@ -116,13 +119,6 @@ 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;
             });
         }
@@ -133,7 +129,6 @@ class ZLinkAutoConnectReconciler {
                 .map((nodeRid) => encodeRoutingIdHex(nodeRid)));
         });
         const candidates = auto_connect_planner_1.ZLinkAutoConnectPlanner.computeCandidates(this.local, rows);
-        const nowMs = this.monotonicNowMs();
         this.executor.expectPeers?.([...candidates.values()]);
         this.executor.replaceNotRequired?.(auto_connect_planner_1.ZLinkAutoConnectPlanner.computeNotRequired(this.local, rows));
         const desired = new Map(auto_connect_planner_1.ZLinkAutoConnectPlanner.computeDesired(this.local, rows));
@@ -152,6 +147,19 @@ class ZLinkAutoConnectReconciler {
             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);
         });
@@ -178,14 +186,13 @@ 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;
             }
             if (current.endpoint !== target.endpoint || current.ownerId !== target.ownerId) {
@@ -203,25 +210,16 @@ 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) {
             if (!desired.has(key)) {
@@ -330,10 +328,24 @@ class ZLinkAutoConnectReconciler {
         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));
-            }
+            });
+        }
+    }
+    async connectTarget(target, accept) {
+        let accepted;
+        try {
+            accepted = await this.executor.connect(target);
+        }
+        catch (error) {
+            if (!(error instanceof zlink_1.ConnectError))
+                throw error;
+            this.errorSink.reportRuntimeTaskException('auto-connect', error);
+            return;
         }
+        if (accepted)
+            await accept();
     }
     beginStoreFailureCore() {
         const nowMs = this.monotonicNowMs();

package/dist/runtime/locations/creation-operation-id.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomOperationId = randomOperationId;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
+const operation_identity_1 = require("../foundation/operation-identity");
 const node_crypto_1 = require("node:crypto");
-function randomOperationId(entropy = (0, node_crypto_1.randomBytes)(16)) {
-    if (entropy.byteLength !== 16)
-        throw new RangeError('Operation ID entropy must be 16 bytes.');
+function randomOperationId(entropy = (0, node_crypto_1.randomBytes)(operation_identity_1.OPERATION_IDENTITY_BYTES)) {
+    if (entropy.byteLength !== operation_identity_1.OPERATION_IDENTITY_BYTES)
+        throw new RangeError(`Operation ID entropy must be ${operation_identity_1.OPERATION_IDENTITY_BYTES} bytes.`);
     const bytes = Buffer.from(entropy);
     const high = bytes.readBigUInt64BE(0);
-    const low = bytes.readBigUInt64BE(8);
+    const low = bytes.readBigUInt64BE(stream_wire_1.UINT64_BYTES);
     return high === 0n && low === 0n ? { high, low: 1n } : { high, low };
 }

package/dist/runtime/locations/domain-store-contract.d.ts

@@ -22,10 +22,10 @@ export interface ZLinkDomainLocationStore {
     compareExchangeAuthority(key: ZLinkAuthorityKey, expectedStoreVersion: ZLinkAuthorityStoreVersion, mutation: ZLinkAuthorityMutation, signal?: AbortSignal): Promise<ZLinkAuthorityCompareExchangeResult>;
     listAuthorities(prefix: string, cursor: ZLinkAuthorityScanCursor | undefined, limit: number, signal?: AbortSignal): Promise<ZLinkAuthorityScanResult>;
     readCreationTerminal(operation: ZLinkCreationOperationIdentity, signal?: AbortSignal): Promise<ZLinkCreationTerminalReadResult>;
-    reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal): Promise<ZLinkObjectReserveResult>;
-    commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal): Promise<ZLinkObjectCommitResult>;
+    reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectReserveResult>;
+    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, signal?: AbortSignal): Promise<ZLinkAggregatePrepareResult>;
     commitAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateCommitResult>;
     abortAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateAbortResult>;

package/dist/runtime/locations/in-memory-authority-store.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkInMemoryAuthorityStore = void 0;
+const InternalDefaults_1 = require("../../contracts/Configuration/InternalDefaults");
+const stream_wire_1 = require("@zlink-systems/stream-wire");
+const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
+const Stores_1 = require("../../contracts/Locations/Stores");
 const node_crypto_1 = require("node:crypto");
+const actor_join_recovery_codec_1 = require("../foundation/actor-join-recovery-codec");
 const authority_key_codec_1 = require("./authority-key-codec");
 const opaque_record_key_1 = require("./opaque-record-key");
 const MAX_GENERATION = 0x7fffffffffffffffn;
-const MAX_PAYLOAD_BYTES = 1024 * 1024;
 const CREATION_TERMINAL_RETENTION_MS = 5 * 60 * 1000;
-const MAX_U64 = 0xffffffffffffffffn;
+const MAX_U64 = stream_wire_1.UINT64_MAX;
 /**
  * In-memory reference provider for the provider-owned authority state machine.
  * Opaque payload bytes are copied but never parsed.
@@ -101,11 +105,21 @@ 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)
         };
@@ -114,8 +128,8 @@ class ZLinkInMemoryAuthorityStore {
     }
     async listAuthorities(prefix, cursor, limit, signal) {
         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 > Stores_1.ZLINK_PROVIDER_MAX_PAGE_SIZE) {
+            throw new RangeError(`Authority scan limit must be in 1..${Stores_1.ZLINK_PROVIDER_MAX_PAGE_SIZE}.`);
         }
         const decoded = cursor === undefined
             ? { revision: this.scanRevision, offset: 0, prefix }
@@ -611,7 +625,7 @@ function validateAuthorityMutation(mutation) {
     }
     const generationTransition = mutation
         .generationTransition;
-    if (generationTransition !== 'preserve') {
+    if (generationTransition !== 'preserve' && generationTransition !== 'reincarnate') {
         throw new TypeError('Authority owner transitions require an aggregate CAS.');
     }
 }
@@ -621,17 +635,19 @@ function validateReserve(request) {
     requireText(request.intent.requestContentReference, 'creation content reference');
     validatePayload(request.creatingPayload);
     validateCapacityVector(request.capacity);
-    if (request.intent.requestSha256.byteLength !== 32 ||
+    if (request.intent.requestSha256.byteLength !== actor_join_recovery_codec_1.SHA256_DIGEST_BYTES ||
         request.intent.requestEncodedSize < 0n ||
-        request.intent.requestEncodedSize > BigInt(MAX_PAYLOAD_BYTES)) {
+        request.intent.requestEncodedSize > BigInt(InternalDefaults_1.CREATION_INTENT_MAX_BYTES)) {
         throw new TypeError('Object creation content receipt is invalid.');
     }
 }
 function validateCreationOperation(operation) {
     const sourceRid = String(operation.sourceNodeRid);
     const sourceRidBytes = Buffer.byteLength(sourceRid, 'utf8');
-    if (sourceRidBytes < 1 || sourceRidBytes > 255 || sourceRid.includes('\0')) {
-        throw new TypeError('Creation terminal source node RID must contain 1..255 UTF-8 bytes without NUL.');
+    if (sourceRidBytes < 1 ||
+        sourceRidBytes > CoreTypes_1.ZLINK_MAX_ROUTING_ID_BYTES ||
+        sourceRid.includes('\0')) {
+        throw new TypeError(`Creation terminal source node RID must contain 1..${CoreTypes_1.ZLINK_MAX_ROUTING_ID_BYTES} UTF-8 bytes without NUL.`);
     }
     if (operation.sourceNodeGeneration < 1n ||
         operation.sourceNodeGeneration > MAX_U64 ||
@@ -647,8 +663,8 @@ function validateTerminalForMutation(publication, storeNow) {
     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 > InternalDefaults_1.CREATION_TERMINAL_ENVELOPE_MAX_BYTES) {
+        throw new RangeError(`Creation terminal envelope must not exceed ${InternalDefaults_1.CREATION_TERMINAL_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
     const deadlineMs = publication.operationDeadline.getTime();
     const expiresAtMs = deadlineMs + CREATION_TERMINAL_RETENTION_MS;
@@ -691,8 +707,8 @@ function validateAggregateRequest(request) {
     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 !== actor_join_recovery_codec_1.SHA256_DIGEST_BYTES) {
+        throw new TypeError(`Aggregate inventory digest must contain ${actor_join_recovery_codec_1.SHA256_DIGEST_BYTES} bytes.`);
     }
     validateCapacityVector(request.capacity);
     const keys = request.participants.map((participant) => participant.authorityKey.value);
@@ -702,8 +718,8 @@ function validateAggregateRequest(request) {
     }
 }
 function validatePayload(payload) {
-    if (payload.byteLength > MAX_PAYLOAD_BYTES) {
-        throw new RangeError('Authority payload exceeds 1 MiB.');
+    if (payload.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+        throw new RangeError(`Authority payload exceeds ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
 }
 function validateCapacityVector(value) {

package/dist/runtime/locations/in-memory-location-store.d.ts

@@ -1,7 +1,7 @@
-import { ZLinkLocationWriteIntent, ZLinkLocationWriteStatus, type ZLinkActorLocation, type ZLinkAggregateAbortResult, type ZLinkAggregateCommitResult, type ZLinkAggregateFence, type ZLinkAggregatePrepareRequest, type ZLinkAggregatePrepareResult, type ZLinkAuthorityCompareExchangeResult, type ZLinkAuthorityKey, type ZLinkAuthorityMutation, type ZLinkAuthorityReadResult, type ZLinkAuthorityScanCursor, type ZLinkAuthorityScanResult, type ZLinkAuthorityStoreVersion, type ZLinkActorLocationFilter, type ZLinkActorLocationKey, 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, type ZLinkObjectCommitResult, type ZLinkObjectCreationCompleteRequest, type ZLinkObjectCreationCompleteResult, type ZLinkObjectReserveRequest, type ZLinkObjectReserveResult, type ZLinkCreationOperationIdentity, type ZLinkCreationTerminalReadResult, type ZLinkPageRequest, type ZLinkPeerLocation, type ZLinkPeerLocationFilter, type ZLinkPeerLocationKey, type ZLinkRouteLocation, type ZLinkRouteLocationFilter, type ZLinkRouteLocationKey, type ZLinkSpotLocation, type ZLinkSpotLocationFilter, type ZLinkSpotLocationKey } from './internal-location-contracts';
 import type { ZLinkActorTransferPrepareRequest, ZLinkActorTransferRecord, ZLinkActorTransferWriteResult } from '../../contracts/Locations/ActorTransfer';
-import type { ZLinkFanoutLocationStore } from './internal-store-contracts';
 import type { ZLinkDomainLocationStore } from './domain-store-contract';
+import { ZLinkLocationWriteIntent, ZLinkLocationWriteStatus, type ZLinkActorLocation, type ZLinkActorLocationFilter, type ZLinkActorLocationKey, type ZLinkAggregateAbortResult, type ZLinkAggregateCommitResult, type ZLinkAggregateFence, type ZLinkAggregatePrepareRequest, type ZLinkAggregatePrepareResult, type ZLinkAuthorityCompareExchangeResult, type ZLinkAuthorityKey, type ZLinkAuthorityMutation, type ZLinkAuthorityReadResult, type ZLinkAuthorityScanCursor, type ZLinkAuthorityScanResult, type ZLinkAuthorityStoreVersion, 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 ZLinkObjectAbortRequest, type ZLinkObjectAbortResult, type ZLinkObjectCommitRequest, type ZLinkObjectCommitResult, type ZLinkObjectCreationCompleteRequest, type ZLinkObjectCreationCompleteResult, type ZLinkObjectReserveRequest, type ZLinkObjectReserveResult, type ZLinkOwnerLeaseClaimResult, type ZLinkOwnerLeaseReadResult, type ZLinkOwnerLeaseReleaseResult, type ZLinkOwnerLeaseRenewResult, type ZLinkPageRequest, type ZLinkPeerLocation, type ZLinkPeerLocationFilter, type ZLinkPeerLocationKey, type ZLinkRouteLocation, type ZLinkRouteLocationFilter, type ZLinkRouteLocationKey, type ZLinkSpotLocation, type ZLinkSpotLocationFilter, type ZLinkSpotLocationKey } from './internal-location-contracts';
+import type { ZLinkFanoutLocationStore } from './internal-store-contracts';
 export declare class ZLinkInMemoryLocationStore implements ZLinkDomainLocationStore, ZLinkFanoutLocationStore {
     private readonly now;
     private readonly leases;

package/dist/runtime/locations/in-memory-location-store.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkInMemoryLocationStore = void 0;
-const internal_location_contracts_1 = require("./internal-location-contracts");
-const in_memory_authority_store_1 = require("./in-memory-authority-store");
+const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
+const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
+const location_store_integration_1 = require("../../location-store-integration");
 const authority_key_codec_1 = require("./authority-key-codec");
+const in_memory_authority_store_1 = require("./in-memory-authority-store");
+const internal_location_contracts_1 = require("./internal-location-contracts");
 const key_codec_1 = require("./key-codec");
-const location_store_integration_1 = require("../../location-store-integration");
+const MAX_LOCATION_GENERATION = 0x7fffffffffffffffn;
+const MAX_DESCRIPTOR_OBJECT_CAPABILITIES = 1024;
 class ZLinkInMemoryLocationStore {
     now;
     leases = new Map();
@@ -526,7 +530,7 @@ class ZLinkInMemoryLocationStore {
         if (current !== undefined && current.leaseExpiresAt.getTime() > storeNow.getTime()) {
             return { kind: 'conflict' };
         }
-        if (this.ownerLeaseGeneration >= 0x7fffffffffffffffn) {
+        if (this.ownerLeaseGeneration >= MAX_LOCATION_GENERATION) {
             return { kind: 'generationExhausted' };
         }
         const token = { ownerId, leaseGeneration: ++this.ownerLeaseGeneration };
@@ -743,13 +747,13 @@ function validateMeshNodeDescriptor(descriptor) {
     }
     if (descriptor.objectRole === internal_location_contracts_1.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..${CoreTypes_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 = 0x7fffffffffffffffn;
+    const maxGeneration = MAX_LOCATION_GENERATION;
     if (descriptor.lifecycleGeneration < 1n ||
         descriptor.lifecycleGeneration > maxGeneration ||
         descriptor.descriptorRevision < 1n ||
@@ -777,9 +781,8 @@ function validateMeshNodeDescriptor(descriptor) {
         !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 ||
+        !(0, RegistrationBuilderPolicy_1.isValidPublicWeight)(descriptor.placementWeight) ||
+        descriptor.objectCapabilities.length > MAX_DESCRIPTOR_OBJECT_CAPABILITIES ||
         (descriptor.objectRole !== internal_location_contracts_1.ZLinkObjectRole.Server && descriptor.objectCapabilities.length !== 0)) {
         throw new RangeError('MeshNode object capacity is invalid.');
     }
@@ -804,7 +807,7 @@ function validateMeshNodeDescriptor(descriptor) {
 }
 function validDescriptorText(value) {
     const size = Buffer.byteLength(value, 'utf8');
-    return size >= 1 && size <= 255 && !value.includes('\0');
+    return size >= 1 && size <= CoreTypes_1.ZLINK_MAX_IDENTITY_TEXT_BYTES && !value.includes('\0');
 }
 function meshNodeImmutableFingerprint(descriptor) {
     const capabilities = [...descriptor.objectCapabilities].sort((left, right) => {
@@ -867,7 +870,7 @@ function validateClientServerDescriptor(descriptor) {
         !validDescriptorText(descriptor.ownerId)) {
         throw new TypeError('ClientServer descriptor identity and endpoint are required.');
     }
-    const maxGeneration = 0x7fffffffffffffffn;
+    const maxGeneration = MAX_LOCATION_GENERATION;
     if (descriptor.lifecycleGeneration < 1n ||
         descriptor.lifecycleGeneration > maxGeneration ||
         descriptor.descriptorRevision < 1n ||
@@ -876,8 +879,8 @@ function validateClientServerDescriptor(descriptor) {
         descriptor.leaseGeneration > maxGeneration) {
         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 (!(0, RegistrationBuilderPolicy_1.isValidPublicWeight)(descriptor.weight)) {
+        throw new RangeError(`ClientServer descriptor weight must be an integer in 0..${RegistrationBuilderPolicy_1.ZLINK_MAX_PUBLIC_WEIGHT}.`);
     }
 }
 function clientServerImmutableFingerprint(descriptor) {
@@ -907,7 +910,7 @@ function validateFanoutPublisherDescriptor(descriptor) {
         !validDescriptorText(descriptor.ownerId)) {
         throw new TypeError('Fanout publisher descriptor identity and endpoint are required.');
     }
-    const maxGeneration = 0x7fffffffffffffffn;
+    const maxGeneration = MAX_LOCATION_GENERATION;
     if (descriptor.lifecycleGeneration < 1n ||
         descriptor.lifecycleGeneration > maxGeneration ||
         descriptor.descriptorRevision < 1n ||

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

@@ -1,4 +1,5 @@
 import type { ZLinkLocationStore, ZLinkStoreKey, ZLinkStoreReadResult, ZLinkStoreScanRequest, ZLinkStoreScanResult, ZLinkStoreVersion, ZLinkStoreWriteRequest, ZLinkStoreWriteResult } from '../../contracts';
+export declare const PROVIDER_STORAGE_NAMESPACE_PREFIX = "zlink:v11:";
 /**
  * Framework-owned primitive Store used by the explicit in-memory option.
  * Domain records are encoded by ZLinkLocationStoreRepository.

package/dist/runtime/locations/in-memory-provider-location-store.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkInMemoryProviderLocationStore = void 0;
+exports.ZLinkInMemoryProviderLocationStore = exports.PROVIDER_STORAGE_NAMESPACE_PREFIX = void 0;
 exports.storeKey = storeKey;
 exports.storeVersion = storeVersion;
+const Stores_1 = require("../../contracts/Locations/Stores");
+exports.PROVIDER_STORAGE_NAMESPACE_PREFIX = 'zlink:v11:';
 /**
  * Framework-owned primitive Store used by the explicit in-memory option.
  * Domain records are encoded by ZLinkLocationStoreRepository.
@@ -42,6 +44,12 @@ class ZLinkInMemoryProviderLocationStore {
                 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 };
             }
@@ -52,7 +60,7 @@ class ZLinkInMemoryProviderLocationStore {
                 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);
             this.values.set(mutation.key.value, {
@@ -84,13 +92,26 @@ class ZLinkInMemoryProviderLocationStore {
             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)
+            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 > Stores_1.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);
@@ -133,9 +154,10 @@ function scanCursor(value) {
 function parseCursor(cursor) {
     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];
 }
@@ -145,27 +167,55 @@ function requireWriteRequest(request) {
     const keys = [...new Set([...conditionKeys, ...mutationKeys])];
     if (new Set(conditionKeys).size !== conditionKeys.length ||
         new Set(mutationKeys).size !== mutationKeys.length ||
-        keys.length > 2_048) {
-        throw new RangeError('Location Store write keys must be unique and bounded to 2,048.');
+        keys.length > Stores_1.ZLINK_PROVIDER_MAX_WRITE_KEYS) {
+        throw new RangeError(`Location Store write keys must be unique and bounded to ${Stores_1.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 > Stores_1.ZLINK_PROVIDER_MAX_VERSION_BYTES) {
+            throw new RangeError(`Location Store version must contain 1..${Stores_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 > Stores_1.ZLINK_PROVIDER_MAX_WRITE_BYTES) {
+        throw new RangeError(`Location Store write exceeds ${Stores_1.ZLINK_PROVIDER_MAX_WRITE_BYTES / (1024 * 1024)} MiB.`);
     }
 }
 function requireScanRequest(request) {
-    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 > Stores_1.ZLINK_PROVIDER_MAX_SCAN_CURSOR_BYTES) {
+            throw new RangeError(`Location Store cursor must contain 1..${Stores_1.ZLINK_PROVIDER_MAX_SCAN_CURSOR_BYTES.toLocaleString('en-US')} UTF-8 bytes.`);
+        }
+    }
+    if (Buffer.byteLength(request.prefix, 'utf8') > Stores_1.ZLINK_PROVIDER_MAX_KEY_BYTES) {
+        throw new RangeError(`Location Store scan prefix exceeds ${Stores_1.ZLINK_PROVIDER_MAX_KEY_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 (!Number.isSafeInteger(request.limit) ||
+        request.limit < 1 ||
+        request.limit > Stores_1.ZLINK_PROVIDER_MAX_PAGE_SIZE) {
+        throw new RangeError(`Location Store scan limit must be in 1..${Stores_1.ZLINK_PROVIDER_MAX_PAGE_SIZE}.`);
     }
 }
 function requireValue(bytes, retentionMs) {
-    if (bytes.byteLength > 1024 * 1024) {
-        throw new RangeError('Location Store value exceeds 1 MiB.');
+    if (bytes.byteLength > Stores_1.ZLINK_PROVIDER_MAX_VALUE_BYTES) {
+        throw new RangeError(`Location Store value exceeds ${Stores_1.ZLINK_PROVIDER_MAX_VALUE_BYTES / (1024 * 1024)} MiB.`);
     }
     if (retentionMs !== undefined &&
         (!Number.isFinite(retentionMs) ||
@@ -177,7 +227,7 @@ function requireValue(bytes, retentionMs) {
 }
 function requireKey(value) {
     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 > Stores_1.ZLINK_PROVIDER_MAX_KEY_BYTES) {
+        throw new RangeError(`Location Store key must contain 1..${Stores_1.ZLINK_PROVIDER_MAX_KEY_BYTES.toLocaleString('en-US')} UTF-8 bytes.`);
     }
 }

package/dist/runtime/locations/key-codec.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkLocationKeyCodec = void 0;
+const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
 const canonical_codec_1 = require("./canonical-codec");
 const routing_id_1 = require("../routing-id");
 // Framework bookkeeping codec for in-memory row maps and generation guards.
@@ -31,8 +32,8 @@ function encodeSegments(...segments) {
 }
 function requireSpotId(value) {
     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 > CoreTypes_1.ZLINK_MAX_SPOT_ID_BYTES) {
+        throw new TypeError(`SpotId must contain 1..${CoreTypes_1.ZLINK_MAX_SPOT_ID_BYTES} UTF-8 bytes.`);
     }
     return value;
 }

package/dist/runtime/locations/lease-tracker.d.ts

@@ -19,6 +19,7 @@ export declare class ZLinkOwnerLeaseTracker {
     isOwnerLive(ownerId: string, signal?: AbortSignal): Promise<boolean>;
     remainingLeaseMs(ownerId: string, signal?: AbortSignal): Promise<number>;
     remainingOwnerTokenLeaseMs(owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<number>;
+    isOwnerTokenLive(owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<boolean>;
     getLiveOwnerSetVersion(signal?: AbortSignal): Promise<number>;
     private getSnapshot;
     private prepareSnapshotRefresh;
@@ -28,9 +29,6 @@ export declare class ZLinkOwnerLeaseTracker {
     private isLive;
 }
 export declare class ZLinkLiveRowFilter {
-    private readonly leaseTracker;
-    constructor(leaseTracker: ZLinkOwnerLeaseTracker);
-    filter<TRow>(rows: readonly TRow[], ownerIdOf: (row: TRow) => string, signal?: AbortSignal, include?: (row: TRow) => boolean): Promise<TRow[]>;
-    resolve<TRow>(row: TRow | undefined, ownerIdOf: (row: TRow) => string, signal?: AbortSignal, include?: (row: TRow) => boolean): Promise<TRow | undefined>;
-    private isLive;
+    filter<TRow>(rows: readonly TRow[], isLive: (row: TRow, signal?: AbortSignal) => Promise<boolean>, signal?: AbortSignal, include?: (row: TRow) => boolean): Promise<TRow[]>;
+    resolve<TRow>(row: TRow | undefined, isLive: (row: TRow, signal?: AbortSignal) => Promise<boolean>, signal?: AbortSignal, include?: (row: TRow) => boolean): Promise<TRow | undefined>;
 }