@zlink-systems/framework 0.30.1 → 0.30.2

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkLocationStoreRepository = void 0;
+const routing_id_1 = require("../routing-id");
 const service_relocation_runtime_1 = require("../foundation/service-relocation-runtime");
 const service_authority_payload_codec_1 = require("../foundation/service-authority-payload-codec");
 const actor_authority_payload_codec_1 = require("../actors/actor-authority-payload-codec");
@@ -15,7 +16,7 @@ const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/Regis
 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 routing_id_2 = 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");
@@ -45,28 +46,47 @@ const MAX_OWNER_CLEANUP_BATCH_ROWS = 2_047;
  */
 class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMemoryLocationStore {
     nowProvider;
+    metrics;
     provider;
+    confirmedCapacities = new Map();
     aggregateInventory;
-    constructor(provider, nowProvider = () => new Date()) {
+    constructor(provider, nowProvider = () => new Date(), metrics) {
         super(nowProvider);
         this.nowProvider = nowProvider;
+        this.metrics = metrics;
         // Classify only failures of the opaque SPI, before interpreting its records.
+        const confirm = (key, bytes) => {
+            if (this.confirmedCapacities.has(key.value)) {
+                this.confirmedCapacities.set(key.value, bytes === undefined ? emptyCapacityRecord() : decodeJson(bytes));
+            }
+        };
         this.provider = {
             async read(key, signal) {
+                let result;
                 try {
-                    return await provider.read(key, signal);
+                    result = await provider.read(key, signal);
                 }
                 catch (error) {
                     throw locationStoreProviderFailure(error, signal);
                 }
+                confirm(key, result.kind === 'found' ? result.value.bytes : undefined);
+                return result;
             },
             async write(request, signal) {
+                let result;
                 try {
-                    return await provider.write(request, signal);
+                    result = await provider.write(request, signal);
                 }
                 catch (error) {
                     throw locationStoreProviderFailure(error, signal);
                 }
+                if (result.kind === 'applied') {
+                    for (const mutation of request.mutations) {
+                        if (mutation.kind === 'put')
+                            confirm(mutation.key, mutation.bytes);
+                    }
+                }
+                return result;
             },
             async scan(request, signal) {
                 try {
@@ -79,7 +99,26 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         };
         this.aggregateInventory = new aggregate_inventory_store_1.ZLinkAggregateInventoryStore(this.provider);
     }
+    async observeStore(operation, request) {
+        try {
+            return await request();
+        }
+        catch (error) {
+            if (error instanceof contracts_2.ZLinkFrameworkException &&
+                error.kind === contracts_2.ZLinkFrameworkErrorKind.Unavailable) {
+                this.metrics?.recordLocationStoreError(operation);
+            }
+            throw error;
+        }
+    }
+    confirmedCapacity(key, limits) {
+        const record = this.confirmedCapacities.get(capacityKey(key.meshName, String(key.rid)).value);
+        return record === undefined ? undefined : projectCapacity(limits, record);
+    }
     async readAuthority(key, signal) {
+        return this.observeStore('read', () => this.readAuthorityRequest(key, signal));
+    }
+    async readAuthorityRequest(key, signal) {
         const result = await this.provider.read(authorityKey(key.value), signal);
         if (result.kind === 'missing') {
             return { kind: 'missing', storeNow: result.storeNow };
@@ -87,6 +126,9 @@ 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) {
+        return this.observeStore('read', () => this.listAuthoritiesRequest(prefix, cursor, limit, signal));
+    }
+    async listAuthoritiesRequest(prefix, cursor, limit, signal) {
         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}.`);
         }
@@ -114,6 +156,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         };
     }
     async compareExchangeAuthority(key, expectedStoreVersion, mutation, signal) {
+        return this.observeStore('compare_exchange', () => this.compareExchangeAuthorityRequest(key, expectedStoreVersion, mutation, signal));
+    }
+    async compareExchangeAuthorityRequest(key, expectedStoreVersion, mutation, signal) {
         if (mutation.kind !== 'delete') {
             validatePayloadSize(mutation.payload, 'Authority payload');
         }
@@ -310,6 +355,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async prepareAggregate(request, signal) {
+        return this.observeStore('compare_exchange', () => this.prepareAggregateRequest(request, signal));
+    }
+    async prepareAggregateRequest(request, signal) {
         validateProviderAggregateRequest(request);
         const fence = aggregateFence(request.aggregateId, request.aggregateGeneration);
         const rowKey = aggregateKey(fence);
@@ -550,7 +598,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                         const aggregateRecord = decodeJson(aggregateRaced.value.bytes);
                         if (aggregateRecord.requestFingerprint === fingerprint &&
                             (aggregateRecord.state === 'staging' || aggregateRecord.state === 'prepared')) {
-                            return await this.prepareAggregate(request, signal);
+                            return await this.prepareAggregateRequest(request, signal);
                         }
                     }
                     await this.clearAggregateMarkers(fence, installed, signal);
@@ -622,6 +670,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async commitAggregate(fence, signal) {
+        return this.observeStore('compare_exchange', () => this.commitAggregateRequest(fence, signal));
+    }
+    async commitAggregateRequest(fence, signal) {
         validateAggregateFence(fence);
         return await this.commitAggregateCore(fence, signal);
     }
@@ -804,6 +855,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async abortAggregate(fence, signal) {
+        return this.observeStore('compare_exchange', () => this.abortAggregateRequest(fence, signal));
+    }
+    async abortAggregateRequest(fence, signal) {
         validateAggregateFence(fence);
         const rowKey = aggregateKey(fence);
         for (;;) {
@@ -859,6 +913,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async releaseEndedReservation(key, expectedStoreVersion, signal, request) {
+        return this.observeStore('release', () => this.releaseEndedReservationRequest(key, expectedStoreVersion, signal, request));
+    }
+    async releaseEndedReservationRequest(key, expectedStoreVersion, signal, request) {
         return ((await this.tryReleaseEndedReservation(key, expectedStoreVersion, signal, request)) ===
             'reclaimed');
     }
@@ -881,9 +938,8 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             this.provider.read(descriptorKey, signal),
             this.provider.read(capacityRowKey, signal)
         ]);
-        if (lease.kind === 'found' && lease.value.expiresAt === undefined)
-            throw new Error('Location Store owner lease record is invalid.');
         const ownerLive = sameLiveOwner(lease, snapshot);
+        let members = [];
         if (snapshot.allocation.state === 'active') {
             if (ownerLive)
                 return 'notReclaimable';
@@ -896,42 +952,10 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                         spot.stableType !== request.intent.stableType ||
                         spot.spotId !== request.key.globalId ||
                         spot.activationRecovery !== undefined;
-                if (spot?.kind === 'user_spot') {
-                    // The snapshot starts only after the old owner's lease was found invalid.
-                    for (const prefix of [`${PREFIX}actor:`, `${AUTHORITY_PREIMAGE_PREFIX}actor\0`]) {
-                        membershipSnapshot: for (;;) {
-                            let snapshotHasMember = false;
-                            let cursor;
-                            do {
-                                const page = await this.provider.scan({ prefix, cursor, limit: Stores_1.ZLINK_PROVIDER_MAX_PAGE_SIZE }, signal);
-                                if (page.kind === 'expired')
-                                    continue membershipSnapshot;
-                                for (const item of page.value.items) {
-                                    if (prefix === `${PREFIX}actor:`) {
-                                        const actor = normalizeActor(decodeJson(item.value.bytes).descriptor);
-                                        snapshotHasMember ||=
-                                            actor.spotKind === contracts_1.ZLinkSpotKind.User &&
-                                                String(actor.spotId) === spot.spotId &&
-                                                actor.spotGeneration === snapshot.objectGeneration;
-                                    }
-                                    else {
-                                        const authority = decodeAuthorityRecord(item.value.bytes).snapshot;
-                                        if (authority.allocation.objectKind !== 'actor')
-                                            continue;
-                                        const actor = (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(authority.payload));
-                                        snapshotHasMember ||=
-                                            actor?.currentSpotKind === contracts_1.ZLinkSpotKind.User &&
-                                                actor.currentSpotId === spot.spotId &&
-                                                actor.currentSpotGeneration === snapshot.objectGeneration;
-                                    }
-                                }
-                                cursor = page.value.nextCursor;
-                            } while (cursor !== undefined);
-                            unavailable ||= snapshotHasMember;
-                            break;
-                        }
-                    }
-                }
+                if (spot?.kind === 'user_spot' &&
+                    !unavailable &&
+                    request?.actorRelocationPolicy === 'disabled')
+                    members = await this.readEndedSpotMembers(spot.spotId, snapshot.objectGeneration, signal);
             }
             if (unavailable || request?.actorRelocationPolicy !== 'disabled')
                 throw new contracts_2.ZLinkFrameworkException(contracts_2.ZLinkFrameworkErrorKind.Unavailable, 'Object owner lease is unavailable.');
@@ -943,48 +967,136 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         if (snapshot.allocation.state !== 'active' &&
             (record.aggregate !== undefined || hasRelocationAuthority(snapshot.payload)))
             return 'notReclaimable';
+        // Location runtime §6.1: the authority and every ended-owner member are released in
+        // one conditional batch. Each member is fenced by its row version and the observed
+        // (invalid) state of its own owner lease; member capacity is returned like the Spot's.
+        const conditions = [
+            { kind: 'version', key: rowKey, expected: current.value.version },
+            conditionFor(descriptorKey, descriptor)
+        ];
         const mutations = [
             { kind: 'delete', key: rowKey }
         ];
-        if (capacity.kind === 'found') {
-            const stored = decodeJson(capacity.value.bytes);
-            try {
-                mutations.push({
-                    kind: 'put',
-                    key: capacityRowKey,
-                    bytes: encodeJson({
-                        active: snapshot.allocation.state === 'active'
-                            ? subtractCapacity(stored.active, snapshot.allocation.capacity)
-                            : stored.active,
-                        pending: snapshot.allocation.state === 'reserved'
-                            ? subtractCapacity(stored.pending, snapshot.allocation.capacity)
-                            : stored.pending
-                    })
-                });
+        const owners = new Map([[snapshot.ownerId, lease]]);
+        for (const member of members) {
+            let memberLease = owners.get(member.ownerId);
+            if (memberLease === undefined) {
+                memberLease = await this.provider.read(ownerKey(member.ownerId), signal);
+                owners.set(member.ownerId, memberLease);
+            }
+            if (memberLease.kind === 'found' &&
+                matchesLiveOwnerLease(memberLease, member.ownerId, member.leaseGeneration))
+                throw new contracts_2.ZLinkFrameworkException(contracts_2.ZLinkFrameworkErrorKind.Unavailable, 'User Spot still has a member with a live owner lease.');
+            conditions.push({ kind: 'version', key: member.key, expected: member.version });
+            mutations.push({ kind: 'delete', key: member.key });
+        }
+        for (const [ownerId, read] of owners)
+            conditions.push(conditionFor(ownerKey(ownerId), read));
+        const capacities = new Map([
+            [capacityRowKey.value, { read: capacity }]
+        ]);
+        const releases = [
+            { allocation: snapshot.allocation },
+            ...members.map((member) => ({ allocation: member.allocation }))
+        ];
+        try {
+            for (const { allocation } of releases) {
+                const key = capacityKey(allocation.descriptor.meshName, String(allocation.descriptor.rid));
+                let entry = capacities.get(key.value);
+                if (entry === undefined) {
+                    entry = { read: await this.provider.read(key, signal) };
+                    capacities.set(key.value, entry);
+                }
+                if (entry.read.kind !== 'found')
+                    continue;
+                const stored = entry.next ?? decodeJson(entry.read.value.bytes);
+                entry.next = {
+                    active: allocation.state === 'active'
+                        ? subtractCapacity(stored.active, allocation.capacity)
+                        : stored.active,
+                    pending: allocation.state === 'reserved'
+                        ? subtractCapacity(stored.pending, allocation.capacity)
+                        : stored.pending
+                };
             }
-            catch (error) {
-                if (!(error instanceof contracts_2.ZLinkFrameworkException) ||
-                    error.kind !== contracts_2.ZLinkFrameworkErrorKind.DataLost)
-                    throw error;
-                const observed = await this.provider.read(rowKey, signal);
-                if (observed.kind === 'missing' ||
-                    observed.value.version.value !== current.value.version.value)
-                    return 'conflict';
+        }
+        catch (error) {
+            if (!(error instanceof contracts_2.ZLinkFrameworkException) ||
+                error.kind !== contracts_2.ZLinkFrameworkErrorKind.DataLost)
                 throw error;
+            for (const authority of [{ key: rowKey, version: current.value.version }, ...members]) {
+                const observed = await this.provider.read(authority.key, signal);
+                if (observed.kind === 'missing' || observed.value.version.value !== authority.version.value)
+                    return 'conflict';
             }
+            throw error;
         }
-        const result = await this.provider.write({
-            conditions: [
-                { kind: 'version', key: rowKey, expected: current.value.version },
-                conditionFor(leaseKey, lease),
-                conditionFor(descriptorKey, descriptor),
-                conditionFor(capacityRowKey, capacity)
-            ],
-            mutations
-        }, signal);
+        for (const [key, entry] of capacities) {
+            conditions.push(conditionFor((0, in_memory_provider_location_store_1.storeKey)(key), entry.read));
+            if (entry.next !== undefined)
+                mutations.push({
+                    kind: 'put',
+                    key: (0, in_memory_provider_location_store_1.storeKey)(key),
+                    bytes: encodeJson(entry.next)
+                });
+        }
+        // Every mutated key is also a condition key, so the condition count is the batch's
+        // unique key count. A release beyond the provider bound changes nothing.
+        if (conditions.length > Stores_1.ZLINK_PROVIDER_MAX_WRITE_KEYS)
+            throw new contracts_2.ZLinkFrameworkException(contracts_2.ZLinkFrameworkErrorKind.Unavailable, 'User Spot member release exceeds one Location Store batch.');
+        const result = await this.provider.write({ conditions, mutations }, signal);
         return result.kind === 'applied' ? 'reclaimed' : 'conflict';
     }
+    /**
+     * Reads every Actor membership of one User Spot incarnation from complete snapshot scans
+     * (location runtime §6.1), from Actor authorities alone. An expired snapshot
+     * discards the earlier pages and restarts; a Store failure propagates. A member authority
+     * that is relocating, part of an aggregate or not yet activated keeps the Spot.
+     */
+    async readEndedSpotMembers(spotId, spotGeneration, signal) {
+        membershipSnapshot: for (;;) {
+            const members = [];
+            let cursor;
+            do {
+                const page = await this.provider.scan({
+                    prefix: `${AUTHORITY_PREIMAGE_PREFIX}actor\0`,
+                    cursor,
+                    limit: Stores_1.ZLINK_PROVIDER_MAX_PAGE_SIZE
+                }, signal);
+                if (page.kind === 'expired')
+                    continue membershipSnapshot;
+                for (const item of page.value.items) {
+                    const record = decodeAuthorityRecord(item.value.bytes);
+                    const authority = record.snapshot;
+                    if (authority.allocation.objectKind !== 'actor')
+                        continue;
+                    const actor = (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(authority.payload));
+                    if (actor?.currentSpotKind !== contracts_1.ZLinkSpotKind.User ||
+                        actor.currentSpotId !== spotId ||
+                        actor.currentSpotGeneration !== spotGeneration)
+                        continue;
+                    if (authority.allocation.state !== 'active' ||
+                        record.aggregate !== undefined ||
+                        hasRelocationAuthority(authority.payload) ||
+                        (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)(authority.payload)?.state !== 'ready')
+                        throw new contracts_2.ZLinkFrameworkException(contracts_2.ZLinkFrameworkErrorKind.Unavailable, 'User Spot still has a relocating or unactivated member.');
+                    members.push({
+                        key: item.key,
+                        version: item.value.version,
+                        ownerId: authority.ownerId,
+                        leaseGeneration: authority.ownerLeaseGeneration,
+                        allocation: authority.allocation
+                    });
+                }
+                cursor = page.value.nextCursor;
+            } while (cursor !== undefined);
+            return members;
+        }
+    }
     async reserve(request, signal, deadlineUnixMs) {
+        return this.observeStore('compare_exchange', () => this.reserveRequest(request, signal, deadlineUnixMs));
+    }
+    async reserveRequest(request, signal, deadlineUnixMs) {
         const encodedAuthorityKey = (0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId);
         const reservationId = (0, node_crypto_1.randomUUID)();
         let reclaimVersion;
@@ -1112,6 +1224,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async commit(request, signal, deadlineUnixMs) {
+        return this.observeStore('compare_exchange', () => this.commitRequest(request, signal, deadlineUnixMs));
+    }
+    async commitRequest(request, signal, deadlineUnixMs) {
         const key = (0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId);
         const rowKey = authorityKey(key.value);
         for (;;) {
@@ -1188,6 +1303,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async abort(request, signal, deadlineUnixMs) {
+        return this.observeStore('compare_exchange', () => this.abortRequest(request, signal, deadlineUnixMs));
+    }
+    async abortRequest(request, signal, deadlineUnixMs) {
         const key = (0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId);
         const rowKey = authorityKey(key.value);
         for (;;) {
@@ -1210,12 +1328,6 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 this.provider.read(leaseKey, signal),
                 this.provider.read(capacityRowKey, signal)
             ]);
-            if (leaseRead.kind === 'found' && leaseRead.value.expiresAt === undefined) {
-                // A lease is always written with a positive TTL, so a missing expiry
-                // is a corrupt record. Abort deletes authority state, so refuse
-                // rather than read the absence as expiry.
-                throw new Error('Location Store owner lease record is invalid.');
-            }
             if (liveTargetDescriptor(descriptorRead, leaseRead, request.target) === undefined)
                 return { kind: 'stale' };
             const capacity = capacityRead.kind === 'missing'
@@ -1249,6 +1361,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async completeCreation(request, signal) {
+        return this.observeStore('compare_exchange', () => this.completeCreationRequest(request, signal));
+    }
+    async completeCreationRequest(request, signal) {
         if (request.key.kind !== 'actor') {
             throw new TypeError('completeCreation is reserved for Actor creation.');
         }
@@ -1388,6 +1503,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async readCreationTerminal(operation, signal) {
+        return this.observeStore('read', () => this.readCreationTerminalRequest(operation, signal));
+    }
+    async readCreationTerminalRequest(operation, signal) {
         validateCreationOperation(operation);
         const result = await this.provider.read(creationTerminalKey(operation), signal);
         return result.kind === 'missing'
@@ -1398,6 +1516,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             };
     }
     async claimOwnerLease(ownerId, leaseTtlMs, signal) {
+        return this.observeStore('compare_exchange', () => this.claimOwnerLeaseRequest(ownerId, leaseTtlMs, signal));
+    }
+    async claimOwnerLeaseRequest(ownerId, leaseTtlMs, signal) {
         requireOwnerInput(ownerId, leaseTtlMs);
         for (;;) {
             const [owner, counter] = await Promise.all([
@@ -1445,21 +1566,28 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async readOwnerLease(ownerId, signal) {
+        return this.observeStore('read', () => this.readOwnerLeaseRequest(ownerId, signal));
+    }
+    async readOwnerLeaseRequest(ownerId, signal) {
         const result = await this.provider.read(ownerKey(ownerId), signal);
         if (result.kind === 'missing')
             return { kind: 'missing' };
+        const leaseExpiresAt = requireOwnerLeaseExpiry(result.value);
         const record = decodeOwnerRecord(result.value.bytes);
-        if (record.ownerId !== ownerId || result.value.expiresAt === undefined) {
+        if (record.ownerId !== ownerId) {
             throw new Error('Location Store owner lease record is invalid.');
         }
         return {
             kind: 'found',
             token: { ownerId, leaseGeneration: BigInt(record.leaseGeneration) },
-            leaseExpiresAt: result.value.expiresAt,
+            leaseExpiresAt,
             storeNow: result.value.storeNow
         };
     }
     async renewOwnerLease(token, leaseTtlMs, signal) {
+        return this.observeStore('lease_renew', () => this.renewOwnerLeaseRequest(token, leaseTtlMs, signal));
+    }
+    async renewOwnerLeaseRequest(token, leaseTtlMs, signal) {
         requireOwnerInput(token.ownerId, leaseTtlMs);
         const key = ownerKey(token.ownerId);
         const current = await this.provider.read(key, signal);
@@ -1488,6 +1616,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         };
     }
     async releaseOwnerLease(token, signal) {
+        return this.observeStore('release', () => this.releaseOwnerLeaseRequest(token, signal));
+    }
+    async releaseOwnerLeaseRequest(token, signal) {
         const key = ownerKey(token.ownerId);
         const current = await this.provider.read(key, signal);
         if (current.kind === 'missing')
@@ -1502,9 +1633,18 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         return result.kind === 'applied' ? 'released' : 'stale';
     }
     async updateMeshNode(descriptor, intent, signal) {
+        return this.observeStore('compare_exchange', () => this.updateMeshNodeRequest(descriptor, intent, signal));
+    }
+    async updateMeshNodeRequest(descriptor, intent, signal) {
+        const capacityRowKey = capacityKey(descriptor.meshName, String(descriptor.rid));
+        if (!this.confirmedCapacities.has(capacityRowKey.value))
+            this.confirmedCapacities.set(capacityRowKey.value, undefined);
         return this.updateDescriptor(meshKey(descriptor.meshName, descriptor.rid), descriptor, intent, reviveMeshDescriptor, sameMeshDescriptor, canRenewMesh, signal);
     }
     async removeMeshNode(key, owner, signal) {
+        return this.observeStore('release', () => this.removeMeshNodeRequest(key, owner, signal));
+    }
+    async removeMeshNodeRequest(key, owner, signal) {
         const rowKey = meshKey(key.meshName, key.rid);
         const current = await this.provider.read(rowKey, signal);
         if (current.kind === 'missing')
@@ -1518,9 +1658,14 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             conditions: [{ kind: 'version', key: rowKey, expected: current.value.version }],
             mutations: [{ kind: 'delete', key: rowKey }]
         }, signal);
+        if (result.kind === 'applied')
+            this.confirmedCapacities.delete(capacityKey(key.meshName, String(key.rid)).value);
         return result.kind === 'applied' ? Locations_1.ZLinkLocationWriteStatus.Stored : Locations_1.ZLinkLocationWriteStatus.IgnoredStale;
     }
     async listMeshNodes(meshName, page = {}, signal) {
+        return this.observeStore('read', () => this.listMeshNodesRequest(meshName, page, signal));
+    }
+    async listMeshNodesRequest(meshName, page = {}, signal) {
         const result = await this.provider.scan({
             prefix: meshPrefix(meshName),
             cursor: page.continuationToken === undefined
@@ -1539,30 +1684,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                 : decodeJson(capacityRead.value.bytes);
             return {
                 ...descriptor,
-                populationCapacity: {
-                    actors: {
-                        ...descriptor.populationCapacity.actors,
-                        active: capacity.active.actors,
-                        reserved: capacity.pending.actors
-                    },
-                    spots: {
-                        ...descriptor.populationCapacity.spots,
-                        active: capacity.active.spots,
-                        reserved: capacity.pending.spots
-                    },
-                    spotTypes: descriptor.populationCapacity.spotTypes.map((value) => {
-                        const key = capacityTypeKey({
-                            objectKind: value.objectKind,
-                            stableType: value.stableType,
-                            count: 0
-                        });
-                        return {
-                            ...value,
-                            active: capacity.active.spotTypes[key] ?? 0,
-                            reserved: capacity.pending.spotTypes[key] ?? 0
-                        };
-                    })
-                }
+                populationCapacity: projectCapacity(descriptor.populationCapacity, capacity)
             };
         }));
         return {
@@ -1571,54 +1693,99 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         };
     }
     async updateClientServer(descriptor, intent, signal) {
+        return this.observeStore('compare_exchange', () => this.updateClientServerRequest(descriptor, intent, signal));
+    }
+    async updateClientServerRequest(descriptor, intent, signal) {
         validateClientServerDescriptor(descriptor);
         const normalized = reviveClientServerDescriptor(descriptor);
         return this.updateDescriptor(clientServerKey(normalized.channelName, normalized.serverRid), normalized, intent, reviveClientServerDescriptor, sameClientServerDescriptor, canRenewClientServer, signal);
     }
     async removeClientServer(key, owner, signal) {
+        return this.observeStore('release', () => this.removeClientServerRequest(key, owner, signal));
+    }
+    async removeClientServerRequest(key, owner, signal) {
         return this.removeDescriptor(clientServerKey(key.channelName, key.serverRid), owner, reviveClientServerDescriptor, signal);
     }
     async listClientServers(channelName, page = {}, signal) {
+        return this.observeStore('read', () => this.listClientServersRequest(channelName, page, signal));
+    }
+    async listClientServersRequest(channelName, page = {}, signal) {
         return this.listDescriptors(clientServerPrefix(channelName), page, reviveClientServerDescriptor, signal);
     }
     async updateFanoutPublisher(descriptor, intent, signal) {
+        return this.observeStore('compare_exchange', () => this.updateFanoutPublisherRequest(descriptor, intent, signal));
+    }
+    async updateFanoutPublisherRequest(descriptor, intent, signal) {
         validateFanoutPublisherDescriptor(descriptor);
         const normalized = reviveFanoutDescriptor(descriptor);
         return this.updateDescriptor(fanoutKey(normalized.channelName, normalized.publisherRid), normalized, intent, reviveFanoutDescriptor, sameFanoutDescriptor, canRenewFanout, signal);
     }
     async removeFanoutPublisher(key, owner, signal) {
+        return this.observeStore('release', () => this.removeFanoutPublisherRequest(key, owner, signal));
+    }
+    async removeFanoutPublisherRequest(key, owner, signal) {
         return this.removeDescriptor(fanoutKey(key.channelName, key.publisherRid), owner, reviveFanoutDescriptor, signal);
     }
     async listFanoutPublishers(channelName, page = {}, signal) {
+        return this.observeStore('read', () => this.listFanoutPublishersRequest(channelName, page, signal));
+    }
+    async listFanoutPublishersRequest(channelName, page = {}, signal) {
         return this.listDescriptors(fanoutPrefix(channelName), page, reviveFanoutDescriptor, signal);
     }
     async updateSpot(location, intent, signal) {
+        return this.observeStore('compare_exchange', () => this.updateSpotRequest(location, intent, signal));
+    }
+    async updateSpotRequest(location, intent, signal) {
         return this.updateOwnedLocation(spotKey(location.meshName, String(location.spotId)), normalizeSpot(location), intent, signal);
     }
     async removeSpot(key, owner, signal) {
+        return this.observeStore('release', () => this.removeSpotRequest(key, owner, signal));
+    }
+    async removeSpotRequest(key, owner, signal) {
         return this.removeOwnedLocation(spotKey(key.meshName, String(key.spotId)), owner, signal);
     }
     async resolveSpot(key, signal) {
+        return this.observeStore('read', () => this.resolveSpotRequest(key, signal));
+    }
+    async resolveSpotRequest(key, signal) {
         const value = await this.readOwnedLocation(spotKey(key.meshName, String(key.spotId)), signal);
         return value === undefined ? undefined : normalizeSpot(value);
     }
     async listSpots(filter, page = {}, signal) {
+        return this.observeStore('read', () => this.listSpotsRequest(filter, page, signal));
+    }
+    async listSpotsRequest(filter, page = {}, signal) {
         return this.listOwnedLocations(`${PREFIX}spot:`, page, normalizeSpot, (value) => matchesSpot(value, filter), signal);
     }
     async updateActor(location, intent, signal) {
+        return this.observeStore('compare_exchange', () => this.updateActorRequest(location, intent, signal));
+    }
+    async updateActorRequest(location, intent, signal) {
         return this.updateOwnedLocation(actorKey(location.meshName, location.actorId), normalizeActor(location), intent, signal, location);
     }
     async removeActor(key, owner, signal) {
+        return this.observeStore('release', () => this.removeActorRequest(key, owner, signal));
+    }
+    async removeActorRequest(key, owner, signal) {
         return this.removeOwnedLocation(actorKey(key.meshName, key.actorId), owner, signal);
     }
     async resolveActor(key, signal) {
+        return this.observeStore('read', () => this.resolveActorRequest(key, signal));
+    }
+    async resolveActorRequest(key, signal) {
         const value = await this.readOwnedLocation(actorKey(key.meshName, key.actorId), signal);
         return value === undefined ? undefined : normalizeActor(value);
     }
     async listActors(filter, page = {}, signal) {
+        return this.observeStore('read', () => this.listActorsRequest(filter, page, signal));
+    }
+    async listActorsRequest(filter, page = {}, signal) {
         return this.listOwnedLocations(`${PREFIX}actor:`, page, normalizeActor, (value) => matchesActor(value, filter), signal);
     }
     async updateRoute(location, intent, signal) {
+        return this.observeStore('compare_exchange', () => this.updateRouteRequest(location, intent, signal));
+    }
+    async updateRouteRequest(location, intent, signal) {
         const rowKey = routeKey(String(location.routeKind), location.routeKey);
         const normalized = normalizeRoute(location);
         const current = await this.provider.read(rowKey, signal);
@@ -1673,6 +1840,9 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             : rejected(result.storeNow);
     }
     async removeRoute(key, owner, signal) {
+        return this.observeStore('release', () => this.removeRouteRequest(key, owner, signal));
+    }
+    async removeRouteRequest(key, owner, signal) {
         const rowKey = routeKey(String(key.routeKind), key.routeKey);
         const current = await this.provider.read(rowKey, signal);
         if (current.kind === 'missing')
@@ -1699,13 +1869,22 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             : rejected(result.storeNow);
     }
     async resolveRoute(key, signal) {
+        return this.observeStore('read', () => this.resolveRouteRequest(key, signal));
+    }
+    async resolveRouteRequest(key, signal) {
         const value = await this.readOwnedLocation(routeKey(String(key.routeKind), key.routeKey), signal);
         return value === undefined ? undefined : normalizeRoute(value);
     }
     async listRoutes(filter, page = {}, signal) {
+        return this.observeStore('read', () => this.listRoutesRequest(filter, page, signal));
+    }
+    async listRoutesRequest(filter, page = {}, signal) {
         return this.listOwnedLocations(`${PREFIX}route:`, page, normalizeRoute, (value) => matchesRoute(value, filter), signal);
     }
     async removeAllByOwner(owner, signal) {
+        return this.observeStore('release', () => this.removeAllByOwnerRequest(owner, signal));
+    }
+    async removeAllByOwnerRequest(owner, signal) {
         const leaseKey = ownerKey(owner.ownerId);
         const lease = await this.provider.read(leaseKey, signal);
         if (liveOwnerLeaseGeneration(lease) !== owner.leaseGeneration)
@@ -1792,7 +1971,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             const encodedAuthority = authorityContractValueFromPreimage(candidate.key.value);
             const identity = (0, authority_key_codec_1.decodeAuthorityKey)({ value: encodedAuthority });
             if (record.snapshot.allocation.state === 'active') {
-                const result = await this.compareExchangeAuthority({ value: encodedAuthority }, current.value.version, { kind: 'delete' }, signal);
+                const result = await this.compareExchangeAuthorityRequest({ value: encodedAuthority }, current.value.version, { kind: 'delete' }, signal);
                 if (result.kind === 'deleted')
                     removed += 1n;
                 continue;
@@ -1800,7 +1979,7 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             const reservationId = record.snapshot.pendingCreation?.reservationId;
             if (reservationId === undefined)
                 continue;
-            const aborted = await this.abort({
+            const aborted = await this.abortRequest({
                 key: identity,
                 reservationId,
                 expectedStoreVersion: current.value.version.value,
@@ -1922,10 +2101,23 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             const rowCondition = currentRow.kind === 'found'
                 ? { kind: 'version', key: rowKey, expected: currentRow.value.version }
                 : { kind: 'missing', key: rowKey };
-            const result = await this.provider.write({
-                conditions: [leaseValueCondition(leaseKey, { ownerId, leaseGeneration }), rowCondition],
-                mutations: [{ kind: 'put', key: rowKey, bytes: encodedDescriptor }]
-            }, signal);
+            let result;
+            try {
+                result = await this.provider.write({
+                    conditions: [leaseValueCondition(leaseKey, { ownerId, leaseGeneration }), rowCondition],
+                    mutations: [{ kind: 'put', key: rowKey, bytes: encodedDescriptor }]
+                }, signal);
+            }
+            catch (failure) {
+                // Location runtime §10: the Store may have applied a write whose result
+                // was lost. Re-read the same key; the same bytes confirm the write.
+                const confirmed = await this.provider.read(rowKey, signal).catch(() => undefined);
+                if (confirmed?.kind === 'found' &&
+                    Buffer.from(confirmed.value.bytes).equals(Buffer.from(encodedDescriptor))) {
+                    return { status: Locations_1.ZLinkLocationWriteStatus.Stored, generation, updatedAt: confirmed.value.storeNow };
+                }
+                throw failure;
+            }
             if (result.kind === 'applied') {
                 return { status: Locations_1.ZLinkLocationWriteStatus.Stored, generation, updatedAt: result.storeNow };
             }
@@ -2671,6 +2863,11 @@ function reviveCanonical(value, key = '') {
     }
     return value;
 }
+function requireOwnerLeaseExpiry(value) {
+    if (value.expiresAt === undefined)
+        throw new Error('Location Store owner lease record is invalid.');
+    return value.expiresAt;
+}
 function decodeOwnerRecord(bytes) {
     const record = decodeJson(bytes);
     requireRecordVersion(record, 'owner lease');
@@ -2710,7 +2907,7 @@ function canonicalDescriptor(descriptor) {
     if ('serverRid' in descriptor)
         return {
             channelName: descriptor.channelName,
-            serverRoutingIdHex: (0, routing_id_1.encodeRoutingIdStorageHex)(descriptor.serverRid),
+            serverRoutingIdHex: (0, routing_id_2.encodeRoutingIdStorageHex)(descriptor.serverRid),
             lifecycleGeneration: descriptor.lifecycleGeneration.toString(),
             descriptorRevision: descriptor.descriptorRevision.toString(),
             endpoint: descriptor.endpoint,
@@ -2724,7 +2921,7 @@ function canonicalDescriptor(descriptor) {
     const publisher = descriptor;
     return {
         channelName: publisher.channelName,
-        publisherRoutingIdHex: (0, routing_id_1.encodeRoutingIdStorageHex)(publisher.publisherRid),
+        publisherRoutingIdHex: (0, routing_id_2.encodeRoutingIdStorageHex)(publisher.publisherRid),
         lifecycleGeneration: publisher.lifecycleGeneration.toString(),
         descriptorRevision: publisher.descriptorRevision.toString(),
         endpoint: publisher.endpoint,
@@ -2738,7 +2935,7 @@ function canonicalDescriptor(descriptor) {
 function canonicalMeshDescriptor(descriptor) {
     return {
         meshName: descriptor.meshName,
-        routingIdHex: (0, routing_id_1.encodeRoutingIdStorageHex)(descriptor.rid),
+        routingIdHex: (0, routing_id_2.encodeRoutingIdStorageHex)(descriptor.rid),
         lifecycleGeneration: descriptor.lifecycleGeneration.toString(),
         descriptorRevision: descriptor.descriptorRevision.toString(),
         endpoint: descriptor.endpoint,
@@ -2839,7 +3036,7 @@ function encodeAuthorityRecord(record) {
             stableType: allocation.stableType,
             descriptor: {
                 meshName: allocation.descriptor.meshName,
-                routingIdHex: (0, routing_id_1.encodeRoutingIdStorageHex)(allocation.descriptor.rid)
+                routingIdHex: (0, routing_id_2.encodeRoutingIdStorageHex)(allocation.descriptor.rid)
             },
             descriptorLifecycleGeneration: allocation.descriptorLifecycleGeneration.toString(),
             capacity: canonicalAuthorityCapacity(allocation.capacity)
@@ -2890,7 +3087,7 @@ function decodeAuthorityRecord(bytes) {
                 stableType: String(allocation.stableType),
                 descriptor: {
                     meshName: String(descriptor.meshName),
-                    rid: (0, routing_id_1.decodeRoutingId)(String(descriptor.routingIdHex), descriptor.routingIdHex)
+                    rid: (0, routing_id_2.decodeRoutingId)(String(descriptor.routingIdHex), descriptor.routingIdHex)
                 },
                 descriptorLifecycleGeneration: BigInt(String(allocation.descriptorLifecycleGeneration)),
                 capacity: {
@@ -3047,20 +3244,22 @@ function authoritySnapshot(snapshot, storeVersion, storeNow) {
     };
 }
 function liveTargetDescriptor(descriptorRead, leaseRead, target) {
-    if (descriptorRead.kind === 'missing' || leaseRead.kind === 'missing')
+    if (leaseRead.kind === 'missing')
+        return undefined;
+    const leaseExpiresAt = requireOwnerLeaseExpiry(leaseRead.value);
+    if (descriptorRead.kind === 'missing')
         return undefined;
     const descriptor = reviveMeshDescriptor(decodeCanonicalDescriptorRecord(descriptorRead.value.bytes).descriptor);
     const lease = decodeOwnerRecord(leaseRead.value.bytes);
     return descriptor.meshName === target.meshName &&
-        String(descriptor.rid) === String(target.nodeRid) &&
+        (0, routing_id_1.routingIdsEqual)(descriptor.rid, (0, routing_id_1.toBackendRoutingId)(target.nodeRid)) &&
         descriptor.lifecycleGeneration === target.nodeLifecycleGeneration &&
         descriptor.ownerId === target.owner.ownerId &&
         descriptor.leaseGeneration === target.owner.leaseGeneration &&
         descriptor.objectRole === contracts_2.ZLinkObjectRole.Server &&
         lease.ownerId === target.owner.ownerId &&
         BigInt(lease.leaseGeneration) === target.owner.leaseGeneration &&
-        leaseRead.value.expiresAt !== undefined &&
-        leaseRead.value.expiresAt.getTime() > leaseRead.value.storeNow.getTime()
+        leaseExpiresAt.getTime() > leaseRead.value.storeNow.getTime()
         ? descriptor
         : undefined;
 }
@@ -3148,7 +3347,7 @@ function sameCapacityVector(left, right) {
 }
 function sameCreationTarget(snapshot, target) {
     return (snapshot.allocation.descriptor.meshName === target.meshName &&
-        String(snapshot.allocation.descriptor.rid) === String(target.nodeRid) &&
+        (0, routing_id_1.routingIdsEqual)(snapshot.allocation.descriptor.rid, target.nodeRid) &&
         snapshot.allocation.descriptorLifecycleGeneration === target.nodeLifecycleGeneration &&
         snapshot.ownerId === target.owner.ownerId &&
         snapshot.ownerLeaseGeneration === target.owner.leaseGeneration);
@@ -3163,8 +3362,7 @@ function sameLiveOwner(lease, snapshot) {
     return matchesLiveOwnerLease(lease, snapshot.ownerId, snapshot.ownerLeaseGeneration);
 }
 function matchesLiveOwnerLease(lease, ownerId, leaseGeneration) {
-    if (lease.value.expiresAt === undefined ||
-        lease.value.expiresAt.getTime() <= lease.value.storeNow.getTime()) {
+    if (requireOwnerLeaseExpiry(lease.value).getTime() <= lease.value.storeNow.getTime()) {
         return false;
     }
     const owner = decodeOwnerRecord(lease.value.bytes);
@@ -3177,9 +3375,9 @@ function sameDescriptorPredecessor(expected, current) {
     return Buffer.from(expected.value.bytes).equals(Buffer.from(current.value.bytes));
 }
 function liveOwnerLeaseGeneration(lease) {
-    if (lease.kind === 'missing' ||
-        lease.value.expiresAt === undefined ||
-        lease.value.expiresAt.getTime() <= lease.value.storeNow.getTime()) {
+    if (lease.kind === 'missing')
+        return undefined;
+    if (requireOwnerLeaseExpiry(lease.value).getTime() <= lease.value.storeNow.getTime()) {
         return undefined;
     }
     return BigInt(decodeOwnerRecord(lease.value.bytes).leaseGeneration);
@@ -3199,16 +3397,13 @@ function canTakeOverStoredLocation(intent, currentOwnerId, currentLeaseGeneratio
         currentLeaseGeneration !== nextLeaseGeneration &&
         liveLeaseGeneration === nextLeaseGeneration);
 }
-function persistMeshDescriptor(descriptor) {
-    return descriptor;
-}
 function reviveMeshDescriptor(descriptor) {
     const value = descriptor;
     if ('routingIdHex' in value) {
         const capacity = value.capacity;
         return {
             meshName: String(value.meshName),
-            rid: (0, routing_id_1.decodeRoutingId)(String(value.routingIdHex), value.routingIdHex),
+            rid: (0, routing_id_2.decodeRoutingId)(String(value.routingIdHex), value.routingIdHex),
             lifecycleGeneration: BigInt(String(value.lifecycleGeneration)),
             descriptorRevision: BigInt(String(value.descriptorRevision)),
             endpoint: String(value.endpoint),
@@ -3240,7 +3435,7 @@ function reviveClientServerDescriptor(descriptor) {
     if ('serverRoutingIdHex' in value) {
         return {
             channelName: String(value.channelName),
-            serverRid: (0, routing_id_1.decodeRoutingId)(String(value.serverRoutingIdHex), value.serverRoutingIdHex),
+            serverRid: (0, routing_id_2.decodeRoutingId)(String(value.serverRoutingIdHex), value.serverRoutingIdHex),
             lifecycleGeneration: BigInt(String(value.lifecycleGeneration)),
             descriptorRevision: BigInt(String(value.descriptorRevision)),
             endpoint: String(value.endpoint),
@@ -3263,7 +3458,7 @@ function reviveFanoutDescriptor(descriptor) {
     if ('publisherRoutingIdHex' in value) {
         return {
             channelName: String(value.channelName),
-            publisherRid: (0, routing_id_1.decodeRoutingId)(String(value.publisherRoutingIdHex), value.publisherRoutingIdHex),
+            publisherRid: (0, routing_id_2.decodeRoutingId)(String(value.publisherRoutingIdHex), value.publisherRoutingIdHex),
             lifecycleGeneration: BigInt(String(value.lifecycleGeneration)),
             descriptorRevision: BigInt(String(value.descriptorRevision)),
             endpoint: String(value.endpoint),
@@ -3314,19 +3509,19 @@ function normalizeRoute(value) {
 function matchesSpot(value, filter) {
     return ((filter.meshName === undefined || value.meshName === filter.meshName) &&
         (filter.spotType === undefined || value.spotType === filter.spotType) &&
-        (filter.nodeRid === undefined || String(value.ownerNodeRid) === String(filter.nodeRid)) &&
+        (filter.nodeRid === undefined || (0, routing_id_1.routingIdsEqual)(value.ownerNodeRid, filter.nodeRid)) &&
         (filter.spotKind === undefined || value.spotKind === filter.spotKind));
 }
 function matchesActor(value, filter) {
     return ((filter.actorType === undefined || value.actorType === filter.actorType) &&
-        (filter.nodeRid === undefined || String(value.ownerNodeRid) === String(filter.nodeRid)) &&
+        (filter.nodeRid === undefined || (0, routing_id_1.routingIdsEqual)(value.ownerNodeRid, filter.nodeRid)) &&
         (filter.spotId === undefined || String(value.spotId) === String(filter.spotId)) &&
         (filter.locationKind === undefined || value.spotKind === filter.locationKind));
 }
 function matchesRoute(value, filter) {
     return ((filter.routeKind === undefined || value.routeKind === filter.routeKind) &&
         (filter.ownerNodeRid === undefined ||
-            String(value.ownerNodeRid) === String(filter.ownerNodeRid)) &&
+            (0, routing_id_1.routingIdsEqual)(value.ownerNodeRid, filter.ownerNodeRid)) &&
         (filter.ownerId === undefined || value.ownerId === filter.ownerId));
 }
 function locationOwnerGeneration(value) {
@@ -3343,8 +3538,11 @@ function descriptorOwnerLeaseGeneration(value) {
     }
     return undefined;
 }
+// Location runtime §10: a write whose result was lost is confirmed by reading
+// the same key. The stored row already is this write when it differs only in
+// the time the Store stamped, as for every other descriptor kind.
 function sameMeshDescriptor(left, right) {
-    return Buffer.from(encodeJson(persistMeshDescriptor(left))).equals(Buffer.from(encodeJson(persistMeshDescriptor(right))));
+    return descriptorFingerprint(left, ['updatedAt']) === descriptorFingerprint(right, ['updatedAt']);
 }
 function sameClientServerDescriptor(left, right) {
     return descriptorFingerprint(left, ['updatedAt']) === descriptorFingerprint(right, ['updatedAt']);
@@ -3446,7 +3644,7 @@ function requireOwnerInput(ownerId, leaseTtlMs) {
 function throwIfOperationExpired(signal, deadlineUnixMs) {
     signal?.throwIfAborted();
     if (deadlineUnixMs !== undefined && Date.now() >= Number(deadlineUnixMs)) {
-        throw new DOMException('Operation deadline exceeded.', 'TimeoutError');
+        throw new contracts_2.ZLinkFrameworkException(contracts_2.ZLinkFrameworkErrorKind.DeadlineExceeded, 'Operation deadline exceeded.');
     }
 }
 // Store SPI §6: preserve caller failures and classify provider failures once.
@@ -3458,3 +3656,29 @@ function locationStoreProviderFailure(error, signal) {
         return error;
     return new contracts_2.ZLinkFrameworkException(contracts_2.ZLinkFrameworkErrorKind.Unavailable, 'Location Store provider is unavailable.', error);
 }
+function projectCapacity(limits, capacity) {
+    return {
+        actors: {
+            ...limits.actors,
+            active: capacity.active.actors,
+            reserved: capacity.pending.actors
+        },
+        spots: {
+            ...limits.spots,
+            active: capacity.active.spots,
+            reserved: capacity.pending.spots
+        },
+        spotTypes: limits.spotTypes.map((value) => {
+            const key = capacityTypeKey({
+                objectKind: value.objectKind,
+                stableType: value.stableType,
+                count: 0
+            });
+            return {
+                ...value,
+                active: capacity.active.spotTypes[key] ?? 0,
+                reserved: capacity.pending.spotTypes[key] ?? 0
+            };
+        })
+    };
+}