@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/host/index.js

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkUserSpotCreationCoordinator = exports.ZLinkHostSpotAddressTransport = exports.ZLinkRelocationStateIncompatibleError = exports.ZLinkRouteMeshRuntimeCoordinator = exports.ZLinkRetiringRollbackError = exports.ZLinkDrainingStatePublishError = exports.transferIdString = exports.ZLinkActorTransferAuthorityRuntime = exports.ZLinkFrameworkRuntimeHost = void 0;
 exports.hasUnsupportedManualTopology = hasUnsupportedManualTopology;
 exports.hasExactPeerReadiness = hasExactPeerReadiness;
+const relocation_blob_1 = require("../locations/relocation-blob");
 const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
 const location_store_pages_1 = require("../locations/location-store-pages");
+const descriptor_publication_1 = require("../locations/descriptor-publication");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
 const contracts_1 = require("../../contracts");
 const ConfigurationException_1 = require("../../contracts/Configuration/ConfigurationException");
 const DiagnosticsValidation_1 = require("../../contracts/Configuration/DiagnosticsValidation");
@@ -19,6 +22,7 @@ const abort_1 = require("../abort");
 const activation_admission_1 = require("../activation-admission");
 const actors_1 = require("../actors");
 const actor_message_follow_context_1 = require("../actors/actor-message-follow-context");
+const actor_packet_relay_wire_1 = require("../actors/actor-packet-relay-wire");
 const actor_transport_delivery_gate_1 = require("../actors/actor-transport-delivery-gate");
 const admission_1 = require("../admission");
 const application_job_queue_handler_start_gate_1 = require("../application-jobs/application-job-queue-handler-start-gate");
@@ -68,6 +72,8 @@ const spot_node_runtime_options_factory_1 = require("./spot-node-runtime-options
 const spot_runtime_options_factory_1 = require("./spot-runtime-options-factory");
 const stateful_authority_route_runtime_1 = require("./stateful-authority-route-runtime");
 const user_spot_creation_coordinator_1 = require("./user-spot-creation-coordinator");
+const spot_remote_route_codec_1 = require("../spots/spot-remote-route-codec");
+const protocol_1 = require("../streams/protocol");
 const HOST_SHUTDOWN_POLL_INTERVAL_MS = 100;
 const HANDOFF_ACCEPTANCE_POLL_INTERVAL_MS = 10;
 const DEFAULT_HOST_CONTROL_TIMEOUT_MS = 30_000;
@@ -77,7 +83,7 @@ class ZLinkFrameworkRuntimeHost {
     lifecycleSink;
     executionState;
     runtimeState = contracts_1.ZLinkFrameworkRuntimeState.Preparing;
-    runtimeSequence = 0n;
+    runtimeStatus;
     runtimeObservationSource = Symbol('zlink.framework-runtime');
     runtimeDeadline;
     shutdownDeadline;
@@ -145,6 +151,7 @@ class ZLinkFrameworkRuntimeHost {
     routeMeshRuntime;
     clientServerRuntime;
     fanoutRuntime;
+    relocationStore;
     routeMeshCoordinator;
     constructor(options, internalOptions) {
         this.options = options;
@@ -153,16 +160,13 @@ class ZLinkFrameworkRuntimeHost {
         this.runtimeEventPublisher =
             options.runtimeEventPublisher ?? new diagnostics_1.DefaultZLinkRuntimeEventPublisher();
         this.metrics = new diagnostics_1.ZLinkRuntimeMetrics(options.registration.metrics?.meterProvider);
-        this.applicationJobQueue = new application_job_queue_1.ApplicationJobQueue((0, application_job_queue_1.resolveApplicationJobQueueConfiguration)(options.registration.applicationJobQueue, () => (0, application_job_queue_1.nodeEffectiveProcessorCount)(options.registration.worker?.maxThreads)), undefined, () => {
-            try {
-                return (this.options.providerResolver
-                    ?.get?.(application_job_queue_handler_start_gate_1.ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE)
-                    ?.shouldHoldPermitBeforeHandler() === true);
-            }
-            catch {
-                return false;
-            }
-        }, (error) => (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException('logger-provider', error));
+        const relocationProvider = options.registration.locations.relocationStoreInstance;
+        this.relocationStore =
+            relocationProvider === undefined
+                ? undefined
+                : new relocation_blob_1.ZLinkProviderRelocationRepository(relocationProvider, this.metrics);
+        const handlerStartGate = options.providerResolver?.get?.(application_job_queue_handler_start_gate_1.ZLINK_INTERNAL_APPLICATION_JOB_QUEUE_HANDLER_START_GATE);
+        this.applicationJobQueue = new application_job_queue_1.ApplicationJobQueue((0, application_job_queue_1.resolveApplicationJobQueueConfiguration)(options.registration.applicationJobQueue, () => (0, application_job_queue_1.nodeEffectiveProcessorCount)(options.registration.worker?.maxThreads)), undefined, handlerStartGate?.shouldHoldPermitBeforeHandler.bind(handlerStartGate), (error) => (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException('logger-provider', error));
         this.capacityStatus = new host_capacity_status_1.HostCapacityStatusProjection(options.registration.coreHwm, this.applicationJobQueue);
         this.clientServerRuntime = new topology_runtime_projections_1.ZLinkClientServerRuntimeProjection(() => this.channelRuntime, () => this.runtimeState);
         this.fanoutRuntime = new topology_runtime_projections_1.ZLinkFanoutRuntimeProjection(() => this.channelRuntime, () => this.runtimeState);
@@ -221,7 +225,7 @@ class ZLinkFrameworkRuntimeHost {
                     : this.boundSessionRelay.actorPackets.confirmRemoteSessionBinding(actor, sessionNode.status().routingId, sessionRid, signal, options);
             },
             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 actors_1.ZLinkActorHandoffCoordinator({
             routedTransport: this.routeTransport,
@@ -437,20 +441,11 @@ class ZLinkFrameworkRuntimeHost {
             actorManager: () => this.actorManager,
             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),
             prepareApplicationJob: async (preparationSignal, origin) => {
@@ -502,13 +497,15 @@ class ZLinkFrameworkRuntimeHost {
                 };
             },
             reportPostCommitError: (error) => (this.errorSink ?? this.preStartErrorSink).reportRuntimeTaskException('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 service_relocation_host_runtime_1.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,
@@ -518,11 +515,10 @@ 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) => this.boundSessionRelay.boundSessions.receiveServiceWireSessionRelocationSeal(value, signal),
+                receiveSeal: (value, signal, onInstalled) => this.boundSessionRelay.boundSessions.receiveServiceWireSessionRelocationSeal(value, signal, onInstalled),
                 receiveRoute: (value) => this.boundSessionRelay.boundSessions.receiveServiceWireSessionRelocationRoute(value),
                 clear: () => this.boundSessionRelay.boundSessions.clearServiceWireSessionRelocations()
             },
@@ -573,7 +569,7 @@ class ZLinkFrameworkRuntimeHost {
             drainResources: (meshName, signal, stopStartingSignal) => 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)), this.metrics.registerHostCapacity(() => this.capacityStatus.snapshot(this.context?.getCoreHwmBudgetSnapshot())), this.metrics.registerApplicationJobQueuePressure(() => this.applicationJobQueue.snapshot()), this.metrics.registerMeshSnapshots(() => this.runtimeMetricMeshSnapshots()));
         this.routeMeshRuntime = this.routeMeshCoordinator;
@@ -582,6 +578,9 @@ class ZLinkFrameworkRuntimeHost {
         return this.executionState !== undefined && !this.executionState.abortController.signal.aborted;
     }
     get status() {
+        return this.publishCurrentRuntimeStatus();
+    }
+    buildRuntimeStatus() {
         return {
             state: this.runtimeState,
             isReady: (0, runtime_state_projections_1.runtimeStateIsReady)(this.runtimeState),
@@ -591,8 +590,8 @@ 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()
         };
     }
     // Bound listener records of the current runtime generation.
@@ -605,10 +604,11 @@ class ZLinkFrameworkRuntimeHost {
         return { kind, name, endpoint, observedAt: new Date() };
     }
     observe(signal) {
+        const status = this.status;
         const queue = new runtime_observation_queue_1.RuntimeEventQueue(undefined, signal);
         this.runtimeObservers.add(queue);
         queue.onClose(() => this.runtimeObservers.delete(queue));
-        this.publishRuntimeStatus(queue, this.status);
+        this.publishRuntimeStatus(queue, status);
         return queue;
     }
     resetCapacityMetrics() {
@@ -771,6 +771,9 @@ class ZLinkFrameworkRuntimeHost {
                 const shutdown = this.routeMeshCoordinator.shutdownHost(this.runtimeDeadline, this.shutdownDeadline.signal);
                 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({
@@ -892,12 +895,24 @@ class ZLinkFrameworkRuntimeHost {
         if (this.runtimeState === state)
             return;
         this.runtimeState = state;
-        this.runtimeSequence += 1n;
         this.notifyTopologyHostStateChanged();
-        const status = this.status;
+        this.publishCurrentRuntimeStatus();
+    }
+    publishCurrentRuntimeStatus() {
+        const current = this.buildRuntimeStatus();
+        if (this.runtimeStatus !== undefined && (0, node_util_1.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;
     }
     publishRuntimeStatus(observer, status) {
         if ((0, runtime_state_projections_1.runtimeObservationIsTerminal)(status.state)) {
@@ -1003,7 +1018,6 @@ class ZLinkFrameworkRuntimeHost {
         let spotNodeRuntime;
         let streamRuntime;
         let startedLocationRuntime;
-        let statefulAuthorityRoutes;
         try {
             this.executionState = new execution_1.ZLinkFrameworkExecutionState(context);
             // Seed the shared live-mode cell from the configured mode (default errorsOnly).
@@ -1026,18 +1040,13 @@ class ZLinkFrameworkRuntimeHost {
             this.executionState.listenerTasks.push(...channelRuntime.start(this.executionState.taskRunner));
             const locationRuntime = await this.locationOwner.startForRuntime(this.meshRouters.primaryMeshName(), spotNodeRuntime, channelRuntime, this.executionState.abortController.signal, () => 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(contracts_1.ZLinkFrameworkRuntimeState.Preparing, this.executionState.abortController.signal);
-                if (this.requiresStatefulAuthorityRuntime()) {
-                    this.installLocationBackedAuthorities(locationStore, spotNodeRuntime);
-                    statefulAuthorityRoutes = this.createStatefulAuthorityRoutes(locationStore, spotNodeRuntime);
-                    await statefulAuthorityRoutes.start(this.executionState.abortController.signal);
-                    this.statefulAuthorityRoutes = statefulAuthorityRoutes;
-                }
+                await this.publishOrStayPreparing(locationRuntime, async (publishSignal) => {
+                    await spotNodeRuntime.startLocationAutoConnect(publishSignal);
+                    await channelRuntime.startLocationAutoConnect(publishSignal);
+                    await spotNodeRuntime.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Preparing, publishSignal);
+                });
             }
             streamRuntime = new streams_1.ZLinkStreamRuntimeManager({
                 listenerRecords,
@@ -1058,17 +1067,20 @@ 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(contracts_1.ZLinkFrameworkRuntimeState.Serving, this.executionState.abortController.signal);
+                await this.publishOrStayPreparing(locationRuntime, (publishSignal) => this.enterServing(spotNodeRuntime, publishSignal));
+            }
+            if (locationRuntime !== undefined) {
+                this.installOwnerLeaseRecoveryPublication(locationRuntime, spotNodeRuntime, channelRuntime);
             }
-            this.routeMeshCoordinator.markServing();
-            this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Serving);
             this.lifecycleSink?.push('framework:started');
         }
         catch (error) {
             if (this.shutdownDeadline !== undefined && (0, abort_1.isAbortError)(error))
                 throw error;
-            await statefulAuthorityRoutes?.stop();
+            await this.statefulAuthorityRoutes?.stop();
             try {
                 await this.runWithShutdownDeadline(DEFAULT_HOST_CONTROL_TIMEOUT_MS, async () => (0, runtime_shutdown_1.rollbackRuntimeStart)({
                     context,
@@ -1114,7 +1126,9 @@ class ZLinkFrameworkRuntimeHost {
                 (options.pubSub?.manualConnections?.length ?? 0) > 0;
             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,
@@ -1126,9 +1140,9 @@ 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,
@@ -1180,12 +1194,21 @@ class ZLinkFrameworkRuntimeHost {
         }
     }
     installOwnerLeaseRecoveryPublication(runtime, spotNodeRuntime, channelRuntime) {
-        const handler = () => {
+        let recoveryOperation;
+        const handler = (_renewal, wasOwnerLeaseUsable) => {
             if (!this.ownerAdmissionOpen())
                 return;
-            void this.resumeOwnerLeaseOwnedWork(runtime, spotNodeRuntime, channelRuntime).catch((error) => {
+            if (wasOwnerLeaseUsable && this.runtimeState !== contracts_1.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;
@@ -1195,30 +1218,64 @@ class ZLinkFrameworkRuntimeHost {
     async resumeOwnerLeaseOwnedWork(runtime, spotNodeRuntime, channelRuntime) {
         if (!this.ownerAdmissionOpen())
             return;
-        const signal = this.executionState?.abortController.signal;
-        await spotNodeRuntime.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Preparing, signal);
+        await this.publishOrStayPreparing(runtime, async (signal) => {
+            await spotNodeRuntime.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Preparing, signal);
+            if (runtime.ownerLeaseUsable === false)
+                return;
+            if (this.runtimeState !== contracts_1.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 === contracts_1.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.
+    async enterServing(spotNodeRuntime, signal) {
         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 (runtime.ownerLeaseUsable === false)
+        if (store !== undefined) {
+            await this.startStatefulAuthority(store, spotNodeRuntime, signal);
+        }
+        await spotNodeRuntime.publishMeshNodeState(contracts_1.ZLinkFrameworkRuntimeState.Serving, signal);
+        this.routeMeshCoordinator.markServing();
+        this.setRuntimeState(contracts_1.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.
+    async publishOrStayPreparing(runtime, publish) {
+        const signal = this.executionState?.abortController.signal;
+        try {
+            await publish(signal);
+            return true;
+        }
+        catch (error) {
+            if (runtime === undefined || !(error instanceof descriptor_publication_1.ZLinkDescriptorPublicationUnconfirmedError))
+                throw error;
+            this.runtimeOrPreStartErrorSink.reportRuntimeTaskException('startup descriptor publication', error);
+            return false;
+        }
+    }
+    async startStatefulAuthority(locationStore, spotNodeRuntime, signal) {
+        if (this.statefulAuthorityRoutes !== undefined || !this.requiresStatefulAuthorityRuntime()) {
             return;
-        await spotNodeRuntime.publishMeshNodeState(this.runtimeState, signal);
-        await spotNodeRuntime.startLocationAutoConnect(signal);
-        await channelRuntime.startLocationAutoConnect(signal);
-        await channelRuntime.reclaimLocationOwnerRows(signal);
-        await this.locationOwner.currentLifecycle?.reclaimOwnerRows();
+        }
+        this.installLocationBackedAuthorities(locationStore, spotNodeRuntime);
+        const routes = this.createStatefulAuthorityRoutes(locationStore, spotNodeRuntime);
+        await routes.start(signal);
+        this.statefulAuthorityRoutes = routes;
     }
     createStatefulAuthorityRoutes(locationStore, spotNodeRuntime) {
         return new stateful_authority_route_runtime_1.ZLinkStatefulAuthorityRouteRuntime({
             store: locationStore,
             creationStore: locationStore,
-            relocationStore: this.options.registration.locations.relocationStoreInstance,
+            relocationStore: this.relocationStore,
             meshNodes: spotNodeRuntime.meshNodesByName,
             pollingIntervalMs: this.options.registration.locations.options.pollingIntervalMs ??
                 Locations_1.zlinkDefaultLocationOptions.pollingIntervalMs,
@@ -1247,7 +1304,7 @@ class ZLinkFrameworkRuntimeHost {
             activationNode.registerAsyncInstanceActivationAuthority?.(new instance_activation_authority_1.ZLinkInstanceActivationAuthority({
                 store: locationStore,
                 relocationPolicy: (stableType) => 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,
@@ -1295,7 +1352,16 @@ class ZLinkFrameworkRuntimeHost {
     async performMeshDrain(meshName, signal, stopStartingSignal) {
         await this.serviceRelocation.relocateMesh(meshName, this.relocationTargetApplicationVersion, signal, stopStartingSignal);
     }
-    async performMeshShutdown(meshName, signal) {
+    async performMeshShutdown(meshName, signal, forceReason) {
+        if (forceReason !== undefined) {
+            this.spotNodeRuntime
+                ?.meshNode(meshName)
+                ?.cancelPendingOperations?.((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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);
     }
@@ -1406,10 +1472,6 @@ class ZLinkFrameworkRuntimeHost {
             throw new locations_1.ZLinkOwnerCleanupError(error);
         }
     }
-    async forceStopMesh(meshName) {
-        await waitForForcedSessionNotification(this.streamRuntime?.notifyServerDrain(meshName));
-        await this.spotManager?.drainForShutdown(meshName, undefined, this.runtimeDeadline);
-    }
     registerInstanceApplicationLifecycle(meshName, node, spotManager) {
         const activationNode = node;
         activationNode.registerInstanceApplicationLifecycle?.({
@@ -1417,7 +1479,8 @@ class ZLinkFrameworkRuntimeHost {
             isMaterializing: (target) => spotManager.isInstanceMaterializing(meshName, target.targetSpotId),
             isIdleEvicting: (target) => spotManager.isInstanceSpotIdleEvicting(meshName, target.targetSpotId),
             beginIdleEviction: (target) => spotManager.beginInstanceSpotIdleEviction(meshName, target.targetSpotId),
-            materialize: (target, objectGeneration) => spotManager.materializeInstance(meshName, target.stableType, target.targetSpotId, objectGeneration, this.executionState?.abortController.signal),
+            materialize: (target, objectGeneration) => spotManager.materializeInstance(meshName, target.stableType, target.targetSpotId, objectGeneration, this.executionState?.abortController.signal, 'first-terminal'),
+            publish: (target) => spotManager.publishInstance(target, meshName),
             discard: (target) => spotManager.discardInstance(meshName, target.targetSpotId),
             beginTerminal: (target) => spotManager.beginInstanceTerminal(meshName, target.targetSpotId, target.objectGeneration),
             completeTerminal: (target) => spotManager.completeInstanceTerminal(meshName, target.targetSpotId, target.objectGeneration)
@@ -1554,8 +1617,8 @@ class ZLinkFrameworkRuntimeHost {
                         descriptor.objectRole === 'server' &&
                         descriptor.placementWeight > 0 &&
                         descriptor.entrySpotId !== undefined &&
-                        excludedNodeRids?.has(String(descriptor.rid)) !== true &&
-                        capability !== undefined);
+                        excludedNodeRids?.has((0, routing_id_1.encodeRoutingIdStorageHex)(descriptor.rid)) !== true &&
+                        capability?.entryAccepted === true);
                 });
                 if (selected === undefined)
                     return undefined;
@@ -1574,7 +1637,7 @@ class ZLinkFrameworkRuntimeHost {
                         ownerId: selected.ownerId,
                         leaseGeneration: selected.leaseGeneration
                     },
-                    isLocal: String(localStatus.routingId) === String(selected.rid) &&
+                    isLocal: (0, routing_id_1.routingIdsEqual)(localStatus.routingId, selected.rid) &&
                         localStatus.lifecycleGeneration === selected.lifecycleGeneration
                 };
             }
@@ -1636,7 +1699,7 @@ class ZLinkFrameworkRuntimeHost {
                     return (descriptor.state === 1 &&
                         descriptor.objectRole === 'server' &&
                         descriptor.placementWeight > 0 &&
-                        excludedNodeRids?.has(String(descriptor.rid)) !== true &&
+                        excludedNodeRids?.has((0, routing_id_1.encodeRoutingIdStorageHex)(descriptor.rid)) !== true &&
                         (spots.limit === 0 || spots.active + spots.reserved < spots.limit) &&
                         capability !== undefined &&
                         (spotTypeCapacity === undefined ||
@@ -1655,7 +1718,7 @@ class ZLinkFrameworkRuntimeHost {
                         leaseGeneration: selected.leaseGeneration
                     },
                     isLocal: localStatus !== undefined &&
-                        String(localStatus.routingId) === String(selected.rid) &&
+                        (0, routing_id_1.routingIdsEqual)(localStatus.routingId, selected.rid) &&
                         localStatus.lifecycleGeneration === selected.lifecycleGeneration
                 };
             }
@@ -1737,6 +1800,13 @@ class ZLinkFrameworkRuntimeHost {
                             throw new ConfigurationException_1.ZLinkConfigurationException('Actor placement target runtime is not initialized.');
                         }
                         return await actorPlacement.handleRemoteCreate(record, async (requestPayload, authority, createSignal) => {
+                            const registration = this.options.registration.spotNodes.get(meshName);
+                            if (registration === undefined ||
+                                !(0, spots_1.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 (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `RouteMesh '${meshName}' registers no Entry Spot type that accepts Actor type '${record.stableType}'.`);
+                            }
                             const request = (0, creation_payload_codec_1.decodeFrameworkCreationPayload)(requestPayload, this.options.registration.messageSerializers);
                             const entrySpotId = this.spotNodeRuntime?.meshNodeDescriptor(meshName)?.entrySpotId;
                             if (entrySpotId === undefined) {
@@ -1768,7 +1838,7 @@ class ZLinkFrameworkRuntimeHost {
                                 };
                             }
                             if (local.actorRef.objectGeneration !== authority.objectGeneration ||
-                                String(local.actorRef.nodeRid) !== record.reservation.targetNodeRid) {
+                                !(0, routing_id_1.routingIdsEqual)(local.actorRef.nodeRid, record.reservation.targetNodeRid)) {
                                 throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorCreateFailed, `Actor '${record.actorId}' native authority does not match its placement reservation.`);
                             }
                             let reply;
@@ -1821,7 +1891,7 @@ class ZLinkFrameworkRuntimeHost {
             },
             isLocalNode: (meshName, nodeRid) => {
                 const status = this.spotNodeRuntime?.meshNode(meshName)?.status();
-                return status !== undefined && String(status.routingId) === String(nodeRid);
+                return status !== undefined && (0, routing_id_1.routingIdsEqual)(status.routingId, nodeRid);
             },
             remoteClose: (meshName, targetNodeRid, request, timeoutMs) => {
                 const node = this.spotNodeRuntime?.meshNode(meshName);
@@ -1969,92 +2039,45 @@ class ZLinkFrameworkRuntimeHost {
             activationConcurrency: (meshName) => this.activationAdmission.current(meshName)
         };
     }
-    async dispatchMeshRecord(applicationJobOrigin, meshName, owner, record, signal) {
+    dispatchMeshNodeRecord(meshName, record, signal, admit) {
+        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);
+    }
+    dispatchMeshNodePayload(meshName, record, signal, admit) {
+        if (record.kind === service_runtime_contracts_1.ReceiveKind.NodeRequest && record.parts.length === 1) {
+            const terminal = (0, actors_1.decodeRemoteActorSourceLeaveTerminal)(record.parts[0].data());
+            if (terminal !== undefined) {
+                return this.completeFormalSourceLeave(record, terminal);
+            }
+        }
+        const channelRuntime = this.channelRuntime;
+        if (channelRuntime === undefined) {
+            throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode node-direct dispatch requires the channel runtime.');
+        }
+        return channelRuntime.dispatchMeshRoute(meshName, record, signal, admit);
+    }
+    async completeFormalSourceLeave(record, terminal) {
+        const completed = await this.spotManager?.completeFormalSourceLeaveTerminal(terminal.actorId, terminal.transferId, terminal.succeeded);
+        if (completed !== true) {
+            throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${terminal.actorId}' has no matching formal transfer terminal gate.`);
+        }
+        if (record.reply(Buffer.alloc(0)) !== runtime_values_1.SubmitResult.Ok) {
+            throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${terminal.actorId}' formal transfer terminal acknowledgement failed.`);
+        }
+        return;
+    }
+    dispatchMeshRecord(applicationJobOrigin, meshName, owner, record, signal) {
         if (record.operationKind === service_runtime_contracts_1.OperationKind.ActorJoin) {
             if (this.spotManager === undefined) {
                 throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Actor join dispatch requires the Spot manager.');
             }
             return this.spotManager.dispatchMeshActorJoin(meshName, owner, record);
         }
-        if (record.kind === service_runtime_contracts_1.ReceiveKind.ActorBinding) {
-            if (record.kindData?.kind !== 'actorBinding') {
-                throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Actor binding record has no binding generation.');
-            }
-            const binding = record.kindData;
-            const replyBindingFailure = (kind) => {
-                const terminal = (0, framework_errors_internal_1.internalFrameworkWireReply)(kind);
-                if (record.replyFailure?.(terminal.terminalResult, terminal.failureCode) !== runtime_values_1.SubmitResult.Ok) {
-                    throw new ConfigurationException_1.ZLinkConfigurationException(`MeshNode Actor binding target '${binding.actor.actorId}' failure acknowledgement failed.`);
-                }
-            };
-            const replyBindingSuccess = () => {
-                if (record.reply(Buffer.alloc(0)) !== runtime_values_1.SubmitResult.Ok) {
-                    throw new ConfigurationException_1.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 ||
-                !(0, routing_id_1.routingIdsEqual)(nativeActorRef.nodeRid, binding.actor.nodeRid)) {
-                replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-                return;
-            }
-            if (nativeActorRef.generation !== binding.actor.generation) {
-                replyBindingFailure(framework_errors_internal_1.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 ||
-                !(0, routing_id_1.routingIdsEqual)(localStatus.routingId, binding.actor.nodeRid) ||
-                localStatus.lifecycleGeneration !== binding.actorNodeGeneration ||
-                state.locationGeneration !== binding.authorityOwnerGeneration ||
-                state.isMoving) {
-                replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-                return;
-            }
-            const sessionOwnerIsLocal = (0, routing_id_1.routingIdsEqual)(localStatus.routingId, binding.sessionNodeRid) &&
-                localStatus.lifecycleGeneration === binding.sessionOwnerNodeGeneration;
-            if (binding.transition === 'tombstone') {
-                const actorRef = {
-                    actorId: binding.actor.actorId,
-                    objectGeneration: binding.actor.generation,
-                    meshName,
-                    nodeRid: binding.actor.nodeRid
-                };
-                if (sessionOwnerIsLocal) {
-                    (0, application_job_queue_scope_2.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(framework_errors_internal_1.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(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale);
-                return;
-            }
-            replyBindingSuccess();
-            return Promise.resolve();
-        }
+        if (record.kind === service_runtime_contracts_1.ReceiveKind.ActorBinding)
+            return this.dispatchMeshActorBinding(meshName, record, signal);
         switch (record.kind) {
             case service_runtime_contracts_1.ReceiveKind.TransferControl:
                 if (record.kindData?.kind !== 'transferControl') {
@@ -2067,42 +2090,21 @@ class ZLinkFrameworkRuntimeHost {
                 if (channelRuntime === undefined) {
                     throw new ConfigurationException_1.ZLinkConfigurationException('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 service_runtime_contracts_1.ReceiveKind.NodeSend:
             case service_runtime_contracts_1.ReceiveKind.NodeRequest: {
-                return this.admission.run(meshName, 'RouteMesh node dispatch', async () => {
-                    if (await this.serviceRelocation.tryHandleControl(meshName, record, signal)) {
-                        return;
-                    }
-                    if (record.kind === service_runtime_contracts_1.ReceiveKind.NodeRequest && record.parts.length === 1) {
-                        const terminal = (0, actors_1.decodeRemoteActorSourceLeaveTerminal)(record.parts[0].data());
-                        if (terminal !== undefined) {
-                            if ((await this.spotManager?.completeFormalSourceLeaveTerminal(terminal.actorId, terminal.transferId, terminal.succeeded)) !== true) {
-                                throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${terminal.actorId}' has no matching formal transfer terminal gate.`);
-                            }
-                            if (record.reply(Buffer.alloc(0)) !== runtime_values_1.SubmitResult.Ok) {
-                                throw new ConfigurationException_1.ZLinkConfigurationException(`Actor '${terminal.actorId}' formal transfer terminal acknowledgement failed.`);
-                            }
-                            return;
-                        }
-                    }
-                    const channelRuntime = this.channelRuntime;
-                    if (channelRuntime === undefined) {
-                        throw new ConfigurationException_1.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 service_runtime_contracts_1.ReceiveKind.SpotSend:
             case service_runtime_contracts_1.ReceiveKind.SpotRequest:
             case service_runtime_contracts_1.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 service_runtime_contracts_1.ReceiveKind.InstanceSpotActivation:
                 if (this.spotManager === undefined) {
                     throw new ConfigurationException_1.ZLinkConfigurationException('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 service_runtime_contracts_1.ReceiveKind.SpotControl:
                 if (this.spotManager === undefined) {
                     throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Spot control dispatch requires the Spot manager.');
@@ -2113,13 +2115,107 @@ class ZLinkFrameworkRuntimeHost {
                 if (this.spotManager === undefined) {
                     throw new ConfigurationException_1.ZLinkConfigurationException('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 service_runtime_contracts_1.ReceiveKind.SendReady:
                 return Promise.resolve();
             default:
                 throw new ConfigurationException_1.ZLinkConfigurationException(`MeshNode record kind '${record.kind}' does not yet have a registered framework consumer.`);
         }
     }
+    admitMeshDispatch(meshName, record, operation, dispatch, onRejected) {
+        // 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 === service_runtime_contracts_1.ReadyDomain.Infrastructure)
+            return dispatch();
+        if (!this.admission.accepts(meshName) &&
+            (record.kind === service_runtime_contracts_1.ReceiveKind.NodeSend ||
+                record.kind === service_runtime_contracts_1.ReceiveKind.NodeRequest ||
+                record.kind === service_runtime_contracts_1.ReceiveKind.SpotSend ||
+                record.kind === service_runtime_contracts_1.ReceiveKind.SpotRequest)) {
+            const relay = (0, spot_remote_route_codec_1.decodeRemoteActorPacketRelay)(record.parts, { serializers: this.options.registration.messageSerializers }, this.flowCreationEnabled());
+            if (relay !== undefined &&
+                (0, protocol_1.decodeStreamHeader)(Buffer.from(relay.header, 'base64'), this.flowCreationEnabled()).name ===
+                    actor_packet_relay_wire_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
+                return dispatch();
+            }
+        }
+        return this.admission.run(meshName, operation, dispatch, onRejected);
+    }
+    async dispatchMeshActorBinding(meshName, record, signal) {
+        if (record.kindData?.kind !== 'actorBinding') {
+            throw new ConfigurationException_1.ZLinkConfigurationException('MeshNode Actor binding record has no binding generation.');
+        }
+        const binding = record.kindData;
+        const replyBindingFailure = (kind) => {
+            const terminal = (0, framework_errors_internal_1.internalFrameworkWireReply)(kind);
+            if (record.replyFailure?.(terminal.terminalResult, terminal.failureCode) !== runtime_values_1.SubmitResult.Ok) {
+                throw new ConfigurationException_1.ZLinkConfigurationException(`MeshNode Actor binding target '${binding.actor.actorId}' failure acknowledgement failed.`);
+            }
+        };
+        const replyBindingSuccess = () => {
+            if (record.reply(Buffer.alloc(0)) !== runtime_values_1.SubmitResult.Ok) {
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.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 ||
+            !(0, routing_id_1.routingIdsEqual)(nativeActorRef.nodeRid, binding.actor.nodeRid)) {
+            replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+            return;
+        }
+        if (nativeActorRef.generation !== binding.actor.generation) {
+            replyBindingFailure(framework_errors_internal_1.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 ||
+            !(0, routing_id_1.routingIdsEqual)(localStatus.routingId, binding.actor.nodeRid) ||
+            localStatus.lifecycleGeneration !== binding.actorNodeGeneration ||
+            state.locationGeneration !== binding.authorityOwnerGeneration ||
+            state.isMoving) {
+            replyBindingFailure(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorLocationStale);
+            return;
+        }
+        const sessionOwnerIsLocal = (0, routing_id_1.routingIdsEqual)(localStatus.routingId, binding.sessionNodeRid) &&
+            localStatus.lifecycleGeneration === binding.sessionOwnerNodeGeneration;
+        if (binding.transition === 'tombstone') {
+            const actorRef = {
+                actorId: binding.actor.actorId,
+                objectGeneration: binding.actor.generation,
+                meshName,
+                nodeRid: binding.actor.nodeRid
+            };
+            if (sessionOwnerIsLocal) {
+                (0, application_job_queue_scope_2.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(framework_errors_internal_1.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();
+    }
     submitLocalMeshRoute(meshName, sourceNodeRid, parts) {
         const state = this.executionState;
         const channelRuntime = this.channelRuntime;
@@ -2166,7 +2262,7 @@ class ZLinkFrameworkRuntimeHost {
         }
         return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
     }
-    async dispatchMeshSpotRecord(meshName, owner, record) {
+    async dispatchMeshSpotRecord(meshName, owner, record, admit) {
         const envelope = (0, channel_envelope_1.decodeChannelEnvelope)(record.parts, undefined, this.flowCreationEnabled());
         if (envelope.packetName === actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET) {
             const payload = (0, channel_envelope_1.decodeChannelPayload)(envelope, {
@@ -2181,26 +2277,28 @@ class ZLinkFrameworkRuntimeHost {
                 correlationId: envelope.header.correlationId ?? undefined
             };
             try {
-                const response = await this.boundSessionRelay.actorPackets.receiveRemoteActorPacketRelay(payload, context);
-                if (record.kind === service_runtime_contracts_1.ReceiveKind.SpotRequest) {
-                    record.reply((0, channel_envelope_1.encodeChannelReplyParts)(envelope.header, response));
-                }
+                const dispatch = async () => {
+                    const response = await this.boundSessionRelay.actorPackets.receiveRemoteActorPacketRelay(payload, context);
+                    if (record.kind === service_runtime_contracts_1.ReceiveKind.SpotRequest)
+                        record.reply((0, channel_envelope_1.encodeChannelReplyParts)(envelope.header, response));
+                };
+                await (admit === undefined ? dispatch() : admit(dispatch));
             }
             catch (error) {
                 if (record.kind !== service_runtime_contracts_1.ReceiveKind.SpotRequest) {
                     throw error;
                 }
-                record.reply((0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error instanceof Error ? error.message : String(error)));
+                record.reply((0, channel_envelope_1.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 ConfigurationException_1.ZLinkConfigurationException('MeshNode Spot dispatch requires the Spot manager.');
         }
-        await this.spotManager.dispatchMeshSpot(meshName, owner, record);
+        await this.spotManager.dispatchMeshSpot(meshName, owner, record, admit);
     }
     createDispatchErrorReporter(errorSink) {
         const existing = this.dispatchErrorReporters.get(errorSink);
@@ -2231,7 +2329,7 @@ class ZLinkFrameworkRuntimeHost {
         const mode = this.executionState === undefined
             ? (this.options.registration.dispatch?.diagnostics.messageFlow ?? 'errors')
             : this.messageFlowModeCell.mode;
-        return mode !== 'off';
+        return (0, diagnostics_1.messageFlowTracingEnabled)(mode);
     }
     runLifecycle(operation) {
         const current = (0, diagnostics_1.currentOrCreateFlow)('Lifecycle', false);
@@ -2300,7 +2398,7 @@ function hasConfiguredLocationStore(registration) {
     return (registration.locations.useInMemoryStores || registration.locations.storeInstance !== undefined);
 }
 function hasExactPeerReadiness(descriptors, local, peers) {
-    const replacementDescriptors = descriptors.filter((descriptor) => !(String(descriptor.rid) === String(local.routingId) &&
+    const replacementDescriptors = descriptors.filter((descriptor) => !((0, routing_id_1.routingIdsEqual)(descriptor.rid, (0, routing_id_1.toBackendRoutingId)(local.routingId)) &&
         descriptor.lifecycleGeneration === local.lifecycleGeneration) &&
         descriptor.state === contracts_1.ZLinkFrameworkRuntimeState.Serving &&
         local.applicationVersion !== undefined &&
@@ -2309,7 +2407,7 @@ function hasExactPeerReadiness(descriptors, local, peers) {
         (local.maintenanceWave === undefined || descriptor.maintenanceWave !== local.maintenanceWave));
     return (replacementDescriptors.length > 0 &&
         replacementDescriptors.some((descriptor) => peers.some((peer) => peer.routingId !== null &&
-            String(peer.routingId) === String(descriptor.rid) &&
+            (0, routing_id_1.routingIdsEqual)((0, routing_id_1.toBackendRoutingId)(peer.routingId), descriptor.rid) &&
             peer.lifecycleGeneration === descriptor.lifecycleGeneration &&
             peer.state === service_runtime_contracts_1.MeshPeerRuntimeState.Serving)));
 }
@@ -2476,7 +2574,7 @@ function isPlacementTargetReady(node, localStatus, descriptor) {
     if (node === undefined)
         return true;
     if (localStatus !== undefined &&
-        String(localStatus.routingId) === String(descriptor.rid) &&
+        (0, routing_id_1.routingIdsEqual)(localStatus.routingId, descriptor.rid) &&
         localStatus.lifecycleGeneration === descriptor.lifecycleGeneration) {
         return true;
     }