@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/host/actor-transfer-runtime.js

@@ -57,7 +57,6 @@ function createHandoffReplayGate() {
 }
 class ZLinkActorTransferRuntime {
     options;
-    coreSourceLeaves = new Map();
     //  Spot Actor membership sections 4-5: Join completion idempotency is
     //  process-local. These maps end with the process; nothing is replayed.
     activeDeferredJoinTerminals = new Map();
@@ -69,8 +68,15 @@ class ZLinkActorTransferRuntime {
         const actorId = actor.context.actorId;
         this.options.actorHandoff.beginProvisional(actorId, requireSourceObjectGeneration(actorId, state));
     }
-    promoteDeferredActorHandoff(actor, _state) {
-        this.options.actorHandoff.promoteProvisional(actor.context.actorId);
+    /** Relocation activation owns admission; handler terminals are observed independently. */
+    admitRelocationPrefix(actor, objectGeneration, packets, start, onResult) {
+        const manager = this.options.spotManager();
+        if (manager === undefined)
+            throw new Error('Relocated Actor has no local FIFO owner.');
+        const admitted = this.options.actorHandoff.admitTransferredPrefix(actor.context.actorId, objectGeneration, packets, (records) => manager.admitSourceActorPacketPrefix(actor.context.actorId, records), this.options.prepareApplicationJob, start, (packet, result) => {
+            void this.observeHandoffReplay(onResult(packet, result));
+        });
+        void this.observeHandoffReplay(admitted.terminal);
     }
     async completeDeferredActorHandoff(actor, target, _targetActorRef) {
         const actorId = actor.context.actorId;
@@ -83,8 +89,8 @@ class ZLinkActorTransferRuntime {
         const admitted = this.options.actorHandoff.admitDeferredPrefix(actorId, (drain) => manager.admitRoutedActorPacketPrefix(target.spotId, actorId, drain), this.options.prepareApplicationJob);
         void this.observeHandoffReplay(admitted.terminal);
     }
-    async cancelDeferredActorHandoff(actor, state) {
-        const admitted = this.admitDeferredSourcePrefix(actor, state);
+    async cancelDeferredActorHandoff(actor, _state) {
+        const admitted = this.admitDeferredSourcePrefix(actor);
         void this.observeHandoffReplay(admitted.terminal);
     }
     prepareDeferredJoinAccepted(actorId, operationId, actorRef, rawReply, replyContentType) {
@@ -162,20 +168,7 @@ class ZLinkActorTransferRuntime {
         }
         await this.options.notifyEntrySpotActorLeft(actor, signal);
     }
-    async restoreSourceActor(actor, sourceSpotId, signal) {
-        if (sourceSpotId !== undefined) {
-            const manager = this.options.spotManager();
-            if (manager !== undefined) {
-                await manager.restoreActorAfterFailedTransfer(sourceSpotId, actor, signal);
-                return;
-            }
-        }
-        await this.options.restoreEntrySpotActorJoined(actor, signal);
-    }
-    async beginSourceActorMove(actor, state, deferredJoin = false) {
-        if (deferredJoin && this.options.actorHandoff.isProvisional(actor.context.actorId)) {
-            this.promoteDeferredActorHandoff(actor, state);
-        }
+    async beginSourceActorMove(actor, state) {
         state.beginMove();
         if (!this.options.actorHandoff.isActive(actor.context.actorId)) {
             this.options.actorHandoff.begin(actor.context.actorId, requireSourceObjectGeneration(actor.context.actorId, state));
@@ -198,18 +191,12 @@ class ZLinkActorTransferRuntime {
             }
         }
         catch (error) {
-            if (!deferredJoin) {
-                this.options.actorHandoff.cancel(actor.context.actorId);
-            }
-            else {
-                const admitted = this.admitDeferredSourcePrefix(actor, state);
-                void this.observeHandoffReplay(admitted.terminal);
-            }
+            this.options.actorHandoff.cancel(actor.context.actorId);
             state.endMove();
             throw error;
         }
     }
-    async cancelSourceActorMove(actor, state, deferredJoin = false, replayStart = Promise.resolve()) {
+    async cancelSourceActorMove(actor, state, replayStart = Promise.resolve()) {
         try {
             if (state.spotId !== undefined) {
                 await this.options.spotManager()?.cancelActorTransfer(state.spotId, actor.context.actorId);
@@ -217,38 +204,32 @@ class ZLinkActorTransferRuntime {
         }
         finally {
             try {
-                if (!deferredJoin) {
-                    const admitted = this.admitCanceledSourcePrefix(actor, state, replayStart);
-                    void this.observeHandoffReplay(admitted.terminal);
-                }
-                else {
-                    const admitted = this.admitDeferredSourcePrefix(actor, state, replayStart);
-                    void this.observeHandoffReplay(admitted.terminal);
-                }
+                const admitted = this.admitCanceledSourcePrefix(actor, replayStart);
+                void this.observeHandoffReplay(admitted.terminal);
             }
             finally {
                 state.endMove();
             }
         }
     }
-    admitCanceledSourcePrefix(actor, state, replayStart = Promise.resolve()) {
+    admitCanceledSourcePrefix(actor, replayStart = Promise.resolve()) {
         // The seal-era ingress hold returns to the source queue on a precommit
         // abort. Rejection stays reserved for a source Actor whose dispatch is
         // gone, because held packets then have no queue left to return to.
-        const queue = this.sourceHandoffPrefixQueue(actor, state);
-        if (queue === undefined) {
+        const manager = this.options.spotManager();
+        if (manager === undefined) {
             this.options.actorHandoff.cancel(actor.context.actorId);
             return { terminal: Promise.resolve() };
         }
-        return this.options.actorHandoff.admitCanceledPrefix(actor.context.actorId, queue, this.options.prepareApplicationJob, replayStart);
+        return this.options.actorHandoff.admitCanceledPrefix(actor.context.actorId, (records) => manager.admitSourceActorPacketPrefix(actor.context.actorId, records), this.options.prepareApplicationJob, replayStart);
     }
-    admitDeferredSourcePrefix(actor, state, replayStart = Promise.resolve()) {
-        const queue = this.sourceHandoffPrefixQueue(actor, state);
-        if (queue === undefined) {
+    admitDeferredSourcePrefix(actor, replayStart = Promise.resolve()) {
+        const manager = this.options.spotManager();
+        if (manager === undefined) {
             this.options.actorHandoff.cancel(actor.context.actorId);
             return { terminal: Promise.resolve() };
         }
-        return this.options.actorHandoff.admitDeferredPrefix(actor.context.actorId, queue, this.options.prepareApplicationJob, replayStart);
+        return this.options.actorHandoff.admitDeferredPrefix(actor.context.actorId, (records) => manager.admitSourceActorPacketPrefix(actor.context.actorId, records), this.options.prepareApplicationJob, replayStart);
     }
     async observeHandoffReplay(release) {
         try {
@@ -266,175 +247,48 @@ class ZLinkActorTransferRuntime {
             }
         }
     }
-    sourceHandoffPrefixQueue(actor, state) {
-        const sourceSpotId = state.spotId;
-        const manager = this.options.spotManager();
-        if (sourceSpotId === undefined || manager === undefined) {
-            return undefined;
+    async prepareMaintenanceSession(actor, state, signal, manageMembership = true, relocation, relocationTarget) {
+        if ((0, diagnostics_1.isRelocationDebugEnabled)()) {
+            (0, diagnostics_1.relocationDebug)('maintenance_session.begin', {
+                actorId: actor.context.actorId,
+                spotId: state.spotId === undefined ? undefined : String(state.spotId)
+            });
         }
-        return (drain) => manager.admitRoutedActorPacketPrefix(sourceSpotId, actor.context.actorId, drain);
-    }
-    async prepareSource(actor, state, signal, lifecycleAuthority = 'framework', deferredJoin = false, relocation) {
-        await this.beginSourceActorMove(actor, state, deferredJoin);
-        const relocationMetric = state.meshName === undefined
-            ? undefined
-            : this.options.metrics?.startRelocation(state.meshName, 'actor', this.options.actorTransferRegistry.policy(state.actorType));
-        const sourceSpotId = state.spotId;
-        let sourceLeaveStarted = false;
-        // The relocation operation owns its Session seal; the Actor keeps only
-        // its current binding (Session–Actor binding §8.1).
-        let sealedSession;
+        // Relocation 04 §4.1: the Session owner seals a bound Actor's binding
+        // (command 42/43) before the source stops that Actor's application
+        // dispatch, so Session messages that arrive after the seal wait at the
+        // Session owner and never enter the source handoff backlog. A failed seal
+        // leaves the source dispatching; a dispatch stop that fails after the seal
+        // releases the matching seal with command 44 abort. The relocation
+        // operation owns this seal; the Actor keeps only its current binding
+        // (Session–Actor binding §8.1).
+        const bound = state.boundSession !== undefined;
+        const sealedSession = bound
+            ? await this.sealBoundSessionRoute(actor, state, signal, relocation, relocationTarget)
+            : undefined;
         try {
-            if (state.boundSession !== undefined) {
-                sealedSession = await this.sealBoundSessionRoute(actor, state, signal, relocation);
-                this.options.actorHandoff.sealConnectionBoundIngress(actor.context.actorId);
+            if (manageMembership) {
+                await this.beginSourceActorMove(actor, state);
             }
-            const transfer = await this.options.actorTransferRegistry.transferOut(actor, state.actorType, signal);
-            // The captured state is handed off inline with the join request; the
-            // Relocation Store no longer carries relocation state payloads
-            // (spec 28 §2 — direct transfer is the only handoff original).
-            relocationMetric?.recordBytes(transfer.state.toEncodedPayload().toBytes().byteLength);
-            if (lifecycleAuthority === 'framework') {
-                sourceLeaveStarted = true;
-                await this.prepareSourceActorLeave(actor, sourceSpotId, signal);
+            else {
+                state.beginMove();
+                this.options.actorHandoff.begin(actor.context.actorId, requireSourceObjectGeneration(actor.context.actorId, state));
             }
-            const coreSourceLeave = lifecycleAuthority === 'core'
-                ? this.beginCoreSourceLeave(actor.context.actorId)
-                : undefined;
-            const sourceLeaveCompletion = coreSourceLeave?.completion;
-            const handoffBacklog = lifecycleAuthority === 'core'
-                ? this.options.actorHandoff.snapshotCoreBacklog(actor.context.actorId)
-                : this.options.actorHandoff.snapshot(actor.context.actorId);
-            let phase = 'prepared';
-            let committedTargetOwnerFence;
-            return {
-                ...transfer,
-                handoffBacklog,
-                sourceLeaveCompletion,
-                sourceLeaveSubmitted: coreSourceLeave?.submitted,
-                onSourceLeaveSubmitted: (notify) => {
-                    const pending = this.coreSourceLeaves.get(actor.context.actorId);
-                    if (pending === undefined) {
-                        throw new Error(`Actor '${actor.context.actorId}' has no pending Core source leave.`);
-                    }
-                    pending.notifySubmitted = notify;
-                },
-                observeTargetAuthority: async (target, targetActorRef, observeSignal) => {
-                    const authority = this.options.authorityStore();
-                    if (authority === undefined ||
-                        target.targetOwnerId === undefined ||
-                        target.ownerLeaseGeneration === undefined ||
-                        target.targetNodeGeneration === undefined) {
-                        throw new Error(`Actor '${actor.context.actorId}' relocation target has no complete authority fence.`);
-                    }
-                    const committed = await authority.readAuthority((0, authority_key_codec_1.encodeAuthorityKey)('actor', actor.context.actorId), observeSignal);
-                    if (committed.kind !== 'snapshot' ||
-                        committed.ownerId !== target.targetOwnerId ||
-                        committed.ownerLeaseGeneration !== target.ownerLeaseGeneration ||
-                        committed.allocation.descriptorLifecycleGeneration !== target.targetNodeGeneration ||
-                        !(0, routing_id_1.routingIdsEqual)(committed.allocation.descriptor.rid, target.targetNodeRid) ||
-                        committed.objectGeneration !== targetActorRef.objectGeneration) {
-                        throw new Error(`Actor '${actor.context.actorId}' relocation target authority was not committed exactly.`);
-                    }
-                    committedTargetOwnerFence = committedActorOwnerFence(actor.context.actorId, targetActorRef, committed);
-                },
-                commit: (target, targetActorRef, results, releaseLocation = true) => {
-                    if (phase !== 'prepared')
-                        return;
-                    if (committedTargetOwnerFence === undefined) {
-                        throw new Error(`Actor '${actor.context.actorId}' handoff has no committed target authority fence.`);
-                    }
-                    phase = 'committed';
-                    relocationMetric?.complete('completed');
-                    try {
-                        this.options.actorHandoff.complete(actor.context.actorId, target, targetActorRef, results, committedTargetOwnerFence);
-                    }
-                    catch (error) {
-                        // The target has already committed. Local Message Follow setup is now
-                        // post-commit work and must not turn the accepted transfer into a
-                        // source rollback that can no longer undo the target.
-                        this.options.reportPostCommitError?.(error);
-                    }
-                    finally {
-                        const releaseSourceLocation = lifecycleAuthority === 'core' && releaseLocation;
-                        if (releaseSourceLocation && sourceLeaveCompletion !== undefined) {
-                            // Core sends the source leave control after the authority
-                            // transition. Keep the source shell available for that
-                            // callback, then release the old location and registry entry.
-                            void sourceLeaveCompletion.then(() => this.scheduleSourceDeparture(actor, sourceSpotId, true), (error) => {
-                                this.scheduleSourceDeparture(actor, sourceSpotId, true, [error]);
-                            });
-                        }
-                        else {
-                            this.scheduleSourceDeparture(actor, sourceSpotId, releaseSourceLocation);
-                        }
-                    }
-                },
-                rollback: async () => {
-                    if (phase !== 'prepared')
-                        return;
-                    phase = 'rolledBack';
-                    relocationMetric?.complete('aborted');
-                    this.coreSourceLeaves.delete(actor.context.actorId);
-                    const replayGate = createHandoffReplayGate();
-                    try {
-                        await this.cancelSourceActorMove(actor, state, deferredJoin, replayGate.start);
-                        await this.restoreSourceActor(actor, sourceSpotId);
-                        if (sealedSession !== undefined) {
-                            await this.observeBoundSessionSealAbort(actor, state, sealedSession);
-                        }
-                    }
-                    finally {
-                        replayGate.open();
-                    }
-                }
-            };
         }
         catch (error) {
-            relocationMetric?.complete('failed');
-            const replayGate = createHandoffReplayGate();
-            try {
-                await this.cancelSourceActorMove(actor, state, deferredJoin, replayGate.start);
-                if (sourceLeaveStarted)
-                    await this.restoreSourceActor(actor, sourceSpotId);
-                if (sealedSession !== undefined) {
-                    await this.observeBoundSessionSealAbort(actor, state, sealedSession);
-                }
-            }
-            catch (rollbackError) {
-                throw new AggregateError([error, rollbackError], 'Actor source leave and rollback both failed.');
-            }
-            finally {
-                replayGate.open();
+            if (sealedSession !== undefined) {
+                await this.observeBoundSessionSealAbort(actor, state, sealedSession);
             }
             throw error;
         }
-    }
-    async prepareMaintenanceSession(actor, state, signal, manageMembership = true, relocation) {
-        if ((0, diagnostics_1.isRelocationDebugEnabled)()) {
-            (0, diagnostics_1.relocationDebug)('maintenance_session.begin', {
-                actorId: actor.context.actorId,
-                spotId: state.spotId === undefined ? undefined : String(state.spotId)
-            });
-        }
-        if (manageMembership) {
-            await this.beginSourceActorMove(actor, state);
-        }
-        else {
-            state.beginMove();
-            this.options.actorHandoff.begin(actor.context.actorId, requireSourceObjectGeneration(actor.context.actorId, state));
-        }
+        if (bound)
+            this.options.actorHandoff.sealConnectionBoundIngress(actor.context.actorId);
         if ((0, diagnostics_1.isRelocationDebugEnabled)()) {
             (0, diagnostics_1.relocationDebug)('maintenance_session.source_move_complete', {
                 actorId: actor.context.actorId
             });
         }
-        let sealedSession;
         try {
-            if (state.boundSession !== undefined) {
-                sealedSession = await this.sealBoundSessionRoute(actor, state, signal, relocation);
-                this.options.actorHandoff.sealConnectionBoundIngress(actor.context.actorId);
-            }
             const handoffBacklog = this.options.actorHandoff.snapshot(actor.context.actorId);
             let terminal = 'prepared';
             let replayResults = [];
@@ -492,11 +346,11 @@ class ZLinkActorTransferRuntime {
                     const replayGate = createHandoffReplayGate();
                     try {
                         if (manageMembership) {
-                            await this.cancelSourceActorMove(actor, state, undefined, replayGate.start);
+                            await this.cancelSourceActorMove(actor, state, replayGate.start);
                         }
                         else {
                             try {
-                                const admitted = this.admitCanceledSourcePrefix(actor, state, replayGate.start);
+                                const admitted = this.admitCanceledSourcePrefix(actor, replayGate.start);
                                 void this.observeHandoffReplay(admitted.terminal);
                             }
                             finally {
@@ -519,14 +373,14 @@ class ZLinkActorTransferRuntime {
             try {
                 if (manageMembership) {
                     try {
-                        await this.cancelSourceActorMove(actor, state, undefined, replayGate.start);
+                        await this.cancelSourceActorMove(actor, state, replayGate.start);
                         sourceRestored = true;
                     }
                     catch { }
                 }
                 else {
                     try {
-                        const admitted = this.admitCanceledSourcePrefix(actor, state, replayGate.start);
+                        const admitted = this.admitCanceledSourcePrefix(actor, replayGate.start);
                         void this.observeHandoffReplay(admitted.terminal);
                         sourceRestored = true;
                     }
@@ -548,39 +402,6 @@ class ZLinkActorTransferRuntime {
             throw error;
         }
     }
-    async notifyCoreSourceLeave(actor, callback) {
-        const pending = this.coreSourceLeaves.get(actor.context.actorId);
-        let callbackResult;
-        try {
-            callbackResult = Promise.resolve(callback());
-        }
-        catch (error) {
-            callbackResult = Promise.reject(error);
-        }
-        // Submission, not the callback result, releases the target Join. Observe
-        // a fast rejection while the submission ACK is in flight without making
-        // that rejection an unhandled promise.
-        void callbackResult.catch(() => { });
-        try {
-            if (pending !== undefined) {
-                if (pending.notifySubmitted === undefined) {
-                    throw new Error(`Actor '${actor.context.actorId}' has no Core source leave submission notifier.`);
-                }
-                await pending.notifySubmitted();
-                pending.resolveSubmitted();
-            }
-            await callbackResult;
-            pending?.resolve();
-        }
-        catch (error) {
-            pending?.rejectSubmitted(error);
-            pending?.reject(error);
-            throw error;
-        }
-        finally {
-            this.coreSourceLeaves.delete(actor.context.actorId);
-        }
-    }
     async completeRelocationSourceLeave(actor, sourceSpotId, signal) {
         await this.prepareSourceActorLeave(actor, sourceSpotId, signal);
     }
@@ -590,13 +411,16 @@ class ZLinkActorTransferRuntime {
     relayCanonicalMaintenanceTerminal(operationId, replyRouteId, result, sourceNodeRid, targetAuthorityOwnerGeneration) {
         return this.options.actorHandoff.acceptRelocatedTerminalRelay(operationId, replyRouteId, undefined, result, sourceNodeRid, targetAuthorityOwnerGeneration);
     }
-    async sealBoundSessionRoute(actor, state, signal, relocation) {
+    async sealBoundSessionRoute(actor, state, signal, relocation, relocationTarget) {
         const target = state.boundSession;
         const actorRef = state.nativeActorRef;
         if (target === undefined ||
             actorRef === undefined ||
             target.bindingGeneration === undefined ||
             target.bindingGeneration <= 0n ||
+            target.sessionOwnerNodeGeneration === undefined ||
+            target.sessionOwnerId === undefined ||
+            target.sessionOwnerLeaseGeneration === undefined ||
             state.locationGeneration === undefined ||
             state.locationGeneration < 0n ||
             state.ownerLeaseGeneration === undefined ||
@@ -605,48 +429,47 @@ class ZLinkActorTransferRuntime {
         }
         const serviceWire = this.options.sessionRelocationWire?.();
         const authorityStore = this.options.authorityStore();
-        const descriptors = this.options.liveDescriptors;
         if (relocation === undefined ||
+            relocationTarget === undefined ||
             serviceWire === undefined ||
             authorityStore === undefined ||
-            descriptors === undefined ||
             target.sessionRid === undefined) {
             throw new Error(`Actor '${actor.context.actorId}' Session relocation requires the command 42/43 service-wire path.`);
         }
-        const [authority, live] = await Promise.all([
-            authorityStore.readAuthority((0, authority_key_codec_1.encodeAuthorityKey)('actor', actor.context.actorId), signal),
-            descriptors(target.routerChannelId, signal)
-        ]);
+        const authority = await authorityStore.readAuthority((0, authority_key_codec_1.encodeAuthorityKey)('actor', actor.context.actorId), signal);
         const local = this.options.primaryMeshNode().status();
-        const sessionOwner = live.find((value) => String(value.rid) === String(target.targetNodeRid));
         if (authority.kind !== 'snapshot' ||
-            sessionOwner === undefined ||
-            String(local.routingId) !== String(actorRef.nodeRid) ||
+            !(0, routing_id_1.routingIdsEqual)(local.routingId, actorRef.nodeRid) ||
             authority.objectGeneration !== actorRef.generation ||
             authority.authorityOwnerGeneration !== state.locationGeneration ||
             authority.ownerLeaseGeneration !== state.ownerLeaseGeneration ||
-            String(authority.allocation.descriptor.rid) !== String(actorRef.nodeRid) ||
+            !(0, routing_id_1.routingIdsEqual)(authority.allocation.descriptor.rid, actorRef.nodeRid) ||
             authority.allocation.descriptorLifecycleGeneration !== local.lifecycleGeneration ||
             (target.sessionNodeRid !== undefined &&
-                String(target.sessionNodeRid) !== String(target.targetNodeRid))) {
+                !(0, routing_id_1.routingIdsEqual)(target.sessionNodeRid, target.targetNodeRid))) {
             throw new Error(`Actor '${actor.context.actorId}' Session route service-wire source fence is stale.`);
         }
+        const sourceNodeRid = local.routingId;
         const coordinator = {
             ownerId: authority.ownerId,
             leaseGeneration: authority.ownerLeaseGeneration,
-            nodeRid: String(local.routingId),
+            nodeRid: sourceNodeRid,
             nodeGeneration: local.lifecycleGeneration,
             expectedAuthorityStoreVersion: authority.storeVersion.value
         };
+        // Session-Actor binding §4: command 42 carries the Session owner identity
+        // stored at bind unchanged.
         const session = {
-            sessionOwnerNodeRid: String(target.targetNodeRid),
-            sessionOwnerNodeGeneration: sessionOwner.lifecycleGeneration,
-            sessionOwnerId: sessionOwner.ownerId,
-            sessionOwnerLeaseGeneration: sessionOwner.leaseGeneration,
-            sessionRid: String(target.sessionRid),
+            sessionOwnerNodeRid: target.targetNodeRid,
+            sessionOwnerNodeGeneration: target.sessionOwnerNodeGeneration,
+            sessionOwnerId: target.sessionOwnerId,
+            sessionOwnerLeaseGeneration: target.sessionOwnerLeaseGeneration,
+            sessionRid: target.sessionRid,
             bindingGeneration: target.bindingGeneration
         };
         const request = {
+            targetNodeRid: relocationTarget.rid,
+            targetNodeGeneration: relocationTarget.lifecycleGeneration,
             relocation,
             coordinator,
             senderRole: 'source',
@@ -654,7 +477,7 @@ class ZLinkActorTransferRuntime {
                 actor: {
                     actorId: actor.context.actorId,
                     generation: actorRef.generation,
-                    nodeRid: String(actorRef.nodeRid)
+                    nodeRid: sourceNodeRid
                 },
                 targetNodeGeneration: local.lifecycleGeneration,
                 authorityOwnerGeneration: authority.authorityOwnerGeneration,
@@ -662,7 +485,9 @@ class ZLinkActorTransferRuntime {
             },
             session
         };
-        await serviceWire.requestSessionRelocationSeal(target.routerChannelId, target.targetNodeRid, request, signal);
+        const response = await serviceWire.requestSessionRelocationSeal(target.routerChannelId, target.targetNodeRid, request, signal);
+        if (response.sealResult === 'bindingAbsent')
+            return undefined;
         return {
             ...target,
             previousAuthorityOwnerGeneration: authority.authorityOwnerGeneration,
@@ -691,7 +516,7 @@ class ZLinkActorTransferRuntime {
             actor: {
                 actorId: actor.context.actorId,
                 generation: actorRef.generation,
-                nodeRid: String(actorRef.nodeRid)
+                nodeRid: actorRef.nodeRid
             },
             session: serviceFence.session,
             route: {
@@ -717,78 +542,6 @@ class ZLinkActorTransferRuntime {
             }
         }
     }
-    beginCoreSourceLeave(actorId) {
-        let resolve;
-        let reject;
-        const promise = new Promise((accept, fail) => {
-            resolve = accept;
-            reject = fail;
-        });
-        let resolveSubmitted;
-        let rejectSubmitted;
-        const submitted = new Promise((accept, fail) => {
-            resolveSubmitted = accept;
-            rejectSubmitted = fail;
-        });
-        void promise.catch(() => { });
-        void submitted.catch(() => { });
-        this.coreSourceLeaves.set(actorId, {
-            promise,
-            resolve,
-            reject,
-            submitted,
-            resolveSubmitted,
-            rejectSubmitted
-        });
-        return { completion: promise, submitted };
-    }
-    scheduleSourceDeparture(actor, sourceSpotId, releaseLocation, failures = []) {
-        void this.finishSourceDeparture(actor, sourceSpotId, releaseLocation, failures);
-    }
-    async finishSourceDeparture(actor, sourceSpotId, releaseLocation, failures) {
-        if (sourceSpotId !== undefined) {
-            try {
-                await this.options
-                    .spotManager()
-                    ?.commitActorLeaveAfterTransfer(sourceSpotId, actor.context.actorId);
-            }
-            catch (error) {
-                failures.push(error);
-            }
-        }
-        if (releaseLocation) {
-            try {
-                const state = this.options.actorManager()?.getState(actor.context.actorId);
-                if (state?.actorType !== undefined && state.ownsLocation) {
-                    await this.options
-                        .locationLifecycle()
-                        ?.releaseActor(state.actorType, actor.context.actorId);
-                    state.markLocationReleased();
-                }
-            }
-            catch (error) {
-                failures.push(error);
-            }
-        }
-        try {
-            // Message Follow keeps its route separately from the retired application instance.
-            await this.options.actorManager()?.completeCoreRelocationSource(actor.context.actorId);
-        }
-        catch (error) {
-            failures.push(error);
-        }
-        try {
-            this.options.onSourceDepartureCompleted?.(actor.context.actorId);
-        }
-        catch (error) {
-            failures.push(error);
-        }
-        if (failures.length > 0) {
-            this.options.reportPostCommitError?.(failures.length === 1
-                ? failures[0]
-                : new AggregateError(failures, 'Actor source retirement failed.'));
-        }
-    }
     async getOrCreateRoutedActor(actorId, actorType, actorRef, remoteBoundSessionTarget, actorCreateRequest, signal) {
         const actorManager = this.requireActorManager('Routed actor join requires ZLINK_ACTOR_MANAGER.');
         const actor = actorRef === undefined
@@ -1018,7 +771,7 @@ class ZLinkActorTransferRuntime {
             ?.readAuthority((0, authority_key_codec_1.encodeAuthorityKey)('actor', actor.context.actorId));
         if (authority?.kind === 'snapshot' &&
             authority.allocation.state === 'active' &&
-            String(authority.allocation.descriptor.rid) === String(node.status().routingId) &&
+            (0, routing_id_1.routingIdsEqual)(authority.allocation.descriptor.rid, node.status().routingId) &&
             authority.allocation.descriptorLifecycleGeneration === ownerNodeGeneration) {
             state.setLocationGeneration(authority.authorityOwnerGeneration);
             state.setOwnerLeaseGeneration(authority.ownerLeaseGeneration);
@@ -1141,9 +894,10 @@ class ZLinkActorTransferRuntime {
                 authority.objectGeneration !== actorRef.generation ||
                 authority.authorityOwnerGeneration !== ownershipGeneration ||
                 authority.ownerLeaseGeneration !== targetOwnerLeaseGeneration ||
-                String(authority.allocation.descriptor.rid) !== String(actorRef.nodeRid)) {
+                !(0, routing_id_1.routingIdsEqual)(authority.allocation.descriptor.rid, actorRef.nodeRid)) {
                 throw new Error(`Actor '${actorId}' command 44 target authority fence is stale.`);
             }
+            const targetNodeRid = actorRef.nodeRid;
             await serviceWire.sendSessionRelocationRoute(target.routerChannelId, target.targetNodeRid, {
                 relocation: serviceFence.relocation,
                 coordinator: serviceFence.coordinator,
@@ -1151,14 +905,14 @@ class ZLinkActorTransferRuntime {
                 actor: {
                     actorId,
                     generation: actorRef.generation,
-                    nodeRid: String(actorRef.nodeRid)
+                    nodeRid: targetNodeRid
                 },
                 session: serviceFence.session,
                 route: {
                     action: 'commit',
                     previousAuthorityOwnerGeneration: target.previousAuthorityOwnerGeneration,
                     targetAuthorityOwnerGeneration: ownershipGeneration,
-                    targetNodeRid: String(actorRef.nodeRid),
+                    targetNodeRid,
                     targetNodeGeneration: authority.allocation.descriptorLifecycleGeneration,
                     targetOwnerLeaseGeneration: authority.ownerLeaseGeneration
                 }