@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/host/actor-packet-relay.js

@@ -5,12 +5,14 @@ const framework_errors_internal_1 = require("../framework-errors-internal");
 const runtime_message_1 = require("../backend/runtime-message");
 const contracts_1 = require("../../contracts");
 const ConfigurationException_1 = require("../../contracts/Configuration/ConfigurationException");
+const abort_1 = require("../abort");
 const actors_1 = require("../actors");
 const actor_packet_relay_wire_1 = require("../actors/actor-packet-relay-wire");
 const actor_routed_json_request_1 = require("../actors/actor-routed-json-request");
 const actor_message_follow_context_1 = require("../actors/actor-message-follow-context");
 const bound_session_wire_1 = require("../actors/bound-session-wire");
 const routing_id_1 = require("../routing-id");
+const session_disconnected_wire_1 = require("../actors/session-disconnected-wire");
 const submission_result_1 = require("../messaging/submission-result");
 const actor_session_binding_runtime_owner_1 = require("../streams/actor-session-binding-runtime-owner");
 const protocol_1 = require("../streams/protocol");
@@ -32,29 +34,14 @@ class ZLinkActorPacketRelay {
             spotRouterChannelIdForMesh: spotRouterChannelIdByMesh?.call(options.meshRouters) ?? ((meshName) => meshName)
         });
     }
-    async notifyBoundActorDisconnected(actor, signal) {
-        const state = this.options.actorManager()?.getState(actor.actorId);
-        const currentRemoteBoundSessionTarget = state?.spotId === undefined ? undefined : state.remoteBoundSessionTarget;
-        const currentRemoteActorPacketTarget = state?.spotId === undefined ? undefined : state.remoteActorPacketTarget;
-        const remoteTarget = currentRemoteBoundSessionTarget ??
-            currentRemoteActorPacketTarget ??
-            (state?.spotId === undefined ? undefined : this.targets.cachedTargetForActor(actor));
-        if (remoteTarget !== undefined) {
-            await this.notifyRemoteActorDisconnected(actor.actorId, remoteTarget, signal, actor.ref);
-            return;
-        }
+    async notifyBoundActorDisconnected(actor, signal, binding) {
+        // The Session binding owns this route, including after relocation and detach (§5, §7).
         const actorRefTarget = this.targets.targetForActorRef(actor.ref);
         if (actorRefTarget !== undefined) {
-            await this.notifyRemoteActorDisconnected(actor.actorId, actorRefTarget, signal, actor.ref);
+            await this.notifyRemoteActorDisconnected(actor.actorId, actorRefTarget, signal, actor.ref, binding);
             return;
         }
-        if (state?.spotId !== undefined && state.actor !== undefined) {
-            const handled = await this.requireSpotManager().notifyJoinedSpotActorDisconnected(state.spotId, state.actor, signal);
-            if (handled) {
-                return;
-            }
-        }
-        await this.notifyActorDisconnectedById(actor.actorId, signal);
+        await this.notifyLocalActorDisconnectedById(actor.actorId, signal, binding, actor.ref);
     }
     clearRemoteActorPacketTarget(actorId) {
         this.targets.clear(actorId);
@@ -65,34 +52,22 @@ class ZLinkActorPacketRelay {
     actorPacketTargetForState(actorId) {
         return this.targets.targetForState(actorId);
     }
-    async notifyActorDisconnectedById(actorId, signal) {
+    async notifyLocalActorDisconnectedById(actorId, signal, binding, bindingActorRef) {
+        (0, abort_1.throwIfAborted)(signal);
         const state = this.options.actorManager()?.getState(actorId);
-        const remoteTarget = state === undefined
-            ? undefined
-            : (state.remoteBoundSessionTarget ?? state.remoteActorPacketTarget);
-        if (remoteTarget !== undefined) {
-            await this.notifyRemoteActorDisconnected(actorId, remoteTarget, signal);
-            return;
-        }
-        await this.notifyLocalActorDisconnectedById(actorId, signal);
-    }
-    async notifyLocalActorDisconnectedById(actorId, signal) {
-        const state = this.options.actorManager()?.getState(actorId);
-        if (state?.spotId !== undefined && state.actor !== undefined) {
-            const handled = await this.requireSpotManager().notifyJoinedSpotActorDisconnected(state.spotId, state.actor, signal);
-            if (handled) {
-                return;
-            }
-        }
-        const localActor = state?.actor;
-        if (localActor === undefined) {
-            throw new Error(`Actor '${actorId}' does not have a local actor instance.`);
+        const frame = this.disconnectedFrame(actorId, binding);
+        const header = runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(frame.header));
+        const body = runtime_message_1.ZLinkBufferMessage.fromOwned(frame.payload);
+        try {
+            if (state?.spotId === undefined)
+                await this.requireSpotNodeRuntime().dispatchEntryActorPacket('local', actorId, [header, body], false, undefined, bindingActorRef);
+            else
+                await this.requireSpotManager().dispatchRoutedActorPacket('local', state.spotId, actorId, [header, body], false, undefined, bindingActorRef);
         }
-        const meshName = state?.meshName;
-        if (meshName === undefined) {
-            throw new Error(`Actor '${actorId}' does not have a RouteMesh identity.`);
+        finally {
+            header.close();
+            body.close();
         }
-        await this.requireSpotNodeRuntime().notifyEntrySpotActorDisconnected(meshName, localActor, signal);
     }
     async receiveRemoteActorPacketRelay(payload, _routeContext) {
         const relay = (0, actor_packet_relay_wire_1.decodeRemoteActorPacketRelayPayload)(payload);
@@ -159,22 +134,23 @@ class ZLinkActorPacketRelay {
                 }
                 return { ok: true, response: { acknowledged: true } };
             }
-            if (frameHeader.name === actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
-                this.requireCurrentRemoteBinding(relay, _routeContext);
-                await this.notifyLocalActorDisconnectedById(relay.actorId);
-                return {
-                    ok: true,
-                    actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId))
-                };
-            }
-            if (remoteBoundSessionTarget !== undefined) {
+            if (remoteBoundSessionTarget !== undefined &&
+                frameHeader.name !== actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
                 this.requireCurrentRemoteBinding(relay, _routeContext);
             }
             const state = this.options.actorManager()?.getState(relay.actorId);
-            if (frameHeader.kind === protocol_1.ZLinkStreamMessageKind.Send) {
+            if (frameHeader.kind === protocol_1.ZLinkStreamMessageKind.Send ||
+                frameHeader.name === actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
                 const dispatch = state?.spotId === undefined
                     ? this.requireSpotNodeRuntime().dispatchEntryActorPacket('remote', relay.actorId, [header, body], false, remoteBoundSessionTarget, fallbackActorRef)
                     : this.requireSpotManager().dispatchRoutedActorPacket('remote', state.spotId, relay.actorId, [header, body], false, remoteBoundSessionTarget, fallbackActorRef);
+                if (frameHeader.name === actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
+                    await dispatch;
+                    return {
+                        ok: true,
+                        actorPacketTarget: (0, actor_packet_relay_wire_1.encodeRemoteActorPacketTarget)(this.actorPacketTargetForState(relay.actorId))
+                    };
+                }
                 // Spec 05 §1.3: a one-way Session Actor relay completes at relay
                 // queue admission, not after the remote application turn. In
                 // particular, a handler may register a deferred Join whose relocation
@@ -469,21 +445,14 @@ class ZLinkActorPacketRelay {
         }
         return true;
     }
-    async notifyRemoteActorDisconnected(actorId, remoteTarget, signal, bindingActorRef) {
+    async notifyRemoteActorDisconnected(actorId, remoteTarget, signal, bindingActorRef, binding) {
         const spotKind = 'spotKind' in remoteTarget ? remoteTarget.spotKind : undefined;
-        const header = {
-            kind: protocol_1.ZLinkStreamMessageKind.Send,
-            codec: protocol_1.ZLinkStreamCodec.Raw,
-            flags: protocol_1.ZLinkStreamHeaderFlags.None,
-            name: actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET,
-            metadata: new Map()
-        };
+        const frame = this.disconnectedFrame(actorId, binding, 'sessionNodeRid' in remoteTarget ? remoteTarget : undefined);
         const payload = (0, actor_packet_relay_wire_1.encodeRemoteActorPacketRelayPayload)({
             actorId,
             routerChannelId: remoteTarget.routerChannelId,
             bindingActorRef,
-            header: (0, protocol_1.encodeStreamHeader)(header),
-            payload: Buffer.alloc(0)
+            ...frame
         });
         if ((spotKind ?? contracts_1.ZLinkSpotKind.Entry) === contracts_1.ZLinkSpotKind.Entry) {
             await this.options.routeTransport.request(remoteTarget.routerChannelId, String(remoteTarget.targetNodeRid), actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, payload, this.options.requestTimeoutMs, signal);
@@ -500,18 +469,36 @@ class ZLinkActorPacketRelay {
             signal
         });
     }
+    disconnectedFrame(actorId, binding, target) {
+        const current = binding === undefined
+            ? (this.options.actorManager()?.getState(actorId)?.boundSession ?? target)
+            : undefined;
+        const header = {
+            kind: protocol_1.ZLinkStreamMessageKind.Send,
+            codec: protocol_1.ZLinkStreamCodec.Raw,
+            flags: protocol_1.ZLinkStreamHeaderFlags.None,
+            name: actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET,
+            metadata: new Map()
+        };
+        return {
+            header: (0, protocol_1.encodeStreamHeader)(header),
+            payload: (0, session_disconnected_wire_1.encodeSessionDisconnected)(binding?.sessionOwnerNodeRid ?? current?.sessionNodeRid, binding?.sessionOwnerNodeGeneration ?? current?.sessionOwnerNodeGeneration, binding?.bindingGeneration ?? current?.bindingGeneration)
+        };
+    }
     requireCurrentRemoteBinding(relay, routeContext) {
-        const state = this.options.actorManager()?.getState(relay.actorId);
-        const current = state?.boundSession;
-        if (current === undefined ||
-            current.sessionNodeRid === undefined ||
-            !(0, routing_id_1.routingIdsEqual)(current.sessionNodeRid, routeContext.sourceNodeRid) ||
-            current.bindingGeneration === undefined ||
-            relay.bindingGeneration === undefined ||
-            current.bindingGeneration !== BigInt(relay.bindingGeneration)) {
+        if (!this.matchesCurrentRemoteBinding(relay, routeContext)) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorSessionNotBound, `Actor '${relay.actorId}' bound session identity is stale.`, true);
         }
     }
+    matchesCurrentRemoteBinding(relay, routeContext) {
+        const current = this.options.actorManager()?.getState(relay.actorId)?.boundSession;
+        return (current !== undefined &&
+            current.sessionNodeRid !== undefined &&
+            (0, routing_id_1.routingIdsEqual)(current.sessionNodeRid, routeContext.sourceNodeRid) &&
+            current.bindingGeneration !== undefined &&
+            relay.bindingGeneration !== undefined &&
+            current.bindingGeneration === BigInt(relay.bindingGeneration));
+    }
     async requestRemoteTarget(target, request, unavailableMessage, decodeReply, signal) {
         if (target.spotKind === contracts_1.ZLinkSpotKind.Entry) {
             try {

package/dist/runtime/host/actor-placement-coordinator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkActorPlacementCoordinator = void 0;
+const routing_id_1 = require("../routing-id");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const node_crypto_1 = require("node:crypto");
 const runtime_values_1 = require("../backend/runtime-values");
@@ -33,6 +34,13 @@ class ZLinkActorPlacementCoordinator {
             for (;;) {
                 const target = await this.options.target(meshName, stableType, deadline.signal, excluded);
                 if (target === undefined) {
+                    // Entry eligibility limits new creation, not lookup of a Ready Actor (Actor model §6.3, §6.5).
+                    if (!createOnly) {
+                        const current = await this.options.store.readAuthority((0, authority_key_codec_1.encodeAuthorityKey)('actor', actorId), deadline.signal);
+                        const existing = existingActor(current, actorId, stableType);
+                        if (existing !== undefined)
+                            return { status: 'existing', actor: existing };
+                    }
                     throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.PlacementCapacityExhausted, `No eligible Actor placement target is ready for '${stableType}'.`, true);
                 }
                 const creatingPayload = (0, actor_authority_publication_1.encodeActorAuthorityIdentity)({
@@ -75,7 +83,7 @@ class ZLinkActorPlacementCoordinator {
                     throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorTypeMismatch, `Actor '${actorId}' is registered with another stable type.`);
                 }
                 if (reserved.kind === 'placementCapacityExhausted') {
-                    excluded.add(String(target.nodeRid));
+                    excluded.add((0, routing_id_1.encodeRoutingIdStorageHex)(target.nodeRid));
                     continue;
                 }
                 if (reserved.kind === 'alreadyExists' || reserved.kind === 'conflict') {
@@ -106,6 +114,13 @@ class ZLinkActorPlacementCoordinator {
                 }
                 if (remote === undefined)
                     throw transportFailure;
+                if ((0, framework_errors_internal_1.internalFrameworkErrorKindFromWireReply)(remote.terminalResult, remote.failureCode) ===
+                    framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected) {
+                    //  The target refused before the callback and cancelled its reservation
+                    //  (Actor model §6.3); exclude this host run like a Reserve failure.
+                    excluded.add((0, routing_id_1.encodeRoutingIdStorageHex)(target.nodeRid));
+                    continue;
+                }
                 if (remote.terminalResult !== runtime_values_1.RequestResult.Ok || remote.failureCode !== 0) {
                     //  Classify the (terminal, fine failure code) pair via the shared
                     //  ownership-aware translator instead of collapsing every non-OK
@@ -274,12 +289,14 @@ function creationTarget(snapshot) {
         }
     };
 }
-function existingActor(reserved, actorId, stableType) {
-    const snapshot = reserved.kind === 'alreadyExists'
-        ? reserved.current
-        : reserved.kind === 'conflict' && reserved.current.kind === 'snapshot'
-            ? reserved.current
-            : undefined;
+function existingActor(current, actorId, stableType) {
+    const snapshot = current.kind === 'snapshot'
+        ? current
+        : current.kind === 'alreadyExists'
+            ? current.current
+            : current.kind === 'conflict' && current.current.kind === 'snapshot'
+                ? current.current
+                : undefined;
     if (snapshot === undefined ||
         snapshot.allocation.state !== 'active' ||
         snapshot.allocation.objectKind !== 'actor' ||
@@ -348,7 +365,7 @@ function requireExactReservation(current, record) {
         current.allocation.stableType !== record.stableType ||
         current.objectGeneration !== record.reservation.objectGeneration ||
         current.authorityOwnerGeneration !== record.reservation.authorityOwnerGeneration ||
-        String(current.allocation.descriptor.rid) !== record.reservation.targetNodeRid ||
+        !(0, routing_id_1.routingIdsEqual)(current.allocation.descriptor.rid, record.reservation.targetNodeRid) ||
         current.allocation.descriptorLifecycleGeneration !== record.reservation.targetNodeGeneration ||
         current.ownerId !== record.reservation.targetOwnerId ||
         current.ownerLeaseGeneration !== record.reservation.targetOwnerLeaseGeneration ||

package/dist/runtime/host/actor-runtime-options-factory.js

@@ -149,9 +149,9 @@ class ZLinkActorRuntimeOptionsFactory {
             staleActorRefReporter: (_meshName, actorId) => this.options.actorHandoff.recordStaleFailure(actorId),
             staleActorRefPredicate: (meshName, actor) => this.actorBelongsToMesh(meshName, actor.actorId) &&
                 this.options.actorHandoff.isKnownStale(actor),
-            handoffCapture: (meshName, actorId, parts, returnResponse, actor, deadlineUnixMs) => this.actorBelongsToMesh(meshName, actorId) &&
+            handoffCapture: (meshName, actorId, parts, returnResponse, actor, deadlineUnixMs, onAdmitted) => this.actorBelongsToMesh(meshName, actorId) &&
                 !this.options.actorHandoff.isProvisional(actorId)
-                ? this.options.actorHandoff.capture('local', actorId, parts, returnResponse, undefined, actor, deadlineUnixMs)
+                ? this.options.actorHandoff.capture('local', actorId, parts, returnResponse, undefined, actor, deadlineUnixMs, undefined, undefined, onAdmitted)
                 : undefined,
             sendErrorReporter: this.options.reportPostCommitError
         };

package/dist/runtime/host/actor-transfer-runtime.d.ts

@@ -1,6 +1,6 @@
-import { type ActorRef, type RoutingId, type ZLinkActor, type ZLinkActorJoinOperationId, type ZLinkMessageSerializer, type ZLinkSpot, ZLinkMessage } from '../../contracts';
+import { type ActorRef, type RoutingId, type ZLinkActor, type ZLinkMeshNodeDescriptor, type ZLinkActorJoinOperationId, type ZLinkMessageSerializer, type ZLinkSpot, ZLinkMessage } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
-import { type ZLinkActorHandoffCoordinator, type ZLinkActorHandoffReplayPreparation, type ZLinkActorRoutedJoinTransport, type ZLinkActorTransferRegistry, type ZLinkDeferredJoinCompletion, type ZLinkRemoteBoundSessionTarget } from '../actors';
+import { type ZLinkActorHandoffCoordinator, type ZLinkActorHandoffReplayPreparation, type ZLinkActorRoutedJoinTransport, type ZLinkDeferredJoinCompletion, type ZLinkRemoteBoundSessionTarget } from '../actors';
 import type { ZLinkActorHandoffPacket, ZLinkActorHandoffResult, ZLinkActorHandoffTerminalAcceptance, ZLinkActorHandoffTerminalAck } from '../actors/actor-handoff';
 import { type ZLinkActorMessageFollowOwnerFence } from '../actors/actor-message-follow-context';
 import type { ZLinkActorRuntimeState } from '../actors/actor-runtime-state';
@@ -32,7 +32,6 @@ export interface ZLinkActorTransferRuntimeActorManager {
     }): Promise<ZLinkActor>;
     publishRelocationActor(actorId: string): void;
     rollbackTransferredActor(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
-    completeCoreRelocationSource(actorId: string): Promise<void>;
 }
 export interface ZLinkActorTransferRuntimeOptions {
     readonly routeTransport: ZLinkActorRoutedJoinTransport;
@@ -41,36 +40,30 @@ export interface ZLinkActorTransferRuntimeOptions {
     readonly actorManager: () => ZLinkActorTransferRuntimeActorManager | undefined;
     readonly primaryMeshNode: () => ZLinkBackendMeshNode;
     readonly notifyEntrySpotActorLeft: (actor: ZLinkActor, signal?: AbortSignal) => Promise<void>;
-    readonly restoreEntrySpotActorJoined: (actor: ZLinkActor, signal?: AbortSignal) => Promise<void>;
     readonly locationLifecycle: () => ZLinkLocationLifecycle | undefined;
     /** Resolves the authoritative Ready route for a target User/Instance Spot. */
     readonly spotRouteResolver?: () => ZLinkSpotRouteResolver | undefined;
     readonly actorHandoff: ZLinkActorHandoffCoordinator;
-    readonly actorTransferRegistry: ZLinkActorTransferRegistry;
     readonly authorityStore: () => (ZLinkAuthorityStore & ZLinkObjectCreationStore & ZLinkOwnerLeaseStore) | undefined;
     readonly currentOwner: () => ZLinkLocationOwnerToken | undefined;
-    /** Live admitted peers of a mesh; used to stop retries against a gone session owner. */
-    readonly liveDescriptors?: (meshName: string, signal?: AbortSignal) => Promise<readonly import('../../contracts').ZLinkMeshNodeDescriptor[]>;
     /** Service-wire command 42/43/44 bridge, installed after the host runtime is assembled. */
     readonly sessionRelocationWire?: () => ZLinkSessionRelocationWirePort | undefined;
     readonly clearRemoteActorPacketTarget: (actorId: string) => void;
     /** Acquires that permit before the Actor FIFO claims the runnable child. */
     readonly prepareApplicationJob?: ZLinkActorHandoffReplayPreparation;
     readonly reportPostCommitError?: (error: unknown) => void;
-    readonly onSourceDepartureCompleted?: (actorId: string) => void;
     readonly shutdownSignal?: () => AbortSignal | undefined;
-    readonly metrics?: import('../diagnostics').ZLinkRuntimeMetrics;
 }
 export declare class ZLinkActorTransferRuntime {
     private readonly options;
-    private readonly coreSourceLeaves;
     private readonly activeDeferredJoinTerminals;
     private readonly deferredJoinTerminals;
     constructor(options: ZLinkActorTransferRuntimeOptions);
     beginDeferredActorHandoff(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
-    promoteDeferredActorHandoff(actor: ZLinkActor, _state: ZLinkActorRuntimeState): void;
+    /** Relocation activation owns admission; handler terminals are observed independently. */
+    admitRelocationPrefix(actor: ZLinkActor, objectGeneration: bigint, packets: readonly ZLinkActorHandoffPacket[], start: Promise<void>, onResult: (packet: ZLinkActorHandoffPacket, result: ZLinkActorHandoffResult) => Promise<void>): void;
     completeDeferredActorHandoff(actor: ZLinkActor, target: ZLinkSpotRouteTarget, _targetActorRef: ActorRef): Promise<void>;
-    cancelDeferredActorHandoff(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void>;
+    cancelDeferredActorHandoff(actor: ZLinkActor, _state: ZLinkActorRuntimeState): Promise<void>;
     prepareDeferredJoinAccepted(actorId: string, operationId: ZLinkActorJoinOperationId, actorRef: ActorRef, rawReply: Uint8Array, replyContentType?: string): ZLinkDeferredJoinCompletion;
     /**
      * Runs the completion callback once in the target Actor mailbox.
@@ -80,43 +73,26 @@ export declare class ZLinkActorTransferRuntime {
     deliverDeferredJoinCompletion(completion: ZLinkDeferredJoinCompletion, actor: ZLinkActor, actorRef: ActorRef, submitMailbox: <T>(operation: () => Promise<T>) => Promise<T>, signal?: AbortSignal): Promise<void>;
     private deliverDeferredJoinCompletionCore;
     private prepareSourceActorLeave;
-    private restoreSourceActor;
     private beginSourceActorMove;
     private cancelSourceActorMove;
     private admitCanceledSourcePrefix;
     private admitDeferredSourcePrefix;
     private observeHandoffReplay;
-    private sourceHandoffPrefixQueue;
-    prepareSource(actor: ZLinkActor, state: ZLinkActorRuntimeState, signal?: AbortSignal, lifecycleAuthority?: 'framework' | 'core', deferredJoin?: boolean, relocation?: ServiceWireOperationId): Promise<{
-        handoffBacklog: readonly ZLinkActorHandoffPacket[];
-        sourceLeaveCompletion: Promise<void> | undefined;
-        sourceLeaveSubmitted: Promise<void> | undefined;
-        onSourceLeaveSubmitted: (notify: () => Promise<void>) => void;
-        observeTargetAuthority: (target: ZLinkSpotRouteTarget, targetActorRef: ActorRef, observeSignal?: AbortSignal) => Promise<void>;
-        commit: (target: Parameters<ZLinkActorHandoffCoordinator["complete"]>[1], targetActorRef: ActorRef, results: Parameters<ZLinkActorHandoffCoordinator["complete"]>[3], releaseLocation?: boolean) => void;
-        rollback: () => Promise<void>;
-        adapterKey?: string;
-        state: ZLinkMessage;
-    }>;
-    prepareMaintenanceSession(actor: ZLinkActor, state: ZLinkActorRuntimeState, signal?: AbortSignal, manageMembership?: boolean, relocation?: ServiceWireOperationId): Promise<{
+    prepareMaintenanceSession(actor: ZLinkActor, state: ZLinkActorRuntimeState, signal?: AbortSignal, manageMembership?: boolean, relocation?: ServiceWireOperationId, relocationTarget?: Pick<ZLinkMeshNodeDescriptor, 'rid' | 'lifecycleGeneration'>): Promise<{
         readonly target?: ZLinkRemoteBoundSessionTarget;
         readonly handoffBacklog: readonly import('../actors').ZLinkActorHandoffPacket[];
         takeRelocationRelay(): readonly import('../actors').ZLinkActorHandoffPacket[];
         setReplayResults(results: readonly import('../actors').ZLinkActorHandoffResult[]): void;
-        commit(target: ZLinkSpotRouteTarget, targetActorRef: ActorRef, targetOwnerFence: ZLinkActorMessageFollowOwnerFence): Promise<void>;
+        commit(target: ZLinkSpotRouteTarget, targetActorRef: ActorRef, targetOwnerFence: ZLinkActorMessageFollowOwnerFence | null): Promise<void>;
         rollback(): Promise<void>;
         discard(reason: unknown): void;
     }>;
-    notifyCoreSourceLeave(actor: ZLinkActor, callback: () => Promise<void>): Promise<void>;
     completeRelocationSourceLeave(actor: ZLinkActor, sourceSpotId: RoutingId | undefined, signal?: AbortSignal): Promise<void>;
     relayMaintenanceTerminal(actorId: string, packet: ZLinkActorHandoffPacket, result: ZLinkActorHandoffResult, sourceNodeRid: RoutingId, targetAuthorityOwnerGeneration?: bigint): ZLinkActorHandoffTerminalAck;
     relayCanonicalMaintenanceTerminal(operationId: string, replyRouteId: string, result: ZLinkActorHandoffResult, sourceNodeRid: RoutingId, targetAuthorityOwnerGeneration?: bigint): ZLinkActorHandoffTerminalAcceptance;
     private sealBoundSessionRoute;
     private abortBoundSessionRouteSeal;
     private observeBoundSessionSealAbort;
-    private beginCoreSourceLeave;
-    private scheduleSourceDeparture;
-    private finishSourceDeparture;
     getOrCreateRoutedActor(actorId: string, actorType: string, actorRef?: ActorRef, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, actorCreateRequest?: Message, signal?: AbortSignal): Promise<{
         readonly actor: ZLinkActor;
         readonly actorRef: ZLinkBackendActorRef;