@zlink-systems/framework 0.25.0 → 0.26.0

package/dist/runtime/host/actor-transfer-runtime.js

@@ -4,6 +4,7 @@ exports.ZLinkActorTransferRuntime = void 0;
 exports.committedActorOwnerFence = committedActorOwnerFence;
 const node_crypto_1 = require("node:crypto");
 const contracts_1 = require("../../contracts");
+const runtime_message_1 = require("../backend/runtime-message");
 const authority_key_codec_1 = require("../locations/authority-key-codec");
 const actors_1 = require("../actors");
 const actor_retry_delay_1 = require("../actors/actor-retry-delay");
@@ -56,19 +57,21 @@ class ZLinkActorTransferRuntime {
     options;
     sourceDepartureTasks = new Map();
     coreSourceLeaves = new Map();
+    //  Spot Actor membership sections 4-5: Join completion idempotency is
+    //  process-local. These maps end with the process; nothing is replayed.
     activeDeferredJoinTerminals = new Map();
     deferredJoinTerminals = new bounded_replay_map_1.BoundedReplayMap(DEFERRED_JOIN_TERMINAL_CAPACITY);
     constructor(options) {
         this.options = options;
     }
-    beginDeferredActorHandoff(actor, state, operationId) {
+    beginDeferredActorHandoff(actor, state) {
         const actorId = actor.context.actorId;
-        this.options.actorHandoff.beginProvisional(actorId, operationId, requireSourceObjectGeneration(actorId, state));
+        this.options.actorHandoff.beginProvisional(actorId, requireSourceObjectGeneration(actorId, state));
     }
-    promoteDeferredActorHandoff(actor, _state, operationId) {
-        this.options.actorHandoff.promoteProvisional(actor.context.actorId, operationId);
+    promoteDeferredActorHandoff(actor, _state) {
+        this.options.actorHandoff.promoteProvisional(actor.context.actorId);
     }
-    async completeDeferredActorHandoff(actor, target, _targetActorRef, operationId) {
+    async completeDeferredActorHandoff(actor, target, _targetActorRef) {
         const actorId = actor.context.actorId;
         if (!this.options.actorHandoff.isProvisional(actorId))
             return;
@@ -76,91 +79,69 @@ class ZLinkActorTransferRuntime {
         if (manager === undefined) {
             throw new Error(`Actor '${actorId}' same-node Join has no local Spot manager.`);
         }
-        const admitted = this.options.actorHandoff.admitDeferredPrefix(actorId, operationId, (drain) => manager.admitRoutedActorPacketPrefix(target.spotId, actorId, drain), this.options.prepareApplicationJob);
+        const admitted = this.options.actorHandoff.admitDeferredPrefix(actorId, (drain) => manager.admitRoutedActorPacketPrefix(target.spotId, actorId, drain), this.options.prepareApplicationJob);
         void this.observeHandoffReplay(admitted.terminal);
     }
-    async cancelDeferredActorHandoff(actor, _state, operationId) {
-        const admitted = this.admitDeferredSourcePrefix(actor, _state, operationId);
+    async cancelDeferredActorHandoff(actor, state) {
+        const admitted = this.admitDeferredSourcePrefix(actor, state);
         void this.observeHandoffReplay(admitted.terminal);
     }
-    async prepareDeferredJoinAccepted(actorId, operationId, actorRef, rawReply, replyContentType, signal, canonicalInventoryDigest) {
-        return await this.requireDeferredJoinJournal().prepare(actorId, operationId, actorRef, rawReply, replyContentType, signal, canonicalInventoryDigest);
+    prepareDeferredJoinAccepted(actorId, operationId, actorRef, rawReply, replyContentType) {
+        return (0, actors_1.createDeferredJoinCompletion)(actorId, operationId, actorRef, rawReply, replyContentType);
     }
-    async isDeferredJoinAcceptedRootPublication(reference, checksumCrc32c, expected, signal) {
-        const relocation = this.options.relocationStore();
-        return relocation === undefined
-            ? false
-            : await (0, actors_1.isDeferredJoinAcceptedRootPublication)(relocation, reference, checksumCrc32c, expected, signal);
-    }
-    async discardDeferredJoinAccepted(root, signal) {
-        await this.requireDeferredJoinJournal().discardPrepared(root, signal);
-    }
-    markDeferredJoinAcceptedCommitted(root, actorRef, signal) {
-        return this.requireDeferredJoinJournal().markCommitted(root, actorRef, signal);
-    }
-    async commitAndDeliverDeferredJoinAccepted(root, actor, actorRef, submitMailbox, signal) {
-        const terminalKey = deferredJoinTerminalKey(root);
-        const terminal = this.deferredJoinTerminals.get(terminalKey);
-        if (terminal !== undefined) {
+    /**
+     * Runs the Accepted completion callback once in the target Actor mailbox.
+     * A repeated delivery of the same OperationId in this process observes the
+     * first terminal (completion idempotency only).
+     */
+    async deliverDeferredJoinAccepted(completion, actor, actorRef, submitMailbox, signal) {
+        const terminalKey = deferredJoinTerminalKey(completion);
+        if (this.deferredJoinTerminals.get(terminalKey) !== undefined) {
             this.deferredJoinTerminals.touch(terminalKey);
-            return terminal;
+            return;
         }
         const active = this.activeDeferredJoinTerminals.get(terminalKey);
         if (active !== undefined)
             return await waitForOperation(active, signal);
-        const completion = this.commitAndDeliverDeferredJoinAcceptedCore(root, actor, actorRef, submitMailbox);
-        this.activeDeferredJoinTerminals.set(terminalKey, completion);
-        void completion.then((completed) => {
-            this.deferredJoinTerminals.remember(terminalKey, completed);
-            if (this.activeDeferredJoinTerminals.get(terminalKey) === completion) {
+        const delivery = this.deliverDeferredJoinAcceptedCore(completion, actor, actorRef, submitMailbox);
+        this.activeDeferredJoinTerminals.set(terminalKey, delivery);
+        void delivery.then(() => {
+            this.deferredJoinTerminals.remember(terminalKey, true);
+            if (this.activeDeferredJoinTerminals.get(terminalKey) === delivery) {
                 this.activeDeferredJoinTerminals.delete(terminalKey);
             }
         }, () => {
-            if (this.activeDeferredJoinTerminals.get(terminalKey) === completion) {
+            if (this.activeDeferredJoinTerminals.get(terminalKey) === delivery) {
                 this.activeDeferredJoinTerminals.delete(terminalKey);
             }
         });
-        return await waitForOperation(completion, signal);
+        return await waitForOperation(delivery, signal);
     }
-    async commitAndDeliverDeferredJoinAcceptedCore(root, actor, actorRef, submitMailbox) {
+    async deliverDeferredJoinAcceptedCore(completion, actor, actorRef, submitMailbox) {
         const targetActorRef = this.options
             .actorManager()
             ?.getState(actor.context.actorId)?.nativeActorRef;
         const currentActorRef = targetActorRef === undefined
             ? actorRef
             : (0, actors_1.toFrameworkActorRef)(targetActorRef, actor.context.meshName);
-        let current = root.cursor === 'prepared'
-            ? await this.requireDeferredJoinJournal().markCommitted(root, currentActorRef)
-            : root;
-        if (current.cursor === 'delivered')
-            return current;
-        let lastError;
-        for (let attempt = 0; attempt < 3; attempt++) {
-            try {
-                current = await this.requireDeferredJoinJournal().deliver(current, actor, currentActorRef, submitMailbox);
-                return current;
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt < 2) {
-                    await new Promise((resolve) => {
-                        const timer = setTimeout(resolve, 10 << attempt);
-                        timer.unref();
-                    });
-                    current =
-                        (await this.requireDeferredJoinJournal().recover(currentActorRef.actorId)) ?? current;
-                }
-            }
-        }
-        throw lastError;
-    }
-    requireDeferredJoinJournal() {
-        const authority = this.options.authorityStore();
-        const relocation = this.options.relocationStore();
-        if (authority === undefined || relocation === undefined) {
-            throw new Error('Cross-node deferred Actor Join requires Location and Relocation Stores.');
-        }
-        return new actors_1.ZLinkDeferredJoinAcceptedJournal(authority, relocation, this.options.messageSerializers);
+        if (completion.actor.actorId !== currentActorRef.actorId ||
+            completion.actor.objectGeneration !== currentActorRef.objectGeneration) {
+            throw new Error('Deferred Join completion generation fence is stale ' +
+                `(completion ${completion.actor.actorId}/${completion.actor.objectGeneration}, ` +
+                `actor ${currentActorRef.actorId}/${currentActorRef.objectGeneration}).`);
+        }
+        await submitMailbox(async () => {
+            await actor.onJoinCompleted?.({
+                status: 'accepted',
+                operationId: completion.operationId,
+                actor: currentActorRef,
+                reply: completion.rawReply.byteLength === 0
+                    ? undefined
+                    : completion.replyContentType === undefined
+                        ? contracts_1.ZLinkMessage.fromEncoded(contracts_1.ZLinkEncodedPayload.from(completion.rawReply))
+                        : (0, payload_codec_1.wrapFrameworkPayloadMessage)(runtime_message_1.ZLinkBufferMessage.from(completion.rawReply), this.options.messageSerializers, completion.replyContentType, undefined, 'reply')
+            });
+        });
     }
     async prepareSourceActorLeave(actor, sourceSpotId, signal) {
         if (sourceSpotId !== undefined) {
@@ -182,10 +163,9 @@ class ZLinkActorTransferRuntime {
         }
         await this.options.restoreEntrySpotActorJoined(actor, signal);
     }
-    async beginSourceActorMove(actor, state, deferredOperationId) {
-        if (deferredOperationId !== undefined &&
-            this.options.actorHandoff.isProvisional(actor.context.actorId)) {
-            this.promoteDeferredActorHandoff(actor, state, deferredOperationId);
+    async beginSourceActorMove(actor, state, deferredJoin = false) {
+        if (deferredJoin && this.options.actorHandoff.isProvisional(actor.context.actorId)) {
+            this.promoteDeferredActorHandoff(actor, state);
         }
         state.beginMove();
         if (!this.options.actorHandoff.isActive(actor.context.actorId)) {
@@ -205,18 +185,18 @@ class ZLinkActorTransferRuntime {
             }
         }
         catch (error) {
-            if (deferredOperationId === undefined) {
+            if (!deferredJoin) {
                 this.options.actorHandoff.cancel(actor.context.actorId);
             }
             else {
-                const admitted = this.admitDeferredSourcePrefix(actor, state, deferredOperationId);
+                const admitted = this.admitDeferredSourcePrefix(actor, state);
                 void this.observeHandoffReplay(admitted.terminal);
             }
             state.endMove();
             throw error;
         }
     }
-    async cancelSourceActorMove(actor, state, deferredOperationId, replayStart = Promise.resolve()) {
+    async cancelSourceActorMove(actor, state, deferredJoin = false, replayStart = Promise.resolve()) {
         try {
             if (state.spotId !== undefined) {
                 await this.options.spotManager()?.cancelActorTransfer(state.spotId, actor.context.actorId);
@@ -224,12 +204,12 @@ class ZLinkActorTransferRuntime {
         }
         finally {
             try {
-                if (deferredOperationId === undefined) {
+                if (!deferredJoin) {
                     const admitted = this.admitCanceledSourcePrefix(actor, state, replayStart);
                     void this.observeHandoffReplay(admitted.terminal);
                 }
                 else {
-                    const admitted = this.admitDeferredSourcePrefix(actor, state, deferredOperationId, replayStart);
+                    const admitted = this.admitDeferredSourcePrefix(actor, state, replayStart);
                     void this.observeHandoffReplay(admitted.terminal);
                 }
             }
@@ -249,13 +229,13 @@ class ZLinkActorTransferRuntime {
         }
         return this.options.actorHandoff.admitCanceledPrefix(actor.context.actorId, queue, this.options.prepareApplicationJob, replayStart);
     }
-    admitDeferredSourcePrefix(actor, state, operationId, replayStart = Promise.resolve()) {
+    admitDeferredSourcePrefix(actor, state, replayStart = Promise.resolve()) {
         const queue = this.sourceHandoffPrefixQueue(actor, state);
         if (queue === undefined) {
             this.options.actorHandoff.cancel(actor.context.actorId);
             return { terminal: Promise.resolve() };
         }
-        return this.options.actorHandoff.admitDeferredPrefix(actor.context.actorId, operationId, queue, this.options.prepareApplicationJob, replayStart);
+        return this.options.actorHandoff.admitDeferredPrefix(actor.context.actorId, queue, this.options.prepareApplicationJob, replayStart);
     }
     async observeHandoffReplay(release) {
         try {
@@ -281,8 +261,8 @@ class ZLinkActorTransferRuntime {
         }
         return (drain) => manager.admitRoutedActorPacketPrefix(sourceSpotId, actor.context.actorId, drain);
     }
-    async prepareSource(actor, state, signal, lifecycleAuthority = 'framework', deferredOperationId, relocation) {
-        await this.beginSourceActorMove(actor, state, deferredOperationId);
+    async prepareSource(actor, state, signal, lifecycleAuthority = 'framework', deferredJoin = false, relocation) {
+        await this.beginSourceActorMove(actor, state, deferredJoin);
         const relocationMetric = state.meshName === undefined
             ? undefined
             : this.options.metrics?.startRelocation(state.meshName, 'actor', this.options.actorTransferRegistry.policy(state.actorType));
@@ -386,7 +366,7 @@ class ZLinkActorTransferRuntime {
                     this.coreSourceLeaves.delete(actor.context.actorId);
                     const replayGate = createHandoffReplayGate();
                     try {
-                        await this.cancelSourceActorMove(actor, state, deferredOperationId, replayGate.start);
+                        await this.cancelSourceActorMove(actor, state, deferredJoin, replayGate.start);
                         await this.restoreSourceActor(actor, sourceSpotId);
                         if (sealId !== undefined) {
                             await this.observeBoundSessionSealAbort(actor, state);
@@ -402,7 +382,7 @@ class ZLinkActorTransferRuntime {
             relocationMetric?.complete('failed');
             const replayGate = createHandoffReplayGate();
             try {
-                await this.cancelSourceActorMove(actor, state, deferredOperationId, replayGate.start);
+                await this.cancelSourceActorMove(actor, state, deferredJoin, replayGate.start);
                 if (sourceLeaveStarted)
                     await this.restoreSourceActor(actor, sourceSpotId);
                 if (sealId !== undefined) {
@@ -465,6 +445,12 @@ class ZLinkActorTransferRuntime {
                         terminal = 'committed';
                     }
                 },
+                discard: (reason) => {
+                    if (terminal !== 'prepared')
+                        return;
+                    terminal = 'rolledBack';
+                    this.options.actorHandoff.failPending(actor.context.actorId, reason);
+                },
                 rollback: async () => {
                     if (terminal !== 'prepared')
                         return;
@@ -1201,7 +1187,8 @@ class ZLinkActorTransferRuntime {
                     previousAuthorityOwnerGeneration: target.previousAuthorityOwnerGeneration,
                     targetAuthorityOwnerGeneration: ownershipGeneration,
                     targetNodeRid: String(actorRef.nodeRid),
-                    targetNodeGeneration: authority.allocation.descriptorLifecycleGeneration
+                    targetNodeGeneration: authority.allocation.descriptorLifecycleGeneration,
+                    targetOwnerLeaseGeneration: authority.ownerLeaseGeneration
                 }
             }, this.options.shutdownSignal?.());
             return;
@@ -1214,9 +1201,9 @@ function relocationDebug(marker, detail) {
         return;
     console.error('[zlink.runtime.relocation]', marker, detail);
 }
-function deferredJoinTerminalKey(root) {
-    return (`${root.actor.actorId}:${root.actor.objectGeneration.toString()}:` +
-        (0, operation_identity_1.operationIdentityKey)(root.operationId));
+function deferredJoinTerminalKey(completion) {
+    return (`${completion.actor.actorId}:${completion.actor.objectGeneration.toString()}:` +
+        (0, operation_identity_1.operationIdentityKey)(completion.operationId));
 }
 function waitForOperation(operation, signal) {
     if (signal === undefined)

package/dist/runtime/host/index.d.ts

@@ -1,6 +1,6 @@
 import type { ZLinkBackendContext, ZLinkBackendMeshNode } from '../backend';
 import type { ZLinkFrameworkRegistration } from '../configuration';
-import type { ZLinkMeshNodeDescriptor, ZLinkClientServerRuntime, ZLinkFanoutRuntime, ZLinkFrameworkRuntime, ZLinkFrameworkLifecycleOptions, ZLinkFrameworkRelocationOptions, ZLinkFrameworkRelocationResult, ZLinkObservedStatus, ZLinkFrameworkRuntimeStatus, ZLinkFrameworkTerminationResult, ZLinkRouteMeshRuntime } from '../../contracts';
+import type { ZLinkMeshNodeDescriptor, ZLinkClientServerRuntime, ZLinkFanoutRuntime, ZLinkFrameworkRuntime, ZLinkListenerKind, ZLinkListenerStatus, ZLinkFrameworkLifecycleOptions, ZLinkFrameworkRelocationOptions, ZLinkFrameworkRelocationResult, ZLinkObservedStatus, ZLinkFrameworkRuntimeStatus, ZLinkFrameworkTerminationResult, ZLinkRouteMeshRuntime } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
 import type { ZLinkMessageFlowControl, ZLinkMessageFlowLogMode } from '../../contracts';
@@ -61,6 +61,7 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private actorManager?;
     private actorPlacement?;
     private spotManager?;
+    private userSpotCoordinator?;
     private ownerLeaseRecoveryRuntime?;
     private ownerLeaseRecoveryHandler?;
     private registerUserSpotHandlers?;
@@ -71,6 +72,7 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private readonly capacityStatus;
     private readonly metricRegistrations;
     private readonly admission;
+    private readonly activationAdmission;
     private cachedLocationSpotRouteResolver?;
     private actorClientLocationResolver?;
     private readonly messageFlowModeCell;
@@ -94,6 +96,8 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     constructor(options: ZLinkFrameworkRuntimeHostOptions, internalOptions?: unknown);
     get isStarted(): boolean;
     get status(): ZLinkFrameworkRuntimeStatus;
+    private listenerRecords;
+    getListenerStatus(kind: ZLinkListenerKind, name: string): ZLinkListenerStatus;
     observe(signal?: AbortSignal): AsyncIterable<ZLinkObservedStatus<ZLinkFrameworkRuntimeStatus>>;
     resetCapacityMetrics(): void;
     relocate(options: ZLinkFrameworkRelocationOptions): Promise<ZLinkFrameworkRelocationResult>;
@@ -150,7 +154,7 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private registerInstanceApplicationLifecycle;
     setActorManager(actorManager: DefaultZLinkActorManager): void;
     setSpotManager(spotManager: DefaultZLinkSpotManager): void;
-    createActorManagerOptions(): Pick<ZLinkActorManagerOptions, 'joinCoordinator' | 'actorMeshNameProvider' | 'actorLeaveSpot' | 'messageSerializers' | 'nativeActorNode' | 'nativeActorNodeProvider' | 'actorCreatedNodeRidProvider' | 'actorRefResolver' | 'actorCreatedNotifier' | 'actorDestroyedCleanup' | 'locationLifecycle' | 'boundSessionFactory' | 'shutdownSignal' | 'admission' | 'placementCreate'>;
+    createActorManagerOptions(): Pick<ZLinkActorManagerOptions, 'joinCoordinator' | 'actorMeshNameProvider' | 'actorLeaveSpot' | 'messageSerializers' | 'nativeActorNode' | 'nativeActorNodeProvider' | 'actorCreatedNodeRidProvider' | 'actorRefResolver' | 'actorCreatedNotifier' | 'actorDestroyedCleanup' | 'locationLifecycle' | 'boundSessionFactory' | 'shutdownSignal' | 'admission' | 'activationAdmission' | 'placementCreate'>;
     createActorClientOptions(): ConstructorParameters<typeof DefaultZLinkActorClient>[0];
     createLocationHandleResolver(): ZLinkStoreLocationResolvers | undefined;
     createSpotManagerOptions(): Partial<ZLinkSpotManagerOptions>;

package/dist/runtime/host/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkUserSpotCreationCoordinator = exports.ZLinkHostSpotAddressTransport = exports.ZLinkRelocationStateIncompatibleError = exports.ZLinkRouteMeshRuntimeCoordinator = exports.ZLinkRetiringRollbackError = exports.transferIdString = exports.ZLinkActorTransferAuthorityRuntime = exports.ZLinkFrameworkRuntimeHost = void 0;
 exports.hasUnsupportedManualTopology = hasUnsupportedManualTopology;
 exports.hasExactPeerReadiness = hasExactPeerReadiness;
+const listener_records_1 = require("../foundation/listener-records");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const node_crypto_1 = require("node:crypto");
 const runtime_message_1 = require("../backend/runtime-message");
@@ -46,7 +47,9 @@ const channel_runtime_options_factory_1 = require("./channel-runtime-options-fac
 const spot_node_runtime_options_factory_1 = require("./spot-node-runtime-options-factory");
 const runtime_shutdown_1 = require("./runtime-shutdown");
 const admission_1 = require("../admission");
+const activation_admission_1 = require("../activation-admission");
 const route_mesh_runtime_1 = require("./route-mesh-runtime");
+const service_relocation_coordinator_1 = require("../foundation/service-relocation-coordinator");
 const ConfigurationException_1 = require("../../contracts/Configuration/ConfigurationException");
 const stateful_authority_route_runtime_1 = require("./stateful-authority-route-runtime");
 const instance_activation_authority_1 = require("./instance-activation-authority");
@@ -95,6 +98,7 @@ class ZLinkFrameworkRuntimeHost {
     actorManager;
     actorPlacement;
     spotManager;
+    userSpotCoordinator;
     ownerLeaseRecoveryRuntime;
     ownerLeaseRecoveryHandler;
     registerUserSpotHandlers;
@@ -105,6 +109,11 @@ class ZLinkFrameworkRuntimeHost {
     capacityStatus;
     metricRegistrations = [];
     admission = new admission_1.ZLinkRuntimeAdmissionGate(() => this.ownerAdmissionOpen());
+    activationAdmission = new activation_admission_1.ZLinkActivationAdmission((meshName) => this.options.registration.spotNodes.get(meshName)?.activationConcurrencyLimit ?? 128, (meshName) => {
+        void this.spotNodeRuntime
+            ?.publishMeshNodeState(this.runtimeState, this.executionState?.abortController.signal, meshName)
+            .catch(() => undefined);
+    });
     cachedLocationSpotRouteResolver;
     actorClientLocationResolver;
     // Shared, runtime-mutable message-flow mode cell — installed once so
@@ -441,7 +450,6 @@ class ZLinkFrameworkRuntimeHost {
             actorTransferRegistry: this.actorTransferRegistry,
             authorityStore: () => this.locationOwner.currentStores?.locationStore,
             currentOwner: () => this.locationOwner.currentRuntime?.currentOwnerToken,
-            relocationStore: () => this.options.registration.locations.relocationStoreInstance,
             liveDescriptors: (meshName, signal) => {
                 const runtime = this.locationOwner.currentRuntime;
                 if (runtime === undefined) {
@@ -527,7 +535,8 @@ class ZLinkFrameworkRuntimeHost {
             invalidateActorRoute: (actorId) => this.actorClientLocationResolver?.invalidateActorRoute(actorId),
             reconcileStatefulAuthorityRoutes: (signal) => this.statefulAuthorityRoutes?.reconcile(signal) ?? Promise.resolve(),
             runtimeEventPublisher: this.runtimeEventPublisher,
-            metrics: this.metrics
+            metrics: this.metrics,
+            activationAdmission: this.activationAdmission
         });
         this.actorTransferAuthorityRuntime = new actor_transfer_authority_runtime_1.ZLinkActorTransferAuthorityRuntime({
             store: () => this.locationOwner.actorTransferStore(),
@@ -561,6 +570,7 @@ class ZLinkFrameworkRuntimeHost {
             },
             hostState: () => this.runtimeState,
             admission: this.admission,
+            activationAdmission: this.activationAdmission,
             publishRetiring: (meshName, signal) => this.publishMeshRetiring(meshName, signal),
             rollbackRetiring: (meshName, signal) => this.publishMeshServing(meshName, signal),
             publishDraining: (meshName, signal) => this.publishMeshDraining(meshName, signal),
@@ -590,6 +600,15 @@ class ZLinkFrameworkRuntimeHost {
             observedAt: new Date()
         };
     }
+    // Bound listener records of the current runtime generation.
+    listenerRecords = new listener_records_1.ZLinkListenerRecords();
+    getListenerStatus(kind, name) {
+        const endpoint = this.listenerRecords.endpoint(kind, name);
+        if (endpoint === undefined || endpoint.length === 0) {
+            throw new ConfigurationException_1.ZLinkConfigurationException(`Listener '${kind}:${name}' is not configured or has not bound.`);
+        }
+        return { kind, name, endpoint, observedAt: new Date() };
+    }
     observe(signal) {
         const queue = new runtime_observation_queue_1.RuntimeEventQueue(undefined, signal);
         this.runtimeObservers.add(queue);
@@ -704,6 +723,11 @@ class ZLinkFrameworkRuntimeHost {
             this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Relocating);
             const drained = await this.routeMeshCoordinator.relocateHost(remainingDeadlineMs(), stopStartingSignal);
             if (drained.kind === 'forceStopped') {
+                // Settled authority on both sides or an expired source owner lease
+                // ends the host in Error (spec 30 §13).
+                if (drained.error instanceof service_relocation_coordinator_1.ServiceRelocationAuthorityError) {
+                    return this.completeRelocation(blockedRelocation(mode, effectiveTargetApplicationVersion, contracts_1.ZLinkFrameworkRelocationReason.RelocationFailed));
+                }
                 return this.resetBlockedRelocation(blockedRelocation(mode, effectiveTargetApplicationVersion, stopStartingSignal.aborted
                     ? contracts_1.ZLinkFrameworkRelocationReason.ShutdownRequested
                     : drained.error instanceof service_relocation_host_runtime_1.ZLinkRelocationStateIncompatibleError
@@ -947,6 +971,8 @@ class ZLinkFrameworkRuntimeHost {
         }
         this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Preparing);
         this.lifecycleSink?.push('framework:start');
+        const listenerRecords = new listener_records_1.ZLinkListenerRecords();
+        this.listenerRecords = listenerRecords;
         const channelAdapter = this.backendAdapterFactory.createChannelAdapter();
         const context = channelAdapter.createContext();
         const coreHwm = this.options.registration.coreHwm;
@@ -964,10 +990,13 @@ class ZLinkFrameworkRuntimeHost {
             this.messageFlowModeCell.mode =
                 this.options.registration.dispatch?.diagnostics.messageFlow ?? 'errors';
             const dispatchErrors = this.createDispatchErrorReporter(this.executionState.errorSink);
-            channelRuntime = new channels_1.ZLinkChannelRuntimeManager(this.options.registration, channelAdapter, context, this.options.providerResolver, this.createChannelRuntimeOptions());
+            channelRuntime = new channels_1.ZLinkChannelRuntimeManager(this.options.registration, channelAdapter, context, this.options.providerResolver, { ...this.createChannelRuntimeOptions(), listenerRecords });
             this.channelRuntime = channelRuntime;
             channelRuntime.prepareMeshDispatch(this.executionState.taskRunner);
-            spotNodeRuntime = new spots_1.ZLinkSpotNodeRuntimeManager(this.createSpotNodeRuntimeOptions(context, dispatchErrors));
+            spotNodeRuntime = new spots_1.ZLinkSpotNodeRuntimeManager({
+                ...this.createSpotNodeRuntimeOptions(context, dispatchErrors),
+                listenerRecords
+            });
             await spotNodeRuntime.start();
             this.spotNodeRuntime = spotNodeRuntime;
             this.registerUserSpotHandlers?.(spotNodeRuntime);
@@ -991,6 +1020,7 @@ class ZLinkFrameworkRuntimeHost {
                 }
             }
             streamRuntime = new streams_1.ZLinkStreamRuntimeManager({
+                listenerRecords,
                 registration: this.options.registration,
                 backendAdapterFactory: this.backendAdapterFactory,
                 context,
@@ -1076,7 +1106,7 @@ class ZLinkFrameworkRuntimeHost {
                     reserved: capacity.reserved,
                     limit: capacity.limit
                 })),
-                activation: descriptor?.activationConcurrency ?? { active: 0, limit: 0 },
+                activation: this.activationAdmission.current(meshName),
                 instanceSpots: []
             });
         }
@@ -1112,6 +1142,7 @@ class ZLinkFrameworkRuntimeHost {
             serviceRelocation: this.serviceRelocation,
             ownedStores: registeredRuntimeStores(this.options.registration)
         });
+        this.listenerRecords.clear();
         this.lifecycleSink?.push('framework:stopped');
         if (this.shutdownOperation === undefined) {
             this.setRuntimeState(contracts_1.ZLinkFrameworkRuntimeState.Stopped);
@@ -1180,6 +1211,11 @@ class ZLinkFrameworkRuntimeHost {
             const activationNode = node;
             const spotManager = this.spotManager;
             if (spotManager !== undefined) {
+                activationNode.setSpotAdmissionProvider?.({
+                    isClosing: (spotId) => spotManager.isSpotClosing(meshName, spotId),
+                    awaitCloseDecision: (spotId) => spotManager.pendingSpotCloseDecision(meshName, spotId),
+                    runtimeState: () => this.runtimeState
+                });
                 this.registerInstanceApplicationLifecycle(meshName, activationNode, spotManager);
             }
             activationNode.registerAsyncInstanceActivationAuthority?.(new instance_activation_authority_1.ZLinkInstanceActivationAuthority({
@@ -1366,6 +1402,12 @@ class ZLinkFrameworkRuntimeHost {
     setSpotManager(spotManager) {
         this.spotManager = spotManager;
         for (const [meshName, node] of this.spotNodeRuntime?.meshNodesByName ?? []) {
+            const admissionNode = node;
+            admissionNode.setSpotAdmissionProvider?.({
+                isClosing: (spotId) => spotManager.isSpotClosing(meshName, spotId),
+                awaitCloseDecision: (spotId) => spotManager.pendingSpotCloseDecision(meshName, spotId),
+                runtimeState: () => this.runtimeState
+            });
             this.registerInstanceApplicationLifecycle(meshName, node, spotManager);
         }
     }
@@ -1373,6 +1415,7 @@ class ZLinkFrameworkRuntimeHost {
         this.ensureLocationRuntime();
         return {
             ...this.actorRuntimeOptionsFactory().createActorManagerOptions(),
+            activationAdmission: this.activationAdmission,
             placementCreate: async (actorId, actorType, createOnly, call, signal) => {
                 const placement = this.actorPlacement;
                 if (placement === undefined) {
@@ -1416,10 +1459,16 @@ class ZLinkFrameworkRuntimeHost {
                         ?.meshNode(meshName)
                         ?.completeClosedInstance?.(spotId, objectGeneration);
                 },
-                beginInstanceIdleClosingAuthority: (meshName, spotId) => this.locationOwner.currentLifecycle?.beginInstanceSpotClosing(meshName, spotId) ??
-                    Promise.resolve(undefined),
-                beginInstanceClosingAuthority: (meshName, spotId) => this.locationOwner.currentLifecycle?.beginInstanceSpotClosing(meshName, spotId) ??
-                    Promise.resolve(undefined),
+                beginInstanceIdleClosingAuthority: (meshName, spotId, onCommitted) => this.locationOwner.currentLifecycle?.beginInstanceSpotClosing(meshName, spotId, onCommitted) ?? Promise.resolve(undefined),
+                beginInstanceClosingAuthority: (meshName, spotId, onCommitted) => this.locationOwner.currentLifecycle?.beginInstanceSpotClosing(meshName, spotId, onCommitted) ?? Promise.resolve(undefined),
+                beginUserClosingAuthority: async (meshName, spotId, objectGeneration, onCommitted) => {
+                    const coordinator = this.userSpotCoordinator;
+                    const nodeRid = this.spotNodeRuntime?.meshNode(meshName)?.status().routingId;
+                    if (coordinator === undefined || nodeRid === undefined) {
+                        throw new ConfigurationException_1.ZLinkConfigurationException('User Spot context Close requires its authority coordinator.');
+                    }
+                    return await coordinator.beginOwnerClose({ spotId: spotId, objectGeneration, meshName, nodeRid }, onCommitted);
+                },
                 createLocationSpotRouteResolver: () => this.createLocationSpotRouteResolver(),
                 boundSessionRelay: this.boundSessionRelay,
                 actorHandoff: this.actorHandoff,
@@ -1430,12 +1479,7 @@ class ZLinkFrameworkRuntimeHost {
                 admission: this.admission,
                 statefulExecutionAllowed: () => this.ownerAdmissionOpen()
             }).create(this.actorTransferRuntime),
-            activationConcurrencyLimitProvider: (meshName) => this.options.registration.spotNodes.get(meshName)?.activationConcurrencyLimit ?? 128,
-            onInstanceActivationConcurrencyChanged: (meshName) => {
-                void this.spotNodeRuntime
-                    ?.publishMeshNodeState(this.runtimeState, this.executionState?.abortController.signal, meshName)
-                    .catch(() => undefined);
-            }
+            activationAdmission: this.activationAdmission
         };
     }
     createPublicSpotManager(local) {
@@ -1511,7 +1555,7 @@ class ZLinkFrameworkRuntimeHost {
                 };
             }
         });
-        const coordinator = new user_spot_creation_coordinator_1.ZLinkUserSpotCreationCoordinator({
+        const coordinator = (this.userSpotCoordinator = new user_spot_creation_coordinator_1.ZLinkUserSpotCreationCoordinator({
             store: locationStore,
             publishReadyRoute: (meshName, route) => {
                 this.cachedLocationSpotRouteResolver?.invalidate?.(route.spot.spotId);
@@ -1589,7 +1633,7 @@ class ZLinkFrameworkRuntimeHost {
                         localStatus.lifecycleGeneration === selected.lifecycleGeneration
                 };
             }
-        });
+        }));
         const factories = new Map([...this.options.registration.spotNodes].map(([meshName, node]) => [
             meshName,
             new Map(Object.entries(node.spotFactoryRegistrations ?? {}))
@@ -1725,25 +1769,12 @@ class ZLinkFrameworkRuntimeHost {
                         }, signal);
                     },
                     close: async (record, signal) => {
-                        if (!local.hasActiveSpot(record.target.spotId)) {
-                            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, `User Spot '${record.target.spotId}' is not materialized on its authority owner.`, true);
-                        }
-                        if (!local.canCloseUserSpot(meshName, record.target.spotId)) {
-                            return {
-                                terminalResult: runtime_values_1.RequestResult.Ok,
-                                failureCode: 0,
-                                tail: {
-                                    kind: 'userSpotClose',
-                                    closed: false
-                                }
-                            };
-                        }
                         return {
                             terminalResult: runtime_values_1.RequestResult.Ok,
                             failureCode: 0,
                             tail: {
                                 kind: 'userSpotClose',
-                                closed: await coordinator.handleRemoteClose(record, (spot, closeSignal) => local.close(spot.meshName, spot.spotId, closeSignal), signal)
+                                closed: await coordinator.handleRemoteClose(record, (spot, beginAuthority, closeSignal) => local.closeUserWithAuthority(spot.meshName, spot.spotId, beginAuthority, closeSignal), signal, (spot) => local.isSpotClosing(spot.meshName, spot.spotId))
                             }
                         };
                     }
@@ -1905,12 +1936,7 @@ class ZLinkFrameworkRuntimeHost {
                 });
             },
             meshRecordDispatcher: (meshName, owner, record) => this.dispatchMeshRecord(meshName, owner, record, this.executionState?.abortController.signal),
-            instanceActivationConcurrencyProvider: (meshName) => {
-                return (this.spotManager?.instanceActivationConcurrency(meshName) ?? {
-                    active: 0,
-                    limit: this.options.registration.spotNodes.get(meshName)?.activationConcurrencyLimit ?? 128
-                });
-            }
+            activationConcurrency: (meshName) => this.activationAdmission.current(meshName)
         };
     }
     async dispatchMeshRecord(meshName, owner, record, signal) {

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

@@ -338,7 +338,7 @@ class ZLinkRemoteBoundSessionRelay {
         const owner = (0, actor_session_binding_runtime_owner_1.actorSessionBindingRuntimeOwner)(runtime);
         const fingerprint = (0, service_stateful_wire_codec_1.encodeSessionRelocationRoute)(value).toString('base64');
         if (value.route.action === 'abort') {
-            await owner.applyRelocation(value.actor.actorId, key, fingerprint, 'abort', async () => {
+            await owner.applyRelocation(value.actor.actorId, key, fingerprint, async () => {
                 if (!(await runtime.abortActorRouteSeal(value.actor.actorId, key))) {
                     throw new bound_session_wire_1.ZLinkRemoteBoundSessionFenceError(`Actor '${value.actor.actorId}' command 44 abort lost its Session seal.`);
                 }
@@ -357,9 +357,10 @@ class ZLinkRemoteBoundSessionRelay {
                 nodeRid: (0, routing_id_1.decodeRoutingId)(committedRoute.targetNodeRid, undefined),
                 bindingGeneration: value.session.bindingGeneration,
                 ownershipGeneration: committedRoute.targetAuthorityOwnerGeneration,
-                ownerNodeGeneration: committedRoute.targetNodeGeneration
+                ownerNodeGeneration: committedRoute.targetNodeGeneration,
+                ownerLeaseGeneration: committedRoute.targetOwnerLeaseGeneration
             };
-            await owner.applyRelocation(value.actor.actorId, key, fingerprint, 'commit', async () => {
+            await owner.applyRelocation(value.actor.actorId, key, fingerprint, async () => {
                 await runtime.commitActorRoute(targetActorRef, undefined, {
                     confirmRemoteSessionBinding: 'send',
                     releaseSeal: { sealId: key }

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

@@ -9,6 +9,7 @@ type ZLinkMeshDrainResult = {
 };
 import type { ZLinkBackendMeshNode } from '../backend';
 import type { ZLinkRuntimeAdmissionGate } from '../admission';
+import type { ZLinkActivationAdmission } from '../activation-admission';
 import type { ZLinkSpotNodeOptions } from '../configuration';
 import { type ZLinkMeshNodeDescriptor } from '../../contracts';
 export interface ZLinkRouteMeshRuntimeCoordinatorOptions {
@@ -20,6 +21,7 @@ export interface ZLinkRouteMeshRuntimeCoordinatorOptions {
     readonly isLocationStoreHealthy?: () => boolean;
     readonly hostState?: () => ZLinkFrameworkRuntimeState;
     readonly admission: ZLinkRuntimeAdmissionGate;
+    readonly activationAdmission?: ZLinkActivationAdmission;
     readonly publishRetiring: (meshName: string, signal: AbortSignal) => Promise<void>;
     readonly rollbackRetiring: (meshName: string, signal: AbortSignal) => Promise<void>;
     readonly publishDraining: (meshName: string, signal: AbortSignal) => Promise<void>;