@zlink-systems/framework 0.26.0 → 0.28.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");
@@ -81,7 +84,10 @@ class DefaultZLinkSpotManager {
     idleSweepRunning = false;
     constructor(options, timerClock) {
         this.options = options;
-        this.activations = new spot_activation_registry_1.ZLinkSpotActivationRegistry(options.metrics, (meshName, spotId) => this.isSpotClosing(meshName, spotId));
+        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();
         this.locationClaim = new spot_location_claim_1.ZLinkSpotLocationClaim({
@@ -91,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'),
@@ -99,8 +105,6 @@ class DefaultZLinkSpotManager {
             dispatchErrors: options.dispatchErrors
         });
         this.actorMembership = new spot_actor_membership_1.ZLinkSpotActorMembership({
-            isSpotClosing: (activation) => this.isSpotClosing(activation.meshName, activation.spotId) ||
-                this.activations.resolve(activation.meshName, activation.spotId) !== activation,
             resolveActivation: (spotId, meshName) => meshName === undefined
                 ? this.activations.resolveUnique(spotId)
                 : this.activations.resolve(meshName, spotId),
@@ -150,11 +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),
             requestContextClose: (activation, objectGeneration, signal) => this.closeFromContext(activation, objectGeneration, signal),
-            isSpotClosing: (activation) => this.isSpotClosing(activation.meshName, activation.spotId) ||
-                this.activations.resolve(activation.meshName, activation.spotId) !== activation,
             registerActivation: (activation) => {
                 this.activations.register(activation);
                 this.scheduleIdleSweep();
@@ -264,10 +266,6 @@ class DefaultZLinkSpotManager {
                 await (0, abort_1.awaitWithAbort)(pendingClose, signal);
                 continue;
             }
-            if (closeOperation?.committed === true) {
-                await (0, abort_1.awaitWithAbort)(this.closeWithReason(meshName, spotId), signal);
-                continue;
-            }
             const closing = this.activations.closingOperation(meshName, spotId);
             if (closing !== undefined) {
                 await (0, abort_1.awaitWithAbort)(closing.ready, signal);
@@ -344,24 +342,36 @@ class DefaultZLinkSpotManager {
         }
     }
     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);
     }
     isSpotClosing(meshName, spotId) {
-        const key = `${meshName}\0${String(spotId)}`;
-        return this.closeOperations.get(key)?.committed === true;
+        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;
     }
-    isInstanceClosing(meshName, spotId) {
-        return this.closeOperations.has(`${meshName}\0${String(spotId)}`);
-    }
     async discardInstance(meshName, spotId) {
         const activation = this.activations.resolve(meshName, spotId);
         if (activation === undefined)
@@ -508,10 +518,7 @@ class DefaultZLinkSpotManager {
                         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 {
@@ -541,8 +548,8 @@ 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))
@@ -559,11 +566,15 @@ class DefaultZLinkSpotManager {
     }
     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
@@ -612,12 +623,13 @@ class DefaultZLinkSpotManager {
                 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 ??
-                (activation.domain.kind === 'instance' &&
+                (domain.kind === 'instance' &&
                     reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose &&
                     this.options.beginInstanceClosingAuthority !== undefined
-                    ? (onCommitted) => this.options.beginInstanceClosingAuthority(meshName, spotId, onCommitted)
-                    : activation.domain.kind === 'instance' &&
+                    ? (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)
@@ -628,14 +640,21 @@ class DefaultZLinkSpotManager {
             operation = {
                 activation,
                 reason,
-                beginAuthority,
-                committed: false
+                beginAuthority
             };
+            if (reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose) {
+                operation.canExecuteApplication = (record) => {
+                    const context = record.context;
+                    return context === undefined;
+                };
+            }
             this.closeOperations.set(key, operation);
         }
         if (operation.ready === undefined) {
             const active = operation;
-            const run = active.activation.serial.executeLifecycleOperation(() => this.runCloseOperation(meshName, spotId, active, signal, deadline));
+            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) {
@@ -646,17 +665,83 @@ class DefaultZLinkSpotManager {
         return await operation.ready;
     }
     async runCloseOperation(meshName, spotId, operation, signal, deadline) {
-        const began = await this.beginCloseAuthority(meshName, spotId, operation, signal);
-        if (!began)
+        const seal = await this.beginCloseAuthority(meshName, spotId, operation, signal);
+        if (seal === undefined)
             return false;
-        const seal = operation.activation.sealExecution(true);
-        await this.activationLifecycle.sealForClose(operation.activation, seal);
+        if (seal !== true) {
+            await this.activationLifecycle.sealForClose(operation.activation, seal);
+        }
+        else {
+            await operation.activation.executionBarrier.waitForStartedTurns(signal);
+        }
         const closingFailure = await this.activationLifecycle.cleanupClosedActivation(operation.activation, operation.reason, deadline);
-        await operation.authority?.release();
-        // The incarnation has no further lifecycle item once its authority is
-        // released, so its lifecycle lane admission closes with this Close.
-        operation.activation.serial.closeAdmission();
         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);
+            }
+            catch (error) {
+                const initialized = this.activations.resolve(meshName, spotId);
+                if (initialized !== undefined && initialized !== operation.activation) {
+                    await this.activationLifecycle.cleanupFailedIncarnation(initialized);
+                }
+                this.activations.finishClose(meshName, spotId);
+                operation.activation.serial.visitPendingApplication((record) => {
+                    const context = record.context;
+                    if (context?.replay !== undefined)
+                        record.operation = () => context.replay(error);
+                });
+                operation.activation.serial.closeAdmission();
+                throw error;
+            }
+        }
+        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.
@@ -666,24 +751,33 @@ class DefaultZLinkSpotManager {
         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 false;
+            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(() => {
-            operation.committed = true;
+            if (operation.reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose) {
+                operation.activation.serial.setLifecycleAdmissionClosed(true);
+                seal = true;
+            }
+            else {
+                seal = operation.activation.sealExecution('close');
+            }
         }));
         operation.authorityDecision = authorityPromise.then(() => undefined, () => undefined);
         const authority = await authorityPromise;
         if (authority === undefined)
-            return false;
+            return undefined;
         operation.authority = authority;
-        if (!this.isSpotClosing(meshName, spotId)) {
+        if (seal === undefined) {
             throw new Error(`Spot '${String(spotId)}' Closing authority did not confirm its commit.`);
         }
-        return true;
+        return seal;
     }
     async executeOnSpot(spotType, spotId, operation, signal) {
         (0, abort_1.throwIfAborted)(signal);
@@ -732,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) {
@@ -841,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))
@@ -868,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.`);
                 }
@@ -885,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);
@@ -901,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)));
             }
         });
     }
+    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)
@@ -960,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,
@@ -1016,36 +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);
-        if (activation?.domain.kind === 'user') {
-            await activation.serial.executeLifecycleOperation(async () => {
-                if (this.isSpotClosing(meshName, activation.spotId) ||
-                    this.activations.resolve(meshName, activation.spotId) !== activation) {
-                    const rejection = (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `User Spot '${String(spotId)}' is closing.`);
-                    if (record.replyFailure !== undefined) {
-                        const terminal = (0, framework_errors_internal_1.internalFrameworkWireReply)(rejection);
-                        requireMeshSpotReply(record.replyFailure(terminal.terminalResult, terminal.failureCode));
-                    }
-                    else {
-                        requireMeshSpotReply(record.replyActorJoin(1, []));
-                    }
-                    return;
+        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.`);
                 }
-                await this.dispatchMeshActorJoinCore(meshName, owner, record);
-            });
-            return;
+            }
+            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));
         }
-        await this.dispatchMeshActorJoinCore(meshName, owner, record);
     }
-    async dispatchMeshActorJoinCore(meshName, owner, record) {
+    async dispatchMeshActorJoinCore(meshName, owner, record, replyState) {
         const spotId = owner.spotId;
         const control = record.kindData;
         if (control?.kind !== 'actorControl') {
@@ -1098,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;
             }
         }
@@ -1134,7 +1252,6 @@ class DefaultZLinkSpotManager {
         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 = () => {
@@ -1185,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;
@@ -1446,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.
-                this.options.actorTransferRuntime.rememberRoutedActorTransferTarget(actorId, transferRequest.remoteBoundSessionTarget);
-            }
             if (accepted &&
                 actor !== undefined &&
                 transferRequest !== undefined &&
@@ -1466,7 +1570,8 @@ class DefaultZLinkSpotManager {
                     spotId,
                     transferId: transferRequest.transferId,
                     handoffBacklog: transferRequest.handoffBacklog,
-                    deferredJoinCompletion
+                    deferredJoinCompletion,
+                    sealedSession: transferRequest.remoteBoundSessionTarget
                 });
                 if (isRemoteCommit && admissionRecord !== undefined) {
                     this.formalRemoteActorAdmissions.markCommitted(transferRequest.transferId, actor);
@@ -1482,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;
@@ -1512,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 {
@@ -1555,10 +1674,10 @@ class DefaultZLinkSpotManager {
             if (control.canonicalActorJoin !== undefined) {
                 this.formalRemoteActorAdmissions.fail(control.canonicalActorJoin.handoffId, error);
             }
-            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;
@@ -1587,9 +1706,7 @@ class DefaultZLinkSpotManager {
                 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);
-                if (this.options.detachedTaskRunner === undefined)
-                    void operation.catch(() => undefined);
+                this.options.detachedTaskRunner.runDetached(`actor transfer target commit ${actorId}`, async () => await operation);
                 return;
             }
             await operation;
@@ -1668,7 +1785,7 @@ class DefaultZLinkSpotManager {
                         if (currentRef === null) {
                             throw new Error(`Actor '${actor.context.actorId}' has no target ref for deferred Join completion.`);
                         }
-                        await this.options.actorTransferRuntime?.deliverDeferredJoinAccepted(deferredJoinCompletion, 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 () => {
@@ -1683,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
@@ -1696,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 {
@@ -1731,10 +1849,7 @@ class DefaultZLinkSpotManager {
                         onDetachedTerminal(terminal);
                     }
                     else {
-                        this.options.detachedTaskRunner?.runDetached(`actor transfer target commit ${actor.context.actorId}`, async () => await terminal);
-                        if (this.options.detachedTaskRunner === undefined) {
-                            void terminal.catch(() => undefined);
-                        }
+                        this.options.detachedTaskRunner.runDetached(`actor transfer target commit ${actor.context.actorId}`, async () => await terminal);
                     }
                     return;
                 }
@@ -1784,30 +1899,48 @@ 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, []);
+            }
+            else {
+                if (activation === undefined) {
+                    throw new Error(`Actor Join relocation '${relocationId}' target Spot is not active.`);
+                }
+                await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
             }
-            await activation.serial.execute(() => activation.spot.onJoinedActor(actor));
         }
-        await submitSourceLeave(admission.admission.actorRef.nodeRid);
+        catch (error) {
+            lifecycleFailure = { error };
+        }
+        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.deliverDeferredJoinAccepted(outcome.deferredJoinCompletion, 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;
     }
@@ -1934,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());