@zlink-systems/framework 0.30.0 → 0.30.2

package/dist/runtime/host/location-runtime-owner.js

@@ -146,10 +146,6 @@ class ZLinkLocationRuntimeOwner {
         }
         spotNodeRuntime.configureLocationAutoConnect(runtime, stores, this.options.registration.locations.options, this.currentEvents);
         channelRuntime.configureLocationAutoConnect(runtime, stores, this.options.registration.locations.options, this.currentEvents);
-        if (runtime.ownerLeaseUsable) {
-            await spotNodeRuntime.startLocationAutoConnect();
-            await channelRuntime.startLocationAutoConnect();
-        }
         return runtime;
     }
     clearForStop() {
@@ -168,7 +164,7 @@ class ZLinkLocationRuntimeOwner {
         const locations = this.options.registration.locations;
         if (locations.useInMemoryStores) {
             const provider = new locations_1.ZLinkInMemoryProviderLocationStore();
-            const store = new locations_1.ZLinkLocationStoreRepository(provider);
+            const store = new locations_1.ZLinkLocationStoreRepository(provider, undefined, this.options.metrics);
             return {
                 locationStore: store,
                 authorityStore: store,
@@ -183,7 +179,7 @@ class ZLinkLocationRuntimeOwner {
         }
         const provider = locations.storeInstance;
         if (provider !== undefined) {
-            const store = new locations_1.ZLinkLocationStoreRepository(provider);
+            const store = new locations_1.ZLinkLocationStoreRepository(provider, undefined, this.options.metrics);
             return {
                 locationStore: store,
                 authorityStore: store,

package/dist/runtime/host/mesh-router-resolver.d.ts

@@ -5,6 +5,10 @@ export declare class MeshRouterResolver {
     private readonly registration;
     constructor(registration: ZLinkFrameworkRegistration);
     canUseRouterChannel(routerChannelId: string): boolean;
+    /**
+     * Runs on every node-direct send: a direct scan of the registered manual
+     * peers, without temporary arrays or a predicate closure per call.
+     */
     classifyManualNodeTarget(meshName: string, targetNodeRid: RoutingId): boolean | undefined;
     defaultRouterChannelId(): string | undefined;
     defaultSpotRouterChannelId(): string | undefined;

package/dist/runtime/host/mesh-router-resolver.js

@@ -11,17 +11,25 @@ class MeshRouterResolver {
         return (this.registration.routeChannels.has(routerChannelId) ||
             this.registration.spotNodes.get(routerChannelId)?.router !== undefined);
     }
+    /**
+     * Runs on every node-direct send: a direct scan of the registered manual
+     * peers, without temporary arrays or a predicate closure per call.
+     */
     classifyManualNodeTarget(meshName, targetNodeRid) {
         const router = this.registration.spotNodes.get(meshName)?.router;
         if (router === undefined)
             return undefined;
-        const manualConnections = router.manualConnections ?? [];
-        const manualPeers = router.manualPeerConnections ?? [];
-        if (manualConnections.length === 0 && manualPeers.length === 0)
+        const manualPeers = router.manualPeerConnections;
+        if (manualPeers !== undefined) {
+            for (const peer of manualPeers) {
+                if ((0, routing_id_1.routingIdsEqual)(peer.peerRid, targetNodeRid))
+                    return true;
+            }
+        }
+        const manualConnectionCount = router.manualConnections?.length ?? 0;
+        if (manualConnectionCount === 0 && (manualPeers?.length ?? 0) === 0)
             return undefined;
-        if (manualPeers.some((peer) => (0, routing_id_1.routingIdsEqual)(peer.peerRid, targetNodeRid)))
-            return true;
-        return manualConnections.length === 0 ? false : undefined;
+        return manualConnectionCount === 0 ? false : undefined;
     }
     defaultRouterChannelId() {
         const candidates = [

package/dist/runtime/host/remote-bound-session-relay.d.ts

@@ -25,7 +25,6 @@ export declare class ZLinkRemoteBoundSessionRelay {
     private readonly options;
     private readonly actorOwnershipGenerations;
     private readonly activeServiceWireRelocations;
-    private readonly terminalServiceWireRelocations;
     constructor(options: ZLinkRemoteBoundSessionRelayOptions);
     receiveRoutedBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, actorRef?: ActorRef, actorPacketTarget?: unknown): Promise<void>;
     receiveRoutedBoundSessionResponse(actorId: string, packetName: string, requestSeq: bigint, message: unknown, replyOptions: ZLinkActorResponseOptions, actorPacketTarget?: unknown): Promise<void>;
@@ -40,12 +39,11 @@ export declare class ZLinkRemoteBoundSessionRelay {
     receiveRemoteBoundSessionError(payload: unknown): Promise<{
         readonly ok: boolean;
     }>;
-    receiveServiceWireSessionRelocationSeal(value: ServiceSessionRelocationSeal, signal?: AbortSignal): Promise<ServiceSessionRelocationSealed>;
+    receiveServiceWireSessionRelocationSeal(value: ServiceSessionRelocationSeal, signal?: AbortSignal, onInstalled?: () => void): Promise<ServiceSessionRelocationSealed | undefined>;
     receiveServiceWireSessionRelocationRoute(value: ServiceSessionRelocationRoute): Promise<void>;
-    clearServiceWireSessionRelocations(): void;
+    clearServiceWireSessionRelocations(): Promise<void>;
     private warnLateSessionRouteUpdate;
     private applyServiceWireSessionRelocationRoute;
-    private validateServiceWireSessionRoute;
     resolveRemoteBoundSessionTarget(sourceNodeRid: RoutingId, sourceSessionRid: RoutingId): ZLinkRemoteBoundSessionTarget | undefined;
     actorPacketTargetForState(actorId: string): ZLinkRemoteActorPacketTarget | undefined;
     clearOwnership(actorId: string): void;

package/dist/runtime/host/remote-bound-session-relay.js

@@ -8,14 +8,11 @@ const actor_packet_relay_wire_1 = require("../actors/actor-packet-relay-wire");
 const routing_id_1 = require("../routing-id");
 const service_stateful_wire_codec_1 = require("../foundation/service-stateful-wire-codec");
 const service_wire_m6a_codec_1 = require("../foundation/service-wire-m6a-codec");
-const bounded_replay_map_1 = require("./bounded-replay-map");
 const framework_errors_internal_1 = require("../framework-errors-internal");
-const SERVICE_CONTROL_TERMINAL_CAPACITY = 4096;
 class ZLinkRemoteBoundSessionRelay {
     options;
     actorOwnershipGenerations = new Map();
     activeServiceWireRelocations = new Map();
-    terminalServiceWireRelocations = new bounded_replay_map_1.BoundedReplayMap(SERVICE_CONTROL_TERMINAL_CAPACITY);
     constructor(options) {
         this.options = options;
     }
@@ -112,77 +109,40 @@ class ZLinkRemoteBoundSessionRelay {
             .sendLocalBoundSessionError(response.actorId, response.boundPacketName, response.requestSeq, response.error, new Map(Object.entries(response.metadata ?? {})));
         return { ok: sent };
     }
-    async receiveServiceWireSessionRelocationSeal(value, signal) {
+    async receiveServiceWireSessionRelocationSeal(value, signal, onInstalled) {
+        const runtime = this.options.streamBindingRuntime();
+        const owner = (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(runtime);
+        const sealController = new AbortController();
+        const sealSignal = signal === undefined
+            ? sealController.signal
+            : AbortSignal.any([signal, sealController.signal]);
+        const prepared = await owner.prepareSessionRelocationSeal(value, sealSignal);
+        if (prepared === undefined)
+            return undefined;
+        if (prepared.response.sealResult === 'bindingAbsent')
+            return prepared.response;
         const key = serviceWireBarrierKey(value);
-        const fingerprint = (0, service_stateful_wire_codec_1.encodeSessionRelocationSeal)(value).toString('base64');
-        const terminal = this.terminalServiceWireRelocations.get(key);
-        if (terminal !== undefined) {
-            if (terminal.sealFingerprint !== fingerprint) {
-                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${key}' repeated command 42 with different bytes.`);
-            }
-            this.terminalServiceWireRelocations.touch(key);
-            return terminal.sealed;
-        }
-        const active = this.activeServiceWireRelocations.get(key);
-        if (active !== undefined) {
-            if (active.sealFingerprint !== fingerprint) {
-                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${key}' repeated command 42 with different bytes.`);
-            }
-            return await active.sealPromise;
-        }
+        const existing = this.activeServiceWireRelocations.get(key);
+        if (existing !== undefined)
+            return await existing.sealPromise;
         const actorId = value.actor.actor.actorId;
-        // Register the identity before the first asynchronous owner operation.
-        // Concurrent identical commands join this promise; different bytes for
-        // the same identity fail before they can install another seal.
-        let state;
-        const sealController = new AbortController();
-        const sealPromise = Promise.resolve().then(async () => {
-            await this.validateServiceWireSessionRoute(value);
-            await (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(this.options.streamBindingRuntime()).sealRelocation({
-                actorId,
-                actorGeneration: value.actor.actor.generation,
-                bindingGeneration: value.session.bindingGeneration,
-                sessionIdentity: value.session.sessionRid,
-                actorNodeRid: value.actor.actor.nodeRid,
-                actorNodeGeneration: value.actor.targetNodeGeneration,
-                sealId: key
-            }, {
-                objectGeneration: value.actor.actor.generation,
-                bindingGeneration: value.session.bindingGeneration
-            }, sealController.signal);
-            return {
-                relocation: value.relocation,
-                coordinator: value.coordinator,
-                actor: value.actor,
-                session: value.session
-            };
-        });
-        state = {
+        const state = {
             actorId,
-            sealFingerprint: fingerprint,
-            sealPromise,
-            sealController
+            sealPromise: prepared.ready.then(() => prepared.response)
         };
         this.activeServiceWireRelocations.set(key, state);
+        onInstalled?.();
         const expire = async (error) => {
-            if (state.terminal === true || state.routePromise !== undefined)
+            if (state.terminal === true ||
+                (await owner.relocationSnapshot(actorId, key))?.phase !== 'sealed')
                 return;
             state.terminal = true;
             sealController.abort(error);
             if (this.activeServiceWireRelocations.get(key) === state) {
                 this.activeServiceWireRelocations.delete(key);
             }
-            if (state.sealed !== undefined) {
-                this.terminalServiceWireRelocations.remember(key, {
-                    actorId,
-                    sealFingerprint: state.sealFingerprint,
-                    sealed: state.sealed
-                });
-            }
-            const owner = (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(this.options.streamBindingRuntime());
-            await owner.clearRelocation(actorId, error);
-            void this.options
-                .streamBindingRuntime()
+            await owner.clearRelocation(actorId, error, key);
+            void runtime
                 .closeSessionBinding(actorId, value.session)
                 .catch((disconnectError) => this.options.reportOwnershipRefreshError?.(actorId, disconnectError));
             state.sealAbortCleanup?.();
@@ -203,9 +163,7 @@ class ZLinkRemoteBoundSessionRelay {
                 signal.addEventListener('abort', onAbort, { once: true });
         }
         try {
-            const sealed = await sealPromise;
-            state.sealed = sealed;
-            return sealed;
+            return await state.sealPromise;
         }
         catch (error) {
             clearTimeout(state.sealTimer);
@@ -213,126 +171,69 @@ class ZLinkRemoteBoundSessionRelay {
             if (this.activeServiceWireRelocations.get(key) === state) {
                 this.activeServiceWireRelocations.delete(key);
             }
-            if (state.terminal !== true) {
-                const owner = (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(this.options.streamBindingRuntime());
-                if ((await owner.relocationSnapshot(actorId, key)) !== undefined) {
-                    await owner.clearRelocation(actorId, error);
-                    void this.options
-                        .streamBindingRuntime()
-                        .closeSessionBinding(actorId, value.session)
-                        .catch((disconnectError) => this.options.reportOwnershipRefreshError?.(actorId, disconnectError));
-                }
+            if (state.terminal !== true && (await owner.relocationSnapshot(actorId, key)) !== undefined) {
+                await owner.clearRelocation(actorId, error, key);
+                void runtime
+                    .closeSessionBinding(actorId, value.session)
+                    .catch((disconnectError) => this.options.reportOwnershipRefreshError?.(actorId, disconnectError));
             }
             throw sealController.signal.aborted ? sealController.signal.reason : error;
         }
     }
     async receiveServiceWireSessionRelocationRoute(value) {
         const key = serviceWireBarrierKey(value);
-        const routeRequestFingerprint = (0, service_stateful_wire_codec_1.encodeSessionRelocationRoute)(value).toString('base64');
-        const fingerprint = routeRequestFingerprint;
-        const terminal = this.terminalServiceWireRelocations.get(key);
-        if (terminal !== undefined) {
-            if (terminal.routeFingerprint === undefined) {
-                // The Session owner already closed this binding at the seal deadline.
-                // A late command 44 is terminal and cannot reactivate the route.
-                this.terminalServiceWireRelocations.touch(key);
-                this.warnLateSessionRouteUpdate(value);
-                return;
-            }
-            if (terminal.routeFingerprint !== fingerprint) {
-                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${key}' repeated command 44 with different bytes.`);
-            }
-            this.terminalServiceWireRelocations.touch(key);
-            this.warnLateSessionRouteUpdate(value);
-            return;
-        }
+        const runtime = this.options.streamBindingRuntime();
+        const owner = (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(runtime);
         const state = this.activeServiceWireRelocations.get(key);
-        if (state === undefined) {
-            this.warnLateSessionRouteUpdate(value);
-            return;
-        }
-        if (state.routeRequestFingerprint !== undefined &&
-            state.routeRequestFingerprint !== routeRequestFingerprint) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${key}' repeated command 44 with different bytes.`);
-        }
-        if (state.routeFingerprint !== undefined) {
-            if (state.routeFingerprint !== fingerprint || state.routePromise === undefined) {
-                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${key}' repeated command 44 with different bytes.`);
+        const accepted = await owner.acceptSessionRelocationRoute(value, async () => {
+            if (state === undefined) {
+                throw new bound_session_wire_1.ZLinkRemoteBoundSessionFenceError(`Session relocation '${key}' has no active seal.`);
             }
-            this.warnLateSessionRouteUpdate(value);
-            await state.routePromise;
-            return;
-        }
-        state.routeRequestFingerprint = routeRequestFingerprint;
-        state.routeFingerprint = fingerprint;
-        if (state.sealTimer !== undefined)
-            clearTimeout(state.sealTimer);
-        state.sealAbortCleanup?.();
-        const routePromise = state.sealPromise.then(async (sealed) => {
-            validateSessionRelocationRouteAgainstSeal(value, sealed);
-            await this.applyServiceWireSessionRelocationRoute(key, value);
-        });
-        state.routePromise = routePromise;
-        try {
-            await routePromise;
-            this.terminalServiceWireRelocations.remember(key, {
-                actorId: state.actorId,
-                sealFingerprint: state.sealFingerprint,
-                sealed: state.sealed ?? (await state.sealPromise),
-                routeRequestFingerprint,
-                routeFingerprint: fingerprint
-            });
-            if (this.activeServiceWireRelocations.get(key) === state) {
-                this.activeServiceWireRelocations.delete(key);
+            if (state.sealTimer !== undefined)
+                clearTimeout(state.sealTimer);
+            state.sealAbortCleanup?.();
+            try {
+                const sealed = await state.sealPromise;
+                validateSessionRelocationRouteAgainstSeal(value, sealed);
+                await this.applyServiceWireSessionRelocationRoute(key, value);
             }
-            state.terminal = true;
-        }
-        catch (error) {
-            // Command 44 is one-way. Once an exact update wins the timeout race,
-            // an apply failure cannot be repaired by waiting for an ACK-driven
-            // retry. Close the physical Session and terminalize this identity so a
-            // late duplicate cannot reactivate the binding or its held messages.
-            state.terminal = true;
-            if (this.activeServiceWireRelocations.get(key) === state) {
-                this.activeServiceWireRelocations.delete(key);
+            catch (error) {
+                // The binding owner chose this command. A failed one-way apply closes
+                // its physical Session; conflicting duplicates never enter this callback.
+                await owner.clearRelocation(state.actorId, error, key);
+                await runtime
+                    .closeSessionBinding(state.actorId, value.session)
+                    .catch((disconnectError) => this.options.reportOwnershipRefreshError?.(state.actorId, disconnectError));
+                throw error;
             }
-            const sealed = state.sealed ?? (await state.sealPromise);
-            this.terminalServiceWireRelocations.remember(key, {
-                actorId: state.actorId,
-                sealFingerprint: state.sealFingerprint,
-                sealed,
-                routeRequestFingerprint,
-                routeFingerprint: fingerprint
-            });
-            (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(this.options.streamBindingRuntime()).clearRelocation(state.actorId, error);
-            await this.options
-                .streamBindingRuntime()
-                .closeSessionBinding(state.actorId, value.session)
-                .catch((disconnectError) => this.options.reportOwnershipRefreshError?.(state.actorId, disconnectError));
-            throw error;
-        }
+            finally {
+                state.terminal = true;
+                if (this.activeServiceWireRelocations.get(key) === state) {
+                    this.activeServiceWireRelocations.delete(key);
+                }
+            }
+        });
+        if (!accepted)
+            this.warnLateSessionRouteUpdate(value);
     }
-    clearServiceWireSessionRelocations() {
+    async clearServiceWireSessionRelocations() {
         for (const state of this.activeServiceWireRelocations.values()) {
             if (state.sealTimer !== undefined)
                 clearTimeout(state.sealTimer);
+            state.sealAbortCleanup?.();
         }
         this.activeServiceWireRelocations.clear();
-        this.terminalServiceWireRelocations.clear();
+        await (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwnerIfRegistered)(this.options.streamBindingRuntime())?.clearSessionRelocationResults();
     }
     warnLateSessionRouteUpdate(value) {
         console.warn(`late_session_route_update session=${value.session.sessionRid}`);
     }
     async applyServiceWireSessionRelocationRoute(key, value) {
         const runtime = this.options.streamBindingRuntime();
-        const owner = (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(runtime);
-        const fingerprint = (0, service_stateful_wire_codec_1.encodeSessionRelocationRoute)(value).toString('base64');
         if (value.route.action === 'abort') {
-            await owner.applyRelocation(value.actor.actorId, key, fingerprint, async () => {
-                if (!(await runtime.abortActorRouteSeal(value.actor.actorId, key))) {
-                    throw new bound_session_wire_1.ZLinkRemoteBoundSessionFenceError(`Actor '${value.actor.actorId}' command 44 abort lost its Session seal.`);
-                }
-            });
+            if (!(await runtime.abortActorRouteSeal(value.actor.actorId, key))) {
+                throw new bound_session_wire_1.ZLinkRemoteBoundSessionFenceError(`Actor '${value.actor.actorId}' command 44 abort lost its Session seal.`);
+            }
         }
         else {
             const committedRoute = value.route;
@@ -344,36 +245,20 @@ class ZLinkRemoteBoundSessionRelay {
                 actorId: value.actor.actorId,
                 objectGeneration: value.actor.generation,
                 meshName: current.meshName,
-                nodeRid: (0, routing_id_1.decodeRoutingId)(committedRoute.targetNodeRid, undefined),
+                nodeRid: committedRoute.targetNodeRid,
                 bindingGeneration: value.session.bindingGeneration,
                 ownershipGeneration: committedRoute.targetAuthorityOwnerGeneration,
                 ownerNodeGeneration: committedRoute.targetNodeGeneration,
                 ownerLeaseGeneration: committedRoute.targetOwnerLeaseGeneration
             };
-            await owner.applyRelocation(value.actor.actorId, key, fingerprint, async () => {
-                await runtime.commitActorRoute(targetActorRef, undefined, {
-                    confirmRemoteSessionBinding: 'send',
-                    releaseSeal: { sealId: key }
-                });
-                const currentGeneration = this.actorOwnershipGenerations.get(value.actor.actorId);
-                if (currentGeneration === undefined ||
-                    currentGeneration < committedRoute.targetAuthorityOwnerGeneration) {
-                    this.actorOwnershipGenerations.set(value.actor.actorId, committedRoute.targetAuthorityOwnerGeneration);
-                }
+            await runtime.commitActorRoute(targetActorRef, undefined, {
+                releaseSeal: { sealId: key }
             });
-        }
-        await owner.observeRelocationTerminal(value.actor.actorId, key, fingerprint);
-    }
-    async validateServiceWireSessionRoute(value) {
-        const current = await this.options
-            .streamBindingRuntime()
-            .sessionRouteFence(value.actor.actor.actorId);
-        if (current === undefined ||
-            current.actor.objectGeneration !== value.actor.actor.generation ||
-            !(0, routing_id_1.routingIdsEqual)(current.actor.nodeRid, value.actor.actor.nodeRid) ||
-            current.sessionRid.toString() !== value.session.sessionRid ||
-            current.bindingGeneration !== value.session.bindingGeneration) {
-            throw new bound_session_wire_1.ZLinkRemoteBoundSessionFenceError(`Actor '${value.actor.actor.actorId}' command 42 was fenced by its exact Session route.`);
+            const currentGeneration = this.actorOwnershipGenerations.get(value.actor.actorId);
+            if (currentGeneration === undefined ||
+                currentGeneration < committedRoute.targetAuthorityOwnerGeneration) {
+                this.actorOwnershipGenerations.set(value.actor.actorId, committedRoute.targetAuthorityOwnerGeneration);
+            }
         }
     }
     resolveRemoteBoundSessionTarget(sourceNodeRid, sourceSessionRid) {
@@ -405,10 +290,6 @@ class ZLinkRemoteBoundSessionRelay {
                 this.activeServiceWireRelocations.delete(key);
             }
         }
-        for (const [key, value] of this.terminalServiceWireRelocations) {
-            if (value.actorId === actorId)
-                this.terminalServiceWireRelocations.delete(key);
-        }
     }
     async sendActorResponse(actor, packetName, requestSeq, response, replyOptions, fallbackBoundSessionTarget, fallbackActorRef, signal) {
         const state = this.options.actorManager()?.getState(actor.context.actorId);
@@ -520,33 +401,17 @@ function serviceWireBarrierKey(value) {
     return (0, service_stateful_wire_codec_1.serviceSessionRelocationIdentityKey)(value);
 }
 function validateSessionRelocationRouteAgainstSeal(route, sealed) {
-    const sameCoordinator = route.coordinator.ownerId === sealed.coordinator.ownerId &&
-        route.coordinator.leaseGeneration === sealed.coordinator.leaseGeneration &&
-        route.coordinator.nodeRid === sealed.coordinator.nodeRid &&
-        route.coordinator.nodeGeneration === sealed.coordinator.nodeGeneration &&
-        route.coordinator.expectedAuthorityStoreVersion ===
-            sealed.coordinator.expectedAuthorityStoreVersion;
-    const sameSession = route.session.sessionOwnerNodeRid === sealed.session.sessionOwnerNodeRid &&
+    const sameSession = (0, routing_id_1.routingIdsEqual)(route.session.sessionOwnerNodeRid, sealed.session.sessionOwnerNodeRid) &&
         route.session.sessionOwnerNodeGeneration === sealed.session.sessionOwnerNodeGeneration &&
         route.session.sessionOwnerId === sealed.session.sessionOwnerId &&
         route.session.sessionOwnerLeaseGeneration === sealed.session.sessionOwnerLeaseGeneration &&
-        route.session.sessionRid === sealed.session.sessionRid &&
+        (0, routing_id_1.routingIdsEqual)(route.session.sessionRid, sealed.session.sessionRid) &&
         route.session.bindingGeneration === sealed.session.bindingGeneration;
     if (route.relocation.high !== sealed.relocation.high ||
         route.relocation.low !== sealed.relocation.low ||
-        !sameCoordinator ||
         !sameSession ||
         route.actor.actorId !== sealed.actor.actor.actorId ||
         route.actor.generation !== sealed.actor.actor.generation) {
         throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${serviceWireBarrierKey(route)}' changed its command 42 fence.`);
     }
-    if (route.route.action === 'commit') {
-        if (route.route.previousAuthorityOwnerGeneration !== sealed.actor.authorityOwnerGeneration) {
-            throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${serviceWireBarrierKey(route)}' changed its source authority fence.`);
-        }
-        return;
-    }
-    if (route.route.currentAuthorityOwnerGeneration !== sealed.actor.authorityOwnerGeneration) {
-        throw new service_wire_m6a_codec_1.ServiceWireProtocolError(`Session relocation '${serviceWireBarrierKey(route)}' abort changed its authority fence.`);
-    }
 }

package/dist/runtime/host/route-mesh-runtime.d.ts

@@ -3,7 +3,7 @@ import type { ZLinkActivationAdmission } from '../activation-admission';
 import type { ZLinkRuntimeAdmissionGate } from '../admission';
 import type { ZLinkBackendMeshNode } from '../backend';
 import type { ZLinkSpotNodeOptions } from '../configuration';
-type ZLinkDrainForceReason = 'deadline_exceeded' | 'drain_state_publish_failed' | 'owner_cleanup_failed' | 'teardown_failed';
+export type ZLinkDrainForceReason = 'deadline_exceeded' | 'drain_state_publish_failed' | 'owner_cleanup_failed' | 'teardown_failed';
 type ZLinkMeshDrainResult = {
     readonly kind: 'drained';
 } | {
@@ -28,7 +28,7 @@ export interface ZLinkRouteMeshRuntimeCoordinatorOptions {
     readonly drainResources: (meshName: string, signal: AbortSignal, stopStartingSignal?: AbortSignal) => Promise<void>;
     readonly shutdownResources?: (meshName: string, signal: AbortSignal) => Promise<void>;
     readonly cleanupHostResources: (signal: AbortSignal) => Promise<void>;
-    readonly forceStopResources: (meshName: string) => Promise<void>;
+    readonly forceStopResources: (meshName: string, reason: ZLinkDrainForceReason, signal: AbortSignal) => Promise<void>;
 }
 export interface ZLinkLocalPlacementCounts {
     readonly activeActorCount: number;

package/dist/runtime/host/route-mesh-runtime.js

@@ -312,7 +312,9 @@ class ZLinkRouteMeshRuntimeCoordinator {
                 : deadline.signal.aborted
                     ? 'deadline_exceeded'
                     : classified;
-            await this.options.forceStopResources(meshName).catch(() => undefined);
+            await this.options
+                .forceStopResources(meshName, reason, deadline.signal)
+                .catch(() => undefined);
             result = { kind: 'forceStopped', reason };
             this.transition(meshName, state, contracts_1.ZLinkTopologyState.Failed);
         }
@@ -362,7 +364,7 @@ class ZLinkRouteMeshRuntimeCoordinator {
                 : deadline.signal.aborted
                     ? 'deadline_exceeded'
                     : classified;
-            await Promise.all(entries.map(([meshName]) => this.options.forceStopResources(meshName).catch(() => undefined)));
+            await Promise.all(entries.map(([meshName]) => this.options.forceStopResources(meshName, reason, deadline.signal).catch(() => undefined)));
             result = { kind: 'forceStopped', reason };
             for (const [meshName, state] of entries) {
                 this.transition(meshName, state, contracts_1.ZLinkTopologyState.Failed);
@@ -408,8 +410,8 @@ class ZLinkRouteMeshRuntimeCoordinator {
                 : signal.aborted
                     ? 'deadline_exceeded'
                     : classified;
-            await Promise.all(entries.map(([meshName]) => this.options.forceStopResources(meshName).catch(() => undefined)));
-            result = { kind: 'forceStopped', reason };
+            await Promise.all(entries.map(([meshName]) => this.options.forceStopResources(meshName, reason, signal).catch(() => undefined)));
+            result = { kind: 'forceStopped', reason, error };
             for (const [meshName, state] of entries) {
                 this.transition(meshName, state, contracts_1.ZLinkTopologyState.Failed);
             }

package/dist/runtime/host/runtime-shutdown.d.ts

@@ -26,6 +26,7 @@ export interface ZLinkRuntimeStopParts {
     readonly spotNodeRuntime?: ZLinkSpotNodeRuntimeManager;
     readonly channelRuntime?: ZLinkChannelRuntimeManager;
     readonly serviceRelocation?: {
+        drainActorJoinSources?(): Promise<void>;
         dispose(): Promise<void>;
     };
     readonly ownedStores?: readonly ZLinkRuntimeOwnedStore[];

package/dist/runtime/host/runtime-shutdown.js

@@ -20,10 +20,11 @@ async function rollbackRuntimeStart(parts) {
 async function stopRuntimeParts(parts) {
     const state = parts.state;
     const errors = [];
+    await runShutdownStep(errors, () => (0, abort_1.awaitWithAbort)(Promise.resolve(parts.serviceRelocation?.drainActorJoinSources?.()), parts.shutdownSignal));
     await runShutdownStep(errors, () => parts.streamRuntime?.dispose());
-    await runShutdownStep(errors, () => parts.spotNodeRuntime?.dispose(undefined, parts.cleanupDeadline));
+    await runShutdownStep(errors, () => parts.spotNodeRuntime?.dispose(parts.shutdownSignal, parts.cleanupDeadline));
     await runShutdownStep(errors, () => parts.channelRuntime?.dispose());
-    await runShutdownStep(errors, () => parts.serviceRelocation?.dispose());
+    await runShutdownStep(errors, () => (0, abort_1.awaitWithAbort)(Promise.resolve(parts.serviceRelocation?.dispose()), parts.shutdownSignal));
     await runShutdownStep(errors, () => parts.locationSnapshot.lifecycle?.dispose());
     await runShutdownStep(errors, () => parts.locationSnapshot.runtime?.stop(parts.shutdownSignal));
     await Promise.allSettled(state.listenerTasks);

package/dist/runtime/host/service-relocation-control.d.ts

@@ -3,5 +3,6 @@ export type ZLinkServiceRelocationControlRequest = ServiceMaintenanceRelocationC
 export type ZLinkServiceRelocationControlResponse = ServiceMaintenanceRelocationControl;
 export declare function encodeServiceRelocationControlRequest(request: ZLinkServiceRelocationControlRequest): Buffer;
 export declare function decodeServiceRelocationControlRequest(payload: Uint8Array): ZLinkServiceRelocationControlRequest | undefined;
+export declare function serviceRelocationControlCommand(payload: Uint8Array): number | undefined;
 export declare function encodeServiceRelocationControlResponse(response: ZLinkServiceRelocationControlResponse): Buffer;
 export declare function decodeServiceRelocationControlResponse(payload: Uint8Array): ZLinkServiceRelocationControlResponse;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeServiceRelocationControlRequest = encodeServiceRelocationControlRequest;
 exports.decodeServiceRelocationControlRequest = decodeServiceRelocationControlRequest;
+exports.serviceRelocationControlCommand = serviceRelocationControlCommand;
 exports.encodeServiceRelocationControlResponse = encodeServiceRelocationControlResponse;
 exports.decodeServiceRelocationControlResponse = decodeServiceRelocationControlResponse;
 const service_wire_binary_primitives_1 = require("../foundation/service-wire-binary-primitives");
@@ -14,13 +15,18 @@ function decodeServiceRelocationControlRequest(payload) {
     const bytes = Buffer.isBuffer(payload)
         ? payload
         : Buffer.from(payload.buffer, payload.byteOffset, payload.byteLength);
-    if (bytes.byteLength < service_wire_binary_primitives_1.SERVICE_WIRE_PREFIX_SIZE ||
-        bytes[0] !== service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[0] ||
-        bytes[1] !== service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[1] ||
-        bytes[service_wire_binary_primitives_1.SERVICE_WIRE_MAJOR_OFFSET] !== service_wire_constants_generated_1.SERVICE_WIRE_MAJOR)
+    if (serviceRelocationControlCommand(bytes) === undefined)
         return undefined;
     return (0, service_stateful_wire_codec_1.decodeMaintenanceRelocationControl)(bytes);
 }
+function serviceRelocationControlCommand(payload) {
+    if (payload.byteLength < service_wire_binary_primitives_1.SERVICE_WIRE_PREFIX_SIZE ||
+        payload[0] !== service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[0] ||
+        payload[1] !== service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[1] ||
+        payload[service_wire_binary_primitives_1.SERVICE_WIRE_MAJOR_OFFSET] !== service_wire_constants_generated_1.SERVICE_WIRE_MAJOR)
+        return undefined;
+    return payload[service_wire_binary_primitives_1.SERVICE_WIRE_COMMAND_OFFSET];
+}
 function encodeServiceRelocationControlResponse(response) {
     return (0, service_stateful_wire_codec_1.encodeMaintenanceRelocationControl)(response);
 }