@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/host/location-runtime-owner.d.ts

@@ -19,8 +19,8 @@ export interface ZLinkLocationRuntimeStopSnapshot {
 }
 export declare class ZLinkLocationRuntimeOwner {
     private readonly options;
-    private stores?;
-    private runtime?;
+    stores?: ZLinkLocationRuntimeStores;
+    runtime?: ZLinkLocationRuntime;
     private lifecycle?;
     private events?;
     private leaseTrackerState?;

package/dist/runtime/host/location-runtime-owner.js

@@ -26,7 +26,7 @@ class ZLinkLocationRuntimeOwner {
         return this.events;
     }
     get currentLeaseTracker() {
-        return this.leaseTrackerState?.tracker;
+        return this.stores === undefined ? undefined : this.leaseTracker(this.stores);
     }
     setSpotRouteInvalidator(invalidator) {
         this.spotRouteInvalidator = invalidator;

package/dist/runtime/host/service-relocation-host-runtime.d.ts

@@ -1,25 +1,35 @@
-import { type RoutingId, type ZLinkMeshNodeDescriptor } from '../../contracts';
+import type { RequestRuntime } from '../foundation/request-runtime';
+import { inspectRuntime } from '../internal-observation';
+import { type RoutingId, type Type, type ZLinkActor, type ZLinkMeshNodeDescriptor, ZLinkSpotKind } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkActivationAdmission } from '../activation-admission';
 import type { DefaultZLinkActorManager } from '../actors';
-import { type ZLinkActorHandoffPacket } from '../actors/actor-handoff';
+import { type ZLinkActorHandoffPacket, type ZLinkActorHandoffResult } from '../actors/actor-handoff';
 import type { ZLinkActorJoinRelocation } from '../actors/actor-join-relocation';
+import { type ZLinkActorRuntimeState } from '../actors/actor-runtime-state';
 import type { ZLinkBackendMeshNode, ZLinkMeshCompletionTable } from '../backend';
 import type { ZLinkFrameworkRegistration } from '../configuration';
-import { type ZLinkRuntimeEventPublisher, type ZLinkRuntimeMetrics } from '../diagnostics';
+import { type ZLinkRuntimeEventPublisher, type ZLinkRelocationMetricOperation, type ZLinkRuntimeMetrics } from '../diagnostics';
 import { type ZLinkMessageFlowTracer } from '../diagnostics/message-flow';
-import { type ServiceRelocationQueuedMessage } from '../foundation/service-relocation-runtime';
+import { type ServicePreparedRelocationAggregate } from '../foundation/service-relocation-aggregate-committer';
+import { ServiceRelocationObjectRestoreOwner, type ServiceCapturedObjectRelocation, type ServiceObjectRelocationStaging, type ServiceRelocationHiddenObject, type ServiceRelocationTargetObjectPort } from '../foundation/service-relocation-object-owner';
+import { ServiceRelocationAuthorityPayloadCodec, type ServiceRelocationEnvelope, type ServiceRelocationMembership, type ServiceRelocationParticipant, type ServiceRelocationPublication, type ServiceRelocationQueuedMessage } from '../foundation/service-relocation-runtime';
 import { type ReceiveRecord } from '../foundation/service-runtime-contracts';
-import { type ServiceSessionRelocationRoute, type ServiceSessionRelocationSeal, type ServiceSessionRelocationSealed } from '../foundation/service-stateful-wire-codec';
+import { type ServiceMaintenanceRelocationCutover, type ServiceMaintenanceRelocationData, type ServiceMaintenanceRelocationPrepare, type ServiceMaintenanceRelocationReady, type ServiceMaintenanceReplyRelay, type ServiceSessionRelocationRoute, type ServiceSessionRelocationSeal, type ServiceSessionRelocationSealed, type ServiceWireRelocationCoordinatorFence, type ServiceWireRelocationTarget, type ServiceWireRequestSourceFence } from '../foundation/service-stateful-wire-codec';
 import type { ZLinkDomainLocationStore as ZLinkLocationStore } from '../locations/domain-store-contract';
-import type { ZLinkLocationOwnerToken } from '../locations/internal-location-contracts';
+import type { ZLinkAuthoritySnapshot, ZLinkLocationOwnerToken } from '../locations/internal-location-contracts';
 import type { ZLinkTrackedInstanceAuthority } from '../locations/spot-location-claims';
 import type { DefaultZLinkSpotManager } from '../spots';
+import type { ZLinkSpotActivation } from '../spots/spot-activation-state';
+import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 import { type ZLinkActorTransferRuntime } from './actor-transfer-runtime';
+import { ZLinkRelocationPayloadAssembly } from './relocation-direct-transfer';
+import { decodeServiceRelocationControlResponse, type ZLinkServiceRelocationControlRequest } from './service-relocation-control';
 export declare class ZLinkRelocationStateIncompatibleError extends Error {
     constructor(message: string);
 }
 interface ZLinkHostRelocationOptions {
+    readonly requests: RequestRuntime;
     readonly flowCreationEnabled?: () => boolean;
     readonly messageFlow?: () => ZLinkMessageFlowTracer | undefined;
     readonly registration: ZLinkFrameworkRegistration;
@@ -42,20 +52,107 @@ interface ZLinkHostRelocationOptions {
         clear?(): void | Promise<void>;
     };
     readonly trackInstanceSpot?: (input: ZLinkTrackedInstanceAuthority) => void;
-    readonly invalidateActorRoute?: (actorId: string) => void;
+    readonly observeActorAuthorityVersion?: (actorId: string, storeVersion: string) => void;
     readonly reconcileStatefulAuthorityRoutes?: (signal?: AbortSignal) => Promise<void>;
     readonly runtimeEventPublisher?: ZLinkRuntimeEventPublisher;
     readonly metrics?: ZLinkRuntimeMetrics;
     readonly activationAdmission?: ZLinkActivationAdmission;
 }
+interface LocalHidden extends ServiceRelocationHiddenObject {
+    readonly participant: ServiceRelocationParticipant;
+    readonly actor?: ZLinkActor;
+    readonly activation?: ZLinkSpotActivation;
+    initialized: boolean;
+    replayStart?: Promise<void>;
+    onReplayResult?: (packet: ZLinkActorHandoffPacket, result: ZLinkActorHandoffResult) => Promise<void>;
+    readonly replayPackets: ZLinkActorHandoffPacket[];
+    targetAuthorityOwnerGeneration?: bigint;
+}
+interface LocalStage {
+    readonly offer: TargetRelocationOffer;
+    readonly owner: ServiceRelocationObjectRestoreOwner<LocalHidden>;
+    readonly staging: ServiceObjectRelocationStaging<LocalHidden>;
+    phase: 'ready' | 'finalizing' | 'committed' | 'open' | 'failed';
+    lane: Promise<void>;
+    cutoverReceived: boolean;
+    /** Boundary relay records buffered until cutover (or fallback) applies them. */
+    readonly boundaryRelay: ServiceMaintenanceRelocationData[];
+    fallback?: ReturnType<typeof setTimeout>;
+    finalize?: Promise<void>;
+    /** The Restore's activation admission (MeshNode §5.1); held until target commit or abort. */
+    readonly releaseActivation: () => void;
+    readonly releaseJoinAdmission: () => void;
+}
+interface TargetPayloadAssembly {
+    readonly prepare: ServiceMaintenanceRelocationPrepare;
+    readonly fingerprint: string;
+    readonly authenticatedSourceNodeRid: string;
+    readonly assembly: ZLinkRelocationPayloadAssembly;
+}
+/** One authority read decides commit and the snapshots eligible for Follow. */
+type SourceAuthorityCommit = {
+    readonly kind: 'target';
+    readonly followAuthorities: ReadonlyMap<string, ZLinkAuthoritySnapshot>;
+};
+interface SourceCutoverWindow {
+    readonly meshName: string;
+    readonly targetNodeRid: RoutingId;
+    /** Boundary batch frames plus the cutover frame, retained until authority settlement. */
+    frames?: readonly Buffer[];
+    /** The ready route used to submit the retained batch. */
+    submittedRouteGeneration?: bigint;
+    readonly cutoverSubmittedAtMs: number;
+    followTimer?: ReturnType<typeof setTimeout>;
+    windowClosed: boolean;
+    followExpired: boolean;
+}
+interface TargetRelocationReservation {
+    readonly prepared: ServicePreparedRelocationAggregate;
+}
+interface TargetRelocationOffer {
+    readonly prepare: ServiceMaintenanceRelocationPrepare;
+    readonly prepareFingerprint: string;
+    readonly authenticatedSourceNodeRid: string;
+    readonly envelope: ServiceRelocationEnvelope;
+    readonly reservation: TargetRelocationReservation;
+}
+interface TargetPrepareOperation {
+    readonly fingerprint: string;
+    readonly promise: Promise<ServiceMaintenanceRelocationReady>;
+}
+interface SourceActorSession {
+    readonly state: ZLinkActorRuntimeState;
+    readonly actor: ZLinkActor;
+    readonly prepared: Awaited<ReturnType<ZLinkActorTransferRuntime['prepareMaintenanceSession']>>;
+}
+interface PendingSessionRelocation {
+    readonly targetNodeRid: string;
+    readonly request: ServiceSessionRelocationSeal;
+    readonly requestFingerprint: string;
+    readonly promise: Promise<ServiceSessionRelocationSealed>;
+    readonly resolve: (response: ServiceSessionRelocationSealed) => void;
+    readonly reject: (error: unknown) => void;
+    retryTimer?: ReturnType<typeof setTimeout>;
+    deadlineTimer?: ReturnType<typeof setTimeout>;
+}
 /** Production host bridge from Retire inventory to remote RouteMesh owners. */
 export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoinRelocation {
-    private readonly options;
-    private readonly targetStages;
+    readonly options: ZLinkHostRelocationOptions;
+    [inspectRuntime](): Readonly<{
+        targetStages: number;
+        targetAssemblies: number;
+        pendingReplyRelays: number;
+        sourceActorJoinProfiles: number;
+        sourceCutoverWindow: Readonly<{
+            readonly frameCount: number | undefined;
+        }> | undefined;
+        terminalTargets: number;
+    }>;
+    readonly targetStages: Map<string, LocalStage>;
     private readonly terminalTargets;
-    private readonly targetPrepareOperations;
+    readonly targetPrepareOperations: Map<string, TargetPrepareOperation>;
     private readonly pendingReplyRelays;
-    private readonly pendingSessionRelocations;
+    readonly pendingSessionRelocations: Map<string, PendingSessionRelocation>;
     private readonly terminalSessionRelocations;
     /**
      * A command 44 submit has no response path. Keep a bounded record of a
@@ -64,7 +161,7 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
      */
     private readonly failedSessionRouteSubmits;
     private readonly sourceRelocationIds;
-    private readonly targetAssemblies;
+    readonly targetAssemblies: Map<string, TargetPayloadAssembly>;
     /**
      * Terminal restore failures (assembly/checksum/factory/restore error): the
      * target already sent relocationFailed (command 53) once. An exact-identity
@@ -83,7 +180,7 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
     private nodePayloadBudget?;
     private readonly sourceActorJoinProfiles;
     private readonly terminalActorJoinSourceLeaves;
-    private readonly codec;
+    readonly codec: ServiceRelocationAuthorityPayloadCodec;
     /**
      * Set once dispose() starts tearing assemblies down. A payload() rejection
      * observed after this point is the shutdown itself, not a chunk-assembly or
@@ -109,7 +206,7 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
     tryHandleControl(meshName: string, record: ReceiveRecord, signal?: AbortSignal): boolean | Promise<boolean>;
     private handleControl;
     /** Sends the Ready reply once the async restore finished; failures replay on resend. */
-    private deliverTargetReady;
+    deliverTargetReady(meshName: string, operationKey: string, request: ServiceMaintenanceRelocationPrepare, ingress: ReceiveRecord, operation: Promise<ServiceMaintenanceRelocationReady>): Promise<void>;
     /** Cleans up a Ready reply that never delivered within the Restore validity window. */
     private expireTargetReadyResponse;
     /**
@@ -132,16 +229,24 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
     private handleSessionRelocationRoute;
     private validateSessionOwnerFence;
     private sendSessionRelocationResponse;
-    private relocateSpotAggregate;
+    relocateSpotAggregate(meshName: string, activation: ZLinkSpotActivation, kind: 'user_spot' | 'instance_spot', actorStates: readonly ZLinkActorRuntimeState[], target: ZLinkMeshNodeDescriptor | undefined, targetApplicationVersion: bigint | undefined, signal?: AbortSignal): Promise<void>;
     private relocateSpotAggregateCore;
-    private relocateStandaloneActor;
-    private relocatePerActorSpotShell;
+    relocateStandaloneActor(meshName: string, state: ZLinkActorRuntimeState, target: ZLinkMeshNodeDescriptor | undefined, targetApplicationVersion: bigint | undefined, signal?: AbortSignal, targetMembership?: ZLinkSpotRouteTarget & {
+        readonly spotKind: ZLinkSpotKind.Entry | ZLinkSpotKind.User;
+        readonly spotObjectGeneration: bigint;
+    }, aggregateIdOverride?: string, retainSourceForActorJoin?: boolean, 
+    /** Target's advertised relocation state chunk cap (Actor Join only; spec 15 §4.2). */
+    advertisedReceiveChunkLimitBytes?: number, deadlineAtMs?: number): Promise<void>;
+    relocatePerActorSpotShell(meshName: string, activation: ZLinkSpotActivation, target: ZLinkMeshNodeDescriptor | undefined, targetApplicationVersion: bigint | undefined, signal?: AbortSignal): Promise<void>;
     private relocatePerActorSpotShellCore;
     private actorCaptureUnit;
     private reserveRelocationId;
     private reserveExactRelocationId;
-    private runCoordinator;
+    runCoordinator(meshName: string, target: ZLinkMeshNodeDescriptor, primary: ZLinkAuthoritySnapshot, captured: ServiceCapturedObjectRelocation, _authorities: ReadonlyMap<string, ZLinkAuthoritySnapshot>, signal?: AbortSignal, sessions?: readonly SourceActorSession[], 
+    /** Target's advertised relocation state chunk cap (Actor Join only; spec 15 §4.2). */
+    advertisedReceiveChunkLimitBytes?: number, controlDeadlineAtMs?: number, relocationMetric?: ZLinkRelocationMetricOperation): Promise<void>;
     private completeSourceRelocationMetric;
+    startSourceRelocationMetric(meshName: string, objectKind: 'actor' | 'user_spot' | 'instance_spot', policy: 'recreate' | 'snapshot', actorId?: string): ZLinkRelocationMetricOperation | undefined;
     /** Streams the payload chunks of one stage under the effective in-flight budgets. */
     private sendRelocationStateChunks;
     /**
@@ -150,7 +255,7 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
      */
     private acquireRelocationBudget;
     /** Pre-seal admission wait — a full budget delays the next unit before seal. */
-    private waitForRelocationBudgetHeadroom;
+    waitForRelocationBudgetHeadroom(targetRid: string, signal?: AbortSignal): Promise<void>;
     private requireNodePayloadBudget;
     private requirePeerPayloadBudget;
     /**
@@ -165,9 +270,9 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
     private closeSourceCutoverWindow;
     private releaseSourceCutoverWindow;
     /** Relocation flow §4.4: replay the whole batch on a different ready route. */
-    private resendSourceCutover;
+    resendSourceCutover(window: SourceCutoverWindow): Promise<void>;
     /**
-     * The one source authority settlement after Ready (Location runtime
+     * The one source authority settlement after request creation (Location runtime
      * §6.1·§10, spec 28 §4.4). It reads the Store until the target commit or
      * the Restore deadline. From the Restore deadline it runs the source
      * Preserve fence: a CAS on the StoreVersion expected by target NewOwner
@@ -178,7 +283,7 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
      * A committed later owner has no Follow snapshot (Location runtime §10). An uncertain
      * Store or lease result keeps the work retained and repeats the same decision.
      */
-    private settleSourceAuthority;
+    settleSourceAuthority(envelope: ServiceRelocationEnvelope, primary: ZLinkAuthoritySnapshot, target: ServiceWireRelocationTarget, restoreDeadlineReached: () => boolean, window: SourceCutoverWindow | undefined, relocationMetric?: ZLinkRelocationMetricOperation): Promise<SourceAuthorityCommit | 'source' | 'lost'>;
     private readSourceSettlement;
     /**
      * True when every relocation this source started reached its Message
@@ -186,9 +291,9 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
      * ended — both source-local events (spec 30 §11).
      */
     isSafeToShutdown(): boolean;
-    private releaseParticipantAuthorities;
+    releaseParticipantAuthorities(envelope: ServiceRelocationEnvelope, primaryKey: string, signal?: AbortSignal): Promise<void>;
     /** Restores the hidden object and its saved-work prefix before Ready. */
-    private handlePrepareControl;
+    handlePrepareControl(meshName: string, stagingId: string, request: ServiceMaintenanceRelocationPrepare, sourceNodeRid: RoutingId, signal?: AbortSignal): Promise<ServiceMaintenanceRelocationReady>;
     /**
      * The cutover wait of a Ready stage (spec 28 §4.4) is a Warning only: it
      * records `cutover_timeout` and never submits the target CAS or opens
@@ -206,34 +311,49 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
      * whole (the retransmission always resends the entire batch, so the exact
      * span is the staged suffix of `boundaryRecordCount` records).
      */
-    private reconcileBoundaryRelay;
-    private beginTargetFinalize;
-    private finalizeTargetStage;
+    reconcileBoundaryRelay(stage: LocalStage, request: ServiceMaintenanceRelocationCutover, stagingId: string): void;
+    beginTargetFinalize(meshName: string, stagingId: string, stage: LocalStage, signal?: AbortSignal): Promise<void>;
+    finalizeTargetStage(meshName: string, stagingId: string, stage: LocalStage, signal?: AbortSignal): Promise<void>;
     private validateRelocationData;
     private applyRelocationData;
-    private finalizeActorJoinProfiles;
-    private submitActorJoinSourceLeave;
-    private acceptActorJoinSourceLeave;
+    finalizeActorJoinProfiles(meshName: string, stage: LocalStage, signal?: AbortSignal): Promise<void>;
+    submitActorJoinSourceLeave(meshName: string, sourceNodeRid: RoutingId, relocationId: string, actorId: string): Promise<void>;
+    acceptActorJoinSourceLeave(input: {
+        readonly transferId: string;
+        readonly actorId: string;
+        readonly succeeded: boolean;
+    }): boolean;
     private sendControlOneWay;
-    private submitControlFrame;
-    private clearTargetRelocationPublication;
+    submitControlFrame(meshName: string, targetNodeRid: RoutingId, frame: Buffer, kind: string): Promise<void>;
+    clearTargetRelocationPublication(stage: LocalStage, primary: ZLinkAuthoritySnapshot, signal?: AbortSignal): Promise<ZLinkAuthoritySnapshot>;
     private handleReplyRelay;
-    private sendReplyRelay;
+    sendReplyRelay(meshName: string, ackTargetNodeRid: RoutingId, request: ServiceMaintenanceReplyRelay, expectedRequestSource: ServiceWireRequestSourceFence, signal?: AbortSignal): Promise<RelocationTerminalDelivery>;
     private acceptReplyRelayAck;
     private requireAdmittedPeer;
-    private targetReplyRelayCoordinator;
-    private relayTerminalReply;
+    targetReplyRelayCoordinator(meshName: string, stage: LocalStage, authority: ZLinkAuthoritySnapshot): ServiceWireRelocationCoordinatorFence;
+    relayTerminalReply(meshName: string, stage: LocalStage, coordinator: ServiceWireRelocationCoordinatorFence, participantId: bigint, packet: ZLinkActorHandoffPacket, result: ZLinkActorHandoffResult, signal?: AbortSignal): Promise<void>;
     private exactSourceLeaseExpired;
-    private publishSessionRoutes;
-    private sendControl;
+    publishSessionRoutes(staging: ServiceObjectRelocationStaging<LocalHidden>): Promise<void>;
+    sendControl(meshName: string, targetNodeRid: RoutingId, request: ZLinkServiceRelocationControlRequest, signal?: AbortSignal, deadlineAtMs?: number, onSubmitted?: (signal: AbortSignal) => Promise<void>): Promise<ReturnType<typeof decodeServiceRelocationControlResponse>>;
     private selectTarget;
     private readTargetParticipantAuthorities;
-    private reserveTargetForPrepare;
-    private authorityPayloadForPublication;
+    reserveTargetForPrepare(meshName: string, prepare: ServiceMaintenanceRelocationPrepare, envelope: ServiceRelocationEnvelope, signal?: AbortSignal): Promise<TargetRelocationReservation>;
+    authorityPayloadForPublication(payload: Uint8Array, publication: ServiceRelocationPublication, target?: {
+        readonly owner: ZLinkLocationOwnerToken;
+        readonly meshName: string;
+        readonly nodeRid: string;
+        readonly nodeGeneration: bigint;
+        readonly objectGeneration: bigint;
+        readonly targetAttemptGeneration: bigint;
+        readonly coordinatorExpectedStoreVersion: string;
+        readonly actorSpotId?: string;
+        readonly actorSpotGeneration?: bigint;
+        readonly actorSpotKind?: ZLinkSpotKind.Entry | ZLinkSpotKind.User;
+    }): Uint8Array;
     private abortTargetReservation;
     private abortTargetStage;
     private discardTargetStage;
-    private commitTargetReservation;
+    commitTargetReservation(stage: LocalStage, reservation: TargetRelocationReservation, signal?: AbortSignal): Promise<ZLinkAuthoritySnapshot | undefined>;
     /**
      * The one target authority settlement (Location runtime §10, spec 28
      * §4.4-§4.5). Only a verified cutover lets the target submit its NewOwner
@@ -246,27 +366,57 @@ export declare class ZLinkHostServiceRelocationRuntime implements ZLinkActorJoin
      * caller then discards the staging.
      */
     private commitTargetAggregate;
-    private readAggregateForCommitRetry;
-    private materializeTargetEnvelope;
+    readAggregateForCommitRetry(prepared: ServicePreparedRelocationAggregate, signal?: AbortSignal): Promise<{
+        readonly kind: 'committed';
+        readonly authorities: ReadonlyMap<string, ZLinkAuthoritySnapshot>;
+    } | {
+        readonly kind: 'source' | 'unknown' | 'stale';
+    }>;
+    materializeTargetEnvelope(meshName: string, envelope: ServiceRelocationEnvelope, signal?: AbortSignal): Promise<Pick<LocalStage, 'owner' | 'staging'> & {
+        readonly target: LocalTargetPort;
+    }>;
     /** Maps schema ordinals to the authoritative Location Store inventory. */
-    private resolveTargetParticipantInventory;
+    resolveTargetParticipantInventory(meshName: string, request: ServiceMaintenanceRelocationPrepare, envelope: ServiceRelocationEnvelope, signal?: AbortSignal): Promise<ServiceRelocationEnvelope>;
     private spotKind;
     private spotRegistration;
     private actorRegistration;
-    private captureApplication;
+    captureApplication<T>(policy: {
+        readonly kind: 'disabled' | 'recreate' | 'snapshot';
+        readonly adapterType?: Type;
+    }, value: T, signal?: AbortSignal): Promise<Uint8Array>;
     private createRelocationAdapter;
     private recordRelocationInterruption;
     private sealSpotMessageFollow;
     private commitSpotMessageFollow;
     private requireLocationStore;
     private requireSpotManager;
-    private afterSpotCloseDecision;
+    afterSpotCloseDecision<T>(meshName: string, spotId: RoutingId, seal: () => T): T | Promise<T>;
     private requireActorManager;
     private relocationLimits;
     private requireMeshNode;
     private sendInfrastructureControl;
     private requestInfrastructureControl;
 }
+declare class LocalTargetPort implements ServiceRelocationTargetObjectPort<LocalHidden> {
+    private readonly options;
+    private readonly meshName;
+    private readonly envelope;
+    constructor(options: ZLinkHostRelocationOptions, meshName: string, envelope: ServiceRelocationEnvelope);
+    createHidden(participant: ServiceRelocationParticipant, signal?: AbortSignal): Promise<LocalHidden>;
+    restoreApplicationState(hidden: LocalHidden, payload: Uint8Array, signal?: AbortSignal): Promise<void>;
+    restoreMemberships(hidden: ReadonlyMap<string, LocalHidden>, memberships: readonly ServiceRelocationMembership[]): Promise<void>;
+    publish(hidden: LocalHidden, authority: ZLinkAuthoritySnapshot): Promise<void>;
+    restoreBoundSession(hidden: LocalHidden, payload: Uint8Array): Promise<void>;
+    replayQueuedMessage(hidden: LocalHidden, message: ServiceRelocationQueuedMessage): Promise<void>;
+    openAdmission(hidden: LocalHidden): Promise<void>;
+    normalize(hidden: LocalHidden): Promise<void>;
+    abort(hidden: LocalHidden): Promise<void>;
+    private registration;
+    private requireLocationStore;
+    private requireSpotManager;
+    private requireActorManager;
+}
+type RelocationTerminalDelivery = 'terminalReceived' | 'alreadyTerminal' | 'sourceLeaseExpired';
 export declare function decodeQueuedHandoffPacket(message: ServiceRelocationQueuedMessage): ZLinkActorHandoffPacket;
 export declare function createServiceRelocationId(isInUse: (candidate: string) => boolean, entropy?: (size: number) => Uint8Array): string;
 /**