@zlink-systems/framework 0.25.0 → 0.27.0

package/dist/runtime/spots/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkSpotManager = exports.ZLinkPublicSpotManager = exports.ZLinkSpotNodeRuntimeManager = exports.createFrameworkEntrySpotId = exports.ZLinkEntrySpotActivation = exports.ZLinkRuntimeSpotPublisherTransport = exports.DefaultZLinkSpotHandlerRegistry = exports.DefaultZLinkSpotOutbound = exports.ZLinkSpotTimerRegistry = exports.ZLinkManagedTimer = exports.ZLinkSpotSerialExecutor = exports.ZLinkSpotSerialTurnExecutor = exports.ZLinkSpotActorAdmissionCoordinator = exports.ZLinkSpotRoutedBoundSessionDispatch = exports.sendToSpotHandle = exports.requestToSpotHandle = exports.resolveSpotHandle = exports.createSpotHandle = void 0;
+const dispatch_error_details_1 = require("../diagnostics/dispatch-error-details");
 var spot_handle_1 = require("./spot-handle");
 Object.defineProperty(exports, "createSpotHandle", { enumerable: true, get: function () { return spot_handle_1.createSpotHandle; } });
 Object.defineProperty(exports, "resolveSpotHandle", { enumerable: true, get: function () { return spot_handle_1.resolveSpotHandle; } });
@@ -15,11 +16,13 @@ const abort_1 = require("../abort");
 const contracts_1 = require("../../contracts");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const diagnostics_1 = require("../diagnostics");
+const diagnostic_text_1 = require("../diagnostics/diagnostic-text");
 const runtime_message_1 = require("../backend/runtime-message");
 const runtime_values_1 = require("../backend/runtime-values");
 const service_runtime_contracts_1 = require("../foundation/service-runtime-contracts");
 const serial_work_size_1 = require("../execution/serial-work-size");
 const configuration_1 = require("../configuration");
+const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const workers_1 = require("../workers");
 const payload_codec_1 = require("../messaging/payload-codec");
@@ -44,7 +47,6 @@ Object.defineProperty(exports, "DefaultZLinkSpotHandlerRegistry", { enumerable:
 var spot_publisher_transport_1 = require("./spot-publisher-transport");
 Object.defineProperty(exports, "ZLinkRuntimeSpotPublisherTransport", { enumerable: true, get: function () { return spot_publisher_transport_1.ZLinkRuntimeSpotPublisherTransport; } });
 const spot_activation_registry_1 = require("./spot-activation-registry");
-const spot_activation_state_1 = require("./spot-activation-state");
 const spot_activation_1 = require("./spot-activation");
 const spot_actor_membership_1 = require("./spot-actor-membership");
 const formal_remote_actor_transfer_registry_1 = require("./formal-remote-actor-transfer-registry");
@@ -74,8 +76,7 @@ class DefaultZLinkSpotManager {
     //  callbacks (isInstanceMaterializing, sibling-generation lookups) resolve
     //  in O(1) instead of scanning every pending key.
     pendingInstanceMaterializationsByPrefix = new Map();
-    instanceActivationGates = new Map();
-    pendingInstanceCloses = new Map();
+    closeOperations = new Map();
     pendingInstanceTerminals = new Map();
     pendingInstanceTerminalGenerations = new Map();
     deferredInstanceAuthorityReleases = new Map();
@@ -83,6 +84,9 @@ class DefaultZLinkSpotManager {
     idleSweepRunning = false;
     constructor(options, timerClock) {
         this.options = options;
+        if (options.detachedTaskRunner === undefined) {
+            throw new configuration_1.ZLinkConfigurationException('Spot manager requires a detached task runner.');
+        }
         this.activations = new spot_activation_registry_1.ZLinkSpotActivationRegistry(options.metrics);
         this.factories = new Set(options.spotFactories);
         this.workerRuntime = options.workerRuntime ?? new workers_1.ZLinkWorkerRuntime();
@@ -93,7 +97,7 @@ class DefaultZLinkSpotManager {
             nodeGenerationProvider: options.nodeGenerationProvider
         });
         this.routedSpotPackets = new spot_routed_spot_packet_dispatch_1.ZLinkRoutedSpotPacketDispatch({
-            resolveActivation: (spotId) => this.activations.resolveUnique(spotId),
+            resolveActivation: (spotId) => this.resolveApplicationActivation(spotId),
             claimApplicationWork: options.admission === undefined
                 ? undefined
                 : (meshName) => options.admission.claim(meshName, 'Spot route dispatch'),
@@ -136,12 +140,12 @@ class DefaultZLinkSpotManager {
             spotRouterChannelIdForMesh: options.spotRouterChannelIdForMesh,
             providerResolver: options.providerResolver,
             dispatchErrors: options.dispatchErrors,
+            closeErrorSink: options.closeErrorSink,
             runtimeEventPublisher: options.runtimeEventPublisher,
             workerRuntime: this.workerRuntime,
             messageSerializers: options.messageSerializers,
             locationClaim: this.locationClaim,
             createNativeSpot: options.createNativeSpot,
-            createReceived: options.createReceived,
             createTopicMessage: options.createTopicMessage,
             nativeSpotNodeProvider: options.nativeSpotNodeProvider,
             actorResolver: options.actorResolver,
@@ -150,9 +154,9 @@ class DefaultZLinkSpotManager {
             boundSessionRuntime: options.boundSessionRuntime,
             actorHandoffRuntime: options.actorHandoffRuntime,
             admission: options.admission,
-            statefulExecutionAllowed: options.statefulExecutionAllowed,
+            statefulExecutionAllowed: options.statefulExecution?.admissionOpen,
             leaveActor: (spotId, actor, signal, meshName) => this.actorMembership.leaveActor(spotId, actor, signal, meshName),
-            closeSpot: (meshName, spotId, signal, reason) => this.closeWithReason(meshName, spotId, signal, reason),
+            requestContextClose: (activation, objectGeneration, signal) => this.closeFromContext(activation, objectGeneration, signal),
             registerActivation: (activation) => {
                 this.activations.register(activation);
                 this.scheduleIdleSweep();
@@ -199,10 +203,6 @@ class DefaultZLinkSpotManager {
     activeSpotCount(meshName) {
         return this.activations.list(meshName).length;
     }
-    instanceActivationConcurrency(meshName) {
-        const limit = this.options.activationConcurrencyLimitProvider?.(meshName) ?? 128;
-        return { active: this.instanceActivationGates.get(meshName)?.active ?? 0, limit };
-    }
     resolveRelocationActivation(meshName, spotId) {
         return this.activations.resolve(meshName, spotId);
     }
@@ -237,12 +237,12 @@ class DefaultZLinkSpotManager {
             await (0, abort_1.awaitWithAbort)(existing, signal);
             return;
         }
-        const release = await this.acquireInstanceActivation(meshName, signal);
+        const release = await this.options.activationAdmission?.acquire(meshName, signal);
         try {
             await this.materializeInstanceCore(meshName, instanceType, spotId, objectGeneration, readyTarget?.objectGeneration === objectGeneration, signal);
         }
         finally {
-            release();
+            release?.();
         }
     }
     async materializeInstanceCore(meshName, instanceType, spotId, objectGeneration, requiresReadyTarget, signal) {
@@ -260,7 +260,8 @@ class DefaultZLinkSpotManager {
             // explicit Instance intent arriving at that boundary must wait for the
             // old resources to be released before materializing the replacement.
             // This is lifecycle convergence; it does not resubmit application work.
-            const pendingClose = this.pendingInstanceCloses.get(key);
+            const closeOperation = this.closeOperations.get(key);
+            const pendingClose = closeOperation?.ready;
             if (pendingClose !== undefined) {
                 await (0, abort_1.awaitWithAbort)(pendingClose, signal);
                 continue;
@@ -340,71 +341,36 @@ class DefaultZLinkSpotManager {
             return;
         }
     }
-    async acquireInstanceActivation(meshName, signal) {
-        let gate = this.instanceActivationGates.get(meshName);
-        if (gate === undefined) {
-            gate = {
-                meshName,
-                limit: this.options.activationConcurrencyLimitProvider?.(meshName) ?? 128,
-                active: 0,
-                waiters: [],
-                waiterHead: 0
-            };
-            this.instanceActivationGates.set(meshName, gate);
-        }
-        if (signal?.aborted === true)
-            throw signal.reason;
-        if (gate.active < gate.limit) {
-            gate.active += 1;
-            this.options.onInstanceActivationConcurrencyChanged?.(meshName);
-            return () => this.releaseInstanceActivation(gate);
-        }
-        return new Promise((resolve, reject) => {
-            const waiter = { resolve, reject, signal, abort: undefined };
-            const slot = gate.waiters.length;
-            waiter.abort = () => {
-                if (gate.waiters[slot] === waiter)
-                    gate.waiters[slot] = undefined;
-                reject(signal?.reason);
-            };
-            signal?.addEventListener('abort', waiter.abort, { once: true });
-            gate.waiters.push(waiter);
-        });
-    }
-    releaseInstanceActivation(gate) {
-        while (gate.waiterHead < gate.waiters.length) {
-            const waiter = gate.waiters[gate.waiterHead];
-            gate.waiters[gate.waiterHead] = undefined;
-            gate.waiterHead += 1;
-            if (gate.waiterHead >= gate.waiters.length) {
-                gate.waiters.length = 0;
-                gate.waiterHead = 0;
-            }
-            if (waiter === undefined)
-                continue;
-            if (waiter.abort !== undefined)
-                waiter.signal?.removeEventListener('abort', waiter.abort);
-            waiter.resolve(() => this.releaseInstanceActivation(gate));
-            return;
-        }
-        gate.waiters.length = 0;
-        gate.waiterHead = 0;
-        gate.active -= 1;
-        this.options.onInstanceActivationConcurrencyChanged?.(gate.meshName);
-    }
     isInstanceMaterialized(meshName, instanceType, spotId) {
-        const activation = this.activations.resolve(meshName, spotId);
+        const activation = this.resolveApplicationActivation(spotId, meshName);
         return (activation !== undefined &&
             activation.spotType === this.requireInstanceFactory(meshName, instanceType));
     }
+    resolveApplicationActivation(spotId, meshName) {
+        const current = meshName === undefined
+            ? this.activations.resolveUnique(spotId)
+            : this.activations.resolve(meshName, spotId);
+        if (current !== undefined)
+            return current;
+        if (meshName !== undefined)
+            return this.closeOperations.get(`${meshName}\0${String(spotId)}`)?.activation;
+        for (const operation of this.closeOperations.values()) {
+            if (String(operation.activation.spotId) === String(spotId))
+                return operation.activation;
+        }
+        return undefined;
+    }
     isInstanceMaterializing(meshName, spotId) {
         const prefix = instanceMaterializationPrefix(meshName, spotId);
-        return (this.pendingInstanceMaterializationsByPrefix.get(prefix)?.size ?? 0) > 0;
+        return ((this.pendingInstanceMaterializationsByPrefix.get(prefix)?.size ?? 0) > 0 ||
+            this.closeOperations.get(`${meshName}\0${String(spotId)}`)?.authority !== undefined);
     }
-    isInstanceClosing(meshName, spotId) {
-        const key = `${meshName}\0${String(spotId)}`;
-        return (this.pendingInstanceCloses.has(key) ||
-            this.activations.closingOperation(meshName, spotId) !== undefined);
+    isSpotClosing(meshName, spotId) {
+        return (this.closeOperations.get(`${meshName}\0${String(spotId)}`)?.authority !== undefined ||
+            this.activations.activationForClose(meshName, spotId)?.executionBarrier.isCloseSealed === true);
+    }
+    pendingSpotCloseDecision(meshName, spotId) {
+        return this.closeOperations.get(`${meshName}\0${String(spotId)}`)?.authorityDecision;
     }
     async discardInstance(meshName, spotId) {
         const activation = this.activations.resolve(meshName, spotId);
@@ -443,7 +409,7 @@ class DefaultZLinkSpotManager {
         }
         this.pendingInstanceTerminals.delete(key);
         this.pendingInstanceTerminalGenerations.delete(key);
-        const pendingClose = this.pendingInstanceCloses.get(key);
+        const pendingClose = this.closeOperations.get(key)?.ready;
         if (pendingClose !== undefined) {
             this.deferInstanceAuthorityRelease(key, objectGeneration);
             await pendingClose;
@@ -539,39 +505,20 @@ class DefaultZLinkSpotManager {
                     !activation.beginIdleEviction()) {
                     continue;
                 }
-                let durableClosing;
-                try {
-                    durableClosing = await (this.options.beginInstanceIdleClosingAuthority?.(activation.meshName, activation.spotId) ?? Promise.resolve({ restoreReady: async () => undefined }));
-                }
-                catch (error) {
-                    activation.abortIdleEviction();
-                    throw error;
-                }
-                if (durableClosing === undefined) {
-                    activation.abortIdleEviction();
-                    continue;
-                }
                 const close = this.closeWithReason(activation.meshName, activation.spotId, undefined, contracts_1.ZLinkSpotCloseReason.IdleEvicted);
                 const run = async () => {
                     try {
                         const closed = await close;
-                        if (!closed) {
-                            await durableClosing.restoreReady();
+                        if (!closed)
                             activation.abortIdleEviction();
-                        }
                     }
                     catch (error) {
-                        if (error instanceof spot_activation_state_1.ZLinkSpotCloseOccupiedError) {
-                            await durableClosing.restoreReady();
-                        }
-                        activation.abortIdleEviction();
+                        if (!this.isSpotClosing(activation.meshName, activation.spotId))
+                            activation.abortIdleEviction();
                         throw error;
                     }
                 };
-                this.options.detachedTaskRunner?.runDetached(`instance idle eviction ${String(activation.spotId)}`, run);
-                if (this.options.detachedTaskRunner === undefined) {
-                    void run().catch(() => undefined);
-                }
+                this.options.detachedTaskRunner.runDetached(`instance idle eviction ${String(activation.spotId)}`, run);
             }
         }
         finally {
@@ -601,8 +548,9 @@ class DefaultZLinkSpotManager {
         requireMeshName(meshName);
         const args = normalizeSpotCreateArgs(requestOrSignal, signal);
         (0, abort_1.throwIfAborted)(args.signal);
+        this.options.admission?.requireRequest('SPOT create', meshName);
         const operation = this.activations.getOrBegin(meshName, spotType, spotId, async () => {
-            this.options.admission?.requireRequest('SPOT create', meshName);
+            const release = await this.options.activationAdmission?.acquire(meshName, args.signal);
             const ownedRequest = args.request === undefined
                 ? runtime_message_1.ZLinkBufferMessage.from(Buffer.alloc(0))
                 : (0, payload_codec_1.encodeFrameworkPayloadMessage)(args.request, this.options.messageSerializers);
@@ -611,17 +559,22 @@ class DefaultZLinkSpotManager {
             }
             finally {
                 ownedRequest.close();
+                release?.();
             }
         });
         return await (0, abort_1.awaitWithAbort)(operation.ready, args.signal);
     }
     async find(meshName, spotId) {
         requireMeshName(meshName);
-        return this.activations.has(meshName, spotId) ? { spotId } : null;
+        return this.activations.has(meshName, spotId) && !this.isSpotClosing(meshName, spotId)
+            ? { spotId }
+            : null;
     }
     async list(meshName) {
         requireMeshName(meshName);
-        return this.activations.list(meshName);
+        return this.activations
+            .list(meshName)
+            .filter(({ spotId }) => !this.isSpotClosing(meshName, spotId));
     }
     async drainForShutdown(meshName, signal, deadline) {
         const results = await Promise.allSettled(this.activations
@@ -639,99 +592,192 @@ class DefaultZLinkSpotManager {
     async close(meshName, spotId, signal) {
         return await this.closeWithReason(meshName, spotId, signal, contracts_1.ZLinkSpotCloseReason.ExplicitClose);
     }
-    async closeWithReason(meshName, spotId, signal, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose, deadline) {
+    async closeUserWithAuthority(meshName, spotId, beginAuthority, signal) {
+        return await this.closeWithReason(meshName, spotId, signal, contracts_1.ZLinkSpotCloseReason.ExplicitClose, undefined, beginAuthority);
+    }
+    closeFromContext(activation, objectGeneration, signal) {
+        const { meshName, spotId } = activation;
+        const operation = this.closeOperations.get(`${meshName}\0${String(spotId)}`);
+        const current = operation?.activation ?? this.activations.resolve(meshName, spotId);
+        if (current === undefined) {
+            return Promise.resolve(false);
+        }
+        if (current !== activation || current.objectGeneration !== objectGeneration) {
+            return Promise.reject((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Spot '${String(spotId)}' generation is stale.`));
+        }
+        const beginUserAuthority = activation.domain.kind === 'user' && this.options.beginUserClosingAuthority !== undefined
+            ? (onCommitted) => this.options.beginUserClosingAuthority(meshName, spotId, objectGeneration, onCommitted)
+            : undefined;
+        return this.closeWithReason(meshName, spotId, signal, contracts_1.ZLinkSpotCloseReason.ExplicitClose, undefined, beginUserAuthority);
+    }
+    async closeWithReason(meshName, spotId, signal, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose, deadline, beginUserAuthority) {
         requireMeshName(meshName);
         const key = `${meshName}\0${String(spotId)}`;
-        const closing = this.activations.closingOperation(meshName, spotId);
-        if (closing !== undefined) {
-            return await closing.ready;
+        let operation = this.closeOperations.get(key);
+        if (operation === undefined) {
+            const activation = this.activations.resolve(meshName, spotId);
+            if (activation === undefined)
+                return false;
+            if (activation.domain.kind === 'user' &&
+                reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose &&
+                beginUserAuthority === undefined) {
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `User Spot '${String(spotId)}' Close requires its authority owner.`);
+            }
+            const domain = activation.domain;
+            const beginAuthority = beginUserAuthority ??
+                (domain.kind === 'instance' &&
+                    reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose &&
+                    this.options.beginInstanceClosingAuthority !== undefined
+                    ? (onCommitted) => this.options.beginInstanceClosingAuthority(meshName, spotId, onCommitted, domain.objectGeneration)
+                    : domain.kind === 'instance' &&
+                        reason === contracts_1.ZLinkSpotCloseReason.IdleEvicted &&
+                        this.options.beginInstanceIdleClosingAuthority !== undefined
+                        ? (onCommitted) => this.options.beginInstanceIdleClosingAuthority(meshName, spotId, onCommitted)
+                        : async (onCommitted) => {
+                            onCommitted();
+                            return { release: async () => undefined };
+                        });
+            operation = {
+                activation,
+                reason,
+                beginAuthority
+            };
+            if (reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose) {
+                operation.canExecuteApplication = (record) => {
+                    const context = record.context;
+                    return context === undefined;
+                };
+            }
+            this.closeOperations.set(key, operation);
         }
-        const pendingClose = this.pendingInstanceCloses.get(key);
-        if (pendingClose !== undefined) {
-            const pendingActivation = this.activations.resolve(meshName, spotId);
-            if (pendingActivation?.serial.isCurrentTurn === true)
-                return true;
-            return await pendingClose;
+        if (operation.ready === undefined) {
+            const active = operation;
+            const run = active.activation.serial.executeControlLifecycleOperation(() => this.runCloseOperation(meshName, spotId, active, signal, deadline), active.canExecuteApplication === undefined
+                ? undefined
+                : active);
+            active.ready = run.finally(() => {
+                active.ready = undefined;
+                if (this.closeOperations.get(key) === active) {
+                    this.closeOperations.delete(key);
+                }
+            });
         }
-        const activation = this.activations.resolve(meshName, spotId);
-        if (activation === undefined) {
+        return await operation.ready;
+    }
+    async runCloseOperation(meshName, spotId, operation, signal, deadline) {
+        const seal = await this.beginCloseAuthority(meshName, spotId, operation, signal);
+        if (seal === undefined)
             return false;
+        if (seal !== true) {
+            await this.activationLifecycle.sealForClose(operation.activation, seal);
         }
-        const currentTurn = activation.serial.isCurrentTurn;
-        const isInstance = activation.domain.kind === 'instance';
-        const beginClose = () => {
-            const seal = activation.sealExecution();
-            const operation = this.activations.startClose(meshName, spotId, (target) => this.activationLifecycle.closeAfterSeal(target, seal, signal, reason, deadline), (target) => this.activationLifecycle.resourcesReleased(target), reason);
-            if (operation === undefined) {
-                activation.abortExecutionSeal(seal);
+        else {
+            await operation.activation.executionBarrier.waitForStartedTurns(signal);
+        }
+        const closingFailure = await this.activationLifecycle.cleanupClosedActivation(operation.activation, operation.reason, deadline);
+        this.activations.finishClose(meshName, spotId);
+        const intentRecords = [];
+        operation.activation.serial.visitPendingApplication((record) => {
+            const context = record.context;
+            if (context?.replay !== undefined)
+                intentRecords.push(record);
+        });
+        const hasIntent = intentRecords.length > 0;
+        // Spot messaging §7 step 3: with no Instance intent message waiting, the
+        // release decision also ends this Instance incarnation's admission in this turn.
+        if (!hasIntent && operation.activation.domain.kind === 'instance')
+            operation.activation.serial.closeAdmission();
+        const hostState = this.options.statefulExecution?.hostState();
+        const intentFailure = !hasIntent
+            ? undefined
+            : hostState === contracts_1.ZLinkFrameworkRuntimeState.Draining
+                ? (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown, 'Instance intent cannot continue while the host is draining.')
+                : hostState === contracts_1.ZLinkFrameworkRuntimeState.Relocating ||
+                    hostState === contracts_1.ZLinkFrameworkRuntimeState.Relocated ||
+                    this.options.statefulExecution?.admissionOpen() === false ||
+                    (operation.activation.executionBarrier.isSealed &&
+                        !operation.activation.executionBarrier.isCloseSealed)
+                    ? (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'Instance intent cannot continue on an unavailable or relocating owner.')
+                    : undefined;
+        if (operation.reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose &&
+            hasIntent &&
+            intentFailure === undefined &&
+            operation.authority?.reincarnate !== undefined) {
+            try {
+                await operation.authority.reincarnate(async (authority) => {
+                    await this.activationLifecycle.materializeInstance(meshName, authority.stableType, operation.activation.spotType, spotId, authority.objectGeneration, signal, operation.activation);
+                });
+                // The new incarnation shares this serial owner and admits membership work again.
+                operation.activation.serial.setLifecycleAdmissionClosed(false);
             }
-            return operation;
-        };
-        if (isInstance) {
-            const beginAuthorityClose = reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose
-                ? this.options.beginInstanceClosingAuthority
-                : undefined;
-            // Register the close gate before waiting for the current application
-            // and activation-authority terminal completions. A close requested from
-            // a handler cannot publish Closing until that handler's durable inbox
-            // completion has removed the recovery fence.
-            const trackedClosePromise = (async () => {
-                const waitForApplication = this.options.instanceSpotApplicationQuiescenceProvider?.(meshName, spotId, signal);
-                if (waitForApplication !== undefined) {
-                    await waitForApplication;
-                }
-                const closingAuthority = beginAuthorityClose === undefined
-                    ? undefined
-                    : await beginAuthorityClose(meshName, spotId);
-                if (beginAuthorityClose !== undefined && closingAuthority === undefined) {
-                    return false;
-                }
-                const operation = beginClose();
-                if (operation === undefined) {
-                    await closingAuthority?.restoreReady();
-                    return false;
-                }
-                const closed = await operation.ready;
-                if (!closed)
-                    await closingAuthority?.restoreReady();
-                return closed;
-            })().finally(() => {
-                if (this.pendingInstanceCloses.get(key) === trackedClosePromise) {
-                    this.pendingInstanceCloses.delete(key);
+            catch (error) {
+                const initialized = this.activations.resolve(meshName, spotId);
+                if (initialized !== undefined && initialized !== operation.activation) {
+                    await this.activationLifecycle.cleanupFailedIncarnation(initialized);
                 }
-            });
-            this.pendingInstanceCloses.set(key, trackedClosePromise);
-            if (currentTurn) {
-                // The current turn must return before its terminal completion can
-                // release the activation recovery fence and allow the durable close
-                // CAS. The registered close gate prevents a second admission while
-                // that detached close finishes.
-                this.options.detachedTaskRunner?.runDetached(`instance spot close ${String(spotId)}`, async () => {
-                    await trackedClosePromise;
+                this.activations.finishClose(meshName, spotId);
+                operation.activation.serial.visitPendingApplication((record) => {
+                    const context = record.context;
+                    if (context?.replay !== undefined)
+                        record.operation = () => context.replay(error);
                 });
-                if (this.options.detachedTaskRunner === undefined) {
-                    void trackedClosePromise.catch(() => undefined);
-                }
-                return true;
+                operation.activation.serial.closeAdmission();
+                throw error;
             }
-            return await trackedClosePromise;
-        }
-        const operation = beginClose();
-        if (operation === undefined) {
-            return false;
         }
-        if (currentTurn) {
-            if (operation.started) {
-                this.options.detachedTaskRunner?.runDetached(`spot close ${String(spotId)}`, async () => {
-                    await operation.ready;
-                });
-                if (this.options.detachedTaskRunner === undefined) {
-                    void operation.ready.catch(() => undefined);
+        else {
+            await operation.authority?.release();
+            operation.activation.serial.closeAdmission();
+            if (!operation.activation.executionBarrier.isSealed) {
+                const closed = operation.activation.sealExecution('close');
+                operation.activation.commitExecutionSeal(closed);
+            }
+        }
+        if (operation.reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose) {
+            operation.activation.serial.visitPendingApplication((record) => {
+                const context = record.context;
+                if (context?.replay !== undefined) {
+                    record.operation =
+                        intentFailure === undefined ? context.replay : () => context.replay(intentFailure);
                 }
+            });
+        }
+        this.closeOperations.delete(`${meshName}\0${String(spotId)}`);
+        // An OnClosing failure never changes a Close result; host shutdown alone
+        // reports it as its teardown outcome after cleanup has finished.
+        if (closingFailure !== undefined && operation.reason === contracts_1.ZLinkSpotCloseReason.HostShutdown) {
+            throw closingFailure;
+        }
+        return true;
+    }
+    async beginCloseAuthority(meshName, spotId, operation, signal) {
+        // Spot messaging §4 step 12 with §7 step 1: a Close of any reason begins its
+        // Closing CAS only after the first terminal record of an activated message.
+        await this.options.instanceSpotApplicationQuiescenceProvider?.(meshName, spotId, signal);
+        if (!operation.activation.canClose(operation.reason))
+            return undefined;
+        if (operation.activation.executionBarrier.isSealed) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `Spot '${String(spotId)}' is sealed for relocation.`, true);
+        }
+        let seal;
+        const authorityPromise = Promise.resolve().then(() => operation.beginAuthority(() => {
+            if (operation.reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose) {
+                operation.activation.serial.setLifecycleAdmissionClosed(true);
+                seal = true;
             }
-            return true;
+            else {
+                seal = operation.activation.sealExecution('close');
+            }
+        }));
+        operation.authorityDecision = authorityPromise.then(() => undefined, () => undefined);
+        const authority = await authorityPromise;
+        if (authority === undefined)
+            return undefined;
+        operation.authority = authority;
+        if (seal === undefined) {
+            throw new Error(`Spot '${String(spotId)}' Closing authority did not confirm its commit.`);
         }
-        return await operation.ready;
+        return seal;
     }
     async executeOnSpot(spotType, spotId, operation, signal) {
         (0, abort_1.throwIfAborted)(signal);
@@ -750,9 +796,6 @@ class DefaultZLinkSpotManager {
     hasActiveSpot(spotId) {
         return this.activations.resolveUnique(spotId) !== undefined;
     }
-    canCloseUserSpot(meshName, spotId) {
-        return this.activations.canClose(meshName, spotId);
-    }
     beginUserSpotPublication(meshName, spotId) {
         this.activations.stage(meshName, spotId);
     }
@@ -783,6 +826,9 @@ class DefaultZLinkSpotManager {
     async admitActorJoin(spotId, actor, request, commit, signal, leaveSource, contentType = 'application/json') {
         const meshName = this.activations.resolveUnique(spotId)?.meshName;
         this.options.admission?.requireRequest('Actor join admission', meshName);
+        if (meshName !== undefined && this.isSpotClosing(meshName, spotId)) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `Spot '${String(spotId)}' is closing.`);
+        }
         return await this.actorMembership.admitActorJoin(spotId, actor, request, commit, signal, leaveSource, contentType);
     }
     async leaveActor(spotId, actor, signal) {
@@ -884,7 +930,7 @@ class DefaultZLinkSpotManager {
             requireMeshSpotReply(record.reply((0, channel_envelope_1.encodeChannelReplyParts)(envelope.header, response, codecs)));
         }
         catch (error) {
-            requireMeshSpotReply(record.reply((0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error instanceof Error ? error.message : String(error))));
+            requireMeshSpotReply(record.reply((0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error)));
         }
     }
     async ensureInstanceApplicationActivation(meshName, spotId) {
@@ -892,7 +938,7 @@ class DefaultZLinkSpotManager {
         if (target === undefined)
             return;
         for (;;) {
-            const current = this.activations.resolve(meshName, spotId);
+            const current = this.resolveApplicationActivation(spotId, meshName);
             if (current !== undefined &&
                 current.objectGeneration === target.objectGeneration &&
                 current.spotType === this.requireInstanceFactory(meshName, target.stableType))
@@ -919,7 +965,7 @@ class DefaultZLinkSpotManager {
             this.traceInstanceMessage(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Received, meshName, spotId, record, envelope, 'activating');
             try {
                 await this.ensureInstanceApplicationActivation(meshName, spotId);
-                const activation = this.activations.resolve(meshName, spotId);
+                const activation = this.resolveApplicationActivation(spotId, meshName);
                 if (activation === undefined || activation.domain.kind !== 'instance') {
                     throw new configuration_1.ZLinkConfigurationException(`MeshNode Instance Spot target '${String(spotId)}' is not active.`);
                 }
@@ -936,9 +982,26 @@ class DefaultZLinkSpotManager {
                     channelName: envelope.header.channelName,
                     contentType: envelope.header.contentType,
                     awaitFirstHandlerTurn: record.kind === service_runtime_contracts_1.ReceiveKind.InstanceSpotActivation,
+                    activationRecord: record,
+                    onOneWayError: this.options.dispatchErrors?.captureEnabled() === true
+                        ? (error) => this.reportInstanceDispatchFailure(meshName, spotId, record, envelope, false, error)
+                        : undefined,
                     workOptions: (0, serial_work_size_1.zlinkSerialWorkOptions)(envelope.payload.byteLength, record.applicationMetadata?.byteLength ??
                         (0, serial_work_size_1.zlinkMetadataByteLength)(envelope.header.metadata))
                 };
+                // Spot messaging §7 step 3: an Instance intent request that reaches an
+                // incarnation whose Close ended admission is refused before admission
+                // with the owner fence terminal, so its caller re-reads authority.
+                const instanceIntent = record.activationRecord?.activation === 'missing' ||
+                    (record.activationRecord?.activation === 'ready' &&
+                        record.activationRecord.instanceIntent);
+                const refusal = activation.serial.applicationAdmissionRefusal(instanceIntent === true);
+                if (request && refusal !== undefined && record.replyFailure !== undefined) {
+                    this.reportInstanceDispatchFailure(meshName, spotId, record, envelope, request, refusal);
+                    const terminal = (0, framework_errors_internal_1.internalFrameworkWireReply)(refusal);
+                    requireMeshSpotReply(record.replyFailure(terminal.terminalResult, terminal.failureCode));
+                    return;
+                }
                 this.traceInstanceMessage(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Admitted, meshName, spotId, record, envelope, 'ready', target?.stableType);
                 if (!request) {
                     this.traceInstanceMessage(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dispatched, meshName, spotId, record, envelope, 'ready', target?.stableType);
@@ -952,33 +1015,39 @@ class DefaultZLinkSpotManager {
                 this.traceInstanceMessage(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Replied, meshName, spotId, record, envelope, 'ready', target?.stableType);
             }
             catch (error) {
-                const reason = instanceDispatchErrorReason(error);
+                this.reportInstanceDispatchFailure(meshName, spotId, record, envelope, request, error);
+                const reason = (0, dispatch_error_details_1.dispatchReasonFromError)(error);
                 if (!request) {
                     this.traceInstanceMessage(ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped, meshName, spotId, record, envelope, 'closing', undefined, reason);
                     return;
                 }
-                this.options.dispatchErrors?.report({
-                    surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.InstanceSpot,
-                    messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request,
-                    packetName: envelope.packetName,
-                    channelName: envelope.header.channelName,
-                    meshName,
-                    correlationId: envelope.header.correlationId ?? undefined,
-                    sourceRid: record.sourceNodeRid === null ? undefined : String(record.sourceNodeRid),
-                    spotId: String(spotId),
-                    instanceSpotType: this.options.instanceSpotApplicationTargetProvider?.(meshName, spotId)
-                        ?.stableType,
-                    activationState: 'closing',
-                    flowId: envelope.header.flowId,
-                    flowOrigin: envelope.header.flowOrigin,
-                    reason,
-                    action: ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.ReplyError,
-                    error
-                });
-                requireMeshSpotReply(record.reply((0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error instanceof Error ? error.message : String(error))));
+                requireMeshSpotReply(record.reply((0, channel_envelope_1.encodeChannelErrorReplyParts)(envelope.header, error)));
             }
         });
     }
+    reportInstanceDispatchFailure(meshName, spotId, record, envelope, request, error) {
+        const reporter = this.options.dispatchErrors;
+        if (reporter?.captureEnabled() !== true)
+            return;
+        reporter.report({
+            surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.InstanceSpot,
+            messageKind: request ? ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request : ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Send,
+            packetName: envelope.packetName,
+            channelName: envelope.header.channelName,
+            meshName,
+            correlationId: envelope.header.correlationId ?? undefined,
+            sourceRid: record.sourceNodeRid === null ? undefined : String(record.sourceNodeRid),
+            spotId: String(spotId),
+            instanceSpotType: this.options.instanceSpotApplicationTargetProvider?.(meshName, spotId)
+                ?.stableType,
+            activationState: 'closing',
+            flowId: envelope.header.flowId,
+            flowOrigin: envelope.header.flowOrigin,
+            reason: (0, dispatch_error_details_1.dispatchReasonFromError)(error),
+            action: request ? ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.ReplyError : ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorAction.Drop,
+            error
+        });
+    }
     traceInstanceMessage(outcome, meshName, spotId, record, envelope, activationState, instanceSpotType, errorReason) {
         const flow = (0, diagnostics_1.flowIfEnabled)(this.options.dispatchErrors?.flow, outcome, undefined, envelope.header.flowId);
         if (flow === undefined)
@@ -1011,9 +1080,6 @@ class DefaultZLinkSpotManager {
             throw new configuration_1.ZLinkConfigurationException('MeshNode Actor record is missing its Actor owner.');
         }
         const request = record.kind === service_runtime_contracts_1.ReceiveKind.ActorRequest;
-        if (record.sourceBindingGeneration > 0n) {
-            this.options.actorBindingGenerationObserver?.(actor.actorId, record.sourceBindingGeneration);
-        }
         const resolvedOwner = this.options.actorDispatchOwnerResolver?.(actor.actorId);
         const resolvedActorRef = resolvedOwner?.actorRef ?? {
             actorId: actor.actorId,
@@ -1067,13 +1133,41 @@ class DefaultZLinkSpotManager {
             }
             requireMeshSpotReply(record.reply(this.encodeMeshActorReply(record.parts[0], protocol_1.ZLinkStreamMessageKind.Error, {
                 message: error instanceof Error ? error.message : String(error),
-                kind: error instanceof contracts_1.ZLinkFrameworkException
-                    ? error.kind
-                    : contracts_1.ZLinkFrameworkErrorKind.InternalFailure
+                kind: spotActorFailureKind(error)
             })));
         }
     }
     async dispatchMeshActorJoin(meshName, owner, record) {
+        const spotId = owner.spotId;
+        const activation = spotId === null ? undefined : this.activations.resolve(meshName, spotId);
+        const replyState = { targetCommitPublished: false };
+        try {
+            if (record.kindData?.kind === 'actorControl' &&
+                record.kindData.canonicalActorJoin !== undefined) {
+                const entrySpotId = this.options.entryNodeRidProvider?.() ?? this.options.entryNodeRid;
+                if (spotId !== null && entrySpotId !== undefined && String(spotId) === String(entrySpotId)
+                    ? this.options.dispatchEntryActorJoin === undefined
+                    : activation === undefined) {
+                    throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `Spot '${String(spotId)}' is not active on this node.`);
+                }
+            }
+            if (activation?.domain.kind === 'user') {
+                await activation.serial.executeLifecycleOperation(() => this.dispatchMeshActorJoinCore(meshName, owner, record, replyState));
+                return;
+            }
+            await this.dispatchMeshActorJoinCore(meshName, owner, record, replyState);
+        }
+        catch (error) {
+            if (replyState.targetCommitPublished || record.replyFailure === undefined)
+                throw error;
+            const failure = error instanceof contracts_1.ZLinkFrameworkException
+                ? error
+                : (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestFailed, 'Actor Join target admission failed.', error);
+            const terminal = (0, framework_errors_internal_1.internalFrameworkWireReply)(failure);
+            requireMeshSpotReply(record.replyFailure(terminal.terminalResult, terminal.failureCode));
+        }
+    }
+    async dispatchMeshActorJoinCore(meshName, owner, record, replyState) {
         const spotId = owner.spotId;
         const control = record.kindData;
         if (control?.kind !== 'actorControl') {
@@ -1126,15 +1220,11 @@ class DefaultZLinkSpotManager {
             admissionRecord = provisional.record;
             canonicalAdmissionCreated = provisional.created;
             try {
+                (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
                 canonicalActorType = (await resolver({ actorId, ...control.canonicalActorJoin })).actorType;
             }
             catch (error) {
                 this.formalRemoteActorAdmissions.fail(control.canonicalActorJoin.handoffId, error);
-                if (error instanceof contracts_1.ZLinkFrameworkException && record.replyFailure !== undefined) {
-                    const terminal = (0, framework_errors_internal_1.internalFrameworkWireReply)(error);
-                    requireMeshSpotReply(record.replyFailure(terminal.terminalResult, terminal.failureCode));
-                    return;
-                }
                 throw error;
             }
         }
@@ -1157,12 +1247,11 @@ class DefaultZLinkSpotManager {
         let ownedCallbackRequest;
         let materialized = false;
         let reply;
-        let deferredJoinRoot;
+        let deferredJoinCompletion;
         let preparedTransferState;
         let admissionOutcome;
         let accepted = false;
         let committedAdmissionReplay = isRemoteCommit && admissionRecord?.state === 'committed';
-        let targetCommitPublished;
         const actorJoinIsCurrent = () => (record.deadlineUnixMs === undefined || record.deadlineUnixMs > BigInt(Date.now())) &&
             (record.isPending?.() ?? true);
         const abandonStaleAdmission = () => {
@@ -1213,13 +1302,10 @@ class DefaultZLinkSpotManager {
                 if (canonicalAdmissionCreated) {
                     if (targetsEntrySpot) {
                         admissionOutcome = {
-                            accepted: this.options.dispatchEntryActorJoin !== undefined,
+                            accepted: true,
                             actorRef
                         };
                     }
-                    else if (activation === undefined) {
-                        admissionOutcome = { accepted: false, actorRef };
-                    }
                     else {
                         const response = await activation.serial.execute(async () => activation.spot.onActorJoin(actorRef.actorId, (0, payload_codec_1.wrapFrameworkPayloadMessage)(callbackRequest, this.options.messageSerializers, requestContentType)));
                         let encodedReply;
@@ -1286,13 +1372,13 @@ class DefaultZLinkSpotManager {
                             if (this.options.dispatchEntryActorJoin !== undefined &&
                                 transferRequest.completionOperationId !== undefined &&
                                 this.options.actorTransferRuntime !== undefined) {
-                                deferredJoinRoot =
-                                    await this.options.actorTransferRuntime.prepareDeferredJoinAccepted(actorId, transferRequest.completionOperationId, actorRef, Buffer.alloc(0));
+                                deferredJoinCompletion =
+                                    this.options.actorTransferRuntime.prepareDeferredJoinAccepted(actorId, transferRequest.completionOperationId, actorRef, Buffer.alloc(0));
                             }
                             admissionOutcome = {
                                 accepted: this.options.dispatchEntryActorJoin !== undefined,
                                 actorRef,
-                                ...(deferredJoinRoot === undefined ? {} : { deferredJoinRoot })
+                                ...(deferredJoinCompletion === undefined ? {} : { deferredJoinCompletion })
                             };
                         }
                         else if (activation === undefined) {
@@ -1313,8 +1399,8 @@ class DefaultZLinkSpotManager {
                                 if (response.accepted &&
                                     transferRequest.completionOperationId !== undefined &&
                                     this.options.actorTransferRuntime !== undefined) {
-                                    deferredJoinRoot =
-                                        await this.options.actorTransferRuntime.prepareDeferredJoinAccepted(actorId, transferRequest.completionOperationId, actorRef, encodedReply?.data() ?? Buffer.alloc(0), encodedReply === undefined
+                                    deferredJoinCompletion =
+                                        this.options.actorTransferRuntime.prepareDeferredJoinAccepted(actorId, transferRequest.completionOperationId, actorRef, encodedReply?.data() ?? Buffer.alloc(0), encodedReply === undefined
                                             ? undefined
                                             : (0, payload_codec_1.frameworkPayloadContentType)(encodedReply));
                                     this.options.runtimeEventPublisher?.publish({
@@ -1327,7 +1413,7 @@ class DefaultZLinkSpotManager {
                                 admissionOutcome = {
                                     accepted: response.accepted,
                                     actorRef,
-                                    ...(deferredJoinRoot === undefined ? {} : { deferredJoinRoot }),
+                                    ...(deferredJoinCompletion === undefined ? {} : { deferredJoinCompletion }),
                                     ...(encodedReply === undefined
                                         ? {}
                                         : {
@@ -1366,7 +1452,7 @@ class DefaultZLinkSpotManager {
                 if ('error' in admissionOutcome) {
                     throw admissionOutcome.error;
                 }
-                deferredJoinRoot = admissionOutcome.deferredJoinRoot;
+                deferredJoinCompletion = admissionOutcome.deferredJoinCompletion;
             }
             if (actor === undefined &&
                 transferRequest !== undefined &&
@@ -1436,7 +1522,7 @@ class DefaultZLinkSpotManager {
                 if (accepted &&
                     transferRequest?.completionOperationId !== undefined &&
                     this.options.actorTransferRuntime !== undefined) {
-                    deferredJoinRoot = await this.options.actorTransferRuntime.prepareDeferredJoinAccepted(actorId, transferRequest.completionOperationId, actorRef, reply?.data() ?? Buffer.alloc(0), reply === undefined ? undefined : (0, payload_codec_1.frameworkPayloadContentType)(reply));
+                    deferredJoinCompletion = this.options.actorTransferRuntime.prepareDeferredJoinAccepted(actorId, transferRequest.completionOperationId, actorRef, reply?.data() ?? Buffer.alloc(0), reply === undefined ? undefined : (0, payload_codec_1.frameworkPayloadContentType)(reply));
                     this.options.runtimeEventPublisher?.publish({
                         sourceName: 'zlink.framework.actor-handoff',
                         timestamp: new Date(),
@@ -1474,16 +1560,6 @@ class DefaultZLinkSpotManager {
                     return;
                 }
             }
-            if (accepted &&
-                transferRequest !== undefined &&
-                this.options.actorTransferRuntime !== undefined &&
-                !isRemoteAdmission) {
-                // A lightweight Core actor-join notification can create the Actor
-                // before the formal transfer request reaches this branch. Preserve
-                // the full relocation fence in that race so a later Session bind
-                // refresh cannot erase the seal or accepted journal.
-                this.options.actorTransferRuntime.rememberRoutedActorTransferTarget(actorId, transferRequest.remoteBoundSessionTarget);
-            }
             if (accepted &&
                 actor !== undefined &&
                 transferRequest !== undefined &&
@@ -1494,7 +1570,8 @@ class DefaultZLinkSpotManager {
                     spotId,
                     transferId: transferRequest.transferId,
                     handoffBacklog: transferRequest.handoffBacklog,
-                    deferredJoinRoot
+                    deferredJoinCompletion,
+                    sealedSession: transferRequest.remoteBoundSessionTarget
                 });
                 if (isRemoteCommit && admissionRecord !== undefined) {
                     this.formalRemoteActorAdmissions.markCommitted(transferRequest.transferId, actor);
@@ -1510,7 +1587,7 @@ class DefaultZLinkSpotManager {
                     // Core commits the target membership while it accepts this reply.
                     // From this call onward a later callback/transport failure is
                     // post-commit and must not roll the materialized Actor back.
-                    targetCommitPublished = true;
+                    replyState.targetCommitPublished = true;
                 }
                 requireMeshSpotReply(joinReplyResult);
                 return true;
@@ -1540,38 +1617,52 @@ class DefaultZLinkSpotManager {
                         return;
                     const commitEntryTransfer = async () => {
                         try {
-                            await this.options.dispatchEntryActorJoin?.(meshName, entryActor, []);
-                        }
-                        finally {
-                            this.formalRemoteTransfers.completeTargetLifecycle(entryActor.context.actorId, pendingTransfer.transferId);
-                        }
-                        const sourceLeaveSubmitted = await pendingTransfer.sourceLeaveSubmitted;
-                        if (!sourceLeaveSubmitted) {
-                            throw new Error(`Actor '${entryActor.context.actorId}' source authority commit failed before leave submission.`);
+                            try {
+                                await this.options.dispatchEntryActorJoin?.(meshName, entryActor, []);
+                            }
+                            finally {
+                                this.formalRemoteTransfers.completeTargetLifecycle(entryActor.context.actorId, pendingTransfer.transferId);
+                            }
+                            const sourceLeaveSubmitted = await pendingTransfer.sourceLeaveSubmitted;
+                            if (!sourceLeaveSubmitted) {
+                                throw new Error(`Actor '${entryActor.context.actorId}' source authority commit failed before leave submission.`);
+                            }
+                            const handoffResults = await (0, actor_handoff_1.replayActorHandoffBacklog)(pendingTransfer.handoffBacklog, async (parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => {
+                                if (this.options.dispatchEntryActorPacket === undefined) {
+                                    throw new Error('Entry Spot saved handoff replay requires its Actor packet runtime.');
+                                }
+                                return await this.options.dispatchEntryActorPacket(entryActor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
+                            }, (index) => this.options.runtimeEventPublisher?.publish({
+                                sourceName: 'zlink.framework.actor-handoff',
+                                timestamp: new Date(),
+                                marker: 'backlog_enqueued',
+                                actorId: entryActor.context.actorId,
+                                index
+                            }));
+                            const failedHandoff = handoffResults.find((result) => !result.ok);
+                            if (failedHandoff !== undefined) {
+                                throw new Error(`Actor '${entryActor.context.actorId}' saved Entry handoff packet ` +
+                                    `${failedHandoff.index} failed: ${(0, diagnostic_text_1.diagnosticTextOrAbsent)(failedHandoff.error)}.`);
+                            }
                         }
-                        const handoffResults = await (0, actor_handoff_1.replayActorHandoffBacklog)(pendingTransfer.handoffBacklog, async (parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => {
-                            if (this.options.dispatchEntryActorPacket === undefined) {
-                                throw new Error('Entry Spot saved handoff replay requires its Actor packet runtime.');
+                        catch (error) {
+                            const completion = pendingTransfer.deferredJoinCompletion;
+                            if (completion !== undefined) {
+                                await this.options.actorTransferRuntime?.deliverDeferredJoinCompletion({
+                                    ...completion,
+                                    status: 'failed',
+                                    kind: spotActorFailureKind(error)
+                                }, entryActor, completion.actor, (operation) => this.options.executeEntryActor(meshName, entryActor.context.actorId, operation));
                             }
-                            return await this.options.dispatchEntryActorPacket(entryActor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
-                        }, (index) => this.options.runtimeEventPublisher?.publish({
-                            sourceName: 'zlink.framework.actor-handoff',
-                            timestamp: new Date(),
-                            marker: 'backlog_enqueued',
-                            actorId: entryActor.context.actorId,
-                            index
-                        }));
-                        const failedHandoff = handoffResults.find((result) => !result.ok);
-                        if (failedHandoff !== undefined) {
-                            throw new Error(`Actor '${entryActor.context.actorId}' saved Entry handoff packet ` +
-                                `${failedHandoff.index} failed: ${failedHandoff.error ?? 'unknown error'}.`);
+                            throw error;
+                        }
+                        const completion = pendingTransfer.deferredJoinCompletion;
+                        if (completion !== undefined) {
+                            await this.options.actorTransferRuntime?.deliverDeferredJoinCompletion(completion, entryActor, completion.actor, (operation) => this.options.executeEntryActor(meshName, entryActor.context.actorId, operation));
                         }
                         this.formalRemoteTransfers.delete(entryActor.context.actorId);
                     };
-                    this.options.detachedTaskRunner?.runDetached(`actor Entry Spot transfer ${entryActor.context.actorId}`, commitEntryTransfer);
-                    if (this.options.detachedTaskRunner === undefined) {
-                        void commitEntryTransfer().catch(() => undefined);
-                    }
+                    this.options.detachedTaskRunner.runDetached(`actor Entry Spot transfer ${entryActor.context.actorId}`, commitEntryTransfer);
                 }
             }
             else {
@@ -1583,13 +1674,10 @@ class DefaultZLinkSpotManager {
             if (control.canonicalActorJoin !== undefined) {
                 this.formalRemoteActorAdmissions.fail(control.canonicalActorJoin.handoffId, error);
             }
-            if (deferredJoinRoot !== undefined && targetCommitPublished !== true) {
-                await this.options.actorTransferRuntime?.discardDeferredJoinAccepted(deferredJoinRoot);
-            }
-            if (targetCommitPublished !== true) {
+            if (!replyState.targetCommitPublished) {
                 this.formalRemoteTransfers.delete(actorId);
             }
-            if (materialized && targetCommitPublished !== true) {
+            if (materialized && !replyState.targetCommitPublished) {
                 await this.options.actorTransferRuntime?.rollbackRoutedActor(actor);
             }
             throw error;
@@ -1602,6 +1690,31 @@ class DefaultZLinkSpotManager {
         }
     }
     async dispatchMeshSpotControl(meshName, owner, record) {
+        const spotId = owner.spotId;
+        const activation = spotId === null ? undefined : this.activations.resolve(meshName, spotId);
+        if (activation?.domain.kind === 'user') {
+            const transfer = { terminal: undefined };
+            const operation = activation.serial.executeLifecycleOperation(async () => {
+                await this.dispatchMeshSpotControlCore(meshName, owner, record, (terminal) => {
+                    transfer.terminal = terminal;
+                });
+                await transfer.terminal;
+            });
+            const control = record.kindData;
+            const actorId = control?.kind === 'actorControl' ? control.currentActor?.actorId : undefined;
+            if (control?.kind === 'actorControl' &&
+                control.lifecycleKind === service_runtime_contracts_1.ActorLifecycleKind.Joined &&
+                actorId !== undefined &&
+                this.formalRemoteTransfers.get(actorId) !== undefined) {
+                this.options.detachedTaskRunner.runDetached(`actor transfer target commit ${actorId}`, async () => await operation);
+                return;
+            }
+            await operation;
+            return;
+        }
+        await this.dispatchMeshSpotControlCore(meshName, owner, record);
+    }
+    async dispatchMeshSpotControlCore(meshName, owner, record, onDetachedTerminal) {
         const spotId = owner.spotId;
         const control = record.kindData;
         if (control?.kind !== 'actorControl') {
@@ -1664,15 +1777,15 @@ class DefaultZLinkSpotManager {
                     await activation.spot.onJoinedActor(actor);
                 };
                 const completePublicJoin = async () => {
-                    const deferredJoinRoot = pendingTransfer?.deferredJoinRoot;
-                    if (deferredJoinRoot !== undefined) {
+                    const deferredJoinCompletion = pendingTransfer?.deferredJoinCompletion;
+                    if (deferredJoinCompletion !== undefined) {
                         const currentRef = this.options.actorTransferRuntime === undefined
                             ? null
                             : control.currentActor;
                         if (currentRef === null) {
                             throw new Error(`Actor '${actor.context.actorId}' has no target ref for deferred Join completion.`);
                         }
-                        await this.options.actorTransferRuntime?.commitAndDeliverDeferredJoinAccepted(deferredJoinRoot, actor, currentRef, (operation) => activation.executeActor(actor.context.actorId, async () => await operation()));
+                        await this.options.actorTransferRuntime?.deliverDeferredJoinCompletion(deferredJoinCompletion, actor, currentRef, (operation) => activation.executeActor(actor.context.actorId, async () => await operation()));
                     }
                 };
                 const completeTargetReady = async () => {
@@ -1687,7 +1800,7 @@ class DefaultZLinkSpotManager {
                         const failedHandoff = handoffResults.find((result) => !result.ok);
                         if (failedHandoff !== undefined) {
                             throw new Error(`Actor '${actor.context.actorId}' saved handoff packet ` +
-                                `${failedHandoff.index} failed: ${failedHandoff.error ?? 'unknown error'}.`);
+                                `${failedHandoff.index} failed: ${(0, diagnostic_text_1.diagnosticTextOrAbsent)(failedHandoff.error)}.`);
                         }
                         // Spec 15 §4.2 relocation temporary queue: arrivals parked at
                         // this target directly (not relayed through the source's
@@ -1700,13 +1813,14 @@ class DefaultZLinkSpotManager {
                         // the Session binding aggregate after this boundary.
                         this.formalRemoteTransfers.delete(actor.context.actorId);
                     }
+                    const sealedSession = pendingTransfer?.sealedSession;
                     const updateBoundSessionRoute = async () => {
-                        await this.options.actorTransferRuntime?.publishRoutedActorOwnership(actor);
+                        await this.options.actorTransferRuntime?.publishRoutedActorOwnership(actor, sealedSession);
                         await this.options.actorTransferRuntime?.openRoutedActorSession(actor);
                     };
-                    // Session routing is an independent post-Ready branch. Callback
-                    // sends are retained by the Session owner seal until this converges.
-                    if (pendingTransfer !== undefined && this.options.detachedTaskRunner !== undefined) {
+                    // Session routing is an independent post-Ready branch. The Session
+                    // owner submits current-binding pushes while the route seal remains installed.
+                    if (pendingTransfer !== undefined) {
                         this.options.detachedTaskRunner.runDetached(`actor transfer Session route ${actor.context.actorId}`, updateBoundSessionRoute);
                     }
                     else {
@@ -1730,9 +1844,12 @@ class DefaultZLinkSpotManager {
                         // them only after the lifecycle turn above has been released.
                         await completeTargetReady();
                     };
-                    this.options.detachedTaskRunner?.runDetached(`actor transfer target commit ${actor.context.actorId}`, resume);
-                    if (this.options.detachedTaskRunner === undefined) {
-                        void resume().catch(() => undefined);
+                    const terminal = resume();
+                    if (onDetachedTerminal !== undefined) {
+                        onDetachedTerminal(terminal);
+                    }
+                    else {
+                        this.options.detachedTaskRunner.runDetached(`actor transfer target commit ${actor.context.actorId}`, async () => await terminal);
                     }
                     return;
                 }
@@ -1782,33 +1899,52 @@ class DefaultZLinkSpotManager {
         }
         const entrySpotId = this.options.entryNodeRidProvider?.() ?? this.options.entryNodeRid;
         const targetsEntry = entrySpotId !== undefined && String(admission.admission.spotId) === String(entrySpotId);
-        if (targetsEntry) {
-            await this.options.dispatchEntryActorJoin?.(meshName, actor, []);
-        }
-        else {
-            const activation = this.activations.resolve(meshName, admission.admission.spotId);
-            if (activation === undefined) {
-                throw new Error(`Actor Join relocation '${relocationId}' target Spot is not active.`);
+        const activation = targetsEntry
+            ? undefined
+            : this.activations.resolve(meshName, admission.admission.spotId);
+        let lifecycleFailure;
+        try {
+            if (targetsEntry) {
+                await this.options.dispatchEntryActorJoin?.(meshName, actor, []);
             }
-            await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
+            else {
+                if (activation === undefined) {
+                    throw new Error(`Actor Join relocation '${relocationId}' target Spot is not active.`);
+                }
+                await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
+            }
+        }
+        catch (error) {
+            lifecycleFailure = { error };
         }
-        await submitSourceLeave(admission.admission.actorRef.nodeRid);
-        if (outcome.deferredJoinRoot !== undefined && this.options.actorTransferRuntime !== undefined) {
+        if (lifecycleFailure === undefined) {
+            const sourceLeave = submitSourceLeave(admission.admission.actorRef.nodeRid);
+            this.options.detachedTaskRunner.runDetached(`actor Join source leave ${actor.context.actorId}`, () => sourceLeave);
+        }
+        if (outcome.deferredJoinCompletion !== undefined &&
+            this.options.actorTransferRuntime !== undefined) {
             const submitMailbox = targetsEntry
                 ? (operation) => operation()
                 : (operation) => {
-                    const activation = this.activations.resolve(meshName, admission.admission.spotId);
                     if (activation === undefined) {
                         throw new Error(`Actor Join relocation '${relocationId}' target mailbox is missing.`);
                     }
                     return activation.executeActor(actor.context.actorId, operation);
                 };
-            await this.options.actorTransferRuntime.commitAndDeliverDeferredJoinAccepted(outcome.deferredJoinRoot, actor, actorRef, submitMailbox, signal);
-        }
+            await this.options.actorTransferRuntime.deliverDeferredJoinCompletion(lifecycleFailure === undefined
+                ? outcome.deferredJoinCompletion
+                : {
+                    ...outcome.deferredJoinCompletion,
+                    status: 'failed',
+                    kind: spotActorFailureKind(lifecycleFailure.error)
+                }, actor, actorRef, submitMailbox, signal);
+        }
+        if (lifecycleFailure !== undefined)
+            throw lifecycleFailure.error;
         this.formalRemoteActorAdmissions.markCommitted(relocationId, actor);
         return true;
     }
-    async restoreCanonicalActorJoinRecovery(recovery, signal, canonicalInventoryDigest) {
+    async restoreCanonicalActorJoinRecovery(recovery, signal) {
         (0, abort_1.throwIfAborted)(signal);
         const admission = this.formalRemoteActorAdmissions.get(recovery.request.handoffId);
         if (admission === undefined) {
@@ -1850,15 +1986,14 @@ class DefaultZLinkSpotManager {
         }
         // Command 28 carries a present reply in one outer framework-multipart
         // part. The accepted target admission still owns the inner typed content
-        // type, which the durable completion must retain for application decode.
+        // type, which the process-local completion keeps for application decode.
         const admittedContentType = admittedReply.byteLength === 0 ? recovery.replyContentType : outcome.replyContentType;
         const transfer = this.options.actorTransferRuntime;
         if (transfer === undefined) {
             throw new Error('Canonical Actor Join recovery requires the Actor transfer runtime.');
         }
-        const deferred = await transfer.prepareDeferredJoinAccepted(recovery.request.actorId, recovery.operationId, admitted.actorRef, recovery.reply, admittedContentType, signal, canonicalInventoryDigest);
-        this.formalRemoteActorAdmissions.attachDeferredJoinRoot(recovery.request.handoffId, deferred);
-        return deferred;
+        const deferred = transfer.prepareDeferredJoinAccepted(recovery.request.actorId, recovery.operationId, admitted.actorRef, recovery.reply, admittedContentType);
+        this.formalRemoteActorAdmissions.attachDeferredJoinCompletion(recovery.request.handoffId, deferred);
     }
     encodeMeshActorReply(requestHeaderPart, kind, payload) {
         // Spec 27 §4/§7: the decode gate strips the observation-only flow pair at
@@ -1932,17 +2067,10 @@ class DefaultZLinkSpotManager {
     }
 }
 exports.DefaultZLinkSpotManager = DefaultZLinkSpotManager;
-function instanceDispatchErrorReason(error) {
-    if (error instanceof contracts_1.ZLinkFrameworkException) {
-        const kind = (0, framework_errors_internal_1.internalFrameworkErrorKind)(error);
-        if (kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotGenerationStale ||
-            kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving ||
-            kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotRouteNotFound ||
-            kind === framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound) {
-            return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.StaleTarget;
-        }
-    }
-    return ZLinkDispatchOptions_1.ZLinkRuntimeDispatchErrorReason.HandlerException;
+function spotActorFailureKind(error) {
+    return error instanceof contracts_1.ZLinkFrameworkException
+        ? error.kind
+        : contracts_1.ZLinkFrameworkErrorKind.InternalFailure;
 }
 function decodeFormalRemoteTransferRequest(message) {
     return decodeFormalRemoteTransferRequestBytes(message.data());