@zlink-systems/framework 0.26.0 → 0.28.0

package/dist/runtime/spots/spot-activation-registry.d.ts

@@ -1,7 +1,6 @@
-import type { RoutingId, Type, ZLinkSpot, ZLinkSpotInfo } from '../../contracts';
-import type { ZLinkLocalSpotCreateResult } from './spot-manager-internal-contracts';
-import { ZLinkSpotCloseReason } from '../../contracts';
+import { type RoutingId, type Type, type ZLinkSpot, type ZLinkSpotInfo, ZLinkSpotCloseReason } from '../../contracts';
 import type { ZLinkSpotActivation } from './spot-activation-state';
+import type { ZLinkLocalSpotCreateResult } from './spot-manager-internal-contracts';
 export { ZLinkSpotActivation } from './spot-activation-state';
 export interface ZLinkSpotActivationOperation {
     readonly owner: boolean;
@@ -14,7 +13,6 @@ export interface ZLinkSpotCloseOperation {
     readonly started: boolean;
 }
 export declare class ZLinkSpotActivationRegistry {
-    private readonly isCommittedClose;
     private nextId;
     private readonly activations;
     private readonly staged;
@@ -24,7 +22,7 @@ export declare class ZLinkSpotActivationRegistry {
     private readonly emptyWaiters;
     private readonly lifecycleMetrics;
     private activeScan;
-    constructor(metrics?: import('../diagnostics').ZLinkRuntimeMetrics, isCommittedClose?: (meshName: string, spotId: RoutingId) => boolean);
+    constructor(metrics?: import('../diagnostics').ZLinkRuntimeMetrics);
     allocateSpotId(meshName: string): RoutingId;
     resolve(meshName: string, spotId: RoutingId): ZLinkSpotActivation | undefined;
     resolveUnique(spotId: RoutingId): ZLinkSpotActivation | undefined;

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

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotActivationRegistry = exports.ZLinkSpotActivation = void 0;
-const framework_errors_internal_1 = require("../framework-errors-internal");
 const contracts_1 = require("../../contracts");
-const configuration_1 = require("../configuration");
 const abort_1 = require("../abort");
+const framework_errors_internal_1 = require("../framework-errors-internal");
 const spot_lifecycle_metrics_1 = require("./spot-lifecycle-metrics");
+const DEFAULT_ACTIVE_ACTIVATION_BATCH_SIZE = 64;
 var spot_activation_state_1 = require("./spot-activation-state");
 Object.defineProperty(exports, "ZLinkSpotActivation", { enumerable: true, get: function () { return spot_activation_state_1.ZLinkSpotActivation; } });
 class ZLinkSpotActivationRegistry {
-    isCommittedClose;
     nextId = 1;
     activations = new Map();
     staged = new Set();
@@ -19,8 +18,7 @@ class ZLinkSpotActivationRegistry {
     emptyWaiters = new Set();
     lifecycleMetrics;
     activeScan;
-    constructor(metrics, isCommittedClose = () => false) {
-        this.isCommittedClose = isCommittedClose;
+    constructor(metrics) {
         this.lifecycleMetrics = new spot_lifecycle_metrics_1.ZLinkSpotLifecycleMetrics(metrics);
     }
     allocateSpotId(meshName) {
@@ -33,28 +31,16 @@ class ZLinkSpotActivationRegistry {
     }
     resolve(meshName, spotId) {
         const key = spotActivationKey(meshName, spotId);
-        return this.isCommittedClose(meshName, spotId) ||
-            this.closing.has(key) ||
-            this.failedClose.has(key) ||
-            this.staged.has(key)
-            ? undefined
-            : this.activations.get(key);
+        return this.staged.has(key) ? undefined : this.activations.get(key);
     }
     resolveUnique(spotId) {
         const matches = [...this.activations.values()].filter((activation) => String(activation.spotId) === String(spotId) &&
-            !this.isCommittedClose(activation.meshName, activation.spotId) &&
-            !this.staged.has(spotActivationKey(activation.meshName, activation.spotId)) &&
-            !this.closing.has(spotActivationKey(activation.meshName, activation.spotId)) &&
-            !this.failedClose.has(spotActivationKey(activation.meshName, activation.spotId)));
+            !this.staged.has(spotActivationKey(activation.meshName, activation.spotId)));
         return matches.length === 1 ? matches[0] : undefined;
     }
     has(meshName, spotId) {
         const key = spotActivationKey(meshName, spotId);
-        return (!this.isCommittedClose(meshName, spotId) &&
-            !this.staged.has(key) &&
-            !this.closing.has(key) &&
-            !this.failedClose.has(key) &&
-            this.activations.has(key));
+        return !this.staged.has(key) && this.activations.has(key);
     }
     list(meshName) {
         return [...this.activations.values()]
@@ -62,10 +48,7 @@ class ZLinkSpotActivationRegistry {
             if (activation.meshName !== meshName)
                 return false;
             const key = spotActivationKey(activation.meshName, activation.spotId);
-            return (!this.isCommittedClose(meshName, activation.spotId) &&
-                !this.staged.has(key) &&
-                !this.closing.has(key) &&
-                !this.failedClose.has(key));
+            return !this.staged.has(key);
         })
             .map((activation) => String(activation.spotId))
             .sort((left, right) => left.localeCompare(right))
@@ -88,7 +71,7 @@ class ZLinkSpotActivationRegistry {
     hasActiveActivations() {
         return this.activations.size > 0;
     }
-    nextActiveActivationBatch(limit = 64) {
+    nextActiveActivationBatch(limit = DEFAULT_ACTIVE_ACTIVATION_BATCH_SIZE) {
         if (!Number.isInteger(limit) || limit <= 0)
             throw new RangeError('Activation scan limit must be positive.');
         if (this.activations.size === 0) {
@@ -205,35 +188,16 @@ class ZLinkSpotActivationRegistry {
     }
     getOrBegin(meshName, spotType, spotId, create) {
         const key = spotActivationKey(meshName, spotId);
-        if (this.isCommittedClose(meshName, spotId)) {
-            return {
-                owner: false,
-                ready: Promise.reject((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, `Spot '${String(spotId)}' is Closing.`))
-            };
-        }
-        const closing = this.closing.get(key);
-        if (closing !== undefined) {
-            return {
-                owner: false,
-                ready: closing.ready
-                    .catch(() => undefined)
-                    .then(() => this.getOrBegin(meshName, spotType, spotId, create).ready)
-            };
-        }
-        if (this.failedClose.has(key)) {
-            return {
-                owner: false,
-                ready: Promise.reject(new configuration_1.ZLinkConfigurationException(`Spot '${spotId}' cleanup has not completed.`))
-            };
-        }
         const existing = this.activations.get(key);
         if (existing !== undefined) {
-            if (existing.spotType !== spotType) {
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotTypeMismatch, `Spot '${spotId}' already exists with a different spot type.`);
-            }
             return {
                 owner: false,
-                ready: Promise.resolve({ spotId, state: contracts_1.ZLinkSpotCreateState.Existing })
+                ready: existing.serial.execute(() => {
+                    if (existing.spotType !== spotType) {
+                        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotTypeMismatch, `Spot '${spotId}' already exists with a different spot type.`);
+                    }
+                    return { spotId, state: contracts_1.ZLinkSpotCreateState.Existing };
+                })
             };
         }
         const pending = this.pending.get(key);

package/dist/runtime/spots/spot-activation-state.d.ts

@@ -72,7 +72,7 @@ export declare class ZLinkSpotActivation {
     completeConsumedRelocationBoundary(outcome: ZLinkSpotRelocationReadyOutcome): Promise<void>;
     notifyRelocatedBoundary(): Promise<void>;
     executeActor<T>(actorId: string, operation: (serial: ZLinkSpotSerialTurnExecutor) => Promise<T> | T): Promise<T>;
-    sealExecution(drainsYieldedTurns?: boolean): ZLinkExecutionBarrierSeal;
+    sealExecution(kind?: ZLinkExecutionBarrierSeal['kind']): ZLinkExecutionBarrierSeal;
     waitForExecutionQuiescence(seal: ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void>;
     abortExecutionSeal(seal: ZLinkExecutionBarrierSeal): boolean;
     commitExecutionSeal(seal: ZLinkExecutionBarrierSeal): boolean;

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

@@ -158,8 +158,8 @@ class ZLinkSpotActivation {
     admitActorDurablePrefix(actorId, records) {
         return this.serialExecutor.admitActorDurablePrefix(actorId, records);
     }
-    sealExecution(drainsYieldedTurns = false) {
-        return this.executionBarrier.seal(drainsYieldedTurns);
+    sealExecution(kind = 'relocation') {
+        return this.executionBarrier.seal(kind);
     }
     waitForExecutionQuiescence(seal, signal) {
         return this.executionBarrier.waitForQuiescence(seal, signal);

package/dist/runtime/spots/spot-activation.d.ts

@@ -36,7 +36,6 @@ export interface ZLinkSpotActivationLifecycleOptions {
     readonly routedTransport?: ZLinkSpotRoutedTransport;
     readonly addressTransport?: ZLinkSpotAddressTransport;
     readonly spotRouterChannelIdForMesh?: (meshName: string) => string;
-    readonly channelMeshNameForChannel?: (channelName: string) => string | undefined;
     readonly providerResolver?: ZLinkProviderResolver;
     readonly dispatchErrors?: ZLinkDispatchErrorReporter;
     readonly closeErrorSink?: import('../diagnostics/dispatch-error-port').ZLinkDispatchErrorSink;
@@ -51,13 +50,12 @@ export interface ZLinkSpotActivationLifecycleOptions {
     readonly actorTransferRuntime?: ZLinkSpotActorTransferRuntime;
     readonly boundSessionRuntime?: ZLinkSpotBoundSessionRuntime;
     readonly actorHandoffRuntime?: ZLinkSpotActorHandoffRuntime;
-    readonly detachedTaskRunner?: ZLinkDetachedTaskRunner;
+    readonly detachedTaskRunner: ZLinkDetachedTaskRunner;
     readonly admission?: ZLinkRuntimeAdmissionGate;
     readonly statefulExecutionAllowed?: () => boolean;
     readonly leaveActor: (spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal, meshName?: string) => Promise<void>;
     /** Starts a context Close request after its calling turn has ended. */
     readonly requestContextClose: (activation: ZLinkSpotActivation, objectGeneration: bigint, signal?: AbortSignal) => Promise<boolean>;
-    readonly isSpotClosing: (activation: ZLinkSpotActivation) => boolean;
     readonly registerActivation: (activation: ZLinkSpotActivation) => void;
     readonly routeToActorJoinPrewarm?: ZLinkRouteToActorJoinPrewarm;
     readonly releaseLocation: (activation: ZLinkSpotActivation, meshName: string, spotId: RoutingId) => Promise<void>;
@@ -75,7 +73,7 @@ export declare class ZLinkSpotActivationLifecycle {
     private readonly cleanupStates;
     constructor(options: ZLinkSpotActivationLifecycleOptions);
     materializeRelocation<TSpot extends ZLinkSpot | ZLinkInstanceSpot>(meshName: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, implementation: Type<TSpot>, spotId: RoutingId, objectGeneration: bigint, authorityOwnerGeneration: bigint, signal?: AbortSignal): Promise<ZLinkSpotActivation>;
-    materializeInstance<TSpot extends ZLinkInstanceSpot>(meshName: string, instanceType: string, implementation: Type<TSpot>, spotId: RoutingId, objectGeneration: bigint, signal?: AbortSignal): Promise<ZLinkSpotActivation>;
+    materializeInstance<TSpot extends ZLinkInstanceSpot>(meshName: string, instanceType: string, implementation: Type<TSpot>, spotId: RoutingId, objectGeneration: bigint, signal?: AbortSignal, serialOwner?: ZLinkSpotActivation): Promise<ZLinkSpotActivation>;
     discardInstance(activation: ZLinkSpotActivation): Promise<void>;
     create<TSpot extends ZLinkSpot>(meshName: string, spotType: Type<TSpot>, spotId: RoutingId, request: Message, signal?: AbortSignal, authority?: ZLinkNativeSpotAuthority): Promise<ZLinkLocalSpotCreateResult>;
     private createWithoutNativeSpot;
@@ -83,6 +81,7 @@ export declare class ZLinkSpotActivationLifecycle {
     sealForClose(activation: ZLinkSpotActivation, seal: import('../execution').ZLinkExecutionBarrierSeal, signal?: AbortSignal): Promise<void>;
     /** Returns the OnClosing failure, which cleanup records and does not rethrow. */
     cleanupClosedActivation(activation: ZLinkSpotActivation, reason?: ZLinkSpotCloseReason, deadline?: Date): Promise<unknown>;
+    cleanupFailedIncarnation(activation: ZLinkSpotActivation): Promise<void>;
     dispatchActorPacket(activation: ZLinkSpotActivation, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     private runCreateLifecycle;
     private cleanupActivation;

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

@@ -24,6 +24,9 @@ class ZLinkSpotActivationLifecycle {
     cleanupStates = new WeakMap();
     constructor(options) {
         this.options = options;
+        if (options.detachedTaskRunner === undefined) {
+            throw new configuration_1.ZLinkConfigurationException('Spot activation requires a detached task runner.');
+        }
         this.actorAdmission = new spot_actor_admission_coordinator_1.ZLinkSpotActorAdmissionCoordinator(options);
     }
     async materializeRelocation(meshName, objectKind, stableType, implementation, spotId, objectGeneration, authorityOwnerGeneration, signal) {
@@ -63,7 +66,7 @@ class ZLinkSpotActivationLifecycle {
         const common = {
             meshName,
             spotId,
-            objectGeneration: toContextGeneration(objectGeneration),
+            objectGeneration: objectGeneration,
             outbound,
             timers,
             serial,
@@ -131,16 +134,24 @@ class ZLinkSpotActivationLifecycle {
             return activation;
         }
         catch (error) {
-            await timers.dispose().catch(() => undefined);
-            if (instance !== undefined) {
-                await (0, handler_instance_scope_1.disposeLifecycleHandlers)(instance).catch(() => undefined);
+            const cleanup = await Promise.allSettled([
+                timers.dispose(),
+                ...(instance === undefined
+                    ? []
+                    : [(0, handler_instance_scope_1.disposeLifecycleHandlers)(instance, this.options.detachedTaskRunner)]),
+                ...(nativeSpot === undefined ? [] : [Promise.resolve().then(() => nativeSpot.dispose())])
+            ]);
+            const cleanupErrors = cleanup
+                .filter((result) => result.status === 'rejected')
+                .map((result) => result.reason);
+            if (cleanupErrors.length > 0) {
+                throw new AggregateError([error, ...cleanupErrors], `Spot '${spotId}' relocation materialization cleanup failed.`);
             }
-            await nativeSpot?.dispose().catch(() => undefined);
             throw error;
         }
     }
-    async materializeInstance(meshName, instanceType, implementation, spotId, objectGeneration, signal) {
-        const serial = new spot_serial_turn_executor_1.ZLinkSpotSerialTurnExecutor(true, spotId);
+    async materializeInstance(meshName, instanceType, implementation, spotId, objectGeneration, signal, serialOwner) {
+        const serial = serialOwner?.serial ?? new spot_serial_turn_executor_1.ZLinkSpotSerialTurnExecutor(true, spotId);
         const serialExecutor = new spot_serial_executor_1.ZLinkSpotSerialExecutor(serial, contracts_1.ZLinkUserSpotExecutionMode.SpotWide, spotId);
         const actorHandlers = new actors_1.ZLinkSpotActorHandlerRegistryRuntime();
         const handlers = new spot_handler_registry_1.DefaultZLinkSpotHandlerRegistry(actorHandlers);
@@ -162,7 +173,7 @@ class ZLinkSpotActivationLifecycle {
         const context = (0, spot_context_1.createInstanceSpotContext)({
             meshName,
             spotId,
-            objectGeneration: toContextGeneration(objectGeneration),
+            objectGeneration: objectGeneration,
             handlers: instanceHandlers,
             outbound,
             timers,
@@ -192,6 +203,7 @@ class ZLinkSpotActivationLifecycle {
             timers,
             actorHandlers,
             handlers,
+            executionBarrier: serialOwner?.executionBarrier,
             externalActorCount: () => this.options.actorCountProvider?.(spotId) ?? 0
         });
         try {
@@ -201,14 +213,21 @@ class ZLinkSpotActivationLifecycle {
                 runtimeEventPublisher: this.options.runtimeEventPublisher,
                 signal
             });
-            await serial.execute(() => instance.onInitialize?.());
+            await (serialOwner === undefined
+                ? serial.execute(() => instance.onInitialize?.())
+                : serial.postBarrierTurn(() => instance.onInitialize?.()));
             this.options.registerActivation(activation);
             return activation;
         }
         catch (error) {
-            await timers.dispose();
-            await (0, handler_instance_scope_1.disposeLifecycleHandlers)(instance);
-            throw new AggregateError([error], `Instance Spot '${instanceType}' materialization failed for '${String(spotId)}'.`);
+            const cleanup = await Promise.allSettled([
+                timers.dispose(),
+                (0, handler_instance_scope_1.disposeLifecycleHandlers)(instance, this.options.detachedTaskRunner)
+            ]);
+            const cleanupErrors = cleanup
+                .filter((result) => result.status === 'rejected')
+                .map((result) => result.reason);
+            throw new AggregateError([error, ...cleanupErrors], `Instance Spot '${instanceType}' materialization failed for '${String(spotId)}'.`);
         }
     }
     async discardInstance(activation) {
@@ -232,7 +251,7 @@ class ZLinkSpotActivationLifecycle {
             errors.push(error);
         }
         try {
-            await (0, handler_instance_scope_1.disposeLifecycleHandlers)(activation.spot);
+            await (0, handler_instance_scope_1.disposeLifecycleHandlers)(activation.spot, this.options.detachedTaskRunner);
         }
         catch (error) {
             errors.push(error);
@@ -291,7 +310,7 @@ class ZLinkSpotActivationLifecycle {
         const context = (0, spot_context_1.createSpotContext)({
             meshName,
             spotId,
-            objectGeneration: toContextGeneration(spotGeneration),
+            objectGeneration: spotGeneration,
             handlers,
             outbound,
             timers,
@@ -356,9 +375,11 @@ class ZLinkSpotActivationLifecycle {
                 else {
                     const partialCleanup = await Promise.allSettled([
                         timers.dispose(),
-                        ...(spot === undefined ? [] : [(0, handler_instance_scope_1.disposeLifecycleHandlers)(spot)]),
-                        nativeSpot.dispose(),
-                        this.options.locationClaim.release(locationClaim.meshName, spotId)
+                        ...(spot === undefined
+                            ? []
+                            : [(0, handler_instance_scope_1.disposeLifecycleHandlers)(spot, this.options.detachedTaskRunner)]),
+                        Promise.resolve().then(() => nativeSpot.dispose()),
+                        Promise.resolve().then(() => this.options.locationClaim.release(locationClaim.meshName, spotId))
                     ]);
                     const partialErrors = partialCleanup
                         .filter((result) => result.status === 'rejected')
@@ -385,7 +406,7 @@ class ZLinkSpotActivationLifecycle {
         const context = (0, spot_context_1.createSpotContext)({
             meshName,
             spotId,
-            objectGeneration: toContextGeneration(objectGeneration),
+            objectGeneration: objectGeneration,
             handlers,
             outbound,
             timers,
@@ -444,13 +465,7 @@ class ZLinkSpotActivationLifecycle {
         };
     }
     async sealForClose(activation, seal, signal) {
-        try {
-            await activation.waitForExecutionQuiescence(seal, signal);
-        }
-        catch (error) {
-            activation.abortExecutionSeal(seal);
-            throw error;
-        }
+        await activation.waitForExecutionQuiescence(seal, signal);
         if (!activation.commitExecutionSeal(seal)) {
             throw new Error(`Spot '${String(activation.spotId)}' close seal is stale.`);
         }
@@ -459,6 +474,9 @@ class ZLinkSpotActivationLifecycle {
     async cleanupClosedActivation(activation, reason = contracts_1.ZLinkSpotCloseReason.ExplicitClose, deadline) {
         return await this.cleanupActivation(activation, activation.meshName, true, undefined, reason, deadline, true);
     }
+    async cleanupFailedIncarnation(activation) {
+        await this.cleanupActivation(activation, activation.meshName, false, undefined, contracts_1.ZLinkSpotCloseReason.ExplicitClose, undefined, true);
+    }
     async dispatchActorPacket(activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
         return await this.actorAdmission.dispatchActorPacket(activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
     }
@@ -570,7 +588,7 @@ class ZLinkSpotActivationLifecycle {
             });
         }
         if (!state.handlersDisposed) {
-            await cleanup(() => (0, handler_instance_scope_1.disposeLifecycleHandlers)(activation.spot), () => {
+            await cleanup(() => (0, handler_instance_scope_1.disposeLifecycleHandlers)(activation.spot, this.options.detachedTaskRunner), () => {
                 state.handlersDisposed = true;
             });
         }
@@ -585,6 +603,11 @@ class ZLinkSpotActivationLifecycle {
             });
         }
         if (!state.locationReleased &&
+            // Spot messaging §7 step 3: an Instance Spot's ExplicitClose releases its authority
+            // through the Close operation's Closing fence; a User Spot still releases its location.
+            !(owningLifecycle &&
+                reason === contracts_1.ZLinkSpotCloseReason.ExplicitClose &&
+                activation.domain.kind === 'instance') &&
             state.timersDisposed &&
             state.serialDisposed &&
             state.handlersDisposed &&
@@ -615,9 +638,3 @@ class ZLinkSpotActivationLifecycle {
     }
 }
 exports.ZLinkSpotActivationLifecycle = ZLinkSpotActivationLifecycle;
-function toContextGeneration(generation) {
-    if (generation < 0n || generation > BigInt(Number.MAX_SAFE_INTEGER)) {
-        throw new configuration_1.ZLinkConfigurationException(`Spot object generation '${generation}' cannot be represented by the Node.js public context.`);
-    }
-    return Number(generation);
-}

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

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

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

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

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

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