@zlink-systems/framework 0.25.0 → 0.27.0

package/dist/runtime/spots/spot-activation.js

@@ -4,6 +4,7 @@ exports.ZLinkSpotActivationLifecycle = void 0;
 const contracts_1 = require("../../contracts");
 const abort_1 = require("../abort");
 const configuration_1 = require("../configuration");
+const framework_errors_internal_1 = require("../framework-errors-internal");
 const actors_1 = require("../actors");
 const handler_instance_scope_1 = require("../handlers/handler-instance-scope");
 const payload_codec_1 = require("../messaging/payload-codec");
@@ -23,6 +24,9 @@ class ZLinkSpotActivationLifecycle {
     cleanupStates = new WeakMap();
     constructor(options) {
         this.options = options;
+        if (options.detachedTaskRunner === undefined) {
+            throw new configuration_1.ZLinkConfigurationException('Spot activation requires a detached task runner.');
+        }
         this.actorAdmission = new spot_actor_admission_coordinator_1.ZLinkSpotActorAdmissionCoordinator(options);
     }
     async materializeRelocation(meshName, objectKind, stableType, implementation, spotId, objectGeneration, authorityOwnerGeneration, signal) {
@@ -62,7 +66,7 @@ class ZLinkSpotActivationLifecycle {
         const common = {
             meshName,
             spotId,
-            objectGeneration: toContextGeneration(objectGeneration),
+            objectGeneration: objectGeneration,
             outbound,
             timers,
             serial,
@@ -72,7 +76,7 @@ class ZLinkSpotActivationLifecycle {
             providerResolver: this.options.providerResolver,
             runtimeEventPublisher: this.options.runtimeEventPublisher,
             workerRuntime: this.options.workerRuntime,
-            close: this.contextClose(meshName, spotId, () => activation)
+            close: this.contextClose(objectGeneration, () => activation)
         };
         const context = objectKind === 'user_spot'
             ? (0, spot_context_1.createSpotContext)({
@@ -110,6 +114,7 @@ class ZLinkSpotActivationLifecycle {
                 domain: objectKind === 'user_spot'
                     ? {
                         kind: 'user',
+                        objectGeneration,
                         executionMode,
                         relocationCoordinationMode: this.options.userSpotRelocationCoordinationMode?.(meshName, implementation) ?? contracts_1.ZLinkSpotRelocationCoordinationMode.FrameworkManaged
                     }
@@ -129,16 +134,24 @@ class ZLinkSpotActivationLifecycle {
             return activation;
         }
         catch (error) {
-            await timers.dispose().catch(() => undefined);
-            if (instance !== undefined) {
-                await (0, handler_instance_scope_1.disposeLifecycleHandlers)(instance).catch(() => undefined);
+            const cleanup = await Promise.allSettled([
+                timers.dispose(),
+                ...(instance === undefined
+                    ? []
+                    : [(0, handler_instance_scope_1.disposeLifecycleHandlers)(instance, this.options.detachedTaskRunner)]),
+                ...(nativeSpot === undefined ? [] : [Promise.resolve().then(() => nativeSpot.dispose())])
+            ]);
+            const cleanupErrors = cleanup
+                .filter((result) => result.status === 'rejected')
+                .map((result) => result.reason);
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([error, ...cleanupErrors], `Spot '${spotId}' relocation materialization cleanup failed.`);
             }
-            await nativeSpot?.dispose().catch(() => undefined);
             throw error;
         }
     }
-    async materializeInstance(meshName, instanceType, implementation, spotId, objectGeneration, signal) {
-        const serial = new spot_serial_turn_executor_1.ZLinkSpotSerialTurnExecutor(true, spotId);
+    async materializeInstance(meshName, instanceType, implementation, spotId, objectGeneration, signal, serialOwner) {
+        const serial = serialOwner?.serial ?? new spot_serial_turn_executor_1.ZLinkSpotSerialTurnExecutor(true, spotId);
         const serialExecutor = new spot_serial_executor_1.ZLinkSpotSerialExecutor(serial, contracts_1.ZLinkUserSpotExecutionMode.SpotWide, spotId);
         const actorHandlers = new actors_1.ZLinkSpotActorHandlerRegistryRuntime();
         const handlers = new spot_handler_registry_1.DefaultZLinkSpotHandlerRegistry(actorHandlers);
@@ -160,7 +173,7 @@ class ZLinkSpotActivationLifecycle {
         const context = (0, spot_context_1.createInstanceSpotContext)({
             meshName,
             spotId,
-            objectGeneration: toContextGeneration(objectGeneration),
+            objectGeneration: objectGeneration,
             handlers: instanceHandlers,
             outbound,
             timers,
@@ -171,7 +184,7 @@ class ZLinkSpotActivationLifecycle {
             providerResolver: this.options.providerResolver,
             runtimeEventPublisher: this.options.runtimeEventPublisher,
             workerRuntime: this.options.workerRuntime,
-            close: this.contextClose(meshName, spotId, () => activation)
+            close: this.contextClose(objectGeneration, () => activation)
         });
         instance = await (0, spot_provider_1.createFreshProviderInstance)(implementation, this.options.providerResolver, context);
         Object.defineProperty(instance, 'context', {
@@ -190,6 +203,7 @@ class ZLinkSpotActivationLifecycle {
             timers,
             actorHandlers,
             handlers,
+            executionBarrier: serialOwner?.executionBarrier,
             externalActorCount: () => this.options.actorCountProvider?.(spotId) ?? 0
         });
         try {
@@ -199,14 +213,21 @@ class ZLinkSpotActivationLifecycle {
                 runtimeEventPublisher: this.options.runtimeEventPublisher,
                 signal
             });
-            await serial.execute(() => instance.onInitialize?.());
+            await (serialOwner === undefined
+                ? serial.execute(() => instance.onInitialize?.())
+                : serial.postBarrierTurn(() => instance.onInitialize?.()));
             this.options.registerActivation(activation);
             return activation;
         }
         catch (error) {
-            await timers.dispose();
-            await (0, handler_instance_scope_1.disposeLifecycleHandlers)(instance);
-            throw new AggregateError([error], `Instance Spot '${instanceType}' materialization failed for '${String(spotId)}'.`);
+            const cleanup = await Promise.allSettled([
+                timers.dispose(),
+                (0, handler_instance_scope_1.disposeLifecycleHandlers)(instance, this.options.detachedTaskRunner)
+            ]);
+            const cleanupErrors = cleanup
+                .filter((result) => result.status === 'rejected')
+                .map((result) => result.reason);
+            throw new AggregateError([error, ...cleanupErrors], `Instance Spot '${instanceType}' materialization failed for '${String(spotId)}'.`);
         }
     }
     async discardInstance(activation) {
@@ -230,7 +251,7 @@ class ZLinkSpotActivationLifecycle {
             errors.push(error);
         }
         try {
-            await (0, handler_instance_scope_1.disposeLifecycleHandlers)(activation.spot);
+            await (0, handler_instance_scope_1.disposeLifecycleHandlers)(activation.spot, this.options.detachedTaskRunner);
         }
         catch (error) {
             errors.push(error);
@@ -241,13 +262,6 @@ class ZLinkSpotActivationLifecycle {
             throw new AggregateError(errors, `Instance Spot '${String(activation.spotId)}' cleanup failed.`);
         }
     }
-    resourcesReleased(activation) {
-        const state = this.cleanupStates.get(activation);
-        return (state?.timersDisposed === true &&
-            state.handlersDisposed === true &&
-            state.nativeDisposed === true &&
-            state.locationReleased === true);
-    }
     async create(meshName, spotType, spotId, request, signal, authority) {
         const executionMode = this.options.userSpotExecutionMode?.(meshName, spotType) ??
             contracts_1.ZLinkUserSpotExecutionMode.SpotWide;
@@ -296,7 +310,7 @@ class ZLinkSpotActivationLifecycle {
         const context = (0, spot_context_1.createSpotContext)({
             meshName,
             spotId,
-            objectGeneration: toContextGeneration(spotGeneration),
+            objectGeneration: spotGeneration,
             handlers,
             outbound,
             timers,
@@ -315,7 +329,7 @@ class ZLinkSpotActivationLifecycle {
             },
             ensureOperationAllowed: () => activation?.ensureContextOperationAllowed(),
             leaveActor: (actor, contextSignal) => this.options.leaveActor(spotId, actor, contextSignal, meshName),
-            close: this.contextClose(meshName, spotId, () => activation)
+            close: this.contextClose(spotGeneration, () => activation)
         });
         try {
             spot = await (0, spot_provider_1.createFreshProviderInstance)(spotType, this.options.providerResolver, context);
@@ -331,6 +345,7 @@ class ZLinkSpotActivationLifecycle {
                 spotId,
                 domain: {
                     kind: 'user',
+                    objectGeneration: spotGeneration,
                     executionMode,
                     relocationCoordinationMode: this.options.userSpotRelocationCoordinationMode?.(meshName, spotType) ??
                         contracts_1.ZLinkSpotRelocationCoordinationMode.FrameworkManaged
@@ -360,9 +375,11 @@ class ZLinkSpotActivationLifecycle {
                 else {
                     const partialCleanup = await Promise.allSettled([
                         timers.dispose(),
-                        ...(spot === undefined ? [] : [(0, handler_instance_scope_1.disposeLifecycleHandlers)(spot)]),
-                        nativeSpot.dispose(),
-                        this.options.locationClaim.release(locationClaim.meshName, spotId)
+                        ...(spot === undefined
+                            ? []
+                            : [(0, handler_instance_scope_1.disposeLifecycleHandlers)(spot, this.options.detachedTaskRunner)]),
+                        Promise.resolve().then(() => nativeSpot.dispose()),
+                        Promise.resolve().then(() => this.options.locationClaim.release(locationClaim.meshName, spotId))
                     ]);
                     const partialErrors = partialCleanup
                         .filter((result) => result.status === 'rejected')
@@ -389,7 +406,7 @@ class ZLinkSpotActivationLifecycle {
         const context = (0, spot_context_1.createSpotContext)({
             meshName,
             spotId,
-            objectGeneration: toContextGeneration(objectGeneration),
+            objectGeneration: objectGeneration,
             handlers,
             outbound,
             timers,
@@ -408,7 +425,7 @@ class ZLinkSpotActivationLifecycle {
             },
             ensureOperationAllowed: () => activation?.ensureContextOperationAllowed(),
             leaveActor: (actor, contextSignal) => this.options.leaveActor(spotId, actor, contextSignal, meshName),
-            close: this.contextClose(meshName, spotId, () => activation)
+            close: this.contextClose(objectGeneration, () => activation)
         });
         spot = await (0, spot_provider_1.createFreshProviderInstance)(spotType, this.options.providerResolver, context);
         Object.defineProperty(spot, 'context', {
@@ -421,6 +438,7 @@ class ZLinkSpotActivationLifecycle {
             spotId,
             domain: {
                 kind: 'user',
+                objectGeneration,
                 executionMode,
                 relocationCoordinationMode: this.options.userSpotRelocationCoordinationMode?.(meshName, spotType) ??
                     contracts_1.ZLinkSpotRelocationCoordinationMode.FrameworkManaged
@@ -437,51 +455,27 @@ class ZLinkSpotActivationLifecycle {
         });
         return await this.runCreateLifecycle(activation, spotType, request, locationClaim, undefined, signal);
     }
-    contextClose(meshName, spotId, activationProvider) {
-        return async (signal) => {
+    contextClose(objectGeneration, activationProvider) {
+        return (signal) => {
             const activation = activationProvider();
-            // Native callbacks can cross a promise boundary that does not retain
-            // the serial turn context. Queue the close before calling the manager
-            // so the callback never waits for work behind its own serial turn.
-            if (activation?.serial.isExecuting === true && !activation.serial.isCurrentTurn) {
-                activation.requestClose();
-                const retry = activation.serial.post(() => this.options.closeSpot(meshName, spotId, signal));
-                this.options.detachedTaskRunner?.runDetached(`spot close ${String(spotId)}`, async () => {
-                    await retry;
-                });
-                if (this.options.detachedTaskRunner === undefined) {
-                    void retry.catch(() => undefined);
-                }
-                return true;
+            if (activation === undefined) {
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, 'Spot context Close requires its active generation.');
             }
-            return await this.options.closeSpot(meshName, spotId, signal);
+            return this.options.requestContextClose(activation, objectGeneration, signal);
         };
     }
-    async close(activation, signal, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose) {
-        const seal = activation.sealExecution();
-        await this.closeAfterSeal(activation, seal, signal, reason);
-    }
-    async closeAfterSeal(activation, seal, signal, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose, deadline) {
-        try {
-            await activation.waitForExecutionQuiescence(seal, signal);
-        }
-        catch (error) {
-            activation.abortExecutionSeal(seal);
-            throw error;
-        }
-        // The eager occupancy check that authorized this seal (startClose ->
-        // canClose()) ran before quiescence, so it can miss an actor join that
-        // was already queued on the serial executor at that moment. Recheck now
-        // that every turn admitted before the seal has finished, and release the
-        // seal instead of closing an occupied Spot.
-        if (!activation.canClose(reason)) {
-            activation.abortExecutionSeal(seal);
-            throw new spot_activation_state_1.ZLinkSpotCloseOccupiedError(activation.spotId);
-        }
+    async sealForClose(activation, seal, signal) {
+        await activation.waitForExecutionQuiescence(seal, signal);
         if (!activation.commitExecutionSeal(seal)) {
             throw new Error(`Spot '${String(activation.spotId)}' close seal is stale.`);
         }
-        await this.cleanupActivation(activation, activation.meshName, true, signal, reason, deadline);
+    }
+    /** Returns the OnClosing failure, which cleanup records and does not rethrow. */
+    async cleanupClosedActivation(activation, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose, deadline) {
+        return await this.cleanupActivation(activation, activation.meshName, true, undefined, reason, deadline, true);
+    }
+    async cleanupFailedIncarnation(activation) {
+        await this.cleanupActivation(activation, activation.meshName, false, undefined, contracts_1.ZLinkSpotCloseReason.ExplicitClose, undefined, true);
     }
     async dispatchActorPacket(activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
         return await this.actorAdmission.dispatchActorPacket(activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
@@ -536,25 +530,28 @@ class ZLinkSpotActivationLifecycle {
             throw error;
         }
     }
-    async cleanupActivation(activation, locationMeshName, notifyClosing, signal, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose, deadline) {
+    async cleanupActivation(activation, locationMeshName, notifyClosing, signal, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose, deadline, owningLifecycle = false) {
         (0, abort_1.throwIfAborted)(signal);
         const state = this.cleanupStates.get(activation) ?? {
             closingAttempted: false,
             timersDisposed: false,
+            serialDisposed: false,
             handlersDisposed: false,
+            actorDispatchDisposed: false,
             nativeDisposed: false,
             locationReleased: false
         };
         this.cleanupStates.set(activation, state);
         if (state.inFlight !== undefined)
             return await state.inFlight;
-        state.inFlight = this.runCleanup(activation, locationMeshName, notifyClosing, reason, state, deadline).finally(() => {
+        state.inFlight = this.runCleanup(activation, locationMeshName, notifyClosing, reason, state, deadline, owningLifecycle).finally(() => {
             state.inFlight = undefined;
         });
         return await state.inFlight;
     }
-    async runCleanup(activation, locationMeshName, notifyClosing, reason, state, deadline) {
+    async runCleanup(activation, locationMeshName, notifyClosing, reason, state, deadline, owningLifecycle = false) {
         const errors = [];
+        let closingFailure;
         const cleanup = async (operation, completed) => {
             try {
                 await operation();
@@ -566,26 +563,56 @@ class ZLinkSpotActivationLifecycle {
         };
         if (notifyClosing && !state.closingAttempted) {
             state.closingAttempted = true;
-            await cleanup(() => (0, spot_closing_1.invokeSpotClosing)(activation.spot.onClosing?.bind(activation.spot), reason, deadline), () => undefined);
+            try {
+                // OnClosing is user code: it runs as a Framework turn through the
+                // execution gate while the Close lifecycle item keeps its FIFO slot.
+                await activation.serial.postBarrierTurn(() => (0, spot_closing_1.invokeSpotClosing)(activation.spot.onClosing?.bind(activation.spot), reason, deadline));
+            }
+            catch (error) {
+                // An OnClosing failure is diagnostic and cleanup continues. It is
+                // returned so host shutdown can classify its teardown outcome.
+                this.options.closeErrorSink?.reportRuntimeTaskException(`spot ${String(activation.spotId)} onClosing`, error);
+                closingFailure = error;
+            }
         }
         if (!state.timersDisposed) {
             await cleanup(() => activation.timers.dispose(), () => {
                 state.timersDisposed = true;
             });
         }
-        await cleanup(() => activation.serialExecutor.close(), () => undefined);
+        if (!state.serialDisposed && state.timersDisposed) {
+            await cleanup(() => owningLifecycle
+                ? activation.serialExecutor.closeChildren()
+                : activation.serialExecutor.close(), () => {
+                state.serialDisposed = true;
+            });
+        }
         if (!state.handlersDisposed) {
-            await cleanup(() => (0, handler_instance_scope_1.disposeLifecycleHandlers)(activation.spot), () => {
+            await cleanup(() => (0, handler_instance_scope_1.disposeLifecycleHandlers)(activation.spot, this.options.detachedTaskRunner), () => {
                 state.handlersDisposed = true;
             });
         }
+        if (!state.actorDispatchDisposed) {
+            await cleanup(() => activation.actorDispatch?.dispose(), () => {
+                state.actorDispatchDisposed = true;
+            });
+        }
         if (!state.nativeDisposed) {
-            await cleanup(() => activation.actorDispatch?.dispose(), () => undefined);
             await cleanup(() => activation.nativeSpot?.dispose(), () => {
                 state.nativeDisposed = true;
             });
         }
-        if (!state.locationReleased) {
+        if (!state.locationReleased &&
+            // Spot messaging §7 step 3: an Instance Spot's ExplicitClose releases its authority
+            // through the Close operation's Closing fence; a User Spot still releases its location.
+            !(owningLifecycle &&
+                reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose &&
+                activation.domain.kind === 'instance') &&
+            state.timersDisposed &&
+            state.serialDisposed &&
+            state.handlersDisposed &&
+            state.actorDispatchDisposed &&
+            state.nativeDisposed) {
             await cleanup(() => this.options.releaseLocation(activation, locationMeshName, activation.spotId), () => {
                 state.locationReleased = true;
             });
@@ -595,6 +622,7 @@ class ZLinkSpotActivationLifecycle {
         if (errors.length > 1) {
             throw new AggregateError(errors, `Spot '${activation.spotId}' cleanup failed.`);
         }
+        return closingFailure;
     }
     decodeCreateReply(reply) {
         if (reply === undefined) {
@@ -610,9 +638,3 @@ class ZLinkSpotActivationLifecycle {
     }
 }
 exports.ZLinkSpotActivationLifecycle = ZLinkSpotActivationLifecycle;
-function toContextGeneration(generation) {
-    if (generation < 0n || generation > BigInt(Number.MAX_SAFE_INTEGER)) {
-        throw new configuration_1.ZLinkConfigurationException(`Spot object generation '${generation}' cannot be represented by the Node.js public context.`);
-    }
-    return Number(generation);
-}

package/dist/runtime/spots/spot-actor-admission-coordinator.d.ts

@@ -6,14 +6,13 @@ import { type ZLinkRemoteBoundSessionTarget } from '../actors';
 import type { ZLinkSpotActivationLifecycleOptions } from './spot-activation';
 import { ZLinkSpotActivation } from './spot-activation-state';
 import { ZLinkSpotActorJoinDispatch } from './spot-actor-join-dispatch';
-type AdmissionOptions = Pick<ZLinkSpotActivationLifecycleOptions, 'actorHandoffRuntime' | 'admission' | 'actorResolver' | 'actorTransferRuntime' | 'boundSessionRuntime' | 'detachedTaskRunner' | 'dispatchErrors' | 'locationClaim' | 'messageSerializers' | 'nativeSpotNodeProvider' | 'createReceived' | 'createTopicMessage' | 'providerResolver' | 'runtimeEventPublisher' | 'routeToActorJoinPrewarm'>;
+type AdmissionOptions = Pick<ZLinkSpotActivationLifecycleOptions, 'actorHandoffRuntime' | 'admission' | 'actorResolver' | 'actorTransferRuntime' | 'boundSessionRuntime' | 'detachedTaskRunner' | 'dispatchErrors' | 'locationClaim' | 'messageSerializers' | 'nativeSpotNodeProvider' | 'createTopicMessage' | 'providerResolver' | 'runtimeEventPublisher' | 'routeToActorJoinPrewarm'>;
 export declare class ZLinkSpotActorAdmissionCoordinator {
     private readonly options;
     constructor(options: AdmissionOptions);
     dispatchActorPacket(activation: ZLinkSpotActivation, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     attachNativeActorJoinDispatch(activation: ZLinkSpotActivation, nativeSpot: ZLinkBackendSpot | undefined): ZLinkSpotActorJoinDispatch | undefined;
     private dispatchActorPacketInActorTurn;
-    private commitNativeActorTransaction;
     private commitTransferredActorTransaction;
     private replayActorBacklog;
 }

package/dist/runtime/spots/spot-actor-admission-coordinator.js

@@ -21,7 +21,6 @@ class ZLinkSpotActorAdmissionCoordinator {
             return undefined;
         const nativeDispatch = new spot_actor_join_dispatch_1.ZLinkSpotActorJoinDispatch({
             nativeSpot,
-            createReceived: requireBackendValueFactory(this.options.createReceived, 'Received'),
             createTopicMessage: requireBackendValueFactory(this.options.createTopicMessage, 'TopicMessage'),
             serial: activation.serial,
             actors: {
@@ -36,9 +35,8 @@ class ZLinkSpotActorAdmissionCoordinator {
                         kind: 'enabled',
                         runtime: this.options.actorTransferRuntime
                     },
-                commitNativeActor: (actor) => this.commitNativeActorTransaction(activation, actor),
                 commitActorDeparture: (actorId) => activation.commitActorDeparture(actorId),
-                commitTransferredActor: (actor, backlog) => this.commitTransferredActorTransaction(activation, actor, backlog)
+                commitTransferredActor: (actor, backlog, sealedSession) => this.commitTransferredActorTransaction(activation, actor, backlog, sealedSession)
             },
             packets: {
                 handle: (delivery) => this.dispatchActorPacket(activation, delivery.actorId, delivery.parts, delivery.returnResponse, delivery.remoteBoundSessionTarget, delivery.fallbackActorRef),
@@ -46,10 +44,6 @@ class ZLinkSpotActorAdmissionCoordinator {
                     const node = this.options.nativeSpotNodeProvider?.(activation.meshName);
                     if (node === undefined || (0, routing_id_1.routingIdsEqual)(sourceNodeRid, node.routingId))
                         return;
-                    const target = this.options.boundSessionRuntime?.resolveRemoteBoundSessionTarget(sourceNodeRid, sourceSessionRid);
-                    if (target !== undefined) {
-                        this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(actor.actorId, target);
-                    }
                     node.bindRemoteActorSession(actor, sourceNodeRid, sourceSessionRid);
                 },
                 replyNoBind: (info, parts, result) => this.options
@@ -106,7 +100,6 @@ class ZLinkSpotActorAdmissionCoordinator {
                 : (activation.resolveJoinedActor(targetActorId) ??
                     this.options.actorResolver?.(targetActorId)),
             actorLeft: (targetActorId) => activation.hasDepartedActor(targetActorId),
-            onRemoteBoundSessionTarget: (targetActorId, target) => this.options.boundSessionRuntime?.rememberRemoteBoundSessionTarget(targetActorId, target),
             onDisconnectActor: (actor) => activation.serial.execute(() => activation.spot.onDisconnectActor?.(actor)),
             actorResponseSender: this.options.boundSessionRuntime?.sendActorResponse.bind(this.options.boundSessionRuntime),
             actorErrorSender: this.options.boundSessionRuntime?.sendActorError.bind(this.options.boundSessionRuntime),
@@ -116,37 +109,7 @@ class ZLinkSpotActorAdmissionCoordinator {
             routeToActorJoinPrewarm: this.options.routeToActorJoinPrewarm
         }).dispatch(actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
     }
-    async commitNativeActorTransaction(activation, actor) {
-        const transfer = this.options.actorTransferRuntime;
-        let snapshot;
-        let rollbackMembership;
-        let routeSwitchStarted = false;
-        try {
-            snapshot = await transfer?.claimNativeActorLocation(actor, activation.spotId, activation.meshName);
-            transfer?.commitRoutedActor(actor, activation.spotId, activation.spot);
-            rollbackMembership = activation.commitActorJoin(actor);
-            activation.beginActorTransfer(actor.context.actorId);
-            await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
-            routeSwitchStarted = true;
-            await transfer?.publishRoutedActorOwnership(actor);
-            await transfer?.openRoutedActorSession(actor);
-            activation.cancelActorTransfer(actor.context.actorId);
-        }
-        catch (error) {
-            if (routeSwitchStarted)
-                throw error;
-            rollbackMembership?.();
-            try {
-                if (snapshot !== undefined)
-                    await transfer?.rollbackNativeActorJoin(actor, snapshot);
-            }
-            catch (rollbackError) {
-                throw new AggregateError([error, rollbackError], 'Native actor admission and rollback both failed.');
-            }
-            throw error;
-        }
-    }
-    async commitTransferredActorTransaction(activation, actor, backlog) {
+    async commitTransferredActorTransaction(activation, actor, backlog, sealedSession) {
         const transfer = this.options.actorTransferRuntime;
         let routeSwitchStarted = false;
         try {
@@ -157,7 +120,7 @@ class ZLinkSpotActorAdmissionCoordinator {
             const results = backlog.length === 0 ? [] : await this.replayActorBacklog(activation, actor, backlog);
             await transfer?.claimRoutedActorLocation(actor, activation.spotId, activation.meshName);
             routeSwitchStarted = true;
-            await transfer?.publishRoutedActorOwnership(actor);
+            await transfer?.publishRoutedActorOwnership(actor, sealedSession);
             await transfer?.openRoutedActorSession(actor);
             activation.cancelActorTransfer(actor.context.actorId);
             return results;

package/dist/runtime/spots/spot-actor-join-dispatch.d.ts

@@ -1,17 +1,17 @@
 import type { RoutingId, ZLinkActor, ZLinkMessage, ZLinkMessageSerializer, ZLinkSpotActorJoinResult } from '../../contracts';
-import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
-import type { ZLinkBackendActorRef, ZLinkBackendActorRecvInfo, ZLinkBackendReceived, ZLinkBackendSpot, ZLinkBackendTopicMessage } from '../backend/contracts';
 import type { Message } from '../../contracts/Common/Message';
-import type { RequestResult } from '../backend/runtime-values';
-type RuntimeMessage = Message;
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkRemoteBoundSessionTarget } from '../actors';
-import type { ZLinkDispatchErrorReporter } from '../channels';
-import type { ZLinkSpotHandlerRegistration } from './spot-handler-registry';
-import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
-import type { ZLinkApplicationWorkClaim } from '../admission';
 import type { ZLinkActorHandoffPacket, ZLinkActorHandoffResult } from '../actors/actor-handoff';
+import type { ZLinkApplicationWorkClaim } from '../admission';
+import { type ZLinkBackendActorRecvInfo, type ZLinkBackendActorRef, type ZLinkBackendSpot, type ZLinkBackendTopicMessage } from '../backend/contracts';
+import type { RequestResult } from '../backend/runtime-values';
+import type { ZLinkDispatchErrorReporter } from '../channels';
 import type { ZLinkActorPacketDelivery } from './spot-actor-packet-dispatch';
+import type { ZLinkSpotHandlerRegistration } from './spot-handler-registry';
 import type { ZLinkSpotActorTransferRuntime, ZLinkSpotBoundSessionRuntime } from './spot-runtime-ports';
+import type { ZLinkSpotSerialTurnExecutor } from './spot-serial-turn-executor';
+type RuntimeMessage = Message;
 /**
  * Minimal lifecycle callback surface required by the native join and actor
  * lifecycle drains. User and Entry Spots differ in ownership policy, but both
@@ -33,13 +33,12 @@ interface ZLinkSpotActorAdmissionRuntime {
         readonly kind: 'enabled';
         readonly runtime: ZLinkSpotActorTransferRuntime;
     };
-    readonly commitNativeActor?: (actor: ZLinkActor) => Promise<void>;
     readonly commitActorDeparture?: (actorId: string) => void;
-    readonly commitTransferredActor?: (actor: ZLinkActor, backlog: readonly ZLinkActorHandoffPacket[]) => Promise<readonly ZLinkActorHandoffResult[]>;
+    readonly commitTransferredActor?: (actor: ZLinkActor, backlog: readonly ZLinkActorHandoffPacket[], sealedSession: ZLinkRemoteBoundSessionTarget | undefined) => Promise<readonly ZLinkActorHandoffResult[]>;
 }
 interface ZLinkSpotActorPacketRuntime {
     readonly handle: (delivery: ZLinkActorPacketDelivery) => Promise<unknown>;
-    readonly bindRemoteSession?: (actor: ZLinkBackendActorRef, sourceNodeRid: RoutingId, sourceSessionRid: RoutingId, declaredTarget?: ZLinkRemoteBoundSessionTarget) => void;
+    readonly bindRemoteSession?: (actor: ZLinkBackendActorRef, sourceNodeRid: RoutingId, sourceSessionRid: RoutingId) => void;
     readonly replyNoBind?: (info: ZLinkBackendActorRecvInfo, parts: readonly Message[], result: RequestResult) => void;
 }
 export interface ZLinkDetachedTaskRunner {
@@ -47,7 +46,6 @@ export interface ZLinkDetachedTaskRunner {
 }
 interface ZLinkSpotActorJoinDispatchOptions {
     readonly nativeSpot: ZLinkBackendSpot;
-    readonly createReceived: () => ZLinkBackendReceived;
     readonly createTopicMessage: () => ZLinkBackendTopicMessage;
     readonly serial: ZLinkSpotSerialTurnExecutor;
     readonly actors: ZLinkSpotActorAdmissionRuntime;
@@ -61,13 +59,10 @@ interface ZLinkSpotActorJoinDispatchOptions {
 }
 export declare class ZLinkSpotActorJoinDispatch {
     private readonly options;
-    private draining;
-    private redrainRequested;
     private readonly nativeSpotId;
     private readonly subscriptions;
     private readonly actorLifecycleDrain;
     private readonly actorPacketDrain;
-    private readonly nativeActorJoinAdmission;
     private readonly routedFrames;
     private readonly nativeSpot;
     constructor(options: ZLinkSpotActorJoinDispatchOptions);
@@ -76,8 +71,5 @@ export declare class ZLinkSpotActorJoinDispatch {
     dispose(): void;
     attach(): void;
     private runDetached;
-    private drain;
-    private redrainWasRequested;
-    private drainAvailableActorJoins;
 }
 export {};