@zlink-systems/framework 0.30.1 → 0.30.2

package/src/runtime/host/spot-runtime-options-factory.ts

@@ -1,3 +1,4 @@
+import { routingIdsEqual } from '../routing-id';
 import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
 import { ZLinkSpotRelocationCoordinationMode, ZLinkUserSpotExecutionMode } from '../../contracts';
 import {
@@ -137,6 +138,15 @@ export class ZLinkSpotRuntimeOptionsFactory {
         }
         await runtime.dispatchEntryActorJoin(meshName, actor, handoffBacklog);
       },
+      admitEntryActorPacketPrefix: (meshName, actorId, records) => {
+        const runtime = this.options.spotNodeRuntime();
+        if (runtime === undefined) {
+          throw new 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) {
@@ -278,8 +288,9 @@ export class ZLinkSpotRuntimeOptionsFactory {
         this.options.spotNodeRuntime()?.meshNode(meshName) as never,
       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({
@@ -297,14 +308,14 @@ export class ZLinkSpotRuntimeOptionsFactory {
           state?.nativeActorRef === undefined
             ? undefined
             : 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
+          !routingIdsEqual(actorRef.nodeRid, localNodeRid)
         ) {
           return {};
         }
@@ -351,11 +362,11 @@ export class ZLinkSpotRuntimeOptionsFactory {
 
   private primaryNodeRoutingId(): string | undefined {
     const node = this.primaryNode();
-    return node === undefined ? undefined : String(node.status().routingId);
+    return node === undefined ? undefined : node.status().routingId;
   }
 
   private meshNodeRoutingId(meshName: string): string | undefined {
     const node = this.options.spotNodeRuntime()?.meshNode(meshName);
-    return node === undefined ? undefined : String(node.status().routingId);
+    return node === undefined ? undefined : node.status().routingId;
   }
 }

package/src/runtime/host/user-spot-creation-coordinator.ts

@@ -1,3 +1,4 @@
+import { encodeRoutingIdStorageHex, routingIdsEqual } from '../routing-id';
 import { createHash } from 'node:crypto';
 import {
   type RoutingId,
@@ -131,7 +132,6 @@ export class ZLinkUserSpotCreationCoordinator {
     const contentReference = encodeLocationCreationContent(request.requestPayload);
     const excludedNodeRids = new Set<string>();
     let target: Awaited<ReturnType<ZLinkUserSpotCreationCoordinatorOptions['target']>>;
-    let authorityTarget;
     let reserved: ZLinkObjectReserveResult;
     for (;;) {
       try {
@@ -154,7 +154,7 @@ export class ZLinkUserSpotCreationCoordinator {
           true
         );
       }
-      if (excludedNodeRids.has(String(target.nodeRid))) {
+      if (excludedNodeRids.has(encodeRoutingIdStorageHex(target.nodeRid))) {
         deadline.close();
         throw createInternalFrameworkException(
           ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted,
@@ -163,7 +163,7 @@ export class ZLinkUserSpotCreationCoordinator {
         );
       }
       const owner = target.owner;
-      authorityTarget = {
+      const authorityTarget = {
         meshName: target.meshName,
         nodeRid: target.nodeRid,
         nodeLifecycleGeneration: target.nodeGeneration,
@@ -217,92 +217,31 @@ export class ZLinkUserSpotCreationCoordinator {
           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: ZLinkSpotCreateState.Existing },
-          spot
-        };
-      }
-      if (current.kind !== 'snapshot' || !sameCreationTarget(current, authorityTarget)) {
-        deadline.close();
-        if (request.generatedIdentity === true) {
-          throw spotIdConflict(request.spotId);
-        }
-        throw createInternalFrameworkException(
-          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: ZLinkSpotCreateState.Existing },
-              spot
-            };
-          } finally {
+          const spot = await this.awaitReady(request, signal);
+          if (spot !== undefined) {
             deadline.close();
+            return { result: { spot, state: ZLinkSpotCreateState.Existing }, spot };
           }
-        }
-        try {
-          const result = await admitted;
-          return result.result.state === ZLinkSpotCreateState.Created
-            ? {
-                result: {
-                  ...result.result,
-                  state: 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: ZLinkSpotCreateState.Existing },
-          spot
-        };
-      } finally {
-        deadline.close();
-      }
+      if (reserved.kind !== 'placementCapacityExhausted') break;
+      excludedNodeRids.add(encodeRoutingIdStorageHex(target.nodeRid));
     }
     if (reserved.kind === 'typeMismatch') {
       deadline.close();
@@ -478,7 +417,7 @@ export 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 &&
+          routingIdsEqual(current.allocation.descriptor.rid, record.reservation.targetNodeRid) &&
           current.allocation.descriptorLifecycleGeneration ===
             record.reservation.targetNodeGeneration &&
           current.ownerId === record.reservation.targetOwnerId &&
@@ -532,7 +471,7 @@ export class ZLinkUserSpotCreationCoordinator {
     try {
       local = await materialize(requestPayload, current, signal ?? new AbortController().signal);
       if (local.state === ZLinkSpotCreateState.Rejected) {
-        local.publication?.abort();
+        await local.publication?.abort();
         await this.options.store.abort(
           {
             key: { kind: 'user_spot', globalId: record.spotId },
@@ -609,13 +548,15 @@ export class ZLinkUserSpotCreationCoordinator {
         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
       );
@@ -644,7 +585,7 @@ export class ZLinkUserSpotCreationCoordinator {
         waitForAbort(discard?.(cleanupSignal) ?? Promise.resolve(), cleanupSignal)
       ]);
       cleanupDeadline.close();
-      const cleanupErrors = cleanup
+      const cleanupErrors = [...publicationCleanup, ...cleanup]
         .filter((item): item is PromiseRejectedResult => item.status === 'rejected')
         .map((item) => item.reason);
       if (cleanupErrors.length > 0) {
@@ -774,12 +715,25 @@ export class ZLinkUserSpotCreationCoordinator {
   private async awaitReady(
     request: ZLinkUserSpotCreationRequest,
     signal: AbortSignal
-  ): Promise<SpotRef> {
+  ): Promise<SpotRef | undefined> {
     const key = encodeAuthorityKey('user_spot', String(request.spotId));
     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 createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.SpotTypeMismatch,
+          `User Spot '${String(request.spotId)}' has another stable type.`
+        );
+      }
+      if (
+        current.allocation.state === 'active' &&
+        decodeServiceClosingSpotAuthority(current.payload) === undefined
+      ) {
         return spotRef(current, request);
       }
       await wait(this.options.pollIntervalMs ?? DEFAULT_USER_SPOT_POLL_INTERVAL_MS, signal);
@@ -931,7 +885,7 @@ function requireCloseTarget(
     decoded.ownerLeaseGeneration !== current.ownerLeaseGeneration ||
     allocation.objectKind !== 'user_spot' ||
     allocation.state !== 'active' ||
-    String(allocation.descriptor.rid) !== fence.nodeRid ||
+    !routingIdsEqual(allocation.descriptor.rid, fence.nodeRid) ||
     (fence.meshName !== undefined && allocation.descriptor.meshName !== fence.meshName) ||
     (fence.nodeGeneration !== undefined &&
       allocation.descriptorLifecycleGeneration !== fence.nodeGeneration) ||
@@ -1057,19 +1011,6 @@ export function decodeLocationCreationContent(
   return payload;
 }
 
-function sameCreationTarget(
-  snapshot: ZLinkAuthoritySnapshot,
-  target: Parameters<ZLinkObjectCreationStore['reserve']>[0]['target']
-): boolean {
-  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: ServiceUserSpotCreateRecord): string {
   return JSON.stringify(
     {

package/src/runtime/locations/auto-connect-loop.ts

@@ -55,6 +55,15 @@ export class ZLinkAutoConnectLoop {
     this.scheduleNext();
   }
 
+  async requestPeerReconcile(meshName: string, _peerRid: string): Promise<void> {
+    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?: AbortSignal): Promise<void> {
     await this.prepareTransportShutdown();
     await this.finishTransportShutdown(signal);
@@ -78,7 +87,11 @@ export class ZLinkAutoConnectLoop {
   }
 
   async tick(signal?: AbortSignal): Promise<void> {
-    const lastTickFailed = await this.lane.run(() => this.lastTickFailed);
+    await this.lane.run(() => this.tickCore(signal));
+  }
+
+  private async tickCore(signal?: AbortSignal): Promise<void> {
+    const lastTickFailed = this.lastTickFailed;
     if (this.changeStampStore?.getMeshNodeChangeStamp !== undefined && !lastTickFailed) {
       try {
         const stamp = await this.changeStampStore.getMeshNodeChangeStamp(this.meshName, signal);
@@ -94,11 +107,10 @@ export 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 {
         // A failed stamp read degrades to a full reconcile tick.
@@ -106,18 +118,14 @@ export class ZLinkAutoConnectLoop {
     }
 
     await this.runReconcile(signal);
-    await this.lane.run(() => {
-      this.lastStamp = undefined;
-      this.lastLiveOwnerSetVersion = undefined;
-    });
+    this.lastStamp = undefined;
+    this.lastLiveOwnerSetVersion = undefined;
   }
 
   private async runReconcile(signal?: AbortSignal): Promise<boolean> {
     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;
   }
 
   private scheduleNext(): void {

package/src/runtime/locations/auto-connect-reconciler.ts

@@ -195,15 +195,11 @@ export class ZLinkAutoConnectReconciler {
     }
     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);
@@ -270,8 +266,6 @@ export 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/src/runtime/locations/auto-connect-types.ts

@@ -32,7 +32,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/src/runtime/locations/descriptor-publication.ts

@@ -0,0 +1,7 @@
+/** A descriptor Store write failed without a confirmed result (Location runtime section 5). */
+export class ZLinkDescriptorPublicationUnconfirmedError extends Error {
+  constructor(cause: unknown) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.name = 'ZLinkDescriptorPublicationUnconfirmedError';
+  }
+}

package/src/runtime/locations/domain-store-contract.ts

@@ -49,6 +49,11 @@ import type {
  * 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,

package/src/runtime/locations/in-memory-authority-store.ts

@@ -1,3 +1,4 @@
+import { routingIdsEqual } from '../routing-id';
 import {
   AUTHORITY_ENVELOPE_MAX_BYTES,
   CREATION_INTENT_MAX_BYTES,
@@ -5,7 +6,10 @@ import {
 } from '../../contracts/Configuration/InternalDefaults';
 import { UINT64_MAX } from '@zlink-systems/stream-wire';
 import { ZLINK_MAX_ROUTING_ID_BYTES } from '../../contracts/Common/CoreTypes';
-import { ZLINK_PROVIDER_MAX_PAGE_SIZE } from '../../contracts/Locations/Stores';
+import {
+  ZLINK_PROVIDER_MAX_PAGE_SIZE,
+  ZLINK_PROVIDER_MAX_WRITE_KEYS
+} from '../../contracts/Locations/Stores';
 import { randomUUID } from 'node:crypto';
 import { ZLinkFrameworkException, ZLinkFrameworkErrorKind } from '../../contracts';
 import { SHA256_DIGEST_BYTES } from '../foundation/actor-join-recovery-codec';
@@ -71,7 +75,6 @@ export interface ZLinkInMemoryAuthorityValidation {
     currentActive: ZLinkCapacityVector
   ): boolean;
   identityClaimed?(authorityKey: string): boolean;
-  hasSpotMembers?(spotId: string, objectGeneration: bigint): boolean;
 }
 
 interface AuthorityRow {
@@ -344,6 +347,7 @@ export class ZLinkInMemoryAuthorityStore {
         : current.creation === undefined)
     )
       return false;
+    let members: string[] = [];
     if (current.snapshot.allocation.state === 'active') {
       let unavailable = false;
       for (const aggregate of this.aggregates.values()) {
@@ -374,21 +378,12 @@ export 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 = decodeActorAuthorityPayload(
-              serviceRelocationAuthorityApplicationPayload(row.snapshot.payload)
-            );
-            unavailable ||=
-              actor?.currentSpotKind === 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 ZLinkFrameworkException(
@@ -412,12 +407,83 @@ export class ZLinkInMemoryAuthorityStore {
       -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).
+   */
+  private endedSpotMembers(spotKey: string, spot: StoredSnapshot, spotId: string): string[] {
+    const descriptorKey = (descriptor: ZLinkMeshNodeDescriptorKey) =>
+      `${descriptor.meshName}\0${String(descriptor.rid)}`;
+    const batchKeys = new Set<string>([
+      `authority:${spotKey}`,
+      `owner:${spot.ownerId}`,
+      `descriptor:${descriptorKey(spot.allocation.descriptor)}`,
+      `capacity:${descriptorKey(spot.allocation.descriptor)}`
+    ]);
+    const members: string[] = [];
+    for (const [memberKey, row] of this.rows) {
+      if (row.snapshot.allocation.objectKind !== 'actor') continue;
+      const actor = decodeActorAuthorityPayload(
+        serviceRelocationAuthorityApplicationPayload(row.snapshot.payload)
+      );
+      if (
+        actor?.currentSpotKind !== 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 ||
+        decodeActorAuthorityPayload(row.snapshot.payload)?.state !== 'ready'
+      )
+        throw new ZLinkFrameworkException(
+          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 ZLinkFrameworkException(
+          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 > ZLINK_PROVIDER_MAX_WRITE_KEYS)
+      throw new ZLinkFrameworkException(
+        ZLinkFrameworkErrorKind.Unavailable,
+        'User Spot member release exceeds one Location Store batch.'
+      );
+    return members;
+  }
+
   async reserve(
     request: ZLinkObjectReserveRequest,
     signal?: AbortSignal
@@ -1204,7 +1270,7 @@ function sameCreationTarget(
 ): boolean {
   return (
     target.descriptor.meshName === actual.meshName &&
-    sameRid(target.descriptor.rid, actual.nodeRid) &&
+    routingIdsEqual(target.descriptor.rid, actual.nodeRid) &&
     target.lifecycleGeneration === actual.nodeLifecycleGeneration &&
     sameOwner(target.owner, actual.owner)
   );
@@ -1218,11 +1284,7 @@ function sameDescriptor(
   left: ZLinkMeshNodeDescriptorKey,
   right: ZLinkMeshNodeDescriptorKey
 ): boolean {
-  return left.meshName === right.meshName && sameRid(left.rid, right.rid);
-}
-
-function sameRid(left: unknown, right: unknown): boolean {
-  return String(left) === String(right);
+  return left.meshName === right.meshName && routingIdsEqual(left.rid, right.rid);
 }
 
 function capacityEntries(

package/src/runtime/locations/in-memory-location-store.ts

@@ -145,18 +145,7 @@ export class ZLinkInMemoryLocationStore
                     typeCapacity.limit)))
           );
         },
-        identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey),
-        hasSpotMembers: (spotId, objectGeneration) => {
-          for (const actor of this.actors.rows.values()) {
-            if (
-              actor.spotKind === ZLinkSpotKind.User &&
-              String(actor.spotId) === spotId &&
-              actor.spotGeneration === objectGeneration
-            )
-              return true;
-          }
-          return false;
-        }
+        identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey)
       },
       now
     );

package/src/runtime/locations/index.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/src/runtime/locations/lease-tracker.ts

@@ -7,10 +7,7 @@ import {
   type ZLinkOwnerLeaseReadResult
 } from './internal-location-contracts';
 import type { ZLinkOwnerLeaseStore } from './internal-store-contracts';
-import { AsyncResource } from 'node:async_hooks';
-import { ZLinkStateLane } from '../execution/state-lane';
-
-const detachedLeaseRefreshResource = new AsyncResource('zlink:owner-lease-tracker');
+import { startOutsideStateLane, ZLinkStateLane } from '../execution/state-lane';
 
 export interface ZLinkOwnerLeaseTrackerOptions {
   readonly store: ZLinkOwnerLeaseStore;
@@ -108,7 +105,7 @@ export class ZLinkOwnerLeaseTracker {
     const prepared = await this.lane.run(() => this.prepareSnapshotRefresh(ownerId));
     if (prepared.snapshot !== undefined) return prepared.snapshot;
     if (prepared.start) {
-      void runDetachedLeaseRefresh(() => this.refreshSnapshot(ownerId, signal, prepared.refresh));
+      void startOutsideStateLane(() => this.refreshSnapshot(ownerId, signal, prepared.refresh));
     }
     return await prepared.refresh.promise;
   }
@@ -218,7 +215,3 @@ export class ZLinkLiveRowFilter {
     return (await isLive(row, signal)) ? row : undefined;
   }
 }
-
-function runDetachedLeaseRefresh(work: () => Promise<void>): Promise<void> {
-  return detachedLeaseRefreshResource.runInAsyncScope(work);
-}