@zlink-systems/framework 0.10.0

package/dist/runtime/foundation/service-stateful-runtime.d.ts

@@ -0,0 +1,393 @@
+import type { RawServiceMeshRuntime } from './raw-service-mesh-runtime';
+import { type ReceiveKindData, type StreamSessionActorAuthorityFence } from './service-runtime-contracts';
+import type { ServiceMailboxRecord } from './service-mailbox';
+import { ServiceStatefulRegistry, type ServiceActorRef, type ServiceActorState, type ServiceSessionBinding, type ServiceSpotRef, type ServiceSpotState } from './service-stateful-registry';
+import { type ServiceActorRouteFence, type ServiceRetiredBoundSessionRouteFence, type ServiceActorCreateRecord, type ServiceInstanceActivationTarget, type ServiceInstanceRouteFence, type ServiceDirectSpotRouteFence, type ServiceStatefulReplyTail, type ServiceUserSpotCloseRecord, type ServiceUserSpotCreateRecord } from './service-stateful-wire-codec';
+import { type ServiceApplicationPayload } from './service-wire-m6a-codec';
+import type { ServiceInstanceActivationRecoveryEnvelope } from './service-instance-activation-recovery-codec';
+import type { ServiceSessionBindingIngressPort } from './service-session-binding-ingress-port';
+export interface ServiceSpotMessageFollowSeal {
+    readonly key: string;
+    readonly serial: bigint;
+}
+export interface ServiceBoundSessionSendFence {
+    readonly targetNodeGeneration: bigint;
+    readonly authorityOwnerGeneration: bigint;
+    readonly ownerLeaseGeneration: bigint;
+}
+export interface ServiceStatefulResult {
+    readonly terminalResult: number;
+    readonly failureCode: number;
+    readonly payload?: ServiceApplicationPayload;
+    readonly kindData?: ReceiveKindData;
+    readonly applicationMetadata?: Buffer;
+    /** Carries the authority-owned generation returned by a remote stream bind. */
+    readonly streamBinding?: {
+        readonly bindingGeneration: bigint;
+        readonly authorityOwnerGeneration: bigint;
+    };
+}
+export interface ServiceStatefulPendingOperation {
+    readonly id: bigint;
+    readonly promise: Promise<ServiceStatefulResult>;
+}
+export interface ServiceStatefulMailboxData {
+    readonly correlation?: bigint;
+    readonly receiveKind: number;
+    readonly operationKind: number;
+    readonly sourceSpotId?: string;
+    readonly sourceActor?: ServiceActorRef;
+    readonly sourceBindingGeneration?: bigint;
+    readonly channelName?: string;
+    readonly topic?: string;
+    readonly targetSpot?: ServiceSpotRef;
+    readonly targetActor?: ServiceActorRef;
+    readonly kindData?: ReceiveKindData;
+    readonly applicationMetadata?: Buffer;
+    readonly messageFollowOrigin?: import('./service-runtime-contracts').ZLinkMessageFollowOrigin;
+    /** Prevents a local lifecycle callback from publishing after its operation ended. */
+    readonly isPending?: () => boolean;
+    /** Carries the local operation deadline into the lifecycle dispatch lane. */
+    readonly deadlineUnixMs?: bigint;
+    readonly onTerminalCompletion?: () => void | Promise<void>;
+    /** Decoded only by the canonical command-28 generator path. */
+    readonly canonicalApplicationPayload?: ServiceApplicationPayload;
+    readonly reply?: (terminalResult: number, failureCode: number, payload?: ServiceApplicationPayload, tail?: ServiceStatefulReplyTail) => boolean;
+}
+export interface ServiceCanonicalActorJoinCandidate {
+    readonly request: ServiceApplicationPayload;
+    readonly actorFence: {
+        readonly targetNodeGeneration: bigint;
+        readonly authorityOwnerGeneration: bigint;
+        readonly ownerLeaseGeneration: bigint;
+    };
+    /** Local-only relocation bookkeeping; it is never encoded in command 28. */
+    readonly local: {
+        readonly phase: 'admission';
+        readonly transferId: string;
+    };
+}
+export interface ServiceSessionDelivery {
+    readonly binding: ServiceSessionBinding;
+    readonly bindingIngress?: ServiceSessionBindingIngressPort;
+    /**
+     * Delivers the retained M6A application frame after the binding fence has
+     * been validated. The stream adapter owns multipart decoding at that point.
+     */
+    readonly deliver: (sessionRid: string, payloadFrame: Uint8Array) => Promise<boolean>;
+    /** Enqueues the replacement lifecycle callback on the owning STREAM session. */
+    readonly onBindingReplaced?: (actorId: string, retiredSession: ServiceRetiredBoundSessionRouteFence, actor: ServiceActorRef) => void;
+}
+export interface ServiceInstanceActivationReservation {
+    readonly attempt: bigint;
+    readonly authorityOwnerGeneration: bigint;
+    readonly token: string;
+}
+export type ServiceInstanceApplicationIdentity = Pick<ServiceInstanceActivationTarget, 'targetSpotId' | 'stableType'>;
+export type ServiceInstanceApplicationTarget = ServiceInstanceApplicationIdentity & {
+    readonly objectGeneration: bigint;
+};
+export interface ServiceInstanceApplicationLifecycle {
+    isMaterialized(target: ServiceInstanceApplicationIdentity): boolean;
+    isMaterializing?(target: ServiceInstanceApplicationIdentity): boolean;
+    isClosing?(target: ServiceInstanceApplicationIdentity): boolean;
+    isIdleEvicting?(target: ServiceInstanceApplicationIdentity): boolean;
+    beginIdleEviction?(target: ServiceInstanceApplicationIdentity): boolean;
+    materialize(target: ServiceInstanceApplicationIdentity, objectGeneration: bigint): Promise<void>;
+    discard(target: ServiceInstanceActivationTarget): Promise<void>;
+    beginTerminal(target: ServiceInstanceApplicationTarget): void;
+    completeTerminal(target: ServiceInstanceApplicationTarget): Promise<boolean>;
+}
+export interface ServicePendingInstanceActivation {
+    readonly reservationId: string;
+    readonly storeVersion: string;
+    readonly objectGeneration: bigint;
+    readonly authorityOwnerGeneration: bigint;
+    readonly ownerId: string;
+    readonly ownerLeaseGeneration: bigint;
+    readonly meshName: string;
+    readonly nodeRid: string;
+    readonly nodeGeneration: bigint;
+    readonly requestReference: string;
+    readonly requestSha256: Uint8Array;
+    readonly requestEncodedSize: bigint;
+}
+export type ServiceInstanceAuthorityRead = {
+    readonly kind: 'missing';
+} | {
+    readonly kind: 'creating';
+    readonly objectGeneration: bigint;
+    readonly authorityOwnerGeneration: bigint;
+} | {
+    readonly kind: 'ready';
+    readonly route: ServiceInstanceRouteFence;
+};
+export type ServiceInstanceAuthorityReserve = {
+    readonly kind: 'reserved';
+    readonly reservation: ServiceInstanceActivationReservation;
+} | {
+    readonly kind: 'ready';
+    readonly route: ServiceInstanceRouteFence;
+};
+/**
+ * Synchronous authority port used by the raw ingress turn. An asynchronous
+ * provider must complete outside this turn and re-enter with its result.
+ */
+export interface ServiceInstanceActivationAuthority {
+    read(target: ServiceInstanceActivationTarget): ServiceInstanceAuthorityRead;
+    reserve(target: ServiceInstanceActivationTarget, operation: {
+        readonly high: bigint;
+        readonly low: bigint;
+    }, deadlineUnixMs: bigint): ServiceInstanceAuthorityReserve;
+    commit(target: ServiceInstanceActivationTarget, reservation: ServiceInstanceActivationReservation, spot: ServiceSpotState): {
+        readonly kind: 'committed' | 'lost';
+        readonly route: ServiceInstanceRouteFence;
+    };
+    abort(target: ServiceInstanceActivationTarget, reservation: ServiceInstanceActivationReservation): void;
+}
+/**
+ * Promise-based authority port used by real Location Store providers. Raw
+ * ingress retains the envelope and resumes activation after each Store
+ * operation completes; the binding callback itself never blocks.
+ */
+export interface ServiceAsyncInstanceActivationAuthority {
+    read(target: ServiceInstanceActivationTarget): Promise<ServiceInstanceAuthorityRead>;
+    reserve(activation: Omit<ServiceInstanceActivationRecoveryEnvelope, 'targetMeshName'>): Promise<ServiceInstanceAuthorityReserve>;
+    resume(target: ServiceInstanceActivationTarget, pending: ServicePendingInstanceActivation): Promise<ServiceInstanceActivationReservation>;
+    commit(target: ServiceInstanceActivationTarget, reservation: ServiceInstanceActivationReservation, spot: ServiceSpotState): Promise<{
+        readonly kind: 'committed' | 'lost';
+        readonly route: ServiceInstanceRouteFence;
+    }>;
+    complete(target: ServiceInstanceActivationTarget, route: ServiceInstanceRouteFence): Promise<ServiceInstanceRouteFence>;
+    abort(target: ServiceInstanceActivationTarget, reservation: ServiceInstanceActivationReservation): Promise<void>;
+}
+export declare class ServiceInstanceActivationRedirectError extends Error {
+    readonly route: ServiceInstanceRouteFence;
+    constructor(route: ServiceInstanceRouteFence);
+}
+export interface ServiceUserSpotOperationResult {
+    readonly terminalResult: number;
+    readonly failureCode: number;
+    readonly tail?: Extract<ServiceStatefulReplyTail, {
+        readonly kind: 'userSpotCreate' | 'userSpotClose' | 'actorCreate';
+    }>;
+    readonly payload?: ServiceApplicationPayload;
+}
+export interface ServiceUserSpotOperationHandler {
+    create(record: ServiceUserSpotCreateRecord, signal: AbortSignal): Promise<ServiceUserSpotOperationResult>;
+    close(record: ServiceUserSpotCloseRecord, signal: AbortSignal): Promise<ServiceUserSpotOperationResult>;
+    createActor?(record: ServiceActorCreateRecord, signal: AbortSignal): Promise<ServiceUserSpotOperationResult>;
+}
+/**
+ * Owns M6B routing, identity fences and terminal operations. Application turns
+ * remain in the common mailbox, where a claimed Spot or Actor owner is serial.
+ */
+export declare class ServiceStatefulRuntime {
+    private readonly raw;
+    readonly nodeRid: string;
+    readonly nodeGeneration: bigint;
+    private static readonly detachedIngressScope;
+    readonly registry: ServiceStatefulRegistry;
+    private readonly operations;
+    private readonly sessionDeliveries;
+    /**
+     * A local Actor owner can replace its own session binding before the
+     * replacement notice is looped back through ingress. Retain that exact old
+     * delivery until the old session performs its normal close cleanup.
+     */
+    private readonly retiredSessionDeliveries;
+    private readonly appliedReplacementNotices;
+    private readonly subscriptions;
+    private readonly instanceIntents;
+    private readonly admittedInstanceOperations;
+    private readonly pendingInstanceTerminals;
+    private readonly pendingInstanceAuthorityTerminals;
+    private readonly instanceApplicationWaiters;
+    private readonly canonicalActorJoinHandoffs;
+    private readonly actorRoutes;
+    private readonly spotRoutes;
+    private readonly directSpotRoutes;
+    private readonly spotMessageFollow;
+    private readonly spotMessageFollowSuppression;
+    private nextMessageFollowSerial;
+    private nextMessageFollowOperation;
+    private nextSpotId;
+    private nextSessionSequence;
+    private nextInstanceOperation;
+    private nextUserSpotOperation;
+    private instanceAuthority?;
+    private asyncInstanceAuthority?;
+    private instanceApplicationLifecycle?;
+    private userSpotOperationHandler?;
+    private messageFollowHandler?;
+    private mailboxDropHandler?;
+    private readonly admittedUserSpotOperations;
+    private readonly pendingInstanceActivations;
+    private closed;
+    constructor(raw: RawServiceMeshRuntime, nodeRid: string, nodeGeneration: bigint);
+    setMailboxDropHandler(handler: (record: {
+        readonly kind: 'spot_multicast' | 'actor_control' | 'actor_binding';
+        readonly owner: string;
+    }) => void): void;
+    createSpot(routingId?: string, kind?: 'user' | 'instance', stableType?: "user" | "instance"): ServiceSpotState;
+    restoreUserSpotAuthority(spotId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpotState;
+    restoreSpotAuthority(spotId: string, objectKind: 'user_spot' | 'instance_spot', stableType: string, generation: bigint, authorityOwnerGeneration: bigint): ServiceSpotState;
+    entrySpot(): ServiceSpotState;
+    createActor(actorId: string, stableType?: string): ServiceActorState;
+    restoreActorAuthority(actorId: string, stableType: string, generation: bigint, authorityOwnerGeneration: bigint, spotId: string, spotGeneration: bigint, membershipEpoch: bigint): ServiceActorState;
+    discardRelocatedActor(actor: ServiceActorRef): void;
+    restoreActorSessionBinding(actorRef: ServiceActorRef, sessionNodeRid: string, sessionRid: string, bindingGeneration: bigint): void;
+    activateInstanceSpot(spotId: string, instanceType: string, attempt: bigint, authorityOwnerGeneration?: bigint): {
+        readonly spot: ServiceSpotState;
+        readonly created: boolean;
+    };
+    registerInstanceIntent(instanceType: string, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): void;
+    instanceSpotApplicationTarget(spotId: string): {
+        readonly stableType: string;
+        readonly objectGeneration: bigint;
+    } | undefined;
+    forgetInstanceIntent(spotId: string, objectGeneration: bigint, authorityOwnerGeneration: bigint, storeVersion?: string): void;
+    registerInstanceActivationAuthority(authority: ServiceInstanceActivationAuthority): void;
+    registerAsyncInstanceActivationAuthority(authority: ServiceAsyncInstanceActivationAuthority): void;
+    registerInstanceApplicationLifecycle(lifecycle: ServiceInstanceApplicationLifecycle): void;
+    registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
+    requestUserSpotCreate(targetNodeRid: string, request: Omit<ServiceUserSpotCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    requestUserSpotClose(targetNodeRid: string, request: Omit<ServiceUserSpotCloseRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    requestActorCreate(targetNodeRid: string, request: Omit<ServiceActorCreateRecord, 'kind' | 'correlation' | 'operation'>, timeoutMs: number): Promise<ServiceUserSpotOperationResult>;
+    recoverInstanceActivation(envelope: ServiceInstanceActivationRecoveryEnvelope, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<boolean>;
+    private finishRecoveredInstanceActivation;
+    recoverPendingInstanceActivation(envelope: ServiceInstanceActivationRecoveryEnvelope, pending: ServicePendingInstanceActivation, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<boolean>;
+    completeRecoveredInstanceActivation(target: ServiceInstanceActivationTarget, route: ServiceInstanceRouteFence, expectedCurrentRoute?: ServiceInstanceRouteFence | null): Promise<ServiceInstanceRouteFence | undefined>;
+    waitForInstanceApplicationQuiescence(spotId: string, signal?: AbortSignal): Promise<void>;
+    rememberActorRoute(route: ServiceActorRouteFence): void;
+    rememberSpotRoute(route: ServiceDirectSpotRouteFence, expectedCurrentRoute?: ServiceDirectSpotRouteFence | null): void;
+    sendMessageFollowNotification(targetNodeRid: string, record: Omit<import('./service-stateful-wire-codec').ServiceMessageFollowRecord, 'kind'>): Promise<boolean>;
+    setMessageFollowHandler(handler: (record: import('./service-stateful-wire-codec').ServiceMessageFollowRecord) => void): void;
+    sealSpotMessageFollowIngress(source: ServiceDirectSpotRouteFence): ServiceSpotMessageFollowSeal | undefined;
+    abortSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal): boolean;
+    commitSpotMessageFollowIngress(seal: ServiceSpotMessageFollowSeal, target: ServiceDirectSpotRouteFence, durationMs: number): Promise<boolean>;
+    forgetSpotRoute(spot: ServiceSpotRef, authorityOwnerGeneration: bigint, storeVersion?: string): void;
+    actor(actorId: string): ServiceActorState | undefined;
+    setSubscription(spot: ServiceSpotState, channelName: string, topicFilter: string): void;
+    unsetSubscription(spot: ServiceSpotState, channelName: string, topicFilter: string): void;
+    clearSubscriptions(spotId: string): void;
+    publishLogicalMulticast(channelName: string, topic: string, payload: ServiceApplicationPayload, sourceSpotId?: string): Promise<void>;
+    sendToSpot(sourceSpotId: string, requested: ServiceDirectSpotRouteFence, payload: ServiceApplicationPayload): Promise<number>;
+    requestToSpot(sourceSpotId: string, requested: ServiceDirectSpotRouteFence, payload: ServiceApplicationPayload, timeoutMs: number): ServiceStatefulPendingOperation;
+    sendToActor(target: ServiceActorRef, _targetNodeGeneration: bigint, _authorityOwnerGeneration: bigint, payload: ServiceApplicationPayload, sourceActor?: ServiceActorRef, boundSession?: {
+        readonly sessionRid: string;
+        readonly bindingGeneration: bigint;
+    }): Promise<number>;
+    requestToActor(target: ServiceActorRef, _targetNodeGeneration: bigint, _authorityOwnerGeneration: bigint, payload: ServiceApplicationPayload, timeoutMs: number, sourceActor?: ServiceActorRef, boundSession?: {
+        readonly sessionRid: string;
+        readonly bindingGeneration: bigint;
+    }): ServiceStatefulPendingOperation;
+    sendToInstanceSpot(route: ServiceInstanceRouteFence, payload: ServiceApplicationPayload, sourceSpotId?: string, metadataFrame?: Uint8Array): Promise<number>;
+    sendToMissingInstanceSpot(target: ServiceInstanceActivationTarget, payload: ServiceApplicationPayload, deadlineUnixMs: bigint, sourceSpotId?: string, metadataFrame?: Uint8Array): Promise<number>;
+    sendToMissingInstanceSpotFrame(target: ServiceInstanceActivationTarget, payloadFrame: Buffer, deadlineUnixMs: bigint, sourceSpotId?: string, metadataFrame?: Uint8Array): Promise<number>;
+    requestToInstanceSpot(route: ServiceInstanceRouteFence, payload: ServiceApplicationPayload, timeoutMs: number, sourceSpotId?: string, metadataFrame?: Uint8Array): ServiceStatefulPendingOperation;
+    requestToMissingInstanceSpot(target: ServiceInstanceActivationTarget, payload: ServiceApplicationPayload, timeoutMs: number, sourceSpotId?: string, metadataFrame?: Uint8Array): ServiceStatefulPendingOperation;
+    requestToMissingInstanceSpotFrame(target: ServiceInstanceActivationTarget, payloadFrame: Buffer, deadlineUnixMs: bigint, sourceSpotId?: string, metadataFrame?: Uint8Array): ServiceStatefulPendingOperation;
+    lookupRemoteActor(targetNodeRid: string, actorId: string, timeoutMs: number): ServiceStatefulPendingOperation;
+    destroyActor(actor: ServiceActorRef, timeoutMs: number): ServiceStatefulPendingOperation;
+    joinActor(actor: ServiceActorRef, targetNodeRid: string, targetSpot: ServiceSpotRef, targetSpotGeneration: bigint, payload: ServiceApplicationPayload | undefined, timeoutMs: number): ServiceStatefulPendingOperation;
+    joinActorCanonical(actor: ServiceActorRef, targetNodeRid: string, targetSpot: ServiceSpotRef, targetSpotGeneration: bigint, request: ServiceApplicationPayload, actorFence: ServiceCanonicalActorJoinCandidate['actorFence'], local: ServiceCanonicalActorJoinCandidate['local'], timeoutMs: number): ServiceStatefulPendingOperation;
+    joinActorEntrySpot(actor: ServiceActorRef, targetNodeRid: string, payload: ServiceApplicationPayload | undefined, timeoutMs: number): ServiceStatefulPendingOperation;
+    joinActorEntrySpotCanonical(actor: ServiceActorRef, targetNodeRid: string, request: ServiceApplicationPayload, actorFence: ServiceCanonicalActorJoinCandidate['actorFence'], local: ServiceCanonicalActorJoinCandidate['local'], timeoutMs: number): ServiceStatefulPendingOperation;
+    leaveActor(actor: ServiceActorRef, expectedMembershipEpoch: bigint, timeoutMs: number): ServiceStatefulPendingOperation;
+    bindSession(sessionRid: string, actor: ServiceActorRef, timeoutMs: number, deliver: ServiceSessionDelivery['deliver'], onBindingReplaced?: ServiceSessionDelivery['onBindingReplaced'], bindingIngress?: ServiceSessionBindingIngressPort, actorAuthority?: StreamSessionActorAuthorityFence): ServiceStatefulPendingOperation;
+    unbindSession(sessionRid: string, actor: ServiceActorRef, expectedBindingGeneration: bigint, timeoutMs: number): ServiceStatefulPendingOperation;
+    sessionBindings(sessionRid: string): readonly ServiceSessionBinding[];
+    allSessionBindings(): readonly ServiceSessionBinding[];
+    sendSessionToActor(sessionRid: string, actor: ServiceActorRef, payload: ServiceApplicationPayload): Promise<number>;
+    sendBoundSession(actor: ServiceActorRef, expectedBindingGeneration: bigint, payload: ServiceApplicationPayload, senderFence?: ServiceBoundSessionSendFence): Promise<number>;
+    close(): void;
+    private ingress;
+    private handleIngress;
+    private enqueueInstanceSpot;
+    private needsInstanceApplicationMaterialization;
+    private enqueueActivatedInstanceSpot;
+    private continueMissingInstanceActivation;
+    private continueReadyInstanceMaterialization;
+    private activationTerminalCompletion;
+    private instanceApplicationTerminalCompletion;
+    private instanceApplicationTarget;
+    private beginInstanceApplicationOperation;
+    private beginInstanceAuthorityOperation;
+    private completeInstanceApplicationOperation;
+    private completeInstanceAuthorityOperation;
+    private completeInstanceApplicationWaitersIfQuiescent;
+    private relayMissingInstanceActivation;
+    private requireInstanceActivation;
+    private requireReadyInstanceApplicationRoute;
+    private validateInstanceIngress;
+    private activateMissingInstance;
+    private activateMissingInstanceAsync;
+    private runMissingInstanceActivation;
+    private acceptsLocalMissingInstancePlacement;
+    private reconcileReadyInstanceProjection;
+    private publishCommittedInstanceRoute;
+    private replaceCommittedInstanceRoute;
+    private forgetClosedInstanceRoute;
+    private enqueueActorJoin;
+    private replyLookup;
+    private replyDestroy;
+    private replySessionBind;
+    /**
+     * Handles the replacement notice at the retired session owner.  This path
+     * intentionally never calls validateActorFence(): the notice is authorized
+     * by its transport source and exact retired session identity, not by a
+     * local Actor registry entry.
+     */
+    private handleBoundSessionReplaced;
+    private sendBoundSessionReplacement;
+    private enqueueSessionBindingTombstone;
+    private enqueueSessionBindingRetirement;
+    private deliverBoundSession;
+    private enqueueApplicationFrame;
+    private enqueueLifecycleFrame;
+    private enqueueFrame;
+    private enqueueLogicalMulticast;
+    private enqueueLogicalMulticastFrame;
+    private enqueueActorControl;
+    private enqueueActorBindingControl;
+    private replyPort;
+    private replyWire;
+    private handleUserSpotOperation;
+    private releaseExpiredUserSpotOperations;
+    private executeUserSpotOperation;
+    private requestUserSpotOperation;
+    private requestDurableOperation;
+    private requestLocalInfrastructure;
+    private submitOneWay;
+    private submitRequest;
+    private submitActorJoin;
+    private submitLocalRequest;
+    private completeRemoteReply;
+    private resultFromReply;
+    private validateActorFence;
+    private validateActorMessageFence;
+    private validateSpotFence;
+    private validateDirectSpotFence;
+    private holdOrRelaySpotMessage;
+    private restoreSpotMessageFollowRecord;
+    private drainSpotMessageFollow;
+    private notifySpotMessageFollowSource;
+    private failExpiredSpotMessageFollow;
+    private exactSpotMessageFollow;
+    private removeSpotMessageFollow;
+    private peekSpotMessageFollow;
+    private takeSpotMessageFollow;
+    private actorFence;
+    private tryBoundSessionSendFence;
+    private tryActorFence;
+    private acceptCanonicalActorFence;
+    private trySpotFence;
+    private tryEntrySpotFence;
+    private acceptSpotAuthority;
+    private peerGeneration;
+    private tryPeerGeneration;
+    private commitJoinedActor;
+    private requireOpen;
+}
+export declare function statefulMailboxData(record: ServiceMailboxRecord): ServiceStatefulMailboxData | undefined;