@zlink-systems/framework 0.25.0 → 0.26.0

package/dist/runtime/foundation/service-stateful-wire-codec.js

@@ -42,6 +42,7 @@ const framework_errors_internal_1 = require("../framework-errors-internal");
 const routing_id_1 = require("../routing-id");
 const service_wire_constants_generated_1 = require("./service-wire-constants.generated");
 const service_wire_binary_primitives_1 = require("./service-wire-binary-primitives");
+const service_wire_codec_generated_1 = require("../protocol/service_wire_codec.generated");
 const service_wire_pilot_codec_generated_1 = require("../protocol/service_wire_pilot_codec.generated");
 const PREFIX_SIZE = 5;
 const MAGIC_0 = service_wire_constants_generated_1.SERVICE_WIRE_MAGIC[0];
@@ -491,20 +492,85 @@ function fromGeneratedReplyRelay(value) {
             })
     };
 }
-function encodeSpotHeader(kind, sourceSpotId, target, correlation) {
-    return concat(prefix(kind === 'spotSend' ? exports.M6bServiceWireCommand.spotSend : exports.M6bServiceWireCommand.spotRequest), ...(kind === 'spotRequest' ? [u64(requirePositive(correlation, 'correlation'))] : []), rid(sourceSpotId, 'sourceSpotId'), directSpotFence(target));
+const STATEFUL_MESSAGE_CONTEXT = {
+    effectiveCompleteMessageBytesMinusActualEnvelopeOverhead: 0xffff_fdf6,
+    effectiveCompleteMessageBytes: 0xffff_ffff
+};
+const STATEFUL_HEADER_PAYLOAD = {
+    packetName: 'wire',
+    contentType: 'application/json',
+    payload: Buffer.from('{}')
+};
+function generatedSpotFence(target) {
+    return {
+        spot: { spotId: target.spot.spotId, objectGeneration: target.spot.generation },
+        targetNodeRid: toGeneratedRoutingId(target.targetNodeRid, 'targetNodeRid'),
+        targetNodeGeneration: target.targetNodeGeneration,
+        expectedAuthorityOwnerGeneration: target.authorityOwnerGeneration,
+        expectedOwnerLeaseGeneration: target.ownerLeaseGeneration
+    };
+}
+function generatedActorFence(target) {
+    return {
+        actor: { actorId: target.actor.actorId, objectGeneration: target.actor.generation },
+        targetNodeRid: toGeneratedRoutingId(target.actor.nodeRid, 'targetNodeRid'),
+        targetNodeGeneration: target.targetNodeGeneration,
+        expectedAuthorityOwnerGeneration: target.authorityOwnerGeneration,
+        expectedOwnerLeaseGeneration: target.ownerLeaseGeneration
+    };
 }
-function encodeActorHeader(kind, target, correlation, sourceActor, boundSession) {
+function encodeSpotHeader(kind, sourceSpotId, target, correlation, operation = { high: 0n, low: 1n }, messageFollowHopCount = 0, metadataFrame) {
+    const common = {
+        flags: metadataFrame === undefined ? 0 : exports.M6bServiceWireFlag.metadata,
+        operation,
+        messageFollowHopCount,
+        sourceSpotId,
+        targetSpot: generatedSpotFence(target),
+        payload: STATEFUL_HEADER_PAYLOAD,
+        ...(metadataFrame === undefined
+            ? {}
+            : { metadata: (0, service_wire_codec_generated_1.decodeMetadataFrame)(metadataFrame, STATEFUL_MESSAGE_CONTEXT) })
+    };
+    const frames = kind === 'spotSend'
+        ? (0, service_wire_codec_generated_1.encodeSpotSendCommand)({ command: kind, ...common }, STATEFUL_MESSAGE_CONTEXT)
+        : (0, service_wire_codec_generated_1.encodeSpotRequestCommand)({
+            command: kind,
+            ...common,
+            correlation: requirePositive(correlation, 'correlation')
+        }, STATEFUL_MESSAGE_CONTEXT);
+    return Buffer.from(frames[0]);
+}
+function encodeActorHeader(kind, target, correlation, sourceActor, boundSession, operation = { high: 0n, low: 1n }, messageFollowHopCount = 0) {
     const flags = boundSession === undefined
         ? 0
         : exports.M6bServiceWireFlag.boundSession | exports.M6bServiceWireFlag.sourceSpotId;
-    return concat(prefix(kind === 'actorSend' ? exports.M6bServiceWireCommand.actorSend : exports.M6bServiceWireCommand.actorRequest, flags), ...(kind === 'actorRequest' ? [u64(requirePositive(correlation, 'correlation'))] : []), optionalActor(sourceActor), actorFence(target), ...(boundSession === undefined
-        ? []
-        : [
-            rid(boundSession.sessionRid, 'sourceSessionRid'),
-            u64(boundSession.bindingGeneration),
-            u64(boundSession.sequence)
-        ]));
+    const common = {
+        flags,
+        operation,
+        messageFollowHopCount,
+        sourceActor: sourceActor === undefined
+            ? { actorId: null }
+            : { actorId: sourceActor.actorId, generation: sourceActor.generation },
+        targetActor: generatedActorFence(target),
+        ...(boundSession === undefined
+            ? {}
+            : {
+                boundSessionTail: {
+                    sourceSessionRid: toGeneratedRoutingId(boundSession.sessionRid, 'sourceSessionRid'),
+                    sourceBindingGeneration: boundSession.bindingGeneration,
+                    sourceSessionSequence: boundSession.sequence
+                }
+            }),
+        payload: STATEFUL_HEADER_PAYLOAD
+    };
+    const frames = kind === 'actorSend'
+        ? (0, service_wire_codec_generated_1.encodeActorSendCommand)({ command: kind, ...common }, STATEFUL_MESSAGE_CONTEXT)
+        : (0, service_wire_codec_generated_1.encodeActorRequestCommand)({
+            command: kind,
+            ...common,
+            correlation: requirePositive(correlation, 'correlation')
+        }, STATEFUL_MESSAGE_CONTEXT);
+    return Buffer.from(frames[0]);
 }
 function encodeLogicalMulticastHeader(channelName, topic, sourceSpotId) {
     return concat(prefix(exports.M6bServiceWireCommand.logicalMulticast), text8(channelName, 'channelName'), text8(topic, 'topic'), rid(sourceSpotId, 'sourceSpotId'));
@@ -590,7 +656,7 @@ function encodeMessageFollowHeader(record) {
     }
     return concat(prefix(exports.M6bServiceWireCommand.messageFollow), Buffer.of(1), u32(body.byteLength, 'messageFollow.length'), body);
 }
-function decodeStatefulHeader(frame) {
+function decodeStatefulHeader(frame, payloadFrame, metadataFrame) {
     switch (frame[3]) {
         case exports.M6bServiceWireCommand.userSpotCreate:
             return fromGeneratedUserSpotCreate((0, service_wire_pilot_codec_generated_1.decodeUserSpotCreate47)(frame));
@@ -598,49 +664,87 @@ function decodeStatefulHeader(frame) {
             return fromGeneratedUserSpotClose((0, service_wire_pilot_codec_generated_1.decodeUserSpotClose48)(frame));
         case exports.M6bServiceWireCommand.actorCreate:
             return fromGeneratedActorCreate((0, service_wire_pilot_codec_generated_1.decodeActorCreate49)(frame));
-    }
-    const reader = new Reader(frame);
-    const command = reader.prefix();
-    switch (command.command) {
         case exports.M6bServiceWireCommand.spotSend:
-        case exports.M6bServiceWireCommand.spotRequest: {
-            requireFlags(command.flags, 0);
-            const request = command.command === exports.M6bServiceWireCommand.spotRequest;
-            const correlation = request ? reader.nonZeroU64('correlation') : undefined;
-            const sourceSpotId = reader.rid('sourceSpotId');
-            const target = reader.directSpotFence();
-            reader.end();
-            return {
-                kind: request ? 'spotRequest' : 'spotSend',
-                ...(correlation === undefined ? {} : { correlation }),
-                sourceSpotId,
-                target
-            };
-        }
+        case exports.M6bServiceWireCommand.spotRequest:
         case exports.M6bServiceWireCommand.actorSend:
         case exports.M6bServiceWireCommand.actorRequest: {
-            const request = command.command === exports.M6bServiceWireCommand.actorRequest;
-            const hasBinding = command.flags !== 0;
-            requireFlags(command.flags, hasBinding ? exports.M6bServiceWireFlag.boundSession | exports.M6bServiceWireFlag.sourceSpotId : 0);
-            const correlation = request ? reader.nonZeroU64('correlation') : undefined;
-            const sourceActor = reader.optionalActor();
-            const target = reader.actorFence();
-            const boundSession = hasBinding
-                ? {
-                    sessionRid: reader.rid('sourceSessionRid'),
-                    bindingGeneration: reader.nonZeroU64('sourceBindingGeneration'),
-                    sequence: reader.nonZeroU64('sourceSessionSequence')
+            const frames = [
+                frame,
+                ...(metadataFrame === undefined ? [] : [metadataFrame]),
+                payloadFrame ??
+                    (0, service_wire_codec_generated_1.encodeApplicationPayloadEnvelopeV1)(STATEFUL_HEADER_PAYLOAD, STATEFUL_MESSAGE_CONTEXT)
+            ];
+            try {
+                if (frame[3] === exports.M6bServiceWireCommand.spotSend ||
+                    frame[3] === exports.M6bServiceWireCommand.spotRequest) {
+                    const decoded = frame[3] === exports.M6bServiceWireCommand.spotSend
+                        ? (0, service_wire_codec_generated_1.decodeSpotSendCommand)(frames, STATEFUL_MESSAGE_CONTEXT)
+                        : (0, service_wire_codec_generated_1.decodeSpotRequestCommand)(frames, STATEFUL_MESSAGE_CONTEXT);
+                    return {
+                        kind: decoded.command,
+                        ...(decoded.command === 'spotRequest' ? { correlation: decoded.correlation } : {}),
+                        operation: decoded.operation,
+                        messageFollowHopCount: decoded.messageFollowHopCount,
+                        sourceSpotId: decoded.sourceSpotId,
+                        target: {
+                            spot: {
+                                spotId: decoded.targetSpot.spot.spotId,
+                                generation: decoded.targetSpot.spot.objectGeneration
+                            },
+                            targetNodeRid: fromGeneratedRoutingId(decoded.targetSpot.targetNodeRid, 'targetNodeRid'),
+                            targetNodeGeneration: decoded.targetSpot.targetNodeGeneration,
+                            authorityOwnerGeneration: decoded.targetSpot.expectedAuthorityOwnerGeneration,
+                            ownerLeaseGeneration: decoded.targetSpot.expectedOwnerLeaseGeneration
+                        }
+                    };
                 }
-                : undefined;
-            reader.end();
-            return {
-                kind: request ? 'actorRequest' : 'actorSend',
-                ...(correlation === undefined ? {} : { correlation }),
-                ...(sourceActor === undefined ? {} : { sourceActor }),
-                target,
-                ...(boundSession === undefined ? {} : { boundSession })
-            };
+                const decoded = frame[3] === exports.M6bServiceWireCommand.actorSend
+                    ? (0, service_wire_codec_generated_1.decodeActorSendCommand)(frames, STATEFUL_MESSAGE_CONTEXT)
+                    : (0, service_wire_codec_generated_1.decodeActorRequestCommand)(frames, STATEFUL_MESSAGE_CONTEXT);
+                const source = decoded.sourceActor;
+                return {
+                    kind: decoded.command,
+                    ...(decoded.command === 'actorRequest' ? { correlation: decoded.correlation } : {}),
+                    operation: decoded.operation,
+                    messageFollowHopCount: decoded.messageFollowHopCount,
+                    ...(source.actorId === null
+                        ? {}
+                        : {
+                            sourceActor: {
+                                nodeRid: '',
+                                actorId: source.actorId,
+                                generation: source.generation
+                            }
+                        }),
+                    target: {
+                        actor: {
+                            nodeRid: fromGeneratedRoutingId(decoded.targetActor.targetNodeRid, 'targetNodeRid'),
+                            actorId: decoded.targetActor.actor.actorId,
+                            generation: decoded.targetActor.actor.objectGeneration
+                        },
+                        targetNodeGeneration: decoded.targetActor.targetNodeGeneration,
+                        authorityOwnerGeneration: decoded.targetActor.expectedAuthorityOwnerGeneration,
+                        ownerLeaseGeneration: decoded.targetActor.expectedOwnerLeaseGeneration
+                    },
+                    ...(decoded.boundSessionTail === undefined
+                        ? {}
+                        : {
+                            boundSession: {
+                                sessionRid: fromGeneratedRoutingId(decoded.boundSessionTail.sourceSessionRid, 'sourceSessionRid'),
+                                bindingGeneration: decoded.boundSessionTail.sourceBindingGeneration,
+                                sequence: decoded.boundSessionTail.sourceSessionSequence
+                            }
+                        })
+                };
+            }
+            catch (error) {
+                throw new service_wire_m6a_codec_1.ServiceWireProtocolError(error instanceof Error ? error.message : 'Invalid stateful message.');
+            }
         }
+    }
+    const reader = new Reader(frame);
+    const command = reader.prefix();
+    switch (command.command) {
         case exports.M6bServiceWireCommand.logicalMulticast: {
             requireFlags(command.flags, 0);
             const result = {
@@ -1182,12 +1286,6 @@ function actorFence(value) {
 function actorAuthorityFence(value) {
     return concat(actorRef(value.actor), rid(value.actor.nodeRid, 'targetNodeRid'), u64(value.targetNodeGeneration), u64(value.authorityOwnerGeneration), u64(value.ownerLeaseGeneration));
 }
-function spotFence(value) {
-    return concat(spotRef(value.spot), rid(value.targetNodeRid, 'targetNodeRid'), u64(value.targetNodeGeneration), u64(value.authorityOwnerGeneration), u64(value.ownerLeaseGeneration));
-}
-function directSpotFence(value) {
-    return concat(spotFence(value), text16(value.storeVersion, 'storeVersion'));
-}
 function messageFollowRoute(value) {
     const body = value.kind === 'actor'
         ? concat(actorRef(value.actor), rid(value.targetNodeRid, 'targetNodeRid'), u64(value.targetNodeGeneration), u64(value.authorityOwnerGeneration), u64(value.ownerLeaseGeneration))
@@ -1232,11 +1330,6 @@ function validateMessageFollowRecord(value, invalid = (message) => {
 function actorRef(value) {
     return concat(text8(value.actorId, 'actorId'), u64(value.generation));
 }
-function optionalActor(value) {
-    return value === undefined
-        ? Buffer.of(0)
-        : concat(text8(value.actorId, 'sourceActorId'), u64(value.generation));
-}
 function spotRef(value) {
     return concat(rid(value.spotId, 'spotId'), u64(value.generation));
 }
@@ -1408,20 +1501,6 @@ class Reader {
             generation: this.nonZeroU64(`${name}.generation`)
         };
     }
-    optionalActor() {
-        const length = this.u8('sourceActorId.length');
-        if (length === 0)
-            return undefined;
-        this.need(length, 'sourceActorId');
-        const bytes = this.bytes.subarray(this.offset, this.offset + length);
-        this.offset += length;
-        const actorId = (0, service_wire_binary_primitives_1.decodeCanonicalServiceWireText)(bytes, 'sourceActorId', fail);
-        return {
-            nodeRid: '',
-            actorId,
-            generation: this.nonZeroU64('sourceActorGeneration')
-        };
-    }
     spotRef() {
         return {
             spotId: this.rid('spotId'),
@@ -1438,22 +1517,6 @@ class Reader {
             ownerLeaseGeneration: this.nonZeroU64('ownerLeaseGeneration')
         };
     }
-    spotFence() {
-        const spot = this.spotRef();
-        return {
-            spot,
-            targetNodeRid: this.rid('targetNodeRid'),
-            targetNodeGeneration: this.nonZeroU64('targetNodeGeneration'),
-            authorityOwnerGeneration: this.nonZeroU64('authorityOwnerGeneration'),
-            ownerLeaseGeneration: this.nonZeroU64('ownerLeaseGeneration')
-        };
-    }
-    directSpotFence() {
-        return {
-            ...this.spotFence(),
-            storeVersion: this.text16('storeVersion')
-        };
-    }
     messageFollowRoute(name) {
         const kind = this.u8(`${name}.objectKind`);
         const length = this.u16(`${name}.length`);

package/dist/runtime/foundation/service-topology-registry.d.ts

@@ -26,7 +26,6 @@ export interface ServiceNodeDescriptor {
 export interface AdmittedServicePeer {
     readonly descriptor: ServiceNodeDescriptor;
     readonly connectionId: string;
-    readonly connectionDiscriminator: string;
 }
 export interface ServicePeerAdmissionExpectation {
     readonly endpoint?: string;
@@ -45,7 +44,7 @@ export declare class ServiceTopologyRegistry {
     constructor(local: ServiceNodeDescriptor);
     localDescriptor(): ServiceNodeDescriptor;
     publishLocal(descriptor: ServiceNodeDescriptor): void;
-    admit(descriptor: ServiceNodeDescriptor, connectionId: string, expected?: ServicePeerAdmissionExpectation, connectionDiscriminator?: string): PeerAdmissionResult;
+    admit(descriptor: ServiceNodeDescriptor, connectionId: string, expected?: ServicePeerAdmissionExpectation): PeerAdmissionResult;
     disconnect(nodeRoutingId: string, connectionId: string): boolean;
     peer(nodeRoutingId: string): AdmittedServicePeer | undefined;
     peers(): readonly AdmittedServicePeer[];

package/dist/runtime/foundation/service-topology-registry.js

@@ -41,11 +41,10 @@ class ServiceTopologyRegistry {
         }
         this.rebuildSelections();
     }
-    admit(descriptor, connectionId, expected, connectionDiscriminator = connectionId) {
+    admit(descriptor, connectionId, expected) {
         try {
             validateDescriptor(descriptor);
             requireText(connectionId, 'connectionId');
-            requireText(connectionDiscriminator, 'connectionDiscriminator');
         }
         catch (error) {
             return 'invalidDescriptor';
@@ -83,25 +82,11 @@ class ServiceTopologyRegistry {
                     !sameServiceNodeDescriptor(current.descriptor, descriptor)))) {
             return 'staleDescriptor';
         }
-        if (current !== undefined &&
-            current.descriptor.lifecycleGeneration === descriptor.lifecycleGeneration &&
-            current.descriptor.descriptorRevision === descriptor.descriptorRevision &&
-            sameServiceNodeDescriptor(current.descriptor, descriptor) &&
-            current.connectionId !== connectionId &&
-            // A fallback candidate is only a logical placeholder. Once the
-            // monitor reports the physical connection, its evidence supersedes
-            // candidate ordering so the request path uses the native route.
-            !(isUnmonitoredConnectionId(current.connectionId) && !isUnmonitoredConnectionId(connectionId)) &&
-            compareConnectionCandidate(current.connectionDiscriminator, current.connectionId, connectionDiscriminator, connectionId) <= 0) {
-            // Both manual directions can reach admission. The same comparison on
-            // every retry keeps one physical candidate instead of replacing it in
-            // arrival order.
-            return 'staleDescriptor';
-        }
+        // Core selects the one route per RID (Core ROUTER §10.1); an admission on
+        // that route replaces the admission of a route it replaced.
         this.peersByRid.set(descriptor.nodeRoutingId, {
             descriptor: cloneDescriptor(descriptor),
-            connectionId,
-            connectionDiscriminator
+            connectionId
         });
         this.remember(descriptor);
         this.rebuildSelections();
@@ -188,8 +173,7 @@ class ServiceTopologyRegistry {
         return this.selectWeightedCycle(`channel:${channelName}`, () => {
             const local = {
                 descriptor: cloneDescriptor(this.local),
-                connectionId: 'local',
-                connectionDiscriminator: 'local'
+                connectionId: 'local'
             };
             return [local, ...this.peersByRid.values()]
                 .map((peer) => ({
@@ -361,8 +345,7 @@ function cloneDescriptor(descriptor) {
 function clonePeer(peer) {
     return {
         descriptor: cloneDescriptor(peer.descriptor),
-        connectionId: peer.connectionId,
-        connectionDiscriminator: peer.connectionDiscriminator
+        connectionId: peer.connectionId
     };
 }
 function sameServiceNodeDescriptor(left, right) {
@@ -382,13 +365,6 @@ function sameImmutableDescriptor(left, right) {
 function arraysEqual(left, right) {
     return left.length === right.length && left.every((value, index) => value === right[index]);
 }
-function isUnmonitoredConnectionId(connectionId) {
-    return connectionId.startsWith('unmonitored:');
-}
-function compareConnectionCandidate(leftDiscriminator, leftId, rightDiscriminator, rightId) {
-    const discriminator = compareOrdinal(leftDiscriminator, rightDiscriminator);
-    return discriminator === 0 ? compareOrdinal(leftId, rightId) : discriminator;
-}
 function compareOrdinal(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }

package/dist/runtime/host/actor-transfer-runtime.d.ts

@@ -1,9 +1,10 @@
-import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorJoinOperationId, ZLinkMessage, ZLinkMessageSerializer, ZLinkRelocationStore, ZLinkSpot } from '../../contracts';
+import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorJoinOperationId, ZLinkMessageSerializer, ZLinkSpot } from '../../contracts';
+import { ZLinkMessage } from '../../contracts';
 import type { ZLinkAuthoritySnapshot, ZLinkLocationOwnerToken } from '../locations/internal-location-contracts';
 import type { ZLinkAuthorityStore, ZLinkObjectCreationStore, ZLinkOwnerLeaseStore } from '../locations/internal-store-contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendActorRef, ZLinkBackendMeshNode } from '../backend';
-import { type ZLinkActorHandoffCoordinator, type ZLinkActorHandoffReplayPreparation, type ZLinkActorRoutedJoinTransport, type ZLinkActorTransferRegistry, type ZLinkDeferredJoinAcceptedRoot, type ZLinkDeferredJoinRootIdentity, type ZLinkRemoteBoundSessionTarget } from '../actors';
+import { type ZLinkActorHandoffCoordinator, type ZLinkActorHandoffReplayPreparation, type ZLinkActorRoutedJoinTransport, type ZLinkActorTransferRegistry, type ZLinkDeferredJoinCompletion, type ZLinkRemoteBoundSessionTarget } from '../actors';
 import type { ZLinkActorRuntimeState } from '../actors/actor-runtime-state';
 import type { ZLinkLocationLifecycle } from '../locations';
 import type { DefaultZLinkSpotManager } from '../spots';
@@ -50,7 +51,6 @@ export interface ZLinkActorTransferRuntimeOptions {
     readonly actorTransferRegistry: ZLinkActorTransferRegistry;
     readonly authorityStore: () => (ZLinkAuthorityStore & ZLinkObjectCreationStore & ZLinkOwnerLeaseStore) | undefined;
     readonly currentOwner: () => ZLinkLocationOwnerToken | undefined;
-    readonly relocationStore: () => ZLinkRelocationStore | undefined;
     /** Live admitted peers of a mesh; used to stop retries against a gone session owner. */
     readonly liveDescriptors?: (meshName: string, signal?: AbortSignal) => Promise<readonly import('../../contracts').ZLinkMeshNodeDescriptor[]>;
     /** Service-wire command 42/43/44 bridge, installed after the host runtime is assembled. */
@@ -70,17 +70,18 @@ export declare class ZLinkActorTransferRuntime {
     private readonly activeDeferredJoinTerminals;
     private readonly deferredJoinTerminals;
     constructor(options: ZLinkActorTransferRuntimeOptions);
-    beginDeferredActorHandoff(actor: ZLinkActor, state: ZLinkActorRuntimeState, operationId: string): void;
-    promoteDeferredActorHandoff(actor: ZLinkActor, _state: ZLinkActorRuntimeState, operationId: string): void;
-    completeDeferredActorHandoff(actor: ZLinkActor, target: ZLinkSpotRouteTarget, _targetActorRef: ActorRef, operationId: string): Promise<void>;
-    cancelDeferredActorHandoff(actor: ZLinkActor, _state: ZLinkActorRuntimeState, operationId: string): Promise<void>;
-    prepareDeferredJoinAccepted(actorId: string, operationId: ZLinkActorJoinOperationId, actorRef: ActorRef, rawReply: Uint8Array, replyContentType?: string, signal?: AbortSignal, canonicalInventoryDigest?: string): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    isDeferredJoinAcceptedRootPublication(reference: string, checksumCrc32c: number, expected: ZLinkDeferredJoinRootIdentity, signal?: AbortSignal): Promise<boolean>;
-    discardDeferredJoinAccepted(root: ZLinkDeferredJoinAcceptedRoot, signal?: AbortSignal): Promise<void>;
-    markDeferredJoinAcceptedCommitted(root: ZLinkDeferredJoinAcceptedRoot, actorRef: ActorRef, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    commitAndDeliverDeferredJoinAccepted(root: ZLinkDeferredJoinAcceptedRoot, actor: ZLinkActor, actorRef: ActorRef, submitMailbox: <T>(operation: () => Promise<T>) => Promise<T>, signal?: AbortSignal): Promise<ZLinkDeferredJoinAcceptedRoot>;
-    private commitAndDeliverDeferredJoinAcceptedCore;
-    private requireDeferredJoinJournal;
+    beginDeferredActorHandoff(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
+    promoteDeferredActorHandoff(actor: ZLinkActor, _state: ZLinkActorRuntimeState): void;
+    completeDeferredActorHandoff(actor: ZLinkActor, target: ZLinkSpotRouteTarget, _targetActorRef: ActorRef): Promise<void>;
+    cancelDeferredActorHandoff(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void>;
+    prepareDeferredJoinAccepted(actorId: string, operationId: ZLinkActorJoinOperationId, actorRef: ActorRef, rawReply: Uint8Array, replyContentType?: string): ZLinkDeferredJoinCompletion;
+    /**
+     * 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).
+     */
+    deliverDeferredJoinAccepted(completion: ZLinkDeferredJoinCompletion, actor: ZLinkActor, actorRef: ActorRef, submitMailbox: <T>(operation: () => Promise<T>) => Promise<T>, signal?: AbortSignal): Promise<void>;
+    private deliverDeferredJoinAcceptedCore;
     private prepareSourceActorLeave;
     private restoreSourceActor;
     private beginSourceActorMove;
@@ -89,7 +90,7 @@ export declare class ZLinkActorTransferRuntime {
     private admitDeferredSourcePrefix;
     private observeHandoffReplay;
     private sourceHandoffPrefixQueue;
-    prepareSource(actor: ZLinkActor, state: ZLinkActorRuntimeState, signal?: AbortSignal, lifecycleAuthority?: 'framework' | 'core', deferredOperationId?: string, relocation?: ServiceWireOperationId): Promise<{
+    prepareSource(actor: ZLinkActor, state: ZLinkActorRuntimeState, signal?: AbortSignal, lifecycleAuthority?: 'framework' | 'core', deferredJoin?: boolean, relocation?: ServiceWireOperationId): Promise<{
         handoffBacklog: readonly ZLinkActorHandoffPacket[];
         sourceLeaveCompletion: Promise<void> | undefined;
         sourceLeaveSubmitted: Promise<void> | undefined;
@@ -107,6 +108,7 @@ export declare class ZLinkActorTransferRuntime {
         setReplayResults(results: readonly import('../actors').ZLinkActorHandoffResult[]): void;
         commit(target: ZLinkSpotRouteTarget, targetActorRef: ActorRef, targetOwnerFence: ZLinkActorMessageFollowOwnerFence): Promise<void>;
         rollback(): Promise<void>;
+        discard(reason: unknown): void;
     }>;
     notifyCoreSourceLeave(actor: ZLinkActor, callback: () => Promise<void>): Promise<void>;
     completeRelocationSourceLeave(actor: ZLinkActor, sourceSpotId: RoutingId | undefined, signal?: AbortSignal): Promise<void>;