@zlink-systems/framework 0.26.0 → 0.28.0

package/dist/runtime/locations/location-store-repository.js

@@ -1,17 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkLocationStoreRepository = void 0;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
-const internal_location_contracts_1 = require("./internal-location-contracts");
+const Options_1 = require("../../contracts/Locations/Options");
 const contracts_1 = require("../../contracts");
+const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
+const InternalDefaults_1 = require("../../contracts/Configuration/InternalDefaults");
+const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
 const Locations_1 = require("../../contracts/Locations");
+const Stores_1 = require("../../contracts/Locations/Stores");
+const actor_join_recovery_codec_1 = require("../foundation/actor-join-recovery-codec");
+const routing_id_1 = require("../routing-id");
+const aggregate_inventory_store_1 = require("./aggregate-inventory-store");
+const authority_key_codec_1 = require("./authority-key-codec");
 const in_memory_location_store_1 = require("./in-memory-location-store");
 const in_memory_provider_location_store_1 = require("./in-memory-provider-location-store");
+const internal_location_contracts_1 = require("./internal-location-contracts");
 const opaque_record_key_1 = require("./opaque-record-key");
-const authority_key_codec_1 = require("./authority-key-codec");
-const aggregate_inventory_store_1 = require("./aggregate-inventory-store");
-const routing_id_1 = require("../routing-id");
-const PREFIX = 'zlink:v11:';
+const LOCATION_STORE_WRITE_CONCURRENCY = 64;
+const LOCATION_RECORD_VERSION = 1;
+const PREFIX = in_memory_provider_location_store_1.PROVIDER_STORAGE_NAMESPACE_PREFIX;
 const OWNER_COUNTER_KEY = (0, in_memory_provider_location_store_1.storeKey)(`${PREFIX}owner-counter`);
 // These counters are store-wide fences.  They deliberately are not derived
 // from an authority identity: deleting and recreating an authority must never
@@ -19,11 +28,8 @@ const OWNER_COUNTER_KEY = (0, in_memory_provider_location_store_1.storeKey)(`${P
 const OBJECT_COUNTER_KEY = (0, in_memory_provider_location_store_1.storeKey)(`${PREFIX}object-counter`);
 const AUTHORITY_OWNER_COUNTER_KEY = (0, in_memory_provider_location_store_1.storeKey)(`${PREFIX}authority-owner-counter`);
 const MAX_GENERATION = 0x7fffffffffffffffn;
-const MAX_U64 = 0xffffffffffffffffn;
-const MAX_CREATION_TERMINAL_BYTES = 1024 * 1024;
+const MAX_U64 = stream_wire_1.UINT64_MAX;
 const CREATION_TERMINAL_RETENTION_MS = 5 * 60 * 1000;
-const AGGREGATE_COMMIT_RETRY_WINDOW_MS = 5_000;
-const MAX_AGGREGATE_COMMIT_CONFLICT_RETRIES = 64;
 const MAX_DESCRIPTOR_WRITE_RETRIES = 3;
 const MAX_OWNER_CLEANUP_BATCH_ROWS = 2_047;
 /**
@@ -40,7 +46,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
     constructor(provider, nowProvider = () => new Date()) {
         super(nowProvider);
         this.nowProvider = nowProvider;
-        this.provider = new AmbiguousWriteReconcilingLocationStore(provider);
+        this.provider = provider;
         this.aggregateInventory = new aggregate_inventory_store_1.ZLinkAggregateInventoryStore(this.provider);
     }
     async readAuthority(key, signal) {
@@ -51,8 +57,8 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         return await this.projectAuthority(decodeAuthorityRecord(result.value.bytes), result.value.version, result.value.storeNow, signal);
     }
     async listAuthorities(prefix, cursor, limit, signal) {
-        if (!Number.isInteger(limit) || limit < 1 || limit > 1_000) {
-            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 scan = await this.provider.scan({
             prefix: AUTHORITY_PREIMAGE_PREFIX,
@@ -130,7 +136,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                     conditions: [
                         { kind: 'version', key: rowKey, expected: current.value.version },
                         versionCondition(descriptorKey, descriptorRead),
-                        versionCondition(ownerKey(mutation.targetOwner.ownerId), targetLeaseRead)
+                        leaseValueCondition(ownerKey(mutation.targetOwner.ownerId), mutation.targetOwner)
                     ],
                     mutations: [{ kind: 'put', key: rowKey, bytes: encodeAuthorityRecord(nextRecord) }]
                 }, signal);
@@ -156,6 +162,16 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             }
             const capacityRowKey = capacityKey(record.snapshot.allocation.descriptor.meshName, String(record.snapshot.allocation.descriptor.rid));
             const capacityRead = mutation.kind === 'delete' ? await this.provider.read(capacityRowKey, signal) : undefined;
+            const generations = mutation.kind === 'put' && mutation.generationTransition === 'reincarnate'
+                ? await Promise.all([
+                    this.provider.read(OBJECT_COUNTER_KEY, signal),
+                    this.provider.read(AUTHORITY_OWNER_COUNTER_KEY, signal)
+                ])
+                : undefined;
+            if (generations !== undefined &&
+                generations.some((counter) => counterNextValue(counter) >= MAX_GENERATION)) {
+                return { kind: 'generationExhausted' };
+            }
             const nextRecord = mutation.kind === 'delete'
                 ? undefined
                 : {
@@ -163,14 +179,33 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                     visibleStoreVersion: undefined,
                     snapshot: {
                         ...record.snapshot,
+                        ...(generations === undefined
+                            ? {}
+                            : {
+                                objectGeneration: counterNextValue(generations[0]),
+                                authorityOwnerGeneration: counterNextValue(generations[1])
+                            }),
                         payload: Buffer.from(mutation.payload)
                     }
                 };
             const result = await this.provider.write({
                 conditions: [
                     { kind: 'version', key: rowKey, expected: current.value.version },
-                    ...(mutation.kind === 'restore' ? [] : [versionCondition(leaseKey, lease)]),
-                    ...(capacityRead === undefined ? [] : [conditionFor(capacityRowKey, capacityRead)])
+                    ...(mutation.kind === 'restore'
+                        ? []
+                        : [
+                            leaseValueCondition(leaseKey, {
+                                ownerId: record.snapshot.ownerId,
+                                leaseGeneration: record.snapshot.ownerLeaseGeneration
+                            })
+                        ]),
+                    ...(capacityRead === undefined ? [] : [conditionFor(capacityRowKey, capacityRead)]),
+                    ...(generations === undefined
+                        ? []
+                        : [
+                            conditionFor(OBJECT_COUNTER_KEY, generations[0]),
+                            conditionFor(AUTHORITY_OWNER_COUNTER_KEY, generations[1])
+                        ])
                 ],
                 mutations: mutation.kind === 'delete'
                     ? [
@@ -188,7 +223,23 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                             })
                         }
                     ]
-                    : [{ kind: 'put', key: rowKey, bytes: encodeAuthorityRecord(nextRecord) }]
+                    : [
+                        { kind: 'put', key: rowKey, bytes: encodeAuthorityRecord(nextRecord) },
+                        ...(generations === undefined
+                            ? []
+                            : [
+                                {
+                                    kind: 'put',
+                                    key: OBJECT_COUNTER_KEY,
+                                    bytes: encodeText((counterNextValue(generations[0]) + 1n).toString())
+                                },
+                                {
+                                    kind: 'put',
+                                    key: AUTHORITY_OWNER_COUNTER_KEY,
+                                    bytes: encodeText((counterNextValue(generations[1]) + 1n).toString())
+                                }
+                            ])
+                    ]
             }, signal);
             if (result.kind === 'conflict')
                 continue;
@@ -266,7 +317,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             if (entries.length !== request.participants.length) {
                 throw new Error('Aggregate inventory count changed after staging.');
             }
-            await parallelForEach(request.participants, 64, async (participant, index) => {
+            await parallelForEach(request.participants, LOCATION_STORE_WRITE_CONCURRENCY, async (participant, index) => {
                 const entry = entries[index];
                 if (entry.authorityKey !== participant.authorityKey.value ||
                     entry.expectedStoreVersion !== participant.expectedStoreVersion.value ||
@@ -485,7 +536,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 conditions: [
                     { kind: 'version', key: rowKey, expected: aggregateRead.value.version },
                     versionCondition(targetDescriptorKey, descriptorRead),
-                    versionCondition(targetLeaseKey, leaseRead),
+                    leaseValueCondition(targetLeaseKey, request.targetOwner),
                     conditionFor(targetCapacityKey, targetCapacityRead)
                 ],
                 mutations: [
@@ -524,162 +575,162 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
     }
     async commitAggregate(fence, signal) {
         validateAggregateFence(fence);
-        return await this.commitAggregateCore(fence, 0, performance.now() + AGGREGATE_COMMIT_RETRY_WINDOW_MS, signal);
+        return await this.commitAggregateCore(fence, signal);
     }
-    async commitAggregateCore(fence, retryAttempt, retryDeadlineAtMs, signal) {
-        const rowKey = aggregateKey(fence);
-        let aggregateRead = await this.provider.read(rowKey, signal);
-        if (aggregateRead.kind === 'missing')
-            return { kind: 'stale' };
-        let aggregate = decodeJson(aggregateRead.value.bytes);
-        if (aggregate.state === 'aborted' || aggregate.state === 'staging') {
-            return { kind: 'stale' };
-        }
-        if (aggregate.state === 'committed') {
-            await this.normalizeCommittedAggregate(fence, aggregate, signal);
-            return { kind: 'alreadyCommitted' };
-        }
-        const entries = await this.aggregateInventory.read(fence, Buffer.from(aggregate.inventoryDigest), signal);
-        if (entries.length !== aggregate.participantCount) {
-            throw new Error('Aggregate inventory count differs from its authority record.');
-        }
-        const authorityRows = [];
-        for (let index = 0; index < entries.length; index++) {
-            const entry = entries[index];
-            const rowKeyForParticipant = authorityKey(entry.authorityKey);
-            const current = await this.provider.read(rowKeyForParticipant, signal);
-            if (current.kind === 'missing')
+    async commitAggregateCore(fence, signal) {
+        for (;;) {
+            signal?.throwIfAborted();
+            const rowKey = aggregateKey(fence);
+            let aggregateRead = await this.provider.read(rowKey, signal);
+            if (aggregateRead.kind === 'missing')
                 return { kind: 'stale' };
-            const record = decodeAuthorityRecord(current.value.bytes);
-            if (!sameAggregateMarkerEntry(record.aggregate, fence, index, entry)) {
-                // A competing committer may already have published the aggregate and
-                // normalized this participant before this reader reached it.  The
-                // committed aggregate is the terminal outcome to adopt, not a stale
-                // failure caused by observing the post-normalization row.
-                const latest = await this.provider.read(rowKey, signal);
-                if (latest.kind === 'found') {
-                    const latestAggregate = decodeJson(latest.value.bytes);
-                    if (latestAggregate.state === 'committed') {
-                        await this.normalizeCommittedAggregate(fence, latestAggregate, signal);
-                        return { kind: 'alreadyCommitted' };
+            let aggregate = decodeJson(aggregateRead.value.bytes);
+            if (aggregate.state === 'aborted' || aggregate.state === 'staging') {
+                return { kind: 'stale' };
+            }
+            if (aggregate.state === 'committed') {
+                await this.normalizeCommittedAggregate(fence, aggregate, signal);
+                return { kind: 'alreadyCommitted' };
+            }
+            const entries = await this.aggregateInventory.read(fence, Buffer.from(aggregate.inventoryDigest), signal);
+            if (entries.length !== aggregate.participantCount) {
+                throw new Error('Aggregate inventory count differs from its authority record.');
+            }
+            const authorityRows = [];
+            for (let index = 0; index < entries.length; index++) {
+                const entry = entries[index];
+                const rowKeyForParticipant = authorityKey(entry.authorityKey);
+                const current = await this.provider.read(rowKeyForParticipant, signal);
+                if (current.kind === 'missing')
+                    return { kind: 'stale' };
+                const record = decodeAuthorityRecord(current.value.bytes);
+                if (!sameAggregateMarkerEntry(record.aggregate, fence, index, entry)) {
+                    // A competing committer may already have published the aggregate and
+                    // normalized this participant before this reader reached it.  The
+                    // committed aggregate is the terminal outcome to adopt, not a stale
+                    // failure caused by observing the post-normalization row.
+                    const latest = await this.provider.read(rowKey, signal);
+                    if (latest.kind === 'found') {
+                        const latestAggregate = decodeJson(latest.value.bytes);
+                        if (latestAggregate.state === 'committed') {
+                            await this.normalizeCommittedAggregate(fence, latestAggregate, signal);
+                            return { kind: 'alreadyCommitted' };
+                        }
                     }
+                    return { kind: 'stale' };
                 }
-                return { kind: 'stale' };
+                const [payload, membership] = await Promise.all([
+                    requireProviderBytes(this.provider, aggregateParticipantPayloadKey(fence, index), signal),
+                    requireProviderBytes(this.provider, aggregateParticipantMembershipKey(fence, index), signal)
+                ]);
+                if (sha256Hex(payload) !== entry.authorityPayloadSha256 ||
+                    sha256Hex(membership) !== entry.membershipMutationSha256) {
+                    throw new Error('Aggregate participant staging checksum does not match inventory.');
+                }
+                authorityRows.push({ key: rowKeyForParticipant, current, record, entry });
             }
-            const [payload, membership] = await Promise.all([
-                requireProviderBytes(this.provider, aggregateParticipantPayloadKey(fence, index), signal),
-                requireProviderBytes(this.provider, aggregateParticipantMembershipKey(fence, index), signal)
+            const targetDescriptorKey = meshKey(aggregate.targetDescriptor.meshName, aggregate.targetDescriptor.rid);
+            const targetLeaseKey = ownerKey(aggregate.targetOwner.ownerId);
+            const targetCapacityKey = capacityKey(aggregate.targetDescriptor.meshName, String(aggregate.targetDescriptor.rid));
+            const [descriptorRead, leaseRead] = await Promise.all([
+                this.provider.read(targetDescriptorKey, signal),
+                this.provider.read(targetLeaseKey, signal)
             ]);
-            if (sha256Hex(payload) !== entry.authorityPayloadSha256 ||
-                sha256Hex(membership) !== entry.membershipMutationSha256) {
-                throw new Error('Aggregate participant staging checksum does not match inventory.');
+            if (liveTargetDescriptor(descriptorRead, leaseRead, aggregateTargetFromRecord(aggregate)) ===
+                undefined) {
+                return { kind: 'stale' };
             }
-            authorityRows.push({ key: rowKeyForParticipant, current, record, entry });
-        }
-        const targetDescriptorKey = meshKey(aggregate.targetDescriptor.meshName, aggregate.targetDescriptor.rid);
-        const targetLeaseKey = ownerKey(aggregate.targetOwner.ownerId);
-        const targetCapacityKey = capacityKey(aggregate.targetDescriptor.meshName, String(aggregate.targetDescriptor.rid));
-        const [descriptorRead, leaseRead] = await Promise.all([
-            this.provider.read(targetDescriptorKey, signal),
-            this.provider.read(targetLeaseKey, signal)
-        ]);
-        if (liveTargetDescriptor(descriptorRead, leaseRead, aggregateTargetFromRecord(aggregate)) ===
-            undefined) {
-            return { kind: 'stale' };
-        }
-        const capacityDeltas = new Map();
-        for (const row of authorityRows) {
-            if (row.entry.ownerTransition !== 'newOwner')
-                continue;
-            const key = capacityKey(row.record.snapshot.allocation.descriptor.meshName, String(row.record.snapshot.allocation.descriptor.rid)).value;
-            capacityDeltas.set(key, addCapacityVector(capacityDeltas.get(key) ?? { actors: 0, spots: 0 }, row.record.snapshot.allocation.capacity));
-        }
-        const capacityKeys = new Map();
-        capacityKeys.set(targetCapacityKey.value, targetCapacityKey);
-        for (const value of capacityDeltas.keys())
-            capacityKeys.set(value, (0, in_memory_provider_location_store_1.storeKey)(value));
-        const capacityReads = new Map();
-        for (const [value, key] of capacityKeys) {
-            const read = await this.provider.read(key, signal);
-            if (read.kind === 'missing') {
-                // Capacity rows are provider-private. A foreign source legitimately
-                // has no row under this provider's key encoding; its source runtime
-                // releases that capacity after observing the committed authority.
-                // The target row remains mandatory because this provider reserved it
-                // during prepare and must consume it atomically with commit.
-                if (value === targetCapacityKey.value)
-                    return { kind: 'stale' };
-                capacityKeys.delete(value);
-                continue;
+            const capacityDeltas = new Map();
+            for (const row of authorityRows) {
+                if (row.entry.ownerTransition !== 'newOwner')
+                    continue;
+                const key = capacityKey(row.record.snapshot.allocation.descriptor.meshName, String(row.record.snapshot.allocation.descriptor.rid)).value;
+                capacityDeltas.set(key, addCapacityVector(capacityDeltas.get(key) ?? { actors: 0, spots: 0 }, row.record.snapshot.allocation.capacity));
+            }
+            const capacityKeys = new Map();
+            capacityKeys.set(targetCapacityKey.value, targetCapacityKey);
+            for (const value of capacityDeltas.keys())
+                capacityKeys.set(value, (0, in_memory_provider_location_store_1.storeKey)(value));
+            const capacityReads = new Map();
+            for (const [value, key] of capacityKeys) {
+                const read = await this.provider.read(key, signal);
+                if (read.kind === 'missing') {
+                    // Capacity rows are provider-private. A foreign source legitimately
+                    // has no row under this provider's key encoding; its source runtime
+                    // releases that capacity after observing the committed authority.
+                    // The target row remains mandatory because this provider reserved it
+                    // during prepare and must consume it atomically with commit.
+                    if (value === targetCapacityKey.value)
+                        return { kind: 'stale' };
+                    capacityKeys.delete(value);
+                    continue;
+                }
+                capacityReads.set(value, read);
+            }
+            const capacityMutations = [];
+            for (const [value, key] of capacityKeys) {
+                const read = capacityReads.get(value);
+                let capacity = decodeJson(read.value.bytes);
+                const sourceDelta = capacityDeltas.get(value);
+                if (sourceDelta !== undefined) {
+                    capacity = {
+                        active: subtractCapacity(capacity.active, sourceDelta),
+                        pending: capacity.pending
+                    };
+                }
+                if (value === targetCapacityKey.value) {
+                    capacity = {
+                        active: addCapacity(capacity.active, aggregate.capacity),
+                        pending: subtractCapacity(capacity.pending, aggregate.capacity)
+                    };
+                }
+                capacityMutations.push({
+                    kind: 'put',
+                    key,
+                    bytes: encodeJson(capacity)
+                });
             }
-            capacityReads.set(value, read);
-        }
-        const capacityMutations = [];
-        for (const [value, key] of capacityKeys) {
-            const read = capacityReads.get(value);
-            let capacity = decodeJson(read.value.bytes);
-            const sourceDelta = capacityDeltas.get(value);
-            if (sourceDelta !== undefined) {
-                capacity = {
-                    active: subtractCapacity(capacity.active, sourceDelta),
-                    pending: capacity.pending
-                };
+            const published = await this.provider.write({
+                conditions: [
+                    { kind: 'version', key: rowKey, expected: aggregateRead.value.version },
+                    versionCondition(targetDescriptorKey, descriptorRead),
+                    leaseValueCondition(targetLeaseKey, aggregate.targetOwner),
+                    ...[...capacityReads.entries()].map(([value, read]) => ({
+                        kind: 'version',
+                        key: capacityKeys.get(value),
+                        expected: read.value.version
+                    }))
+                ],
+                mutations: [
+                    {
+                        kind: 'put',
+                        key: rowKey,
+                        bytes: encodeJson({ ...aggregate, state: 'committed' })
+                    },
+                    ...capacityMutations
+                ]
+            }, signal);
+            if (published.kind === 'conflict') {
+                aggregateRead = await this.provider.read(rowKey, signal);
+                if (aggregateRead.kind === 'missing')
+                    return { kind: 'stale' };
+                aggregate = decodeJson(aggregateRead.value.bytes);
+                if (aggregate.state === 'prepared') {
+                    // The commit CAS also fences the target's live owner lease, descriptor,
+                    // and capacity rows. Re-read the whole prepared fence after an
+                    // auxiliary-row race; a changed aggregate or participant fence exits
+                    // through the normal stale checks on the next attempt.
+                    continue;
+                }
+                if (aggregate.state !== 'committed')
+                    return { kind: 'stale' };
             }
-            if (value === targetCapacityKey.value) {
-                capacity = {
-                    active: addCapacity(capacity.active, aggregate.capacity),
-                    pending: subtractCapacity(capacity.pending, aggregate.capacity)
-                };
+            else {
+                aggregate = { ...aggregate, state: 'committed' };
             }
-            capacityMutations.push({
-                kind: 'put',
-                key,
-                bytes: encodeJson(capacity)
-            });
-        }
-        const published = await this.provider.write({
-            conditions: [
-                { kind: 'version', key: rowKey, expected: aggregateRead.value.version },
-                versionCondition(targetDescriptorKey, descriptorRead),
-                versionCondition(targetLeaseKey, leaseRead),
-                ...[...capacityReads.entries()].map(([value, read]) => ({
-                    kind: 'version',
-                    key: capacityKeys.get(value),
-                    expected: read.value.version
-                }))
-            ],
-            mutations: [
-                {
-                    kind: 'put',
-                    key: rowKey,
-                    bytes: encodeJson({ ...aggregate, state: 'committed' })
-                },
-                ...capacityMutations
-            ]
-        }, signal);
-        if (published.kind === 'conflict') {
-            aggregateRead = await this.provider.read(rowKey, signal);
-            if (aggregateRead.kind === 'missing')
-                return { kind: 'stale' };
-            aggregate = decodeJson(aggregateRead.value.bytes);
-            if (aggregate.state === 'prepared' &&
-                retryAttempt < MAX_AGGREGATE_COMMIT_CONFLICT_RETRIES &&
-                performance.now() < retryDeadlineAtMs) {
-                // The commit CAS also fences the target's live owner lease, descriptor,
-                // and capacity rows. Re-read the whole prepared fence after an
-                // auxiliary-row race; a changed aggregate or participant fence exits
-                // through the normal stale checks on the next attempt.
-                await waitForAggregateCommitRetry(retryAttempt, retryDeadlineAtMs, signal);
-                return await this.commitAggregateCore(fence, retryAttempt + 1, retryDeadlineAtMs, signal);
-            }
-            if (aggregate.state !== 'committed')
-                return { kind: 'stale' };
-        }
-        else {
-            aggregate = { ...aggregate, state: 'committed' };
+            await this.normalizeCommittedAggregate(fence, aggregate, signal);
+            return { kind: 'committed' };
         }
-        await this.normalizeCommittedAggregate(fence, aggregate, signal);
-        return { kind: 'committed' };
     }
     async abortAggregate(fence, signal) {
         validateAggregateFence(fence);
@@ -736,22 +787,16 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             return { kind: 'aborted' };
         }
     }
-    async reserve(request, signal) {
+    async reserve(request, signal, deadlineUnixMs) {
         const encodedAuthorityKey = (0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId);
+        const reservationId = (0, node_crypto_1.randomUUID)();
         for (;;) {
-            signal?.throwIfAborted();
+            throwIfOperationExpired(signal, deadlineUnixMs);
             const rowKey = authorityKey(encodedAuthorityKey.value);
             const descriptorKey = meshKey(request.target.meshName, request.target.nodeRid);
             const leaseKey = ownerKey(request.target.owner.ownerId);
             const capacityRowKey = capacityKey(request.target.meshName, String(request.target.nodeRid));
-            const [current, descriptorRead, leaseRead, capacityRead, objectGenerationRead, authorityOwnerGenerationRead] = await Promise.all([
-                this.provider.read(rowKey, signal),
-                this.provider.read(descriptorKey, signal),
-                this.provider.read(leaseKey, signal),
-                this.provider.read(capacityRowKey, signal),
-                this.provider.read(OBJECT_COUNTER_KEY, signal),
-                this.provider.read(AUTHORITY_OWNER_COUNTER_KEY, signal)
-            ]);
+            const current = await this.provider.read(rowKey, signal);
             if (current.kind === 'found') {
                 const record = decodeAuthorityRecord(current.value.bytes);
                 const snapshot = authoritySnapshot(record.snapshot, current.value.version, current.value.storeNow);
@@ -809,10 +854,19 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 }, signal);
                 continue;
             }
+            const [descriptorRead, leaseRead] = await Promise.all([
+                this.provider.read(descriptorKey, signal),
+                this.provider.read(leaseKey, signal)
+            ]);
             const descriptor = liveTargetDescriptor(descriptorRead, leaseRead, request.target);
-            if (descriptor === undefined) {
+            if (descriptor === undefined || descriptor.state !== contracts_1.ZLinkFrameworkRuntimeState.Serving) {
                 return { kind: 'conflict', current: { kind: 'missing', storeNow: current.storeNow } };
             }
+            const [capacityRead, objectGenerationRead, authorityOwnerGenerationRead] = await Promise.all([
+                this.provider.read(capacityRowKey, signal),
+                this.provider.read(OBJECT_COUNTER_KEY, signal),
+                this.provider.read(AUTHORITY_OWNER_COUNTER_KEY, signal)
+            ]);
             const capacity = capacityRead.kind === 'missing'
                 ? emptyCapacityRecord()
                 : decodeJson(capacityRead.value.bytes);
@@ -827,7 +881,6 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             if (generation >= MAX_GENERATION || authorityOwnerGeneration >= MAX_GENERATION) {
                 return { kind: 'generationExhausted' };
             }
-            const reservationId = (0, node_crypto_1.randomUUID)();
             const allocation = {
                 state: 'reserved',
                 objectKind: request.key.kind,
@@ -859,7 +912,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 conditions: [
                     { kind: 'missing', key: rowKey },
                     versionCondition(descriptorKey, descriptorRead),
-                    versionCondition(leaseKey, leaseRead),
+                    leaseValueCondition(leaseKey, request.target.owner),
                     conditionFor(capacityRowKey, capacityRead),
                     conditionFor(OBJECT_COUNTER_KEY, objectGenerationRead),
                     conditionFor(AUTHORITY_OWNER_COUNTER_KEY, authorityOwnerGenerationRead)
@@ -898,11 +951,11 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             };
         }
     }
-    async commit(request, signal) {
+    async commit(request, signal, deadlineUnixMs) {
         const key = (0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId);
         const rowKey = authorityKey(key.value);
         for (;;) {
-            signal?.throwIfAborted();
+            throwIfOperationExpired(signal, deadlineUnixMs);
             const current = await this.provider.read(rowKey, signal);
             if (current.kind === 'missing')
                 return { kind: 'stale' };
@@ -948,7 +1001,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 conditions: [
                     { kind: 'version', key: rowKey, expected: current.value.version },
                     versionCondition(descriptorKey, descriptorRead),
-                    versionCondition(leaseKey, leaseRead),
+                    leaseValueCondition(leaseKey, request.target.owner),
                     conditionFor(capacityRowKey, capacityRead)
                 ],
                 mutations: [
@@ -974,11 +1027,11 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             };
         }
     }
-    async abort(request, signal) {
+    async abort(request, signal, deadlineUnixMs) {
         const key = (0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId);
         const rowKey = authorityKey(key.value);
         for (;;) {
-            signal?.throwIfAborted();
+            throwIfOperationExpired(signal, deadlineUnixMs);
             const current = await this.provider.read(rowKey, signal);
             if (current.kind === 'missing')
                 return { kind: 'stale' };
@@ -989,9 +1042,11 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 !sameCreationTarget(record.snapshot, request.target)) {
                 return { kind: 'stale' };
             }
+            const descriptorKey = meshKey(request.target.meshName, request.target.nodeRid);
             const leaseKey = ownerKey(request.target.owner.ownerId);
             const capacityRowKey = capacityKey(request.target.meshName, String(request.target.nodeRid));
-            const [leaseRead, capacityRead] = await Promise.all([
+            const [descriptorRead, leaseRead, capacityRead] = await Promise.all([
+                this.provider.read(descriptorKey, signal),
                 this.provider.read(leaseKey, signal),
                 this.provider.read(capacityRowKey, signal)
             ]);
@@ -1001,7 +1056,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 // rather than read the absence as expiry.
                 throw new Error('Location Store owner lease record is invalid.');
             }
-            if (!sameLiveOwner(leaseRead, record.snapshot))
+            if (liveTargetDescriptor(descriptorRead, leaseRead, request.target) === undefined)
                 return { kind: 'stale' };
             const capacity = capacityRead.kind === 'missing'
                 ? emptyCapacityRecord()
@@ -1009,7 +1064,11 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             const result = await this.provider.write({
                 conditions: [
                     { kind: 'version', key: rowKey, expected: current.value.version },
-                    versionCondition(leaseKey, leaseRead),
+                    versionCondition(descriptorKey, descriptorRead),
+                    leaseValueCondition(leaseKey, {
+                        ownerId: record.snapshot.ownerId,
+                        leaseGeneration: record.snapshot.ownerLeaseGeneration
+                    }),
                     conditionFor(capacityRowKey, capacityRead)
                 ],
                 mutations: [
@@ -1037,17 +1096,15 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         const rowKey = authorityKey((0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId).value);
         const terminalRowKey = creationTerminalKey(terminal.operation);
         for (;;) {
-            signal?.throwIfAborted();
-            const [current, existingTerminal] = await Promise.all([
-                this.provider.read(rowKey, signal),
-                this.provider.read(terminalRowKey, signal)
-            ]);
+            throwIfOperationExpired(signal, BigInt(request.completion.terminal.operationDeadline.getTime()));
+            const existingTerminal = await this.provider.read(terminalRowKey, signal);
             if (existingTerminal.kind === 'found') {
                 return {
                     kind: 'alreadyCompleted',
                     terminal: retainedCreationTerminal(terminal.operation, existingTerminal.value.bytes, existingTerminal.value.expiresAt, existingTerminal.value.storeNow)
                 };
             }
+            const current = await this.provider.read(rowKey, signal);
             if (current.kind === 'missing')
                 return { kind: 'stale' };
             const record = decodeAuthorityRecord(current.value.bytes);
@@ -1060,14 +1117,14 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             const descriptorKey = meshKey(request.target.meshName, request.target.nodeRid);
             const leaseKey = ownerKey(request.target.owner.ownerId);
             const capacityRowKey = capacityKey(request.target.meshName, request.target.nodeRid);
-            const [descriptorRead, leaseRead, capacityRead] = await Promise.all([
+            const [descriptorRead, leaseRead] = await Promise.all([
                 this.provider.read(descriptorKey, signal),
-                this.provider.read(leaseKey, signal),
-                this.provider.read(capacityRowKey, signal)
+                this.provider.read(leaseKey, signal)
             ]);
             if (liveTargetDescriptor(descriptorRead, leaseRead, request.target) === undefined) {
                 return { kind: 'stale' };
             }
+            const capacityRead = await this.provider.read(capacityRowKey, signal);
             const capacity = capacityRead.kind === 'missing'
                 ? emptyCapacityRecord()
                 : decodeJson(capacityRead.value.bytes);
@@ -1119,7 +1176,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                     { kind: 'version', key: rowKey, expected: current.value.version },
                     { kind: 'missing', key: terminalRowKey },
                     versionCondition(descriptorKey, descriptorRead),
-                    versionCondition(leaseKey, leaseRead),
+                    leaseValueCondition(leaseKey, request.target.owner),
                     conditionFor(capacityRowKey, capacityRead)
                 ],
                 mutations: [
@@ -1300,7 +1357,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             cursor: page.continuationToken === undefined
                 ? undefined
                 : { value: page.continuationToken },
-            limit: page.pageSize ?? 100
+            limit: page.pageSize ?? Options_1.zlinkRuntimeDefaultLocationOptions.listPageSize
         }, signal);
         if (result.kind === 'expired') {
             throw new Error('Location Store scan snapshot expired.');
@@ -1688,20 +1745,16 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         else if (intent === 2) {
             return rejected(lease.value.storeNow);
         }
-        return this.writeDescriptorWithReconciliation(leaseKey, descriptor.ownerId, descriptor.leaseGeneration, lease, rowKey, current, encodeCanonicalDescriptorRecord(generation, descriptor), generation, signal);
+        return this.writeDescriptorWithReconciliation(leaseKey, descriptor.ownerId, descriptor.leaseGeneration, rowKey, current, encodeCanonicalDescriptorRecord(generation, descriptor), generation, signal);
     }
-    async writeDescriptorWithReconciliation(leaseKey, ownerId, leaseGeneration, liveLease, rowKey, predecessor, encodedDescriptor, generation, signal) {
-        let currentLease = liveLease;
+    async writeDescriptorWithReconciliation(leaseKey, ownerId, leaseGeneration, rowKey, predecessor, encodedDescriptor, generation, signal) {
         let currentRow = predecessor;
         for (let attempt = 0; attempt <= MAX_DESCRIPTOR_WRITE_RETRIES; attempt += 1) {
             const rowCondition = currentRow.kind === 'found'
                 ? { kind: 'version', key: rowKey, expected: currentRow.value.version }
                 : { kind: 'missing', key: rowKey };
             const result = await this.provider.write({
-                conditions: [
-                    { kind: 'version', key: leaseKey, expected: currentLease.value.version },
-                    rowCondition
-                ],
+                conditions: [leaseValueCondition(leaseKey, { ownerId, leaseGeneration }), rowCondition],
                 mutations: [{ kind: 'put', key: rowKey, bytes: encodedDescriptor }]
             }, signal);
             if (result.kind === 'applied') {
@@ -1718,7 +1771,6 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 !sameDescriptorPredecessor(predecessor, refreshedRow)) {
                 return ignoredStale(result.storeNow);
             }
-            currentLease = refreshedLease;
             currentRow = refreshedRow;
         }
         throw new Error('Descriptor write retry loop exhausted unexpectedly.');
@@ -1744,7 +1796,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             cursor: page.continuationToken === undefined
                 ? undefined
                 : { value: page.continuationToken },
-            limit: page.pageSize ?? 100
+            limit: page.pageSize ?? Options_1.zlinkRuntimeDefaultLocationOptions.listPageSize
         }, signal);
         if (result.kind === 'expired') {
             throw new Error('Location Store scan snapshot expired.');
@@ -1801,7 +1853,10 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
         const result = await this.provider.write({
             conditions: [
-                { kind: 'version', key: leaseKey, expected: lease.value.version },
+                leaseValueCondition(leaseKey, {
+                    ownerId: location.ownerId,
+                    leaseGeneration: locationOwnerGeneration(location)
+                }),
                 rowCondition
             ],
             mutations: [
@@ -1842,7 +1897,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             : decodeJson(result.value.bytes).descriptor;
     }
     async listOwnedLocations(prefix, page, revive, matches, signal) {
-        const requested = page.pageSize ?? 100;
+        const requested = page.pageSize ?? Options_1.zlinkRuntimeDefaultLocationOptions.listPageSize;
         let cursor = page.continuationToken === undefined
             ? undefined
             : { value: page.continuationToken };
@@ -1913,7 +1968,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
     }
     async normalizeCommittedAggregate(fence, aggregate, signal) {
         const entries = await this.aggregateInventory.read(fence, Buffer.from(aggregate.inventoryDigest), signal);
-        await parallelForEach(entries, 64, async (entry, index) => {
+        await parallelForEach(entries, LOCATION_STORE_WRITE_CONCURRENCY, async (entry, index) => {
             const rowKey = authorityKey(entry.authorityKey);
             for (;;) {
                 const current = await this.provider.read(rowKey, signal);
@@ -1980,8 +2035,8 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         });
     }
     async putImmutable(key, bytes, signal) {
-        if (bytes.byteLength > 1024 * 1024) {
-            throw new RangeError('Aggregate participant staging value exceeds 1 MiB.');
+        if (bytes.byteLength > Stores_1.ZLINK_PROVIDER_MAX_VALUE_BYTES) {
+            throw new RangeError(`Aggregate participant staging value exceeds ${Stores_1.ZLINK_PROVIDER_MAX_VALUE_BYTES / (1024 * 1024)} MiB.`);
         }
         const result = await this.provider.write({
             conditions: [{ kind: 'missing', key }],
@@ -2024,7 +2079,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async clearAggregateMarkers(fence, installed, signal) {
-        await parallelForEach(installed, 64, async (value) => {
+        await parallelForEach(installed, LOCATION_STORE_WRITE_CONCURRENCY, async (value) => {
             await this.clearAggregateMarker(fence, value.key, signal);
         });
     }
@@ -2045,7 +2100,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 return (record.aggregate?.aggregateId === fence.aggregateId.value &&
                     record.aggregate.aggregateGeneration === fence.aggregateGeneration);
             });
-            await parallelForEach(matching, 64, async (item) => {
+            await parallelForEach(matching, LOCATION_STORE_WRITE_CONCURRENCY, async (item) => {
                 await this.clearAggregateMarker(fence, item.key, signal);
             });
             if (result.value.nextCursor === undefined)
@@ -2083,85 +2138,13 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
     }
 }
 exports.ZLinkLocationStoreRepository = ZLinkLocationStoreRepository;
-const AMBIGUOUS_WRITE_RECONCILIATION_TIMEOUT_MS = 5_000;
-/**
- * Keeps provider failures private while preserving the opaque Store contract.
- *
- * A write response can be lost after the provider applied the atomic batch.
- * The Framework confirms every mutation by an independent exact read. A put
- * must retain the requested bytes and a version different from the conditioned
- * version; a delete must remain absent. Any mismatch is a normal conflict, so
- * the domain repository can reread its authoritative record and classify the
- * operation without exposing a provider-specific retry API.
- */
-class AmbiguousWriteReconcilingLocationStore {
-    inner;
-    constructor(inner) {
-        this.inner = inner;
-    }
-    read(key, signal) {
-        return this.inner.read(key, signal);
-    }
-    scan(request, signal) {
-        return this.inner.scan(request, signal);
-    }
-    async write(request, signal) {
-        try {
-            return await this.inner.write(request, signal);
-        }
-        catch (failure) {
-            try {
-                return await this.reconcile(request);
-            }
-            catch {
-                throw failure;
-            }
-        }
-    }
-    async reconcile(request) {
-        if (request.mutations.length === 0) {
-            throw new Error('Cannot reconcile an opaque Store write without mutations.');
-        }
-        const reconciliationSignal = AbortSignal.timeout(AMBIGUOUS_WRITE_RECONCILIATION_TIMEOUT_MS);
-        const reads = await Promise.all(request.mutations.map((mutation) => this.inner.read(mutation.key, reconciliationSignal)));
-        const putVersions = [];
-        let storeNow = new Date(0);
-        for (let index = 0; index < request.mutations.length; index += 1) {
-            const mutation = request.mutations[index];
-            const read = reads[index];
-            storeNow =
-                read.kind === 'found'
-                    ? latestDate(storeNow, read.value.storeNow)
-                    : latestDate(storeNow, read.storeNow);
-            if (mutation.kind === 'delete') {
-                if (read.kind !== 'missing')
-                    return { kind: 'conflict', storeNow };
-                continue;
-            }
-            if (read.kind !== 'found' ||
-                !Buffer.from(read.value.bytes).equals(Buffer.from(mutation.bytes)) ||
-                !versionAdvanced(request.conditions, mutation.key, read.value.version)) {
-                return { kind: 'conflict', storeNow };
-            }
-            putVersions.push({ key: mutation.key, version: read.value.version });
-        }
-        return { kind: 'applied', putVersions, storeNow };
-    }
-}
-function versionAdvanced(conditions, key, current) {
-    const condition = conditions.find((candidate) => candidate.key.value === key.value);
-    return condition?.kind !== 'version' || condition.expected.value !== current.value;
-}
-function latestDate(left, right) {
-    return left.getTime() >= right.getTime() ? left : right;
-}
 function validateProviderAggregateRequest(request) {
     requireText(request.aggregateId.value, 'aggregate ID');
     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.`);
     }
     const keys = request.participants.map((value) => value.authorityKey.value);
     if (new Set(keys).size !== keys.length ||
@@ -2171,9 +2154,9 @@ function validateProviderAggregateRequest(request) {
     for (const participant of request.participants) {
         requireText(participant.authorityKey.value, 'aggregate authority key');
         requireText(participant.expectedStoreVersion.value, 'aggregate expected Store version');
-        if (participant.authorityPayload.byteLength > 1024 * 1024 ||
-            participant.membershipMutation.byteLength > 1024 * 1024) {
-            throw new RangeError('Aggregate participant value exceeds 1 MiB.');
+        if (participant.authorityPayload.byteLength > Stores_1.ZLINK_PROVIDER_MAX_VALUE_BYTES ||
+            participant.membershipMutation.byteLength > Stores_1.ZLINK_PROVIDER_MAX_VALUE_BYTES) {
+            throw new RangeError(`Aggregate participant value exceeds ${Stores_1.ZLINK_PROVIDER_MAX_VALUE_BYTES / (1024 * 1024)} MiB.`);
         }
     }
 }
@@ -2275,27 +2258,6 @@ async function parallelForEach(values, concurrency, operation) {
         }
     }));
 }
-async function waitForAggregateCommitRetry(retryAttempt, deadlineAtMs, signal) {
-    signal?.throwIfAborted();
-    const remainingMs = deadlineAtMs - performance.now();
-    if (remainingMs <= 0)
-        return;
-    const exponentialMs = Math.min(100, 2 << Math.min(retryAttempt, 5));
-    const delayMs = Math.min(remainingMs, exponentialMs + Math.floor(Math.random() * (exponentialMs + 1)));
-    await new Promise((resolve, reject) => {
-        let timer;
-        const aborted = () => {
-            if (timer !== undefined)
-                clearTimeout(timer);
-            reject(signal?.reason ?? new Error('Aggregate commit was aborted.'));
-        };
-        signal?.addEventListener('abort', aborted, { once: true });
-        timer = setTimeout(() => {
-            signal?.removeEventListener('abort', aborted);
-            resolve();
-        }, delayMs);
-    });
-}
 function sha256Hex(bytes) {
     return (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex');
 }
@@ -2456,7 +2418,7 @@ function decodeJson(value) {
 function requireRecordVersion(value, kind) {
     if (value === null ||
         typeof value !== 'object' ||
-        value.recordVersion !== 1) {
+        value.recordVersion !== LOCATION_RECORD_VERSION) {
         throw new Error(`Location Store ${kind} record has an unrecognized recordVersion.`);
     }
 }
@@ -2474,21 +2436,22 @@ function canonicalize(value) {
     }
     return value;
 }
+const GENERATION_KEYS = new Set([
+    'generation',
+    'leaseGeneration',
+    'ownerLeaseGeneration',
+    'objectGeneration',
+    'authorityOwnerGeneration',
+    'targetAuthorityOwnerGeneration',
+    'aggregateGeneration',
+    'lifecycleGeneration',
+    'descriptorRevision',
+    'nodeGeneration',
+    'applicationVersion',
+    'requestEncodedSize'
+]);
 function reviveCanonical(value, key = '') {
-    const generationKeys = new Set([
-        'generation',
-        'leaseGeneration',
-        'ownerLeaseGeneration',
-        'objectGeneration',
-        'authorityOwnerGeneration',
-        'aggregateGeneration',
-        'lifecycleGeneration',
-        'descriptorRevision',
-        'nodeGeneration',
-        'applicationVersion',
-        'requestEncodedSize'
-    ]);
-    if (typeof value === 'string' && generationKeys.has(key))
+    if (typeof value === 'string' && GENERATION_KEYS.has(key))
         return BigInt(value);
     if (Array.isArray(value))
         return value.map((item) => reviveCanonical(item));
@@ -2504,7 +2467,7 @@ function decodeOwnerRecord(bytes) {
 }
 function encodeOwnerRecord(ownerId, leaseGeneration) {
     return encodeJson({
-        recordVersion: 1,
+        recordVersion: LOCATION_RECORD_VERSION,
         ownerId,
         leaseGeneration: leaseGeneration.toString()
     });
@@ -2515,7 +2478,7 @@ function encodeCanonicalDescriptorRecord(generation, descriptor) {
     // not serialized (21-location-runtime §2.4).
     void generation;
     return Buffer.from(JSON.stringify({
-        recordVersion: 1,
+        recordVersion: LOCATION_RECORD_VERSION,
         ownerId: descriptor.ownerId,
         leaseGeneration: descriptor.leaseGeneration.toString(),
         descriptorRevision: descriptor.descriptorRevision.toString(),
@@ -2525,7 +2488,7 @@ function encodeCanonicalDescriptorRecord(generation, descriptor) {
 function decodeCanonicalDescriptorRecord(bytes) {
     const record = JSON.parse(decodeText(bytes));
     requireRecordVersion(record, 'descriptor');
-    return reviveCanonical(record);
+    return record;
 }
 function descriptorStoreGeneration(record, storeVersion) {
     return record.generation === undefined ? BigInt(storeVersion) : BigInt(record.generation);
@@ -2653,7 +2616,7 @@ function encodeAuthorityRecord(record) {
     const snapshot = record.snapshot;
     const allocation = snapshot.allocation;
     const envelope = {
-        recordVersion: 1,
+        recordVersion: LOCATION_RECORD_VERSION,
         payload: Buffer.from(snapshot.payload).toString('base64'),
         objectGeneration: snapshot.objectGeneration.toString(),
         authorityOwnerGeneration: snapshot.authorityOwnerGeneration.toString(),
@@ -2789,8 +2752,8 @@ function runtimeSpotPlacementObjectKind(kind) {
 function createTerminalRecord(request, now) {
     const publication = request.completion.terminal;
     validateCreationOperation(publication.operation);
-    if (publication.terminalEnvelope.byteLength > MAX_CREATION_TERMINAL_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;
@@ -2831,8 +2794,10 @@ function retainedCreationTerminal(operation, terminalEnvelope, expiresAt, storeN
 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 ||
@@ -2845,8 +2810,8 @@ function validateCreationOperation(operation) {
     }
 }
 function validatePayloadSize(value, name) {
-    if (value.byteLength > MAX_CREATION_TERMINAL_BYTES) {
-        throw new RangeError(`${name} must not exceed 1 MiB.`);
+    if (value.byteLength > InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES) {
+        throw new RangeError(`${name} must not exceed ${InternalDefaults_1.AUTHORITY_ENVELOPE_MAX_BYTES / (1024 * 1024)} MiB.`);
     }
 }
 function requireText(value, name) {
@@ -2881,7 +2846,6 @@ function liveTargetDescriptor(descriptorRead, leaseRead, target) {
         descriptor.ownerId === target.owner.ownerId &&
         descriptor.leaseGeneration === target.owner.leaseGeneration &&
         descriptor.objectRole === contracts_1.ZLinkObjectRole.Server &&
-        descriptor.state === contracts_1.ZLinkFrameworkRuntimeState.Serving &&
         lease.ownerId === target.owner.ownerId &&
         BigInt(lease.leaseGeneration) === target.owner.leaseGeneration &&
         leaseRead.value.expiresAt !== undefined &&
@@ -2900,6 +2864,9 @@ function versionCondition(key, read) {
     }
     return { kind: 'version', key, expected: read.value.version };
 }
+function leaseValueCondition(key, owner) {
+    return { kind: 'value', key, expected: encodeOwnerRecord(owner.ownerId, owner.leaseGeneration) };
+}
 function emptyCapacityRecord() {
     return {
         active: { actors: 0, spots: 0, spotTypes: {} },
@@ -3215,8 +3182,8 @@ function validateClientServerDescriptor(descriptor) {
         descriptor.ownerId
     ], 'ClientServer');
     validateDescriptorGenerations(descriptor, 'ClientServer');
-    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 validateFanoutPublisherDescriptor(descriptor) {
@@ -3266,3 +3233,9 @@ function requireOwnerInput(ownerId, leaseTtlMs) {
         throw new RangeError('Owner lease TTL must be a positive safe integer.');
     }
 }
+function throwIfOperationExpired(signal, deadlineUnixMs) {
+    signal?.throwIfAborted();
+    if (deadlineUnixMs !== undefined && Date.now() >= Number(deadlineUnixMs)) {
+        throw new DOMException('Operation deadline exceeded.', 'TimeoutError');
+    }
+}