@zlink-systems/framework 0.29.1 → 0.30.1

package/dist/runtime/host/spot-address-transport.d.ts

@@ -31,6 +31,7 @@ export declare class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTr
     private reportInstanceRequestError;
     private traceInstanceAddress;
     private resolveExisting;
+    private reactivationCall;
     private selectMissingTarget;
     private validateExisting;
     private encode;

package/dist/runtime/host/spot-address-transport.js

@@ -30,7 +30,10 @@ class ZLinkHostSpotAddressTransport {
     }
     async sendToSpotAddressScoped(spotId, message, call) {
         const activationDeadlineUnixMs = BigInt(Math.round(Date.now() + this.options.defaultRequestTimeoutMs));
-        const existing = await this.resolveExisting(spotId);
+        const resolution = await this.resolveExisting(spotId, undefined, call);
+        const existing = resolution !== undefined && !('kind' in resolution) ? resolution : undefined;
+        if (resolution !== undefined && 'kind' in resolution)
+            call = this.reactivationCall(resolution, call);
         if (existing !== undefined) {
             this.validateExisting(existing, call);
             try {
@@ -64,7 +67,7 @@ class ZLinkHostSpotAddressTransport {
         if (!call.instanceSpot) {
             return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
         }
-        const selected = this.selectMissingTarget(spotId, call);
+        const selected = this.selectMissingTarget(spotId, call, resolution);
         if (selected.kind === 'unsupported') {
             this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send, spotId, message, call.initialMeshName, call.instanceSpotType, undefined, ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget);
             return { status: submission_result_1.ZLinkSubmitStatus.TargetNotFound };
@@ -91,10 +94,13 @@ class ZLinkHostSpotAddressTransport {
         const timeoutMs = call.timeoutMs ?? this.options.defaultRequestTimeoutMs;
         const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
         try {
-            const existing = await this.resolveExisting(spotId, deadline.signal);
+            const resolution = await this.resolveExisting(spotId, deadline.signal, call);
+            const existing = resolution !== undefined && !('kind' in resolution) ? resolution : undefined;
+            if (resolution !== undefined && 'kind' in resolution)
+                call = this.reactivationCall(resolution, call);
             deadline.requireRemaining();
             if (existing === undefined) {
-                return await this.requestToMissingInstance(spotId, request, call, deadline);
+                return await this.requestToMissingInstance(spotId, request, call, deadline, resolution);
             }
             this.validateExisting(existing, call);
             try {
@@ -138,16 +144,17 @@ class ZLinkHostSpotAddressTransport {
             instanceSpot: call.instanceSpot,
             timeoutMs: deadline.requireRemaining(),
             signal: deadline.signal,
-            metadata: call.metadata
+            metadata: call.metadata,
+            onAdmitted: call.onAdmitted
         }), deadline.signal);
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.ReplyReceived, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, existing.routerChannelId, existing.stableType, existing.targetNodeRid);
         return reply;
     }
-    async requestToMissingInstance(spotId, request, call, deadline) {
+    async requestToMissingInstance(spotId, request, call, deadline, current) {
         if (!call.instanceSpot) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound, `Spot '${String(spotId)}' has no Ready authority.`);
         }
-        const selected = this.selectMissingTarget(spotId, call);
+        const selected = this.selectMissingTarget(spotId, call, current);
         if (selected.kind === 'capacity') {
             throw missingInstancePlacementCapacity(spotId, call.instanceSpotType);
         }
@@ -167,7 +174,7 @@ class ZLinkHostSpotAddressTransport {
         const table = this.options.completions(selected.meshName);
         if (table === undefined)
             throw new Error(`MeshNode '${selected.meshName}' completion table is not started.`);
-        const completionPromise = table.submit(() => selected.node.requestToMissingInstanceSpot(selected.target, encoded, deadlineUnixMs, call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId), call.metadata), deadline.signal);
+        const completionPromise = table.submit(() => selected.node.requestToMissingInstanceSpot(selected.target, encoded, deadlineUnixMs, call.sourceSpot === undefined ? undefined : String(call.sourceSpot.routingId), call.metadata, call.onAdmitted), deadline.signal);
         this.traceInstanceAddress(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Sent, ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request, spotId, request, selected.meshName, selected.target.stableType, selected.target.targetNodeRid);
         const completion = await (0, abort_1.awaitWithAbort)(completionPromise, deadline.signal);
         try {
@@ -214,13 +221,15 @@ class ZLinkHostSpotAddressTransport {
             errorReason
         });
     }
-    async resolveExisting(spotId, signal) {
+    async resolveExisting(spotId, signal, call) {
         const resolver = this.options.resolver();
         if (resolver === undefined) {
             throw new Error('Global Spot address resolution requires a Location Store.');
         }
         try {
-            return await (0, abort_1.awaitWithAbort)(resolver.resolve(spotId, signal), signal);
+            return await (0, abort_1.awaitWithAbort)(call?.instanceSpot === true
+                ? resolver.resolve(spotId, signal, true)
+                : resolver.resolve(spotId, signal), signal);
         }
         catch (error) {
             if (error instanceof contracts_1.ZLinkFrameworkException &&
@@ -230,7 +239,11 @@ class ZLinkHostSpotAddressTransport {
             throw error;
         }
     }
-    selectMissingTarget(spotId, call) {
+    reactivationCall(route, call) {
+        this.validateExisting(route, call);
+        return { ...call, initialMeshName: route.meshName, instanceSpotType: route.stableType };
+    }
+    selectMissingTarget(spotId, call, current) {
         const configuredMeshes = this.options.meshNames();
         if (call.initialMeshName !== undefined &&
             this.options.isMeshConfigured?.(call.initialMeshName) === false) {
@@ -253,11 +266,11 @@ class ZLinkHostSpotAddressTransport {
         const stableType = call.instanceSpotType ?? (distinctTypes.length === 1 ? distinctTypes[0] : undefined);
         if (stableType === undefined) {
             if (distinctTypes.length === 0)
-                return { kind: 'unsupported' };
+                return { kind: current === undefined ? 'unsupported' : 'unavailable' };
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, 'Instance Spot type is required when multiple types are registered.');
         }
         if (canInspectPlacementTypes && !distinctTypes.includes(stableType)) {
-            return { kind: 'unsupported' };
+            return { kind: current === undefined ? 'unsupported' : 'unavailable' };
         }
         let unavailable = false;
         let capacity = false;
@@ -276,6 +289,7 @@ class ZLinkHostSpotAddressTransport {
                     node,
                     target: {
                         ...placement.target,
+                        targetMeshName: meshName,
                         targetSpotId: String(spotId),
                         stableType
                     }
@@ -293,7 +307,7 @@ class ZLinkHostSpotAddressTransport {
         if (capacity)
             return { kind: 'capacity' };
         if (unsupported)
-            return { kind: 'unsupported' };
+            return { kind: current === undefined ? 'unsupported' : 'unavailable' };
         return { kind: 'unavailable' };
     }
     validateExisting(target, call) {

package/dist/runtime/host/spot-runtime-options-factory.js

@@ -25,12 +25,12 @@ class ZLinkSpotRuntimeOptionsFactory {
                     ?.notifyPrimaryEntrySpotActorLeft(actor, signal, actorRef, membershipEpoch) ??
                     Promise.resolve()
             },
-            dispatchEntryActorPacket: (actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) => {
+            dispatchEntryActorPacket: (origin, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) => {
                 const runtime = this.options.spotNodeRuntime();
                 if (runtime === undefined) {
                     throw new configuration_1.ZLinkConfigurationException('Entry Spot actor packet dispatch requires the MeshNode runtime.');
                 }
-                return runtime.dispatchEntryActorPacket(actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
+                return runtime.dispatchEntryActorPacket(origin, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
             },
             dispatchEntryActorJoin: async (meshName, actor, handoffBacklog) => {
                 const runtime = this.options.spotNodeRuntime();
@@ -178,6 +178,7 @@ class ZLinkSpotRuntimeOptionsFactory {
                     contracts_1.ZLinkSpotRelocationCoordinationMode.FrameworkManaged);
             },
             actorTransferRuntime,
+            releaseActorMembers: (meshName, spotId) => this.options.actorManager()?.releaseSpotActorMembers(meshName, spotId) ?? Promise.resolve(),
             boundSessionRuntime: this.options.boundSessionRelay.boundSessions,
             actorHandoffRuntime: this.options.actorHandoff,
             metrics: this.options.metrics,

package/dist/runtime/host/user-spot-creation-coordinator.d.ts

@@ -5,6 +5,7 @@ import type { ZLinkAuthoritySnapshot, ZLinkLocationOwnerToken } from '../locatio
 import type { ZLinkAuthorityStore, ZLinkObjectCreationStore } from '../locations/internal-store-contracts';
 import type { ZLinkLocalSpotCreateResult } from '../spots/spot-manager-internal-contracts';
 export interface ZLinkUserSpotCreationCoordinatorOptions {
+    readonly relocationPolicy?: (meshName: string, stableType: string) => import('../locations/internal-location-contracts').ZLinkObjectReserveRequest['actorRelocationPolicy'];
     readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
     readonly target: (request: Pick<ZLinkUserSpotCreationRequest, 'meshName' | 'stableType'>, signal?: AbortSignal, excludedNodeRids?: ReadonlySet<string>) => Promise<{
         readonly meshName: string;

package/dist/runtime/host/user-spot-creation-coordinator.js

@@ -62,6 +62,7 @@ class ZLinkUserSpotCreationCoordinator {
             try {
                 reserved = await this.options.store.reserve({
                     key: { kind: 'user_spot', globalId: String(request.spotId) },
+                    actorRelocationPolicy: this.options.relocationPolicy?.(target.meshName, request.stableType),
                     intent: {
                         stableType: request.stableType,
                         requestContentReference: contentReference,

package/dist/runtime/locations/actor-location-claims.d.ts

@@ -1,6 +1,7 @@
 import type { ActorRef, RoutingId } from '../../contracts/Common';
 import { type ZLinkActorLocation } from './internal-location-contracts';
 import type { ZLinkActorLocationStore, ZLinkAuthorityStore } from './internal-store-contracts';
+import { ZLinkSpotKind } from '../../contracts/Spots';
 import type { IZLinkLocationLifecycleRuntime, ZLinkOwnershipLostEvent } from './lifecycle-runtime';
 export declare enum ZLinkActorClaimStatus {
     Claimed = "claimed",
@@ -31,8 +32,7 @@ export declare class ZLinkActorLocationClaims {
     claim(actorType: string, actorId: string, nodeRid: RoutingId, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
     setRef(actorType: string, actorId: string, actorRef: ActorRef, ownerNodeGeneration: bigint): Promise<void>;
     takeoverJoinedSpot(actorType: string, actorId: string, actorRef: ActorRef, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
-    notifyJoinedSpot(actorType: string, actorId: string, _spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
-    notifyLeftSpot(actorType: string, actorId: string, entrySpotId: RoutingId, entrySpotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
+    commitMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint): Promise<void>;
     release(_actorType: string, actorId: string, actorRef?: ActorRef): Promise<void>;
     owns(_actorType: string, actorId: string): boolean;
     snapshot(actorId: string): ZLinkActorLocation | undefined;

package/dist/runtime/locations/actor-location-claims.js

@@ -6,6 +6,7 @@ const Spots_1 = require("../../contracts/Spots");
 const key_codec_1 = require("./key-codec");
 const authority_key_codec_1 = require("./authority-key-codec");
 const routing_id_1 = require("../routing-id");
+const actor_authority_publication_1 = require("../actors/actor-authority-publication");
 var ZLinkActorClaimStatus;
 (function (ZLinkActorClaimStatus) {
     ZLinkActorClaimStatus["Claimed"] = "claimed";
@@ -149,25 +150,39 @@ class ZLinkActorLocationClaims {
         });
         return { status: ZLinkActorClaimStatus.Claimed, claimed, generation: result.generation };
     }
-    async notifyJoinedSpot(actorType, actorId, _spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.renew(actorType, actorId, (row) => ({
-            ...row,
-            spotKind: Spots_1.ZLinkSpotKind.User,
-            spotId,
-            spotGeneration,
-            membershipEpoch,
-            ownerNodeGeneration
-        }));
-    }
-    async notifyLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.renew(actorType, actorId, (row) => ({
-            ...row,
-            spotKind: Spots_1.ZLinkSpotKind.Entry,
-            spotId: entrySpotId,
-            spotGeneration: entrySpotGeneration,
-            membershipEpoch,
-            ownerNodeGeneration
-        }));
+    async commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration) {
+        const actorId = actorRef.actorId;
+        const store = this.authorityStore;
+        const owner = this.runtime.currentOwnerToken;
+        if (store === undefined || owner === undefined) {
+            throw new Error('Actor membership commit requires Location Store authority and owner.');
+        }
+        const key = (0, authority_key_codec_1.encodeAuthorityKey)('actor', actorId);
+        const current = await store.readAuthority(key);
+        if (!matchesActorAuthority(current, actorRef, owner) ||
+            current.allocation.stableType !== actorType ||
+            current.authorityOwnerGeneration !== authorityOwnerGeneration ||
+            current.allocation.descriptorLifecycleGeneration !== ownerNodeGeneration) {
+            throw new Error(`Actor '${actorId}' membership authority fence does not match.`);
+        }
+        const identity = (0, actor_authority_publication_1.decodeActorAuthorityIdentity)(current.payload, current.objectGeneration);
+        if (identity === undefined ||
+            identity.actorType !== actorType ||
+            identity.ownerNodeGeneration !== ownerNodeGeneration ||
+            identity.owner.ownerId !== owner.ownerId ||
+            identity.owner.leaseGeneration !== owner.leaseGeneration ||
+            !(0, routing_id_1.routingIdsEqual)(identity.actor.nodeRid, actorRef.nodeRid) ||
+            identity.meshName !== actorRef.meshName) {
+            throw new Error(`Actor '${actorId}' membership authority identity does not match.`);
+        }
+        const result = await store.compareExchangeAuthority(key, current.storeVersion, {
+            kind: 'put',
+            generationTransition: 'preserve',
+            payload: (0, actor_authority_publication_1.rewriteActorAuthorityRoute)(current.payload, actorRef, String(spotId), spotGeneration, spotKind)
+        });
+        if (result.kind !== 'stored') {
+            throw new Error(`Actor '${actorId}' membership commit was rejected with status ${result.kind}.`);
+        }
     }
     async release(_actorType, actorId, actorRef) {
         const key = { meshName: this.entryMeshName, actorId };

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

@@ -1,6 +1,6 @@
 import type { ZLinkLocationOwnerToken, ZLinkLocationPage, ZLinkLocationWriteIntent, ZLinkLocationWriteResult, ZLinkLocationWriteStatus, ZLinkMeshNodeDescriptor, ZLinkMeshNodeDescriptorKey, ZLinkClientServerServerDescriptor, ZLinkClientServerServerDescriptorKey, ZLinkFanoutPublisherDescriptor, ZLinkFanoutPublisherDescriptorKey, ZLinkOwnerLeaseClaimResult, ZLinkOwnerLeaseReadResult, ZLinkOwnerLeaseReleaseResult, ZLinkOwnerLeaseRenewResult, ZLinkPageRequest } from '../../contracts/Locations/Models';
 import type { ZLinkAggregateAbortResult, ZLinkAggregateCommitResult, ZLinkAggregateFence, ZLinkAggregatePrepareRequest, ZLinkAggregatePrepareResult, ZLinkAuthorityCompareExchangeResult, ZLinkAuthorityKey, ZLinkAuthorityMutation, ZLinkAuthorityReadResult, ZLinkAuthorityScanCursor, ZLinkAuthorityScanResult, ZLinkAuthorityStoreVersion, ZLinkCreationOperationIdentity, ZLinkCreationTerminalReadResult, ZLinkObjectAbortRequest, ZLinkObjectAbortResult, ZLinkObjectCommitRequest, ZLinkObjectCommitResult, ZLinkObjectCreationCompleteRequest, ZLinkObjectCreationCompleteResult, ZLinkObjectReserveResult } from '../../contracts/Locations/Authority';
-import type { ZLinkObjectReserveRequest } from './internal-location-contracts';
+import type { ZLinkObjectReserveRequest, ZLinkEndedOwnerReleaseIntent } from './internal-location-contracts';
 /**
  * Framework-private domain repository. Provider implementations never
  * implement this interface; the framework maps it to the opaque Store SPI.
@@ -26,7 +26,7 @@ export interface ZLinkDomainLocationStore {
     reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectReserveResult>;
     commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectCommitResult>;
     completeCreation(request: ZLinkObjectCreationCompleteRequest, signal?: AbortSignal): Promise<ZLinkObjectCreationCompleteResult>;
-    releaseEndedReservation?(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal): Promise<boolean>;
+    releaseEndedReservation?(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal, request?: ZLinkEndedOwnerReleaseIntent): Promise<boolean>;
     abort(request: ZLinkObjectAbortRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectAbortResult>;
     prepareAggregate(request: ZLinkAggregatePrepareRequest, signal?: AbortSignal): Promise<ZLinkAggregatePrepareResult>;
     commitAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateCommitResult>;

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

@@ -1,9 +1,10 @@
-import type { ZLinkAggregateAbortResult, ZLinkAggregateCommitResult, ZLinkAggregateFence, ZLinkAggregatePrepareRequest, ZLinkAggregatePrepareResult, ZLinkAuthorityCompareExchangeResult, ZLinkAuthorityKey, ZLinkAuthorityMutation, ZLinkAuthorityReadResult, ZLinkAuthorityScanCursor, ZLinkAuthorityScanResult, ZLinkAuthorityStoreVersion, ZLinkCapacityVector, ZLinkLocationOwnerToken, ZLinkMeshNodeDescriptorKey, ZLinkObjectAbortRequest, ZLinkObjectAbortResult, ZLinkObjectCommitRequest, ZLinkObjectCommitResult, ZLinkObjectCreationCompleteRequest, ZLinkObjectCreationCompleteResult, ZLinkObjectReserveRequest, ZLinkObjectReserveResult, ZLinkCreationOperationIdentity, ZLinkCreationTerminalReadResult } from './internal-location-contracts';
+import type { ZLinkAggregateAbortResult, ZLinkAggregateCommitResult, ZLinkAggregateFence, ZLinkAggregatePrepareRequest, ZLinkAggregatePrepareResult, ZLinkAuthorityCompareExchangeResult, ZLinkAuthorityKey, ZLinkAuthorityMutation, ZLinkAuthorityReadResult, ZLinkAuthorityScanCursor, ZLinkAuthorityScanResult, ZLinkAuthorityStoreVersion, ZLinkCapacityVector, ZLinkLocationOwnerToken, ZLinkMeshNodeDescriptorKey, ZLinkObjectAbortRequest, ZLinkObjectAbortResult, ZLinkObjectCommitRequest, ZLinkObjectCommitResult, ZLinkObjectCreationCompleteRequest, ZLinkObjectCreationCompleteResult, ZLinkEndedOwnerReleaseIntent, ZLinkObjectReserveRequest, ZLinkObjectReserveResult, ZLinkCreationOperationIdentity, ZLinkCreationTerminalReadResult } from './internal-location-contracts';
 export interface ZLinkInMemoryAuthorityValidation {
     isOwnerLive(owner: ZLinkLocationOwnerToken): boolean;
     isTargetLive(descriptor: ZLinkMeshNodeDescriptorKey, lifecycleGeneration: bigint, owner: ZLinkLocationOwnerToken): boolean;
     placementCapacityAvailable?(descriptor: ZLinkMeshNodeDescriptorKey, requested: ZLinkCapacityVector, currentReserved: ZLinkCapacityVector, currentActive: ZLinkCapacityVector): boolean;
     identityClaimed?(authorityKey: string): boolean;
+    hasSpotMembers?(spotId: string, objectGeneration: bigint): boolean;
 }
 /**
  * In-memory reference provider for the provider-owned authority state machine.
@@ -27,7 +28,8 @@ export declare class ZLinkInMemoryAuthorityStore {
     compareExchangeAuthority(key: ZLinkAuthorityKey, expectedStoreVersion: ZLinkAuthorityStoreVersion, mutation: ZLinkAuthorityMutation, signal?: AbortSignal): Promise<ZLinkAuthorityCompareExchangeResult>;
     listAuthorities(prefix: string, cursor: ZLinkAuthorityScanCursor | undefined, limit: number, signal?: AbortSignal): Promise<ZLinkAuthorityScanResult>;
     removeAllByOwner(owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<bigint>;
-    releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal): Promise<boolean>;
+    releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal, request?: ZLinkEndedOwnerReleaseIntent): Promise<boolean>;
+    acceptsUserSpotMembership(spotId: string, objectGeneration: bigint): boolean;
     private tryReleaseEndedReservation;
     reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal): Promise<ZLinkObjectReserveResult>;
     commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal): Promise<ZLinkObjectCommitResult>;

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

@@ -11,6 +11,9 @@ const actor_join_recovery_codec_1 = require("../foundation/actor-join-recovery-c
 const authority_key_codec_1 = require("./authority-key-codec");
 const opaque_record_key_1 = require("./opaque-record-key");
 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");
+const contracts_2 = require("../../contracts");
 const MAX_GENERATION = 0x7fffffffffffffffn;
 const CREATION_TERMINAL_RETENTION_MS = 5 * 60 * 1000;
 const MAX_U64 = stream_wire_1.UINT64_MAX;
@@ -108,6 +111,18 @@ class ZLinkInMemoryAuthorityStore {
         if (!this.isOwnerLive(row.snapshot)) {
             return { kind: 'conflict', current: this.read(keyValue) };
         }
+        const actor = row.snapshot.allocation.objectKind === 'actor'
+            ? (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(mutation.payload))
+            : undefined;
+        const previousActor = actor === undefined
+            ? undefined
+            : (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(row.snapshot.payload));
+        if (actor?.currentSpotKind === contracts_2.ZLinkSpotKind.User &&
+            (previousActor?.currentSpotKind !== contracts_2.ZLinkSpotKind.User ||
+                previousActor.currentSpotId !== actor.currentSpotId ||
+                previousActor.currentSpotGeneration !== actor.currentSpotGeneration) &&
+            !this.acceptsUserSpotMembership(actor.currentSpotId, actor.currentSpotGeneration))
+            return { kind: 'conflict', current: this.read(keyValue) };
         if (mutation.generationTransition === 'reincarnate' &&
             (this.objectGeneration >= MAX_GENERATION || this.ownerGeneration >= MAX_GENERATION)) {
             return { kind: 'generationExhausted' };
@@ -174,33 +189,67 @@ class ZLinkInMemoryAuthorityStore {
             this.scanRevision++;
         return BigInt(removed);
     }
-    async releaseEndedReservation(key, expectedStoreVersion, signal) {
+    async releaseEndedReservation(key, expectedStoreVersion, signal, request) {
         signal?.throwIfAborted();
-        return this.tryReleaseEndedReservation(key, expectedStoreVersion);
+        return this.tryReleaseEndedReservation(key, expectedStoreVersion, request);
+    }
+    acceptsUserSpotMembership(spotId, objectGeneration) {
+        const row = this.rows.get((0, authority_key_codec_1.encodeAuthorityKey)('user_spot', spotId).value);
+        return (row !== undefined &&
+            row.snapshot.allocation.objectKind === 'user_spot' &&
+            row.snapshot.allocation.state === 'active' &&
+            row.snapshot.objectGeneration === objectGeneration &&
+            (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(row.snapshot.payload)?.kind === 'user_spot' &&
+            this.isOwnerLive(row.snapshot));
     }
     tryReleaseEndedReservation(key, expectedStoreVersion, request) {
         const current = this.rows.get(key.value);
         if (current === undefined ||
             current.snapshot.storeVersion.value !== expectedStoreVersion ||
             (current.snapshot.allocation.state === 'active'
-                ? request?.key.kind !== 'actor'
+                ? request === undefined
                 : current.creation === undefined))
             return false;
         if (current.snapshot.allocation.state === 'active') {
+            let unavailable = false;
             for (const aggregate of this.aggregates.values()) {
                 if (aggregate.state === 'prepared' &&
                     aggregate.request.participants.some((participant) => participant.authorityKey.value === key.value))
-                    return false;
+                    unavailable = true;
             }
-            if (relocationAuthorityCodec.read(current.snapshot.payload) !== undefined)
-                return false;
+            unavailable ||= relocationAuthorityCodec.read(current.snapshot.payload) !== undefined;
             if (this.validation.isOwnerLive({
                 ownerId: current.snapshot.ownerId,
                 leaseGeneration: current.snapshot.ownerLeaseGeneration
             }))
                 return false;
-            if (request?.actorRelocationPolicy !== 'disabled')
-                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'Actor owner lease is unavailable.');
+            const spot = current.snapshot.allocation.objectKind === 'actor'
+                ? undefined
+                : (0, service_authority_payload_codec_1.decodeServiceReadySpotAuthority)(current.snapshot.payload);
+            if (current.snapshot.allocation.objectKind !== 'actor') {
+                unavailable ||=
+                    spot === undefined ||
+                        spot.kind !== request?.key.kind ||
+                        spot.stableType !== request.intent.stableType ||
+                        spot.spotId !== request.key.globalId ||
+                        spot.activationRecovery !== undefined;
+                if (spot?.kind === 'user_spot') {
+                    unavailable ||=
+                        this.validation.hasSpotMembers?.(spot.spotId, current.snapshot.objectGeneration) ===
+                            true;
+                    for (const row of this.rows.values()) {
+                        if (row.snapshot.allocation.objectKind !== 'actor')
+                            continue;
+                        const actor = (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(row.snapshot.payload));
+                        unavailable ||=
+                            actor?.currentSpotKind === contracts_2.ZLinkSpotKind.User &&
+                                actor.currentSpotId === spot.spotId &&
+                                actor.currentSpotGeneration === current.snapshot.objectGeneration;
+                    }
+                }
+            }
+            if (unavailable || request?.actorRelocationPolicy !== 'disabled')
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'Object owner lease is unavailable.');
         }
         else if (this.validation.isTargetLive(current.snapshot.allocation.descriptor, current.snapshot.allocation.descriptorLifecycleGeneration, {
             ownerId: current.snapshot.ownerId,
@@ -357,6 +406,12 @@ class ZLinkInMemoryAuthorityStore {
         if (!this.creationTerminalAvailable(terminalRecord)) {
             return { kind: 'stale' };
         }
+        const actor = request.completion.kind === 'created'
+            ? (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(request.completion.readyPayload))
+            : undefined;
+        if (actor?.currentSpotKind === contracts_2.ZLinkSpotKind.User &&
+            !this.acceptsUserSpotMembership(actor.currentSpotId, actor.currentSpotGeneration))
+            return { kind: 'stale' };
         const nextVersion = this.tryNextStoreVersion();
         if (nextVersion === undefined)
             return { kind: 'generationExhausted' };
@@ -500,6 +555,23 @@ class ZLinkInMemoryAuthorityStore {
                 row.snapshot.storeVersion.value !== participant.expectedStoreVersion.value) {
                 return { kind: 'stale' };
             }
+            const actor = row.snapshot.allocation.objectKind === 'actor'
+                ? (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)((0, service_relocation_runtime_1.serviceRelocationAuthorityApplicationPayload)(participant.authorityPayload))
+                : undefined;
+            if (actor?.currentSpotKind === contracts_2.ZLinkSpotKind.User) {
+                const participantSpot = aggregate.request.participants.find((candidate) => candidate.authorityKey.value ===
+                    (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', actor.currentSpotId).value);
+                if (participantSpot === undefined) {
+                    if (!this.acceptsUserSpotMembership(actor.currentSpotId, actor.currentSpotGeneration))
+                        return { kind: 'stale' };
+                }
+                else {
+                    const spot = this.rows.get(participantSpot.authorityKey.value);
+                    if (spot?.snapshot.allocation.objectKind !== 'user_spot' ||
+                        spot.snapshot.objectGeneration !== actor.currentSpotGeneration)
+                        return { kind: 'stale' };
+                }
+            }
             if (participant.ownerTransition === 'newOwner') {
                 if (!this.validation.isTargetLive(aggregate.request.targetDescriptor, aggregate.request.targetDescriptorLifecycleGeneration, aggregate.request.targetOwner)) {
                     return { kind: 'stale' };

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

@@ -1,6 +1,6 @@
 import type { ZLinkActorTransferPrepareRequest, ZLinkActorTransferRecord, ZLinkActorTransferWriteResult } from '../../contracts/Locations/ActorTransfer';
 import type { ZLinkDomainLocationStore } from './domain-store-contract';
-import { ZLinkLocationWriteIntent, ZLinkLocationWriteStatus, type ZLinkActorLocation, type ZLinkActorLocationFilter, type ZLinkActorLocationKey, type ZLinkAggregateAbortResult, type ZLinkAggregateCommitResult, type ZLinkAggregateFence, type ZLinkAggregatePrepareRequest, type ZLinkAggregatePrepareResult, type ZLinkAuthorityCompareExchangeResult, type ZLinkAuthorityKey, type ZLinkAuthorityMutation, type ZLinkAuthorityReadResult, type ZLinkAuthorityScanCursor, type ZLinkAuthorityScanResult, type ZLinkAuthorityStoreVersion, type ZLinkClientServerServerDescriptor, type ZLinkClientServerServerDescriptorKey, type ZLinkCreationOperationIdentity, type ZLinkCreationTerminalReadResult, type ZLinkFanoutPublisherDescriptor, type ZLinkFanoutPublisherDescriptorKey, type ZLinkLocationChangeStampScope, type ZLinkLocationOwnerToken, type ZLinkLocationPage, type ZLinkLocationWriteResult, type ZLinkMeshNodeDescriptor, type ZLinkMeshNodeDescriptorKey, type ZLinkObjectAbortRequest, type ZLinkObjectAbortResult, type ZLinkObjectCommitRequest, type ZLinkObjectCommitResult, type ZLinkObjectCreationCompleteRequest, type ZLinkObjectCreationCompleteResult, type ZLinkObjectReserveRequest, type ZLinkObjectReserveResult, type ZLinkOwnerLeaseClaimResult, type ZLinkOwnerLeaseReadResult, type ZLinkOwnerLeaseReleaseResult, type ZLinkOwnerLeaseRenewResult, type ZLinkPageRequest, type ZLinkPeerLocation, type ZLinkPeerLocationFilter, type ZLinkPeerLocationKey, type ZLinkRouteLocation, type ZLinkRouteLocationFilter, type ZLinkRouteLocationKey, type ZLinkSpotLocation, type ZLinkSpotLocationFilter, type ZLinkSpotLocationKey } from './internal-location-contracts';
+import { ZLinkLocationWriteIntent, ZLinkLocationWriteStatus, type ZLinkActorLocation, type ZLinkActorLocationFilter, type ZLinkActorLocationKey, type ZLinkAggregateAbortResult, type ZLinkAggregateCommitResult, type ZLinkAggregateFence, type ZLinkAggregatePrepareRequest, type ZLinkAggregatePrepareResult, type ZLinkAuthorityCompareExchangeResult, type ZLinkAuthorityKey, type ZLinkAuthorityMutation, type ZLinkAuthorityReadResult, type ZLinkAuthorityScanCursor, type ZLinkAuthorityScanResult, type ZLinkAuthorityStoreVersion, type ZLinkClientServerServerDescriptor, type ZLinkClientServerServerDescriptorKey, type ZLinkCreationOperationIdentity, type ZLinkCreationTerminalReadResult, type ZLinkFanoutPublisherDescriptor, type ZLinkFanoutPublisherDescriptorKey, type ZLinkLocationChangeStampScope, type ZLinkLocationOwnerToken, type ZLinkLocationPage, type ZLinkLocationWriteResult, type ZLinkMeshNodeDescriptor, type ZLinkMeshNodeDescriptorKey, type ZLinkObjectAbortRequest, type ZLinkObjectAbortResult, type ZLinkObjectCommitRequest, type ZLinkObjectCommitResult, type ZLinkObjectCreationCompleteRequest, type ZLinkObjectCreationCompleteResult, type ZLinkEndedOwnerReleaseIntent, type ZLinkObjectReserveRequest, type ZLinkObjectReserveResult, type ZLinkOwnerLeaseClaimResult, type ZLinkOwnerLeaseReadResult, type ZLinkOwnerLeaseReleaseResult, type ZLinkOwnerLeaseRenewResult, type ZLinkPageRequest, type ZLinkPeerLocation, type ZLinkPeerLocationFilter, type ZLinkPeerLocationKey, type ZLinkRouteLocation, type ZLinkRouteLocationFilter, type ZLinkRouteLocationKey, type ZLinkSpotLocation, type ZLinkSpotLocationFilter, type ZLinkSpotLocationKey } from './internal-location-contracts';
 import type { ZLinkFanoutLocationStore } from './internal-store-contracts';
 export declare class ZLinkInMemoryLocationStore implements ZLinkDomainLocationStore, ZLinkFanoutLocationStore {
     private readonly now;
@@ -25,7 +25,7 @@ export declare class ZLinkInMemoryLocationStore implements ZLinkDomainLocationSt
     commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal): Promise<ZLinkObjectCommitResult>;
     completeCreation(request: ZLinkObjectCreationCompleteRequest, signal?: AbortSignal): Promise<ZLinkObjectCreationCompleteResult>;
     readCreationTerminal(operation: ZLinkCreationOperationIdentity, signal?: AbortSignal): Promise<ZLinkCreationTerminalReadResult>;
-    releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal): Promise<boolean>;
+    releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal, request?: ZLinkEndedOwnerReleaseIntent): Promise<boolean>;
     abort(request: ZLinkObjectAbortRequest, signal?: AbortSignal): Promise<ZLinkObjectAbortResult>;
     prepareAggregate(request: ZLinkAggregatePrepareRequest, signal?: AbortSignal): Promise<ZLinkAggregatePrepareResult>;
     commitAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateCommitResult>;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkInMemoryLocationStore = void 0;
+const contracts_1 = require("../../contracts");
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
 const RegistrationBuilderPolicy_1 = require("../../contracts/Configuration/RegistrationBuilderPolicy");
 const location_store_integration_1 = require("../../location-store-integration");
@@ -62,7 +63,16 @@ class ZLinkInMemoryLocationStore {
                                     spotType.count <=
                                     typeCapacity.limit))));
             },
-            identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey)
+            identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey),
+            hasSpotMembers: (spotId, objectGeneration) => {
+                for (const actor of this.actors.rows.values()) {
+                    if (actor.spotKind === contracts_1.ZLinkSpotKind.User &&
+                        String(actor.spotId) === spotId &&
+                        actor.spotGeneration === objectGeneration)
+                        return true;
+                }
+                return false;
+            }
         }, now);
     }
     async readAuthority(key, signal) {
@@ -86,8 +96,8 @@ class ZLinkInMemoryLocationStore {
     async readCreationTerminal(operation, signal) {
         return this.authority.readCreationTerminal(operation, signal);
     }
-    async releaseEndedReservation(key, expectedStoreVersion, signal) {
-        return this.authority.releaseEndedReservation(key, expectedStoreVersion, signal);
+    async releaseEndedReservation(key, expectedStoreVersion, signal, request) {
+        return this.authority.releaseEndedReservation(key, expectedStoreVersion, signal, request);
     }
     async abort(request, signal) {
         return this.authority.abort(request, signal);
@@ -389,6 +399,12 @@ class ZLinkInMemoryLocationStore {
         });
         const updatedAt = this.now();
         const current = this.actors.rows.get(key);
+        if (actor.spotKind === contracts_1.ZLinkSpotKind.User &&
+            (current?.spotKind !== contracts_1.ZLinkSpotKind.User ||
+                String(current.spotId) !== String(actor.spotId) ||
+                current.spotGeneration !== actor.spotGeneration) &&
+            !this.authority.acceptsUserSpotMembership(String(actor.spotId), actor.spotGeneration))
+            return rejectedConflict();
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim &&
             current !== undefined &&
             this.liveOwnerLease(current.ownerId, updatedAt) !== undefined) {

package/dist/runtime/locations/internal-location-contracts.d.ts

@@ -4,6 +4,9 @@ import type { ZLinkRelocationConfiguration } from '../../contracts/Configuration
 export interface ZLinkObjectReserveRequest extends ReserveRequest {
     readonly actorRelocationPolicy?: ZLinkRelocationConfiguration<unknown>['kind'];
 }
+export type ZLinkEndedOwnerReleaseIntent = Pick<ZLinkObjectReserveRequest, 'key' | 'actorRelocationPolicy'> & {
+    readonly intent: Pick<ZLinkObjectReserveRequest['intent'], 'stableType'>;
+};
 export type * from '../../contracts/Locations/Authority';
 export type { ZLinkActorLocation, ZLinkPeerLocation, ZLinkRouteLocation, ZLinkSpotLocation } from '../../contracts/Locations/Rows';
 export type { ZLinkActorLocationFilter, ZLinkActorLocationKey, ZLinkLocationKey, ZLinkPeerLocationFilter, ZLinkPeerLocationKey, ZLinkRouteLocationFilter, ZLinkRouteLocationKey, ZLinkSpotLocationFilter, ZLinkSpotLocationKey } from '../../contracts/Locations/Keys';

package/dist/runtime/locations/lifecycle.d.ts

@@ -19,8 +19,7 @@ export declare class ZLinkLocationLifecycle {
     claimActor(actorType: string, actorId: string, nodeRid: RoutingId, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
     setActorRef(actorType: string, actorId: string, actorRef: ActorRef, ownerNodeGeneration?: bigint): Promise<void>;
     takeoverActorJoinedSpot(actorType: string, actorId: string, actorRef: ActorRef, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint, deactivate?: () => Promise<void>): Promise<ZLinkActorClaimResult>;
-    notifyActorJoinedSpot(actorType: string, actorId: string, spotMeshName: string, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
-    notifyActorLeftSpot(actorType: string, actorId: string, entrySpotId: RoutingId, entrySpotGeneration: bigint, membershipEpoch: bigint, ownerNodeGeneration: bigint): Promise<void>;
+    commitActorMembership(actorType: string, actorRef: ActorRef, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User, ownerNodeGeneration: bigint): Promise<void>;
     releaseActor(actorType: string, actorId: string, actorRef?: ActorRef): Promise<void>;
     ownsActor(actorType: string, actorId: string): boolean;
     actorLocationSnapshot(actorId: string): ZLinkActorLocation | undefined;

package/dist/runtime/locations/lifecycle.js

@@ -34,11 +34,8 @@ class ZLinkLocationLifecycle {
     async takeoverActorJoinedSpot(actorType, actorId, actorRef, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration, deactivate) {
         return await this.actorClaims.takeoverJoinedSpot(actorType, actorId, actorRef, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration, deactivate);
     }
-    async notifyActorJoinedSpot(actorType, actorId, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.actorClaims.notifyJoinedSpot(actorType, actorId, spotMeshName, spotId, spotGeneration, membershipEpoch, ownerNodeGeneration);
-    }
-    async notifyActorLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration) {
-        await this.actorClaims.notifyLeftSpot(actorType, actorId, entrySpotId, entrySpotGeneration, membershipEpoch, ownerNodeGeneration);
+    async commitActorMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration) {
+        await this.actorClaims.commitMembership(actorType, actorRef, authorityOwnerGeneration, spotId, spotGeneration, spotKind, ownerNodeGeneration);
     }
     async releaseActor(actorType, actorId, actorRef) {
         await this.actorClaims.release(actorType, actorId, actorRef);

package/dist/runtime/locations/location-store-repository.d.ts

@@ -1,6 +1,6 @@
 import { type ZLinkClientServerServerDescriptor, type ZLinkClientServerServerDescriptorKey, type ZLinkFanoutPublisherDescriptor, type ZLinkFanoutPublisherDescriptorKey, type ZLinkLocationPage, type ZLinkLocationStore, type ZLinkMeshNodeDescriptor, type ZLinkMeshNodeDescriptorKey, type ZLinkPageRequest } from '../../contracts';
 import { ZLinkInMemoryLocationStore } from './in-memory-location-store';
-import { type ZLinkActorLocation, type ZLinkActorLocationFilter, type ZLinkActorLocationKey, type ZLinkAggregateAbortResult, type ZLinkAggregateCommitResult, type ZLinkAggregateFence, type ZLinkAggregatePrepareRequest, type ZLinkAggregatePrepareResult, type ZLinkAuthorityCompareExchangeResult, type ZLinkAuthorityKey, type ZLinkAuthorityMutation, type ZLinkAuthorityReadResult, type ZLinkAuthorityScanCursor, type ZLinkAuthorityScanResult, type ZLinkAuthorityStoreVersion, type ZLinkCreationOperationIdentity, type ZLinkCreationTerminalReadResult, type ZLinkLocationOwnerToken, type ZLinkLocationWriteResult, type ZLinkLocationWriteStatus, type ZLinkObjectAbortRequest, type ZLinkObjectAbortResult, type ZLinkObjectCommitRequest, type ZLinkObjectCommitResult, type ZLinkObjectCreationCompleteRequest, type ZLinkObjectCreationCompleteResult, type ZLinkObjectReserveRequest, type ZLinkObjectReserveResult, type ZLinkOwnerLeaseClaimResult, type ZLinkOwnerLeaseReadResult, type ZLinkOwnerLeaseReleaseResult, type ZLinkOwnerLeaseRenewResult, type ZLinkRouteLocation, type ZLinkRouteLocationFilter, type ZLinkRouteLocationKey, type ZLinkSpotLocation, type ZLinkSpotLocationFilter, type ZLinkSpotLocationKey, ZLinkLocationWriteIntent } from './internal-location-contracts';
+import { type ZLinkActorLocation, type ZLinkActorLocationFilter, type ZLinkActorLocationKey, type ZLinkAggregateAbortResult, type ZLinkAggregateCommitResult, type ZLinkAggregateFence, type ZLinkAggregatePrepareRequest, type ZLinkAggregatePrepareResult, type ZLinkAuthorityCompareExchangeResult, type ZLinkAuthorityKey, type ZLinkAuthorityMutation, type ZLinkAuthorityReadResult, type ZLinkAuthorityScanCursor, type ZLinkAuthorityScanResult, type ZLinkAuthorityStoreVersion, type ZLinkCreationOperationIdentity, type ZLinkCreationTerminalReadResult, type ZLinkLocationOwnerToken, type ZLinkLocationWriteResult, type ZLinkLocationWriteStatus, type ZLinkObjectAbortRequest, type ZLinkObjectAbortResult, type ZLinkObjectCommitRequest, type ZLinkObjectCommitResult, type ZLinkObjectCreationCompleteRequest, type ZLinkObjectCreationCompleteResult, type ZLinkEndedOwnerReleaseIntent, type ZLinkObjectReserveRequest, type ZLinkObjectReserveResult, type ZLinkOwnerLeaseClaimResult, type ZLinkOwnerLeaseReadResult, type ZLinkOwnerLeaseReleaseResult, type ZLinkOwnerLeaseRenewResult, type ZLinkRouteLocation, type ZLinkRouteLocationFilter, type ZLinkRouteLocationKey, type ZLinkSpotLocation, type ZLinkSpotLocationFilter, type ZLinkSpotLocationKey, ZLinkLocationWriteIntent } from './internal-location-contracts';
 /**
  * Maps framework domain records to the minimal provider SPI.
  *
@@ -20,7 +20,7 @@ export declare class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationS
     commitAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateCommitResult>;
     private commitAggregateCore;
     abortAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateAbortResult>;
-    releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal): Promise<boolean>;
+    releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal, request?: ZLinkEndedOwnerReleaseIntent): Promise<boolean>;
     private tryReleaseEndedReservation;
     reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectReserveResult>;
     commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectCommitResult>;
@@ -59,6 +59,7 @@ export declare class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationS
     private writeDescriptorWithReconciliation;
     private removeDescriptor;
     private listDescriptors;
+    private userSpotMembershipConditions;
     private updateOwnedLocation;
     private removeOwnedLocation;
     private readOwnedLocation;