@zlink-systems/framework 0.30.0 → 0.30.2

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);
-}

package/src/runtime/locations/lifecycle.ts

@@ -118,40 +118,22 @@ export class ZLinkLocationLifecycle {
     );
   }
 
-  async notifyActorJoinedSpot(
+  async commitActorMembership(
     actorType: string,
-    actorId: string,
-    spotMeshName: string,
+    actorRef: ActorRef,
+    authorityOwnerGeneration: bigint,
     spotId: RoutingId,
     spotGeneration: bigint,
-    membershipEpoch: bigint,
+    spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User,
     ownerNodeGeneration: bigint
   ): Promise<void> {
-    await this.actorClaims.notifyJoinedSpot(
+    await this.actorClaims.commitMembership(
       actorType,
-      actorId,
-      spotMeshName,
+      actorRef,
+      authorityOwnerGeneration,
       spotId,
       spotGeneration,
-      membershipEpoch,
-      ownerNodeGeneration
-    );
-  }
-
-  async notifyActorLeftSpot(
-    actorType: string,
-    actorId: string,
-    entrySpotId: RoutingId,
-    entrySpotGeneration: bigint,
-    membershipEpoch: bigint,
-    ownerNodeGeneration: bigint
-  ): Promise<void> {
-    await this.actorClaims.notifyLeftSpot(
-      actorType,
-      actorId,
-      entrySpotId,
-      entrySpotGeneration,
-      membershipEpoch,
+      spotKind,
       ownerNodeGeneration
     );
   }