@zlink-systems/framework 0.30.0 → 0.30.2

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

@@ -144,7 +144,8 @@ 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;
@@ -173,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 {

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 {
@@ -178,6 +186,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,
@@ -192,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/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/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>;