@zlink-systems/framework 0.10.0

package/dist/runtime/actors/actor-remote-wire.d.ts

@@ -0,0 +1,73 @@
+import type { RoutingId, SpotId } from '../../contracts';
+export declare const ZLINK_REMOTE_ACTOR_JOIN_PACKET = "__zlink.actor.join_spot.request";
+export declare const ZLINK_REMOTE_ACTOR_SOURCE_LEAVE_TERMINAL = "__zlink.actor.source_leave.terminal";
+export declare const REMOTE_ACTOR_JOIN_PACKET = "__zlink.actor.join_spot.request";
+export declare const REMOTE_ACTOR_JOIN_ADMISSION = "admission";
+export declare const REMOTE_ACTOR_JOIN_COMMIT = "commit";
+export declare const REMOTE_ACTOR_JOIN_ABORT = "abort";
+export type ZLinkRemoteActorJoinPhase = typeof REMOTE_ACTOR_JOIN_ADMISSION | typeof REMOTE_ACTOR_JOIN_COMMIT | typeof REMOTE_ACTOR_JOIN_ABORT;
+export interface ZLinkRemoteActorSourceLeaveTerminal {
+    readonly packetName: typeof ZLINK_REMOTE_ACTOR_SOURCE_LEAVE_TERMINAL;
+    readonly transferId: string;
+    readonly actorId: string;
+    readonly succeeded: boolean;
+}
+export declare function decodeRemoteActorSourceLeaveTerminal(payload: Buffer): ZLinkRemoteActorSourceLeaveTerminal | undefined;
+export interface ZLinkRemoteActorJoinWirePayload {
+    readonly packetName?: unknown;
+    readonly spotId?: unknown;
+    readonly actorId?: unknown;
+    readonly actorType?: unknown;
+    readonly actorNodeRid?: unknown;
+    readonly actorNodeRidHex?: unknown;
+    readonly actorGeneration?: unknown;
+    readonly actorNodeGeneration?: unknown;
+    readonly expectedAuthorityOwnerGeneration?: unknown;
+    readonly expectedOwnerLeaseGeneration?: unknown;
+    readonly expectedMembershipEpoch?: unknown;
+    readonly actorEntryNodeRid?: unknown;
+    readonly actorEntryNodeRidHex?: unknown;
+    readonly actorCreateRequest?: unknown;
+    readonly phase?: unknown;
+    readonly transferId?: unknown;
+    readonly transferAdapterKey?: unknown;
+    readonly transferState?: unknown;
+    readonly sourceSpotId?: unknown;
+    readonly routerChannelId?: unknown;
+    readonly boundSessionRouterChannelId?: unknown;
+    readonly boundSessionTargetNodeRid?: unknown;
+    readonly boundSessionTargetNodeRidHex?: unknown;
+    readonly boundSessionSpotId?: unknown;
+    readonly boundSessionNodeRid?: unknown;
+    readonly boundSessionNodeRidHex?: unknown;
+    readonly boundSessionRid?: unknown;
+    readonly boundSessionRidHex?: unknown;
+    readonly boundSessionBindingGeneration?: unknown;
+    readonly boundSessionPreviousAuthorityOwnerGeneration?: unknown;
+    readonly boundSessionPreviousOwnerLeaseGeneration?: unknown;
+    readonly boundSessionRelocationSealId?: unknown;
+    readonly boundSessionServiceWireRelocation?: unknown;
+    readonly request?: unknown;
+    readonly requestContentType?: unknown;
+    readonly handoffBacklog?: unknown;
+    readonly completionOperationHigh?: unknown;
+    readonly completionOperationLow?: unknown;
+}
+export declare function decodeRemoteActorJoinPayload(payload: unknown): {
+    readonly spotId: SpotId;
+    readonly actorId: string;
+    readonly actorType: string;
+    readonly actorNodeRid: RoutingId;
+    readonly actorGeneration: string;
+    readonly actorNodeGeneration?: string;
+    readonly expectedAuthorityOwnerGeneration?: string;
+    readonly expectedOwnerLeaseGeneration?: string;
+    readonly sourceSpotId?: SpotId;
+    readonly routerChannelId?: string;
+    readonly boundSessionRouterChannelId?: string;
+    readonly boundSessionTargetNodeRid?: RoutingId;
+    readonly boundSessionSpotId?: SpotId;
+    readonly request: string;
+    readonly requestContentType: string;
+};
+export declare function decodeWireRoutingId(text: string, hex: string | undefined): RoutingId;

package/dist/runtime/actors/actor-remote-wire.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOTE_ACTOR_JOIN_ABORT = exports.REMOTE_ACTOR_JOIN_COMMIT = exports.REMOTE_ACTOR_JOIN_ADMISSION = exports.REMOTE_ACTOR_JOIN_PACKET = exports.ZLINK_REMOTE_ACTOR_SOURCE_LEAVE_TERMINAL = exports.ZLINK_REMOTE_ACTOR_JOIN_PACKET = void 0;
+exports.decodeRemoteActorSourceLeaveTerminal = decodeRemoteActorSourceLeaveTerminal;
+exports.decodeRemoteActorJoinPayload = decodeRemoteActorJoinPayload;
+exports.decodeWireRoutingId = decodeWireRoutingId;
+const routing_id_1 = require("../routing-id");
+exports.ZLINK_REMOTE_ACTOR_JOIN_PACKET = '__zlink.actor.join_spot.request';
+exports.ZLINK_REMOTE_ACTOR_SOURCE_LEAVE_TERMINAL = '__zlink.actor.source_leave.terminal';
+exports.REMOTE_ACTOR_JOIN_PACKET = exports.ZLINK_REMOTE_ACTOR_JOIN_PACKET;
+exports.REMOTE_ACTOR_JOIN_ADMISSION = 'admission';
+exports.REMOTE_ACTOR_JOIN_COMMIT = 'commit';
+exports.REMOTE_ACTOR_JOIN_ABORT = 'abort';
+function decodeRemoteActorSourceLeaveTerminal(payload) {
+    let decoded;
+    try {
+        decoded = JSON.parse(payload.toString());
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof decoded !== 'object'
+        || decoded === null
+        || decoded.packetName
+            !== exports.ZLINK_REMOTE_ACTOR_SOURCE_LEAVE_TERMINAL
+        || typeof decoded.transferId !== 'string'
+        || typeof decoded.actorId !== 'string'
+        || typeof decoded.succeeded !== 'boolean') {
+        return undefined;
+    }
+    return decoded;
+}
+function decodeRemoteActorJoinPayload(payload) {
+    if (typeof payload !== 'object' ||
+        payload === null ||
+        payload.packetName !== exports.ZLINK_REMOTE_ACTOR_JOIN_PACKET ||
+        typeof payload.spotId !== 'string' ||
+        typeof payload.actorId !== 'string' ||
+        typeof payload.actorType !== 'string' ||
+        typeof payload.actorNodeRid !== 'string' ||
+        typeof payload.actorGeneration !== 'string' ||
+        typeof payload.request !== 'string') {
+        throw new Error('Remote actor join payload is invalid.');
+    }
+    return {
+        spotId: requireSpotId(payload.spotId),
+        actorId: payload.actorId,
+        actorType: payload.actorType,
+        actorNodeRid: decodeWireRoutingId(payload.actorNodeRid, optionalString(payload, 'actorNodeRidHex')),
+        actorGeneration: payload.actorGeneration,
+        actorNodeGeneration: optionalString(payload, 'actorNodeGeneration'),
+        expectedAuthorityOwnerGeneration: optionalString(payload, 'expectedAuthorityOwnerGeneration'),
+        expectedOwnerLeaseGeneration: optionalString(payload, 'expectedOwnerLeaseGeneration'),
+        sourceSpotId: optionalSpotId(payload, 'sourceSpotId'),
+        routerChannelId: optionalString(payload, 'routerChannelId'),
+        boundSessionRouterChannelId: optionalString(payload, 'boundSessionRouterChannelId'),
+        boundSessionTargetNodeRid: optionalRoutingId(payload, 'boundSessionTargetNodeRid', 'boundSessionTargetNodeRidHex'),
+        boundSessionSpotId: optionalSpotId(payload, 'boundSessionSpotId'),
+        request: payload.request,
+        requestContentType: optionalString(payload, 'requestContentType') ?? 'application/json'
+    };
+}
+function decodeWireRoutingId(text, hex) {
+    return (0, routing_id_1.decodeRoutingId)(text, hex);
+}
+function optionalString(value, key) {
+    const field = value[key];
+    return typeof field === 'string' ? field : undefined;
+}
+function optionalRoutingId(value, textKey, hexKey) {
+    const text = optionalString(value, textKey);
+    return text === undefined ? undefined : decodeWireRoutingId(text, optionalString(value, hexKey));
+}
+function optionalSpotId(value, key) {
+    const text = optionalString(value, key);
+    return text === undefined ? undefined : requireSpotId(text);
+}
+function requireSpotId(value) {
+    const bytes = Buffer.byteLength(value, 'utf8');
+    if (bytes < 1 || bytes > 255) {
+        throw new Error('Remote actor SpotId must contain 1..255 UTF-8 bytes.');
+    }
+    return value;
+}

package/dist/runtime/actors/actor-retry-delay.d.ts

@@ -0,0 +1,5 @@
+export declare class ZLinkActorRetryDelay {
+    private delayMs;
+    reset(): void;
+    wait(signal: AbortSignal | undefined): Promise<boolean>;
+}

package/dist/runtime/actors/actor-retry-delay.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkActorRetryDelay = void 0;
+const INITIAL_RETRY_DELAY_MS = 25;
+const MAX_RETRY_DELAY_MS = 1_000;
+class ZLinkActorRetryDelay {
+    delayMs = INITIAL_RETRY_DELAY_MS;
+    reset() {
+        this.delayMs = INITIAL_RETRY_DELAY_MS;
+    }
+    async wait(signal) {
+        const completed = await delayUnlessAborted(this.delayMs, signal);
+        if (completed) {
+            this.delayMs = Math.min(this.delayMs * 2, MAX_RETRY_DELAY_MS);
+        }
+        return completed;
+    }
+}
+exports.ZLinkActorRetryDelay = ZLinkActorRetryDelay;
+function delayUnlessAborted(delayMs, signal) {
+    if (signal?.aborted === true)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (completed) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            signal?.removeEventListener('abort', aborted);
+            resolve(completed);
+        };
+        const aborted = () => finish(false);
+        const deadline = setTimeout(() => finish(true), delayMs);
+        deadline.unref();
+        signal?.addEventListener('abort', aborted, { once: true });
+        if (signal?.aborted === true)
+            aborted();
+    });
+}

package/dist/runtime/actors/actor-routed-join-transport.d.ts

@@ -0,0 +1,33 @@
+import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkBackendSpot } from '../backend/contracts';
+import type { ZLinkSubmitResult } from '../messaging/submission-result';
+import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
+export interface ZLinkActorRoutedJoinTransport {
+    canRouteChannel?(routerChannelId: string): boolean;
+    canRoutePacketChannel?(routerChannelId: string): boolean;
+    request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+    submit?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
+    submitInfrastructure?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal): Promise<ZLinkSubmitResult>;
+    sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
+        readonly packetName?: string;
+        readonly signal?: AbortSignal;
+    }): Promise<ZLinkSubmitResult>;
+    requestRawToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
+        readonly timeoutMs?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<readonly Message[]>;
+    requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
+        readonly packetName?: string;
+        readonly timeoutMs?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<TReply>;
+    requestFromSpotToSpot?<TReply = unknown>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
+        readonly packetName?: string;
+        readonly timeoutMs?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<TReply>;
+    requestRawFromSpotToSpot?(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
+        readonly timeoutMs?: number;
+        readonly signal?: AbortSignal;
+    }): Promise<readonly Message[]>;
+}

package/dist/runtime/actors/actor-routed-join-transport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/actors/actor-routed-json-request.d.ts

@@ -0,0 +1,11 @@
+import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
+import type { ZLinkActorRoutedJoinTransport } from './actor-routed-join-transport';
+export declare function tryRequestRoutedJson(transport: ZLinkActorRoutedJoinTransport, target: ZLinkSpotRouteTarget, payload: unknown, options: {
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}): Promise<boolean>;
+export declare function requestRoutedJsonReply<T>(transport: ZLinkActorRoutedJoinTransport, target: ZLinkSpotRouteTarget, payload: unknown, options: {
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}, unavailableMessage: string, decode: (replyParts: readonly Message[]) => T): Promise<T>;

package/dist/runtime/actors/actor-routed-json-request.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryRequestRoutedJson = tryRequestRoutedJson;
+exports.requestRoutedJsonReply = requestRoutedJsonReply;
+const runtime_message_1 = require("../backend/runtime-message");
+async function tryRequestRoutedJson(transport, target, payload, options) {
+    const request = transport.requestRawToSpot;
+    if (request === undefined)
+        return false;
+    const message = runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(JSON.stringify(payload)));
+    try {
+        const replyParts = await request.call(transport, target, message, options);
+        for (const part of replyParts)
+            part.close();
+        return true;
+    }
+    finally {
+        message.close();
+    }
+}
+async function requestRoutedJsonReply(transport, target, payload, options, unavailableMessage, decode) {
+    const request = transport.requestRawToSpot;
+    if (request === undefined)
+        throw new Error(unavailableMessage);
+    const message = runtime_message_1.ZLinkBufferMessage.fromOwned(Buffer.from(JSON.stringify(payload)));
+    try {
+        const replyParts = await request.call(transport, target, message, options);
+        try {
+            return decode(replyParts);
+        }
+        finally {
+            for (const part of replyParts)
+                part.close();
+        }
+    }
+    finally {
+        message.close();
+    }
+}

package/dist/runtime/actors/actor-runtime-contracts.d.ts

@@ -0,0 +1,63 @@
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import type { RoutingId, ActorRef, Type, ZLinkActor, ZLinkActorFactory, ZLinkBoundSession, ZLinkMessage, ZLinkActorCreateResponse, ZLinkMessageSerializer } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkBackendMeshNode, ZLinkMeshCompletionTable } from '../backend';
+import type { ZLinkLocationLifecycle } from '../locations';
+import type { ZLinkActorRuntimeState } from './actor-runtime-state';
+import type { ZLinkActorTransferRegistry } from './actor-transfer-registry';
+import type { ZLinkRuntimeAdmissionGate } from '../admission';
+export interface ZLinkActorJoinRuntimeResult<TReply> {
+    readonly accepted: boolean;
+    readonly actor?: import('../../contracts').ActorRef;
+    readonly reply?: TReply;
+    /** Internal terminal work that must run after the completion callback. */
+    readonly finalizeDeferredJoin?: () => Promise<void>;
+}
+export interface ZLinkActorManagerOptions {
+    readonly actorFactories: ReadonlyMap<string, Type | ZLinkActorFactory>;
+    readonly joinCoordinator?: ZLinkActorJoinCoordinator;
+    readonly actorMeshNameProvider?: (actorType: string) => string | undefined;
+    readonly actorLeaveSpot?: (meshName: string, spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal) => Promise<void>;
+    readonly messageSerializers?: ReadonlyMap<string, ZLinkMessageSerializer>;
+    readonly nativeActorNode?: ZLinkBackendMeshNode;
+    readonly nativeActorNodeProvider?: () => ZLinkBackendMeshNode | undefined;
+    readonly nativeActorCompletionTableProvider?: () => ZLinkMeshCompletionTable | undefined;
+    readonly actorCreatedNodeRidProvider?: () => RoutingId | undefined;
+    readonly actorRefResolver?: ZLinkActorRuntimeLocationLookup;
+    readonly actorCreatedNotifier?: (nodeRid: RoutingId, actor: ZLinkActor, createRequest: ZLinkMessage, signal?: AbortSignal) => Promise<ZLinkActorCreateResponse | undefined>;
+    readonly actorDestroyedCleanup?: (actorId: string) => void;
+    readonly publishActorAuthority?: (actorType: string, actorRef: ActorRef, ownerNodeGeneration: bigint, signal?: AbortSignal) => Promise<void>;
+    readonly locationLifecycle?: ZLinkLocationLifecycle;
+    readonly boundSessionFactory?: ZLinkActorBoundSessionFactory;
+    readonly providerResolver?: ZLinkProviderResolver;
+    readonly actorTransferRegistry?: ZLinkActorTransferRegistry;
+    readonly shutdownSignal?: AbortSignal;
+    readonly metrics?: import('../diagnostics').ZLinkRuntimeMetrics;
+    readonly admission?: ZLinkRuntimeAdmissionGate;
+    readonly placementCreate?: (actorId: string, actorType: string, createOnly: boolean, options: {
+        readonly meshName?: string;
+        readonly request?: unknown;
+        readonly timeoutMs: number;
+    }, signal?: AbortSignal) => Promise<import('../../contracts').ZLinkActorCreateResult>;
+}
+export interface ZLinkActorRuntimeLocationLookup {
+    resolveActorRef(actorId: string, signal?: AbortSignal): Promise<ActorRef | undefined>;
+}
+export type ZLinkActorBoundSessionFactory = (actorId: string) => ZLinkBoundSession;
+export interface ZLinkActorJoinCoordinator {
+    /**
+     * The message flow tracer, when the host wired one. A deferred Join that ends
+     * in `failed` reports its cause here so the failure carries the same flow
+     * identity as the Join that produced it.
+     */
+    messageFlow?(): import('../diagnostics/message-flow').ZLinkMessageFlowTracer | undefined;
+    /**
+     * Starts the internal packet handoff before a Deferred Join performs target
+     * lookup. This is an internal ordering fence; it is not part of the public
+     * actor context contract.
+     */
+    beginDeferredJoin?(actor: ZLinkActor, state: ZLinkActorRuntimeState, operationId: import('../../contracts').ZLinkActorJoinOperationId): void;
+    abortDeferredJoin?(actor: ZLinkActor, state: ZLinkActorRuntimeState, operationId: import('../../contracts').ZLinkActorJoinOperationId): Promise<void>;
+    joinSpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, spotId: RoutingId, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId): Promise<ZLinkActorJoinRuntimeResult<Message>>;
+    joinEntrySpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, nodeRid: RoutingId | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId): Promise<ZLinkActorJoinRuntimeResult<Message>>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/actors/actor-runtime-state.d.ts

@@ -0,0 +1,152 @@
+import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorContext, ZLinkSpot } from '../../contracts';
+import { ZLinkSpotKind } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkBackendActorRef, ZLinkBackendMeshNode } from '../backend/contracts';
+export interface ZLinkRemoteBoundSessionTarget {
+    readonly routerChannelId: string;
+    readonly targetNodeRid: RoutingId;
+    readonly spotId: RoutingId;
+    readonly sessionNodeRid?: RoutingId;
+    readonly sessionRid?: RoutingId;
+    readonly sessionOwnerNodeGeneration?: bigint;
+    readonly sessionOwnerId?: string;
+    readonly sessionOwnerLeaseGeneration?: bigint;
+    readonly bindingGeneration?: bigint;
+    readonly previousAuthorityOwnerGeneration?: bigint;
+    readonly previousOwnerLeaseGeneration?: bigint;
+    readonly relocationSealId?: string;
+    readonly serviceWireRelocation?: {
+        readonly relocation: {
+            readonly high: bigint;
+            readonly low: bigint;
+        };
+        readonly coordinator: {
+            readonly ownerId: string;
+            readonly leaseGeneration: bigint;
+            readonly nodeRid: string;
+            readonly nodeGeneration: bigint;
+            readonly expectedAuthorityStoreVersion: string;
+        };
+        readonly session: {
+            readonly sessionOwnerNodeRid: string;
+            readonly sessionOwnerNodeGeneration: bigint;
+            readonly sessionOwnerId: string;
+            readonly sessionOwnerLeaseGeneration: bigint;
+            readonly sessionRid: string;
+            readonly bindingGeneration: bigint;
+        };
+    };
+}
+/**
+ * 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.
+ */
+export declare function mergeRemoteBoundSessionTarget(target: ZLinkRemoteBoundSessionTarget, fallback: ZLinkRemoteBoundSessionTarget | undefined): ZLinkRemoteBoundSessionTarget;
+/**
+ * Selects the route that still carries the relocation fence when a Core
+ * binding refresh and a formal transfer target temporarily coexist.
+ */
+export declare function preferredRemoteBoundSessionTarget(remote: ZLinkRemoteBoundSessionTarget | undefined, transfer: ZLinkRemoteBoundSessionTarget | undefined): ZLinkRemoteBoundSessionTarget | undefined;
+export interface ZLinkRemoteActorPacketTarget {
+    readonly routerChannelId: string;
+    readonly targetNodeRid: RoutingId;
+    readonly spotId: RoutingId;
+    readonly spotKind?: ZLinkSpotKind;
+    readonly targetSpotGeneration?: bigint;
+    readonly targetNodeGeneration?: bigint;
+    readonly authorityOwnerGeneration?: bigint;
+    readonly targetOwnerId?: string;
+    readonly ownerLeaseGeneration?: bigint;
+    readonly authorityStoreVersion?: string;
+}
+export interface ZLinkActorCreationOperation {
+    readonly task: Promise<ZLinkActorCreationAttemptResult>;
+    readonly created: boolean;
+}
+export type ZLinkActorCreationAttemptResult = {
+    readonly status: 'created';
+    readonly actor: ZLinkActor;
+    readonly reply?: unknown;
+} | {
+    readonly status: 'rejected';
+    readonly reply?: unknown;
+};
+export declare class ZLinkActorRuntimeState {
+    readonly actorId: string;
+    private creationTask;
+    private configured;
+    private context;
+    private actorTypeValue;
+    private meshNameValue;
+    private actorValue;
+    private spotValue;
+    private spotIdValue;
+    private spotGenerationValue;
+    private spotMembershipEpochValue;
+    private nativeActorRefValue;
+    private boundSessionBindingGenerationValue;
+    private entryNodeRidValue;
+    private remoteBoundSessionTargetValue;
+    private boundSessionTransferTargetValue;
+    private remoteActorPacketTargetValue;
+    private createRequestPayloadValue;
+    private ownsLocationValue;
+    private locationGenerationValue;
+    private ownerLeaseGenerationValue;
+    private movingValue;
+    private deferredJoinPendingValue;
+    private destroyTask;
+    constructor(actorId: string);
+    get actorType(): string | undefined;
+    get meshName(): string | undefined;
+    rememberMeshName(meshName: string): void;
+    get actor(): ZLinkActor | undefined;
+    get spot(): ZLinkSpot | undefined;
+    get spotId(): RoutingId | undefined;
+    get spotMembershipEpoch(): bigint;
+    get spotGeneration(): bigint | undefined;
+    get nativeActorRef(): ZLinkBackendActorRef | undefined;
+    get boundSessionBindingGeneration(): bigint;
+    get entryNodeRid(): RoutingId | undefined;
+    get remoteBoundSessionTarget(): ZLinkRemoteBoundSessionTarget | undefined;
+    get boundSessionTransferTarget(): ZLinkRemoteBoundSessionTarget | undefined;
+    get remoteActorPacketTarget(): ZLinkRemoteActorPacketTarget | undefined;
+    get createRequestPayload(): Buffer | undefined;
+    get isJoined(): boolean;
+    get ownsLocation(): boolean;
+    get locationGeneration(): bigint | undefined;
+    get ownerLeaseGeneration(): bigint | undefined;
+    get isMoving(): boolean;
+    tryBeginDeferredJoin(): boolean;
+    endDeferredJoin(): void;
+    get hasActorOrCreation(): boolean;
+    beginMove(): void;
+    endMove(): void;
+    markLocationOwned(): void;
+    markLocationReleased(): void;
+    setLocationGeneration(generation: bigint): void;
+    setOwnerLeaseGeneration(generation: bigint): void;
+    getOrStartDestroy(entryNodeRid: RoutingId, destroy: (actorRef: ZLinkBackendActorRef | undefined) => Promise<void>): Promise<void>;
+    markNativeActorDestroyed(actorRef: ZLinkBackendActorRef): void;
+    clearFailedDestroy(task: Promise<void>): void;
+    ensureContext(createContext: () => ZLinkActorContext): ZLinkActorContext;
+    getOrStartCreation(actorType: string, failIfExists: boolean, createActor: () => Promise<ZLinkActorCreationAttemptResult>): ZLinkActorCreationOperation;
+    clearFailedCreation(task: Promise<ZLinkActorCreationAttemptResult>): boolean;
+    bindActor(actor: ZLinkActor, context: ZLinkActorContext): void;
+    ensureNativeActorRef(node: ZLinkBackendMeshNode, request?: Message): ZLinkBackendActorRef;
+    setNativeActorRef(actorRef: ZLinkBackendActorRef): void;
+    setBoundSessionBindingGeneration(generation: bigint): void;
+    setEntryNodeRid(entryNodeRid: RoutingId): void;
+    setRemoteBoundSessionTarget(target: ZLinkRemoteBoundSessionTarget | undefined): void;
+    setBoundSessionTransferTarget(target: ZLinkRemoteBoundSessionTarget | undefined): void;
+    setRemoteActorPacketTarget(target: ZLinkRemoteActorPacketTarget | undefined): void;
+    setCreateRequestPayload(payload: Buffer | Uint8Array): void;
+    setJoinedSpot(spotId: RoutingId, spot?: ZLinkSpot, membershipEpoch?: bigint, spotGeneration?: bigint): void;
+    clearJoinedSpot(): void;
+    clearAfterDestroy(): void;
+    prepareForRemoteReentry(): void;
+}
+export declare function toFrameworkRoutingId(routingId: unknown): RoutingId;
+export declare function toFrameworkActorRef(actor: ZLinkBackendActorRef, meshName: string): ActorRef;