@zlink-systems/framework 0.29.1 → 0.30.0

package/src/runtime/foundation/service-topology-registry.ts

@@ -1,4 +1,5 @@
 import { ZLINK_MAX_IDENTITY_TEXT_BYTES } from '../../contracts/Common/CoreTypes';
+import type { ServiceLivenessConnection } from './service-liveness-registry';
 import {
   ZLINK_MAX_PUBLIC_WEIGHT,
   isValidCapacity,
@@ -43,7 +44,8 @@ export interface AdmittedServicePeer {
   readonly descriptor: ServiceNodeDescriptor;
   // The Core selected-route generation this admission belongs to (Core ROUTER
   // §10.1), as an opaque token compared only for equality.
-  readonly connectionId: string;
+  readonly connectionId: string | bigint;
+  readonly liveness?: ServiceLivenessConnection;
 }
 
 export interface ServicePeerAdmissionExpectation {
@@ -103,12 +105,14 @@ export class ServiceTopologyRegistry {
 
   admit(
     descriptor: ServiceNodeDescriptor,
-    connectionId: string,
-    expected?: ServicePeerAdmissionExpectation
+    connectionId: string | bigint,
+    expected?: ServicePeerAdmissionExpectation,
+    admitLiveness?: () => ServiceLivenessConnection
   ): PeerAdmissionResult {
     try {
       validateDescriptor(descriptor);
-      requireText(connectionId, 'connectionId');
+      if (typeof connectionId === 'string') requireText(connectionId, 'connectionId');
+      else if (connectionId === 0n) throw new TypeError('connectionId must be nonzero.');
     } catch (error) {
       return 'invalidDescriptor';
     }
@@ -154,14 +158,15 @@ export class ServiceTopologyRegistry {
     // that route replaces the admission of a route it replaced.
     this.peersByRid.set(descriptor.nodeRoutingId, {
       descriptor: cloneDescriptor(descriptor),
-      connectionId
+      connectionId,
+      liveness: admitLiveness?.() ?? current?.liveness
     });
     this.remember(descriptor);
     this.rebuildSelections();
     return 'admitted';
   }
 
-  disconnect(nodeRoutingId: string, connectionId: string): boolean {
+  disconnect(nodeRoutingId: string, connectionId: string | bigint): boolean {
     const current = this.peersByRid.get(nodeRoutingId);
     if (current === undefined || current.connectionId !== connectionId) return false;
     this.peersByRid.delete(nodeRoutingId);
@@ -525,7 +530,8 @@ function cloneDescriptor(descriptor: ServiceNodeDescriptor): ServiceNodeDescript
 function clonePeer(peer: AdmittedServicePeer): AdmittedServicePeer {
   return {
     descriptor: cloneDescriptor(peer.descriptor),
-    connectionId: peer.connectionId
+    connectionId: peer.connectionId,
+    liveness: peer.liveness
   };
 }
 

package/src/runtime/host/actor-packet-relay.ts

@@ -303,6 +303,7 @@ export class ZLinkActorPacketRelay {
         const dispatch =
           state?.spotId === undefined
             ? this.requireSpotNodeRuntime().dispatchEntryActorPacket(
+                'remote',
                 relay.actorId,
                 [header, body],
                 false,
@@ -310,6 +311,7 @@ export class ZLinkActorPacketRelay {
                 fallbackActorRef
               )
             : this.requireSpotManager().dispatchRoutedActorPacket(
+                'remote',
                 state.spotId,
                 relay.actorId,
                 [header, body],
@@ -356,6 +358,7 @@ export class ZLinkActorPacketRelay {
         const dispatch =
           state?.spotId === undefined
             ? this.requireSpotNodeRuntime().dispatchEntryActorPacket(
+                'remote',
                 relay.actorId,
                 [header, body],
                 false,
@@ -363,6 +366,7 @@ export class ZLinkActorPacketRelay {
                 fallbackActorRef
               )
             : this.requireSpotManager().dispatchRoutedActorPacket(
+                'remote',
                 state.spotId,
                 relay.actorId,
                 [header, body],
@@ -423,6 +427,7 @@ export class ZLinkActorPacketRelay {
       const response =
         state?.spotId === undefined
           ? await this.requireSpotNodeRuntime().dispatchEntryActorPacket(
+              'remote',
               relay.actorId,
               [header, body],
               relay.returnResponse === true,
@@ -430,6 +435,7 @@ export class ZLinkActorPacketRelay {
               fallbackActorRef
             )
           : await this.requireSpotManager().dispatchRoutedActorPacket(
+              'remote',
               state.spotId,
               relay.actorId,
               [header, body],
@@ -892,6 +898,7 @@ export class ZLinkActorPacketRelay {
       this.options.detachedTaskRunner.runDetached('local actor packet relay', async () => {
         try {
           const response = await this.requireSpotManager().dispatchRoutedActorPacket(
+            'local',
             spotId,
             actor.actorId,
             [header, body],

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

@@ -280,6 +280,7 @@ export class ZLinkActorRuntimeOptionsFactory {
         this.actorBelongsToMesh(meshName, actorId) &&
         !this.options.actorHandoff.isProvisional(actorId)
           ? this.options.actorHandoff.capture(
+              'local',
               actorId,
               parts,
               returnResponse,

package/src/runtime/host/application-job-queue.ts

@@ -1,3 +1,5 @@
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import { telemetryLogger } from '../diagnostics/message-flow';
 import { MILLISECONDS_PER_SECOND } from '../diagnostics/runtime-metrics';
 import { ZLinkApplicationJobQueueProfile } from '../../contracts/Dispatch';
 import {
@@ -11,6 +13,7 @@ import {
 import { readFileSync } from 'node:fs';
 import { availableParallelism } from 'node:os';
 import type {
+  ApplicationJobOrigin,
   ApplicationJobPermitPort,
   ApplicationJobQueuePort
 } from '../application-jobs/contracts';
@@ -122,7 +125,10 @@ export function resolveApplicationJobQueueConfiguration(
 export class ApplicationJobQueuePermit implements ApplicationJobPermitPort {
   private state: 'reserved' | 'queued' | 'released' = 'reserved';
 
-  constructor(private readonly owner: ApplicationJobQueue) {}
+  constructor(
+    private readonly owner: ApplicationJobQueue,
+    readonly origin: ApplicationJobOrigin
+  ) {}
 
   markApplicationQueued(): void {
     if (this.state !== 'reserved') {
@@ -149,6 +155,7 @@ export class ApplicationJobQueuePermit implements ApplicationJobPermitPort {
 }
 
 interface CapacityWaiter {
+  readonly origin: ApplicationJobOrigin;
   readonly resolve: (permit: ApplicationJobQueuePermit) => void;
   readonly reject: (reason: unknown) => void;
   readonly signal?: AbortSignal;
@@ -164,6 +171,8 @@ interface CapacityWaiter {
  * directly to the oldest live waiter without allocating the configured limit.
  */
 export class ApplicationJobQueue implements ApplicationJobQueuePort {
+  private localWaiters = 0;
+  private localBacklogLogged = false;
   private reservedSupplyPermits = 0n;
   private queuedApplicationJobs = 0n;
   private peakPermitsInUse = 0n;
@@ -191,7 +200,8 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
   constructor(
     private readonly configuration: ApplicationJobQueueConfiguration,
     private readonly nowMs: () => number = () => performance.now(),
-    private readonly handlerStartGate?: () => boolean
+    private readonly handlerStartGate?: () => boolean,
+    private readonly loggerFailureReporter?: (error: unknown) => void
   ) {
     this.receiveFlowController = new ApplicationJobReceiveFlowController(this, (state) => state);
   }
@@ -242,16 +252,33 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
     this.receiveFlowController.unregister(target);
   }
 
-  acquire(signal?: AbortSignal): Promise<ApplicationJobQueuePermit> {
+  acquire(
+    signal: AbortSignal | undefined,
+    origin: ApplicationJobOrigin
+  ): Promise<ApplicationJobQueuePermit> {
+    return new Promise((resolve, reject) => {
+      const permit = this.acquireOrResume(resolve, reject, signal, origin);
+      if (permit !== undefined) resolve(permit);
+    });
+  }
+
+  acquireOrResume(
+    resume: (permit: ApplicationJobQueuePermit) => void,
+    reject: (reason: unknown) => void,
+    signal: AbortSignal | undefined,
+    origin: ApplicationJobOrigin
+  ): ApplicationJobQueuePermit | undefined {
     if (signal?.aborted === true) {
-      return Promise.reject(abortReason(signal));
+      reject(abortReason(signal));
+      return undefined;
     }
     if (this.waiters.length === 0 && this.permitsInUse() < this.limit()) {
-      return Promise.resolve(this.reserve());
+      return this.reserve(origin);
     }
 
-    return new Promise<ApplicationJobQueuePermit>((resolve, reject) => {
+    new Promise<ApplicationJobQueuePermit>((resolve, reject) => {
       const waiter: CapacityWaiter = {
+        origin,
         resolve,
         reject,
         signal,
@@ -262,9 +289,14 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
       };
       this.waiters.push(waiter);
       this.capacityWaitCount += 1n;
+      const warningCount = this.updateLocalWaiters(origin, 1);
       signal?.addEventListener('abort', waiter.abort, { once: true });
       this.drainWaiters();
-    });
+      if (warningCount !== undefined) this.logLocalBacklog(warningCount);
+    })
+      .then(resume)
+      .catch(reject);
+    return undefined;
   }
 
   snapshot(): ApplicationJobQueueSnapshot {
@@ -356,12 +388,15 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
     return this.reservedSupplyPermits + this.queuedApplicationJobs;
   }
 
-  private reserve(evaluatePressure = true): ApplicationJobQueuePermit {
+  private reserve(
+    origin: ApplicationJobOrigin,
+    evaluatePressure = true
+  ): ApplicationJobQueuePermit {
     this.reservedSupplyPermits += 1n;
     const current = this.permitsInUse();
     if (current > this.peakPermitsInUse) this.peakPermitsInUse = current;
     if (evaluatePressure) this.evaluatePressure();
-    return new ApplicationJobQueuePermit(this);
+    return new ApplicationJobQueuePermit(this, origin);
   }
 
   private drainWaiters(): void {
@@ -371,7 +406,7 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
       waiter.active = false;
       waiter.signal?.removeEventListener('abort', waiter.abort);
       this.recordCompletedWait(waiter);
-      waiter.resolve(this.reserve(false));
+      waiter.resolve(this.reserve(waiter.origin, false));
     }
   }
 
@@ -387,11 +422,43 @@ export class ApplicationJobQueue implements ApplicationJobQueuePort {
   }
 
   private recordCompletedWait(waiter: CapacityWaiter): void {
+    this.updateLocalWaiters(waiter.origin, -1);
     if (waiter.metricsEpoch !== this.metricsEpoch) return;
     const durationMs = Math.max(0, this.nowMs() - waiter.startedAtMs);
     this.capacityWaitDurationSeconds += durationMs / MILLISECONDS_PER_SECOND;
   }
 
+  private updateLocalWaiters(origin: ApplicationJobOrigin, delta: number): number | undefined {
+    if (origin !== 'local') return undefined;
+    this.localWaiters += delta;
+    if (this.localWaiters === 0) this.localBacklogLogged = false;
+    if (!this.localBacklogLogged && this.localWaiters > Number(this.limit())) {
+      this.localBacklogLogged = true;
+      return this.localWaiters;
+    }
+    return undefined;
+  }
+
+  private logLocalBacklog(localWaiters: number): void {
+    try {
+      telemetryLogger.emit({
+        eventName: 'zlink.runtime.host.local_job_backlog_exceeded',
+        timestamp: new Date(),
+        severityNumber: SeverityNumber.WARN,
+        severityText: 'WARN',
+        body: 'Same-host jobs waiting for a host permit exceeded the application job queue maximum.',
+        attributes: {
+          source_kind: 'host',
+          source_name: 'zlink.runtime.host',
+          local_waiters: localWaiters,
+          effective_maximum: Number(this.limit())
+        }
+      });
+    } catch (error) {
+      this.loggerFailureReporter?.(error);
+    }
+  }
+
   private evaluatePressure(): void {
     const permitsInUse = this.permitsInUse();
     const next =

package/src/runtime/host/entry-actor-runtime.ts

@@ -95,6 +95,7 @@ export class ZLinkEntryActorRuntimeService implements ZLinkEntryActorRuntime {
     return {
       handled: true,
       response: await spotManager.dispatchRoutedActorPacket(
+        'remote',
         spotId,
         actorId,
         parts,

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,
@@ -2235,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);
@@ -2757,6 +2771,7 @@ export class ZLinkFrameworkRuntimeHost
       },
       meshRecordDispatcher: (meshName: string, owner: ReadyRecord, record: ReceiveRecord) =>
         this.dispatchMeshRecord(
+          currentApplicationJobOrigin,
           meshName,
           owner,
           record,
@@ -2767,6 +2782,7 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   private async dispatchMeshRecord(
+    applicationJobOrigin: () => ApplicationJobOrigin,
     meshName: string,
     owner: ReadyRecord,
     record: ReceiveRecord,
@@ -2968,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();
@@ -3012,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,