@zlink-systems/framework 0.29.0 → 0.30.0

package/src/runtime/host/index.ts

@@ -1,3 +1,5 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
+import { currentApplicationJobOrigin } from '../application-jobs/application-job-queue-scope';
 import { listAllMeshNodeDescriptors } from '../locations/location-store-pages';
 import { ZlinkStreamContentType } from '@zlink-systems/stream-wire';
 import { randomBytes, randomUUID } from 'node:crypto';
@@ -349,7 +351,12 @@ export class ZLinkFrameworkRuntimeHost
         } catch {
           return false;
         }
-      }
+      },
+      (error) =>
+        (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException(
+          'logger-provider',
+          error
+        )
     );
     this.capacityStatus = new HostCapacityStatusProjection(
       options.registration.coreHwm,
@@ -721,13 +728,13 @@ export class ZLinkFrameworkRuntimeHost
       sessionRelocationWire: () => this.serviceRelocation,
       clearRemoteActorPacketTarget: (actorId) =>
         this.boundSessionRelay.clearRemoteActorPacketTarget(actorId),
-      prepareApplicationJob: async (preparationSignal) => {
+      prepareApplicationJob: async (preparationSignal, origin) => {
         const runtimeSignal = this.executionState?.abortController.signal;
         const signal =
           runtimeSignal === undefined
             ? preparationSignal
             : AbortSignal.any([runtimeSignal, preparationSignal]);
-        const permit = await this.applicationJobQueue.acquire(signal);
+        const permit = await this.applicationJobQueue.acquire(signal, origin);
         let state: 'ready' | 'running' | 'closed' = 'ready';
         let closedReason: unknown;
         let abort: (() => void) | undefined;
@@ -1722,6 +1729,10 @@ export class ZLinkFrameworkRuntimeHost
       activationNode.registerAsyncInstanceActivationAuthority?.(
         new ZLinkInstanceActivationAuthority({
           store: locationStore,
+          relocationPolicy: (stableType) =>
+            this.options.registration.spotNodes.get(meshName)?.instanceSpotFactoryRegistrations?.[
+              stableType
+            ]?.relocation.kind,
           relocationStore: this.options.registration.locations.relocationStoreInstance,
           meshName,
           owner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
@@ -2016,6 +2027,7 @@ export class ZLinkFrameworkRuntimeHost
     | 'actorRefResolver'
     | 'actorCreatedNotifier'
     | 'actorDestroyedCleanup'
+    | 'terminateActorActivation'
     | 'locationLifecycle'
     | 'boundSessionFactory'
     | 'shutdownSignal'
@@ -2139,6 +2151,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 +2209,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
             );
           }
@@ -2233,6 +2246,9 @@ export class ZLinkFrameworkRuntimeHost
     });
     const coordinator = (this.userSpotCoordinator = new ZLinkUserSpotCreationCoordinator({
       store: locationStore,
+      relocationPolicy: (meshName, stableType) =>
+        this.options.registration.spotNodes.get(meshName)?.spotFactoryRegistrations?.[stableType]
+          ?.relocation.kind,
       publishReadyRoute: (meshName, route) => {
         this.cachedLocationSpotRouteResolver?.invalidate?.(route.spot.spotId);
         this.spotNodeRuntime?.meshNode(meshName)?.rememberSpotRoute?.(route);
@@ -2592,6 +2608,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,
@@ -2753,6 +2771,7 @@ export class ZLinkFrameworkRuntimeHost
       },
       meshRecordDispatcher: (meshName: string, owner: ReadyRecord, record: ReceiveRecord) =>
         this.dispatchMeshRecord(
+          currentApplicationJobOrigin,
           meshName,
           owner,
           record,
@@ -2763,6 +2782,7 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   private async dispatchMeshRecord(
+    applicationJobOrigin: () => ApplicationJobOrigin,
     meshName: string,
     owner: ReadyRecord,
     record: ReceiveRecord,
@@ -2964,7 +2984,7 @@ export class ZLinkFrameworkRuntimeHost
           );
         }
         return this.admission.run(meshName, 'RouteMesh Actor dispatch', () =>
-          this.spotManager!.dispatchMeshActor(meshName, owner, record)
+          this.spotManager!.dispatchMeshActor(applicationJobOrigin(), meshName, owner, record)
         );
       case ReceiveKind.SendReady:
         return Promise.resolve();
@@ -3008,7 +3028,10 @@ export class ZLinkFrameworkRuntimeHost
     try {
       state.taskRunner.runDetached('mesh-node-local-route-dispatch', async () => {
         try {
-          const permit = await this.applicationJobQueue.acquire(state.abortController.signal);
+          const permit = await this.applicationJobQueue.acquire(
+            state.abortController.signal,
+            'local'
+          );
           permit.markApplicationQueued();
           await runWithApplicationJobPermit(permit, () =>
             channelRuntime.dispatchLocalMeshRoute(meshName, sourceNodeRid, ownedParts)

package/src/runtime/host/instance-activation-authority.ts

@@ -41,6 +41,7 @@ import { putNewRelocationBlob, relocationBlobReference } from '../locations/relo
 
 import {
   encodeInstanceActivationRecoveryEnvelope,
+  decodeInstanceActivationRecoveryEnvelope,
   type ServiceInstanceActivationRecoveryEnvelope
 } from '../foundation/service-instance-activation-recovery-codec';
 
@@ -57,6 +58,9 @@ interface PendingReservation {
 }
 
 export interface ZLinkInstanceActivationAuthorityOptions {
+  readonly relocationPolicy?: (
+    stableType: string
+  ) => import('../locations/internal-location-contracts').ZLinkObjectReserveRequest['actorRelocationPolicy'];
   readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
   readonly relocationStore?: ZLinkRelocationStore;
   readonly meshName: string;
@@ -73,9 +77,101 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
 
   constructor(private readonly options: ZLinkInstanceActivationAuthorityOptions) {}
 
-  async read(target: ServiceInstanceActivationTarget): Promise<ServiceInstanceAuthorityRead> {
-    const current = await this.options.store.readAuthority(authorityKey(target.targetSpotId));
-    return current.kind === 'snapshot' ? readyRead(current, target) : { kind: 'missing' };
+  async read(
+    target: ServiceInstanceActivationTarget,
+    instanceIntent?: true,
+    activation?: ServiceInstanceActivationRecoveryEnvelope,
+    acceptsLocal?: (route: ServiceInstanceRouteFence) => boolean
+  ): Promise<ServiceInstanceAuthorityRead> {
+    const key = authorityKey(target.targetSpotId);
+    const current = await this.options.store.readAuthority(key);
+    if (current.kind !== 'snapshot') return { kind: 'missing' };
+    const ready = decodeServiceInstanceAuthorityPayload(current.payload);
+    const resolved = readyRead(current, target, ready);
+    if (
+      ready?.state === 'ready' &&
+      resolved.kind === 'ready' &&
+      acceptsLocal?.(resolved.route) === true
+    ) {
+      return resolved;
+    }
+    if (
+      activation !== undefined &&
+      current.allocation.objectKind === 'instance_spot' &&
+      routingIdsEqual(current.allocation.descriptor.rid, target.targetNodeRid) &&
+      current.allocation.descriptorLifecycleGeneration === target.targetNodeGeneration
+    ) {
+      const reference =
+        current.pendingCreation?.requestContentReference ?? ready?.activationRecovery?.reference;
+      if (reference !== undefined) {
+        const root = await this.options.relocationStore?.read(relocationBlobReference(reference));
+        if (root?.kind !== 'found') {
+          throw new ZLinkFrameworkException(
+            ZLinkFrameworkErrorKind.DataLost,
+            'Stored Instance activation is missing.'
+          );
+        }
+        let stored: ServiceInstanceActivationRecoveryEnvelope;
+        try {
+          stored = decodeInstanceActivationRecoveryEnvelope(root.bytes);
+        } catch (error) {
+          if (!(error instanceof TypeError || error instanceof RangeError)) throw error;
+          throw new ZLinkFrameworkException(
+            ZLinkFrameworkErrorKind.ProtocolError,
+            'Stored Instance activation is invalid.'
+          );
+        }
+        if (
+          stored.operation.high === activation.operation.high &&
+          stored.operation.low === activation.operation.low &&
+          (stored.targetMeshName !== activation.targetMeshName ||
+            stored.target.stableType !== target.stableType ||
+            stored.target.descriptorVersion !== target.descriptorVersion ||
+            stored.deadlineUnixMs !== activation.deadlineUnixMs ||
+            (stored.metadataFrame === undefined) !== (activation.metadataFrame === undefined) ||
+            (stored.metadataFrame !== undefined &&
+              activation.metadataFrame !== undefined &&
+              Buffer.compare(stored.metadataFrame, activation.metadataFrame) !== 0))
+        ) {
+          throw new ZLinkFrameworkException(
+            ZLinkFrameworkErrorKind.ProtocolError,
+            'Instance route does not match the stored activation.'
+          );
+        }
+      }
+    }
+
+    if (
+      instanceIntent === true &&
+      current.allocation.state === 'active' &&
+      ready?.state === 'ready'
+    ) {
+      if (
+        current.allocation.objectKind !== 'instance_spot' ||
+        current.allocation.stableType !== target.stableType
+      ) {
+        throw createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.SpotTypeMismatch,
+          'Instance activation type does not match the current authority.'
+        );
+      }
+      const released = await this.options.store.releaseEndedReservation?.(
+        key,
+        current.storeVersion.value,
+        undefined,
+        {
+          key: { kind: 'instance_spot', globalId: target.targetSpotId },
+          intent: { stableType: target.stableType },
+          actorRelocationPolicy: this.options.relocationPolicy?.(target.stableType)
+        }
+      );
+      if (released === true) return { kind: 'missing' };
+      const refreshed = await this.options.store.readAuthority(key);
+      return refreshed.kind === 'snapshot'
+        ? readyRead(refreshed, target, decodeServiceInstanceAuthorityPayload(refreshed.payload))
+        : { kind: 'missing' };
+    }
+    return resolved;
   }
 
   async reserve(
@@ -117,6 +213,7 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
       reserved = await this.options.store.reserve(
         {
           key: { kind: 'instance_spot', globalId: target.targetSpotId },
+          actorRelocationPolicy: this.options.relocationPolicy?.(target.stableType),
           intent: {
             stableType: target.stableType,
             requestContentReference: stored.reference.value,
@@ -310,7 +407,11 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
     }
     const current = await this.options.store.readAuthority(authorityKey(target.targetSpotId));
     if (current.kind === 'snapshot') {
-      const ready = readyRead(current, target);
+      const ready = readyRead(
+        current,
+        target,
+        decodeServiceInstanceAuthorityPayload(current.payload)
+      );
       if (ready.kind === 'ready') {
         this.pending.delete(reservation.token);
         return { kind: 'lost', route: ready.route };
@@ -344,7 +445,7 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
       throw new Error('Instance activation authority changed before inbox release.');
     }
     const recovery = decoded.activationRecovery;
-    if (recovery === undefined) return routeFromSnapshot(current);
+    if (recovery === undefined) return routeFromSnapshot(current, decoded.spotId);
     let completed = current;
     if (recovery.replayCursor < recovery.inboxSequence) {
       const cursorStored = await this.options.store.compareExchangeAuthority(
@@ -459,22 +560,19 @@ export class ZLinkInstanceActivationAuthority implements ServiceAsyncInstanceAct
 
 function readyRead(
   snapshot: ZLinkAuthoritySnapshot,
-  target: ServiceInstanceActivationTarget
+  target: ServiceInstanceActivationTarget,
+  decoded: ReturnType<typeof decodeServiceInstanceAuthorityPayload>
 ): ServiceInstanceAuthorityRead {
-  const decoded =
-    decodeServiceReadySpotAuthority(snapshot.payload) ??
-    decodeServiceClosingSpotAuthority(snapshot.payload);
-  const creating = decodeServiceInstanceAuthorityPayload(snapshot.payload);
   if (
-    creating?.state === 'coldActivating' &&
+    decoded?.state === 'coldActivating' &&
     snapshot.allocation.objectKind === 'instance_spot' &&
-    creating.stableType === target.stableType &&
-    creating.spotId === target.targetSpotId &&
-    creating.ownerId === snapshot.ownerId &&
-    creating.ownerLeaseGeneration === snapshot.ownerLeaseGeneration &&
-    creating.ownerMeshName === snapshot.allocation.descriptor.meshName &&
-    creating.ownerNodeGeneration === snapshot.allocation.descriptorLifecycleGeneration &&
-    routingIdsEqual(creating.ownerNodeRid, snapshot.allocation.descriptor.rid) &&
+    decoded.stableType === target.stableType &&
+    decoded.spotId === target.targetSpotId &&
+    decoded.ownerId === snapshot.ownerId &&
+    decoded.ownerLeaseGeneration === snapshot.ownerLeaseGeneration &&
+    decoded.ownerMeshName === snapshot.allocation.descriptor.meshName &&
+    decoded.ownerNodeGeneration === snapshot.allocation.descriptorLifecycleGeneration &&
+    routingIdsEqual(decoded.ownerNodeRid, snapshot.allocation.descriptor.rid) &&
     routingIdsEqual(target.targetNodeRid, snapshot.allocation.descriptor.rid) &&
     target.targetNodeGeneration === snapshot.allocation.descriptorLifecycleGeneration
   ) {
@@ -486,7 +584,8 @@ function readyRead(
     };
   }
   if (
-    decoded?.kind !== 'instance_spot' ||
+    decoded === undefined ||
+    decoded.state === 'coldActivating' ||
     decoded.stableType !== target.stableType ||
     decoded.spotId !== target.targetSpotId ||
     snapshot.allocation.objectKind !== 'instance_spot' ||
@@ -501,7 +600,7 @@ function readyRead(
   ) {
     return { kind: 'missing' };
   }
-  return { kind: 'ready', route: routeFromSnapshot(snapshot), authority: snapshot };
+  return { kind: 'ready', route: routeFromSnapshot(snapshot, decoded.spotId), authority: snapshot };
 }
 
 function requireCommitIdentity(
@@ -529,17 +628,23 @@ function requireCommitIdentity(
   }
 }
 
-function routeFromSnapshot(snapshot: ZLinkAuthoritySnapshot): ServiceInstanceRouteFence {
-  const decoded =
-    decodeServiceReadySpotAuthority(snapshot.payload) ??
-    decodeServiceClosingSpotAuthority(snapshot.payload);
-  if (decoded?.kind !== 'instance_spot') {
-    throw new Error('Instance authority is not Ready.');
+function routeFromSnapshot(
+  snapshot: ZLinkAuthoritySnapshot,
+  spotId?: string
+): ServiceInstanceRouteFence {
+  if (spotId === undefined) {
+    const decoded =
+      decodeServiceReadySpotAuthority(snapshot.payload) ??
+      decodeServiceClosingSpotAuthority(snapshot.payload);
+    if (decoded?.kind !== 'instance_spot') {
+      throw new Error('Instance authority is not Ready.');
+    }
+    spotId = decoded.spotId;
   }
   return {
     targetNodeRid: String(snapshot.allocation.descriptor.rid),
     targetNodeGeneration: snapshot.allocation.descriptorLifecycleGeneration,
-    targetSpotId: decoded.spotId,
+    targetSpotId: spotId,
     objectGeneration: snapshot.objectGeneration,
     ownerId: snapshot.ownerId,
     authorityOwnerGeneration: snapshot.authorityOwnerGeneration,

package/src/runtime/host/service-relocation-host-runtime.ts

@@ -4812,6 +4812,7 @@ class LocalTargetPort implements ServiceRelocationTargetObjectPort<LocalHidden>
             throw new Error('Relocated Entry Spot Actor dispatch is unavailable.');
           }
           return runtime.dispatchEntryActorPacket(
+            'remote',
             hidden.actor!.context.actorId,
             parts,
             returnResponse,
@@ -4820,6 +4821,7 @@ class LocalTargetPort implements ServiceRelocationTargetObjectPort<LocalHidden>
           );
         }
         return this.requireSpotManager().dispatchRoutedActorPacket(
+          'remote',
           state.spotId,
           hidden.actor!.context.actorId,
           parts,

package/src/runtime/host/spot-address-transport.ts

@@ -1,3 +1,4 @@
+import type { ServiceInstanceColdActivationTarget } from '../foundation/service-stateful-wire-codec';
 import { ZLinkFrameworkException, ZLinkSpotKind, type RoutingId } from '../../contracts';
 import {
   ZLinkRuntimeDispatchErrorAction as ZLinkDispatchErrorAction,
@@ -44,7 +45,11 @@ import type {
   ZLinkSpotAddressTransport,
   ZLinkSpotRoutedTransport
 } from '../spots/spot-outbound';
-import type { ZLinkSpotRouteResolver, ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
+import type {
+  ZLinkSpotRouteResolver,
+  ZLinkSpotRouteTarget,
+  ZLinkInstanceReactivationRoute
+} from '../spots/spot-routing-internal';
 
 export interface ZLinkHostSpotAddressTransportOptions {
   readonly resolver: () => ZLinkSpotRouteResolver | undefined;
@@ -65,13 +70,7 @@ export function hasObjectClientCapability(role: 'none' | 'client' | 'server' | u
 type MissingTarget = {
   readonly meshName: string;
   readonly node: ZLinkBackendMeshNode;
-  readonly target: {
-    readonly targetNodeRid: string;
-    readonly targetNodeGeneration: bigint;
-    readonly targetSpotId: string;
-    readonly stableType: string;
-    readonly descriptorVersion: string;
-  };
+  readonly target: ServiceInstanceColdActivationTarget;
 };
 
 type MissingTargetSelection =
@@ -106,7 +105,10 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     const activationDeadlineUnixMs = BigInt(
       Math.round(Date.now() + this.options.defaultRequestTimeoutMs)
     );
-    const existing = await this.resolveExisting(spotId);
+    const resolution = await this.resolveExisting(spotId, undefined, call);
+    const existing = resolution !== undefined && !('kind' in resolution) ? resolution : undefined;
+    if (resolution !== undefined && 'kind' in resolution)
+      call = this.reactivationCall(resolution, call);
     if (existing !== undefined) {
       this.validateExisting(existing, call);
       try {
@@ -166,7 +168,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     if (!call.instanceSpot) {
       return { status: ZLinkSubmitStatus.TargetNotFound };
     }
-    const selected = this.selectMissingTarget(spotId, call);
+    const selected = this.selectMissingTarget(spotId, call, resolution);
     if (selected.kind === 'unsupported') {
       this.traceInstanceAddress(
         ZLinkMessageFlowOutcome.Dropped,
@@ -252,10 +254,13 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     const timeoutMs = call.timeoutMs ?? this.options.defaultRequestTimeoutMs;
     const deadline = createSpotAddressDeadline(timeoutMs, call.signal);
     try {
-      const existing = await this.resolveExisting(spotId, deadline.signal);
+      const resolution = await this.resolveExisting(spotId, deadline.signal, call);
+      const existing = resolution !== undefined && !('kind' in resolution) ? resolution : undefined;
+      if (resolution !== undefined && 'kind' in resolution)
+        call = this.reactivationCall(resolution, call);
       deadline.requireRemaining();
       if (existing === undefined) {
-        return await this.requestToMissingInstance(spotId, request, call, deadline);
+        return await this.requestToMissingInstance(spotId, request, call, deadline, resolution);
       }
       this.validateExisting(existing, call);
       try {
@@ -351,7 +356,8 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     spotId: RoutingId,
     request: unknown,
     call: ZLinkSpotAddressCallOptions,
-    deadline: ZLinkSpotAddressDeadline
+    deadline: ZLinkSpotAddressDeadline,
+    current?: ZLinkSpotRouteTarget | ZLinkInstanceReactivationRoute
   ): Promise<TReply> {
     if (!call.instanceSpot) {
       throw createInternalFrameworkException(
@@ -359,7 +365,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
         `Spot '${String(spotId)}' has no Ready authority.`
       );
     }
-    const selected = this.selectMissingTarget(spotId, call);
+    const selected = this.selectMissingTarget(spotId, call, current);
     if (selected.kind === 'capacity') {
       throw missingInstancePlacementCapacity(spotId, call.instanceSpotType);
     }
@@ -507,14 +513,20 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
 
   private async resolveExisting(
     spotId: RoutingId,
-    signal?: AbortSignal
-  ): Promise<import('../spots/spot-routing-internal').ZLinkSpotRouteTarget | undefined> {
+    signal?: AbortSignal,
+    call?: ZLinkSpotAddressCallOptions
+  ): Promise<ZLinkSpotRouteTarget | ZLinkInstanceReactivationRoute | undefined> {
     const resolver = this.options.resolver();
     if (resolver === undefined) {
       throw new Error('Global Spot address resolution requires a Location Store.');
     }
     try {
-      return await awaitWithAbort(resolver.resolve(spotId, signal), signal);
+      return await awaitWithAbort(
+        call?.instanceSpot === true
+          ? resolver.resolve(spotId, signal, true)
+          : resolver.resolve(spotId, signal),
+        signal
+      );
     } catch (error) {
       if (
         error instanceof ZLinkFrameworkException &&
@@ -526,9 +538,18 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     }
   }
 
+  private reactivationCall(
+    route: ZLinkInstanceReactivationRoute,
+    call: ZLinkSpotAddressCallOptions
+  ): ZLinkSpotAddressCallOptions {
+    this.validateExisting(route, call);
+    return { ...call, initialMeshName: route.meshName, instanceSpotType: route.stableType };
+  }
+
   private selectMissingTarget(
     spotId: RoutingId,
-    call: ZLinkSpotAddressCallOptions
+    call: ZLinkSpotAddressCallOptions,
+    current?: ZLinkSpotRouteTarget | ZLinkInstanceReactivationRoute
   ): MissingTargetSelection {
     const configuredMeshes = this.options.meshNames();
     if (
@@ -574,14 +595,15 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     const stableType =
       call.instanceSpotType ?? (distinctTypes.length === 1 ? distinctTypes[0] : undefined);
     if (stableType === undefined) {
-      if (distinctTypes.length === 0) return { kind: 'unsupported' };
+      if (distinctTypes.length === 0)
+        return { kind: current === undefined ? 'unsupported' : 'unavailable' };
       throw createInternalFrameworkException(
         ZLinkFrameworkInternalErrorKind.InvalidOperation,
         'Instance Spot type is required when multiple types are registered.'
       );
     }
     if (canInspectPlacementTypes && !distinctTypes.includes(stableType)) {
-      return { kind: 'unsupported' };
+      return { kind: current === undefined ? 'unsupported' : 'unavailable' };
     }
     let unavailable = false;
     let capacity = false;
@@ -600,6 +622,7 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
           node,
           target: {
             ...placement.target,
+            targetMeshName: meshName,
             targetSpotId: String(spotId),
             stableType
           }
@@ -611,12 +634,12 @@ export class ZLinkHostSpotAddressTransport implements ZLinkSpotAddressTransport
     }
     if (unavailable) return { kind: 'unavailable' };
     if (capacity) return { kind: 'capacity' };
-    if (unsupported) return { kind: 'unsupported' };
+    if (unsupported) return { kind: current === undefined ? 'unsupported' : 'unavailable' };
     return { kind: 'unavailable' };
   }
 
   private validateExisting(
-    target: import('../spots/spot-routing-internal').ZLinkSpotRouteTarget,
+    target: Pick<ZLinkSpotRouteTarget, 'spotId' | 'spotKind' | 'stableType'>,
     call: ZLinkSpotAddressCallOptions
   ): void {
     if (!call.instanceSpot) return;

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

@@ -102,6 +102,7 @@ export class ZLinkSpotRuntimeOptionsFactory {
           Promise.resolve()
       },
       dispatchEntryActorPacket: (
+        origin,
         actorId,
         parts,
         returnResponse,
@@ -117,6 +118,7 @@ export class ZLinkSpotRuntimeOptionsFactory {
           );
         }
         return runtime.dispatchEntryActorPacket(
+          origin,
           actorId,
           parts,
           returnResponse,

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

@@ -38,6 +38,10 @@ const DEFAULT_USER_SPOT_CLEANUP_TIMEOUT_MS = 1_000;
 const DEFAULT_USER_SPOT_POLL_INTERVAL_MS = 10;
 
 export interface ZLinkUserSpotCreationCoordinatorOptions {
+  readonly relocationPolicy?: (
+    meshName: string,
+    stableType: string
+  ) => import('../locations/internal-location-contracts').ZLinkObjectReserveRequest['actorRelocationPolicy'];
   readonly store: ZLinkObjectCreationStore & ZLinkAuthorityStore;
   readonly target: (
     request: Pick<ZLinkUserSpotCreationRequest, 'meshName' | 'stableType'>,
@@ -169,6 +173,10 @@ export class ZLinkUserSpotCreationCoordinator {
         reserved = await this.options.store.reserve(
           {
             key: { kind: 'user_spot', globalId: String(request.spotId) },
+            actorRelocationPolicy: this.options.relocationPolicy?.(
+              target.meshName,
+              request.stableType
+            ),
             intent: {
               stableType: request.stableType,
               requestContentReference: contentReference,

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

@@ -37,9 +37,12 @@ import type {
   ZLinkObjectCommitResult,
   ZLinkObjectCreationCompleteRequest,
   ZLinkObjectCreationCompleteResult,
-  ZLinkObjectReserveRequest,
   ZLinkObjectReserveResult
 } from '../../contracts/Locations/Authority';
+import type {
+  ZLinkObjectReserveRequest,
+  ZLinkEndedOwnerReleaseIntent
+} from './internal-location-contracts';
 
 /**
  * Framework-private domain repository. Provider implementations never
@@ -143,7 +146,8 @@ export interface ZLinkDomainLocationStore {
   releaseEndedReservation?(
     key: ZLinkAuthorityKey,
     expectedStoreVersion: string,
-    signal?: AbortSignal
+    signal?: AbortSignal,
+    request?: ZLinkEndedOwnerReleaseIntent
   ): Promise<boolean>;
   abort(
     request: ZLinkObjectAbortRequest,