@zlink-systems/framework 0.30.0 → 0.30.2

package/src/runtime/host/index.ts

@@ -1,8 +1,11 @@
+import { ZLinkProviderRelocationRepository } from '../locations/relocation-blob';
 import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import { currentApplicationJobOrigin } from '../application-jobs/application-job-queue-scope';
 import { listAllMeshNodeDescriptors } from '../locations/location-store-pages';
+import { ZLinkDescriptorPublicationUnconfirmedError } from '../locations/descriptor-publication';
 import { ZlinkStreamContentType } from '@zlink-systems/stream-wire';
 import { randomBytes, randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
 import {
   type ActorRef,
   type RoutingId,
@@ -65,11 +68,12 @@ import {
   ZLinkActorTransferRegistry
 } from '../actors';
 import { messageFollowOwnerNodeRid, ownerFence } from '../actors/actor-message-follow-context';
+import { ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET } from '../actors/actor-packet-relay-wire';
 import {
   ZLINK_INTERNAL_ACTOR_TRANSPORT_DELIVERY_GATE,
   type ZLinkInternalActorTransportDeliveryGate
 } from '../actors/actor-transport-delivery-gate';
-import { ZLinkRuntimeAdmissionGate } from '../admission';
+import { ZLinkRuntimeAdmissionGate, type ZLinkMeshDispatchAdmission } from '../admission';
 import {
   ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE,
   type ZLinkInternalApplicationJobQueueHandlerStartGate
@@ -112,6 +116,7 @@ import {
   currentOrCreateFlow,
   DefaultZLinkRuntimeEventPublisher,
   flowIfEnabled,
+  messageFlowTracingEnabled,
   runWithFlow,
   ZLinkRuntimeMetrics,
   type ZLinkDiagnosticsContext,
@@ -140,6 +145,7 @@ import {
 import {
   MeshPeerRuntimeState,
   OperationKind,
+  ReadyDomain,
   ReceiveKind,
   type ReadyRecord,
   type ReceiveRecord
@@ -169,12 +175,18 @@ import {
   encodeFrameworkPayloadMessage
 } from '../messaging/payload-codec';
 import { ZLinkSubmitStatus } from '../messaging/submission-result';
-import { decodeRoutingId, encodeRoutingIdStorageHex, routingIdsEqual } from '../routing-id';
+import {
+  decodeRoutingId,
+  encodeRoutingIdStorageHex,
+  routingIdsEqual,
+  toBackendRoutingId
+} from '../routing-id';
 import {
   DefaultZLinkSpotManager,
   ZLinkPublicSpotManager,
   ZLinkRuntimeSpotPublisherTransport,
   ZLinkSpotNodeRuntimeManager,
+  registrationAcceptsNewActor,
   type ZLinkDetachedTaskRunner,
   type ZLinkSpotManagerOptions
 } from '../spots';
@@ -203,6 +215,7 @@ import { ZLinkInstanceActivationAuthority } from './instance-activation-authorit
 import { ZLinkLocationRuntimeOwner } from './location-runtime-owner';
 import { MeshRouterResolver } from './mesh-router-resolver';
 import {
+  type ZLinkDrainForceReason,
   ZLinkDrainingStatePublishError,
   ZLinkRetiringRollbackError,
   ZLinkRouteMeshRuntimeCoordinator
@@ -218,6 +231,8 @@ import { ZLinkSpotNodeRuntimeOptionsFactory } from './spot-node-runtime-options-
 import { ZLinkSpotRuntimeOptionsFactory } from './spot-runtime-options-factory';
 import { ZLinkStatefulAuthorityRouteRuntime } from './stateful-authority-route-runtime';
 import { ZLinkUserSpotCreationCoordinator } from './user-spot-creation-coordinator';
+import { decodeRemoteActorPacketRelay } from '../spots/spot-remote-route-codec';
+import { decodeStreamHeader } from '../streams/protocol';
 
 const HOST_SHUTDOWN_POLL_INTERVAL_MS = 100;
 const HANDOFF_ACCEPTANCE_POLL_INTERVAL_MS = 10;
@@ -244,7 +259,7 @@ export class ZLinkFrameworkRuntimeHost
   private readonly lifecycleSink?: string[];
   private executionState?: ZLinkFrameworkExecutionState;
   private runtimeState = ZLinkFrameworkRuntimeState.Preparing;
-  private runtimeSequence = 0n;
+  private runtimeStatus?: ZLinkFrameworkRuntimeStatus;
   private readonly runtimeObservationSource = Symbol('zlink.framework-runtime');
   private runtimeDeadline?: Date;
   private shutdownDeadline?: AbortController;
@@ -276,7 +291,9 @@ export class ZLinkFrameworkRuntimeHost
   private spotManager?: DefaultZLinkSpotManager;
   private userSpotCoordinator?: ZLinkUserSpotCreationCoordinator;
   private ownerLeaseRecoveryRuntime?: ZLinkLocationRuntime;
-  private ownerLeaseRecoveryHandler?: () => void;
+  private ownerLeaseRecoveryHandler?: Parameters<
+    ZLinkLocationRuntime['addOwnerLeaseRenewedHandler']
+  >[0];
   private registerUserSpotHandlers?: (runtime: ZLinkSpotNodeRuntimeManager) => void;
   private readonly destroyedActorRefs = new Map<string, ActorRef>();
   private readonly runtimeEventPublisher: ZLinkRuntimeEventPublisher;
@@ -324,6 +341,7 @@ export class ZLinkFrameworkRuntimeHost
   readonly routeMeshRuntime: ZLinkRouteMeshRuntime;
   readonly clientServerRuntime: ZLinkClientServerRuntime;
   readonly fanoutRuntime: ZLinkFanoutRuntime;
+  private readonly relocationStore?: import('../../contracts/Locations/RelocationStore').ZLinkRelocationStore;
   private readonly routeMeshCoordinator: ZLinkRouteMeshRuntimeCoordinator;
   constructor(
     readonly options: ZLinkFrameworkRuntimeHostOptions,
@@ -334,24 +352,20 @@ export class ZLinkFrameworkRuntimeHost
     this.runtimeEventPublisher =
       options.runtimeEventPublisher ?? new DefaultZLinkRuntimeEventPublisher();
     this.metrics = new ZLinkRuntimeMetrics(options.registration.metrics?.meterProvider);
+    const relocationProvider = options.registration.locations.relocationStoreInstance;
+    this.relocationStore =
+      relocationProvider === undefined
+        ? undefined
+        : new ZLinkProviderRelocationRepository(relocationProvider, this.metrics);
+    const handlerStartGate = options.providerResolver?.get?.(
+      ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE as unknown as Type<ZLinkInternalApplicationJobQueueHandlerStartGate>
+    );
     this.applicationJobQueue = new ApplicationJobQueue(
       resolveApplicationJobQueueConfiguration(options.registration.applicationJobQueue, () =>
         nodeEffectiveProcessorCount(options.registration.worker?.maxThreads)
       ),
       undefined,
-      () => {
-        try {
-          return (
-            this.options.providerResolver
-              ?.get?.(
-                ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE as unknown as Type<ZLinkInternalApplicationJobQueueHandlerStartGate>
-              )
-              ?.shouldHoldPermitBeforeHandler() === true
-          );
-        } catch {
-          return false;
-        }
-      },
+      handlerStartGate?.shouldHoldPermitBeforeHandler.bind(handlerStartGate),
       (error) =>
         (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException(
           'logger-provider',
@@ -448,8 +462,8 @@ export class ZLinkFrameworkRuntimeHost
       },
       relay: (actor, header, payload) =>
         this.boundSessionRelay.actorPackets.relayActorPacket(actor, header, payload),
-      notifyDisconnected: (actor, signal) =>
-        this.boundSessionRelay.actorPackets.notifyBoundActorDisconnected(actor, signal)
+      notifyDisconnected: (actor, signal, binding) =>
+        this.boundSessionRelay.actorPackets.notifyBoundActorDisconnected(actor, signal, binding)
     });
     this.actorHandoff = new ZLinkActorHandoffCoordinator({
       routedTransport: this.routeTransport,
@@ -710,21 +724,11 @@ export class ZLinkFrameworkRuntimeHost
       primaryMeshNode: () => this.requirePrimaryMeshNode(),
       notifyEntrySpotActorLeft: (actor, signal) =>
         this.spotNodeRuntime?.notifyPrimaryEntrySpotActorLeft(actor, signal) ?? Promise.resolve(),
-      restoreEntrySpotActorJoined: (actor, signal) =>
-        this.spotNodeRuntime?.notifyPrimaryEntrySpotActorJoined(actor, signal) ?? Promise.resolve(),
       locationLifecycle: () => this.locationOwner.currentLifecycle,
       spotRouteResolver: () => this.createLocationSpotRouteResolver(),
       actorHandoff: this.actorHandoff,
-      actorTransferRegistry: this.actorTransferRegistry,
       authorityStore: () => this.locationOwner.currentStores?.locationStore,
       currentOwner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
-      liveDescriptors: (meshName, signal) => {
-        const runtime = this.locationOwner.currentRuntime;
-        if (runtime === undefined) {
-          throw new Error('Session owner liveness is unavailable without a Location runtime.');
-        }
-        return runtime.listLiveMeshNodes(meshName, signal);
-      },
       sessionRelocationWire: () => this.serviceRelocation,
       clearRemoteActorPacketTarget: (actorId) =>
         this.boundSessionRelay.clearRemoteActorPacketTarget(actorId),
@@ -778,14 +782,16 @@ export class ZLinkFrameworkRuntimeHost
           'source actor departure',
           error
         ),
-      onSourceDepartureCompleted: (actorId) =>
-        this.publishActorHandoffEvent({ marker: 'source_cleanup', actorId }),
-      shutdownSignal: () => this.executionState?.abortController.signal,
-      metrics: this.metrics
+      shutdownSignal: () => this.executionState?.abortController.signal
     });
     this.serviceRelocation = new ZLinkHostServiceRelocationRuntime({
+      flowCreationEnabled: () => this.flowCreationEnabled(),
+      messageFlow: () => this.createDispatchErrorReporter(this.runtimeOrPreStartErrorSink).flow,
       registration: options.registration,
       targetAdmissionSealed: () => this.shutdownOperationStartedAt !== undefined,
+      requestPeerReconcile: (meshName, peerRid) =>
+        this.spotNodeRuntime?.requestPeerReconcile(meshName, peerRid) ?? Promise.resolve(),
+      sourceQuiescenceChanged: () => this.publishCurrentRuntimeStatus(),
       providerResolver: options.providerResolver,
       locationStore: () => this.locationOwner.currentStores?.locationStore,
       currentOwner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
@@ -796,14 +802,14 @@ export class ZLinkFrameworkRuntimeHost
       meshNode: (meshName) => this.spotNodeRuntime?.meshNode(meshName),
       completions: (meshName) => this.spotNodeRuntime?.meshCompletionTable(meshName),
       spotManager: () => this.spotManager,
-      spotNodeRuntime: () => this.spotNodeRuntime,
       actorManager: () => this.actorManager,
       actorTransfer: this.actorTransferRuntime,
       boundSessionRelocation: {
-        receiveSeal: (value, signal) =>
+        receiveSeal: (value, signal, onInstalled) =>
           this.boundSessionRelay.boundSessions.receiveServiceWireSessionRelocationSeal(
             value,
-            signal
+            signal,
+            onInstalled
           ),
         receiveRoute: (value) =>
           this.boundSessionRelay.boundSessions.receiveServiceWireSessionRelocationRoute(value),
@@ -858,7 +864,8 @@ export class ZLinkFrameworkRuntimeHost
         this.performMeshDrain(meshName, signal, stopStartingSignal),
       shutdownResources: (meshName, signal) => this.performMeshShutdown(meshName, signal),
       cleanupHostResources: (signal) => this.cleanupOwnerForDrain(signal),
-      forceStopResources: (meshName) => this.forceStopMesh(meshName)
+      forceStopResources: (meshName, reason, signal) =>
+        this.performMeshShutdown(meshName, signal, reason)
     });
     this.metricRegistrations.push(
       this.metrics.registerHostState(() => runtimeStateMetricName(this.runtimeState)),
@@ -876,6 +883,10 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   get status(): ZLinkFrameworkRuntimeStatus {
+    return this.publishCurrentRuntimeStatus();
+  }
+
+  private buildRuntimeStatus(): ZLinkFrameworkRuntimeStatus {
     return {
       state: this.runtimeState,
       isReady: runtimeStateIsReady(this.runtimeState),
@@ -885,8 +896,8 @@ export class ZLinkFrameworkRuntimeHost
       deadline: this.runtimeDeadline,
       relocationResult: this.runtimeRelocationResult,
       terminationResult: this.runtimeTerminationResult,
-      sequence: this.runtimeSequence,
-      observedAt: new Date()
+      sequence: this.runtimeStatus?.sequence ?? 0n,
+      observedAt: this.runtimeStatus?.observedAt ?? new Date()
     };
   }
 
@@ -904,10 +915,11 @@ export class ZLinkFrameworkRuntimeHost
   }
 
   observe(signal?: AbortSignal): AsyncIterable<ZLinkObservedStatus<ZLinkFrameworkRuntimeStatus>> {
+    const status = this.status;
     const queue = new RuntimeEventQueue<ZLinkFrameworkRuntimeStatus>(undefined, signal);
     this.runtimeObservers.add(queue);
     queue.onClose(() => this.runtimeObservers.delete(queue));
-    this.publishRuntimeStatus(queue, this.status);
+    this.publishRuntimeStatus(queue, status);
     return queue;
   }
 
@@ -1130,6 +1142,9 @@ export class ZLinkFrameworkRuntimeHost
         );
         const drain = await shutdown;
         await unscopedStreamDrain;
+        if (drain.kind === 'forceStopped' && drain.error !== undefined) {
+          this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('host shutdown', drain.error);
+        }
         await this.stop();
         if (drain.kind === 'forceStopped') {
           return this.completeTermination({
@@ -1277,12 +1292,25 @@ export class ZLinkFrameworkRuntimeHost
   private setRuntimeState(state: ZLinkFrameworkRuntimeState): void {
     if (this.runtimeState === state) return;
     this.runtimeState = state;
-    this.runtimeSequence += 1n;
     this.notifyTopologyHostStateChanged();
-    const status = this.status;
+    this.publishCurrentRuntimeStatus();
+  }
+
+  private publishCurrentRuntimeStatus(): ZLinkFrameworkRuntimeStatus {
+    const current = this.buildRuntimeStatus();
+    if (this.runtimeStatus !== undefined && isDeepStrictEqual(this.runtimeStatus, current)) {
+      return this.runtimeStatus;
+    }
+    const status = {
+      ...current,
+      sequence: (this.runtimeStatus?.sequence ?? 0n) + 1n,
+      observedAt: new Date()
+    };
+    this.runtimeStatus = status;
     for (const observer of this.runtimeObservers) {
       this.publishRuntimeStatus(observer, status);
     }
+    return status;
   }
 
   private publishRuntimeStatus(
@@ -1412,7 +1440,6 @@ export class ZLinkFrameworkRuntimeHost
     let spotNodeRuntime: ZLinkSpotNodeRuntimeManager | undefined;
     let streamRuntime: ZLinkStreamRuntimeManager | undefined;
     let startedLocationRuntime: ZLinkLocationRuntime | undefined;
-    let statefulAuthorityRoutes: ZLinkStatefulAuthorityRouteRuntime | undefined;
     try {
       this.executionState = new ZLinkFrameworkExecutionState(context);
       // Seed the shared live-mode cell from the configured mode (default errorsOnly).
@@ -1449,24 +1476,16 @@ export class ZLinkFrameworkRuntimeHost
         () => this.shutdownDeadline!.signal
       );
       startedLocationRuntime = locationRuntime;
-      if (locationRuntime !== undefined) {
-        this.installOwnerLeaseRecoveryPublication(locationRuntime, spotNodeRuntime, channelRuntime);
-      }
       const locationStore = this.locationOwner.currentStores?.locationStore;
       if (locationStore !== undefined && locationRuntime?.ownerLeaseUsable !== false) {
-        await spotNodeRuntime.publishMeshNodeState(
-          ZLinkFrameworkRuntimeState.Preparing,
-          this.executionState.abortController.signal
-        );
-        if (this.requiresStatefulAuthorityRuntime()) {
-          this.installLocationBackedAuthorities(locationStore, spotNodeRuntime);
-          statefulAuthorityRoutes = this.createStatefulAuthorityRoutes(
-            locationStore,
-            spotNodeRuntime
+        await this.publishOrStayPreparing(locationRuntime, async (publishSignal) => {
+          await spotNodeRuntime!.startLocationAutoConnect(publishSignal);
+          await channelRuntime!.startLocationAutoConnect(publishSignal);
+          await spotNodeRuntime!.publishMeshNodeState(
+            ZLinkFrameworkRuntimeState.Preparing,
+            publishSignal
           );
-          await statefulAuthorityRoutes.start(this.executionState.abortController.signal);
-          this.statefulAuthorityRoutes = statefulAuthorityRoutes;
-        }
+        });
       }
       streamRuntime = new ZLinkStreamRuntimeManager({
         listenerRecords,
@@ -1488,18 +1507,20 @@ export class ZLinkFrameworkRuntimeHost
       });
       streamRuntime.start();
       this.streamRuntime = streamRuntime;
+      // Location runtime §5: a host without an owner lease stays Preparing;
+      // owner lease recovery enters Serving once it publishes descriptors.
       if (locationRuntime === undefined || locationRuntime.ownerLeaseUsable) {
-        await spotNodeRuntime.publishMeshNodeState(
-          ZLinkFrameworkRuntimeState.Serving,
-          this.executionState.abortController.signal
+        await this.publishOrStayPreparing(locationRuntime, (publishSignal) =>
+          this.enterServing(spotNodeRuntime!, publishSignal)
         );
       }
-      this.routeMeshCoordinator.markServing();
-      this.setRuntimeState(ZLinkFrameworkRuntimeState.Serving);
+      if (locationRuntime !== undefined) {
+        this.installOwnerLeaseRecoveryPublication(locationRuntime, spotNodeRuntime, channelRuntime);
+      }
       this.lifecycleSink?.push('framework:started');
     } catch (error) {
       if (this.shutdownDeadline !== undefined && isAbortError(error)) throw error;
-      await statefulAuthorityRoutes?.stop();
+      await this.statefulAuthorityRoutes?.stop();
       try {
         await this.runWithShutdownDeadline(DEFAULT_HOST_CONTROL_TIMEOUT_MS, async () =>
           rollbackRuntimeStart({
@@ -1554,7 +1575,13 @@ export class ZLinkFrameworkRuntimeHost
       const hasDiscovery = hasConfiguredLocationStore(this.options.registration);
       const source =
         hasManual && hasDiscovery ? 'manual_and_redis' : hasManual ? 'manual' : 'redis';
-      const emptyCapacity = { active: 0, reserved: 0, limit: 0 };
+      const capacity =
+        descriptor === undefined
+          ? undefined
+          : this.locationOwner.currentStores?.locationStore.confirmedCapacity?.(
+              { meshName, rid: descriptor.rid },
+              descriptor.populationCapacity
+            );
       snapshots.push({
         meshName,
         source,
@@ -1566,9 +1593,9 @@ export class ZLinkFrameworkRuntimeHost
           channelName: channel.channelName,
           readyMembers: channel.readyTargetCount
         })),
-        actorCapacity: descriptor?.populationCapacity.actors ?? emptyCapacity,
-        spotCapacity: descriptor?.populationCapacity.spots ?? emptyCapacity,
-        spotTypeCapacities: (descriptor?.populationCapacity.spotTypes ?? []).map((capacity) => ({
+        actorCapacity: capacity?.actors,
+        spotCapacity: capacity?.spots,
+        spotTypeCapacities: (capacity?.spotTypes ?? []).map((capacity) => ({
           spotKind: capacity.objectKind === 'instance_spot' ? 'instance' : 'user',
           stableType: capacity.stableType,
           active: capacity.active,
@@ -1627,14 +1654,22 @@ export class ZLinkFrameworkRuntimeHost
     spotNodeRuntime: ZLinkSpotNodeRuntimeManager,
     channelRuntime: ZLinkChannelRuntimeManager
   ): void {
-    const handler = () => {
+    let recoveryOperation: Promise<void> | undefined;
+    const handler: Parameters<ZLinkLocationRuntime['addOwnerLeaseRenewedHandler']>[0] = (
+      _renewal,
+      wasOwnerLeaseUsable
+    ) => {
       if (!this.ownerAdmissionOpen()) return;
-      void this.resumeOwnerLeaseOwnedWork(runtime, spotNodeRuntime, channelRuntime).catch(
-        (error) => {
+      if (wasOwnerLeaseUsable && this.runtimeState !== ZLinkFrameworkRuntimeState.Preparing) return;
+      if (recoveryOperation !== undefined) return;
+      recoveryOperation = this.resumeOwnerLeaseOwnedWork(runtime, spotNodeRuntime, channelRuntime)
+        .catch((error) => {
           runtime.closeOwnerLeaseAdmission(error);
           this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('owner lease recovery', error);
-        }
-      );
+        })
+        .finally(() => {
+          recoveryOperation = undefined;
+        });
     };
     this.ownerLeaseRecoveryRuntime = runtime;
     this.ownerLeaseRecoveryHandler = handler;
@@ -1647,25 +1682,72 @@ export class ZLinkFrameworkRuntimeHost
     channelRuntime: ZLinkChannelRuntimeManager
   ): Promise<void> {
     if (!this.ownerAdmissionOpen()) return;
-    const signal = this.executionState?.abortController.signal;
-    await spotNodeRuntime.publishMeshNodeState(ZLinkFrameworkRuntimeState.Preparing, signal);
+    await this.publishOrStayPreparing(runtime, async (signal) => {
+      await spotNodeRuntime.publishMeshNodeState(ZLinkFrameworkRuntimeState.Preparing, signal);
+      if (runtime.ownerLeaseUsable === false) return;
+      if (this.runtimeState !== ZLinkFrameworkRuntimeState.Preparing) {
+        await spotNodeRuntime.publishMeshNodeState(this.runtimeState, signal);
+      }
+      await spotNodeRuntime.startLocationAutoConnect(signal);
+      await channelRuntime.startLocationAutoConnect(signal);
+      await channelRuntime.reclaimLocationOwnerRows(signal);
+      await this.locationOwner.currentLifecycle?.reclaimOwnerRows();
+      if (this.runtimeState === ZLinkFrameworkRuntimeState.Preparing) {
+        await this.enterServing(spotNodeRuntime, signal);
+      }
+    });
+  }
+
+  // The one transition from Preparing to Serving: the host publishes its
+  // Serving descriptors first, then takes new application work.
+  private async enterServing(
+    spotNodeRuntime: ZLinkSpotNodeRuntimeManager,
+    signal: AbortSignal | undefined
+  ): Promise<void> {
     const store = this.locationOwner.currentStores?.locationStore;
-    if (
-      this.statefulAuthorityRoutes === undefined &&
-      store !== undefined &&
-      this.executionState !== undefined &&
-      this.requiresStatefulAuthorityRuntime()
-    ) {
-      const routes = this.createStatefulAuthorityRoutes(store, spotNodeRuntime);
-      await routes.start(signal);
-      this.statefulAuthorityRoutes = routes;
+    if (store !== undefined) {
+      await this.startStatefulAuthority(store, spotNodeRuntime, signal);
+    }
+    await spotNodeRuntime.publishMeshNodeState(ZLinkFrameworkRuntimeState.Serving, signal);
+    this.routeMeshCoordinator.markServing();
+    this.setRuntimeState(ZLinkFrameworkRuntimeState.Serving);
+  }
+
+  // Location runtime §5: a startup publication the Store does not confirm (a
+  // provider error, or no answer within the renew timeout) leaves the host in
+  // Preparing. The owner lease renewal handler retries publication while the
+  // host stays Preparing; only a settled rejection fails startup.
+  private async publishOrStayPreparing(
+    runtime: ZLinkLocationRuntime | undefined,
+    publish: (signal: AbortSignal | undefined) => Promise<void>
+  ): Promise<boolean> {
+    const signal = this.executionState?.abortController.signal;
+    try {
+      await publish(signal);
+      return true;
+    } catch (error) {
+      if (runtime === undefined || !(error instanceof ZLinkDescriptorPublicationUnconfirmedError))
+        throw error;
+      this.runtimeOrPreStartErrorSink.reportRuntimeTaskException(
+        'startup descriptor publication',
+        error
+      );
+      return false;
     }
-    if (runtime.ownerLeaseUsable === false) return;
-    await spotNodeRuntime.publishMeshNodeState(this.runtimeState, signal);
-    await spotNodeRuntime.startLocationAutoConnect(signal);
-    await channelRuntime.startLocationAutoConnect(signal);
-    await channelRuntime.reclaimLocationOwnerRows(signal);
-    await this.locationOwner.currentLifecycle?.reclaimOwnerRows();
+  }
+
+  private async startStatefulAuthority(
+    locationStore: import('../locations/domain-store-contract').ZLinkDomainLocationStore,
+    spotNodeRuntime: ZLinkSpotNodeRuntimeManager,
+    signal: AbortSignal | undefined
+  ): Promise<void> {
+    if (this.statefulAuthorityRoutes !== undefined || !this.requiresStatefulAuthorityRuntime()) {
+      return;
+    }
+    this.installLocationBackedAuthorities(locationStore, spotNodeRuntime);
+    const routes = this.createStatefulAuthorityRoutes(locationStore, spotNodeRuntime);
+    await routes.start(signal);
+    this.statefulAuthorityRoutes = routes;
   }
 
   private createStatefulAuthorityRoutes(
@@ -1675,7 +1757,7 @@ export class ZLinkFrameworkRuntimeHost
     return new ZLinkStatefulAuthorityRouteRuntime({
       store: locationStore,
       creationStore: locationStore,
-      relocationStore: this.options.registration.locations.relocationStoreInstance,
+      relocationStore: this.relocationStore,
       meshNodes: spotNodeRuntime.meshNodesByName,
       pollingIntervalMs:
         this.options.registration.locations.options.pollingIntervalMs ??
@@ -1733,7 +1815,7 @@ export class ZLinkFrameworkRuntimeHost
             this.options.registration.spotNodes.get(meshName)?.instanceSpotFactoryRegistrations?.[
               stableType
             ]?.relocation.kind,
-          relocationStore: this.options.registration.locations.relocationStoreInstance,
+          relocationStore: this.relocationStore,
           meshName,
           owner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
           metrics: this.metrics,
@@ -1798,7 +1880,24 @@ export class ZLinkFrameworkRuntimeHost
     );
   }
 
-  private async performMeshShutdown(meshName: string, signal: AbortSignal): Promise<void> {
+  private async performMeshShutdown(
+    meshName: string,
+    signal: AbortSignal,
+    forceReason?: ZLinkDrainForceReason
+  ): Promise<void> {
+    if (forceReason !== undefined) {
+      this.spotNodeRuntime
+        ?.meshNode(meshName)
+        ?.cancelPendingOperations?.(
+          createInternalFrameworkException(
+            ZLinkFrameworkInternalErrorKind.RuntimeShutdown,
+            'The host stopped before the request completed.'
+          )
+        );
+      await waitForForcedSessionNotification(this.streamRuntime?.notifyServerDrain(meshName));
+    } else {
+      await awaitWithDrainSignal(this.serviceRelocation.drainActorJoinSources(meshName), signal);
+    }
     await this.spotManager?.drainForShutdown(meshName, signal, this.runtimeDeadline);
     await awaitWithDrainSignal(this.streamRuntime?.notifyServerDrain(meshName), signal);
   }
@@ -1952,11 +2051,6 @@ export class ZLinkFrameworkRuntimeHost
     }
   }
 
-  private async forceStopMesh(meshName: string): Promise<void> {
-    await waitForForcedSessionNotification(this.streamRuntime?.notifyServerDrain(meshName));
-    await this.spotManager?.drainForShutdown(meshName, undefined, this.runtimeDeadline);
-  }
-
   private registerInstanceApplicationLifecycle(
     meshName: string,
     node: ZLinkBackendMeshNode,
@@ -1986,8 +2080,10 @@ export class ZLinkFrameworkRuntimeHost
           target.stableType,
           target.targetSpotId as never,
           objectGeneration,
-          this.executionState?.abortController.signal
+          this.executionState?.abortController.signal,
+          'first-terminal'
         ),
+      publish: (target) => spotManager.publishInstance(target, meshName),
       discard: (target) => spotManager.discardInstance(meshName, target.targetSpotId as never),
       beginTerminal: (target) =>
         spotManager.beginInstanceTerminal(
@@ -2214,8 +2310,8 @@ export class ZLinkFrameworkRuntimeHost
               descriptor.objectRole === 'server' &&
               descriptor.placementWeight > 0 &&
               descriptor.entrySpotId !== undefined &&
-              excludedNodeRids?.has(String(descriptor.rid)) !== true &&
-              capability !== undefined
+              excludedNodeRids?.has(encodeRoutingIdStorageHex(descriptor.rid)) !== true &&
+              capability?.entryAccepted === true
             );
           }
         );
@@ -2239,7 +2335,7 @@ export class ZLinkFrameworkRuntimeHost
             leaseGeneration: selected.leaseGeneration
           },
           isLocal:
-            String(localStatus.routingId) === String(selected.rid) &&
+            routingIdsEqual(localStatus.routingId, selected.rid) &&
             localStatus.lifecycleGeneration === selected.lifecycleGeneration
         };
       }
@@ -2330,7 +2426,7 @@ export class ZLinkFrameworkRuntimeHost
               descriptor.state === 1 &&
               descriptor.objectRole === 'server' &&
               descriptor.placementWeight > 0 &&
-              excludedNodeRids?.has(String(descriptor.rid)) !== true &&
+              excludedNodeRids?.has(encodeRoutingIdStorageHex(descriptor.rid)) !== true &&
               (spots.limit === 0 || spots.active + spots.reserved < spots.limit) &&
               capability !== undefined &&
               (spotTypeCapacity === undefined ||
@@ -2351,7 +2447,7 @@ export class ZLinkFrameworkRuntimeHost
           },
           isLocal:
             localStatus !== undefined &&
-            String(localStatus.routingId) === String(selected.rid) &&
+            routingIdsEqual(localStatus.routingId, selected.rid) &&
             localStatus.lifecycleGeneration === selected.lifecycleGeneration
         };
       }
@@ -2457,6 +2553,18 @@ export class ZLinkFrameworkRuntimeHost
             return await actorPlacement.handleRemoteCreate(
               record,
               async (requestPayload, authority, createSignal) => {
+                const registration = this.options.registration.spotNodes.get(meshName);
+                if (
+                  registration === undefined ||
+                  !registrationAcceptsNewActor(registration, record.stableType)
+                ) {
+                  // Framework failure before the callback (Actor model §6.3): the reservation is
+                  // cancelled and the requester excludes this host run.
+                  throw createInternalFrameworkException(
+                    ZLinkFrameworkInternalErrorKind.RouteNotConnected,
+                    `RouteMesh '${meshName}' registers no Entry Spot type that accepts Actor type '${record.stableType}'.`
+                  );
+                }
                 const request = decodeFrameworkCreationPayload(
                   requestPayload,
                   this.options.registration.messageSerializers
@@ -2512,7 +2620,7 @@ export class ZLinkFrameworkRuntimeHost
                 }
                 if (
                   local.actorRef.objectGeneration !== authority.objectGeneration ||
-                  String(local.actorRef.nodeRid) !== record.reservation.targetNodeRid
+                  !routingIdsEqual(local.actorRef.nodeRid, record.reservation.targetNodeRid)
                 ) {
                   throw createInternalFrameworkException(
                     ZLinkFrameworkInternalErrorKind.ActorCreateFailed,
@@ -2589,7 +2697,7 @@ export class ZLinkFrameworkRuntimeHost
       },
       isLocalNode: (meshName, nodeRid) => {
         const status = this.spotNodeRuntime?.meshNode(meshName)?.status();
-        return status !== undefined && String(status.routingId) === String(nodeRid);
+        return status !== undefined && routingIdsEqual(status.routingId, nodeRid);
       },
       remoteClose: (meshName, targetNodeRid, request, timeoutMs) => {
         const node = this.spotNodeRuntime?.meshNode(meshName);
@@ -2781,13 +2889,70 @@ export class ZLinkFrameworkRuntimeHost
     };
   }
 
-  private async dispatchMeshRecord(
+  private dispatchMeshNodeRecord(
+    meshName: string,
+    record: ReceiveRecord,
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
+    const control = this.serviceRelocation.tryHandleControl(meshName, record, signal);
+    if (control instanceof Promise)
+      return control.then((handled) =>
+        handled ? undefined : this.dispatchMeshNodePayload(meshName, record, signal, admit)
+      );
+    if (!control) return this.dispatchMeshNodePayload(meshName, record, signal, admit);
+  }
+
+  private dispatchMeshNodePayload(
+    meshName: string,
+    record: ReceiveRecord,
+    signal?: AbortSignal,
+    admit?: ZLinkMeshDispatchAdmission
+  ): void | Promise<void> {
+    if (record.kind === ReceiveKind.NodeRequest && record.parts.length === 1) {
+      const terminal = decodeRemoteActorSourceLeaveTerminal(record.parts[0]!.data());
+      if (terminal !== undefined) {
+        return this.completeFormalSourceLeave(record, terminal);
+      }
+    }
+    const channelRuntime = this.channelRuntime;
+    if (channelRuntime === undefined) {
+      throw new ZLinkConfigurationException(
+        'MeshNode node-direct dispatch requires the channel runtime.'
+      );
+    }
+    return channelRuntime.dispatchMeshRoute(meshName, record, signal, admit);
+  }
+
+  private async completeFormalSourceLeave(
+    record: ReceiveRecord,
+    terminal: NonNullable<ReturnType<typeof decodeRemoteActorSourceLeaveTerminal>>
+  ): Promise<void> {
+    const completed = await this.spotManager?.completeFormalSourceLeaveTerminal(
+      terminal.actorId,
+      terminal.transferId,
+      terminal.succeeded
+    );
+    if (completed !== true) {
+      throw new ZLinkConfigurationException(
+        `Actor '${terminal.actorId}' has no matching formal transfer terminal gate.`
+      );
+    }
+    if (record.reply(Buffer.alloc(0)) !== SubmitResult.Ok) {
+      throw new ZLinkConfigurationException(
+        `Actor '${terminal.actorId}' formal transfer terminal acknowledgement failed.`
+      );
+    }
+    return;
+  }
+
+  private dispatchMeshRecord(
     applicationJobOrigin: () => ApplicationJobOrigin,
     meshName: string,
     owner: ReadyRecord,
     record: ReceiveRecord,
     signal?: AbortSignal
-  ): Promise<void> {
+  ): void | Promise<void> {
     if (record.operationKind === OperationKind.ActorJoin) {
       if (this.spotManager === undefined) {
         throw new ZLinkConfigurationException(
@@ -2796,107 +2961,8 @@ export class ZLinkFrameworkRuntimeHost
       }
       return this.spotManager.dispatchMeshActorJoin(meshName, owner, record);
     }
-    if (record.kind === ReceiveKind.ActorBinding) {
-      if (record.kindData?.kind !== 'actorBinding') {
-        throw new ZLinkConfigurationException(
-          'MeshNode Actor binding record has no binding generation.'
-        );
-      }
-      const binding = record.kindData;
-      const replyBindingFailure = (kind: ZLinkFrameworkInternalErrorKind): void => {
-        const terminal = internalFrameworkWireReply(kind);
-        if (
-          record.replyFailure?.(terminal.terminalResult, terminal.failureCode) !== SubmitResult.Ok
-        ) {
-          throw new ZLinkConfigurationException(
-            `MeshNode Actor binding target '${binding.actor.actorId}' failure acknowledgement failed.`
-          );
-        }
-      };
-      const replyBindingSuccess = (): void => {
-        if (record.reply(Buffer.alloc(0)) !== SubmitResult.Ok) {
-          throw new ZLinkConfigurationException(
-            `MeshNode Actor binding target '${binding.actor.actorId}' acknowledgement failed.`
-          );
-        }
-      };
-      const state = this.actorManager?.getState(binding.actor.actorId);
-      const nativeActorRef = state?.nativeActorRef;
-      if (
-        state === undefined ||
-        nativeActorRef === undefined ||
-        nativeActorRef.actorId !== binding.actor.actorId ||
-        !routingIdsEqual(nativeActorRef.nodeRid, binding.actor.nodeRid)
-      ) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-        return;
-      }
-      if (nativeActorRef.generation !== binding.actor.generation) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorGenerationStale);
-        return;
-      }
-      const node =
-        state.meshName === meshName ? this.spotNodeRuntime?.meshNode(meshName) : undefined;
-      const localStatus = node?.status();
-      // ownsLocation tracks local cleanup responsibility, not Actor authority.
-      // A relocation target can exact-read committed authority without owning that cleanup.
-      if (
-        localStatus === undefined ||
-        !routingIdsEqual(localStatus.routingId, binding.actor.nodeRid) ||
-        localStatus.lifecycleGeneration !== binding.actorNodeGeneration ||
-        state.locationGeneration !== binding.authorityOwnerGeneration ||
-        state.isMoving
-      ) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-        return;
-      }
-      const sessionOwnerIsLocal =
-        routingIdsEqual(localStatus.routingId, binding.sessionNodeRid) &&
-        localStatus.lifecycleGeneration === binding.sessionOwnerNodeGeneration;
-      if (binding.transition === 'tombstone') {
-        const actorRef: ActorRef = {
-          actorId: binding.actor.actorId,
-          objectGeneration: binding.actor.generation,
-          meshName,
-          nodeRid: binding.actor.nodeRid
-        };
-        if (sessionOwnerIsLocal) {
-          releaseApplicationJobPermitBeforeHandler();
-          await this.streamBindingRuntime.retireRemoteBinding(
-            actorRef,
-            binding.sessionRid,
-            binding.bindingGeneration,
-            signal
-          );
-        }
-        state.retireBoundSessionBinding(binding);
-        replyBindingSuccess();
-        return;
-      }
-      const target = this.boundSessionRelay.boundSessions.resolveRemoteBoundSessionTarget(
-        binding.sessionNodeRid,
-        binding.sessionRid
-      );
-      if (target === undefined) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-        return;
-      }
-      const installed = state.installBoundSessionBinding({
-        ...target,
-        sessionNodeRid: binding.sessionNodeRid,
-        sessionRid: binding.sessionRid,
-        sessionOwnerNodeGeneration: binding.sessionOwnerNodeGeneration,
-        sessionOwnerId: binding.sessionOwnerId,
-        sessionOwnerLeaseGeneration: binding.sessionOwnerLeaseGeneration,
-        bindingGeneration: binding.bindingGeneration
-      });
-      if (!installed) {
-        replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-        return;
-      }
-      replyBindingSuccess();
-      return Promise.resolve();
-    }
+    if (record.kind === ReceiveKind.ActorBinding)
+      return this.dispatchMeshActorBinding(meshName, record, signal);
     switch (record.kind) {
       case ReceiveKind.TransferControl:
         if (record.kindData?.kind !== 'transferControl') {
@@ -2913,52 +2979,32 @@ export class ZLinkFrameworkRuntimeHost
             'MeshNode channel dispatch requires the channel runtime.'
           );
         }
-        return this.admission.run(meshName, 'RouteMesh channel dispatch', () =>
-          channelRuntime.dispatchMeshChannel(meshName, record, signal)
+        return channelRuntime.dispatchMeshChannel(
+          meshName,
+          record,
+          signal,
+          (dispatch, onRejected) =>
+            this.admitMeshDispatch(
+              meshName,
+              record,
+              'RouteMesh channel dispatch',
+              dispatch,
+              onRejected
+            )
         );
       }
       case ReceiveKind.NodeSend:
       case ReceiveKind.NodeRequest: {
-        return this.admission.run(meshName, 'RouteMesh node dispatch', async () => {
-          if (await this.serviceRelocation.tryHandleControl(meshName, record, signal)) {
-            return;
-          }
-          if (record.kind === ReceiveKind.NodeRequest && record.parts.length === 1) {
-            const terminal = decodeRemoteActorSourceLeaveTerminal(record.parts[0]!.data());
-            if (terminal !== undefined) {
-              if (
-                (await this.spotManager?.completeFormalSourceLeaveTerminal(
-                  terminal.actorId,
-                  terminal.transferId,
-                  terminal.succeeded
-                )) !== true
-              ) {
-                throw new ZLinkConfigurationException(
-                  `Actor '${terminal.actorId}' has no matching formal transfer terminal gate.`
-                );
-              }
-              if (record.reply(Buffer.alloc(0)) !== SubmitResult.Ok) {
-                throw new ZLinkConfigurationException(
-                  `Actor '${terminal.actorId}' formal transfer terminal acknowledgement failed.`
-                );
-              }
-              return;
-            }
-          }
-          const channelRuntime = this.channelRuntime;
-          if (channelRuntime === undefined) {
-            throw new ZLinkConfigurationException(
-              'MeshNode node-direct dispatch requires the channel runtime.'
-            );
-          }
-          return await channelRuntime.dispatchMeshRoute(meshName, record, signal);
-        });
+        return this.dispatchMeshNodeRecord(meshName, record, signal, (dispatch, onRejected) =>
+          this.admitMeshDispatch(meshName, record, 'RouteMesh node dispatch', dispatch, onRejected)
+        );
       }
+
       case ReceiveKind.SpotSend:
       case ReceiveKind.SpotRequest:
       case ReceiveKind.SpotMulticast:
-        return this.admission.run(meshName, 'RouteMesh Spot dispatch', () =>
-          this.dispatchMeshSpotRecord(meshName, owner, record)
+        return this.dispatchMeshSpotRecord(meshName, owner, record, (dispatch, onRejected) =>
+          this.admitMeshDispatch(meshName, record, 'RouteMesh Spot dispatch', dispatch, onRejected)
         );
       case ReceiveKind.InstanceSpotActivation:
         if (this.spotManager === undefined) {
@@ -2966,8 +3012,18 @@ export class ZLinkFrameworkRuntimeHost
             'MeshNode Instance Spot dispatch requires the Spot manager.'
           );
         }
-        return this.admission.run(meshName, 'RouteMesh Instance Spot dispatch', () =>
-          this.spotManager!.dispatchMeshInstance(meshName, owner, record)
+        return this.spotManager.dispatchMeshInstance(
+          meshName,
+          owner,
+          record,
+          (dispatch, onRejected) =>
+            this.admitMeshDispatch(
+              meshName,
+              record,
+              'RouteMesh Instance Spot dispatch',
+              dispatch,
+              onRejected
+            )
         );
       case ReceiveKind.SpotControl:
         if (this.spotManager === undefined) {
@@ -2983,8 +3039,19 @@ export class ZLinkFrameworkRuntimeHost
             'MeshNode Actor dispatch requires the Spot manager.'
           );
         }
-        return this.admission.run(meshName, 'RouteMesh Actor dispatch', () =>
-          this.spotManager!.dispatchMeshActor(applicationJobOrigin(), meshName, owner, record)
+        return this.spotManager.dispatchMeshActor(
+          applicationJobOrigin(),
+          meshName,
+          owner,
+          record,
+          (dispatch, onRejected) =>
+            this.admitMeshDispatch(
+              meshName,
+              record,
+              'RouteMesh Actor dispatch',
+              dispatch,
+              onRejected
+            )
         );
       case ReceiveKind.SendReady:
         return Promise.resolve();
@@ -2995,6 +3062,141 @@ export class ZLinkFrameworkRuntimeHost
     }
   }
 
+  private admitMeshDispatch(
+    meshName: string,
+    record: ReceiveRecord,
+    operation: string,
+    dispatch: () => void | Promise<void>,
+    onRejected?: (error: unknown) => void | Promise<void>
+  ): void | Promise<void> {
+    // Execution gate §13 and host relocation §14 keep control progress independent
+    // of new application admission. Disconnect callbacks still use their owner gate.
+    if (record.domain === ReadyDomain.Infrastructure) return dispatch();
+    if (
+      !this.admission.accepts(meshName) &&
+      (record.kind === ReceiveKind.NodeSend ||
+        record.kind === ReceiveKind.NodeRequest ||
+        record.kind === ReceiveKind.SpotSend ||
+        record.kind === ReceiveKind.SpotRequest)
+    ) {
+      const relay = decodeRemoteActorPacketRelay(
+        record.parts,
+        { serializers: this.options.registration.messageSerializers },
+        this.flowCreationEnabled()
+      );
+      if (
+        relay !== undefined &&
+        decodeStreamHeader(Buffer.from(relay.header, 'base64'), this.flowCreationEnabled()).name ===
+          ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET
+      ) {
+        return dispatch();
+      }
+    }
+    return this.admission.run(meshName, operation, dispatch, onRejected);
+  }
+
+  private async dispatchMeshActorBinding(
+    meshName: string,
+    record: ReceiveRecord,
+    signal?: AbortSignal
+  ): Promise<void> {
+    if (record.kindData?.kind !== 'actorBinding') {
+      throw new ZLinkConfigurationException(
+        'MeshNode Actor binding record has no binding generation.'
+      );
+    }
+    const binding = record.kindData;
+    const replyBindingFailure = (kind: ZLinkFrameworkInternalErrorKind): void => {
+      const terminal = internalFrameworkWireReply(kind);
+      if (
+        record.replyFailure?.(terminal.terminalResult, terminal.failureCode) !== SubmitResult.Ok
+      ) {
+        throw new ZLinkConfigurationException(
+          `MeshNode Actor binding target '${binding.actor.actorId}' failure acknowledgement failed.`
+        );
+      }
+    };
+    const replyBindingSuccess = (): void => {
+      if (record.reply(Buffer.alloc(0)) !== SubmitResult.Ok) {
+        throw createInternalFrameworkException(
+          ZLinkFrameworkInternalErrorKind.ActorLocationStale,
+          `MeshNode Actor binding target '${binding.actor.actorId}' acknowledgement failed.`
+        );
+      }
+    };
+    const state = this.actorManager?.getState(binding.actor.actorId);
+    const nativeActorRef = state?.nativeActorRef;
+    if (
+      state === undefined ||
+      nativeActorRef === undefined ||
+      nativeActorRef.actorId !== binding.actor.actorId ||
+      !routingIdsEqual(nativeActorRef.nodeRid, binding.actor.nodeRid)
+    ) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      return;
+    }
+    if (nativeActorRef.generation !== binding.actor.generation) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorGenerationStale);
+      return;
+    }
+    const node = state.meshName === meshName ? this.spotNodeRuntime?.meshNode(meshName) : undefined;
+    const localStatus = node?.status();
+    // ownsLocation tracks local cleanup responsibility, not Actor authority.
+    // A relocation target can exact-read committed authority without owning that cleanup.
+    if (
+      localStatus === undefined ||
+      !routingIdsEqual(localStatus.routingId, binding.actor.nodeRid) ||
+      localStatus.lifecycleGeneration !== binding.actorNodeGeneration ||
+      state.locationGeneration !== binding.authorityOwnerGeneration ||
+      state.isMoving
+    ) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      return;
+    }
+    const sessionOwnerIsLocal =
+      routingIdsEqual(localStatus.routingId, binding.sessionNodeRid) &&
+      localStatus.lifecycleGeneration === binding.sessionOwnerNodeGeneration;
+    if (binding.transition === 'tombstone') {
+      const actorRef: ActorRef = {
+        actorId: binding.actor.actorId,
+        objectGeneration: binding.actor.generation,
+        meshName,
+        nodeRid: binding.actor.nodeRid
+      };
+      if (sessionOwnerIsLocal) {
+        releaseApplicationJobPermitBeforeHandler();
+        await this.streamBindingRuntime.retireRemoteBinding(
+          actorRef,
+          binding.sessionRid,
+          binding.bindingGeneration,
+          signal
+        );
+      }
+      state.retireBoundSessionBinding(binding);
+      replyBindingSuccess();
+      return;
+    }
+    const target = this.boundSessionRelay.boundSessions.resolveRemoteBoundSessionTarget(
+      binding.sessionNodeRid,
+      binding.sessionRid
+    );
+    if (target === undefined) {
+      replyBindingFailure(ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+      return;
+    }
+    replyBindingSuccess();
+    state.installBoundSessionBinding({
+      ...target,
+      sessionNodeRid: binding.sessionNodeRid,
+      sessionRid: binding.sessionRid,
+      sessionOwnerNodeGeneration: binding.sessionOwnerNodeGeneration,
+      sessionOwnerId: binding.sessionOwnerId,
+      sessionOwnerLeaseGeneration: binding.sessionOwnerLeaseGeneration,
+      bindingGeneration: binding.bindingGeneration
+    });
+    return Promise.resolve();
+  }
+
   private submitLocalMeshRoute(
     meshName: string,
     sourceNodeRid: string,
@@ -3052,7 +3254,8 @@ export class ZLinkFrameworkRuntimeHost
   private async dispatchMeshSpotRecord(
     meshName: string,
     owner: ReadyRecord,
-    record: ReceiveRecord
+    record: ReceiveRecord,
+    admit?: ZLinkMeshDispatchAdmission
   ): Promise<void> {
     const envelope = decodeChannelEnvelope(record.parts, undefined, this.flowCreationEnabled());
     if (envelope.packetName === ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET) {
@@ -3068,33 +3271,32 @@ export class ZLinkFrameworkRuntimeHost
         correlationId: envelope.header.correlationId ?? undefined
       };
       try {
-        const response = await this.boundSessionRelay.actorPackets.receiveRemoteActorPacketRelay(
-          payload,
-          context
-        );
-        if (record.kind === ReceiveKind.SpotRequest) {
-          record.reply(encodeChannelReplyParts(envelope.header, response));
-        }
+        const dispatch = async () => {
+          const response = await this.boundSessionRelay.actorPackets.receiveRemoteActorPacketRelay(
+            payload,
+            context
+          );
+          if (record.kind === ReceiveKind.SpotRequest)
+            record.reply(encodeChannelReplyParts(envelope.header, response));
+        };
+        await (admit === undefined ? dispatch() : admit(dispatch));
       } catch (error) {
         if (record.kind !== ReceiveKind.SpotRequest) {
           throw error;
         }
-        record.reply(
-          encodeChannelErrorReplyParts(
-            envelope.header,
-            error instanceof Error ? error.message : String(error)
-          )
-        );
+        record.reply(encodeChannelErrorReplyParts(envelope.header, error));
       }
       return;
     }
-    if ((await this.spotNodeRuntime?.dispatchEntrySpotRecord(meshName, owner, record)) === true) {
+    if (
+      (await this.spotNodeRuntime?.dispatchEntrySpotRecord(meshName, owner, record, admit)) === true
+    ) {
       return;
     }
     if (this.spotManager === undefined) {
       throw new ZLinkConfigurationException('MeshNode Spot dispatch requires the Spot manager.');
     }
-    await this.spotManager.dispatchMeshSpot(meshName, owner, record);
+    await this.spotManager.dispatchMeshSpot(meshName, owner, record, admit);
   }
 
   private createDispatchErrorReporter(
@@ -3144,7 +3346,7 @@ export class ZLinkFrameworkRuntimeHost
       this.executionState === undefined
         ? (this.options.registration.dispatch?.diagnostics.messageFlow ?? 'errors')
         : this.messageFlowModeCell.mode;
-    return mode !== 'off';
+    return messageFlowTracingEnabled(mode);
   }
 
   private runLifecycle<T>(operation: () => T): T {
@@ -3272,7 +3474,7 @@ export function hasExactPeerReadiness(
   const replacementDescriptors = descriptors.filter(
     (descriptor) =>
       !(
-        String(descriptor.rid) === String(local.routingId) &&
+        routingIdsEqual(descriptor.rid, toBackendRoutingId(local.routingId)) &&
         descriptor.lifecycleGeneration === local.lifecycleGeneration
       ) &&
       descriptor.state === ZLinkFrameworkRuntimeState.Serving &&
@@ -3287,7 +3489,7 @@ export function hasExactPeerReadiness(
       peers.some(
         (peer) =>
           peer.routingId !== null &&
-          String(peer.routingId) === String(descriptor.rid) &&
+          routingIdsEqual(toBackendRoutingId(peer.routingId), descriptor.rid) &&
           peer.lifecycleGeneration === descriptor.lifecycleGeneration &&
           peer.state === MeshPeerRuntimeState.Serving
       )
@@ -3499,7 +3701,7 @@ function isPlacementTargetReady(
   if (node === undefined) return true;
   if (
     localStatus !== undefined &&
-    String(localStatus.routingId) === String(descriptor.rid) &&
+    routingIdsEqual(localStatus.routingId, descriptor.rid) &&
     localStatus.lifecycleGeneration === descriptor.lifecycleGeneration
   ) {
     return true;