@zlink-systems/framework 0.10.0

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

@@ -0,0 +1,1008 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkInMemoryLocationStore = void 0;
+const internal_location_contracts_1 = require("./internal-location-contracts");
+const in_memory_authority_store_1 = require("./in-memory-authority-store");
+const authority_key_codec_1 = require("./authority-key-codec");
+const key_codec_1 = require("./key-codec");
+const location_store_integration_1 = require("../../location-store-integration");
+class ZLinkInMemoryLocationStore {
+    now;
+    leases = new Map();
+    meshNodes = new RowTable();
+    clientServers = new RowTable();
+    fanoutPublishers = new RowTable();
+    peers = new RowTable();
+    spots = new RowTable();
+    actors = new RowTable();
+    routes = new RowTable();
+    stamps = new Map();
+    actorTransfers = new Map();
+    entrySpotClaims = new Map();
+    ownerLeaseGeneration = 0n;
+    authority;
+    constructor(now = () => new Date()) {
+        this.now = now;
+        this.authority = new in_memory_authority_store_1.ZLinkInMemoryAuthorityStore({
+            isTargetLive: (key, lifecycleGeneration, owner) => {
+                const descriptor = this.meshNodes.rows.get(meshNodeKey(key.meshName, key.rid));
+                const lease = this.leases.get(owner.ownerId);
+                return descriptor !== undefined
+                    && descriptor.lifecycleGeneration === lifecycleGeneration
+                    && descriptor.ownerId === owner.ownerId
+                    && descriptor.leaseGeneration === owner.leaseGeneration
+                    && descriptor.objectRole === internal_location_contracts_1.ZLinkObjectRole.Server
+                    && descriptor.state === internal_location_contracts_1.ZLinkFrameworkRuntimeState.Serving
+                    && lease !== undefined
+                    && lease.token.leaseGeneration === owner.leaseGeneration
+                    && lease.leaseExpiresAt.getTime() > this.now().getTime();
+            },
+            placementCapacityAvailable: (key, requested, reserved, active) => {
+                const descriptor = this.meshNodes.rows.get(meshNodeKey(key.meshName, key.rid));
+                if (descriptor === undefined)
+                    return false;
+                const spotType = requested.spotType;
+                const typeCapacity = spotType === undefined
+                    ? undefined
+                    : descriptor.populationCapacity.spotTypes.find(candidate => candidate.objectKind === spotType.objectKind
+                        && candidate.stableType === spotType.stableType);
+                return active.actors + reserved.actors + requested.actors
+                    <= descriptor.populationCapacity.actors.limit
+                    && active.spots + reserved.spots + requested.spots
+                        <= descriptor.populationCapacity.spots.limit
+                    && (spotType === undefined
+                        || typeCapacity !== undefined
+                            && (typeCapacity.limit === 0
+                                || (active.spotType?.count ?? 0)
+                                    + (reserved.spotType?.count ?? 0)
+                                    + spotType.count <= typeCapacity.limit));
+            },
+            identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey)
+        }, now);
+    }
+    async readAuthority(key, signal) {
+        return this.authority.readAuthority(key, signal);
+    }
+    async compareExchangeAuthority(key, expectedStoreVersion, mutation, signal) {
+        return this.authority.compareExchangeAuthority(key, expectedStoreVersion, mutation, signal);
+    }
+    async listAuthorities(prefix, cursor, limit, signal) {
+        return this.authority.listAuthorities(prefix, cursor, limit, signal);
+    }
+    async reserve(request, signal) {
+        return this.authority.reserve(request, signal);
+    }
+    async commit(request, signal) {
+        return this.authority.commit(request, signal);
+    }
+    async completeCreation(request, signal) {
+        return this.authority.completeCreation(request, signal);
+    }
+    async readCreationTerminal(operation, signal) {
+        return this.authority.readCreationTerminal(operation, signal);
+    }
+    async abort(request, signal) {
+        return this.authority.abort(request, signal);
+    }
+    async prepareAggregate(request, signal) {
+        return this.authority.prepareAggregate(request, signal);
+    }
+    async commitAggregate(fence, signal) {
+        return this.authority.commitAggregate(fence, signal);
+    }
+    async abortAggregate(fence, signal) {
+        return this.authority.abortAggregate(fence, signal);
+    }
+    async updateMeshNode(descriptor, intent) {
+        validateMeshNodeDescriptor(descriptor);
+        const key = meshNodeKey(descriptor.meshName, descriptor.rid);
+        const current = this.meshNodes.rows.get(key);
+        const lease = this.leases.get(descriptor.ownerId);
+        const updatedAt = this.now();
+        if (lease === undefined
+            || lease.token.leaseGeneration !== descriptor.leaseGeneration
+            || lease.leaseExpiresAt.getTime() <= updatedAt.getTime()) {
+            return rejectedConflict();
+        }
+        if (current === undefined) {
+            if (intent !== internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim
+                && intent !== internal_location_contracts_1.ZLinkLocationWriteIntent.Takeover)
+                return ignoredStale();
+            if (!this.claimEntrySpotIdentity(descriptor, key))
+                return rejectedConflict();
+            this.meshNodes.rows.set(key, { ...descriptor, updatedAt });
+            this.meshNodes.generations.set(key, 1n);
+            this.bump(internal_location_contracts_1.ZLinkLocationKind.Peer, descriptor.meshName);
+            return stored(1n, updatedAt);
+        }
+        const currentLease = this.leases.get(current.ownerId);
+        if (canTakeOver(current.ownerId, current.leaseGeneration, currentLease, descriptor.ownerId, descriptor.leaseGeneration, intent, updatedAt)) {
+            if (!this.claimEntrySpotIdentity(descriptor, key))
+                return rejectedConflict();
+            this.releaseEntrySpotIdentity(current);
+            const next = (this.meshNodes.generations.get(key) ?? 0n) + 1n;
+            this.meshNodes.rows.set(key, { ...descriptor, updatedAt });
+            this.meshNodes.generations.set(key, next);
+            this.bump(internal_location_contracts_1.ZLinkLocationKind.Peer, descriptor.meshName);
+            return stored(next, updatedAt);
+        }
+        if (current.ownerId === descriptor.ownerId
+            && current.leaseGeneration === descriptor.leaseGeneration
+            && current.lifecycleGeneration === descriptor.lifecycleGeneration
+            && descriptor.descriptorRevision === current.descriptorRevision
+            && meshNodeDescriptorFingerprint(current) === meshNodeDescriptorFingerprint(descriptor)) {
+            return stored(this.meshNodes.generations.get(key) ?? 1n, current.updatedAt);
+        }
+        if (current.ownerId !== descriptor.ownerId
+            || current.leaseGeneration !== descriptor.leaseGeneration
+            || current.lifecycleGeneration !== descriptor.lifecycleGeneration
+            || descriptor.descriptorRevision <= current.descriptorRevision
+            || meshNodeImmutableFingerprint(current) !== meshNodeImmutableFingerprint(descriptor)) {
+            return ignoredStale();
+        }
+        this.meshNodes.rows.set(key, { ...descriptor, updatedAt });
+        this.bump(internal_location_contracts_1.ZLinkLocationKind.Peer, descriptor.meshName);
+        return stored(this.meshNodes.generations.get(key) ?? 1n, updatedAt);
+    }
+    async removeMeshNode(key, owner) {
+        const encoded = meshNodeKey(key.meshName, key.rid);
+        const current = this.meshNodes.rows.get(encoded);
+        if (current === undefined
+            || current.ownerId !== owner.ownerId
+            || current.leaseGeneration !== owner.leaseGeneration) {
+            return internal_location_contracts_1.ZLinkLocationWriteStatus.IgnoredStale;
+        }
+        this.meshNodes.rows.delete(encoded);
+        this.releaseEntrySpotIdentity(current);
+        this.bump(internal_location_contracts_1.ZLinkLocationKind.Peer, key.meshName);
+        return internal_location_contracts_1.ZLinkLocationWriteStatus.Stored;
+    }
+    async listMeshNodes(meshName, page, signal) {
+        signal?.throwIfAborted();
+        const rows = [...this.meshNodes.rows.values()]
+            .filter((row) => row.meshName === meshName)
+            .map((row) => {
+            const descriptor = { meshName: row.meshName, rid: row.rid };
+            const objectCapabilities = row.objectCapabilities.map((capability) => {
+                return { ...capability };
+            });
+            const spotTypes = row.populationCapacity.spotTypes.map(capacity => {
+                const usage = this.authority.capacityUsage(descriptor, row.lifecycleGeneration, capacity.objectKind, capacity.stableType);
+                return { ...capacity, ...usage };
+            });
+            const actors = this.authority.capacityUsage(descriptor, row.lifecycleGeneration, 'actor', '');
+            const spots = this.authority.capacityUsage(descriptor, row.lifecycleGeneration, 'spot', '');
+            return {
+                ...row,
+                objectCapabilities,
+                populationCapacity: {
+                    actors: { ...row.populationCapacity.actors, ...actors },
+                    spots: { ...row.populationCapacity.spots, ...spots },
+                    spotTypes
+                }
+            };
+        });
+        return pageValues(rows, page ?? {}, row => meshNodeKey(row.meshName, row.rid));
+    }
+    async updateClientServer(descriptor, intent, signal) {
+        signal?.throwIfAborted();
+        validateClientServerDescriptor(descriptor);
+        const key = clientServerKey(descriptor.channelName, descriptor.serverRid);
+        const current = this.clientServers.rows.get(key);
+        const lease = this.leases.get(descriptor.ownerId);
+        const updatedAt = this.now();
+        if (lease === undefined
+            || lease.token.leaseGeneration !== descriptor.leaseGeneration
+            || lease.leaseExpiresAt.getTime() <= updatedAt.getTime()) {
+            return rejectedConflict();
+        }
+        if (current === undefined) {
+            if (intent !== internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim
+                && intent !== internal_location_contracts_1.ZLinkLocationWriteIntent.Takeover)
+                return ignoredStale();
+            const generation = (this.clientServers.generations.get(key) ?? 0n) + 1n;
+            this.clientServers.rows.set(key, { ...descriptor, updatedAt });
+            this.clientServers.generations.set(key, generation);
+            this.bump(internal_location_contracts_1.ZLinkLocationKind.ClientServer, descriptor.channelName);
+            return stored(generation, updatedAt);
+        }
+        const currentLease = this.leases.get(current.ownerId);
+        if (canTakeOver(current.ownerId, current.leaseGeneration, currentLease, descriptor.ownerId, descriptor.leaseGeneration, intent, updatedAt)) {
+            const generation = (this.clientServers.generations.get(key) ?? 0n) + 1n;
+            this.clientServers.rows.set(key, { ...descriptor, updatedAt });
+            this.clientServers.generations.set(key, generation);
+            this.bump(internal_location_contracts_1.ZLinkLocationKind.ClientServer, descriptor.channelName);
+            return stored(generation, updatedAt);
+        }
+        if (clientServerDescriptorFingerprint(current) === clientServerDescriptorFingerprint(descriptor)) {
+            return stored(this.clientServers.generations.get(key) ?? 1n, current.updatedAt);
+        }
+        if (current.ownerId !== descriptor.ownerId
+            || current.leaseGeneration !== descriptor.leaseGeneration
+            || current.lifecycleGeneration !== descriptor.lifecycleGeneration
+            || descriptor.descriptorRevision <= current.descriptorRevision
+            || clientServerImmutableFingerprint(current) !== clientServerImmutableFingerprint(descriptor)) {
+            return ignoredStale();
+        }
+        this.clientServers.rows.set(key, { ...descriptor, updatedAt });
+        this.bump(internal_location_contracts_1.ZLinkLocationKind.ClientServer, descriptor.channelName);
+        return stored(this.clientServers.generations.get(key) ?? 1n, updatedAt);
+    }
+    async removeClientServer(key, owner, signal) {
+        signal?.throwIfAborted();
+        const encoded = clientServerKey(key.channelName, key.serverRid);
+        const current = this.clientServers.rows.get(encoded);
+        if (current === undefined
+            || current.ownerId !== owner.ownerId
+            || current.leaseGeneration !== owner.leaseGeneration) {
+            return internal_location_contracts_1.ZLinkLocationWriteStatus.IgnoredStale;
+        }
+        this.clientServers.rows.delete(encoded);
+        this.bump(internal_location_contracts_1.ZLinkLocationKind.ClientServer, key.channelName);
+        return internal_location_contracts_1.ZLinkLocationWriteStatus.Stored;
+    }
+    async listClientServers(channelName, page = {}, signal) {
+        signal?.throwIfAborted();
+        return pageRows(this.clientServers, (row) => row.channelName === channelName, page);
+    }
+    async updateFanoutPublisher(descriptor, intent, signal) {
+        signal?.throwIfAborted();
+        validateFanoutPublisherDescriptor(descriptor);
+        const key = fanoutPublisherKey(descriptor.channelName, descriptor.publisherRid);
+        const current = this.fanoutPublishers.rows.get(key);
+        const lease = this.leases.get(descriptor.ownerId);
+        const updatedAt = this.now();
+        if (lease === undefined
+            || lease.token.leaseGeneration !== descriptor.leaseGeneration
+            || lease.leaseExpiresAt.getTime() <= updatedAt.getTime()) {
+            return rejectedConflict();
+        }
+        if (current === undefined) {
+            if (intent !== internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim
+                && intent !== internal_location_contracts_1.ZLinkLocationWriteIntent.Takeover)
+                return ignoredStale();
+            const generation = (this.fanoutPublishers.generations.get(key) ?? 0n) + 1n;
+            this.fanoutPublishers.rows.set(key, { ...descriptor, updatedAt });
+            this.fanoutPublishers.generations.set(key, generation);
+            return stored(generation, updatedAt);
+        }
+        const currentLease = this.leases.get(current.ownerId);
+        if (canTakeOver(current.ownerId, current.leaseGeneration, currentLease, descriptor.ownerId, descriptor.leaseGeneration, intent, updatedAt)) {
+            const generation = (this.fanoutPublishers.generations.get(key) ?? 0n) + 1n;
+            this.fanoutPublishers.rows.set(key, { ...descriptor, updatedAt });
+            this.fanoutPublishers.generations.set(key, generation);
+            return stored(generation, updatedAt);
+        }
+        if (fanoutPublisherDescriptorFingerprint(current)
+            === fanoutPublisherDescriptorFingerprint(descriptor)) {
+            return stored(this.fanoutPublishers.generations.get(key) ?? 1n, current.updatedAt);
+        }
+        if (current.ownerId !== descriptor.ownerId
+            || current.leaseGeneration !== descriptor.leaseGeneration
+            || current.lifecycleGeneration !== descriptor.lifecycleGeneration
+            || descriptor.descriptorRevision <= current.descriptorRevision
+            || fanoutPublisherImmutableFingerprint(current)
+                !== fanoutPublisherImmutableFingerprint(descriptor)) {
+            return ignoredStale();
+        }
+        this.fanoutPublishers.rows.set(key, { ...descriptor, updatedAt });
+        return stored(this.fanoutPublishers.generations.get(key) ?? 1n, updatedAt);
+    }
+    async removeFanoutPublisher(key, owner, signal) {
+        signal?.throwIfAborted();
+        const encoded = fanoutPublisherKey(key.channelName, key.publisherRid);
+        const current = this.fanoutPublishers.rows.get(encoded);
+        if (current === undefined
+            || current.ownerId !== owner.ownerId
+            || current.leaseGeneration !== owner.leaseGeneration) {
+            return internal_location_contracts_1.ZLinkLocationWriteStatus.IgnoredStale;
+        }
+        this.fanoutPublishers.rows.delete(encoded);
+        return internal_location_contracts_1.ZLinkLocationWriteStatus.Stored;
+    }
+    async listFanoutPublishers(channelName, page = {}, signal) {
+        signal?.throwIfAborted();
+        const storeNow = this.now();
+        return pageRows(this.fanoutPublishers, (row) => row.channelName === channelName && this.isOwnerLive(row.ownerId, storeNow), page);
+    }
+    async updatePeer(peer, intent) {
+        return this.write(this.peers, key_codec_1.ZLinkLocationKeyCodec.encodePeerKey({
+            autoConnectType: peer.autoConnectType,
+            meshName: peer.meshName,
+            role: peer.role,
+            nodeRid: peer.nodeRid,
+            endpoint: peer.endpoint
+        }), peer, intent, peer.ownerId, peer.generation, (row) => row.ownerId, (row) => row.generation, (row, generation, updatedAt) => ({ ...row, generation, updatedAt }), internal_location_contracts_1.ZLinkLocationKind.Peer, peer.meshName);
+    }
+    async removePeer(key, owner) {
+        return this.remove(this.peers, key_codec_1.ZLinkLocationKeyCodec.encodePeerKey(key), owner, (row) => row.ownerId, (row) => row.generation, internal_location_contracts_1.ZLinkLocationKind.Peer, key.meshName);
+    }
+    async listPeers(filter) {
+        return [...this.peers.rows.values()].filter((row) => (0, location_store_integration_1.matchesPeerLocation)(row, filter));
+    }
+    async updateSpot(spot, intent) {
+        const key = key_codec_1.ZLinkLocationKeyCodec.encodeSpotKey({ meshName: spot.meshName, spotId: spot.spotId });
+        const updatedAt = this.now();
+        const current = this.spots.rows.get(key);
+        if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim
+            && current !== undefined
+            && this.isOwnerLive(current.ownerId, updatedAt)) {
+            return rejectedConflict();
+        }
+        if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.Renew) {
+            if (current === undefined
+                || current.ownerId !== spot.ownerId
+                || current.leaseGeneration !== spot.leaseGeneration)
+                return ignoredStale();
+            this.spots.rows.set(key, { ...spot, updatedAt });
+            this.bump(internal_location_contracts_1.ZLinkLocationKind.Spot, spot.meshName);
+            return stored(this.spots.generations.get(key) ?? 0n, updatedAt);
+        }
+        if (current !== undefined
+            && !canTakeOver(current.ownerId, current.leaseGeneration, this.leases.get(current.ownerId), spot.ownerId, spot.leaseGeneration, intent, updatedAt))
+            return rejectedConflict();
+        const generation = (this.spots.generations.get(key) ?? 0n) + 1n;
+        this.spots.generations.set(key, generation);
+        this.spots.rows.set(key, { ...spot, updatedAt });
+        this.bump(internal_location_contracts_1.ZLinkLocationKind.Spot, spot.meshName);
+        return stored(generation, updatedAt);
+    }
+    async removeSpot(key, owner) {
+        const encoded = key_codec_1.ZLinkLocationKeyCodec.encodeSpotKey(key);
+        const current = this.spots.rows.get(encoded);
+        const leaseGeneration = current?.leaseGeneration ?? this.spots.generations.get(encoded);
+        if (current === undefined
+            || current.ownerId !== owner.ownerId
+            || leaseGeneration !== owner.leaseGeneration) {
+            return internal_location_contracts_1.ZLinkLocationWriteStatus.IgnoredStale;
+        }
+        this.spots.rows.delete(encoded);
+        this.bump(internal_location_contracts_1.ZLinkLocationKind.Spot, key.meshName);
+        return internal_location_contracts_1.ZLinkLocationWriteStatus.Stored;
+    }
+    async resolveSpot(key) {
+        return this.spots.rows.get(key_codec_1.ZLinkLocationKeyCodec.encodeSpotKey(key));
+    }
+    async listSpots(filter, page = {}) {
+        return pageRows(this.spots, (row) => (0, location_store_integration_1.matchesSpotLocation)(row, filter), page);
+    }
+    async updateActor(actor, intent) {
+        const key = key_codec_1.ZLinkLocationKeyCodec.encodeActorKey({ meshName: actor.meshName, actorId: actor.actorId });
+        const updatedAt = this.now();
+        const current = this.actors.rows.get(key);
+        if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim
+            && current !== undefined
+            && this.isOwnerLive(current.ownerId, updatedAt)) {
+            return rejectedConflict();
+        }
+        if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.Renew) {
+            if (current === undefined
+                || current.ownerId !== actor.ownerId
+                || current.leaseGeneration !== actor.leaseGeneration)
+                return ignoredStale();
+            this.actors.rows.set(key, { ...actor, updatedAt });
+            this.bump(internal_location_contracts_1.ZLinkLocationKind.Actor, actor.meshName);
+            return stored(this.actors.generations.get(key) ?? 0n, updatedAt);
+        }
+        if (current !== undefined
+            && !canTakeOver(current.ownerId, current.leaseGeneration, this.leases.get(current.ownerId), actor.ownerId, actor.leaseGeneration, intent, updatedAt))
+            return rejectedConflict();
+        const generation = (this.actors.generations.get(key) ?? 0n) + 1n;
+        this.actors.generations.set(key, generation);
+        this.actors.rows.set(key, { ...actor, updatedAt });
+        this.bump(internal_location_contracts_1.ZLinkLocationKind.Actor, actor.meshName);
+        return stored(generation, updatedAt);
+    }
+    async removeActor(key, owner) {
+        const encoded = key_codec_1.ZLinkLocationKeyCodec.encodeActorKey(key);
+        const current = this.actors.rows.get(encoded);
+        const leaseGeneration = current?.leaseGeneration ?? this.actors.generations.get(encoded);
+        if (current === undefined
+            || current.ownerId !== owner.ownerId
+            || leaseGeneration !== owner.leaseGeneration) {
+            return internal_location_contracts_1.ZLinkLocationWriteStatus.IgnoredStale;
+        }
+        this.actors.rows.delete(encoded);
+        this.bump(internal_location_contracts_1.ZLinkLocationKind.Actor, key.meshName);
+        return internal_location_contracts_1.ZLinkLocationWriteStatus.Stored;
+    }
+    async resolveActor(key) {
+        return this.actors.rows.get(key_codec_1.ZLinkLocationKeyCodec.encodeActorKey(key));
+    }
+    async listActors(filter, page = {}) {
+        return pageRows(this.actors, (row) => (0, location_store_integration_1.matchesActorLocation)(row, filter), page);
+    }
+    async updateRoute(route, intent) {
+        return this.write(this.routes, key_codec_1.ZLinkLocationKeyCodec.encodeRouteKey({ routeKind: route.routeKind, routeKey: route.routeKey }), route, intent, route.ownerId, route.generation, (row) => row.ownerId, (row) => row.generation, (row, generation, updatedAt) => ({ ...row, generation, updatedAt }), internal_location_contracts_1.ZLinkLocationKind.Route, undefined);
+    }
+    async removeRoute(key, owner) {
+        return this.remove(this.routes, key_codec_1.ZLinkLocationKeyCodec.encodeRouteKey(key), owner, (row) => row.ownerId, (row) => row.generation, internal_location_contracts_1.ZLinkLocationKind.Route, undefined);
+    }
+    async resolveRoute(key) {
+        return this.routes.rows.get(key_codec_1.ZLinkLocationKeyCodec.encodeRouteKey(key));
+    }
+    async listRoutes(filter, page = {}) {
+        return pageRows(this.routes, (row) => (0, location_store_integration_1.matchesRouteLocation)(row, filter), page);
+    }
+    async prepareActorTransfer(request, signal) {
+        signal?.throwIfAborted();
+        validateTransferRequest(request);
+        const key = actorTransferKey(request.meshName, request.actorId);
+        let slot = this.actorTransfers.get(key);
+        if (slot === undefined) {
+            slot = { records: new Map() };
+            this.actorTransfers.set(key, slot);
+        }
+        if (slot.activeTransferId !== undefined) {
+            const existing = slot.records.get(slot.activeTransferId);
+            if (slot.activeTransferId === request.transferId && existing?.state === 'prepared') {
+                return transferStored(existing);
+            }
+            return transferResult('rejectedConflict');
+        }
+        const updatedAt = this.now();
+        const record = {
+            meshName: request.meshName,
+            actorId: request.actorId,
+            transferId: request.transferId,
+            source: request.source,
+            target: request.target,
+            expectedActorGeneration: request.expectedActorGeneration,
+            expectedMembershipEpoch: request.expectedMembershipEpoch,
+            participants: new Set(request.participants),
+            state: 'prepared',
+            recoveryOwnerId: request.recoveryOwnerId,
+            recoveryLeaseExpiresAt: new Date(updatedAt.getTime() + request.recoveryLeaseTtlMs),
+            updatedAt
+        };
+        slot.records.set(request.transferId, record);
+        slot.activeTransferId = request.transferId;
+        return transferStored(record);
+    }
+    async commitActorTransfer(meshName, actorId, transferId, recoveryOwnerId, signal) {
+        signal?.throwIfAborted();
+        return this.transitionActorTransfer(meshName, actorId, transferId, recoveryOwnerId, 'prepared', 'committed', false);
+    }
+    async activateActorTransfer(meshName, actorId, transferId, recoveryOwnerId, signal) {
+        signal?.throwIfAborted();
+        return this.transitionActorTransfer(meshName, actorId, transferId, recoveryOwnerId, 'committed', 'activated', true);
+    }
+    async abortActorTransfer(meshName, actorId, transferId, recoveryOwnerId, signal) {
+        signal?.throwIfAborted();
+        return this.transitionActorTransfer(meshName, actorId, transferId, recoveryOwnerId, 'prepared', 'aborted', true);
+    }
+    async takeOverActorTransfer(meshName, actorId, transferId, successorOwnerId, recoveryLeaseTtlMs, signal) {
+        signal?.throwIfAborted();
+        validateTransferIdentity(meshName, actorId, transferId);
+        validateTransferLease(successorOwnerId, recoveryLeaseTtlMs);
+        const record = this.actorTransfers.get(actorTransferKey(meshName, actorId))?.records.get(transferId);
+        if (record === undefined)
+            return transferResult('notFound');
+        if (record.state !== 'prepared' && record.state !== 'committed') {
+            return transferResult('invalidState');
+        }
+        const updatedAt = this.now();
+        if (record.recoveryLeaseExpiresAt.getTime() > updatedAt.getTime()) {
+            return transferResult('rejectedConflict');
+        }
+        const updated = {
+            ...record,
+            recoveryOwnerId: successorOwnerId,
+            recoveryLeaseExpiresAt: new Date(updatedAt.getTime() + recoveryLeaseTtlMs),
+            updatedAt
+        };
+        this.actorTransfers.get(actorTransferKey(meshName, actorId))?.records.set(transferId, updated);
+        return transferStored(updated);
+    }
+    async resolveActorTransfer(meshName, actorId, signal) {
+        signal?.throwIfAborted();
+        const slot = this.actorTransfers.get(actorTransferKey(meshName, actorId));
+        return slot?.activeTransferId === undefined ? undefined : slot.records.get(slot.activeTransferId);
+    }
+    async claimOwnerLease(ownerId, leaseTtlMs, signal) {
+        signal?.throwIfAborted();
+        validateOwnerLeaseInput(ownerId, leaseTtlMs);
+        const storeNow = this.now();
+        const current = this.leases.get(ownerId);
+        if (current !== undefined && current.leaseExpiresAt.getTime() > storeNow.getTime()) {
+            return { kind: 'conflict' };
+        }
+        if (this.ownerLeaseGeneration >= 0x7fffffffffffffffn) {
+            return { kind: 'generationExhausted' };
+        }
+        const token = { ownerId, leaseGeneration: ++this.ownerLeaseGeneration };
+        const leaseExpiresAt = new Date(storeNow.getTime() + leaseTtlMs);
+        this.leases.set(ownerId, { token, leaseExpiresAt });
+        return { kind: 'claimed', token, leaseExpiresAt, storeNow };
+    }
+    async readOwnerLease(ownerId, signal) {
+        signal?.throwIfAborted();
+        if (ownerId.trim().length === 0)
+            throw new TypeError('ownerId is required.');
+        const storeNow = this.now();
+        const current = this.leases.get(ownerId);
+        if (current === undefined || current.leaseExpiresAt.getTime() <= storeNow.getTime()) {
+            this.leases.delete(ownerId);
+            return { kind: 'missing' };
+        }
+        return {
+            kind: 'found',
+            token: { ...current.token },
+            leaseExpiresAt: new Date(current.leaseExpiresAt),
+            storeNow
+        };
+    }
+    async renewOwnerLease(token, leaseTtlMs, signal) {
+        signal?.throwIfAborted();
+        validateOwnerLeaseInput(token.ownerId, leaseTtlMs);
+        const storeNow = this.now();
+        const current = this.leases.get(token.ownerId);
+        if (current === undefined
+            || current.leaseExpiresAt.getTime() <= storeNow.getTime()
+            || current.token.leaseGeneration !== token.leaseGeneration) {
+            return { kind: 'stale' };
+        }
+        const leaseExpiresAt = new Date(storeNow.getTime() + leaseTtlMs);
+        this.leases.set(token.ownerId, { token: { ...token }, leaseExpiresAt });
+        return { kind: 'renewed', leaseExpiresAt, storeNow };
+    }
+    async releaseOwnerLease(token, signal) {
+        signal?.throwIfAborted();
+        const current = this.leases.get(token.ownerId);
+        if (current === undefined || current.token.leaseGeneration !== token.leaseGeneration) {
+            return 'stale';
+        }
+        this.leases.delete(token.ownerId);
+        return 'released';
+    }
+    async removeAllByOwner(owner, signal) {
+        signal?.throwIfAborted();
+        const lease = this.leases.get(owner.ownerId);
+        if (lease === undefined
+            || lease.token.leaseGeneration !== owner.leaseGeneration
+            || lease.leaseExpiresAt.getTime() <= this.now().getTime()) {
+            return 0n;
+        }
+        const ownerId = owner.ownerId;
+        let removed = Number(await this.authority.removeAllByOwner(owner, signal));
+        for (const [key, row] of [...this.meshNodes.rows]) {
+            if (row.ownerId !== owner.ownerId)
+                continue;
+            this.meshNodes.rows.delete(key);
+            this.releaseEntrySpotIdentity(row);
+            this.bump(internal_location_contracts_1.ZLinkLocationKind.Peer, row.meshName);
+            removed++;
+        }
+        removed += this.removeByOwner(this.peers, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.Peer, (row) => row.meshName);
+        removed += this.removeByOwner(this.spots, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.Spot, (row) => row.meshName);
+        removed += this.removeByOwner(this.actors, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.Actor, () => undefined);
+        removed += this.removeByOwner(this.routes, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.Route, () => undefined);
+        removed += this.removeByOwner(this.clientServers, ownerId, (row) => row.ownerId, internal_location_contracts_1.ZLinkLocationKind.ClientServer, (row) => row.channelName);
+        removed += this.removeFanoutByOwner(owner);
+        return BigInt(removed);
+    }
+    claimEntrySpotIdentity(descriptor, descriptorKey) {
+        if (descriptor.entrySpotId === undefined)
+            return true;
+        const authorityKey = (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', descriptor.entrySpotId).value;
+        const current = this.entrySpotClaims.get(authorityKey);
+        if (current !== undefined) {
+            if (current.descriptorKey !== descriptorKey
+                || current.ownerId !== descriptor.ownerId
+                || current.lifecycleGeneration !== descriptor.lifecycleGeneration) {
+                return false;
+            }
+            this.entrySpotClaims.set(authorityKey, {
+                ...current,
+                leaseGeneration: descriptor.leaseGeneration
+            });
+            return true;
+        }
+        this.entrySpotClaims.set(authorityKey, {
+            descriptorKey,
+            ownerId: descriptor.ownerId,
+            leaseGeneration: descriptor.leaseGeneration,
+            lifecycleGeneration: descriptor.lifecycleGeneration
+        });
+        return true;
+    }
+    releaseEntrySpotIdentity(descriptor) {
+        if (descriptor.entrySpotId === undefined)
+            return;
+        const authorityKey = (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', descriptor.entrySpotId).value;
+        const current = this.entrySpotClaims.get(authorityKey);
+        if (current?.ownerId === descriptor.ownerId
+            && current.leaseGeneration === descriptor.leaseGeneration
+            && current.lifecycleGeneration === descriptor.lifecycleGeneration) {
+            this.entrySpotClaims.delete(authorityKey);
+        }
+    }
+    async getChangeStamp(scope) {
+        return this.stamps.get(stampKey(scope)) ?? 0n;
+    }
+    write(table, key, row, intent, ownerId, generation, ownerOf, generationOf, finalize, kind, meshName) {
+        const updatedAt = this.now();
+        const current = table.rows.get(key);
+        if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim
+            && current !== undefined
+            && this.isOwnerLive(ownerOf(current), updatedAt)) {
+            return rejectedConflict();
+        }
+        if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim || intent === internal_location_contracts_1.ZLinkLocationWriteIntent.Takeover) {
+            const next = (table.generations.get(key) ?? 0n) + 1n;
+            table.generations.set(key, next);
+            table.rows.set(key, finalize(row, next, updatedAt));
+            this.bump(kind, meshName);
+            return stored(next, updatedAt);
+        }
+        if (current !== undefined
+            && ownerOf(current) === ownerId
+            && (generation === 0n || generationOf(current) === generation)) {
+            table.rows.set(key, finalize(row, generation, updatedAt));
+            this.bump(kind, meshName);
+            return stored(table.generations.get(key) ?? generation, updatedAt);
+        }
+        return ignoredStale();
+    }
+    transitionActorTransfer(meshName, actorId, transferId, recoveryOwnerId, requiredState, nextState, clearActive) {
+        validateTransferIdentity(meshName, actorId, transferId);
+        const slot = this.actorTransfers.get(actorTransferKey(meshName, actorId));
+        const record = slot?.records.get(transferId);
+        if (record === undefined || slot?.activeTransferId !== transferId) {
+            return transferResult('notFound');
+        }
+        if (record.state !== requiredState)
+            return transferResult('invalidState');
+        if (record.recoveryOwnerId !== recoveryOwnerId)
+            return transferResult('rejectedConflict');
+        const updated = {
+            ...record,
+            state: nextState,
+            updatedAt: this.now()
+        };
+        slot.records.set(transferId, updated);
+        if (clearActive)
+            slot.activeTransferId = undefined;
+        return transferStored(updated);
+    }
+    remove(table, key, owner, ownerOf, generationOf, kind, meshName) {
+        const current = table.rows.get(key);
+        if (current === undefined || ownerOf(current) !== owner.ownerId
+            || generationOf(current) !== owner.leaseGeneration) {
+            return ignoredStale();
+        }
+        table.rows.delete(key);
+        this.bump(kind, meshName);
+        return stored(owner.leaseGeneration, this.now());
+    }
+    removeByOwner(table, ownerId, ownerOf, kind, meshOf) {
+        let removed = 0;
+        for (const [key, row] of [...table.rows.entries()]) {
+            if (ownerOf(row) === ownerId) {
+                table.rows.delete(key);
+                this.bump(kind, meshOf(row));
+                removed++;
+            }
+        }
+        return removed;
+    }
+    isOwnerLive(ownerId, now) {
+        const lease = this.leases.get(ownerId);
+        return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime();
+    }
+    bump(kind, meshName) {
+        this.bumpScope({ kind, meshName });
+        if (meshName !== undefined) {
+            this.bumpScope({ kind });
+        }
+    }
+    removeFanoutByOwner(owner) {
+        let removed = 0;
+        for (const [key, row] of this.fanoutPublishers.rows) {
+            if (row.ownerId !== owner.ownerId)
+                continue;
+            this.fanoutPublishers.rows.delete(key);
+            removed++;
+        }
+        return removed;
+    }
+    bumpScope(scope) {
+        const key = stampKey(scope);
+        this.stamps.set(key, (this.stamps.get(key) ?? 0n) + 1n);
+    }
+}
+exports.ZLinkInMemoryLocationStore = ZLinkInMemoryLocationStore;
+class RowTable {
+    rows = new Map();
+    generations = new Map();
+}
+function validateMeshNodeDescriptor(descriptor) {
+    if (!validDescriptorText(descriptor.meshName) || !validDescriptorText(descriptor.ownerId)) {
+        throw new TypeError('MeshNode descriptor identity is required.');
+    }
+    if (descriptor.objectRole === internal_location_contracts_1.ZLinkObjectRole.Server) {
+        if (descriptor.entrySpotId !== undefined && !validDescriptorText(descriptor.entrySpotId)) {
+            throw new TypeError('MeshNode Entry Spot ID must contain 1..255 UTF-8 bytes.');
+        }
+    }
+    else if (descriptor.entrySpotId !== undefined) {
+        throw new TypeError('Only Object Server descriptors may publish an Entry Spot ID.');
+    }
+    const maxGeneration = 0x7fffffffffffffffn;
+    if (descriptor.lifecycleGeneration < 1n || descriptor.lifecycleGeneration > maxGeneration
+        || descriptor.descriptorRevision < 1n || descriptor.descriptorRevision > maxGeneration
+        || descriptor.leaseGeneration < 1n || descriptor.leaseGeneration > maxGeneration
+        || descriptor.applicationVersion < 0n || descriptor.applicationVersion > maxGeneration) {
+        throw new RangeError('MeshNode descriptor generations are invalid.');
+    }
+    const capacities = [
+        descriptor.populationCapacity.actors,
+        descriptor.populationCapacity.spots,
+        ...descriptor.populationCapacity.spotTypes
+    ];
+    const values = capacities.flatMap(capacity => [capacity.active, capacity.reserved, capacity.limit]);
+    if (values.some(value => !Number.isSafeInteger(value) || value < 0)
+        || capacities.some(capacity => capacity.active + capacity.reserved > capacity.limit
+            && capacity.limit !== 0)
+        || !Number.isSafeInteger(descriptor.activationConcurrency.active)
+        || descriptor.activationConcurrency.active < 0
+        || !Number.isSafeInteger(descriptor.activationConcurrency.limit)
+        || descriptor.activationConcurrency.limit < 1
+        || descriptor.activationConcurrency.active > descriptor.activationConcurrency.limit
+        || descriptor.placementWeight < 0
+        || descriptor.placementWeight > 10_000
+        || descriptor.objectCapabilities.length > 1024
+        || (descriptor.objectRole !== internal_location_contracts_1.ZLinkObjectRole.Server
+            && descriptor.objectCapabilities.length !== 0)) {
+        throw new RangeError('MeshNode object capacity is invalid.');
+    }
+    const keys = new Set();
+    for (const capability of descriptor.objectCapabilities) {
+        if (!validDescriptorText(capability.stableType)) {
+            throw new TypeError('MeshNode capability stable type is required.');
+        }
+        const key = `${capability.objectKind}\0${capability.stableType}`;
+        if (keys.has(key))
+            throw new TypeError('MeshNode object capabilities must be unique.');
+        keys.add(key);
+        if ((capability.policy === 'snapshot') !== capability.hasSnapshotAdapter) {
+            throw new TypeError('Snapshot adapter presence does not match the maintenance policy.');
+        }
+        if (!Number.isSafeInteger(capability.limit) || capability.limit < 0
+            || capability.objectKind === 'actor' && capability.limit !== 0) {
+            throw new RangeError('MeshNode capability limit is invalid.');
+        }
+    }
+}
+function validDescriptorText(value) {
+    const size = Buffer.byteLength(value, 'utf8');
+    return size >= 1 && size <= 255 && !value.includes('\0');
+}
+function meshNodeImmutableFingerprint(descriptor) {
+    const capabilities = [...descriptor.objectCapabilities]
+        .sort((left, right) => {
+        const byKind = left.objectKind.localeCompare(right.objectKind);
+        return byKind !== 0 ? byKind : left.stableType.localeCompare(right.stableType);
+    });
+    return JSON.stringify({
+        meshName: descriptor.meshName,
+        rid: String(descriptor.rid),
+        lifecycleGeneration: descriptor.lifecycleGeneration.toString(),
+        endpoint: descriptor.endpoint,
+        objectRole: descriptor.objectRole,
+        entrySpotId: descriptor.entrySpotId ?? null,
+        actorLimit: descriptor.populationCapacity.actors.limit,
+        spotLimit: descriptor.populationCapacity.spots.limit,
+        activationConcurrencyLimit: descriptor.activationConcurrency.limit,
+        channelNames: Object.keys(descriptor.channelWeights).sort(),
+        applicationVersion: descriptor.applicationVersion.toString(),
+        spotTypes: [...descriptor.spotTypes].sort(),
+        objectCapabilities: capabilities,
+        securityIdentity: descriptor.securityIdentity,
+        ownerId: descriptor.ownerId,
+        leaseGeneration: descriptor.leaseGeneration.toString()
+    });
+}
+function meshNodeDescriptorFingerprint(descriptor) {
+    return JSON.stringify({
+        immutable: meshNodeImmutableFingerprint(descriptor),
+        descriptorRevision: descriptor.descriptorRevision.toString(),
+        placementWeight: descriptor.placementWeight,
+        populationCapacity: descriptor.populationCapacity,
+        activationConcurrency: descriptor.activationConcurrency,
+        channelWeights: Object.fromEntries(Object.entries(descriptor.channelWeights).sort(([left], [right]) => left.localeCompare(right))),
+        maintenanceWave: descriptor.maintenanceWave ?? null,
+        state: descriptor.state
+    });
+}
+const TRANSFER_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function meshNodeKey(meshName, rid) {
+    const value = typeof rid === 'string'
+        ? rid
+        : rid.toHex();
+    return `${meshName.length}:${meshName}:${value.length}:${value}`;
+}
+function clientServerKey(channelName, serverRid) {
+    const value = typeof serverRid === 'string'
+        ? serverRid
+        : serverRid.toHex();
+    return `${channelName.length}:${channelName}:${value.length}:${value}`;
+}
+function fanoutPublisherKey(channelName, publisherRid) {
+    const value = typeof publisherRid === 'string'
+        ? publisherRid
+        : publisherRid.toHex();
+    return `${channelName.length}:${channelName}:${value.length}:${value}`;
+}
+function validateClientServerDescriptor(descriptor) {
+    if (!validDescriptorText(descriptor.channelName)
+        || !validDescriptorText(String(descriptor.serverRid))
+        || !validDescriptorText(descriptor.endpoint)
+        || !validDescriptorText(descriptor.securityIdentity)
+        || !validDescriptorText(descriptor.ownerId)) {
+        throw new TypeError('ClientServer descriptor identity and endpoint are required.');
+    }
+    const maxGeneration = 0x7fffffffffffffffn;
+    if (descriptor.lifecycleGeneration < 1n || descriptor.lifecycleGeneration > maxGeneration
+        || descriptor.descriptorRevision < 1n || descriptor.descriptorRevision > maxGeneration
+        || descriptor.leaseGeneration < 1n || descriptor.leaseGeneration > maxGeneration) {
+        throw new RangeError('ClientServer descriptor generations are invalid.');
+    }
+    if (!Number.isInteger(descriptor.weight) || descriptor.weight < 0 || descriptor.weight > 10_000) {
+        throw new RangeError('ClientServer descriptor weight must be an integer in 0..10000.');
+    }
+}
+function clientServerImmutableFingerprint(descriptor) {
+    return JSON.stringify({
+        channelName: descriptor.channelName,
+        serverRid: String(descriptor.serverRid),
+        lifecycleGeneration: descriptor.lifecycleGeneration.toString(),
+        endpoint: descriptor.endpoint,
+        securityIdentity: descriptor.securityIdentity,
+        ownerId: descriptor.ownerId,
+        leaseGeneration: descriptor.leaseGeneration.toString()
+    });
+}
+function clientServerDescriptorFingerprint(descriptor) {
+    return JSON.stringify({
+        immutable: clientServerImmutableFingerprint(descriptor),
+        descriptorRevision: descriptor.descriptorRevision.toString(),
+        weight: descriptor.weight,
+        state: descriptor.state
+    });
+}
+function validateFanoutPublisherDescriptor(descriptor) {
+    if (!validDescriptorText(descriptor.channelName)
+        || !validDescriptorText(String(descriptor.publisherRid))
+        || !validDescriptorText(descriptor.endpoint)
+        || !validDescriptorText(descriptor.securityIdentity)
+        || !validDescriptorText(descriptor.ownerId)) {
+        throw new TypeError('Fanout publisher descriptor identity and endpoint are required.');
+    }
+    const maxGeneration = 0x7fffffffffffffffn;
+    if (descriptor.lifecycleGeneration < 1n || descriptor.lifecycleGeneration > maxGeneration
+        || descriptor.descriptorRevision < 1n || descriptor.descriptorRevision > maxGeneration
+        || descriptor.leaseGeneration < 1n || descriptor.leaseGeneration > maxGeneration) {
+        throw new RangeError('Fanout publisher descriptor generations are invalid.');
+    }
+}
+function fanoutPublisherImmutableFingerprint(descriptor) {
+    return JSON.stringify({
+        channelName: descriptor.channelName,
+        publisherRid: String(descriptor.publisherRid),
+        lifecycleGeneration: descriptor.lifecycleGeneration.toString(),
+        endpoint: descriptor.endpoint,
+        securityIdentity: descriptor.securityIdentity,
+        ownerId: descriptor.ownerId,
+        leaseGeneration: descriptor.leaseGeneration.toString()
+    });
+}
+function fanoutPublisherDescriptorFingerprint(descriptor) {
+    return JSON.stringify({
+        immutable: fanoutPublisherImmutableFingerprint(descriptor),
+        descriptorRevision: descriptor.descriptorRevision.toString(),
+        state: descriptor.state
+    });
+}
+function actorTransferKey(meshName, actorId) {
+    return `${meshName.length}:${meshName}${actorId.length}:${actorId}`;
+}
+function validateTransferRequest(request) {
+    validateTransferIdentity(request.meshName, request.actorId, request.transferId);
+    validateTransferLease(request.recoveryOwnerId, request.recoveryLeaseTtlMs);
+    if (request.expectedActorGeneration < 1n || request.expectedMembershipEpoch < 1n) {
+        throw new RangeError('Actor transfer generation and membership epoch must be positive.');
+    }
+    if (request.participants.size === 0) {
+        throw new TypeError('Actor transfer requires at least one participant.');
+    }
+}
+function validateTransferIdentity(meshName, actorId, transferId) {
+    if (meshName.trim().length === 0 || actorId.trim().length === 0) {
+        throw new TypeError('Actor transfer meshName and actorId are required.');
+    }
+    if (!TRANSFER_ID_PATTERN.test(transferId)) {
+        throw new TypeError('Actor transferId must be a lowercase canonical UUID.');
+    }
+}
+function validateTransferLease(ownerId, ttlMs) {
+    if (ownerId.trim().length === 0 || !Number.isFinite(ttlMs) || ttlMs <= 0) {
+        throw new TypeError('Actor transfer recovery owner and positive lease TTL are required.');
+    }
+}
+function transferStored(record) {
+    return { status: 'stored', record };
+}
+function transferResult(status) {
+    return { status };
+}
+function validateOwnerLeaseInput(ownerId, leaseTtlMs) {
+    if (ownerId.trim().length === 0)
+        throw new TypeError('ownerId is required.');
+    if (!Number.isSafeInteger(leaseTtlMs) || leaseTtlMs < 1) {
+        throw new RangeError('leaseTtlMs must be a positive safe integer.');
+    }
+}
+function pageRows(table, matches, page) {
+    const ordered = [...table.rows.entries()]
+        .filter(([, row]) => matches(row))
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([, row]) => row);
+    const offset = parseContinuationToken(page.continuationToken);
+    const size = page.pageSize !== undefined && page.pageSize > 0 ? page.pageSize : Number.MAX_SAFE_INTEGER;
+    const items = ordered.slice(offset, offset + size);
+    const nextOffset = offset + items.length;
+    return {
+        items,
+        continuationToken: nextOffset < ordered.length ? String(nextOffset) : undefined
+    };
+}
+function pageValues(rows, page, key) {
+    const ordered = [...rows].sort((left, right) => key(left).localeCompare(key(right)));
+    const offset = parseContinuationToken(page.continuationToken);
+    const size = page.pageSize !== undefined && page.pageSize > 0
+        ? page.pageSize
+        : Number.MAX_SAFE_INTEGER;
+    const items = ordered.slice(offset, offset + size);
+    const nextOffset = offset + items.length;
+    return {
+        items,
+        continuationToken: nextOffset < ordered.length ? String(nextOffset) : undefined
+    };
+}
+function parseContinuationToken(token) {
+    if (token === undefined) {
+        return 0;
+    }
+    const parsed = Number.parseInt(token, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+}
+function stampKey(scope) {
+    return `${scope.kind}:${scope.meshName ?? ''}`;
+}
+function stored(generation, updatedAt) {
+    return { status: internal_location_contracts_1.ZLinkLocationWriteStatus.Stored, generation, updatedAt };
+}
+function ignoredStale() {
+    return { status: internal_location_contracts_1.ZLinkLocationWriteStatus.IgnoredStale, generation: 0n, updatedAt: new Date(0) };
+}
+function rejectedConflict() {
+    return { status: internal_location_contracts_1.ZLinkLocationWriteStatus.RejectedConflict, generation: 0n, updatedAt: new Date(0) };
+}
+function canTakeOver(currentOwnerId, currentLeaseGeneration, currentLease, nextOwnerId, nextLeaseGeneration, intent, now) {
+    if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.Takeover) {
+        // Takeover is an explicit handoff operation. The row generation and the
+        // next owner's lease still fence concurrent stale writes.
+        return true;
+    }
+    if (intent !== internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim) {
+        return false;
+    }
+    const ownerGone = currentLease === undefined
+        || currentLease.leaseExpiresAt.getTime() <= now.getTime();
+    if (ownerGone)
+        return true;
+    return currentOwnerId === nextOwnerId
+        && currentLeaseGeneration !== nextLeaseGeneration
+        && currentLease.token.leaseGeneration === nextLeaseGeneration;
+}