@zlink-systems/framework 0.26.0 → 0.27.0

package/dist/runtime/actors/actor-runtime-state.js

@@ -1,86 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkActorRuntimeState = void 0;
-exports.mergeRemoteBoundSessionTarget = mergeRemoteBoundSessionTarget;
-exports.preferredRemoteBoundSessionTarget = preferredRemoteBoundSessionTarget;
 exports.toFrameworkRoutingId = toFrameworkRoutingId;
 exports.toFrameworkActorRef = toFrameworkActorRef;
+const state_lane_1 = require("../execution/state-lane");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const routing_id_1 = require("../routing-id");
 const actor_native_lookup_1 = require("./actor-native-lookup");
 /**
- * Applies a lightweight Session binding refresh without discarding the
- * relocation fence that was staged for the same route. Core emits the bind
- * refresh with routing coordinates only; the relocation owner retains the
- * service-wire relocation identity until command 44 releases the owner seal.
+ * Session–Actor binding §5·§6: the Actor owner keeps one current binding. The
+ * stored value is the binding identity and the route to its Session owner; a
+ * relocation fence belongs to the relocation operation that created it.
  */
-function mergeRemoteBoundSessionTarget(target, fallback) {
-    if (fallback === undefined ||
-        fallback.routerChannelId !== target.routerChannelId ||
-        !(0, routing_id_1.routingIdsEqual)(fallback.targetNodeRid, target.targetNodeRid) ||
-        (!(0, routing_id_1.routingIdsEqual)(fallback.spotId, target.spotId) &&
-            !samePhysicalRemoteSession(fallback, target)) ||
-        isSuccessorSessionBinding(fallback, target)) {
-        return target;
-    }
-    const merged = {
-        ...fallback,
-        ...target,
-        sessionNodeRid: target.sessionNodeRid ?? fallback.sessionNodeRid,
-        sessionRid: target.sessionRid ?? fallback.sessionRid,
-        sessionOwnerNodeGeneration: target.sessionOwnerNodeGeneration ?? fallback.sessionOwnerNodeGeneration,
-        sessionOwnerId: target.sessionOwnerId ?? fallback.sessionOwnerId,
-        sessionOwnerLeaseGeneration: target.sessionOwnerLeaseGeneration ?? fallback.sessionOwnerLeaseGeneration,
-        bindingGeneration: target.bindingGeneration ?? fallback.bindingGeneration,
-        previousAuthorityOwnerGeneration: target.previousAuthorityOwnerGeneration ?? fallback.previousAuthorityOwnerGeneration,
-        previousOwnerLeaseGeneration: target.previousOwnerLeaseGeneration ?? fallback.previousOwnerLeaseGeneration,
-        relocationSealId: target.relocationSealId ?? fallback.relocationSealId,
-        serviceWireRelocation: target.serviceWireRelocation ?? fallback.serviceWireRelocation
+function boundSessionIdentity(target) {
+    return {
+        routerChannelId: target.routerChannelId,
+        targetNodeRid: target.targetNodeRid,
+        spotId: target.spotId,
+        sessionNodeRid: target.sessionNodeRid,
+        sessionRid: target.sessionRid,
+        sessionOwnerNodeGeneration: target.sessionOwnerNodeGeneration,
+        sessionOwnerId: target.sessionOwnerId,
+        sessionOwnerLeaseGeneration: target.sessionOwnerLeaseGeneration,
+        bindingGeneration: target.bindingGeneration
     };
-    return merged;
-}
-/**
- * Spec 48 §125: reconnection creates a new Session; the previous Session's
- * binding — and its staged relocation fence — is never inherited by a
- * successor. A Core bind refresh only omits routing coordinates it did not
- * recompute, so an explicit Session identity on both sides that disagrees
- * marks the refresh as belonging to a different Session binding, not a
- * same-Session coordinate/generation-only refresh (a bindingGeneration bump
- * with the same sessionNodeRid/sessionRid is a legitimate same-Session
- * refresh and must keep the fence — see the transfer-target generation test
- * below).
- *
- * NOTE: this identity check is a no-op on the path exercised by
- * `remoteBoundSessionTargetForSource` (mesh-router-resolver.ts), which never
- * populates sessionNodeRid/sessionRid on the refresh it emits. Confirmed via
- * TTT reproduction (2026-08-22, run-dir preserved) that a rejected successor
- * bound-session send still occurs through that path after this change; see
- * session report for the STOP writeup.
- */
-function isSuccessorSessionBinding(fallback, target) {
-    return ((fallback.sessionNodeRid !== undefined &&
-        target.sessionNodeRid !== undefined &&
-        !(0, routing_id_1.routingIdsEqual)(fallback.sessionNodeRid, target.sessionNodeRid)) ||
-        (fallback.sessionRid !== undefined &&
-            target.sessionRid !== undefined &&
-            !(0, routing_id_1.routingIdsEqual)(fallback.sessionRid, target.sessionRid)) ||
-        (fallback.sessionOwnerNodeGeneration !== undefined &&
-            target.sessionOwnerNodeGeneration !== undefined &&
-            fallback.sessionOwnerNodeGeneration !== target.sessionOwnerNodeGeneration) ||
-        (fallback.sessionOwnerId !== undefined &&
-            target.sessionOwnerId !== undefined &&
-            fallback.sessionOwnerId !== target.sessionOwnerId) ||
-        (fallback.sessionOwnerLeaseGeneration !== undefined &&
-            target.sessionOwnerLeaseGeneration !== undefined &&
-            fallback.sessionOwnerLeaseGeneration !== target.sessionOwnerLeaseGeneration));
-}
-function samePhysicalRemoteSession(left, right) {
-    return (left.sessionNodeRid !== undefined &&
-        right.sessionNodeRid !== undefined &&
-        left.sessionRid !== undefined &&
-        right.sessionRid !== undefined &&
-        (0, routing_id_1.routingIdsEqual)(left.sessionNodeRid, right.sessionNodeRid) &&
-        (0, routing_id_1.routingIdsEqual)(left.sessionRid, right.sessionRid));
 }
 function sameRemoteSessionOwnerLifecycle(left, right) {
     return (left.sessionNodeRid !== undefined &&
@@ -108,20 +51,6 @@ function sameRemoteSessionBinding(left, right) {
         right.bindingGeneration !== undefined &&
         left.bindingGeneration === right.bindingGeneration);
 }
-/**
- * Selects the route that still carries the relocation fence when a Core
- * binding refresh and a formal transfer target temporarily coexist.
- */
-function preferredRemoteBoundSessionTarget(remote, transfer) {
-    if (remote === undefined)
-        return transfer;
-    if (hasRelocationFence(remote) || transfer === undefined)
-        return remote;
-    return transfer;
-}
-function hasRelocationFence(target) {
-    return target.relocationSealId !== undefined || target.serviceWireRelocation !== undefined;
-}
 class ZLinkActorRuntimeState {
     actorId;
     creationTask;
@@ -135,10 +64,8 @@ class ZLinkActorRuntimeState {
     spotGenerationValue;
     spotMembershipEpochValue = 0n;
     nativeActorRefValue;
-    boundSessionBindingGenerationValue = 0n;
     entryNodeRidValue;
-    remoteBoundSessionTargetValue;
-    boundSessionTransferTargetValue;
+    boundSessionValue;
     remoteActorPacketTargetValue;
     createRequestPayloadValue;
     ownsLocationValue = false;
@@ -149,6 +76,9 @@ class ZLinkActorRuntimeState {
     destroyTask;
     constructor(actorId) {
         this.actorId = actorId;
+        if ((0, state_lane_1.isStructuralGuardEnabled)()) {
+            guardBoundSessionTargetWrites(this);
+        }
     }
     get actorType() {
         return this.actorTypeValue;
@@ -180,16 +110,28 @@ class ZLinkActorRuntimeState {
         return this.nativeActorRefValue;
     }
     get boundSessionBindingGeneration() {
-        return this.boundSessionBindingGenerationValue;
+        return this.boundSessionValue?.bindingGeneration ?? 0n;
     }
     get entryNodeRid() {
         return this.entryNodeRidValue;
     }
-    get remoteBoundSessionTarget() {
-        return this.remoteBoundSessionTargetValue;
+    /** The one current Session binding of this Actor (Session–Actor binding §6). */
+    get boundSession() {
+        return this.boundSessionValue;
     }
-    get boundSessionTransferTarget() {
-        return this.boundSessionTransferTargetValue;
+    /**
+     * The current binding when its Session owner is another node. A same-node
+     * binding is served by the local Session registry, so remote routing sees
+     * no target for it.
+     */
+    get remoteBoundSessionTarget() {
+        const binding = this.boundSessionValue;
+        const actorNodeRid = this.nativeActorRefValue?.nodeRid;
+        return binding?.sessionNodeRid !== undefined &&
+            actorNodeRid !== undefined &&
+            (0, routing_id_1.routingIdsEqual)(binding.sessionNodeRid, toFrameworkRoutingId(actorNodeRid))
+            ? undefined
+            : binding;
     }
     get remoteActorPacketTarget() {
         return this.remoteActorPacketTargetValue;
@@ -344,23 +286,6 @@ class ZLinkActorRuntimeState {
         this.nativeActorRefValue = actorRef;
         this.entryNodeRidValue ??= toFrameworkRoutingId(actorRef.nodeRid);
     }
-    setBoundSessionBindingGeneration(generation) {
-        if (generation > this.boundSessionBindingGenerationValue) {
-            this.boundSessionBindingGenerationValue = generation;
-            if (this.remoteBoundSessionTargetValue !== undefined) {
-                this.remoteBoundSessionTargetValue = {
-                    ...this.remoteBoundSessionTargetValue,
-                    bindingGeneration: generation
-                };
-            }
-            if (this.boundSessionTransferTargetValue !== undefined) {
-                this.boundSessionTransferTargetValue = {
-                    ...this.boundSessionTransferTargetValue,
-                    bindingGeneration: generation
-                };
-            }
-        }
-    }
     /** @internal Installs one authority-confirmed binding inside its Actor owner turn. */
     installBoundSessionBinding(target) {
         if (target.sessionNodeRid === undefined ||
@@ -369,28 +294,22 @@ class ZLinkActorRuntimeState {
             target.sessionOwnerId === undefined ||
             target.sessionOwnerLeaseGeneration === undefined ||
             target.bindingGeneration === undefined) {
-            throw new TypeError('An installed bound Session target requires its complete binding identity.');
+            throw new TypeError('An installed bound Session target requires its binding identity.');
         }
-        const current = preferredRemoteBoundSessionTarget(this.remoteBoundSessionTargetValue, this.boundSessionTransferTargetValue);
+        const current = this.boundSessionValue;
         if (current !== undefined && sameRemoteSessionOwnerLifecycle(current, target)) {
-            // A duplicate command for the exact physical Session is idempotent. A
-            // different Session in the same owner lifecycle must advance that
-            // lifecycle's generation; a late equal/lower generation is stale.
-            if (sameRemoteSessionOwner(current, target))
-                return true;
-            if (current.bindingGeneration !== undefined &&
-                current.bindingGeneration >= target.bindingGeneration)
-                return false;
+            // A duplicate or late older command for the exact physical Session
+            // leaves the current binding; a newer generation of the same Session
+            // replaces it. A different Session in the same owner lifecycle must
+            // advance that lifecycle's generation; a late equal/lower one is stale.
+            const advances = current.bindingGeneration === undefined ||
+                target.bindingGeneration > current.bindingGeneration;
+            if (!advances)
+                return sameRemoteSessionOwner(current, target);
         }
-        const installed = mergeRemoteBoundSessionTarget(target, current);
         // Binding generations are scoped to a Session-owner lifecycle. A restarted
         // owner can legitimately reset its counter below the predecessor value.
-        this.boundSessionBindingGenerationValue = target.bindingGeneration;
-        this.remoteBoundSessionTargetValue = undefined;
-        this.boundSessionTransferTargetValue = {
-            ...installed,
-            bindingGeneration: target.bindingGeneration
-        };
+        this.boundSessionValue = boundSessionIdentity(target);
         return true;
     }
     /** @internal Removes only the exact authority-confirmed Session incarnation. */
@@ -401,51 +320,17 @@ class ZLinkActorRuntimeState {
             target.sessionOwnerId === undefined ||
             target.sessionOwnerLeaseGeneration === undefined ||
             target.bindingGeneration === undefined) {
-            throw new TypeError('A retired bound Session target requires its complete binding identity.');
-        }
-        let retired = false;
-        if (this.remoteBoundSessionTargetValue !== undefined &&
-            sameRemoteSessionBinding(this.remoteBoundSessionTargetValue, target)) {
-            this.remoteBoundSessionTargetValue = undefined;
-            retired = true;
-        }
-        if (this.boundSessionTransferTargetValue !== undefined &&
-            sameRemoteSessionBinding(this.boundSessionTransferTargetValue, target)) {
-            this.boundSessionTransferTargetValue = undefined;
-            retired = true;
-        }
-        if (retired) {
-            this.boundSessionBindingGenerationValue =
-                preferredRemoteBoundSessionTarget(this.remoteBoundSessionTargetValue, this.boundSessionTransferTargetValue)?.bindingGeneration ?? 0n;
+            throw new TypeError('A retired bound Session target requires its binding identity.');
         }
-        return retired;
+        const current = this.boundSessionValue;
+        if (current === undefined || !sameRemoteSessionBinding(current, target))
+            return false;
+        this.boundSessionValue = undefined;
+        return true;
     }
     setEntryNodeRid(entryNodeRid) {
         this.entryNodeRidValue = entryNodeRid;
     }
-    setRemoteBoundSessionTarget(target) {
-        const current = preferredRemoteBoundSessionTarget(this.remoteBoundSessionTargetValue, this.boundSessionTransferTargetValue);
-        const merged = target === undefined ? undefined : mergeRemoteBoundSessionTarget(target, current);
-        const bindingGeneration = maxBindingGeneration(merged?.bindingGeneration, this.remoteBoundSessionTargetValue?.bindingGeneration, this.boundSessionBindingGenerationValue);
-        this.remoteBoundSessionTargetValue =
-            merged === undefined
-                ? undefined
-                : bindingGeneration === undefined
-                    ? merged
-                    : { ...merged, bindingGeneration };
-    }
-    setBoundSessionTransferTarget(target) {
-        const merged = target === undefined
-            ? undefined
-            : mergeRemoteBoundSessionTarget(target, this.boundSessionTransferTargetValue);
-        const bindingGeneration = maxBindingGeneration(merged?.bindingGeneration, this.boundSessionTransferTargetValue?.bindingGeneration, this.boundSessionBindingGenerationValue);
-        this.boundSessionTransferTargetValue =
-            merged === undefined
-                ? undefined
-                : bindingGeneration === undefined
-                    ? merged
-                    : { ...merged, bindingGeneration };
-    }
     setRemoteActorPacketTarget(target) {
         this.remoteActorPacketTargetValue = target;
     }
@@ -477,10 +362,8 @@ class ZLinkActorRuntimeState {
         this.spotGenerationValue = undefined;
         this.spotMembershipEpochValue = 0n;
         this.nativeActorRefValue = undefined;
-        this.boundSessionBindingGenerationValue = 0n;
         this.entryNodeRidValue = undefined;
-        this.remoteBoundSessionTargetValue = undefined;
-        this.boundSessionTransferTargetValue = undefined;
+        this.boundSessionValue = undefined;
         this.remoteActorPacketTargetValue = undefined;
         this.createRequestPayloadValue = undefined;
         this.ownsLocationValue = false;
@@ -493,10 +376,6 @@ class ZLinkActorRuntimeState {
     prepareForRemoteReentry() {
         if (this.remoteActorPacketTargetValue === undefined)
             return;
-        const relocationTransferTarget = this.boundSessionTransferTargetValue !== undefined &&
-            hasRelocationFence(this.boundSessionTransferTargetValue)
-            ? this.boundSessionTransferTargetValue
-            : undefined;
         this.creationTask = undefined;
         this.configured = false;
         this.context = undefined;
@@ -505,9 +384,8 @@ class ZLinkActorRuntimeState {
         this.spotValue = undefined;
         this.spotIdValue = undefined;
         this.nativeActorRefValue = undefined;
-        this.boundSessionBindingGenerationValue = relocationTransferTarget?.bindingGeneration ?? 0n;
-        this.remoteBoundSessionTargetValue = undefined;
-        this.boundSessionTransferTargetValue = relocationTransferTarget;
+        // The arriving relocation installs the binding it carries.
+        this.boundSessionValue = undefined;
         this.remoteActorPacketTargetValue = undefined;
         this.createRequestPayloadValue = undefined;
         this.ownsLocationValue = false;
@@ -519,15 +397,20 @@ class ZLinkActorRuntimeState {
     }
 }
 exports.ZLinkActorRuntimeState = ZLinkActorRuntimeState;
-function maxBindingGeneration(...values) {
-    let maximum;
-    for (const value of values) {
-        if (value === undefined || value <= 0n)
-            continue;
-        if (maximum === undefined || value > maximum)
-            maximum = value;
-    }
-    return maximum;
+function guardBoundSessionTargetWrites(actor) {
+    let current;
+    Object.defineProperty(actor, 'boundSessionValue', {
+        configurable: true,
+        enumerable: true,
+        get: () => current,
+        set: (target) => {
+            if (target !== undefined &&
+                new Error().stack?.includes('installBoundSessionBinding') !== true) {
+                throw new Error('Bound Session target must be installed by installBoundSessionBinding.');
+            }
+            current = target;
+        }
+    });
 }
 function toFrameworkRoutingId(routingId) {
     // Runtime routing identities are opaque binary values. Preserve binding

package/dist/runtime/actors/bound-session-wire.js

@@ -10,6 +10,7 @@ exports.decodeRemoteBoundSessionSendPayload = decodeRemoteBoundSessionSendPayloa
 exports.decodeRemoteBoundSessionResponsePayload = decodeRemoteBoundSessionResponsePayload;
 exports.decodeRemoteBoundSessionErrorPayload = decodeRemoteBoundSessionErrorPayload;
 exports.streamMetadataMap = streamMetadataMap;
+const flow_context_1 = require("../diagnostics/flow-context");
 exports.ZLINK_REMOTE_BOUND_SESSION_FENCE_NACK_CODE = 'zlink.bound_session.fence';
 /**
  * Permanent command 42/44/45 fence rejection from the session owner. The
@@ -61,14 +62,8 @@ function encodeRemoteBoundSessionSendPayload(input) {
         flowOrigin: encodeWireFlowOrigin(input.flowOrigin)
     };
 }
-const WIRE_FLOW_ORIGIN = {
-    Inbound: 'inbound',
-    Timer: 'timer',
-    Application: 'application',
-    Lifecycle: 'lifecycle'
-};
 function encodeWireFlowOrigin(origin) {
-    return origin === undefined ? undefined : WIRE_FLOW_ORIGIN[origin];
+    return origin === undefined ? undefined : flow_context_1.FLOW_ORIGIN_VALUES[origin];
 }
 function encodeRemoteBoundSessionResponsePayload(input) {
     return {

package/dist/runtime/actors/deferred-join-completion.d.ts

@@ -1,14 +1,19 @@
-import type { ActorRef, ZLinkActorJoinOperationId } from '../../contracts';
+import type { ActorRef, ZLinkActorJoinOperationId, ZLinkFrameworkErrorKind } from '../../contracts';
 /**
- * The Accepted completion of a deferred cross-node Join. Spot Actor membership
- * sections 4-5: the public OperationId, the optional reply and the delivery
+ * The Accepted or Failed result of a deferred cross-node Join. Spot Actor
+ * membership sections 4-5: the public OperationId, optional reply and delivery
  * state live only while the current source and target processes run. The
- * completion is never written to a Store and never replayed after a restart.
+ * completion is never written to a Store or replayed after a restart.
  */
-export interface ZLinkDeferredJoinCompletion {
+export type ZLinkDeferredJoinCompletion = {
     readonly operationId: ZLinkActorJoinOperationId;
     readonly actor: ActorRef;
     readonly rawReply: Buffer;
     readonly replyContentType?: string;
-}
+} & ({
+    readonly status: 'accepted';
+} | {
+    readonly status: 'failed';
+    readonly kind: ZLinkFrameworkErrorKind;
+});
 export declare function createDeferredJoinCompletion(actorId: string, operationId: ZLinkActorJoinOperationId, actor: ActorRef, rawReply: Uint8Array, replyContentType?: string): ZLinkDeferredJoinCompletion;

package/dist/runtime/actors/deferred-join-completion.js

@@ -12,6 +12,7 @@ function createDeferredJoinCompletion(actorId, operationId, actor, rawReply, rep
         throw new TypeError('Deferred Join reply content type must be non-empty.');
     }
     return {
+        status: 'accepted',
         operationId,
         actor,
         rawReply: Buffer.from(rawReply),

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

@@ -1,20 +1,19 @@
-import type { ActorRef, RoutingId, SpotRef, ZLinkActor, ZLinkActorCreateCall, ZLinkActorGetOrCreateCall, ZLinkActorManager } from '../../contracts';
-import { ZLinkMessage } from '../../contracts';
+import { type ActorRef, type RoutingId, type SpotRef, type ZLinkActor, type ZLinkActorCreateCall, type ZLinkActorGetOrCreateCall, type ZLinkActorManager, ZLinkMessage } from '../../contracts';
 import type { ZLinkBackendActorRef, ZLinkBackendSpotNode } from '../backend/contracts';
+import type { ZLinkActorManagerOptions } from './actor-runtime-contracts';
+import { ZLinkActorRuntimeState } from './actor-runtime-state';
 export { DefaultZLinkActorClient, forwardEncodedActorPacket, type ZLinkActorClientOptions } from './actor-client';
 export { DefaultZLinkActorContext, ZLINK_ACTOR_JOIN_ENTRY_SPOT_RUNTIME } from './actor-context';
 export { ZLinkActorSerialExecutor } from './actor-mailbox';
 export { DEFAULT_MESSAGE_FOLLOW_DURATION_MS, ZLinkActorHandoffCoordinator, decodeHandoffPacket, type ZLinkActorHandoffPacket, type ZLinkActorHandoffDispatch, type ZLinkActorHandoffPrefixAdmission, type ZLinkActorHandoffPrefixQueue, type ZLinkActorHandoffPrefixRecord, type ZLinkActorHandoffPreparedReplayAdmission, type ZLinkActorHandoffReplayAdmission, type ZLinkActorHandoffReplayPreparation, type ZLinkActorHandoffResult } from './actor-handoff';
 export { actorMessageFollowContext, attachActorMessageFollowContext, decodeActorMessageFollowContext, type ZLinkActorMessageFollowContext, type ZLinkActorMessageFollowOwnerFence } from './actor-message-follow-context';
-export { ZLinkActorRuntimeState, mergeRemoteBoundSessionTarget, preferredRemoteBoundSessionTarget, toFrameworkActorRef, toFrameworkRoutingId, type ZLinkActorCreationOperation, type ZLinkRemoteActorPacketTarget, type ZLinkRemoteBoundSessionTarget } from './actor-runtime-state';
+export { ZLinkActorRuntimeState, toFrameworkActorRef, toFrameworkRoutingId, type ZLinkActorCreationOperation, type ZLinkRemoteActorPacketTarget, type ZLinkRemoteBoundSessionTarget } from './actor-runtime-state';
 export { createDeferredJoinCompletion, type ZLinkDeferredJoinCompletion } from './deferred-join-completion';
 export { decodeActorAuthorityIdentity, decodeRelocatingActorAuthorityIdentity, encodeActorAuthorityIdentity, isActorAuthorityPayload, rewriteActorAuthorityRoute, rewriteActorAuthorityOwner, publishInitialActorAuthority, type ZLinkActorAuthorityIdentity } from './actor-authority-publication';
-import { ZLinkActorRuntimeState } from './actor-runtime-state';
 export { ZLinkActorPacketKind, ZLinkSpotActorDispatcher, ZLinkSpotActorHandlerRegistryRuntime, type ZLinkActorPacketDescriptor, type ZLinkSpotActorDispatcherOptions } from './spot-actor-dispatch';
 export { ZLinkActorNativeJoinCoordinator, type ZLinkActorNativeJoinCoordinatorOptions } from './actor-remote-joiner';
 export type { ZLinkActorRoutedJoinTransport } from './actor-routed-join-transport';
 export type { ZLinkActorBoundSessionFactory, ZLinkActorJoinCoordinator, ZLinkActorManagerOptions } from './actor-runtime-contracts';
-import type { ZLinkActorManagerOptions } from './actor-runtime-contracts';
 export { ZLinkActorTransferRegistry, type ZLinkActorTransferPayloadState } from './actor-transfer-registry';
 export { ZLINK_REMOTE_ACTOR_JOIN_PACKET, ZLINK_REMOTE_ACTOR_SOURCE_LEAVE_TERMINAL, decodeRemoteActorSourceLeaveTerminal } from './actor-remote-wire';
 export { ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET } from './actor-packet-relay-wire';
@@ -22,12 +21,13 @@ export { ZLINK_REMOTE_BOUND_SESSION_ERROR_PACKET, ZLINK_REMOTE_BOUND_SESSION_FEN
 export { actorJoinIdentity, createActorJoinRequest, createActorMembership, ZLINK_ACTOR_LIFECYCLE_SNAPSHOT, type ZLinkActorLifecycleSnapshotSource } from './actor-lifecycle-snapshot';
 export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     private readonly options;
+    private readonly detachedTaskRunner;
     private readonly states;
     private readonly actorMeshNames;
     private readonly relocationStaged;
     private readonly creation;
     private readonly transferredActorRollback;
-    constructor(options: ZLinkActorManagerOptions);
+    constructor(options: ZLinkActorManagerOptions, detachedTaskRunner: import('../spots/spot-actor-join-dispatch').ZLinkDetachedTaskRunner);
     create(actorId: string, actorType: string): ZLinkActorCreateCall;
     find(actorId: string, signal?: AbortSignal): Promise<ActorRef | undefined>;
     getOrCreate(actorId: string, actorType: string): ZLinkActorGetOrCreateCall;
@@ -44,7 +44,7 @@ export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     private rememberActorMeshFromType;
     findActor(actorId: string, signal?: AbortSignal): Promise<ZLinkActor | undefined>;
     requireRelocationActorFactory(actorType: string): void;
-    prepareRelocationActor(actorId: string, actorType: string, objectGeneration: bigint, authorityOwnerGeneration: bigint, spotId: RoutingId, spotGeneration: bigint, membershipEpoch: bigint, signal?: AbortSignal, transfer?: {
+    prepareRelocationActor(actorId: string, actorType: string, objectGeneration: bigint, authorityOwnerGeneration: bigint, spotId: RoutingId | undefined, spotGeneration: bigint, membershipEpoch: bigint, signal?: AbortSignal, transfer?: {
         readonly adapterKey: string;
         readonly state: ZLinkMessage;
     }): Promise<ZLinkActor>;
@@ -53,6 +53,8 @@ export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     completeRelocationSource(actorId: string, sourceActorRef?: ZLinkBackendActorRef): Promise<void>;
     private removeRelocationActor;
     completeCoreRelocationSource(actorId: string): Promise<void>;
+    private finalizeActorState;
+    private finalizeDestroyedActor;
     getOrCreateActor(actorId: string, actorType: string, signal?: AbortSignal): Promise<ZLinkActor>;
     getOrCreateWithNativeRef(actorId: string, actorType: string, actorRef: ZLinkBackendActorRef, createRequest?: unknown, signal?: AbortSignal): Promise<ZLinkActor>;
     getOrCreateActorResult(actorId: string, actorType: string, createRequest?: unknown, signal?: AbortSignal): Promise<ZLinkActorLocalCreateResult>;