@zlink-systems/framework 0.30.1 → 0.30.2

package/dist/runtime/host/service-relocation-host-runtime.js

@@ -5,19 +5,26 @@ exports.decodeQueuedHandoffPacket = decodeQueuedHandoffPacket;
 exports.createServiceRelocationId = createServiceRelocationId;
 exports.relocationFailedFailureCode = relocationFailedFailureCode;
 exports.encodeHandoffQueuedMessages = encodeHandoffQueuedMessages;
+const actor_reply_1 = require("../actors/actor-reply");
+const protocol_1 = require("../streams/protocol");
+const service_wire_m6a_codec_1 = require("../foundation/service-wire-m6a-codec");
+const service_wire_constants_generated_1 = require("../foundation/service-wire-constants.generated");
+const operation_registry_1 = require("../foundation/operation-registry");
 const durable_service_request_1 = require("../foundation/durable-service-request");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
 const contracts_1 = require("../../contracts");
+const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const Options_1 = require("../../contracts/Locations/Options");
 const Stores_1 = require("../../contracts/Locations/Stores");
 const actor_authority_publication_1 = require("../actors/actor-authority-publication");
-const actor_handoff_1 = require("../actors/actor-handoff");
 const actor_remote_wire_1 = require("../actors/actor-remote-wire");
 const actor_runtime_state_1 = require("../actors/actor-runtime-state");
 const runtime_values_1 = require("../backend/runtime-values");
 const diagnostics_1 = require("../diagnostics");
 const runtime_metrics_1 = require("../diagnostics/runtime-metrics");
+const message_flow_1 = require("../diagnostics/message-flow");
+const dispatch_error_details_1 = require("../diagnostics/dispatch-error-details");
 const state_lane_1 = require("../execution/state-lane");
 const actor_join_recovery_codec_1 = require("../foundation/actor-join-recovery-codec");
 const operation_identity_1 = require("../foundation/operation-identity");
@@ -29,8 +36,8 @@ const service_relocation_object_owner_1 = require("../foundation/service-relocat
 const service_relocation_runtime_1 = require("../foundation/service-relocation-runtime");
 const service_runtime_contracts_1 = require("../foundation/service-runtime-contracts");
 const service_stateful_wire_codec_1 = require("../foundation/service-stateful-wire-codec");
-const service_wire_constants_generated_1 = require("../foundation/service-wire-constants.generated");
-const service_wire_m6a_codec_1 = require("../foundation/service-wire-m6a-codec");
+const service_wire_constants_generated_2 = require("../foundation/service-wire-constants.generated");
+const service_wire_m6a_codec_2 = require("../foundation/service-wire-m6a-codec");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const authority_key_codec_1 = require("../locations/authority-key-codec");
 const location_store_failure_1 = require("../locations/location-store-failure");
@@ -66,7 +73,6 @@ class ZLinkHostServiceRelocationRuntime {
     options;
     targetStages = new Map();
     terminalTargets = new bounded_replay_map_1.BoundedReplayMap(RELOCATION_TARGET_TOMBSTONE_LIMIT);
-    relocationAuthorityKeys = new Map();
     targetPrepareOperations = new Map();
     pendingReplyRelays = new Map();
     pendingSessionRelocations = new Map();
@@ -104,6 +110,7 @@ class ZLinkHostServiceRelocationRuntime {
      * checksum integrity failure — it must not be reported as DataLost(35).
      */
     disposed = false;
+    targetPreparationStop = new AbortController();
     constructor(options) {
         this.options = options;
     }
@@ -131,6 +138,10 @@ class ZLinkHostServiceRelocationRuntime {
                     reject(failure.cause);
             };
         });
+        let acceptRelay;
+        const relayReady = new Promise((resolve) => {
+            acceptRelay = resolve;
+        });
         this.sourceActorJoinProfiles.set(input.relocationId, {
             actor: input.actor,
             state: input.state,
@@ -144,32 +155,43 @@ class ZLinkHostServiceRelocationRuntime {
                 : actor_join_recovery_codec_1.RECREATE_RELOCATION_CONTENT_TYPE,
             completionOperationId: input.completionOperationId,
             canonicalRecovery: input.canonicalRecovery,
+            relayReady: acceptRelay,
             ready,
             resolveReady
         });
         const membershipEpoch = input.state.spotMembershipEpoch > 0n ? input.state.spotMembershipEpoch : 1n;
         const spotGeneration = input.target.targetSpotGeneration ?? target.lifecycleGeneration;
-        try {
-            await this.relocateStandaloneActor(input.meshName, input.state, target, target.applicationVersion, input.signal, {
-                spotId: input.target.spotId,
-                spotKind: input.target.spotKind === contracts_1.ZLinkSpotKind.Entry
-                    ? contracts_1.ZLinkSpotKind.Entry
-                    : contracts_1.ZLinkSpotKind.User,
-                spotObjectGeneration: spotGeneration
-            }, input.relocationId, true, input.advertisedReceiveChunkLimitBytes, input.deadlineAtMs);
-            resolveReady();
-        }
-        catch (error) {
-            if (error instanceof service_relocation_coordinator_1.ServiceRelocationPostCommitError) {
-                resolveReady(error);
-                this.completeActorJoinSourceCleanup(input.state.actorId);
+        const cleanup = (async () => {
+            try {
+                await this.relocateStandaloneActor(input.meshName, input.state, target, target.applicationVersion, input.signal, {
+                    ...input.target,
+                    spotKind: input.target.spotKind === contracts_1.ZLinkSpotKind.Entry
+                        ? contracts_1.ZLinkSpotKind.Entry
+                        : contracts_1.ZLinkSpotKind.User,
+                    spotObjectGeneration: spotGeneration
+                }, input.relocationId, true, input.advertisedReceiveChunkLimitBytes, input.deadlineAtMs);
+                resolveReady();
             }
-            else {
-                this.sourceActorJoinProfiles.delete(input.relocationId);
-                throw error;
+            catch (error) {
+                if (error instanceof service_relocation_coordinator_1.ServiceRelocationPostCommitError) {
+                    resolveReady(error);
+                    this.completeActorJoinSourceCleanup(input.state.actorId);
+                }
+                else {
+                    this.sourceActorJoinProfiles.delete(input.relocationId);
+                    resolveReady();
+                    throw error;
+                }
             }
-        }
+        })();
+        const settledCleanup = Promise.allSettled([cleanup]);
+        await Promise.race([relayReady, cleanup]);
         return {
+            sourceCleanup: async () => {
+                const [outcome] = await settledCleanup;
+                if (outcome.status === 'rejected')
+                    throw outcome.reason;
+            },
             actorRef: {
                 actorId: sourceRef.actorId,
                 generation: sourceRef.generation,
@@ -204,8 +226,7 @@ class ZLinkHostServiceRelocationRuntime {
         this.sourceCutoverWindows.clear();
         if (hadSourceWindows)
             this.options.sourceQuiescenceChanged?.();
-        const stopped = new Error('Relocation runtime stopped.');
-        stopped.name = 'AbortError';
+        const stopped = new ServiceRelocationRuntimeStoppedError();
         this.targetPrepareOperations.clear();
         for (const pending of this.pendingReplyRelays.values()) {
             if (pending.timer !== undefined)
@@ -223,10 +244,9 @@ class ZLinkHostServiceRelocationRuntime {
         this.pendingSessionRelocations.clear();
         this.terminalSessionRelocations.clear();
         this.failedSessionRouteSubmits.clear();
-        this.sourceActorJoinProfiles.clear();
+        await this.drainActorJoinSources();
         this.terminalActorJoinSourceLeaves.clear();
-        this.options.boundSessionRelocation?.clear?.();
-        this.relocationAuthorityKeys.clear();
+        await this.options.boundSessionRelocation?.clear?.();
         if (errors.length === 1)
             throw errors[0];
         if (errors.length > 1)
@@ -234,6 +254,11 @@ class ZLinkHostServiceRelocationRuntime {
     }
     /** Host shutdown waits for the existing attempt terminal before releasing its lease. */
     async drainTargetAttempts() {
+        this.targetPreparationStop.abort(new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ShuttingDown, 'Relocation target is shutting down.'));
+        for (const pending of this.targetAssemblies.values()) {
+            pending.assembly.fail('Relocation target is shutting down.');
+        }
+        await Promise.allSettled([...this.targetPrepareOperations.values()].map((value) => value.promise));
         const results = await Promise.allSettled([...this.targetStages.entries()].map(([stagingId, stage]) => {
             if (stage.fallback !== undefined)
                 clearTimeout(stage.fallback);
@@ -256,18 +281,34 @@ class ZLinkHostServiceRelocationRuntime {
     }
     /** Spec 28 §4.4: the target owner alone orders shutdown seal and verified cutover. */
     targetStageSealed(stage) {
-        return (!stage.cutoverReceived && (this.disposed || this.options.targetAdmissionSealed?.() === true));
+        return !stage.cutoverReceived && this.targetAdmissionSealed();
+    }
+    /** The Shutdown admission seal: closed once the target owner starts shutdown. */
+    targetAdmissionSealed() {
+        return this.disposed || this.options.targetAdmissionSealed?.() === true;
     }
     completeActorJoinSourceCleanup(actorId) {
         for (const [relocationId, profile] of this.sourceActorJoinProfiles) {
             if (profile.state.actorId !== actorId)
                 continue;
-            this.sourceActorJoinProfiles.delete(relocationId);
-            this.terminalActorJoinSourceLeaves.remember(relocationId, actorId);
-            void this.finalizeActorJoinSource(profile);
+            void this.retireActorJoinSource(relocationId, profile);
         }
     }
-    async finalizeActorJoinSource(profile) {
+    /** Drains the exact source scopes before their Spot lifecycle owners stop. */
+    async drainActorJoinSources(meshName) {
+        await Promise.all([...this.sourceActorJoinProfiles].map(([relocationId, profile]) => meshName === undefined || profile.state.meshName === meshName
+            ? this.retireActorJoinSource(relocationId, profile)
+            : undefined));
+    }
+    retireActorJoinSource(relocationId, profile) {
+        return (profile.retirement ??= this.finalizeActorJoinSource(profile, relocationId).finally(() => {
+            if (this.sourceActorJoinProfiles.get(relocationId) === profile) {
+                this.sourceActorJoinProfiles.delete(relocationId);
+                this.terminalActorJoinSourceLeaves.remember(relocationId, profile.state.actorId);
+            }
+        }));
+    }
+    async finalizeActorJoinSource(profile, relocationId) {
         const failures = [];
         try {
             await profile.ready;
@@ -275,6 +316,9 @@ class ZLinkHostServiceRelocationRuntime {
         catch (error) {
             failures.push(error);
         }
+        // A pre-commit failure removed this attempt and restored the source.
+        if (this.sourceActorJoinProfiles.get(relocationId) !== profile)
+            return;
         try {
             await this.options.actorTransfer.completeRelocationSourceLeave(profile.actor, profile.sourceSpotId);
         }
@@ -284,7 +328,7 @@ class ZLinkHostServiceRelocationRuntime {
         try {
             await this.options
                 .actorManager()
-                ?.completeRelocationSource(profile.state.actorId, profile.sourceActorRef);
+                ?.completeCoreRelocationSource(profile.state.actorId, profile.state);
         }
         catch (error) {
             failures.push(error);
@@ -330,10 +374,10 @@ class ZLinkHostServiceRelocationRuntime {
                         id: `actor:${state.actorId}`,
                         relocate: async (relocationSignal) => {
                             await relocateShell(relocationSignal);
+                            const spotAuthority = await requireAuthority(this.requireLocationStore(), (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', String(activation.spotId)), relocationSignal);
                             await this.relocateStandaloneActor(meshName, state, undefined, targetApplicationVersion, relocationSignal, {
-                                spotId: activation.spotId,
-                                spotKind: contracts_1.ZLinkSpotKind.User,
-                                spotObjectGeneration: (await requireAuthority(this.requireLocationStore(), (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', String(activation.spotId)), relocationSignal)).objectGeneration
+                                ...committedSpotRoute(meshName, activation.spotId, contracts_1.ZLinkSpotKind.User, spotAuthority.allocation.descriptor.rid, spotAuthority),
+                                spotObjectGeneration: spotAuthority.objectGeneration
                             });
                         }
                     });
@@ -412,13 +456,11 @@ class ZLinkHostServiceRelocationRuntime {
         const payload = record.parts[0].data();
         const command = (0, service_relocation_control_1.serviceRelocationControlCommand)(payload);
         if (command === undefined) {
-            if (record.kind !== service_runtime_contracts_1.ReceiveKind.NodeSend)
+            if (record.kind !== service_runtime_contracts_1.ReceiveKind.NodeSend || record.parts.length !== 1)
                 return false;
             const sourceLeave = (0, actor_remote_wire_1.decodeRemoteActorSourceLeaveTerminal)(payload);
             if (sourceLeave === undefined)
                 return false;
-            if (record.parts.length !== 1)
-                return false;
             return this.acceptActorJoinSourceLeave(sourceLeave);
         }
         return this.handleControl(meshName, record, payload, command, signal);
@@ -441,9 +483,38 @@ class ZLinkHostServiceRelocationRuntime {
             return true;
         }
         if (command === service_stateful_wire_codec_1.M6bServiceWireCommand.sessionRelocationSeal) {
-            const request = (0, service_stateful_wire_codec_1.decodeSessionRelocationSeal)(payload);
-            const response = await this.handleSessionRelocationSeal(meshName, request, record.sourceNodeRid, signal);
-            await this.sendSessionRelocationResponse(meshName, record.sourceNodeRid, (0, service_stateful_wire_codec_1.encodeSessionRelocationSealed)(response));
+            let request;
+            try {
+                request = (0, service_stateful_wire_codec_1.decodeSessionRelocationSeal)(payload);
+            }
+            catch (error) {
+                const outcome = ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error;
+                (0, message_flow_1.flowIfEnabled)(this.options.messageFlow?.(), outcome)?.trace({
+                    outcome,
+                    surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.StreamSession,
+                    messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Control,
+                    packetName: 'sessionRelocationSeal',
+                    sourceRid: record.sourceNodeRid ?? undefined,
+                    errorReason: 'invalid_frame',
+                    errorAction: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop,
+                    ...(0, dispatch_error_details_1.dispatchErrorDetails)(error)
+                });
+                throw error;
+            }
+            let response;
+            try {
+                response = await this.handleSessionRelocationSeal(meshName, request, record.sourceNodeRid, signal);
+            }
+            catch (error) {
+                (0, message_flow_1.traceSessionBindingControlDrop)(this.options.messageFlow?.(), record.sourceNodeRid ?? '', request.actor.actor.actorId, 'sessionRelocationSeal', error instanceof contracts_1.ZLinkFrameworkException &&
+                    error.kind === contracts_1.ZLinkFrameworkErrorKind.Unavailable
+                    ? 'location_unavailable'
+                    : 'stale_target', error);
+                throw error;
+            }
+            if (response !== undefined) {
+                await this.sendSessionRelocationResponse(meshName, record.sourceNodeRid, (0, service_stateful_wire_codec_1.encodeSessionRelocationSealed)(response));
+            }
             return true;
         }
         if (command === service_stateful_wire_codec_1.M6bServiceWireCommand.sessionRelocationRoute) {
@@ -471,7 +542,7 @@ class ZLinkHostServiceRelocationRuntime {
                 throw new Error('Relocation prepare has no authenticated source node.');
             }
             if (record.kind !== service_runtime_contracts_1.ReceiveKind.NodeRequest) {
-                throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Relocation prepare requires a Core request leg.');
+                throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Relocation prepare requires a Core request leg.');
             }
             const operationKey = relocationStagingId(request);
             const fingerprint = stringifyWire(request);
@@ -484,12 +555,12 @@ class ZLinkHostServiceRelocationRuntime {
                 this.targetAssemblies.get(operationKey)?.fingerprint ??
                 this.targetStages.get(operationKey)?.offer.prepareFingerprint ??
                 this.terminalTargets.get(operationKey);
-            if (request.sourceNodeRid !== String(record.sourceNodeRid))
+            if (!(0, routing_id_1.routingIdsEqual)(request.sourceNodeRid, record.sourceNodeRid))
                 return true;
             if (acceptedFingerprint !== undefined && acceptedFingerprint !== fingerprint) {
                 if (!samePrepareIdentity(acceptedFingerprint, request))
                     return true;
-                this.replyPrepare(record, relocationFailed(request, service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.relocationDataLost));
+                this.replyPrepare(record, relocationFailed(request, service_wire_constants_generated_2.ServiceWireFrameworkErrorCode.relocationDataLost));
                 return true;
             }
             // A restore that failed outright is terminal: the source observes the
@@ -513,7 +584,7 @@ class ZLinkHostServiceRelocationRuntime {
                 // finish the restore and the Ready reply asynchronously.
                 let promise;
                 try {
-                    this.registerTargetAssembly(operationKey, request, String(record.sourceNodeRid));
+                    this.registerTargetAssembly(operationKey, request, record.sourceNodeRid);
                     promise = this.handlePrepareControl(meshName, operationKey, request, record.sourceNodeRid, signal);
                 }
                 catch (error) {
@@ -624,7 +695,7 @@ class ZLinkHostServiceRelocationRuntime {
         const pending = this.targetAssemblies.get(operationKey);
         if (pending === undefined ||
             sourceNodeRid === null ||
-            String(sourceNodeRid) !== pending.authenticatedSourceNodeRid ||
+            !(0, routing_id_1.routingIdsEqual)(sourceNodeRid, pending.authenticatedSourceNodeRid) ||
             request.senderRole !== 'source' ||
             !sameCoordinator(request.coordinator, pending.prepare.coordinator) ||
             !sameRelocationObject(request.object, pending.prepare.object)) {
@@ -676,7 +747,7 @@ class ZLinkHostServiceRelocationRuntime {
         //  to itself; RouteMesh has no self connection (NotConnected), so the
         //  control dispatches through the same inbound handler locally.
         const localRid = this.requireMeshNode(meshName).status().routingId;
-        if (String(localRid) === String(targetNodeRid)) {
+        if ((0, routing_id_1.routingIdsEqual)(localRid, targetNodeRid)) {
             await this.handleSessionRelocationRoute(meshName, request, localRid, signal);
             return;
         }
@@ -696,20 +767,21 @@ class ZLinkHostServiceRelocationRuntime {
         const key = sessionRelocationPendingKey(request);
         const bytes = (0, service_stateful_wire_codec_1.encodeSessionRelocationSeal)(request);
         const requestFingerprint = bytes.toString('base64');
-        const expectedTarget = String(targetNodeRid);
+        const expectedTarget = (0, routing_id_1.encodeRoutingIdStorageHex)(targetNodeRid);
         const terminal = this.terminalSessionRelocations.get(key);
         if (terminal !== undefined) {
             if (terminal.targetNodeRid !== expectedTarget ||
                 terminal.requestFingerprint !== requestFingerprint) {
-                return Promise.reject(new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation control '${key}' repeated with different bytes or target.`));
+                return Promise.reject(new service_wire_m6a_codec_2.ServiceWireProtocolError(`Session relocation control '${key}' repeated with different bytes or target.`));
             }
             this.terminalSessionRelocations.touch(key);
+            return Promise.resolve(terminal.response);
         }
         const existing = this.pendingSessionRelocations.get(key);
         if (existing !== undefined) {
             if (existing.targetNodeRid !== expectedTarget ||
                 existing.requestFingerprint !== requestFingerprint) {
-                return Promise.reject(new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation control '${key}' repeated with different bytes or target.`));
+                return Promise.reject(new service_wire_m6a_codec_2.ServiceWireProtocolError(`Session relocation control '${key}' repeated with different bytes or target.`));
             }
             return existing.promise;
         }
@@ -762,10 +834,11 @@ class ZLinkHostServiceRelocationRuntime {
             //  connection (NotConnected); dispatch through the inbound handler
             //  locally instead of the wire.
             const localRid = this.requireMeshNode(meshName).status().routingId;
-            if (String(localRid) === expectedTarget) {
+            if ((0, routing_id_1.encodeRoutingIdStorageHex)(localRid) === expectedTarget) {
                 try {
                     const response = await this.handleSessionRelocationSeal(meshName, request, localRid, signal);
-                    pending.resolve(response);
+                    if (response !== undefined)
+                        pending.resolve(response);
                 }
                 catch (error) {
                     pending.reject(error);
@@ -798,9 +871,8 @@ class ZLinkHostServiceRelocationRuntime {
             resolve: (response) => finish(() => {
                 this.terminalSessionRelocations.remember(key, {
                     targetNodeRid: expectedTarget,
-                    request,
                     requestFingerprint,
-                    responseFingerprint: sessionRelocationResponseFingerprint(response)
+                    response
                 });
                 resolvePromise(response);
             }),
@@ -826,18 +898,13 @@ class ZLinkHostServiceRelocationRuntime {
             const terminal = this.terminalSessionRelocations.get(key);
             if (terminal === undefined)
                 return;
-            if (sourceNodeRid === null || String(sourceNodeRid) !== terminal.targetNodeRid) {
-                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation ACK '${key}' source node changed.`);
-            }
-            validateSessionRelocationResponse(terminal.request, response);
-            if (sessionRelocationResponseFingerprint(response) !== terminal.responseFingerprint) {
-                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation ACK '${key}' repeated with different bytes.`);
-            }
+            // Session–Actor binding §8.3: the first command 43 is final for this participant.
             this.terminalSessionRelocations.touch(key);
             return;
         }
-        if (sourceNodeRid === null || String(sourceNodeRid) !== pending.targetNodeRid) {
-            pending.reject(new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation ACK '${key}' source node changed.`));
+        if (sourceNodeRid === null ||
+            (0, routing_id_1.encodeRoutingIdStorageHex)(sourceNodeRid) !== pending.targetNodeRid) {
+            pending.reject(new service_wire_m6a_codec_2.ServiceWireProtocolError(`Session relocation ACK '${key}' source node changed.`));
             return;
         }
         try {
@@ -856,44 +923,52 @@ class ZLinkHostServiceRelocationRuntime {
             return undefined;
         const node = this.requireMeshNode(meshName);
         const status = node.status();
-        if (String(status.routingId) === String(sourceNodeRid)) {
+        if ((0, routing_id_1.routingIdsEqual)(status.routingId, sourceNodeRid)) {
             return status.lifecycleGeneration;
         }
         return node
             .peers()
-            .find((peer) => peer.routingId !== null && String(peer.routingId) === String(sourceNodeRid))
+            .find((peer) => peer.routingId !== null && (0, routing_id_1.routingIdsEqual)(peer.routingId, sourceNodeRid))
             ?.lifecycleGeneration;
     }
     async handleSessionRelocationSeal(meshName, request, sourceNodeRid, signal) {
         if (sourceNodeRid === null ||
-            String(sourceNodeRid) !== request.coordinator.nodeRid ||
-            String(sourceNodeRid) !== request.actor.actor.nodeRid) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Session relocation seal source does not match its coordinator and Actor fence.');
+            !(0, routing_id_1.routingIdsEqual)(sourceNodeRid, request.coordinator.nodeRid) ||
+            !(0, routing_id_1.routingIdsEqual)(sourceNodeRid, request.actor.actor.nodeRid)) {
+            throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Session relocation seal source does not match its coordinator and Actor fence.');
         }
         this.validateSessionOwnerFence(meshName, request.session);
         const sealSourceGeneration = this.sourceLifecycleGeneration(meshName, sourceNodeRid);
         if (sealSourceGeneration !== request.actor.targetNodeGeneration ||
             sealSourceGeneration !== request.coordinator.nodeGeneration) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Session relocation seal source lifecycle generation is stale.');
+            throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Session relocation seal source lifecycle generation is stale.');
         }
         const handler = this.options.boundSessionRelocation?.receiveSeal;
         if (handler === undefined) {
             throw new Error('Session relocation seal ingress is not configured.');
         }
-        return await handler(request, signal);
+        return await handler(request, signal, () => {
+            const node = this.requireMeshNode(meshName);
+            if ((0, routing_id_1.routingIdsEqual)(node.status().routingId, request.targetNodeRid) ||
+                node.isPeerRouteReady?.(request.targetNodeRid, request.targetNodeGeneration) === true)
+                return;
+            void this.options
+                .requestPeerReconcile?.(meshName, request.targetNodeRid)
+                .catch((error) => console.error('[zlink.runtime.relocation.session_route_reconcile_failed]', error));
+        });
     }
     async handleSessionRelocationRoute(meshName, request, sourceNodeRid, _signal) {
         this.validateSessionOwnerFence(meshName, request.session);
         const expectedSource = request.route.action === 'commit' ? request.route.targetNodeRid : request.coordinator.nodeRid;
-        if (sourceNodeRid === null || String(sourceNodeRid) !== expectedSource) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Session relocation route source does not match its action fence.');
+        if (sourceNodeRid === null || !(0, routing_id_1.routingIdsEqual)(sourceNodeRid, expectedSource)) {
+            throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Session relocation route source does not match its action fence.');
         }
         const routeSourceGeneration = this.sourceLifecycleGeneration(meshName, sourceNodeRid);
         const expectedSourceGeneration = request.route.action === 'commit'
             ? request.route.targetNodeGeneration
             : request.coordinator.nodeGeneration;
         if (routeSourceGeneration !== expectedSourceGeneration) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Session relocation route source lifecycle generation is stale.');
+            throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Session relocation route source lifecycle generation is stale.');
         }
         const handler = this.options.boundSessionRelocation?.receiveRoute;
         if (handler === undefined) {
@@ -904,16 +979,20 @@ class ZLinkHostServiceRelocationRuntime {
     validateSessionOwnerFence(meshName, session) {
         const status = this.requireMeshNode(meshName).status();
         const owner = this.options.currentOwner();
+        // Session-Actor binding §4: without this host's own descriptor the command is Unavailable.
+        if (owner === undefined) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, 'Session owner has no live MeshNode descriptor.');
+        }
         if (!(0, routing_id_1.routingIdsEqual)(status.routingId, session.sessionOwnerNodeRid) ||
             status.lifecycleGeneration !== session.sessionOwnerNodeGeneration ||
-            owner?.ownerId !== session.sessionOwnerId ||
+            owner.ownerId !== session.sessionOwnerId ||
             owner.leaseGeneration !== session.sessionOwnerLeaseGeneration) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Session relocation command does not match the local Session owner fence.');
+            throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Session relocation command does not match the local Session owner fence.');
         }
     }
     async sendSessionRelocationResponse(meshName, targetNodeRid, bytes) {
         if (targetNodeRid === null) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Session relocation command has no authenticated source.');
+            throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Session relocation command has no authenticated source.');
         }
         const submitted = await this.sendInfrastructureControl(meshName, targetNodeRid, bytes);
         if (submitted !== runtime_values_1.SubmitResult.Ok) {
@@ -938,7 +1017,7 @@ class ZLinkHostServiceRelocationRuntime {
         let readinessBoundaryConsumed = false;
         let interruptionStartedAt;
         const spotRegistration = this.spotRegistration(meshName, kind, spotAuthority.allocation.stableType);
-        target ??= await this.selectTarget(meshName, String(this.requireMeshNode(meshName).status().routingId), targetApplicationVersion, relocationTargetRequirements([
+        target ??= await this.selectTarget(meshName, this.requireMeshNode(meshName).status().routingId, targetApplicationVersion, relocationTargetRequirements([
             {
                 objectKind: kind,
                 stableType: spotAuthority.allocation.stableType,
@@ -963,23 +1042,32 @@ class ZLinkHostServiceRelocationRuntime {
             objectGeneration: spotAuthority.objectGeneration,
             authorityOwnerGeneration: spotAuthority.authorityOwnerGeneration,
             seal: async (captureSignal) => {
+                // Relocation 04 §4.1: every bound member's Session is sealed before
+                // the Spot capture stops member dispatch.
+                const preparations = await Promise.allSettled(actorStates.map(async (state) => ({
+                    state,
+                    actor: state.actor,
+                    prepared: await this.options.actorTransfer.prepareMaintenanceSession(state.actor, state, captureSignal, false, relocationWireId(aggregateId), target)
+                })));
+                const failures = [];
+                for (const preparation of preparations) {
+                    if (preparation.status === 'fulfilled')
+                        sessions.push(preparation.value);
+                    else
+                        failures.push(preparation.reason);
+                }
+                if (failures.length === 1)
+                    throw failures[0];
+                if (failures.length > 1) {
+                    throw new AggregateError(failures, 'Spot relocation source preparation failed.');
+                }
                 const { spotCaptureOperation } = await this.afterSpotCloseDecision(meshName, activation.spotId, () => {
                     interruptionStartedAt = performance.now();
                     spotMessageFollowSeal = this.sealSpotMessageFollow(meshName, spotAuthority, activation);
-                    // Both seals run in the same event-loop turn after the Close decision.
+                    // Both Spot seals run in the same event-loop turn after the Close decision.
                     return { spotCaptureOperation: activation.captureRelocation(captureSignal) };
                 });
-                const preparedSessions = Promise.all(actorStates.map(async (state) => ({
-                    state,
-                    actor: state.actor,
-                    prepared: await this.options.actorTransfer.prepareMaintenanceSession(state.actor, state, captureSignal, false, relocationWireId(aggregateId))
-                })));
-                const preparedSessionsOutcome = preparedSessions.then((value) => ({ value }), (error) => ({ error }));
                 spotCapture = await spotCaptureOperation;
-                const preparation = await preparedSessionsOutcome;
-                if ('error' in preparation)
-                    throw preparation.error;
-                sessions.push(...preparation.value);
                 return {
                     boundSessionState: Buffer.alloc(0),
                     queuedMessages: [],
@@ -987,7 +1075,7 @@ class ZLinkHostServiceRelocationRuntime {
                 };
             },
             captureApplicationState: (captureSignal) => this.captureApplication(spotRegistration.relocation, activation.spot, captureSignal),
-            commitSeal: async () => {
+            commitSeal: async (followAuthorities) => {
                 const failures = [];
                 try {
                     if (!spotSealCommitted) {
@@ -997,7 +1085,7 @@ class ZLinkHostServiceRelocationRuntime {
                         spotSealCommitted = true;
                     }
                     if (spotMessageFollowSeal !== undefined) {
-                        await this.commitSpotMessageFollow(meshName, spotMessageFollowSeal, spotKey, activation, target);
+                        await this.commitSpotMessageFollow(meshName, spotMessageFollowSeal, followAuthorities.get(spotKey.value), activation);
                     }
                 }
                 catch (error) {
@@ -1005,20 +1093,17 @@ class ZLinkHostServiceRelocationRuntime {
                 }
                 for (const session of sessions) {
                     try {
-                        const committedAuthority = await requireAuthority(this.requireLocationStore(), (0, authority_key_codec_1.encodeAuthorityKey)('actor', session.state.actorId));
+                        const committedAuthority = followAuthorities.get((0, authority_key_codec_1.encodeAuthorityKey)('actor', session.state.actorId).value);
+                        const committedSpot = followAuthorities.get(spotKey.value);
                         const targetActorRef = {
                             actorId: session.state.actorId,
                             objectGeneration: actorAuthorities.get(session.state.actorId).objectGeneration,
                             meshName,
                             nodeRid: target.rid
                         };
-                        await session.prepared.commit({
-                            routerChannelId: meshName,
-                            targetNodeRid: target.rid,
-                            spotId: activation.spotId,
-                            spotKind: kind === 'user_spot' ? contracts_1.ZLinkSpotKind.User : contracts_1.ZLinkSpotKind.Instance,
-                            authorityOwnerGeneration: committedAuthority.authorityOwnerGeneration
-                        }, targetActorRef, (0, actor_transfer_runtime_1.committedActorOwnerFence)(session.state.actorId, targetActorRef, committedAuthority));
+                        await session.prepared.commit(committedSpotRoute(meshName, activation.spotId, kind === 'user_spot' ? contracts_1.ZLinkSpotKind.User : contracts_1.ZLinkSpotKind.Instance, target.rid, committedSpot), targetActorRef, committedAuthority === undefined || committedSpot === undefined
+                            ? null
+                            : (0, actor_transfer_runtime_1.committedActorOwnerFence)(session.state.actorId, targetActorRef, committedAuthority));
                     }
                     catch (error) {
                         failures.push(error);
@@ -1050,6 +1135,15 @@ class ZLinkHostServiceRelocationRuntime {
             abortSeal: async () => {
                 const failures = [];
                 if (spotCapture !== undefined) {
+                    // Spot model §5.1: Continued completes while the source seal still holds jobs.
+                    if (readinessBoundaryConsumed) {
+                        try {
+                            await activation.completeConsumedRelocationBoundary(contracts_1.ZLinkSpotRelocationReadyOutcome.Continued);
+                        }
+                        catch (error) {
+                            failures.push(error);
+                        }
+                    }
                     try {
                         activation.abortRelocation(spotCapture);
                     }
@@ -1089,7 +1183,9 @@ class ZLinkHostServiceRelocationRuntime {
             spotObjectGeneration: spotAuthority.objectGeneration,
             membershipEpoch: state.spotMembershipEpoch > 0n ? state.spotMembershipEpoch : 1n
         }));
-        let outcome = 'completed';
+        const relocationMetric = spotRegistration.relocation.kind === 'disabled'
+            ? undefined
+            : this.options.metrics?.startRelocation(meshName, kind, spotRegistration.relocation.kind);
         try {
             const waitForRelocationBoundary = activation.waitForRelocationBoundary;
             readinessBoundaryConsumed =
@@ -1109,10 +1205,9 @@ class ZLinkHostServiceRelocationRuntime {
                     (0, authority_key_codec_1.encodeAuthorityKey)('actor', state.actorId).value,
                     actorAuthorities.get(state.actorId)
                 ])
-            ]), signal, sessions);
+            ]), signal, sessions, undefined, undefined, relocationMetric);
         }
         catch (error) {
-            outcome = 'failed';
             if (readinessBoundaryConsumed &&
                 !(error instanceof service_relocation_coordinator_1.ServiceRelocationPostCommitError) &&
                 !(error instanceof service_relocation_coordinator_1.ServiceRelocationAuthorityError)) {
@@ -1123,9 +1218,10 @@ class ZLinkHostServiceRelocationRuntime {
             throw error;
         }
         finally {
+            this.completeSourceRelocationMetric(relocationMetric);
             this.sourceRelocationIds.delete(aggregateId);
             if (interruptionStartedAt !== undefined) {
-                this.recordRelocationInterruption(meshName, kind, kind === 'user_spot' ? 'spot_wide' : undefined, interruptionStartedAt, outcome);
+                this.recordRelocationInterruption(meshName, kind, kind === 'user_spot' ? 'spot_wide' : undefined, interruptionStartedAt);
             }
         }
     }
@@ -1136,21 +1232,19 @@ class ZLinkHostServiceRelocationRuntime {
             (0, diagnostics_1.relocationDebug)('standalone_actor.begin', { actorId: state.actorId });
         }
         const authority = await requireAuthority(this.requireLocationStore(), (0, authority_key_codec_1.encodeAuthorityKey)('actor', state.actorId), signal);
-        target ??= await this.selectTarget(meshName, String(this.requireMeshNode(meshName).status().routingId), targetApplicationVersion, [
+        const actorPolicy = this.actorRegistration(state.meshName ?? meshName, authority.allocation.stableType).relocation.kind;
+        target ??= await this.selectTarget(meshName, this.requireMeshNode(meshName).status().routingId, targetApplicationVersion, [
             {
                 objectKind: 'actor',
                 stableType: authority.allocation.stableType,
-                policy: this.actorRegistration(state.meshName ?? meshName, authority.allocation.stableType).relocation.kind,
+                policy: actorPolicy,
                 count: 1
             }
         ], signal);
         const sessions = [];
         const membershipSpotId = targetMembership?.spotId ?? (target.entrySpotId ?? String(target.rid));
         const aggregateId = aggregateIdOverride ?? this.reserveRelocationId();
-        const unit = this.actorCaptureUnit(state, authority, sessions, true, target, meshName, {
-            spotId: membershipSpotId,
-            spotKind: targetMembership?.spotKind ?? contracts_1.ZLinkSpotKind.Entry
-        }, relocationWireId(aggregateId), retainSourceForActorJoin);
+        const unit = this.actorCaptureUnit(state, authority, sessions, true, target, meshName, targetMembership, relocationWireId(aggregateId), retainSourceForActorJoin);
         const membership = {
             actorKey: (0, authority_key_codec_1.encodeAuthorityKey)('actor', state.actorId).value,
             spotKey: (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', String(membershipSpotId)).value,
@@ -1165,7 +1259,9 @@ class ZLinkHostServiceRelocationRuntime {
                 return unit.seal(captureSignal);
             }
         };
-        let outcome = 'completed';
+        const relocationMetric = actorPolicy === 'disabled'
+            ? undefined
+            : this.options.metrics?.startRelocation(meshName, 'actor', actorPolicy);
         try {
             if ((0, diagnostics_1.isRelocationDebugEnabled)()) {
                 (0, diagnostics_1.relocationDebug)('standalone_actor.wait_budget', {
@@ -1181,16 +1277,13 @@ class ZLinkHostServiceRelocationRuntime {
             if ((0, diagnostics_1.isRelocationDebugEnabled)()) {
                 (0, diagnostics_1.relocationDebug)('standalone_actor.capture_complete', { actorId: state.actorId });
             }
-            await this.runCoordinator(meshName, target, authority, captured, new Map([[measuredUnit.authorityKey, authority]]), signal, sessions, advertisedReceiveChunkLimitBytes, deadlineAtMs);
-        }
-        catch (error) {
-            outcome = 'failed';
-            throw error;
+            await this.runCoordinator(meshName, target, authority, captured, new Map([[measuredUnit.authorityKey, authority]]), signal, sessions, advertisedReceiveChunkLimitBytes, deadlineAtMs, relocationMetric);
         }
         finally {
+            this.completeSourceRelocationMetric(relocationMetric);
             this.sourceRelocationIds.delete(aggregateId);
             if (interruptionStartedAt !== undefined) {
-                this.recordRelocationInterruption(meshName, 'actor', undefined, interruptionStartedAt, outcome);
+                this.recordRelocationInterruption(meshName, 'actor', undefined, interruptionStartedAt);
             }
         }
     }
@@ -1201,7 +1294,7 @@ class ZLinkHostServiceRelocationRuntime {
         const spotKey = (0, authority_key_codec_1.encodeAuthorityKey)('user_spot', String(activation.spotId));
         const spotAuthority = await requireAuthority(this.requireLocationStore(), spotKey, signal);
         const spotRegistration = this.spotRegistration(meshName, 'user_spot', spotAuthority.allocation.stableType);
-        target ??= await this.selectTarget(meshName, String(this.requireMeshNode(meshName).status().routingId), targetApplicationVersion, [
+        target ??= await this.selectTarget(meshName, this.requireMeshNode(meshName).status().routingId, targetApplicationVersion, [
             {
                 objectKind: 'user_spot',
                 stableType: spotAuthority.allocation.stableType,
@@ -1235,7 +1328,7 @@ class ZLinkHostServiceRelocationRuntime {
             // PerActor User Spots are stateless shells. Application state and the
             // Spot relocation adapter are intentionally not part of this unit.
             captureApplicationState: async () => Buffer.alloc(0),
-            commitSeal: async () => {
+            commitSeal: async (followAuthorities) => {
                 if (!sealCommitted) {
                     if (spotCapture === undefined || !(await activation.commitRelocation(spotCapture))) {
                         throw new Error(`PerActor Spot '${String(activation.spotId)}' relocation seal became stale.`);
@@ -1243,7 +1336,7 @@ class ZLinkHostServiceRelocationRuntime {
                     sealCommitted = true;
                 }
                 if (spotMessageFollowSeal !== undefined) {
-                    await this.commitSpotMessageFollow(meshName, spotMessageFollowSeal, spotKey, activation, target);
+                    await this.commitSpotMessageFollow(meshName, spotMessageFollowSeal, followAuthorities.get(spotKey.value), activation);
                 }
                 await this.requireSpotManager().completeRelocationSource(activation);
             },
@@ -1260,20 +1353,19 @@ class ZLinkHostServiceRelocationRuntime {
             }
         };
         const aggregateId = this.reserveRelocationId();
-        let outcome = 'completed';
+        const relocationMetric = spotRegistration.relocation.kind === 'disabled'
+            ? undefined
+            : this.options.metrics?.startRelocation(meshName, 'user_spot', spotRegistration.relocation.kind);
         try {
             await this.waitForRelocationBudgetHeadroom(String(target.rid), signal);
             const captured = await new service_relocation_object_owner_1.ServiceRelocationObjectCaptureOwner().captureUserSpotAggregate(aggregateId, 1n, spotUnit, [], [], signal);
-            await this.runCoordinator(meshName, target, spotAuthority, captured, new Map([[spotKey.value, spotAuthority]]), signal, []);
-        }
-        catch (error) {
-            outcome = 'failed';
-            throw error;
+            await this.runCoordinator(meshName, target, spotAuthority, captured, new Map([[spotKey.value, spotAuthority]]), signal, [], undefined, undefined, relocationMetric);
         }
         finally {
+            this.completeSourceRelocationMetric(relocationMetric);
             this.sourceRelocationIds.delete(aggregateId);
             if (interruptionStartedAt !== undefined) {
-                this.recordRelocationInterruption(meshName, 'user_spot', 'per_actor', interruptionStartedAt, outcome);
+                this.recordRelocationInterruption(meshName, 'user_spot', 'per_actor', interruptionStartedAt);
             }
         }
     }
@@ -1291,7 +1383,7 @@ class ZLinkHostServiceRelocationRuntime {
                     ownSession = {
                         state,
                         actor: state.actor,
-                        prepared: await this.options.actorTransfer.prepareMaintenanceSession(state.actor, state, signal, true, sessionRelocation)
+                        prepared: await this.options.actorTransfer.prepareMaintenanceSession(state.actor, state, signal, true, sessionRelocation, target)
                     };
                     sessions.push(ownSession);
                 }
@@ -1319,7 +1411,7 @@ class ZLinkHostServiceRelocationRuntime {
             },
             // The sealed Session identity is part of the canonical participant vector.
             captureApplicationState: (signal) => this.captureApplication(registration.relocation, state.actor, signal),
-            commitSeal: async () => {
+            commitSeal: async (followAuthorities) => {
                 if (!standalone ||
                     ownSession === undefined ||
                     target === undefined ||
@@ -1327,33 +1419,36 @@ class ZLinkHostServiceRelocationRuntime {
                     return;
                 const failures = [];
                 try {
-                    const membershipSpotId = targetMembership?.spotId ?? (target.entrySpotId ?? String(target.rid));
-                    const committedAuthority = await requireAuthority(this.requireLocationStore(), (0, authority_key_codec_1.encodeAuthorityKey)('actor', state.actorId));
+                    const committedAuthority = followAuthorities.get((0, authority_key_codec_1.encodeAuthorityKey)('actor', state.actorId).value);
                     const targetActorRef = {
                         actorId: state.actorId,
                         objectGeneration: authority.objectGeneration,
                         meshName,
                         nodeRid: target.rid
                     };
-                    await ownSession.prepared.commit({
+                    await ownSession.prepared.commit(targetMembership ?? {
                         routerChannelId: meshName,
                         targetNodeRid: target.rid,
-                        spotId: membershipSpotId,
-                        spotKind: targetMembership?.spotKind ?? contracts_1.ZLinkSpotKind.Entry,
-                        authorityOwnerGeneration: committedAuthority.authorityOwnerGeneration
-                    }, targetActorRef, (0, actor_transfer_runtime_1.committedActorOwnerFence)(state.actorId, targetActorRef, committedAuthority));
+                        spotId: (target.entrySpotId ?? String(target.rid)),
+                        spotKind: contracts_1.ZLinkSpotKind.Entry
+                    }, targetActorRef, committedAuthority === undefined
+                        ? null
+                        : (0, actor_transfer_runtime_1.committedActorOwnerFence)(state.actorId, targetActorRef, committedAuthority));
                 }
                 catch (error) {
                     failures.push(error);
                 }
-                if (!retainSourceForActorJoin) {
-                    try {
-                        await this.requireActorManager().completeRelocationSource(state.actorId);
+                try {
+                    if (retainSourceForActorJoin) {
+                        this.requireActorManager().detachRelocationSource(state);
                     }
-                    catch (error) {
-                        failures.push(error);
+                    else {
+                        await this.requireActorManager().completeRelocationSource(state.actorId);
                     }
                 }
+                catch (error) {
+                    failures.push(error);
+                }
                 if (failures.length > 0)
                     throw failures.length === 1
                         ? failures[0]
@@ -1390,7 +1485,7 @@ class ZLinkHostServiceRelocationRuntime {
     }
     async runCoordinator(meshName, target, primary, captured, _authorities, signal, sessions = [], 
     /** Target's advertised relocation state chunk cap (Actor Join only; spec 15 §4.2). */
-    advertisedReceiveChunkLimitBytes, controlDeadlineAtMs = performance.now() + RELOCATION_OPERATION_TIMEOUT_MS) {
+    advertisedReceiveChunkLimitBytes, controlDeadlineAtMs = performance.now() + RELOCATION_OPERATION_TIMEOUT_MS, relocationMetric) {
         if ((0, diagnostics_1.isRelocationDebugEnabled)()) {
             (0, diagnostics_1.relocationDebug)('coordinator.begin', {
                 aggregateId: captured.envelope.aggregateId,
@@ -1401,12 +1496,12 @@ class ZLinkHostServiceRelocationRuntime {
         const coordinator = {
             ownerId: primary.ownerId,
             leaseGeneration: primary.ownerLeaseGeneration,
-            nodeRid: String(localStatus.routingId),
+            nodeRid: localStatus.routingId,
             nodeGeneration: localStatus.lifecycleGeneration,
             expectedAuthorityStoreVersion: primary.storeVersion.value
         };
         const targetFence = {
-            nodeRid: String(target.rid),
+            nodeRid: target.rid,
             nodeGeneration: target.lifecycleGeneration,
             ownerId: target.ownerId,
             ownerLeaseGeneration: target.leaseGeneration
@@ -1419,11 +1514,6 @@ class ZLinkHostServiceRelocationRuntime {
         // attempt even when it reuses the same routing id.
         const targetAttemptGeneration = target.lifecycleGeneration;
         const relayAuthorityId = wireIdText(relocationWireId(captured.envelope.aggregateId));
-        const relayAuthorityKey = primaryKey(captured.envelope);
-        if (this.relocationAuthorityKeys.has(relayAuthorityId)) {
-            throw new Error(`Relocation reply relay authority '${relayAuthorityId}' is already registered.`);
-        }
-        this.relocationAuthorityKeys.set(relayAuthorityId, relayAuthorityKey);
         // The captured payload stays in source memory: this copy is the only
         // handoff original until the cutover submit terminal and the
         // retransmission window end (spec 28 §4.2).
@@ -1433,6 +1523,7 @@ class ZLinkHostServiceRelocationRuntime {
             ? canonicalEnvelope
             : appendCanonicalActorJoinRecovery(canonicalEnvelope, actorJoinProfile, coordinator, primary);
         const encoded = (0, service_relocation_runtime_1.encodeServiceRelocationEnvelope)(transportEnvelope, target.applicationVersion);
+        relocationMetric?.recordBytes(encoded.byteLength);
         const limits = this.relocationLimits();
         // Actor Join threads the target's admission-time advertised cap in;
         // other relocation paths have no such negotiation and fall back to the
@@ -1460,7 +1551,8 @@ class ZLinkHostServiceRelocationRuntime {
                 payloadTotalLength: BigInt(plan.totalLength),
                 payloadChunkCount: plan.chunkCount,
                 payloadChecksumCrc32c: plan.checksumCrc32c,
-                applicationVersion: target.applicationVersion
+                applicationVersion: target.applicationVersion,
+                deadlineUnixMs: BigInt(Date.now() + Math.max(0, Math.ceil(controlDeadlineAtMs - performance.now())))
             };
             // Start the Restore request first (it also registers the temporary
             // queue and the assembly on the target), then stream the payload chunks
@@ -1487,6 +1579,7 @@ class ZLinkHostServiceRelocationRuntime {
             // forward the source can no longer reopen dispatch without risking two
             // owners.
             readyReceived = true;
+            actorJoinProfile?.relayReady();
             const boundaryBatch = [];
             for (const session of sessions) {
                 const participant = captured.envelope.participants.find((value) => value.objectKind === 'actor' &&
@@ -1539,7 +1632,7 @@ class ZLinkHostServiceRelocationRuntime {
             }
             const window = this.beginSourceCutoverWindow(meshName, target.rid, relayAuthorityId, [...boundaryBatch.map((value) => value.frame), cutoverFrame], submittedRouteGeneration, limits);
             try {
-                settlement = await this.settleSourceAuthority(captured.envelope, primary, targetFence, restoreDeadlineReached, window);
+                settlement = await this.settleSourceAuthority(captured.envelope, primary, targetFence, restoreDeadlineReached, window, relocationMetric);
             }
             finally {
                 this.closeSourceCutoverWindow(relayAuthorityId, window);
@@ -1554,22 +1647,31 @@ class ZLinkHostServiceRelocationRuntime {
                 // Preserve won: the captured queue, timers and held records return to
                 // the source queue in their accepted order, and dispatch reopens.
                 await captured.abortSource();
+                this.completeSourceRelocationMetric(relocationMetric, settlement);
                 throw new Error(`Relocation '${relayAuthorityId}' ended by the source Preserve fence; the source kept the authority.`);
             }
             if (settlement === 'lost') {
+                this.completeSourceRelocationMetric(relocationMetric, settlement);
                 // Expired owner: dispatch and Store changes stop for good and every
                 // pending request without a terminal gets one Unavailable.
                 const unavailable = (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `Relocation '${relayAuthorityId}' source authority ended (source owner lease expired, authority Missing, or owner changed).`, true);
                 await captured.discardSource(unavailable);
                 throw new service_relocation_coordinator_1.ServiceRelocationAuthorityError(unavailable.message, { cause: unavailable });
             }
+            this.completeSourceRelocationMetric(relocationMetric, settlement);
             for (const session of sessions)
                 session.prepared.setReplayResults([]);
-            await captured.commitSource();
+            await captured.commitSource(settlement.followAuthorities);
             await this.options.reconcileStatefulAuthorityRoutes?.(signal);
         }
         catch (error) {
-            if (settlement !== 'target')
+            if (this.disposed &&
+                (error instanceof ServiceRelocationRuntimeStoppedError ||
+                    (error instanceof runtime_values_1.ZLinkBackendResultError &&
+                        error.result ===
+                            (error.operation === 'request' ? runtime_values_1.RequestResult.Terminated : runtime_values_1.SubmitResult.Terminated))))
+                this.completeSourceRelocationMetric(relocationMetric, undefined, true);
+            if (settlement === undefined || typeof settlement === 'string')
                 throw error;
             // Target commit is confirmed; later source cleanup failures cannot move
             // the authority back (spec 28 §10).
@@ -1577,16 +1679,25 @@ class ZLinkHostServiceRelocationRuntime {
             throw new service_relocation_coordinator_1.ServiceRelocationPostCommitError(authority, { id: `${captured.envelope.aggregateId}:${captured.envelope.aggregateGeneration}` }, error);
         }
         finally {
+            this.completeSourceRelocationMetric(relocationMetric);
             if (!readyReceived) {
                 // Only an explicit failure before the Ready reply becomes accepted
                 // restores the source from the memory payload (spec 28 §9).
                 await captured.abortSource().catch(() => undefined);
             }
-            if (this.relocationAuthorityKeys.get(relayAuthorityId) === relayAuthorityKey) {
-                this.relocationAuthorityKeys.delete(relayAuthorityId);
-            }
         }
     }
+    completeSourceRelocationMetric(metric, settlement, sourceStopped = false) {
+        metric?.complete(settlement === 'source'
+            ? 'aborted'
+            : settlement === 'lost'
+                ? 'failed'
+                : settlement !== undefined
+                    ? 'completed'
+                    : sourceStopped
+                        ? 'shutdown'
+                        : 'failed');
+    }
     /** Streams the payload chunks of one stage under the effective in-flight budgets. */
     async sendRelocationStateChunks(meshName, target, identity, encoded, plan, signal) {
         for (let ordinal = 0; ordinal < plan.chunkCount; ordinal += 1) {
@@ -1721,15 +1832,18 @@ class ZLinkHostServiceRelocationRuntime {
      * excludes a late target commit. `target`: the
      * target committed. `source`: Preserve fenced the target out while the
      * source owner lease was valid. `lost`: the source owner lease ended first
-     * or authority is Missing or another authority owns the object. An uncertain
+     * or authority is Missing or fails the same-object, advanced-generation fence.
+     * A committed later owner has no Follow snapshot (Location runtime §10). An uncertain
      * Store or lease result keeps the work retained and repeats the same decision.
      */
-    async settleSourceAuthority(envelope, primary, target, restoreDeadlineReached, window) {
+    async settleSourceAuthority(envelope, primary, target, restoreDeadlineReached, window, relocationMetric) {
         const owner = { ownerId: primary.ownerId, leaseGeneration: primary.ownerLeaseGeneration };
         const store = this.requireLocationStore();
         for (;;) {
-            if (this.disposed)
-                throw new Error('Relocation runtime stopped.');
+            if (this.disposed) {
+                this.completeSourceRelocationMetric(relocationMetric, undefined, true);
+                throw new ServiceRelocationRuntimeStoppedError();
+            }
             await this.resendSourceCutover(window);
             const observed = await this.readSourceSettlement(envelope, primary, target).catch((error) => {
                 if (!(0, location_store_failure_1.isIndeterminateLocationStoreFailure)(error))
@@ -1737,7 +1851,7 @@ class ZLinkHostServiceRelocationRuntime {
                 return undefined;
             });
             if (observed?.kind === 'target')
-                return 'target';
+                return observed;
             if (observed?.kind === 'other')
                 return 'lost';
             if (restoreDeadlineReached() && observed?.kind === 'source') {
@@ -1772,6 +1886,7 @@ class ZLinkHostServiceRelocationRuntime {
     async readSourceSettlement(envelope, primary, target) {
         const primaryAuthorityKey = primaryKey(envelope);
         let committed = 0;
+        const followAuthorities = new Map();
         let primaryCurrent;
         for (const participant of envelope.participants) {
             const current = await this.requireLocationStore().readAuthority({
@@ -1780,18 +1895,22 @@ class ZLinkHostServiceRelocationRuntime {
             if (current.kind !== 'snapshot')
                 return { kind: 'other' };
             if (current.objectGeneration === participant.objectGeneration &&
-                current.ownerId === target.ownerId &&
-                current.ownerLeaseGeneration === target.ownerLeaseGeneration &&
                 current.authorityOwnerGeneration > participant.authorityOwnerGeneration &&
-                String(current.allocation.descriptor.rid) === target.nodeRid &&
-                current.allocation.descriptorLifecycleGeneration === target.nodeGeneration) {
+                // Location runtime §6: an owner is the (OwnerId, OwnerLeaseGeneration) pair;
+                // a restarted node keeps its OwnerId under a new lease generation.
+                (current.ownerId !== primary.ownerId ||
+                    current.ownerLeaseGeneration !== primary.ownerLeaseGeneration)) {
                 committed += 1;
+                // Location runtime §10: only the observed first target can receive Follow.
+                if (current.ownerId === target.ownerId &&
+                    current.ownerLeaseGeneration === target.ownerLeaseGeneration)
+                    followAuthorities.set(participant.key, current);
             }
             if (participant.key === primaryAuthorityKey)
                 primaryCurrent = current;
         }
         if (committed === envelope.participants.length)
-            return { kind: 'target' };
+            return { kind: 'target', followAuthorities };
         if (primaryCurrent !== undefined && isSourceOwner(primaryCurrent, primary)) {
             return { kind: 'source', current: primaryCurrent };
         }
@@ -1826,11 +1945,21 @@ class ZLinkHostServiceRelocationRuntime {
     }
     /** Restores the hidden object and its saved-work prefix before Ready. */
     async handlePrepareControl(meshName, stagingId, request, sourceNodeRid, signal) {
+        // Host relocation flow 05: a sealed target refuses a new PREPARE before any
+        // staging. The typed ShuttingDown reaches the source as relocationFailed.
+        if (this.targetAdmissionSealed()) {
+            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.ShuttingDown, 'Relocation target admission is sealed for shutdown.');
+        }
+        signal =
+            signal === undefined
+                ? this.targetPreparationStop.signal
+                : AbortSignal.any([signal, this.targetPreparationStop.signal]);
+        signal.throwIfAborted();
         const targetStatus = this.requireMeshNode(meshName).status();
         const targetOwner = this.options.currentOwner();
         const targetDescriptor = this.options.localDescriptor?.(meshName);
         if (targetOwner === undefined ||
-            String(targetStatus.routingId) !== request.target.nodeRid ||
+            !(0, routing_id_1.routingIdsEqual)(targetStatus.routingId, request.target.nodeRid) ||
             targetStatus.lifecycleGeneration !== request.target.nodeGeneration ||
             targetOwner.ownerId !== request.target.ownerId ||
             targetOwner.leaseGeneration !== request.target.ownerLeaseGeneration ||
@@ -1860,11 +1989,10 @@ class ZLinkHostServiceRelocationRuntime {
             payload = await pendingAssembly.assembly.payload();
         }
         catch (error) {
-            // A rejection observed after dispose() started is the runtime shutting
-            // down, not a chunk-assembly or checksum integrity failure — it must
-            // not be reported as DataLost(35). There is no dedicated ShuttingDown
-            // wire code in the vocabulary yet, so it falls through unwrapped to
-            // the generic InternalFailure code (spec 15 §4).
+            // Target shutdown preserves its lifecycle failure instead of reporting payload corruption.
+            this.targetAssemblies.delete(stagingId);
+            if (this.targetPreparationStop.signal.aborted)
+                throw this.targetPreparationStop.signal.reason;
             if (this.disposed)
                 throw error;
             const message = error !== null && typeof error === 'object' && 'message' in error
@@ -1891,11 +2019,43 @@ class ZLinkHostServiceRelocationRuntime {
             // rejects unrelated authority CAS until commit/abort.
             materialized = await this.materializeTargetEnvelope(meshName, inventoryEnvelope, signal);
             await materialized.owner.restoreSavedWork(materialized.staging, signal);
+            for (const participant of inventoryEnvelope.participants) {
+                const binding = participant.sessionBinding;
+                if (binding === undefined)
+                    continue;
+                const peerRid = (0, routing_id_1.decodeRoutingId)('', Buffer.from(binding.sessionOwnerNodeRid).toString('hex'));
+                const node = this.requireMeshNode(meshName);
+                if ((0, routing_id_1.routingIdsEqual)(node.status().routingId, peerRid))
+                    continue;
+                if (node.isPeerRouteReady?.(peerRid, binding.sessionOwnerNodeGeneration) !== true) {
+                    // Subscribe before requesting reconciliation so a synchronous admission cannot be lost.
+                    const wait = node.waitForPeerRoute;
+                    if (wait === undefined)
+                        throw new Error('Mesh peer route observation is unavailable.');
+                    const ready = wait.call(node, peerRid, binding.sessionOwnerNodeGeneration, request.deadlineUnixMs, signal);
+                    void this.options
+                        .requestPeerReconcile?.(meshName, String(peerRid))
+                        .catch((error) => console.error('[zlink.runtime.relocation.session_route_reconcile_failed]', error));
+                    try {
+                        await ready;
+                    }
+                    catch (error) {
+                        if (error instanceof operation_registry_1.OperationTimeoutError) {
+                            throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.DeadlineExceeded, 'Relocation source operation deadline exceeded waiting for Session owner route.');
+                        }
+                        throw error;
+                    }
+                }
+            }
+            if (request.deadlineUnixMs <= BigInt(Date.now())) {
+                throw new contracts_1.ZLinkFrameworkException(contracts_1.ZLinkFrameworkErrorKind.DeadlineExceeded, 'Relocation source operation deadline exceeded before relay-ready.');
+            }
+            signal.throwIfAborted();
             reservation = await this.reserveTargetForPrepare(meshName, request, inventoryEnvelope, signal);
             const offer = {
                 prepare: request,
                 prepareFingerprint: fingerprint,
-                authenticatedSourceNodeRid: String(sourceNodeRid),
+                authenticatedSourceNodeRid: sourceNodeRid,
                 envelope: inventoryEnvelope,
                 reservation
             };
@@ -1912,6 +2072,7 @@ class ZLinkHostServiceRelocationRuntime {
             this.targetStages.set(stagingId, stage);
         }
         catch (error) {
+            this.targetAssemblies.delete(stagingId);
             releaseJoinAdmission();
             releaseActivation();
             if (reservation !== undefined) {
@@ -2052,24 +2213,13 @@ class ZLinkHostServiceRelocationRuntime {
             stage.releaseActivation();
             resumeStartedAt = performance.now();
             stage.phase = 'committed';
-            await stage.owner.normalize(stage.staging, authority, signal);
             await stage.owner.publish(stage.staging, authority, signal);
-            // The target may have visited this Actor before and still retain that
-            // tenure in its private Actor-client resolver. The target-only CAS is
-            // now authoritative, so expire the old projection before OnJoinedActor
-            // can issue an Actor request and deadlock behind source leave.
-            for (const hidden of stage.staging.hidden.values()) {
-                if (hidden.actor !== undefined) {
-                    this.options.invalidateActorRoute?.(hidden.actor.context.actorId);
-                }
-            }
-            await this.finalizeActorJoinProfiles(meshName, stage, signal);
             // Clear the final relocation publication before admission becomes
             // externally visible so a later Join cannot reserve against the
             // previous root. A bounded CAS conflict must not roll back already
             // committed target ownership or strand its staged object.
             try {
-                await this.clearTargetRelocationPublication(stage, authority, signal);
+                authority = await this.clearTargetRelocationPublication(stage, authority, signal);
             }
             catch (error) {
                 console.warn('[zlink.runtime.relocation.publication_clear_failed]', stagingId, error);
@@ -2077,15 +2227,33 @@ class ZLinkHostServiceRelocationRuntime {
                     mesh_name: meshName
                 });
             }
-            await stage.owner.openAdmission(stage.staging, signal);
-            // S2→S3: owner confirmation to application dispatch opening.
-            this.options.metrics?.duration(runtime_metrics_1.METRIC_NAMES.RelocationTargetResume, Math.max(0, performance.now() - resumeStartedAt) / runtime_metrics_1.MILLISECONDS_PER_SECOND, { mesh_name: meshName });
+            for (const [index, participant] of stage.staging.envelope.participants.entries()) {
+                const hidden = stage.staging.hidden.get(participant.key);
+                if (hidden?.actor === undefined || hidden.replayPackets.length === 0)
+                    continue;
+                const coordinator = this.targetReplyRelayCoordinator(meshName, stage, authority);
+                hidden.replayStart = stage.finalize;
+                hidden.onReplayResult = (packet, result) => this.relayTerminalReply(meshName, stage, coordinator, BigInt(index + 1), packet, result, signal);
+            }
+            await stage.owner.normalize(stage.staging, authority, signal);
+            // The target may have visited this Actor before and still retain that
+            // tenure in its private Actor-client resolver. The target-only CAS is
+            // now authoritative, so expire the old projection before OnJoinedActor
+            // can issue an Actor request and deadlock behind source leave.
+            for (const hidden of stage.staging.hidden.values()) {
+                if (hidden.actor !== undefined) {
+                    this.options.invalidateActorRoute?.(hidden.actor.context.actorId);
+                }
+            }
+            await this.finalizeActorJoinProfiles(meshName, stage, signal);
             await this.publishSessionRoutes(stage.staging);
-            await this.relayTerminalReplies(meshName, stage, this.targetReplyRelayCoordinator(meshName, stage, authority), signal);
             stage.phase = 'open';
             this.terminalTargets.remember(stagingId, stage.offer.prepareFingerprint);
             this.targetStages.delete(stagingId);
             this.targetAssemblies.delete(stagingId);
+            await stage.owner.openAdmission(stage.staging, signal);
+            // S2→S3: owner confirmation to application dispatch opening.
+            this.options.metrics?.duration(runtime_metrics_1.METRIC_NAMES.RelocationTargetResume, Math.max(0, performance.now() - resumeStartedAt) / runtime_metrics_1.MILLISECONDS_PER_SECOND, { mesh_name: meshName });
         }
         catch (error) {
             this.terminalTargets.remember(stagingId, stage.offer.prepareFingerprint);
@@ -2182,9 +2350,7 @@ class ZLinkHostServiceRelocationRuntime {
         if (profile.state.actorId !== input.actorId || !input.succeeded) {
             throw new Error(`Actor Join relocation '${input.transferId}' source leave identity changed.`);
         }
-        this.sourceActorJoinProfiles.delete(input.transferId);
-        this.terminalActorJoinSourceLeaves.remember(input.transferId, input.actorId);
-        void this.finalizeActorJoinSource(profile);
+        void this.retireActorJoinSource(input.transferId, profile);
         return true;
     }
     async sendControlOneWay(meshName, targetNodeRid, request) {
@@ -2206,7 +2372,7 @@ class ZLinkHostServiceRelocationRuntime {
         //  row; the caller records it and leaves the committed ownership intact.
         const publication = this.codec.read(primary.payload);
         if (publication === undefined)
-            return;
+            return primary;
         const result = await this.requireLocationStore().compareExchangeAuthority(stage.staging.primaryAuthorityKey, primary.storeVersion, {
             kind: 'put',
             generationTransition: 'preserve',
@@ -2215,39 +2381,52 @@ class ZLinkHostServiceRelocationRuntime {
         if (result.kind !== 'stored') {
             throw new Error('Relocation target authority normalization CAS failed.');
         }
+        return { ...result, kind: 'snapshot' };
     }
     async handleReplyRelay(meshName, relay, sourceNodeRid, signal) {
         if (sourceNodeRid === null) {
             throw new Error('Relocation reply relay has no authenticated target node.');
         }
-        await this.requireAdmittedPeer(meshName, String(sourceNodeRid), relay.coordinator, signal);
-        const relocationId = wireIdText(relay.relocation);
-        const authorityKey = this.relocationAuthorityKeys.get(relocationId);
-        if (authorityKey === undefined) {
-            throw new Error('Relocation reply relay has no registered durable authority.');
-        }
-        const authority = await requireAuthority(this.requireLocationStore(), { value: authorityKey }, signal);
-        if (authority.storeVersion.value !== relay.coordinator.expectedAuthorityStoreVersion ||
-            authority.ownerId !== relay.coordinator.ownerId ||
-            authority.ownerLeaseGeneration !== relay.coordinator.leaseGeneration ||
-            String(authority.allocation.descriptor.rid) !== relay.coordinator.nodeRid ||
-            authority.allocation.descriptorLifecycleGeneration !== relay.coordinator.nodeGeneration) {
-            throw new Error('Relocation reply relay coordinator authority fence is stale.');
-        }
-        const accepted = this.options.actorTransfer.relayCanonicalMaintenanceTerminal(wireIdText(relay.operation), relay.replyRouteId.toString(), handoffResultFromRelay(relay), sourceNodeRid);
-        if ((accepted.status !== 'terminalReceived' && accepted.status !== 'alreadyTerminal') ||
-            accepted.source === undefined) {
-            throw new Error('Canonical relocation reply relay collided with another source route.');
-        }
-        const requestSource = handoffSourceFence(accepted.source);
-        const localStatus = this.requireMeshNode(meshName).status();
+        await this.requireAdmittedPeer(meshName, sourceNodeRid, relay.coordinator, signal);
+        const node = this.requireMeshNode(meshName);
+        const localStatus = node.status();
         const localOwner = this.options.currentOwner();
-        if (localOwner === undefined ||
-            requestSource.ownerId !== localOwner.ownerId ||
-            requestSource.leaseGeneration !== localOwner.leaseGeneration ||
-            !(0, routing_id_1.routingIdsEqual)(requestSource.nodeRid, localStatus.routingId) ||
-            requestSource.nodeGeneration !== localStatus.lifecycleGeneration) {
-            throw new Error('Relocation reply relay request-source fence changed after capture.');
+        if (localOwner === undefined)
+            throw new Error('Relocation requester owner lease is unavailable.');
+        let status = node.acceptRelocatedActorTerminal?.(relay.operation, relay.replyRouteId, {
+            terminalResult: relay.terminalResult,
+            failureCode: relay.failureCode,
+            ...(relay.payload === undefined
+                ? {}
+                : {
+                    payload: {
+                        packetName: relay.payload.packetName,
+                        contentType: relay.payload.contentType,
+                        payload: Buffer.from(relay.payload.bytes)
+                    }
+                })
+        });
+        let requestSource = {
+            ownerId: localOwner.ownerId,
+            leaseGeneration: localOwner.leaseGeneration,
+            nodeRid: localStatus.routingId,
+            nodeGeneration: localStatus.lifecycleGeneration
+        };
+        if (status === undefined) {
+            const accepted = this.options.actorTransfer.relayCanonicalMaintenanceTerminal(relay.operation.high.toString(16).padStart(16, '0') +
+                relay.operation.low.toString(16).padStart(16, '0'), relay.replyRouteId.toString(), handoffResultFromRelay(relay), sourceNodeRid);
+            if (accepted.status === 'notAcknowledged' || accepted.source === undefined) {
+                throw new Error('Canonical relocation reply relay collided with another source route.');
+            }
+            requestSource = handoffSourceFence(accepted.source);
+            if (!sameRequestSource(requestSource, {
+                ownerId: localOwner.ownerId,
+                leaseGeneration: localOwner.leaseGeneration,
+                nodeRid: localStatus.routingId,
+                nodeGeneration: localStatus.lifecycleGeneration
+            }))
+                throw new Error('Relocation reply relay request-source fence changed after capture.');
+            status = accepted.status;
         }
         const ack = {
             relocation: relay.relocation,
@@ -2255,16 +2434,15 @@ class ZLinkHostServiceRelocationRuntime {
             operation: relay.operation,
             replyRouteId: relay.replyRouteId,
             requestSource,
-            status: accepted.status
+            status
         };
         if ((await this.sendInfrastructureControl(meshName, sourceNodeRid, (0, service_stateful_wire_codec_1.encodeMaintenanceReplyRelayAck)(ack))) !== runtime_values_1.SubmitResult.Ok) {
             throw new Error('Relocation reply relay ACK send was rejected.');
         }
     }
     async sendReplyRelay(meshName, ackTargetNodeRid, request, expectedRequestSource, signal) {
-        const targetRid = String(ackTargetNodeRid);
         const identityKey = replyRelayIdentityKey(request);
-        const key = replyRelayPendingKey(targetRid, request);
+        const key = replyRelayPendingKey(ackTargetNodeRid, request);
         if (this.pendingReplyRelays.has(key)) {
             throw new Error(`Relocation reply relay ACK '${key}' is already pending.`);
         }
@@ -2278,7 +2456,7 @@ class ZLinkHostServiceRelocationRuntime {
                 action();
             };
             const pending = {
-                ackTargetNodeRid: targetRid,
+                ackTargetNodeRid,
                 identityKey,
                 request,
                 expectedRequestSource,
@@ -2314,7 +2492,7 @@ class ZLinkHostServiceRelocationRuntime {
     }
     async acceptReplyRelayAck(meshName, ack, sourceNodeRid, signal) {
         const identityKey = replyRelayIdentityKey(ack);
-        const exactKey = sourceNodeRid === null ? undefined : replyRelayPendingKey(String(sourceNodeRid), ack);
+        const exactKey = sourceNodeRid === null ? undefined : replyRelayPendingKey(sourceNodeRid, ack);
         const pending = exactKey === undefined ? undefined : this.pendingReplyRelays.get(exactKey);
         if (pending === undefined) {
             const collision = [...this.pendingReplyRelays.values()].find((value) => value.identityKey === identityKey);
@@ -2337,12 +2515,12 @@ class ZLinkHostServiceRelocationRuntime {
         }
     }
     async requireAdmittedPeer(meshName, authenticatedRid, expected, signal) {
-        const descriptor = (await this.options.liveDescriptors(meshName, signal)).find((value) => String(value.rid) === authenticatedRid && value.state === 1);
+        const descriptor = (await this.options.liveDescriptors(meshName, signal)).find((value) => (0, routing_id_1.routingIdsEqual)(value.rid, authenticatedRid) && value.state === 1);
         if (descriptor === undefined ||
             (expected !== undefined &&
                 (descriptor.ownerId !== expected.ownerId ||
                     descriptor.leaseGeneration !== expected.leaseGeneration ||
-                    String(descriptor.rid) !== expected.nodeRid ||
+                    !(0, routing_id_1.routingIdsEqual)(descriptor.rid, expected.nodeRid) ||
                     descriptor.lifecycleGeneration !== expected.nodeGeneration))) {
             throw new Error('Relocation reply relay peer is not the exact admitted source fence.');
         }
@@ -2354,39 +2532,32 @@ class ZLinkHostServiceRelocationRuntime {
         if (owner === undefined ||
             owner.ownerId !== target.ownerId ||
             owner.leaseGeneration !== target.ownerLeaseGeneration ||
-            String(status.routingId) !== target.nodeRid ||
+            !(0, routing_id_1.routingIdsEqual)(status.routingId, target.nodeRid) ||
             status.lifecycleGeneration !== target.nodeGeneration) {
             throw new Error('Relocation reply relay target coordinator fence is stale.');
         }
         return {
             ownerId: owner.ownerId,
             leaseGeneration: owner.leaseGeneration,
-            nodeRid: String(status.routingId),
+            nodeRid: status.routingId,
             nodeGeneration: status.lifecycleGeneration,
             expectedAuthorityStoreVersion: authority.storeVersion.value
         };
     }
-    async relayTerminalReplies(meshName, stage, coordinator, signal) {
-        for (const [participantIndex, participant] of stage.staging.envelope.participants.entries()) {
-            const hidden = stage.staging.hidden.get(participant.key);
-            if (hidden?.actor === undefined)
-                continue;
-            for (const [resultIndex, packet] of hidden.replayPackets.entries()) {
-                if (!packet.returnResponse || packet.source === undefined)
-                    continue;
-                const result = hidden.replayResults.at(resultIndex);
-                if (result === undefined || result.index !== packet.index) {
-                    throw new Error('Relocation request result changed after target dispatch.');
-                }
-                const completion = {
-                    index: packet.index,
-                    operationId: packet.messageFollowContext.operationId,
-                    source: packet.source,
-                    result
-                };
-                await this.sendReplyRelay(meshName, packet.source.nodeRid, maintenanceReplyRelay(stage, coordinator, BigInt(participantIndex + 1), completion), handoffSourceFence(packet.source), signal);
-            }
-        }
+    async relayTerminalReply(meshName, stage, coordinator, participantId, packet, result, signal) {
+        if (!packet.returnResponse || packet.source === undefined)
+            return;
+        if (result.index !== packet.index) {
+            throw new Error('Relocation request result changed after target dispatch.');
+        }
+        const completion = {
+            index: packet.index,
+            operationId: packet.messageFollowContext.operationId,
+            source: packet.source,
+            result
+        };
+        const source = handoffSourceFence(packet.source);
+        await this.sendReplyRelay(meshName, source.nodeRid, maintenanceReplyRelay(stage, coordinator, participantId, completion, packet, this.options.registration.messageSerializers, this.options.flowCreationEnabled?.() ?? false), source, signal);
     }
     async exactSourceLeaseExpired(source, signal) {
         const lease = await this.requireLocationStore().readOwnerLease(source.ownerId, signal);
@@ -2414,7 +2585,7 @@ class ZLinkHostServiceRelocationRuntime {
         }
         const replyFrames = await this.requestInfrastructureControl(meshName, targetNodeRid, frames, remainingMs, signal, onSubmitted);
         if (replyFrames.length !== 1) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Relocation control '${key}' reply must contain exactly one frame.`);
+            throw new service_wire_m6a_codec_2.ServiceWireProtocolError(`Relocation control '${key}' reply must contain exactly one frame.`);
         }
         const response = (0, service_relocation_control_1.decodeServiceRelocationControlResponse)(Buffer.from(replyFrames[0]));
         if (response.kind === 'failed') {
@@ -2427,11 +2598,11 @@ class ZLinkHostServiceRelocationRuntime {
     async selectTarget(meshName, localRid, targetApplicationVersion, requirements = [], signal) {
         const descriptors = await this.options.liveDescriptors(meshName, signal);
         const local = this.options.localDescriptor?.(meshName) ??
-            descriptors.find((descriptor) => String(descriptor.rid) === localRid);
+            descriptors.find((descriptor) => (0, routing_id_1.routingIdsEqual)(descriptor.rid, localRid));
         const requiredVersion = targetApplicationVersion ?? local?.applicationVersion;
         const peers = this.requireMeshNode(meshName).peers();
         const candidates = descriptors
-            .filter((descriptor) => String(descriptor.rid) !== localRid &&
+            .filter((descriptor) => !(0, routing_id_1.routingIdsEqual)(descriptor.rid, localRid) &&
             descriptor.state === contracts_1.ZLinkFrameworkRuntimeState.Serving &&
             descriptor.objectRole === contracts_1.ZLinkObjectRole.Server &&
             descriptor.placementWeight > 0 &&
@@ -2439,7 +2610,7 @@ class ZLinkHostServiceRelocationRuntime {
             (local?.maintenanceWave === undefined ||
                 descriptor.maintenanceWave !== local.maintenanceWave) &&
             peers.some((peer) => peer.routingId !== null &&
-                String(peer.routingId) === String(descriptor.rid) &&
+                (0, routing_id_1.routingIdsEqual)(peer.routingId, descriptor.rid) &&
                 peer.lifecycleGeneration === descriptor.lifecycleGeneration &&
                 peer.state === service_runtime_contracts_1.MeshPeerRuntimeState.Serving) &&
             relocationTargetSupports(descriptor, requirements))
@@ -2852,19 +3023,13 @@ class ZLinkHostServiceRelocationRuntime {
     async createRelocationAdapter(adapterType) {
         return (await (0, spot_provider_1.createProviderInstance)(adapterType, this.options.providerResolver));
     }
-    recordRelocationInterruption(meshName, unitKind, executionMode, startedAt, outcome) {
+    recordRelocationInterruption(meshName, unitKind, executionMode, startedAt) {
         const seconds = Math.max(0, performance.now() - startedAt) / runtime_metrics_1.MILLISECONDS_PER_SECOND;
         const attributes = {
             unit_kind: unitKind,
             ...(executionMode === undefined ? {} : { execution_mode: executionMode })
         };
         this.options.metrics?.duration(runtime_metrics_1.METRIC_NAMES.RelocationInterruption, seconds, attributes);
-        this.options.metrics?.count(runtime_metrics_1.METRIC_NAMES.RelocationCompleted, 1, {
-            mesh_name: meshName,
-            object_kind: unitKind,
-            policy: unitKind === 'user_spot' && executionMode === 'per_actor' ? 'recreate' : 'configured',
-            outcome
-        });
         if (seconds <= 1)
             return;
         console.warn(`[zlink.runtime.relocation.changed] ${unitKind} admission interruption ` +
@@ -2907,24 +3072,25 @@ class ZLinkHostServiceRelocationRuntime {
         }
         return result;
     }
-    async commitSpotMessageFollow(meshName, seal, authorityKey, activation, target) {
+    async commitSpotMessageFollow(meshName, seal, committed, activation) {
         const node = this.requireMeshNode(meshName);
         const commit = node.commitSpotMessageFollowIngress;
         if (commit === undefined) {
             throw new Error('Spot Message Follow backend support is incomplete.');
         }
-        const committed = await requireAuthority(this.requireLocationStore(), authorityKey);
-        const accepted = await commit.call(node, seal, {
-            spot: {
-                spotId: String(activation.spotId),
-                generation: committed.objectGeneration
-            },
-            targetNodeRid: String(target.rid),
-            targetNodeGeneration: target.lifecycleGeneration,
-            authorityOwnerGeneration: committed.authorityOwnerGeneration,
-            ownerLeaseGeneration: committed.ownerLeaseGeneration,
-            storeVersion: committed.storeVersion.value
-        }, this.relocationLimits().messageFollowDurationMs);
+        const accepted = await commit.call(node, seal, committed === undefined
+            ? null
+            : {
+                spot: {
+                    spotId: String(activation.spotId),
+                    generation: committed.objectGeneration
+                },
+                targetNodeRid: String(committed.allocation.descriptor.rid),
+                targetNodeGeneration: committed.allocation.descriptorLifecycleGeneration,
+                authorityOwnerGeneration: committed.authorityOwnerGeneration,
+                ownerLeaseGeneration: committed.ownerLeaseGeneration,
+                storeVersion: committed.storeVersion.value
+            }, this.relocationLimits().messageFollowDurationMs);
         if (!accepted) {
             throw new Error(`Spot '${String(activation.spotId)}' Message Follow route became stale.`);
         }
@@ -3007,6 +3173,20 @@ class ZLinkHostServiceRelocationRuntime {
     }
 }
 exports.ZLinkHostServiceRelocationRuntime = ZLinkHostServiceRelocationRuntime;
+function committedSpotRoute(meshName, spotId, spotKind, targetNodeRid, authority) {
+    return {
+        routerChannelId: meshName,
+        targetNodeRid,
+        spotId,
+        spotKind,
+        targetSpotGeneration: authority?.objectGeneration,
+        targetNodeGeneration: authority?.allocation.descriptorLifecycleGeneration,
+        authorityOwnerGeneration: authority?.authorityOwnerGeneration,
+        targetOwnerId: authority?.ownerId,
+        ownerLeaseGeneration: authority?.ownerLeaseGeneration,
+        authorityStoreVersion: authority?.storeVersion.value
+    };
+}
 function canonicalActorJoinRecovery(participants) {
     const matches = participants.flatMap((participant) => participant.queuedMessages.flatMap((message) => {
         const recovery = (0, actor_join_recovery_codec_1.decodeCanonicalActorJoinRecoverySavedWork)(message.payload);
@@ -3062,6 +3242,9 @@ class LocalTargetPort {
     async createHidden(participant, signal) {
         const identity = (0, authority_key_codec_1.decodeAuthorityKey)({ value: participant.key }).globalId;
         if (participant.objectKind === 'actor') {
+            if (participant.timers.length !== 0) {
+                throw new Error('Actor relocation cannot restore a Spot timer.');
+            }
             const membership = this.envelope.memberships.find((value) => value.actorKey === participant.key);
             if (membership === undefined)
                 throw new Error(`Actor '${identity}' relocation membership is missing.`);
@@ -3074,20 +3257,28 @@ class LocalTargetPort {
                 participant,
                 actor,
                 initialized: false,
-                restoredTimers: [],
-                replayResults: [],
                 replayPackets: []
             };
         }
         const registration = this.registration(participant.objectKind, participant.stableType);
-        const activation = await this.requireSpotManager().prepareRelocationSpot(this.meshName, participant.objectKind, participant.stableType, registration.implementation, identity, participant.objectGeneration, participant.authorityOwnerGeneration, signal);
+        const activation = await this.requireSpotManager().prepareRelocationSpot(this.meshName, participant.objectKind, participant.stableType, registration.implementation, identity, participant.objectGeneration, participant.authorityOwnerGeneration, participant.timers.map((value) => ({
+            name: value.timerId,
+            handlerType: value.handlerType,
+            periodMs: value.intervalMs,
+            overrunPolicy: value.overrunPolicy,
+            maxCatchUpTicks: value.maxCatchUpTicks,
+            stopOnUnhandledException: value.stopOnUnhandledException,
+            startedAtUnixMs: value.startedAtUnixMs,
+            deliveryIndex: value.deliveryIndex,
+            lastScheduledIndex: value.lastScheduledIndex,
+            nextDueAtUnixMs: value.dueAtUnixMs,
+            pendingTicks: value.pendingTicks
+        })), signal);
         return {
             authorityKey: participant.key,
             participant,
             activation,
             initialized: false,
-            restoredTimers: [],
-            replayResults: [],
             replayPackets: []
         };
     }
@@ -3216,47 +3407,20 @@ class LocalTargetPort {
         hidden.replayPackets.push(packet);
     }
     async openAdmission(hidden) {
-        if (hidden.actor === undefined)
-            return;
-        this.requireActorManager().publishRelocationActor(hidden.actor.context.actorId);
-        if (hidden.replayPackets.length === 0)
-            return;
-        const state = this.requireActorManager().getState(hidden.actor.context.actorId);
-        if (state === undefined)
-            throw new Error('Relocated Actor state is not staged.');
-        const results = await (0, actor_handoff_1.replayActorHandoffBacklog)(hidden.replayPackets, (parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => {
-            if (state.spotId === undefined) {
-                const runtime = this.options.spotNodeRuntime();
-                if (runtime === undefined) {
-                    throw new Error('Relocated Entry Spot Actor dispatch is unavailable.');
-                }
-                return runtime.dispatchEntryActorPacket('remote', hidden.actor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
-            }
-            return this.requireSpotManager().dispatchRoutedActorPacket('remote', state.spotId, hidden.actor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
-        });
-        hidden.replayResults.push(...results);
+        if (hidden.actor !== undefined) {
+            this.requireActorManager().publishRelocationActor(hidden.actor.context.actorId);
+            this.requireSpotManager().openActorJoinRelocation(this.meshName, actorJoinAdmissionIdentity(this.envelope), hidden.actor);
+        }
     }
-    async restoreTimer(hidden, timer) {
-        if (hidden.activation === undefined)
-            throw new Error('Actor relocation cannot restore a Spot timer.');
-        hidden.restoredTimers.push(timer);
-        if (hidden.restoredTimers.length !== hidden.participant.timers.length)
+    async normalize(hidden) {
+        if (hidden.actor === undefined || hidden.replayPackets.length === 0)
             return;
-        hidden.activation.timers.restoreRelocation(hidden.restoredTimers.map((value) => ({
-            name: value.timerId,
-            handlerType: value.handlerType,
-            periodMs: value.intervalMs,
-            overrunPolicy: value.overrunPolicy,
-            maxCatchUpTicks: value.maxCatchUpTicks,
-            stopOnUnhandledException: value.stopOnUnhandledException,
-            startedAtUnixMs: value.startedAtUnixMs,
-            deliveryIndex: value.deliveryIndex,
-            lastScheduledIndex: value.lastScheduledIndex,
-            nextDueAtUnixMs: value.dueAtUnixMs,
-            pendingTicks: value.pendingTicks
-        })));
+        if (hidden.replayStart === undefined || hidden.onReplayResult === undefined) {
+            throw new Error('Relocated Actor backlog has no target activation owner.');
+        }
+        this.options.actorTransfer.admitRelocationPrefix(hidden.actor, hidden.participant.objectGeneration, hidden.replayPackets, hidden.replayStart, hidden.onReplayResult);
+        hidden.replayPackets.length = 0;
     }
-    async normalize(_hidden) { }
     async abort(hidden) {
         if (hidden.actor !== undefined) {
             await this.requireActorManager().abortRelocationActor(hidden.actor.context.actorId);
@@ -3407,6 +3571,19 @@ function decodeQueuedHandoffPacket(message) {
             ...(messageFollowOrigin === undefined ? {} : { messageFollowOrigin })
         }
     ])[0];
+    const requestSource = decoded.source === undefined ? undefined : handoffSourceFence(decoded.source);
+    if (messageFollowOrigin !== undefined &&
+        requestSource !== undefined &&
+        (0, routing_id_1.routingIdsEqual)(messageFollowOrigin.sourceNodeRid, requestSource.nodeRid)) {
+        return {
+            ...decoded,
+            index: index,
+            messageFollowOrigin: {
+                ...messageFollowOrigin,
+                requestSource
+            }
+        };
+    }
     return { ...decoded, index: index };
 }
 /**
@@ -3549,28 +3726,18 @@ function createServiceRelocationId(isInUse, entropy = node_crypto_1.randomBytes)
             return candidate;
     }
 }
-function operationWireId(value) {
-    const match = /^(\d+):(\d+)$/.exec(value);
-    if (match === null)
-        throw new Error(`Actor handoff operation '${value}' is not canonical.`);
-    const result = { high: BigInt(match[1]), low: BigInt(match[2]) };
-    if (result.high === 0n && result.low === 0n) {
-        throw new Error('Actor handoff operation identity must not be zero.');
-    }
-    return result;
-}
 function sameWireId(left, right) {
     return left.high === right.high && left.low === right.low;
 }
 function sameCoordinator(left, right) {
     return (left.ownerId === right.ownerId &&
         BigInt(left.leaseGeneration) === right.leaseGeneration &&
-        left.nodeRid === right.nodeRid &&
+        (0, routing_id_1.routingIdsEqual)(left.nodeRid, right.nodeRid) &&
         BigInt(left.nodeGeneration) === right.nodeGeneration &&
         left.expectedAuthorityStoreVersion === right.expectedAuthorityStoreVersion);
 }
 function sameRelocationTarget(left, right) {
-    return (left.nodeRid === right.nodeRid &&
+    return ((0, routing_id_1.routingIdsEqual)(left.nodeRid, right.nodeRid) &&
         BigInt(left.nodeGeneration) === right.nodeGeneration &&
         left.ownerId === right.ownerId &&
         BigInt(left.ownerLeaseGeneration) === right.ownerLeaseGeneration);
@@ -3604,7 +3771,7 @@ function isSourceOwner(current, expected) {
         current.allocation.state === expected.allocation.state &&
         current.allocation.objectKind === expected.allocation.objectKind &&
         current.allocation.stableType === expected.allocation.stableType &&
-        String(current.allocation.descriptor.rid) === String(expected.allocation.descriptor.rid) &&
+        (0, routing_id_1.routingIdsEqual)(current.allocation.descriptor.rid, expected.allocation.descriptor.rid) &&
         current.allocation.descriptorLifecycleGeneration ===
             expected.allocation.descriptorLifecycleGeneration);
 }
@@ -3613,7 +3780,7 @@ function isExactCommittedTarget(current, expected, target, payload) {
         current.authorityOwnerGeneration > expected.authorityOwnerGeneration &&
         current.ownerId === target.ownerId &&
         current.ownerLeaseGeneration === target.ownerLeaseGeneration &&
-        String(current.allocation.descriptor.rid) === target.nodeRid &&
+        (0, routing_id_1.routingIdsEqual)(current.allocation.descriptor.rid, target.nodeRid) &&
         current.allocation.descriptorLifecycleGeneration === target.nodeGeneration &&
         Buffer.from(current.payload).equals(Buffer.from(payload)));
 }
@@ -3636,40 +3803,52 @@ async function waitForRelocationRetry(delayMs, signal) {
 function sameRequestSource(left, right) {
     return (left.ownerId === right.ownerId &&
         left.leaseGeneration === right.leaseGeneration &&
-        left.nodeRid === right.nodeRid &&
+        (0, routing_id_1.routingIdsEqual)(left.nodeRid, right.nodeRid) &&
         left.nodeGeneration === right.nodeGeneration);
 }
 function handoffSourceFence(value) {
     return {
         ownerId: value.ownerId,
         leaseGeneration: BigInt(value.ownerLeaseGeneration),
-        nodeRid: value.nodeRid,
+        nodeRid: (0, routing_id_1.decodeRoutingId)(value.nodeRid, value.nodeRidHex),
         nodeGeneration: BigInt(value.nodeGeneration)
     };
 }
-function maintenanceReplyRelay(stage, coordinator, participantId, completion) {
+function maintenanceReplyRelay(stage, coordinator, participantId, completion, packet, serializers, flowEnabled) {
     const value = completion.result.ok ? completion.result.response : undefined;
+    const direct = packet.messageFollowOrigin?.requestSource !== undefined;
+    const application = direct && completion.result.ok
+        ? (0, service_wire_m6a_codec_1.decodeApplicationPayloadView)((0, service_wire_m6a_codec_1.encodeMultipartApplicationPayload)((0, actor_reply_1.encodeActorReply)(Buffer.from(packet.header, 'base64'), protocol_1.ZLinkStreamMessageKind.Response, value, serializers, flowEnabled), service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_PACKET_NAME, service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE))
+        : undefined;
     return {
         relocation: relocationWireId(stage.staging.envelope.aggregateId),
         targetAttemptGeneration: stage.offer.prepare.targetAttemptGeneration,
         coordinator,
-        operation: operationWireId(completion.operationId),
+        operation: parseHandoffOperationId(completion.operationId),
         replyRouteId: BigInt(completion.source.replyRouteId),
         participantId,
         sequence: BigInt(completion.index + 1),
         terminalResult: completion.result.ok ? runtime_values_1.RequestResult.Ok : runtime_values_1.RequestResult.InternalError,
         failureCode: completion.result.ok
-            ? service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.none
-            : service_wire_constants_generated_1.ServiceWireFrameworkErrorCode.requestFailed,
-        ...(value === undefined
-            ? {}
-            : {
+            ? service_wire_constants_generated_2.ServiceWireFrameworkErrorCode.none
+            : service_wire_constants_generated_2.ServiceWireFrameworkErrorCode.requestFailed,
+        ...(application !== undefined
+            ? {
                 payload: {
-                    packetName: SERVICE_RELOCATION_REPLY_PACKET_NAME,
-                    contentType: stream_wire_1.ZlinkStreamContentType.Json,
-                    bytes: Buffer.from(JSON.stringify(value), 'utf8')
+                    packetName: application.packetName,
+                    contentType: application.contentType,
+                    bytes: application.payload
                 }
-            })
+            }
+            : value === undefined
+                ? {}
+                : {
+                    payload: {
+                        packetName: SERVICE_RELOCATION_REPLY_PACKET_NAME,
+                        contentType: stream_wire_1.ZlinkStreamContentType.Json,
+                        bytes: Buffer.from(JSON.stringify(value), 'utf8')
+                    }
+                })
     };
 }
 function handoffResultFromRelay(relay) {
@@ -3701,6 +3880,13 @@ function wireIdText(value) {
 class ServiceRelocationDataLostError extends Error {
 }
 exports.ServiceRelocationDataLostError = ServiceRelocationDataLostError;
+/** The local source lifecycle ended a pending relocation operation. */
+class ServiceRelocationRuntimeStoppedError extends Error {
+    constructor() {
+        super('Relocation runtime stopped.');
+        this.name = 'AbortError';
+    }
+}
 /** Classifies relocation failure with the error model §2.1 mapping. */
 function relocationFailedFailureCode(error) {
     if (error instanceof ServiceRelocationDataLostError) {
@@ -3806,7 +3992,7 @@ function validatePrepareEnvelope(request, envelope) {
 }
 function validateTargetOneWayControl(stage, request, sourceNodeRid) {
     const prepare = stage.offer.prepare;
-    if (String(sourceNodeRid) !== stage.offer.authenticatedSourceNodeRid ||
+    if (!(0, routing_id_1.routingIdsEqual)(sourceNodeRid, stage.offer.authenticatedSourceNodeRid) ||
         !sameWireId(request.relocation, prepare.relocation) ||
         request.targetAttemptGeneration !== prepare.targetAttemptGeneration ||
         !sameCoordinator(request.coordinator, prepare.coordinator) ||
@@ -3863,12 +4049,7 @@ function canonicalQueuedFrozenRecord(participant, message, coordinator, target)
     const identity = (0, authority_key_codec_1.decodeAuthorityKey)({ value: participant.key }).globalId;
     const source = packet.source === undefined
         ? coordinatorSource(coordinator)
-        : {
-            ownerId: packet.source.ownerId,
-            leaseGeneration: BigInt(packet.source.ownerLeaseGeneration),
-            nodeRid: packet.source.nodeRid,
-            nodeGeneration: BigInt(packet.source.nodeGeneration)
-        };
+        : handoffSourceFence(packet.source);
     const operationId = parseHandoffOperationId(packet.messageFollowContext.operationId);
     if (packet.returnResponse && packet.source === undefined) {
         throw new Error('Captured Actor request has no exact request-source fence.');
@@ -3971,43 +4152,40 @@ function sessionRelocationPendingKey(request) {
     return sessionRelocationIdentityKey(request);
 }
 function sessionRelocationRouteSubmitKey(request, targetNodeRid) {
-    return `${sessionRelocationIdentityKey(request)}:${String(targetNodeRid)}`;
+    return `${sessionRelocationIdentityKey(request)}:${(0, routing_id_1.encodeRoutingIdStorageHex)(targetNodeRid)}`;
 }
 function sessionRelocationResponseKey(response) {
     return sessionRelocationIdentityKey(response);
 }
-function sessionRelocationResponseFingerprint(response) {
-    return (0, service_stateful_wire_codec_1.encodeSessionRelocationSealed)(response).toString('base64');
-}
 function sessionRelocationIdentityKey(value) {
     return `session-relocation:${(0, service_stateful_wire_codec_1.serviceSessionRelocationIdentityKey)(value)}:sealed`;
 }
 function validateSessionRelocationResponse(request, response) {
     const sameCoordinator = request.coordinator.ownerId === response.coordinator.ownerId &&
         request.coordinator.leaseGeneration === response.coordinator.leaseGeneration &&
-        request.coordinator.nodeRid === response.coordinator.nodeRid &&
+        (0, routing_id_1.routingIdsEqual)(request.coordinator.nodeRid, response.coordinator.nodeRid) &&
         request.coordinator.nodeGeneration === response.coordinator.nodeGeneration &&
         request.coordinator.expectedAuthorityStoreVersion ===
             response.coordinator.expectedAuthorityStoreVersion;
-    const sameSession = request.session.sessionOwnerNodeRid === response.session.sessionOwnerNodeRid &&
+    const sameSession = (0, routing_id_1.routingIdsEqual)(request.session.sessionOwnerNodeRid, response.session.sessionOwnerNodeRid) &&
         request.session.sessionOwnerNodeGeneration === response.session.sessionOwnerNodeGeneration &&
         request.session.sessionOwnerId === response.session.sessionOwnerId &&
         request.session.sessionOwnerLeaseGeneration === response.session.sessionOwnerLeaseGeneration &&
-        request.session.sessionRid === response.session.sessionRid &&
+        (0, routing_id_1.routingIdsEqual)(request.session.sessionRid, response.session.sessionRid) &&
         request.session.bindingGeneration === response.session.bindingGeneration;
     if (request.relocation.high !== response.relocation.high ||
         request.relocation.low !== response.relocation.low ||
         !sameCoordinator ||
         !sameSession) {
-        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Session relocation ACK changed its exact fence.');
+        throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Session relocation ACK changed its exact fence.');
     }
     if (request.actor.actor.actorId !== response.actor.actor.actorId ||
         request.actor.actor.generation !== response.actor.actor.generation ||
-        request.actor.actor.nodeRid !== response.actor.actor.nodeRid ||
+        !(0, routing_id_1.routingIdsEqual)(request.actor.actor.nodeRid, response.actor.actor.nodeRid) ||
         request.actor.targetNodeGeneration !== response.actor.targetNodeGeneration ||
         request.actor.authorityOwnerGeneration !== response.actor.authorityOwnerGeneration ||
         request.actor.ownerLeaseGeneration !== response.actor.ownerLeaseGeneration) {
-        throw new service_wire_m6a_codec_1.ServiceWireProtocolError('Command 43 ACK does not echo command 42.');
+        throw new service_wire_m6a_codec_2.ServiceWireProtocolError('Command 43 ACK does not echo command 42.');
     }
 }
 function replyRelayIdentityKey(value) {
@@ -4019,13 +4197,16 @@ function replyRelayIdentityKey(value) {
         value.relocation.low.toString(),
         value.coordinator.ownerId,
         value.coordinator.leaseGeneration.toString(),
-        value.coordinator.nodeRid,
+        (0, routing_id_1.encodeRoutingIdStorageHex)(value.coordinator.nodeRid),
         value.coordinator.nodeGeneration.toString(),
         value.coordinator.expectedAuthorityStoreVersion
     ]);
 }
 function replyRelayPendingKey(ackTargetNodeRid, value) {
-    return JSON.stringify([ackTargetNodeRid, replyRelayIdentityKey(value)]);
+    return JSON.stringify([
+        (0, routing_id_1.encodeRoutingIdStorageHex)(ackTargetNodeRid),
+        replyRelayIdentityKey(value)
+    ]);
 }
 function encodeHandoffQueuedMessages(backlog) {
     return backlog.map((packet) => ({
@@ -4151,6 +4332,7 @@ function encodeActorSession(target) {
         version: ACTOR_SESSION_JOURNAL_VERSION,
         routerChannelId: target.routerChannelId,
         targetNodeRid: String(target.targetNodeRid),
+        targetNodeRidHex: (0, routing_id_1.encodeRoutingIdStorageHex)(target.targetNodeRid),
         spotId: String(target.spotId),
         sessionNodeRid: target.sessionNodeRid === undefined ? undefined : String(target.sessionNodeRid),
         sessionNodeRidHex: target.sessionNodeRid === undefined
@@ -4172,15 +4354,16 @@ function encodeActorSession(target) {
                 relocationLow: target.serviceWireRelocation.relocation.low.toString(),
                 coordinatorOwnerId: target.serviceWireRelocation.coordinator.ownerId,
                 coordinatorLeaseGeneration: target.serviceWireRelocation.coordinator.leaseGeneration.toString(),
-                coordinatorNodeRid: target.serviceWireRelocation.coordinator.nodeRid,
+                coordinatorNodeRid: String(target.serviceWireRelocation.coordinator.nodeRid),
+                coordinatorNodeRidHex: (0, routing_id_1.encodeRoutingIdStorageHex)(target.serviceWireRelocation.coordinator.nodeRid),
                 coordinatorNodeGeneration: target.serviceWireRelocation.coordinator.nodeGeneration.toString(),
                 expectedAuthorityStoreVersion: target.serviceWireRelocation.coordinator.expectedAuthorityStoreVersion,
-                sessionOwnerNodeRid: target.serviceWireRelocation.session.sessionOwnerNodeRid,
+                sessionOwnerNodeRid: String(target.serviceWireRelocation.session.sessionOwnerNodeRid),
                 sessionOwnerNodeRidHex: (0, routing_id_1.encodeRoutingIdStorageHex)(target.serviceWireRelocation.session.sessionOwnerNodeRid),
                 sessionOwnerNodeGeneration: target.serviceWireRelocation.session.sessionOwnerNodeGeneration.toString(),
                 sessionOwnerId: target.serviceWireRelocation.session.sessionOwnerId,
                 sessionOwnerLeaseGeneration: target.serviceWireRelocation.session.sessionOwnerLeaseGeneration.toString(),
-                sessionRid: target.serviceWireRelocation.session.sessionRid,
+                sessionRid: String(target.serviceWireRelocation.session.sessionRid),
                 sessionRidHex: (0, routing_id_1.encodeRoutingIdStorageHex)(target.serviceWireRelocation.session.sessionRid),
                 bindingGeneration: target.serviceWireRelocation.session.bindingGeneration.toString()
             }
@@ -4200,7 +4383,7 @@ function decodeActorSession(payload) {
     const serviceWire = decodeActorSessionServiceWireFence(value.serviceWireRelocation);
     return {
         routerChannelId: value.routerChannelId,
-        targetNodeRid: value.targetNodeRid,
+        targetNodeRid: (0, routing_id_1.decodeRoutingId)(value.targetNodeRid, value.targetNodeRidHex),
         spotId: value.spotId,
         ...(typeof value.sessionNodeRid === 'string'
             ? { sessionNodeRid: (0, routing_id_1.decodeRoutingId)(value.sessionNodeRid, value.sessionNodeRidHex) }
@@ -4269,7 +4452,7 @@ function decodeActorSessionServiceWireFence(input) {
         coordinator: {
             ownerId: text('coordinatorOwnerId'),
             leaseGeneration: positive('coordinatorLeaseGeneration'),
-            nodeRid: text('coordinatorNodeRid'),
+            nodeRid: (0, routing_id_1.decodeRoutingId)(text('coordinatorNodeRid'), value.coordinatorNodeRidHex),
             nodeGeneration: positive('coordinatorNodeGeneration'),
             expectedAuthorityStoreVersion: text('expectedAuthorityStoreVersion')
         },