@zlink-systems/framework 0.30.1 → 0.30.2

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotRuntimeOptionsFactory = void 0;
+const routing_id_1 = require("../routing-id");
 const contracts_1 = require("../../contracts");
 const actors_1 = require("../actors");
 const channels_1 = require("../channels");
@@ -39,6 +40,13 @@ class ZLinkSpotRuntimeOptionsFactory {
                 }
                 await runtime.dispatchEntryActorJoin(meshName, actor, handoffBacklog);
             },
+            admitEntryActorPacketPrefix: (meshName, actorId, records) => {
+                const runtime = this.options.spotNodeRuntime();
+                if (runtime === undefined) {
+                    throw new configuration_1.ZLinkConfigurationException('Entry Actor replay requires the MeshNode runtime.');
+                }
+                return runtime.admitEntryActorPacketPrefix(meshName, actorId, records);
+            },
             executeEntryActor: (meshName, actorId, operation) => {
                 const runtime = this.options.spotNodeRuntime();
                 if (runtime === undefined) {
@@ -135,8 +143,9 @@ class ZLinkSpotRuntimeOptionsFactory {
             nativeSpotNodeProvider: (meshName) => this.options.spotNodeRuntime()?.meshNode(meshName),
             spotRouteResolver: this.options.createLocationSpotRouteResolver(),
             actorResolver: (actorId) => {
-                const state = this.options.actorManager()?.getState(actorId);
-                return state?.isMoving === true ? undefined : state?.actor;
+                const manager = this.options.actorManager();
+                const state = manager?.getState(actorId);
+                return state?.isMoving === true ? undefined : manager?.resolveLocalActor(actorId);
             },
             canonicalActorJoinResolver: (fence) => this.options.boundSessionRelay.actorJoins.prepareCanonicalActorJoin({
                 actorId: fence.actorId,
@@ -152,13 +161,12 @@ class ZLinkSpotRuntimeOptionsFactory {
                 const actorRef = state?.nativeActorRef === undefined
                     ? undefined
                     : (0, actors_1.toFrameworkActorRef)(state.nativeActorRef, state.meshName ?? '');
-                const localNodeRid = this.primaryNodeRoutingId();
+                const localNodeRid = state?.meshName === undefined ? undefined : this.meshNodeRoutingId(state.meshName);
                 if (state?.actor === undefined ||
-                    state.spot === undefined ||
                     state.remoteActorPacketTarget !== undefined ||
                     actorRef === undefined ||
                     localNodeRid === undefined ||
-                    String(actorRef.nodeRid) !== localNodeRid) {
+                    !(0, routing_id_1.routingIdsEqual)(actorRef.nodeRid, localNodeRid)) {
                     return {};
                 }
                 return {
@@ -193,11 +201,11 @@ class ZLinkSpotRuntimeOptionsFactory {
     }
     primaryNodeRoutingId() {
         const node = this.primaryNode();
-        return node === undefined ? undefined : String(node.status().routingId);
+        return node === undefined ? undefined : node.status().routingId;
     }
     meshNodeRoutingId(meshName) {
         const node = this.options.spotNodeRuntime()?.meshNode(meshName);
-        return node === undefined ? undefined : String(node.status().routingId);
+        return node === undefined ? undefined : node.status().routingId;
     }
 }
 exports.ZLinkSpotRuntimeOptionsFactory = ZLinkSpotRuntimeOptionsFactory;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkUserSpotCreationCoordinator = void 0;
 exports.encodeLocationCreationContent = encodeLocationCreationContent;
 exports.decodeLocationCreationContent = decodeLocationCreationContent;
+const routing_id_1 = require("../routing-id");
 const node_crypto_1 = require("node:crypto");
 const contracts_1 = require("../../contracts");
 const service_authority_payload_codec_1 = require("../foundation/service-authority-payload-codec");
@@ -32,7 +33,6 @@ class ZLinkUserSpotCreationCoordinator {
         const contentReference = encodeLocationCreationContent(request.requestPayload);
         const excludedNodeRids = new Set();
         let target;
-        let authorityTarget;
         let reserved;
         for (;;) {
             try {
@@ -48,12 +48,12 @@ class ZLinkUserSpotCreationCoordinator {
                 deadline.close();
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted, 'No eligible User Spot placement target is ready.', true);
             }
-            if (excludedNodeRids.has(String(target.nodeRid))) {
+            if (excludedNodeRids.has((0, routing_id_1.encodeRoutingIdStorageHex)(target.nodeRid))) {
                 deadline.close();
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted, 'No additional User Spot placement target is ready.', true);
             }
             const owner = target.owner;
-            authorityTarget = {
+            const authorityTarget = {
                 meshName: target.meshName,
                 nodeRid: target.nodeRid,
                 nodeLifecycleGeneration: target.nodeGeneration,
@@ -97,84 +97,31 @@ class ZLinkUserSpotCreationCoordinator {
                     throw error;
                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed, 'User Spot reservation Store operation failed.', false, error);
             }
-            if (reserved.kind !== 'placementCapacityExhausted')
-                break;
-            excludedNodeRids.add(String(target.nodeRid));
-        }
-        if (reserved.kind === 'alreadyExists' ||
-            (reserved.kind === 'conflict' &&
-                reserved.current.kind === 'snapshot' &&
-                reserved.current.allocation.objectKind === 'user_spot' &&
-                reserved.current.allocation.stableType === request.stableType)) {
-            const current = reserved.kind === 'alreadyExists' ? reserved.current : reserved.current;
-            if (current.kind === 'snapshot' && current.allocation.state === 'active') {
+            if (reserved.kind === 'alreadyExists' ||
+                (reserved.kind === 'conflict' &&
+                    reserved.current.kind === 'snapshot' &&
+                    reserved.current.allocation.objectKind === 'user_spot' &&
+                    reserved.current.allocation.stableType === request.stableType)) {
                 if (request.generatedIdentity === true) {
                     deadline.close();
                     throw spotIdConflict(request.spotId);
                 }
-                const spot = spotRef(current, request);
-                deadline.close();
-                return {
-                    result: { spot, state: contracts_1.ZLinkSpotCreateState.Existing },
-                    spot
-                };
-            }
-            if (current.kind !== 'snapshot' || !sameCreationTarget(current, authorityTarget)) {
-                deadline.close();
-                if (request.generatedIdentity === true) {
-                    throw spotIdConflict(request.spotId);
-                }
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed, 'User Spot creation requires a remote generation-fenced create operation.');
-            }
-            if (current.allocation.state === 'reserved' && !target.isLocal) {
                 try {
-                    return await this.remoteCreate(request, current, target.nodeRid, target.nodeGeneration, deadlineUnixMs, deadlineMs);
-                }
-                finally {
-                    deadline.close();
-                }
-            }
-            if (current.allocation.state === 'reserved' && target.isLocal) {
-                const pending = current.pendingCreation;
-                const admitted = pending === undefined ? undefined : this.localCreations.get(pending.reservationId);
-                if (admitted === undefined) {
-                    try {
-                        const spot = await this.awaitReady(request, signal);
-                        return {
-                            result: { spot, state: contracts_1.ZLinkSpotCreateState.Existing },
-                            spot
-                        };
-                    }
-                    finally {
+                    const spot = await this.awaitReady(request, signal);
+                    if (spot !== undefined) {
                         deadline.close();
+                        return { result: { spot, state: contracts_1.ZLinkSpotCreateState.Existing }, spot };
                     }
                 }
-                try {
-                    const result = await admitted;
-                    return result.result.state === contracts_1.ZLinkSpotCreateState.Created
-                        ? {
-                            result: {
-                                ...result.result,
-                                state: contracts_1.ZLinkSpotCreateState.Existing
-                            },
-                            spot: result.spot
-                        }
-                        : result;
-                }
-                finally {
+                catch (error) {
                     deadline.close();
+                    throw error;
                 }
+                continue;
             }
-            try {
-                const spot = await this.awaitReady(request, signal);
-                return {
-                    result: { spot, state: contracts_1.ZLinkSpotCreateState.Existing },
-                    spot
-                };
-            }
-            finally {
-                deadline.close();
-            }
+            if (reserved.kind !== 'placementCapacityExhausted')
+                break;
+            excludedNodeRids.add((0, routing_id_1.encodeRoutingIdStorageHex)(target.nodeRid));
         }
         if (reserved.kind === 'typeMismatch') {
             deadline.close();
@@ -272,7 +219,7 @@ class ZLinkUserSpotCreationCoordinator {
                 current.allocation.stableType === record.stableType &&
                 current.objectGeneration === record.reservation.objectGeneration &&
                 current.authorityOwnerGeneration === record.reservation.authorityOwnerGeneration &&
-                String(current.allocation.descriptor.rid) === record.reservation.targetNodeRid &&
+                (0, routing_id_1.routingIdsEqual)(current.allocation.descriptor.rid, record.reservation.targetNodeRid) &&
                 current.allocation.descriptorLifecycleGeneration ===
                     record.reservation.targetNodeGeneration &&
                 current.ownerId === record.reservation.targetOwnerId &&
@@ -313,7 +260,7 @@ class ZLinkUserSpotCreationCoordinator {
         try {
             local = await materialize(requestPayload, current, signal ?? new AbortController().signal);
             if (local.state === contracts_1.ZLinkSpotCreateState.Rejected) {
-                local.publication?.abort();
+                await local.publication?.abort();
                 await this.options.store.abort({
                     key: { kind: 'user_spot', globalId: record.spotId },
                     reservationId: pending.reservationId,
@@ -372,14 +319,16 @@ class ZLinkUserSpotCreationCoordinator {
                 objectGeneration: committed.ready.objectGeneration
             };
             this.options.publishReadyRoute?.(committed.ready.allocation.descriptor.meshName, readySpotRoute(record.spotId, committed.ready));
-            local.publication?.publish();
+            await local.publication?.publish();
             return {
                 result: { spot: readySpot, state: local.state, reply: local.reply },
                 spot: readySpot
             };
         }
         catch (error) {
-            local?.publication?.abort();
+            const publicationCleanup = await Promise.allSettled([
+                Promise.resolve().then(() => local?.publication?.abort())
+            ]);
             const cleanupDeadline = createDeadline(this.options.cleanupTimeoutMs ?? DEFAULT_USER_SPOT_CLEANUP_TIMEOUT_MS);
             const cleanupSignal = cleanupDeadline.signal;
             const cleanup = await Promise.allSettled([
@@ -400,7 +349,7 @@ class ZLinkUserSpotCreationCoordinator {
                 waitForAbort(discard?.(cleanupSignal) ?? Promise.resolve(), cleanupSignal)
             ]);
             cleanupDeadline.close();
-            const cleanupErrors = cleanup
+            const cleanupErrors = [...publicationCleanup, ...cleanup]
                 .filter((item) => item.status === 'rejected')
                 .map((item) => item.reason);
             if (cleanupErrors.length > 0) {
@@ -475,7 +424,14 @@ class ZLinkUserSpotCreationCoordinator {
         for (;;) {
             signal.throwIfAborted();
             const current = await this.options.store.readAuthority(key, signal);
-            if (current.kind === 'snapshot' && current.allocation.state === 'active') {
+            if (current.kind === 'missing')
+                return undefined;
+            if (current.allocation.objectKind !== 'user_spot' ||
+                current.allocation.stableType !== request.stableType) {
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotTypeMismatch, `User Spot '${String(request.spotId)}' has another stable type.`);
+            }
+            if (current.allocation.state === 'active' &&
+                (0, service_authority_payload_codec_1.decodeServiceClosingSpotAuthority)(current.payload) === undefined) {
                 return spotRef(current, request);
             }
             await wait(this.options.pollIntervalMs ?? DEFAULT_USER_SPOT_POLL_INTERVAL_MS, signal);
@@ -574,7 +530,7 @@ function requireCloseTarget(current, spotId, fence) {
         decoded.ownerLeaseGeneration !== current.ownerLeaseGeneration ||
         allocation.objectKind !== 'user_spot' ||
         allocation.state !== 'active' ||
-        String(allocation.descriptor.rid) !== fence.nodeRid ||
+        !(0, routing_id_1.routingIdsEqual)(allocation.descriptor.rid, fence.nodeRid) ||
         (fence.meshName !== undefined && allocation.descriptor.meshName !== fence.meshName) ||
         (fence.nodeGeneration !== undefined &&
             allocation.descriptorLifecycleGeneration !== fence.nodeGeneration) ||
@@ -662,13 +618,6 @@ function decodeLocationCreationContent(reference, expectedSha256, expectedEncode
     }
     return payload;
 }
-function sameCreationTarget(snapshot, target) {
-    return (snapshot.allocation.descriptor.meshName === target.meshName &&
-        String(snapshot.allocation.descriptor.rid) === String(target.nodeRid) &&
-        snapshot.allocation.descriptorLifecycleGeneration === target.nodeLifecycleGeneration &&
-        snapshot.ownerId === target.owner.ownerId &&
-        snapshot.ownerLeaseGeneration === target.owner.leaseGeneration);
-}
 function remoteCreationFingerprint(record) {
     return JSON.stringify({
         spotId: record.spotId,

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

@@ -28,10 +28,12 @@ export declare class ZLinkAutoConnectLoop {
     private lastTickFailed;
     constructor(options: ZLinkAutoConnectLoopOptions);
     start(signal?: AbortSignal): Promise<void>;
+    requestPeerReconcile(meshName: string, _peerRid: string): Promise<void>;
     stop(signal?: AbortSignal): Promise<void>;
     prepareTransportShutdown(): Promise<void>;
     finishTransportShutdown(signal?: AbortSignal): Promise<void>;
     tick(signal?: AbortSignal): Promise<void>;
+    private tickCore;
     private runReconcile;
     private scheduleNext;
 }

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

@@ -40,6 +40,16 @@ class ZLinkAutoConnectLoop {
             return;
         this.scheduleNext();
     }
+    async requestPeerReconcile(meshName, _peerRid) {
+        const controller = this.controller;
+        if (meshName !== this.meshName || controller === undefined)
+            return;
+        // A fresh descriptor scan uses the same RID ordering and connection owner as a periodic tick.
+        await this.lane.run(async () => {
+            if (!controller.signal.aborted)
+                await this.runReconcile(controller.signal);
+        });
+    }
     async stop(signal) {
         await this.prepareTransportShutdown();
         await this.finishTransportShutdown(signal);
@@ -60,7 +70,10 @@ class ZLinkAutoConnectLoop {
         await this.reconciler.unpublishLocal(signal);
     }
     async tick(signal) {
-        const lastTickFailed = await this.lane.run(() => this.lastTickFailed);
+        await this.lane.run(() => this.tickCore(signal));
+    }
+    async tickCore(signal) {
+        const lastTickFailed = this.lastTickFailed;
         if (this.changeStampStore?.getMeshNodeChangeStamp !== undefined && !lastTickFailed) {
             try {
                 const stamp = await this.changeStampStore.getMeshNodeChangeStamp(this.meshName, signal);
@@ -73,11 +86,10 @@ class ZLinkAutoConnectLoop {
                     return;
                 }
                 const tickFailed = await this.runReconcile(signal);
-                if (!tickFailed)
-                    await this.lane.run(() => {
-                        this.lastStamp = stamp;
-                        this.lastLiveOwnerSetVersion = liveOwners;
-                    });
+                if (!tickFailed) {
+                    this.lastStamp = stamp;
+                    this.lastLiveOwnerSetVersion = liveOwners;
+                }
                 return;
             }
             catch {
@@ -85,17 +97,13 @@ class ZLinkAutoConnectLoop {
             }
         }
         await this.runReconcile(signal);
-        await this.lane.run(() => {
-            this.lastStamp = undefined;
-            this.lastLiveOwnerSetVersion = undefined;
-        });
+        this.lastStamp = undefined;
+        this.lastLiveOwnerSetVersion = undefined;
     }
     async runReconcile(signal) {
         await this.reconciler.tick(signal);
-        return await this.lane.run(() => {
-            this.lastTickFailed = this.reconciler.storeFailed;
-            return this.lastTickFailed;
-        });
+        this.lastTickFailed = this.reconciler.storeFailed;
+        return this.lastTickFailed;
     }
     scheduleNext() {
         if (this.controller === undefined || this.controller.signal.aborted) {

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

@@ -148,17 +148,12 @@ class ZLinkAutoConnectReconciler {
                 desired.set(key, target);
         }
         const deferringMissingTargets = this.monotonicNowMs() < (await this.lane.run(() => this.recoveryDeferUntilMs));
-        let staleCandidates = candidates;
         if (deferringMissingTargets) {
-            const retainedCandidates = new Map(candidates);
             const lastDesired = await this.lane.run(() => [...this.lastDesired]);
             for (const [key, target] of lastDesired) {
                 if (!desired.has(key))
                     desired.set(key, target);
-                if (!retainedCandidates.has(key))
-                    retainedCandidates.set(key, target);
             }
-            staleCandidates = retainedCandidates;
         }
         await this.lane.run(() => {
             this.lastDesired = new Map(desired);
@@ -219,7 +214,6 @@ class ZLinkAutoConnectReconciler {
                 });
             }
         }
-        this.executor.disconnectStalePeers?.([...staleCandidates.values()]);
         const activeTargets = await this.lane.run(() => [...this.active]);
         for (const [key, target] of activeTargets) {
             if (!desired.has(key)) {

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

@@ -22,7 +22,6 @@ export interface ZLinkAutoConnectTarget {
 export interface IZLinkAutoConnectExecutor {
     connect(target: ZLinkAutoConnectTarget): Promise<boolean>;
     disconnect(target: ZLinkAutoConnectTarget): void;
-    disconnectStalePeers?(targets: readonly ZLinkAutoConnectTarget[]): void;
     isDisconnected?(target: ZLinkAutoConnectTarget): boolean;
     onDisconnected?(handler: (endpoint: string) => void): void;
     replaceNotRequired?(targets: readonly ZLinkAutoConnectTarget[]): void;

package/dist/runtime/locations/descriptor-publication.d.ts

@@ -0,0 +1,4 @@
+/** A descriptor Store write failed without a confirmed result (Location runtime section 5). */
+export declare class ZLinkDescriptorPublicationUnconfirmedError extends Error {
+    constructor(cause: unknown);
+}

package/dist/runtime/locations/descriptor-publication.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkDescriptorPublicationUnconfirmedError = void 0;
+/** A descriptor Store write failed without a confirmed result (Location runtime section 5). */
+class ZLinkDescriptorPublicationUnconfirmedError extends Error {
+    constructor(cause) {
+        super(cause instanceof Error ? cause.message : String(cause), { cause });
+        this.name = 'ZLinkDescriptorPublicationUnconfirmedError';
+    }
+}
+exports.ZLinkDescriptorPublicationUnconfirmedError = ZLinkDescriptorPublicationUnconfirmedError;

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

@@ -6,6 +6,7 @@ import type { ZLinkObjectReserveRequest, ZLinkEndedOwnerReleaseIntent } from './
  * implement this interface; the framework maps it to the opaque Store SPI.
  */
 export interface ZLinkDomainLocationStore {
+    confirmedCapacity?(key: ZLinkMeshNodeDescriptorKey, limits: ZLinkMeshNodeDescriptor['populationCapacity']): ZLinkMeshNodeDescriptor['populationCapacity'] | undefined;
     updateMeshNode(descriptor: ZLinkMeshNodeDescriptor, intent: ZLinkLocationWriteIntent, signal?: AbortSignal): Promise<ZLinkLocationWriteResult>;
     removeMeshNode(key: ZLinkMeshNodeDescriptorKey, owner: ZLinkLocationOwnerToken, signal?: AbortSignal): Promise<ZLinkLocationWriteStatus>;
     listMeshNodes(meshName: string, page?: ZLinkPageRequest, signal?: AbortSignal): Promise<ZLinkLocationPage<ZLinkMeshNodeDescriptor>>;

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

@@ -4,7 +4,6 @@ export interface ZLinkInMemoryAuthorityValidation {
     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.
@@ -31,6 +30,13 @@ export declare class ZLinkInMemoryAuthorityStore {
     releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal, request?: ZLinkEndedOwnerReleaseIntent): Promise<boolean>;
     acceptsUserSpotMembership(spotId: string, objectGeneration: bigint): boolean;
     private tryReleaseEndedReservation;
+    /**
+     * Every Actor membership of the old User Spot incarnation must belong to an ended-owner
+     * member (location runtime §6.1): a steady Ready, activated authority outside any aggregate
+     * with an invalid owner lease. The release must fit one provider batch; its key set mirrors
+     * the provider repository batch (authorities, owner leases, descriptor and capacity records).
+     */
+    private endedSpotMembers;
     reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal): Promise<ZLinkObjectReserveResult>;
     commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal): Promise<ZLinkObjectCommitResult>;
     completeCreation(request: ZLinkObjectCreationCompleteRequest, signal?: AbortSignal): Promise<ZLinkObjectCreationCompleteResult>;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkInMemoryAuthorityStore = void 0;
+const routing_id_1 = require("../routing-id");
 const InternalDefaults_1 = require("../../contracts/Configuration/InternalDefaults");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
@@ -210,6 +211,7 @@ class ZLinkInMemoryAuthorityStore {
                 ? request === undefined
                 : current.creation === undefined))
             return false;
+        let members = [];
         if (current.snapshot.allocation.state === 'active') {
             let unavailable = false;
             for (const aggregate of this.aggregates.values()) {
@@ -233,20 +235,10 @@ class ZLinkInMemoryAuthorityStore {
                         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 (spot?.kind === 'user_spot' &&
+                    !unavailable &&
+                    request?.actorRelocationPolicy === 'disabled')
+                    members = this.endedSpotMembers(key.value, current.snapshot, spot.spotId);
             }
             if (unavailable || request?.actorRelocationPolicy !== 'disabled')
                 throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'Object owner lease is unavailable.');
@@ -258,11 +250,59 @@ class ZLinkInMemoryAuthorityStore {
             return false;
         this.adjustCapacity(current.snapshot.allocation.state === 'active' ? this.activeCapacity : this.pendingCapacity, current.snapshot.allocation, -1);
         this.rows.delete(key.value);
+        for (const memberKey of members) {
+            const member = this.rows.get(memberKey);
+            this.adjustCapacity(this.activeCapacity, member.snapshot.allocation, -1);
+            this.rows.delete(memberKey);
+        }
         if (current.snapshot.allocation.state === 'reserved' && current.creation !== undefined)
             this.creationTerminals.set(current.creation.reservationId, 'aborted');
         this.scanRevision++;
         return true;
     }
+    /**
+     * Every Actor membership of the old User Spot incarnation must belong to an ended-owner
+     * member (location runtime §6.1): a steady Ready, activated authority outside any aggregate
+     * with an invalid owner lease. The release must fit one provider batch; its key set mirrors
+     * the provider repository batch (authorities, owner leases, descriptor and capacity records).
+     */
+    endedSpotMembers(spotKey, spot, spotId) {
+        const descriptorKey = (descriptor) => `${descriptor.meshName}\0${String(descriptor.rid)}`;
+        const batchKeys = new Set([
+            `authority:${spotKey}`,
+            `owner:${spot.ownerId}`,
+            `descriptor:${descriptorKey(spot.allocation.descriptor)}`,
+            `capacity:${descriptorKey(spot.allocation.descriptor)}`
+        ]);
+        const members = [];
+        for (const [memberKey, row] of this.rows) {
+            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));
+            if (actor?.currentSpotKind !== contracts_2.ZLinkSpotKind.User ||
+                actor.currentSpotId !== spotId ||
+                actor.currentSpotGeneration !== spot.objectGeneration)
+                continue;
+            if (row.snapshot.allocation.state !== 'active' ||
+                [...this.aggregates.values()].some((aggregate) => aggregate.state === 'prepared' &&
+                    aggregate.request.participants.some((participant) => participant.authorityKey.value === memberKey)) ||
+                relocationAuthorityCodec.read(row.snapshot.payload) !== undefined ||
+                (0, actor_authority_payload_codec_1.decodeActorAuthorityPayload)(row.snapshot.payload)?.state !== 'ready')
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'User Spot still has a relocating or unactivated member.');
+            if (this.validation.isOwnerLive({
+                ownerId: row.snapshot.ownerId,
+                leaseGeneration: row.snapshot.ownerLeaseGeneration
+            }))
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'User Spot still has a member with a live owner lease.');
+            members.push(memberKey);
+            batchKeys.add(`authority:${memberKey}`);
+            batchKeys.add(`owner:${row.snapshot.ownerId}`);
+            batchKeys.add(`capacity:${descriptorKey(row.snapshot.allocation.descriptor)}`);
+        }
+        if (batchKeys.size > Stores_1.ZLINK_PROVIDER_MAX_WRITE_KEYS)
+            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'User Spot member release exceeds one Location Store batch.');
+        return members;
+    }
     async reserve(request, signal) {
         signal?.throwIfAborted();
         validateReserve(request);
@@ -882,7 +922,7 @@ function creationTarget(request) {
 }
 function sameCreationTarget(target, actual) {
     return (target.descriptor.meshName === actual.meshName &&
-        sameRid(target.descriptor.rid, actual.nodeRid) &&
+        (0, routing_id_1.routingIdsEqual)(target.descriptor.rid, actual.nodeRid) &&
         target.lifecycleGeneration === actual.nodeLifecycleGeneration &&
         sameOwner(target.owner, actual.owner));
 }
@@ -890,10 +930,7 @@ function sameOwner(left, right) {
     return left.ownerId === right.ownerId && left.leaseGeneration === right.leaseGeneration;
 }
 function sameDescriptor(left, right) {
-    return left.meshName === right.meshName && sameRid(left.rid, right.rid);
-}
-function sameRid(left, right) {
-    return String(left) === String(right);
+    return left.meshName === right.meshName && (0, routing_id_1.routingIdsEqual)(left.rid, right.rid);
 }
 function capacityEntries(descriptor, lifecycle, capacity) {
     return [

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

@@ -63,16 +63,7 @@ class ZLinkInMemoryLocationStore {
                                     spotType.count <=
                                     typeCapacity.limit))));
             },
-            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;
-            }
+            identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey)
         }, now);
     }
     async readAuthority(key, signal) {

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

@@ -6,6 +6,7 @@ export * from './in-memory-provider-location-store';
 export * from './location-store-repository';
 export * from './in-memory-authority-store';
 export * from './lease-tracker';
+export * from './request-source-resolver';
 export * from './lifecycle';
 export * from './resolvers';
 export * from './runtime';

package/dist/runtime/locations/index.js

@@ -22,6 +22,7 @@ __exportStar(require("./in-memory-provider-location-store"), exports);
 __exportStar(require("./location-store-repository"), exports);
 __exportStar(require("./in-memory-authority-store"), exports);
 __exportStar(require("./lease-tracker"), exports);
+__exportStar(require("./request-source-resolver"), exports);
 __exportStar(require("./lifecycle"), exports);
 __exportStar(require("./resolvers"), exports);
 __exportStar(require("./runtime"), exports);

package/dist/runtime/locations/lease-tracker.js

@@ -2,9 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkLiveRowFilter = exports.ZLinkOwnerLeaseTracker = void 0;
 const Options_1 = require("../../contracts/Locations/Options");
-const node_async_hooks_1 = require("node:async_hooks");
 const state_lane_1 = require("../execution/state-lane");
-const detachedLeaseRefreshResource = new node_async_hooks_1.AsyncResource('zlink:owner-lease-tracker');
 class ZLinkOwnerLeaseTracker {
     lane = new state_lane_1.ZLinkStateLane();
     store;
@@ -65,7 +63,7 @@ class ZLinkOwnerLeaseTracker {
         if (prepared.snapshot !== undefined)
             return prepared.snapshot;
         if (prepared.start) {
-            void runDetachedLeaseRefresh(() => this.refreshSnapshot(ownerId, signal, prepared.refresh));
+            void (0, state_lane_1.startOutsideStateLane)(() => this.refreshSnapshot(ownerId, signal, prepared.refresh));
         }
         return await prepared.refresh.promise;
     }
@@ -148,6 +146,3 @@ class ZLinkLiveRowFilter {
     }
 }
 exports.ZLinkLiveRowFilter = ZLinkLiveRowFilter;
-function runDetachedLeaseRefresh(work) {
-    return detachedLeaseRefreshResource.runInAsyncScope(work);
-}