@zlink-systems/framework 0.29.0 → 0.29.1

package/dist/runtime/actors/actor-runtime-contracts.d.ts

@@ -27,6 +27,7 @@ export interface ZLinkActorManagerOptions {
     readonly actorRefResolver?: ZLinkActorRuntimeLocationLookup;
     readonly actorCreatedNotifier?: (nodeRid: RoutingId, actor: ZLinkActor, createRequest: ZLinkMessage, 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, ownerNodeGeneration: bigint, signal?: AbortSignal) => Promise<void>;
     readonly locationLifecycle?: ZLinkLocationLifecycle;
     readonly boundSessionFactory?: ZLinkActorBoundSessionFactory;

package/dist/runtime/actors/index.d.ts

@@ -55,6 +55,8 @@ export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     completeCoreRelocationSource(actorId: string): Promise<void>;
     private finalizeActorState;
     private finalizeDestroyedActor;
+    private terminateActor;
+    private awaitActorDestroy;
     getOrCreateActor(actorId: string, actorType: string, signal?: AbortSignal): Promise<ZLinkActor>;
     getOrCreateWithNativeRef(actorId: string, actorType: string, actorRef: ZLinkBackendActorRef, createRequest?: unknown, signal?: AbortSignal): Promise<ZLinkActor>;
     getOrCreateActorResult(actorId: string, actorType: string, createRequest?: unknown, signal?: AbortSignal): Promise<ZLinkActorLocalCreateResult>;

package/dist/runtime/actors/index.js

@@ -11,6 +11,7 @@ const runtime_metrics_1 = require("../diagnostics/runtime-metrics");
 const execution_1 = require("../execution");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const handler_instance_scope_1 = require("../handlers/handler-instance-scope");
+const actor_execution_context_1 = require("./actor-execution-context");
 const payload_codec_1 = require("../messaging/payload-codec");
 const actor_creation_1 = require("./actor-creation");
 const actor_runtime_state_1 = require("./actor-runtime-state");
@@ -139,7 +140,7 @@ class DefaultZLinkActorManager {
         const entryNodeRid = state.entryNodeRid ?? current.nodeRid;
         if (node === undefined || completions === undefined)
             return false;
-        const destroyTask = state.getOrStartDestroy(entryNodeRid, async (nativeRef) => {
+        const destroyTask = state.getOrStartDestroy(entryNodeRid, (nativeRef) => this.terminateActor(state, async () => {
             if (nativeRef !== undefined) {
                 const completion = await completions.submit(() => node.destroyActor(nativeRef, 0), signal);
                 try {
@@ -161,9 +162,9 @@ class DefaultZLinkActorManager {
                 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);
@@ -381,6 +382,20 @@ class DefaultZLinkActorManager {
             this.options.metrics?.change(runtime_metrics_1.METRIC_NAMES.ActorCount, -1);
         }
     }
+    terminateActor(state, terminal) {
+        const actor = state.actor;
+        const completion = actor === undefined || this.options.terminateActorActivation === undefined
+            ? terminal()
+            : this.options.terminateActorActivation(actor, terminal);
+        return completion;
+    }
+    awaitActorDestroy(state, completion) {
+        if ((0, actor_execution_context_1.currentZLinkActorExecution)()?.actorId === state.actorId) {
+            this.detachedTaskRunner.runDetached('Actor terminal cleanup', () => completion);
+            return Promise.resolve();
+        }
+        return completion;
+    }
     async getOrCreateActor(actorId, actorType, signal) {
         this.rememberActorMeshFromType(actorId, actorType);
         const result = await this.createOrGet(actorId, actorType, false, undefined, signal);
@@ -429,7 +444,7 @@ class DefaultZLinkActorManager {
         if (state.isJoined) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound, `Actor '${actor.context.actorId}' must leave its current SPOT before destroy.`);
         }
-        const destroyTask = state.getOrStartDestroy(entryNodeRid, async (actorRef) => {
+        const destroyTask = state.getOrStartDestroy(entryNodeRid, (actorRef) => this.terminateActor(state, async () => {
             const destroyedActorRef = actorRef === undefined ? undefined : (0, actor_runtime_state_1.toFrameworkActorRef)(actorRef, state.meshName ?? '');
             if (actorRef !== undefined) {
                 await node.destroyActor(actorRef, 0, destroySignal);
@@ -439,9 +454,9 @@ class DefaultZLinkActorManager {
                 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);

package/dist/runtime/foundation/service-stateful-runtime.js

@@ -754,7 +754,7 @@ class ServiceStatefulRuntime {
         const timeoutMs = remainingDeadlineMs(deadlineUnixMs);
         const pending = this.operations.register(timeoutMs);
         this.submitRequest(pending, target.targetNodeRid, instanceOperationParts([
-            (0, service_stateful_wire_codec_1.encodeInstanceSpotActivationHeader)(target, this.nodeGeneration, this.nodeRid, sourceSpotId, 'request', { high: this.nodeGeneration, low: pending.id }, deadlineUnixMs, pending.id, metadataFrame !== undefined),
+            (0, service_stateful_wire_codec_1.encodeInstanceSpotActivationHeader)(target, this.nodeGeneration, this.nodeRid, sourceSpotId, 'request', { high: operation_identity_1.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE, low: pending.id }, deadlineUnixMs, pending.id, metadataFrame !== undefined),
             payloadFrame
         ], metadataFrame), timeoutMs, 'instanceSpotRequest');
         return pending;
@@ -1436,14 +1436,15 @@ class ServiceStatefulRuntime {
     async continueMissingInstanceActivation(ingress, record, payloadFrame, localReply, metadataFrame) {
         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);
@@ -1738,12 +1739,23 @@ class ServiceStatefulRuntime {
         }
         return activation.spot;
     }
-    activateMissingInstanceAsync(record, payloadFrame, metadataFrame) {
-        const key = instanceActivationKey(record);
+    activateMissingInstanceAsync(record, payloadFrame, metadataFrame, admit) {
+        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 contracts_1.ZLinkFrameworkException(contracts_1.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) {
@@ -1751,7 +1763,7 @@ class ServiceStatefulRuntime {
             }
         };
         void activation.then(clear, clear);
-        return activation;
+        return operation;
     }
     async runMissingInstanceActivation(record, payloadFrame, metadataFrame) {
         const target = record.target;
@@ -3855,10 +3867,6 @@ function instanceOperationKey(record) {
     return (`${record.sourceNodeRid}\0${record.sourceNodeGeneration}\0` +
         `${record.operation.high}\0${record.operation.low}`);
 }
-function instanceActivationKey(record) {
-    return (`${record.target.targetNodeRid}\0${record.target.targetNodeGeneration}\0` +
-        `${record.target.targetSpotId}\0${record.target.stableType}`);
-}
 function subscriptionKey(channelName, topicFilter) {
     if (channelName.length === 0 || topicFilter.length === 0) {
         throw new TypeError('Channel name and topic filter must be non-empty.');

package/dist/runtime/handlers/handler-instance-scope.js

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

package/dist/runtime/host/actor-placement-coordinator.d.ts

@@ -1,5 +1,5 @@
 import type { ActorRef, RoutingId, ZLinkActorCreateResult } from '../../contracts';
-import type { ZLinkAuthoritySnapshot, ZLinkLocationOwnerToken } from '../locations/internal-location-contracts';
+import type { ZLinkAuthoritySnapshot, ZLinkLocationOwnerToken, ZLinkObjectReserveRequest } from '../locations/internal-location-contracts';
 import type { ZLinkAuthorityStore, ZLinkObjectCreationStore } from '../locations/internal-store-contracts';
 import type { ServiceActorCreateRecord } from '../foundation/service-stateful-wire-codec';
 import type { ServiceUserSpotOperationResult } from '../foundation/service-stateful-runtime';
@@ -14,6 +14,7 @@ export interface ZLinkActorPlacementTarget {
     readonly sourceNodeGeneration: bigint;
 }
 export interface ZLinkActorPlacementCoordinatorOptions {
+    readonly actorRelocationPolicy?: (meshName: string, stableType: string) => ZLinkObjectReserveRequest['actorRelocationPolicy'];
     readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
     readonly target: (meshName: string | undefined, stableType: string, signal?: AbortSignal, excludedNodeRids?: ReadonlySet<string>) => Promise<ZLinkActorPlacementTarget | undefined>;
     readonly remoteCreate: (meshName: string, targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation'>, timeoutMs: number) => Promise<ServiceUserSpotOperationResult>;

package/dist/runtime/host/actor-placement-coordinator.js

@@ -61,7 +61,8 @@ 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));
                 const existing = existingActor(reserved, actorId, stableType);
                 if (existing !== undefined) {

package/dist/runtime/host/actor-runtime-options-factory.d.ts

@@ -15,6 +15,7 @@ import type { ZLinkRuntimeAdmissionGate } from '../admission';
 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?: () => import('../diagnostics/message-flow').ZLinkMessageFlowTracer | undefined;
@@ -61,7 +62,7 @@ export interface ZLinkActorRuntimeOptionsFactoryOptions {
 export declare class ZLinkActorRuntimeOptionsFactory {
     private readonly options;
     constructor(options: ZLinkActorRuntimeOptionsFactoryOptions);
-    createActorManagerOptions(): Pick<ZLinkActorManagerOptions, 'joinCoordinator' | 'actorMeshNameProvider' | 'actorLeaveSpot' | 'messageSerializers' | 'nativeActorNode' | 'nativeActorNodeProvider' | 'nativeActorCompletionTableProvider' | 'actorCreatedNodeRidProvider' | 'actorRefResolver' | 'actorCreatedNotifier' | 'actorDestroyedCleanup' | 'publishActorAuthority' | 'locationLifecycle' | 'boundSessionFactory' | 'actorTransferRegistry' | 'shutdownSignal' | 'metrics' | 'admission'>;
+    createActorManagerOptions(): Pick<ZLinkActorManagerOptions, 'joinCoordinator' | 'actorMeshNameProvider' | 'actorLeaveSpot' | 'messageSerializers' | 'nativeActorNode' | 'nativeActorNodeProvider' | 'nativeActorCompletionTableProvider' | 'actorCreatedNodeRidProvider' | 'actorRefResolver' | 'actorCreatedNotifier' | 'actorDestroyedCleanup' | 'terminateActorActivation' | 'publishActorAuthority' | 'locationLifecycle' | 'boundSessionFactory' | 'actorTransferRegistry' | 'shutdownSignal' | 'metrics' | 'admission'>;
     createActorClientOptions(): ConstructorParameters<typeof DefaultZLinkActorClient>[0];
     private actorBelongsToMesh;
 }

package/dist/runtime/host/actor-runtime-options-factory.js

@@ -13,6 +13,7 @@ class ZLinkActorRuntimeOptionsFactory {
     createActorManagerOptions() {
         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/dist/runtime/host/index.d.ts

@@ -155,7 +155,7 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private registerInstanceApplicationLifecycle;
     setActorManager(actorManager: DefaultZLinkActorManager): void;
     setSpotManager(spotManager: DefaultZLinkSpotManager): void;
-    createActorManagerOptions(): Pick<ZLinkActorManagerOptions, 'joinCoordinator' | 'actorMeshNameProvider' | 'actorLeaveSpot' | 'messageSerializers' | 'nativeActorNode' | 'nativeActorNodeProvider' | 'actorCreatedNodeRidProvider' | 'actorRefResolver' | 'actorCreatedNotifier' | 'actorDestroyedCleanup' | 'locationLifecycle' | 'boundSessionFactory' | 'shutdownSignal' | 'admission' | 'activationAdmission' | 'placementCreate'>;
+    createActorManagerOptions(): Pick<ZLinkActorManagerOptions, 'joinCoordinator' | 'actorMeshNameProvider' | 'actorLeaveSpot' | 'messageSerializers' | 'nativeActorNode' | 'nativeActorNodeProvider' | 'actorCreatedNodeRidProvider' | 'actorRefResolver' | 'actorCreatedNotifier' | 'actorDestroyedCleanup' | 'terminateActorActivation' | 'locationLifecycle' | 'boundSessionFactory' | 'shutdownSignal' | 'admission' | 'activationAdmission' | 'placementCreate'>;
     createActorClientOptions(): ConstructorParameters<typeof DefaultZLinkActorClient>[0];
     createLocationHandleResolver(): ZLinkStoreLocationResolvers | undefined;
     createSpotManagerOptions(): Partial<ZLinkSpotManagerOptions>;

package/dist/runtime/host/index.js

@@ -1511,6 +1511,8 @@ class ZLinkFrameworkRuntimeHost {
         }
         this.actorPlacement ??= new actor_placement_coordinator_1.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) {
@@ -1546,13 +1548,11 @@ class ZLinkFrameworkRuntimeHost {
                 const descriptors = await (0, location_store_pages_1.listAllMeshNodeDescriptors)(locationStore, meshName, signal);
                 const selected = await selectReadyLocationPlacementDescriptor(descriptors, meshNode, signal, (descriptor) => {
                     const capability = descriptor.objectCapabilities.find((candidate) => candidate.objectKind === 'actor' && candidate.stableType === stableType);
-                    const actors = descriptor.populationCapacity.actors;
                     return (descriptor.state === contracts_1.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);
                 });
                 if (selected === undefined)
@@ -1832,6 +1832,7 @@ class ZLinkFrameworkRuntimeHost {
     }
     actorRuntimeOptionsFactory() {
         return new actor_runtime_options_factory_1.ZLinkActorRuntimeOptionsFactory({
+            terminateActorActivation: (actor, terminal) => this.spotNodeRuntime?.terminateActorActivation(actor, terminal) ?? terminal(),
             registration: this.options.registration,
             messageFlow: () => this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink).flow,
             routeTransport: this.routeTransport,

package/dist/runtime/locations/domain-store-contract.d.ts

@@ -1,5 +1,6 @@
 import type { ZLinkLocationOwnerToken, ZLinkLocationPage, ZLinkLocationWriteIntent, ZLinkLocationWriteResult, ZLinkLocationWriteStatus, ZLinkMeshNodeDescriptor, ZLinkMeshNodeDescriptorKey, ZLinkClientServerServerDescriptor, ZLinkClientServerServerDescriptorKey, ZLinkFanoutPublisherDescriptor, ZLinkFanoutPublisherDescriptorKey, ZLinkOwnerLeaseClaimResult, ZLinkOwnerLeaseReadResult, ZLinkOwnerLeaseReleaseResult, ZLinkOwnerLeaseRenewResult, ZLinkPageRequest } from '../../contracts/Locations/Models';
-import type { ZLinkAggregateAbortResult, ZLinkAggregateCommitResult, ZLinkAggregateFence, ZLinkAggregatePrepareRequest, ZLinkAggregatePrepareResult, ZLinkAuthorityCompareExchangeResult, ZLinkAuthorityKey, ZLinkAuthorityMutation, ZLinkAuthorityReadResult, ZLinkAuthorityScanCursor, ZLinkAuthorityScanResult, ZLinkAuthorityStoreVersion, ZLinkCreationOperationIdentity, ZLinkCreationTerminalReadResult, ZLinkObjectAbortRequest, ZLinkObjectAbortResult, ZLinkObjectCommitRequest, ZLinkObjectCommitResult, ZLinkObjectCreationCompleteRequest, ZLinkObjectCreationCompleteResult, ZLinkObjectReserveRequest, ZLinkObjectReserveResult } from '../../contracts/Locations/Authority';
+import type { ZLinkAggregateAbortResult, ZLinkAggregateCommitResult, ZLinkAggregateFence, ZLinkAggregatePrepareRequest, ZLinkAggregatePrepareResult, ZLinkAuthorityCompareExchangeResult, ZLinkAuthorityKey, ZLinkAuthorityMutation, ZLinkAuthorityReadResult, ZLinkAuthorityScanCursor, ZLinkAuthorityScanResult, ZLinkAuthorityStoreVersion, ZLinkCreationOperationIdentity, ZLinkCreationTerminalReadResult, ZLinkObjectAbortRequest, ZLinkObjectAbortResult, ZLinkObjectCommitRequest, ZLinkObjectCommitResult, ZLinkObjectCreationCompleteRequest, ZLinkObjectCreationCompleteResult, ZLinkObjectReserveResult } from '../../contracts/Locations/Authority';
+import type { ZLinkObjectReserveRequest } from './internal-location-contracts';
 /**
  * Framework-private domain repository. Provider implementations never
  * implement this interface; the framework maps it to the opaque Store SPI.

package/dist/runtime/locations/in-memory-authority-store.d.ts

@@ -1,5 +1,6 @@
 import type { ZLinkAggregateAbortResult, ZLinkAggregateCommitResult, ZLinkAggregateFence, ZLinkAggregatePrepareRequest, ZLinkAggregatePrepareResult, ZLinkAuthorityCompareExchangeResult, ZLinkAuthorityKey, ZLinkAuthorityMutation, ZLinkAuthorityReadResult, ZLinkAuthorityScanCursor, ZLinkAuthorityScanResult, ZLinkAuthorityStoreVersion, ZLinkCapacityVector, ZLinkLocationOwnerToken, ZLinkMeshNodeDescriptorKey, ZLinkObjectAbortRequest, ZLinkObjectAbortResult, ZLinkObjectCommitRequest, ZLinkObjectCommitResult, ZLinkObjectCreationCompleteRequest, ZLinkObjectCreationCompleteResult, ZLinkObjectReserveRequest, ZLinkObjectReserveResult, ZLinkCreationOperationIdentity, ZLinkCreationTerminalReadResult } from './internal-location-contracts';
 export interface ZLinkInMemoryAuthorityValidation {
+    isOwnerLive(owner: ZLinkLocationOwnerToken): boolean;
     isTargetLive(descriptor: ZLinkMeshNodeDescriptorKey, lifecycleGeneration: bigint, owner: ZLinkLocationOwnerToken): boolean;
     placementCapacityAvailable?(descriptor: ZLinkMeshNodeDescriptorKey, requested: ZLinkCapacityVector, currentReserved: ZLinkCapacityVector, currentActive: ZLinkCapacityVector): boolean;
     identityClaimed?(authorityKey: string): boolean;

package/dist/runtime/locations/in-memory-authority-store.js

@@ -6,12 +6,15 @@ const stream_wire_1 = require("@zlink-systems/stream-wire");
 const CoreTypes_1 = require("../../contracts/Common/CoreTypes");
 const Stores_1 = require("../../contracts/Locations/Stores");
 const node_crypto_1 = require("node:crypto");
+const contracts_1 = require("../../contracts");
 const actor_join_recovery_codec_1 = require("../foundation/actor-join-recovery-codec");
 const authority_key_codec_1 = require("./authority-key-codec");
 const opaque_record_key_1 = require("./opaque-record-key");
+const service_relocation_runtime_1 = require("../foundation/service-relocation-runtime");
 const MAX_GENERATION = 0x7fffffffffffffffn;
 const CREATION_TERMINAL_RETENTION_MS = 5 * 60 * 1000;
 const MAX_U64 = stream_wire_1.UINT64_MAX;
+const relocationAuthorityCodec = new service_relocation_runtime_1.ServiceRelocationAuthorityPayloadCodec();
 /**
  * In-memory reference provider for the provider-owned authority state machine.
  * Opaque payload bytes are copied but never parsed.
@@ -175,20 +178,39 @@ class ZLinkInMemoryAuthorityStore {
         signal?.throwIfAborted();
         return this.tryReleaseEndedReservation(key, expectedStoreVersion);
     }
-    tryReleaseEndedReservation(key, expectedStoreVersion) {
+    tryReleaseEndedReservation(key, expectedStoreVersion, request) {
         const current = this.rows.get(key.value);
         if (current === undefined ||
             current.snapshot.storeVersion.value !== expectedStoreVersion ||
-            current.snapshot.allocation.state !== 'reserved' ||
-            current.creation === undefined ||
-            this.validation.isTargetLive(current.snapshot.allocation.descriptor, current.snapshot.allocation.descriptorLifecycleGeneration, {
+            (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 contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'Actor owner lease is unavailable.');
+        }
+        else if (this.validation.isTargetLive(current.snapshot.allocation.descriptor, current.snapshot.allocation.descriptorLifecycleGeneration, {
+            ownerId: current.snapshot.ownerId,
+            leaseGeneration: current.snapshot.ownerLeaseGeneration
+        }))
             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;
     }
@@ -205,11 +227,10 @@ class ZLinkInMemoryAuthorityStore {
                 current.snapshot.allocation.stableType !== request.intent.stableType) {
                 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((0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId), current.snapshot.storeVersion.value))
-                return { kind: 'conflict', current: this.read(key) };
+            if (!this.tryReleaseEndedReservation((0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId), current.snapshot.storeVersion.value, request))
+                return current.snapshot.allocation.state === 'active'
+                    ? { kind: 'alreadyExists', current: this.snapshot(current.snapshot) }
+                    : { kind: 'conflict', current: this.read(key) };
         }
         const target = creationTarget(request);
         if (!this.validation.isTargetLive(target.descriptor, target.lifecycleGeneration, target.owner)) {

package/dist/runtime/locations/in-memory-location-store.d.ts

@@ -72,7 +72,7 @@ export declare class ZLinkInMemoryLocationStore implements ZLinkDomainLocationSt
     private transitionActorTransfer;
     private remove;
     private removeByOwner;
-    private isOwnerLive;
+    private liveOwnerLease;
     private bump;
     private removeFanoutByOwner;
     private bumpScope;

package/dist/runtime/locations/in-memory-location-store.js

@@ -27,19 +27,19 @@ class ZLinkInMemoryLocationStore {
     authority;
     constructor(now = () => new Date()) {
         this.now = now;
+        const isOwnerLive = (owner) => this.liveOwnerLease(owner.ownerId, this.now())?.token.leaseGeneration ===
+            owner.leaseGeneration;
         this.authority = new in_memory_authority_store_1.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 &&
                     descriptor.ownerId === owner.ownerId &&
                     descriptor.leaseGeneration === owner.leaseGeneration &&
                     descriptor.objectRole === internal_location_contracts_1.ZLinkObjectRole.Server &&
                     descriptor.state === internal_location_contracts_1.ZLinkFrameworkRuntimeState.Serving &&
-                    lease !== undefined &&
-                    lease.token.leaseGeneration === owner.leaseGeneration &&
-                    lease.leaseExpiresAt.getTime() > this.now().getTime());
+                    isOwnerLive(owner));
             },
             placementCapacityAvailable: (key, requested, reserved, active) => {
                 const descriptor = this.meshNodes.rows.get(meshNodeKey(key.meshName, key.rid));
@@ -316,7 +316,7 @@ class ZLinkInMemoryLocationStore {
     async listFanoutPublishers(channelName, page = {}, signal) {
         signal?.throwIfAborted();
         const storeNow = this.now();
-        return pageRows(this.fanoutPublishers, (row) => row.channelName === channelName && this.isOwnerLive(row.ownerId, storeNow), page);
+        return pageRows(this.fanoutPublishers, (row) => row.channelName === channelName && this.liveOwnerLease(row.ownerId, storeNow) !== undefined, page);
     }
     async updatePeer(peer, intent) {
         return this.write(this.peers, key_codec_1.ZLinkLocationKeyCodec.encodePeerKey({
@@ -342,7 +342,7 @@ class ZLinkInMemoryLocationStore {
         const current = this.spots.rows.get(key);
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim &&
             current !== undefined &&
-            this.isOwnerLive(current.ownerId, updatedAt)) {
+            this.liveOwnerLease(current.ownerId, updatedAt) !== undefined) {
             return rejectedConflict();
         }
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.Renew) {
@@ -391,7 +391,7 @@ class ZLinkInMemoryLocationStore {
         const current = this.actors.rows.get(key);
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim &&
             current !== undefined &&
-            this.isOwnerLive(current.ownerId, updatedAt)) {
+            this.liveOwnerLease(current.ownerId, updatedAt) !== undefined) {
             return rejectedConflict();
         }
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.Renew) {
@@ -651,7 +651,7 @@ class ZLinkInMemoryLocationStore {
         const current = table.rows.get(key);
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim &&
             current !== undefined &&
-            this.isOwnerLive(ownerOf(current), updatedAt)) {
+            this.liveOwnerLease(ownerOf(current), updatedAt) !== undefined) {
             return rejectedConflict();
         }
         if (intent === internal_location_contracts_1.ZLinkLocationWriteIntent.NewClaim ||
@@ -714,9 +714,11 @@ class ZLinkInMemoryLocationStore {
         }
         return removed;
     }
-    isOwnerLive(ownerId, now) {
+    liveOwnerLease(ownerId, now) {
         const lease = this.leases.get(ownerId);
-        return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime();
+        return lease !== undefined && lease.leaseExpiresAt.getTime() > now.getTime()
+            ? lease
+            : undefined;
     }
     bump(kind, meshName) {
         this.bumpScope({ kind, meshName });

package/dist/runtime/locations/internal-location-contracts.d.ts

@@ -1,4 +1,9 @@
 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 * from '../../contracts/Locations/Authority';
 export type { ZLinkActorLocation, ZLinkPeerLocation, ZLinkRouteLocation, ZLinkSpotLocation } from '../../contracts/Locations/Rows';
 export type { ZLinkActorLocationFilter, ZLinkActorLocationKey, ZLinkLocationKey, ZLinkPeerLocationFilter, ZLinkPeerLocationKey, ZLinkRouteLocationFilter, ZLinkRouteLocationKey, ZLinkSpotLocationFilter, ZLinkSpotLocationKey } from '../../contracts/Locations/Keys';

package/dist/runtime/locations/location-store-repository.d.ts

@@ -21,6 +21,7 @@ export declare class ZLinkLocationStoreRepository extends ZLinkInMemoryLocationS
     private commitAggregateCore;
     abortAggregate(fence: ZLinkAggregateFence, signal?: AbortSignal): Promise<ZLinkAggregateAbortResult>;
     releaseEndedReservation(key: ZLinkAuthorityKey, expectedStoreVersion: string, signal?: AbortSignal): Promise<boolean>;
+    private tryReleaseEndedReservation;
     reserve(request: ZLinkObjectReserveRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectReserveResult>;
     commit(request: ZLinkObjectCommitRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectCommitResult>;
     abort(request: ZLinkObjectAbortRequest, signal?: AbortSignal, deadlineUnixMs?: bigint): Promise<ZLinkObjectAbortResult>;

package/dist/runtime/locations/location-store-repository.js

@@ -815,17 +815,21 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         }
     }
     async releaseEndedReservation(key, expectedStoreVersion, signal) {
+        return ((await this.tryReleaseEndedReservation(key, expectedStoreVersion, signal)) === 'reclaimed');
+    }
+    async tryReleaseEndedReservation(key, expectedStoreVersion, signal, request) {
         const rowKey = authorityKey(key.value);
         const current = await this.provider.read(rowKey, signal);
         if (current.kind === 'missing' || current.value.version.value !== expectedStoreVersion)
-            return false;
+            return 'conflict';
         const record = decodeAuthorityRecord(current.value.bytes);
         const snapshot = record.snapshot;
-        if (snapshot.allocation.state !== 'reserved' ||
-            snapshot.pendingCreation === undefined ||
+        if ((snapshot.allocation.state === 'active'
+            ? request?.key.kind !== 'actor'
+            : snapshot.pendingCreation === undefined) ||
             record.aggregate !== undefined ||
             hasRelocationAuthority(snapshot.payload))
-            return false;
+            return 'notReclaimable';
         const leaseKey = ownerKey(snapshot.ownerId);
         const descriptorKey = meshKey(snapshot.allocation.descriptor.meshName, snapshot.allocation.descriptor.rid);
         const capacityRowKey = capacityKey(snapshot.allocation.descriptor.meshName, String(snapshot.allocation.descriptor.rid));
@@ -836,23 +840,46 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
         ]);
         if (lease.kind === 'found' && lease.value.expiresAt === undefined)
             throw new Error('Location Store owner lease record is invalid.');
-        if (sameLiveOwner(lease, snapshot) &&
+        const ownerLive = sameLiveOwner(lease, snapshot);
+        if (snapshot.allocation.state === 'active') {
+            if (ownerLive)
+                return 'notReclaimable';
+            if (request?.actorRelocationPolicy !== 'disabled')
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.Unavailable, 'Actor owner lease is unavailable.');
+        }
+        else if (ownerLive &&
             descriptor.kind === 'found' &&
             reviveMeshDescriptor(decodeCanonicalDescriptorRecord(descriptor.value.bytes).descriptor).lifecycleGeneration === snapshot.allocation.descriptorLifecycleGeneration)
-            return false;
+            return 'notReclaimable';
         const mutations = [
             { kind: 'delete', key: rowKey }
         ];
         if (capacity.kind === 'found') {
             const stored = decodeJson(capacity.value.bytes);
-            mutations.push({
-                kind: 'put',
-                key: capacityRowKey,
-                bytes: encodeJson({
-                    active: stored.active,
-                    pending: subtractCapacity(stored.pending, snapshot.allocation.capacity)
-                })
-            });
+            try {
+                mutations.push({
+                    kind: 'put',
+                    key: capacityRowKey,
+                    bytes: encodeJson({
+                        active: snapshot.allocation.state === 'active'
+                            ? subtractCapacity(stored.active, snapshot.allocation.capacity)
+                            : stored.active,
+                        pending: snapshot.allocation.state === 'reserved'
+                            ? subtractCapacity(stored.pending, snapshot.allocation.capacity)
+                            : stored.pending
+                    })
+                });
+            }
+            catch (error) {
+                if (!(error instanceof contracts_1.ZLinkFrameworkException) ||
+                    error.kind !== contracts_1.ZLinkFrameworkErrorKind.DataLost)
+                    throw error;
+                const observed = await this.provider.read(rowKey, signal);
+                if (observed.kind === 'missing' ||
+                    observed.value.version.value !== current.value.version.value)
+                    return 'conflict';
+                throw error;
+            }
         }
         const result = await this.provider.write({
             conditions: [
@@ -863,11 +890,12 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
             ],
             mutations
         }, signal);
-        return result.kind === 'applied';
+        return result.kind === 'applied' ? 'reclaimed' : 'conflict';
     }
     async reserve(request, signal, deadlineUnixMs) {
         const encodedAuthorityKey = (0, authority_key_codec_1.encodeAuthorityKey)(request.key.kind, request.key.globalId);
         const reservationId = (0, node_crypto_1.randomUUID)();
+        let reclaimVersion;
         for (;;) {
             throwIfOperationExpired(signal, deadlineUnixMs);
             const rowKey = authorityKey(encodedAuthorityKey.value);
@@ -882,13 +910,18 @@ class ZLinkLocationStoreRepository extends in_memory_location_store_1.ZLinkInMem
                     snapshot.allocation.stableType !== request.intent.stableType) {
                     return { kind: 'typeMismatch', current: snapshot };
                 }
-                if (snapshot.allocation.state === 'active') {
-                    return { kind: 'alreadyExists', current: snapshot };
-                }
-                if (!(await this.releaseEndedReservation(encodedAuthorityKey, current.value.version.value, signal)))
+                if (reclaimVersion !== undefined && snapshot.storeVersion.value !== reclaimVersion)
                     return { kind: 'conflict', current: snapshot };
+                const reclaim = await this.tryReleaseEndedReservation(encodedAuthorityKey, current.value.version.value, signal, request);
+                if (reclaim === 'notReclaimable')
+                    return snapshot.allocation.state === 'active'
+                        ? { kind: 'alreadyExists', current: snapshot }
+                        : { kind: 'conflict', current: snapshot };
+                reclaimVersion = reclaim === 'conflict' ? snapshot.storeVersion.value : undefined;
                 continue;
             }
+            if (reclaimVersion !== undefined)
+                return { kind: 'conflict', current: { kind: 'missing', storeNow: current.storeNow } };
             const [descriptorRead, leaseRead] = await Promise.all([
                 this.provider.read(descriptorKey, signal),
                 this.provider.read(leaseKey, signal)
@@ -2941,7 +2974,7 @@ function adjustCapacity(usage, delta, direction) {
         const key = capacityTypeKey(delta.spotType);
         const next = (spotTypes[key] ?? 0) + direction * delta.spotType.count;
         if (next < 0)
-            throw new Error('Provider capacity counter underflow.');
+            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.DataLost, 'Provider capacity counter underflow.');
         if (next === 0)
             delete spotTypes[key];
         else
@@ -2950,7 +2983,7 @@ function adjustCapacity(usage, delta, direction) {
     const actors = usage.actors + direction * delta.actors;
     const spots = usage.spots + direction * delta.spots;
     if (actors < 0 || spots < 0)
-        throw new Error('Provider capacity counter underflow.');
+        throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.DataLost, 'Provider capacity counter underflow.');
     return { actors, spots, spotTypes };
 }
 function capacityTypeKey(value) {