@zlink-systems/framework 0.29.0 → 0.30.0

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

@@ -7,6 +7,7 @@ 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 { randomUUID } from 'node:crypto';
+import { ZLinkFrameworkException, ZLinkFrameworkErrorKind } from '../../contracts';
 import { SHA256_DIGEST_BYTES } from '../foundation/actor-join-recovery-codec';
 import type {
   ZLinkAggregateAbortResult,
@@ -31,6 +32,7 @@ import type {
   ZLinkObjectCommitResult,
   ZLinkObjectCreationCompleteRequest,
   ZLinkObjectCreationCompleteResult,
+  ZLinkEndedOwnerReleaseIntent,
   ZLinkObjectReserveRequest,
   ZLinkObjectReserveResult,
   ZLinkCreationOperationIdentity,
@@ -41,13 +43,22 @@ import type {
 } from './internal-location-contracts';
 import { encodeAuthorityKey } from './authority-key-codec';
 import { creationTerminalPreimage } from './opaque-record-key';
+import {
+  ServiceRelocationAuthorityPayloadCodec,
+  serviceRelocationAuthorityApplicationPayload
+} from '../foundation/service-relocation-runtime';
+import { decodeServiceReadySpotAuthority } from '../foundation/service-authority-payload-codec';
+import { decodeActorAuthorityPayload } from '../actors/actor-authority-payload-codec';
+import { ZLinkSpotKind } from '../../contracts';
 
 const MAX_GENERATION = 0x7fff_ffff_ffff_ffffn;
 
 const CREATION_TERMINAL_RETENTION_MS = 5 * 60 * 1000;
 const MAX_U64 = UINT64_MAX;
+const relocationAuthorityCodec = new ServiceRelocationAuthorityPayloadCodec();
 
 export interface ZLinkInMemoryAuthorityValidation {
+  isOwnerLive(owner: ZLinkLocationOwnerToken): boolean;
   isTargetLive(
     descriptor: ZLinkMeshNodeDescriptorKey,
     lifecycleGeneration: bigint,
@@ -60,6 +71,7 @@ export interface ZLinkInMemoryAuthorityValidation {
     currentActive: ZLinkCapacityVector
   ): boolean;
   identityClaimed?(authorityKey: string): boolean;
+  hasSpotMembers?(spotId: string, objectGeneration: bigint): boolean;
 }
 
 interface AuthorityRow {
@@ -199,6 +211,26 @@ export class ZLinkInMemoryAuthorityStore {
     if (!this.isOwnerLive(row.snapshot)) {
       return { kind: 'conflict', current: this.read(keyValue) };
     }
+    const actor =
+      row.snapshot.allocation.objectKind === 'actor'
+        ? decodeActorAuthorityPayload(
+            serviceRelocationAuthorityApplicationPayload(mutation.payload)
+          )
+        : undefined;
+    const previousActor =
+      actor === undefined
+        ? undefined
+        : decodeActorAuthorityPayload(
+            serviceRelocationAuthorityApplicationPayload(row.snapshot.payload)
+          );
+    if (
+      actor?.currentSpotKind === ZLinkSpotKind.User &&
+      (previousActor?.currentSpotKind !== ZLinkSpotKind.User ||
+        previousActor.currentSpotId !== actor.currentSpotId ||
+        previousActor.currentSpotGeneration !== actor.currentSpotGeneration) &&
+      !this.acceptsUserSpotMembership(actor.currentSpotId, actor.currentSpotGeneration)
+    )
+      return { kind: 'conflict', current: this.read(keyValue) };
     if (
       mutation.generationTransition === 'reincarnate' &&
       (this.objectGeneration >= MAX_GENERATION || this.ownerGeneration >= MAX_GENERATION)
@@ -279,22 +311,91 @@ export class ZLinkInMemoryAuthorityStore {
   async releaseEndedReservation(
     key: ZLinkAuthorityKey,
     expectedStoreVersion: string,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    request?: ZLinkEndedOwnerReleaseIntent
   ): Promise<boolean> {
     signal?.throwIfAborted();
-    return this.tryReleaseEndedReservation(key, expectedStoreVersion);
+    return this.tryReleaseEndedReservation(key, expectedStoreVersion, request);
+  }
+
+  acceptsUserSpotMembership(spotId: string, objectGeneration: bigint): boolean {
+    const row = this.rows.get(encodeAuthorityKey('user_spot', spotId).value);
+    return (
+      row !== undefined &&
+      row.snapshot.allocation.objectKind === 'user_spot' &&
+      row.snapshot.allocation.state === 'active' &&
+      row.snapshot.objectGeneration === objectGeneration &&
+      decodeServiceReadySpotAuthority(row.snapshot.payload)?.kind === 'user_spot' &&
+      this.isOwnerLive(row.snapshot)
+    );
   }
 
   private tryReleaseEndedReservation(
     key: ZLinkAuthorityKey,
-    expectedStoreVersion: string
+    expectedStoreVersion: string,
+    request?: ZLinkEndedOwnerReleaseIntent
   ): boolean {
     const current = this.rows.get(key.value);
     if (
       current === undefined ||
       current.snapshot.storeVersion.value !== expectedStoreVersion ||
-      current.snapshot.allocation.state !== 'reserved' ||
-      current.creation === undefined ||
+      (current.snapshot.allocation.state === 'active'
+        ? request === undefined
+        : current.creation === undefined)
+    )
+      return false;
+    if (current.snapshot.allocation.state === 'active') {
+      let unavailable = false;
+      for (const aggregate of this.aggregates.values()) {
+        if (
+          aggregate.state === 'prepared' &&
+          aggregate.request.participants.some(
+            (participant) => participant.authorityKey.value === key.value
+          )
+        )
+          unavailable = true;
+      }
+      unavailable ||= relocationAuthorityCodec.read(current.snapshot.payload) !== undefined;
+      if (
+        this.validation.isOwnerLive({
+          ownerId: current.snapshot.ownerId,
+          leaseGeneration: current.snapshot.ownerLeaseGeneration
+        })
+      )
+        return false;
+      const spot =
+        current.snapshot.allocation.objectKind === 'actor'
+          ? undefined
+          : decodeServiceReadySpotAuthority(current.snapshot.payload);
+      if (current.snapshot.allocation.objectKind !== 'actor') {
+        unavailable ||=
+          spot === undefined ||
+          spot.kind !== request?.key.kind ||
+          spot.stableType !== request.intent.stableType ||
+          spot.spotId !== request.key.globalId ||
+          spot.activationRecovery !== undefined;
+        if (spot?.kind === 'user_spot') {
+          unavailable ||=
+            this.validation.hasSpotMembers?.(spot.spotId, current.snapshot.objectGeneration) ===
+            true;
+          for (const row of this.rows.values()) {
+            if (row.snapshot.allocation.objectKind !== 'actor') continue;
+            const actor = decodeActorAuthorityPayload(
+              serviceRelocationAuthorityApplicationPayload(row.snapshot.payload)
+            );
+            unavailable ||=
+              actor?.currentSpotKind === ZLinkSpotKind.User &&
+              actor.currentSpotId === spot.spotId &&
+              actor.currentSpotGeneration === current.snapshot.objectGeneration;
+          }
+        }
+      }
+      if (unavailable || request?.actorRelocationPolicy !== 'disabled')
+        throw new ZLinkFrameworkException(
+          ZLinkFrameworkErrorKind.Unavailable,
+          'Object owner lease is unavailable.'
+        );
+    } else if (
       this.validation.isTargetLive(
         current.snapshot.allocation.descriptor,
         current.snapshot.allocation.descriptorLifecycleGeneration,
@@ -305,9 +406,14 @@ export class ZLinkInMemoryAuthorityStore {
       )
     )
       return false;
-    this.adjustCapacity(this.pendingCapacity, current.snapshot.allocation, -1);
+    this.adjustCapacity(
+      current.snapshot.allocation.state === 'active' ? this.activeCapacity : this.pendingCapacity,
+      current.snapshot.allocation,
+      -1
+    );
     this.rows.delete(key.value);
-    this.creationTerminals.set(current.creation.reservationId, 'aborted');
+    if (current.snapshot.allocation.state === 'reserved' && current.creation !== undefined)
+      this.creationTerminals.set(current.creation.reservationId, 'aborted');
     this.scanRevision++;
     return true;
   }
@@ -330,16 +436,16 @@ export class ZLinkInMemoryAuthorityStore {
       ) {
         return { kind: 'typeMismatch', current: this.snapshot(current.snapshot) };
       }
-      if (current.snapshot.allocation.state === 'active') {
-        return { kind: 'alreadyExists', current: this.snapshot(current.snapshot) };
-      }
       if (
         !this.tryReleaseEndedReservation(
           encodeAuthorityKey(request.key.kind, request.key.globalId),
-          current.snapshot.storeVersion.value
+          current.snapshot.storeVersion.value,
+          request
         )
       )
-        return { kind: 'conflict', current: this.read(key) };
+        return current.snapshot.allocation.state === 'active'
+          ? { kind: 'alreadyExists', current: this.snapshot(current.snapshot) }
+          : { kind: 'conflict', current: this.read(key) };
     }
     const target = creationTarget(request);
     if (
@@ -495,6 +601,17 @@ export class ZLinkInMemoryAuthorityStore {
     if (!this.creationTerminalAvailable(terminalRecord)) {
       return { kind: 'stale' };
     }
+    const actor =
+      request.completion.kind === 'created'
+        ? decodeActorAuthorityPayload(
+            serviceRelocationAuthorityApplicationPayload(request.completion.readyPayload)
+          )
+        : undefined;
+    if (
+      actor?.currentSpotKind === ZLinkSpotKind.User &&
+      !this.acceptsUserSpotMembership(actor.currentSpotId, actor.currentSpotGeneration)
+    )
+      return { kind: 'stale' };
     const nextVersion = this.tryNextStoreVersion();
     if (nextVersion === undefined) return { kind: 'generationExhausted' };
     const pending = row.snapshot.allocation;
@@ -661,6 +778,30 @@ export class ZLinkInMemoryAuthorityStore {
       ) {
         return { kind: 'stale' };
       }
+      const actor =
+        row.snapshot.allocation.objectKind === 'actor'
+          ? decodeActorAuthorityPayload(
+              serviceRelocationAuthorityApplicationPayload(participant.authorityPayload)
+            )
+          : undefined;
+      if (actor?.currentSpotKind === ZLinkSpotKind.User) {
+        const participantSpot = aggregate.request.participants.find(
+          (candidate) =>
+            candidate.authorityKey.value ===
+            encodeAuthorityKey('user_spot', actor.currentSpotId).value
+        );
+        if (participantSpot === undefined) {
+          if (!this.acceptsUserSpotMembership(actor.currentSpotId, actor.currentSpotGeneration))
+            return { kind: 'stale' };
+        } else {
+          const spot = this.rows.get(participantSpot.authorityKey.value);
+          if (
+            spot?.snapshot.allocation.objectKind !== 'user_spot' ||
+            spot.snapshot.objectGeneration !== actor.currentSpotGeneration
+          )
+            return { kind: 'stale' };
+        }
+      }
       if (participant.ownerTransition === 'newOwner') {
         if (
           !this.validation.isTargetLive(

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

@@ -1,4 +1,5 @@
 import type { RoutingId } from '../../contracts/Common';
+import { ZLinkSpotKind } from '../../contracts';
 import { ZLINK_MAX_IDENTITY_TEXT_BYTES } from '../../contracts/Common/CoreTypes';
 import {
   isValidPublicWeight,
@@ -58,6 +59,7 @@ import {
   type ZLinkObjectCommitResult,
   type ZLinkObjectCreationCompleteRequest,
   type ZLinkObjectCreationCompleteResult,
+  type ZLinkEndedOwnerReleaseIntent,
   type ZLinkObjectReserveRequest,
   type ZLinkObjectReserveResult,
   type ZLinkOwnerLeaseClaimResult,
@@ -99,11 +101,14 @@ export class ZLinkInMemoryLocationStore
   private readonly authority: ZLinkInMemoryAuthorityStore;
 
   constructor(private readonly now: () => Date = () => new Date()) {
+    const isOwnerLive = (owner: ZLinkLocationOwnerToken): boolean =>
+      this.liveOwnerLease(owner.ownerId, this.now())?.token.leaseGeneration ===
+      owner.leaseGeneration;
     this.authority = new ZLinkInMemoryAuthorityStore(
       {
+        isOwnerLive,
         isTargetLive: (key, lifecycleGeneration, owner) => {
           const descriptor = this.meshNodes.rows.get(meshNodeKey(key.meshName, key.rid));
-          const lease = this.leases.get(owner.ownerId);
           return (
             descriptor !== undefined &&
             descriptor.lifecycleGeneration === lifecycleGeneration &&
@@ -111,9 +116,7 @@ export class ZLinkInMemoryLocationStore
             descriptor.leaseGeneration === owner.leaseGeneration &&
             descriptor.objectRole === ZLinkObjectRole.Server &&
             descriptor.state === ZLinkFrameworkRuntimeState.Serving &&
-            lease !== undefined &&
-            lease.token.leaseGeneration === owner.leaseGeneration &&
-            lease.leaseExpiresAt.getTime() > this.now().getTime()
+            isOwnerLive(owner)
           );
         },
         placementCapacityAvailable: (key, requested, reserved, active) => {
@@ -142,7 +145,18 @@ export class ZLinkInMemoryLocationStore
                     typeCapacity.limit)))
           );
         },
-        identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey)
+        identityClaimed: (authorityKey) => this.entrySpotClaims.has(authorityKey),
+        hasSpotMembers: (spotId, objectGeneration) => {
+          for (const actor of this.actors.rows.values()) {
+            if (
+              actor.spotKind === ZLinkSpotKind.User &&
+              String(actor.spotId) === spotId &&
+              actor.spotGeneration === objectGeneration
+            )
+              return true;
+          }
+          return false;
+        }
       },
       now
     );
@@ -204,9 +218,10 @@ export class ZLinkInMemoryLocationStore
   async releaseEndedReservation(
     key: ZLinkAuthorityKey,
     expectedStoreVersion: string,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    request?: ZLinkEndedOwnerReleaseIntent
   ): Promise<boolean> {
-    return this.authority.releaseEndedReservation(key, expectedStoreVersion, signal);
+    return this.authority.releaseEndedReservation(key, expectedStoreVersion, signal, request);
   }
 
   async abort(
@@ -566,7 +581,8 @@ export class ZLinkInMemoryLocationStore
     const storeNow = this.now();
     return pageRows(
       this.fanoutPublishers,
-      (row) => row.channelName === channelName && this.isOwnerLive(row.ownerId, storeNow),
+      (row) =>
+        row.channelName === channelName && this.liveOwnerLease(row.ownerId, storeNow) !== undefined,
       page
     );
   }
@@ -628,7 +644,7 @@ export class ZLinkInMemoryLocationStore
     if (
       intent === ZLinkLocationWriteIntent.NewClaim &&
       current !== undefined &&
-      this.isOwnerLive(current.ownerId, updatedAt)
+      this.liveOwnerLease(current.ownerId, updatedAt) !== undefined
     ) {
       return rejectedConflict();
     }
@@ -703,10 +719,18 @@ export class ZLinkInMemoryLocationStore
     });
     const updatedAt = this.now();
     const current = this.actors.rows.get(key);
+    if (
+      actor.spotKind === ZLinkSpotKind.User &&
+      (current?.spotKind !== ZLinkSpotKind.User ||
+        String(current.spotId) !== String(actor.spotId) ||
+        current.spotGeneration !== actor.spotGeneration) &&
+      !this.authority.acceptsUserSpotMembership(String(actor.spotId), actor.spotGeneration)
+    )
+      return rejectedConflict();
     if (
       intent === ZLinkLocationWriteIntent.NewClaim &&
       current !== undefined &&
-      this.isOwnerLive(current.ownerId, updatedAt)
+      this.liveOwnerLease(current.ownerId, updatedAt) !== undefined
     ) {
       return rejectedConflict();
     }
@@ -1155,7 +1179,7 @@ export class ZLinkInMemoryLocationStore
     if (
       intent === ZLinkLocationWriteIntent.NewClaim &&
       current !== undefined &&
-      this.isOwnerLive(ownerOf(current), updatedAt)
+      this.liveOwnerLease(ownerOf(current), updatedAt) !== undefined
     ) {
       return rejectedConflict();
     }
@@ -1252,9 +1276,11 @@ export class ZLinkInMemoryLocationStore
     return removed;
   }
 
-  private isOwnerLive(ownerId: string, now: Date): boolean {
+  private liveOwnerLease(ownerId: string, now: Date): InMemoryOwnerLease | undefined {
     const lease = this.leases.get(ownerId);
-    return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime();
+    return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime()
+      ? lease
+      : undefined;
   }
 
   private bump(kind: ZLinkLocationKind, meshName: string | undefined): void {

package/src/runtime/locations/internal-location-contracts.ts

@@ -1,4 +1,14 @@
 export * from '../../contracts/Locations';
+import type { ZLinkObjectReserveRequest as ReserveRequest } from '../../contracts/Locations/Authority';
+import type { ZLinkRelocationConfiguration } from '../../contracts/Configuration/RegistrationTypes';
+
+export interface ZLinkObjectReserveRequest extends ReserveRequest {
+  readonly actorRelocationPolicy?: ZLinkRelocationConfiguration<unknown>['kind'];
+}
+export type ZLinkEndedOwnerReleaseIntent = Pick<
+  ZLinkObjectReserveRequest,
+  'key' | 'actorRelocationPolicy'
+> & { readonly intent: Pick<ZLinkObjectReserveRequest['intent'], 'stableType'> };
 export type * from '../../contracts/Locations/Authority';
 export type {
   ZLinkActorLocation,