@zlink-systems/framework 0.29.0 → 0.29.1

package/dist/runtime/spots/spot-entry-activation.d.ts

@@ -89,6 +89,7 @@ export declare class ZLinkEntrySpotActivation {
      */
     commitServiceActorJoin(actor: ZLinkActor, handoffBacklog?: readonly ZLinkActorHandoffPacket[], signal?: AbortSignal): Promise<void>;
     executeActor<T>(actorId: string, operation: () => Promise<T>): Promise<T>;
+    terminateActor(actorId: string, terminal: () => Promise<void>): Promise<void>;
     /**
      * Entry Spot membership does not have an application admission callback.
      * The shared core round-trip therefore accepts a valid returning Actor and

package/dist/runtime/spots/spot-entry-activation.js

@@ -220,6 +220,9 @@ class ZLinkEntrySpotActivation {
     executeActor(actorId, operation) {
         return this.spotSerialExecutor.executeActor(actorId, operation);
     }
+    terminateActor(actorId, terminal) {
+        return this.spotSerialExecutor.terminateActor(actorId, terminal);
+    }
     /**
      * Entry Spot membership does not have an application admission callback.
      * The shared core round-trip therefore accepts a valid returning Actor and

package/dist/runtime/spots/spot-node-runtime-manager.d.ts

@@ -104,6 +104,7 @@ export declare class ZLinkSpotNodeRuntimeManager {
     get primaryMeshCompletions(): ZLinkMeshCompletionTable | undefined;
     notifyEntrySpotActorCreated(nodeRid: RoutingId, actor: ZLinkActor, createRequest: ZLinkMessage, signal?: AbortSignal): Promise<import('../../contracts').ZLinkActorCreateResponse | undefined>;
     notifyPrimaryEntrySpotActorJoined(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
+    terminateActorActivation(actor: ZLinkActor, terminal: () => Promise<void>): Promise<void>;
     notifyPrimaryEntrySpotActorLeft(actor: ZLinkActor, signal?: AbortSignal, actorRef?: ActorRef, membershipEpoch?: bigint): Promise<void>;
     notifyPrimaryEntrySpotActorDisconnected(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     notifyEntrySpotActorDisconnected(meshName: string, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;

package/dist/runtime/spots/spot-node-runtime-manager.js

@@ -542,6 +542,12 @@ class ZLinkSpotNodeRuntimeManager {
         const activation = this.primaryEntryActivation();
         return activation?.notifyJoinActor(actor, signal) ?? Promise.resolve();
     }
+    terminateActorActivation(actor, terminal) {
+        const activation = this.entryActivations.get(actor.context.meshName);
+        return activation === undefined
+            ? terminal()
+            : activation.terminateActor(actor.context.actorId, terminal);
+    }
     notifyPrimaryEntrySpotActorLeft(actor, signal, actorRef, membershipEpoch) {
         const activation = this.primaryEntryActivation();
         return (activation?.notifyLeaveActor(actor, signal, actorRef, membershipEpoch) ?? Promise.resolve());

package/dist/runtime/spots/spot-serial-executor.d.ts

@@ -26,6 +26,7 @@ export declare class ZLinkSpotSerialExecutor {
     executeTimer<T>(timerName: string, operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
     isTimerExecuting(timerName: string): boolean;
     executeLifecycle<T>(operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
+    terminateActor(actorId: string, terminal: () => Promise<void>): Promise<void>;
     /**
      * Makes all child queues unreachable and completes them in one synchronous
      * ownership turn. Already accepted work remains drainable.

package/dist/runtime/spots/spot-serial-executor.js

@@ -42,7 +42,8 @@ class ZLinkSpotSerialExecutor {
         return this.spotSerial.execute(operation, workOptions);
     }
     executeActor(actorId, operation, workOptions) {
-        return this.actorExecutor(actorId).execute(() => operation(this.actorSerial(actorId)), workOptions);
+        const serial = this.actorSerial(actorId);
+        return this.actorExecutor(actorId).execute(() => operation(serial), workOptions);
     }
     /** @internal Restores a durable Actor FIFO prefix without starting it. */
     admitActorDurablePrefix(actorId, records) {
@@ -65,6 +66,14 @@ class ZLinkSpotSerialExecutor {
     executeLifecycle(operation, workOptions) {
         return this.spotSerial.execute(operation, { ...workOptions, lane: 'lifecycle' });
     }
+    async terminateActor(actorId, terminal) {
+        const executor = this.actorExecutor(actorId);
+        await executor.close();
+        await terminal();
+        if (this.actorExecutors.get(actorId) === executor)
+            this.actorExecutors.delete(actorId);
+        this.actorSerials.delete(actorId);
+    }
     /**
      * Makes all child queues unreachable and completes them in one synchronous
      * ownership turn. Already accepted work remains drainable.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.29.0",
+  "version": "0.29.1",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.29.0",
+    "@zlink-systems/stream-wire": "0.29.1",
     "@zlink-systems/zlink": "1.17.0"
   }
 }

package/src/runtime/actors/actor-runtime-contracts.ts

@@ -49,6 +49,10 @@ export interface ZLinkActorManagerOptions {
     signal?: AbortSignal
   ) => Promise<ZLinkActorCreateResponse | undefined>;
   readonly actorDestroyedCleanup?: (actorId: string) => void;
+  readonly terminateActorActivation?: (
+    actor: ZLinkActor,
+    terminal: () => Promise<void>
+  ) => Promise<void>;
   readonly publishActorAuthority?: (
     actorType: string,
     actorRef: ActorRef,

package/src/runtime/actors/index.ts

@@ -29,6 +29,7 @@ import {
   wireReplyFailureException
 } from '../framework-errors-internal';
 import { disposeLifecycleHandlers } from '../handlers/handler-instance-scope';
+import { currentZLinkActorExecution } from './actor-execution-context';
 import { encodeFrameworkPayloadMessage } from '../messaging/payload-codec';
 import { ZLinkActorCreationCoordinator, type ZLinkActorCreateRequest } from './actor-creation';
 import type { ZLinkActorManagerOptions } from './actor-runtime-contracts';
@@ -217,34 +218,43 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
     const completions = this.options.nativeActorCompletionTableProvider?.();
     const entryNodeRid = state.entryNodeRid ?? current.nodeRid;
     if (node === undefined || completions === undefined) return false;
-    const destroyTask = state.getOrStartDestroy(entryNodeRid, async (nativeRef) => {
-      if (nativeRef !== undefined) {
-        const completion = await completions.submit(() => node.destroyActor(nativeRef, 0), signal);
-        try {
-          if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
-            //  Classify the (terminal, fine) pair via the shared translator
-            //  (spec 32-framework-error-model:83-118, 99-108) instead of
-            //  collapsing every destroy failure to NotFound; genuine
-            //  route-not-found fine codes still yield NotFound through the
-            //  shared table.
-            throw wireReplyFailureException(
-              completion.terminalResult,
-              completion.failureErrno,
-              `Actor '${actor.actorId}' destroy failed with result '${completion.terminalResult}' and errno '${completion.failureErrno}'.`
-            );
+    const destroyTask = state.getOrStartDestroy(entryNodeRid, (nativeRef) =>
+      this.terminateActor(state, async () => {
+        if (nativeRef !== undefined) {
+          const completion = await completions.submit(
+            () => node.destroyActor(nativeRef, 0),
+            signal
+          );
+          try {
+            if (completion.terminalResult !== 0 || completion.failureErrno !== 0) {
+              //  Classify the (terminal, fine) pair via the shared translator
+              //  (spec 32-framework-error-model:83-118, 99-108) instead of
+              //  collapsing every destroy failure to NotFound; genuine
+              //  route-not-found fine codes still yield NotFound through the
+              //  shared table.
+              throw wireReplyFailureException(
+                completion.terminalResult,
+                completion.failureErrno,
+                `Actor '${actor.actorId}' destroy failed with result '${completion.terminalResult}' and errno '${completion.failureErrno}'.`
+              );
+            }
+          } finally {
+            closeMeshCompletion(completion);
           }
-        } finally {
-          closeMeshCompletion(completion);
+          state.markNativeActorDestroyed(nativeRef);
         }
-        state.markNativeActorDestroyed(nativeRef);
-      }
-      if (state.actorType !== undefined && state.ownsLocation) {
-        await this.options.locationLifecycle?.releaseActor(state.actorType, actor.actorId, current);
-      }
-      await this.finalizeDestroyedActor(actor.actorId, state);
-    });
+        if (state.actorType !== undefined && state.ownsLocation) {
+          await this.options.locationLifecycle?.releaseActor(
+            state.actorType,
+            actor.actorId,
+            current
+          );
+        }
+        await this.finalizeDestroyedActor(actor.actorId, state);
+      })
+    );
     try {
-      await destroyTask;
+      await this.awaitActorDestroy(state, destroyTask);
     } catch (error) {
       state.clearFailedDestroy(destroyTask);
       throw error;
@@ -548,6 +558,29 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
       this.options.metrics?.change(METRIC_NAMES.ActorCount, -1);
     }
   }
+
+  private terminateActor(
+    state: ZLinkActorRuntimeState,
+    terminal: () => Promise<void>
+  ): Promise<void> {
+    const actor = state.actor;
+    const completion =
+      actor === undefined || this.options.terminateActorActivation === undefined
+        ? terminal()
+        : this.options.terminateActorActivation(actor, terminal);
+    return completion;
+  }
+
+  private awaitActorDestroy(
+    state: ZLinkActorRuntimeState,
+    completion: Promise<void>
+  ): Promise<void> {
+    if (currentZLinkActorExecution()?.actorId === state.actorId) {
+      this.detachedTaskRunner.runDetached('Actor terminal cleanup', () => completion);
+      return Promise.resolve();
+    }
+    return completion;
+  }
   async getOrCreateActor(
     actorId: string,
     actorType: string,
@@ -648,25 +681,27 @@ export class DefaultZLinkActorManager implements ZLinkActorManager {
         `Actor '${actor.context.actorId}' must leave its current SPOT before destroy.`
       );
     }
-    const destroyTask = state.getOrStartDestroy(entryNodeRid, async (actorRef) => {
-      const destroyedActorRef =
-        actorRef === undefined ? undefined : toFrameworkActorRef(actorRef, state.meshName ?? '');
-      if (actorRef !== undefined) {
-        await node.destroyActor(actorRef, 0, destroySignal);
-        state.markNativeActorDestroyed(actorRef);
-      }
-      if (state.actorType !== undefined && state.ownsLocation) {
-        await this.options.locationLifecycle?.releaseActor(
-          state.actorType,
-          actor.context.actorId,
-          destroyedActorRef
-        );
-      }
-      await this.finalizeDestroyedActor(actor.context.actorId, state);
-    });
+    const destroyTask = state.getOrStartDestroy(entryNodeRid, (actorRef) =>
+      this.terminateActor(state, async () => {
+        const destroyedActorRef =
+          actorRef === undefined ? undefined : toFrameworkActorRef(actorRef, state.meshName ?? '');
+        if (actorRef !== undefined) {
+          await node.destroyActor(actorRef, 0, destroySignal);
+          state.markNativeActorDestroyed(actorRef);
+        }
+        if (state.actorType !== undefined && state.ownsLocation) {
+          await this.options.locationLifecycle?.releaseActor(
+            state.actorType,
+            actor.context.actorId,
+            destroyedActorRef
+          );
+        }
+        await this.finalizeDestroyedActor(actor.context.actorId, state);
+      })
+    );
 
     try {
-      await destroyTask;
+      await this.awaitActorDestroy(state, destroyTask);
     } catch (error) {
       state.clearFailedDestroy(destroyTask);
       throw error;

package/src/runtime/foundation/service-stateful-runtime.ts

@@ -432,6 +432,7 @@ export class ServiceStatefulRuntime {
     Promise<{
       readonly spot: Pick<ServiceSpotState, 'ref'>;
       readonly route: ServiceInstanceRouteFence;
+      readonly stableType: string;
     }>
   >();
   private closed = false;
@@ -1559,7 +1560,7 @@ export class ServiceStatefulRuntime {
             this.nodeRid,
             sourceSpotId,
             'request',
-            { high: this.nodeGeneration, low: pending.id },
+            { high: ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: pending.id },
             deadlineUnixMs,
             pending.id,
             metadataFrame !== undefined
@@ -2520,27 +2521,24 @@ export class ServiceStatefulRuntime {
   ): Promise<void> {
     try {
       this.validateInstanceIngress(ingress, record);
-      const activation = await this.activateMissingInstanceAsync(
-        record,
-        payloadFrame,
-        metadataFrame
-      );
-      if (this.closed) return;
-      const terminal = this.activationTerminalCompletion(record.target, activation.route);
-      const admitted = this.enqueueActivatedInstanceSpot(
-        ingress,
-        record,
-        payloadFrame,
-        activation.spot,
-        localReply,
-        terminal.onTerminalCompletion,
-        metadataFrame,
-        terminal.onHandlerTurnStarted,
-        this.instanceApplicationTarget(record, activation.route.objectGeneration)
-      );
-      if (admitted !== 'application') {
-        throw new Error('Activated Instance message was not admitted to the local queue.');
-      }
+      await this.activateMissingInstanceAsync(record, payloadFrame, metadataFrame, (activation) => {
+        if (this.closed) return;
+        const terminal = this.activationTerminalCompletion(record.target, activation.route);
+        const admitted = this.enqueueActivatedInstanceSpot(
+          ingress,
+          record,
+          payloadFrame,
+          activation.spot,
+          localReply,
+          terminal.onTerminalCompletion,
+          metadataFrame,
+          terminal.onHandlerTurnStarted,
+          this.instanceApplicationTarget(record, activation.route.objectGeneration)
+        );
+        if (admitted !== 'application') {
+          throw new Error('Activated Instance message was not admitted to the local queue.');
+        }
+      });
     } catch (error) {
       this.finishMissingInstanceActivationFailure(ingress, record, error, localReply);
     }
@@ -2949,15 +2947,35 @@ export class ServiceStatefulRuntime {
       { readonly kind: 'instanceSpot'; readonly activation: 'missing' }
     >,
     payloadFrame: Buffer,
-    metadataFrame?: Buffer
-  ): Promise<{
-    readonly spot: Pick<ServiceSpotState, 'ref'>;
-    readonly route: ServiceInstanceRouteFence;
-  }> {
-    const key = instanceActivationKey(record);
+    metadataFrame: Buffer | undefined,
+    admit: (activation: {
+      readonly spot: Pick<ServiceSpotState, 'ref'>;
+      readonly route: ServiceInstanceRouteFence;
+    }) => void
+  ): Promise<unknown> {
+    const key = record.target.targetSpotId;
     const pending = this.pendingInstanceActivations.get(key);
-    if (pending !== undefined) return pending;
-    const activation = this.runMissingInstanceActivation(record, payloadFrame, metadataFrame);
+    const ready =
+      pending ??
+      this.runMissingInstanceActivation(record, payloadFrame, metadataFrame).then((activation) => ({
+        ...activation,
+        stableType: record.target.stableType
+      }));
+    const operation = ready.then((value) => {
+      if (value.stableType !== record.target.stableType) {
+        throw new ZLinkFrameworkException(
+          ZLinkFrameworkErrorKind.TypeMismatch,
+          'Instance Spot type does not match.'
+        );
+      }
+      admit(value);
+      return value;
+    });
+    // The caller owns operation failure. Keep the activation available for later participants.
+    const activation = operation.then(
+      (value) => value,
+      () => ready
+    );
     this.pendingInstanceActivations.set(key, activation);
     const clear = () => {
       if (this.pendingInstanceActivations.get(key) === activation) {
@@ -2965,7 +2983,7 @@ export class ServiceStatefulRuntime {
       }
     };
     void activation.then(clear, clear);
-    return activation;
+    return operation;
   }
 
   private async runMissingInstanceActivation(
@@ -5817,18 +5835,6 @@ function instanceOperationKey(
   );
 }
 
-function instanceActivationKey(
-  record: Extract<
-    ServiceStatefulWireRecord,
-    { readonly kind: 'instanceSpot'; readonly activation: 'missing' }
-  >
-): string {
-  return (
-    `${record.target.targetNodeRid}\0${record.target.targetNodeGeneration}\0` +
-    `${record.target.targetSpotId}\0${record.target.stableType}`
-  );
-}
-
 function subscriptionKey(channelName: string, topicFilter: string): string {
   if (channelName.length === 0 || topicFilter.length === 0) {
     throw new TypeError('Channel name and topic filter must be non-empty.');

package/src/runtime/handlers/handler-instance-scope.ts

@@ -212,7 +212,8 @@ class LifecycleHandlerInstanceScope {
   }
 
   async dispose(detachedTaskRunner: ZLinkDetachedTaskRunner): Promise<void> {
-    const disposeFromActiveInvocation = activeLifecycleScope.getStore() === this;
+    const disposeFromActiveInvocation =
+      this.activeInvocations > 0 && activeLifecycleScope.getStore() === this;
     const disposal = this.beginDisposeCore();
     if (disposal.deferred !== undefined) {
       startOutsideLifecycleInvocation(() => {

package/src/runtime/host/actor-placement-coordinator.ts

@@ -11,7 +11,8 @@ import type {
   ZLinkAuthoritySnapshot,
   ZLinkCreationOperationIdentity,
   ZLinkLocationOwnerToken,
-  ZLinkObjectReserveResult
+  ZLinkObjectReserveResult,
+  ZLinkObjectReserveRequest
 } from '../locations/internal-location-contracts';
 import type {
   ZLinkAuthorityStore,
@@ -57,6 +58,10 @@ export interface ZLinkActorPlacementTarget {
 }
 
 export interface ZLinkActorPlacementCoordinatorOptions {
+  readonly actorRelocationPolicy?: (
+    meshName: string,
+    stableType: string
+  ) => ZLinkObjectReserveRequest['actorRelocationPolicy'];
   readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
   readonly target: (
     meshName: string | undefined,
@@ -130,7 +135,8 @@ export class ZLinkActorPlacementCoordinator {
             },
             target: reservationTarget(target),
             creatingPayload,
-            capacity: { actors: 1, spots: 0 }
+            capacity: { actors: 1, spots: 0 },
+            actorRelocationPolicy: this.options.actorRelocationPolicy?.(target.meshName, stableType)
           },
           deadline.signal,
           BigInt(deadlineUnixMs)

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

@@ -34,6 +34,10 @@ import type { ZLinkRemoteActorPacketTarget } from '../actors';
 import type { ZLinkActorJoinRelocation } from '../actors/actor-join-relocation';
 
 export interface ZLinkActorRuntimeOptionsFactoryOptions {
+  readonly terminateActorActivation: (
+    actor: ZLinkActor,
+    terminal: () => Promise<void>
+  ) => Promise<void>;
   readonly registration: ZLinkFrameworkRegistration;
   /** Message flow tracer, so a failed deferred Join records its cause on the flow. */
   readonly messageFlow?: () =>
@@ -101,6 +105,7 @@ export class ZLinkActorRuntimeOptionsFactory {
     | 'actorRefResolver'
     | 'actorCreatedNotifier'
     | 'actorDestroyedCleanup'
+    | 'terminateActorActivation'
     | 'publishActorAuthority'
     | 'locationLifecycle'
     | 'boundSessionFactory'
@@ -111,6 +116,7 @@ export class ZLinkActorRuntimeOptionsFactory {
   > {
     const actorTransferRegistry = this.options.actorTransferRegistry;
     return {
+      terminateActorActivation: this.options.terminateActorActivation,
       actorMeshNameProvider: this.options.actorMeshName,
       actorLeaveSpot: (meshName, spotId, actor, signal) => {
         const spotManager = this.options.spotManager();

package/src/runtime/host/index.ts

@@ -2016,6 +2016,7 @@ export class ZLinkFrameworkRuntimeHost
     | 'actorRefResolver'
     | 'actorCreatedNotifier'
     | 'actorDestroyedCleanup'
+    | 'terminateActorActivation'
     | 'locationLifecycle'
     | 'boundSessionFactory'
     | 'shutdownSignal'
@@ -2139,6 +2140,9 @@ export class ZLinkFrameworkRuntimeHost
     }
     this.actorPlacement ??= new ZLinkActorPlacementCoordinator({
       store: locationStore,
+      actorRelocationPolicy: (meshName, stableType) =>
+        this.options.registration.spotNodes.get(meshName)?.actorFactoryRegistrations?.[stableType]
+          ?.relocation.kind,
       remoteCreate: (meshName, targetNodeRid, request, timeoutMs) => {
         const node = this.spotNodeRuntime?.meshNode(meshName);
         if (node === undefined) {
@@ -2194,14 +2198,12 @@ export class ZLinkFrameworkRuntimeHost
             const capability = descriptor.objectCapabilities.find(
               (candidate) => candidate.objectKind === 'actor' && candidate.stableType === stableType
             );
-            const actors = descriptor.populationCapacity.actors;
             return (
               descriptor.state === ZLinkFrameworkRuntimeState.Serving &&
               descriptor.objectRole === 'server' &&
               descriptor.placementWeight > 0 &&
               descriptor.entrySpotId !== undefined &&
               excludedNodeRids?.has(String(descriptor.rid)) !== true &&
-              (actors.limit === 0 || actors.active + actors.reserved < actors.limit) &&
               capability !== undefined
             );
           }
@@ -2592,6 +2594,8 @@ export class ZLinkFrameworkRuntimeHost
 
   private actorRuntimeOptionsFactory(): ZLinkActorRuntimeOptionsFactory {
     return new ZLinkActorRuntimeOptionsFactory({
+      terminateActorActivation: (actor, terminal) =>
+        this.spotNodeRuntime?.terminateActorActivation(actor, terminal) ?? terminal(),
       registration: this.options.registration,
       messageFlow: () => this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink).flow,
       routeTransport: this.routeTransport,

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

@@ -37,9 +37,9 @@ import type {
   ZLinkObjectCommitResult,
   ZLinkObjectCreationCompleteRequest,
   ZLinkObjectCreationCompleteResult,
-  ZLinkObjectReserveRequest,
   ZLinkObjectReserveResult
 } from '../../contracts/Locations/Authority';
+import type { ZLinkObjectReserveRequest } from './internal-location-contracts';
 
 /**
  * Framework-private domain repository. Provider implementations never

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,
@@ -41,13 +42,16 @@ import type {
 } from './internal-location-contracts';
 import { encodeAuthorityKey } from './authority-key-codec';
 import { creationTerminalPreimage } from './opaque-record-key';
+import { ServiceRelocationAuthorityPayloadCodec } from '../foundation/service-relocation-runtime';
 
 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,
@@ -287,14 +291,42 @@ export class ZLinkInMemoryAuthorityStore {
 
   private tryReleaseEndedReservation(
     key: ZLinkAuthorityKey,
-    expectedStoreVersion: string
+    expectedStoreVersion: string,
+    request?: ZLinkObjectReserveRequest
   ): 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?.key.kind !== 'actor'
+        : current.creation === undefined)
+    )
+      return false;
+    if (current.snapshot.allocation.state === 'active') {
+      for (const aggregate of this.aggregates.values()) {
+        if (
+          aggregate.state === 'prepared' &&
+          aggregate.request.participants.some(
+            (participant) => participant.authorityKey.value === key.value
+          )
+        )
+          return false;
+      }
+      if (relocationAuthorityCodec.read(current.snapshot.payload) !== undefined) return false;
+      if (
+        this.validation.isOwnerLive({
+          ownerId: current.snapshot.ownerId,
+          leaseGeneration: current.snapshot.ownerLeaseGeneration
+        })
+      )
+        return false;
+      if (request?.actorRelocationPolicy !== 'disabled')
+        throw new ZLinkFrameworkException(
+          ZLinkFrameworkErrorKind.Unavailable,
+          'Actor owner lease is unavailable.'
+        );
+    } else if (
       this.validation.isTargetLive(
         current.snapshot.allocation.descriptor,
         current.snapshot.allocation.descriptorLifecycleGeneration,
@@ -305,9 +337,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 +367,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 (