@zlink-systems/framework 0.10.0

package/dist/runtime/host/relocation-integrity-fault-gate.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLINK_INTERNAL_RELOCATION_INTEGRITY_FAULT_GATE = void 0;
+/** Internal E2E-only fault seam for direct relocation transfer integrity cases. */
+exports.ZLINK_INTERNAL_RELOCATION_INTEGRITY_FAULT_GATE = Symbol.for('zlink.internal.relocation-integrity-fault-gate');

package/dist/runtime/host/relocation-state-adapter.d.ts

@@ -0,0 +1,8 @@
+export interface ZLinkRelocationStateAdapterLike<TInstance> {
+    capture(instance: TInstance, signal: AbortSignal): Promise<Uint8Array>;
+    restore(instance: TInstance, payload: Uint8Array, signal: AbortSignal): Promise<void>;
+}
+/** Captures the application state through the adapter. */
+export declare function captureRelocationAdapterState<TInstance>(adapter: ZLinkRelocationStateAdapterLike<TInstance>, instance: TInstance, signal: AbortSignal): Promise<Buffer>;
+/** Restores the application state through the adapter. */
+export declare function restoreRelocationAdapterState<TInstance>(adapter: ZLinkRelocationStateAdapterLike<TInstance>, instance: TInstance, payload: Uint8Array, signal: AbortSignal): Promise<TInstance>;

package/dist/runtime/host/relocation-state-adapter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureRelocationAdapterState = captureRelocationAdapterState;
+exports.restoreRelocationAdapterState = restoreRelocationAdapterState;
+/** Captures the application state through the adapter. */
+async function captureRelocationAdapterState(adapter, instance, signal) {
+    return Buffer.from(await adapter.capture(instance, signal));
+}
+/** Restores the application state through the adapter. */
+async function restoreRelocationAdapterState(adapter, instance, payload, signal) {
+    await adapter.restore(instance, payload, signal);
+    return instance;
+}

package/dist/runtime/host/remote-actor-join-receiver.d.ts

@@ -0,0 +1,47 @@
+import type { RoutingId, ZLinkRouteMessageContext } from '../../contracts';
+import type { DefaultZLinkActorManager } from '../actors';
+import type { DefaultZLinkSpotManager } from '../spots';
+import type { ZLinkAuthorityStore } from '../locations/internal-store-contracts';
+export interface ZLinkCanonicalActorJoinAuthorityFence {
+    readonly actorId: string;
+    readonly actorNodeRid: RoutingId;
+    readonly actorGeneration: bigint;
+    readonly actorNodeGeneration: bigint;
+    readonly expectedAuthorityOwnerGeneration: bigint;
+    readonly expectedOwnerLeaseGeneration: bigint;
+}
+export interface ZLinkRemoteActorJoinReceiverOptions {
+    readonly actorManager: () => DefaultZLinkActorManager | undefined;
+    readonly spotManager: () => DefaultZLinkSpotManager | undefined;
+    readonly authorityStore: () => ZLinkAuthorityStore | undefined;
+}
+export declare class ZLinkRemoteActorJoinReceiver {
+    private readonly options;
+    constructor(options: ZLinkRemoteActorJoinReceiverOptions);
+    receive(payload: unknown, routeContext: ZLinkRouteMessageContext): Promise<{
+        readonly accepted: boolean;
+        readonly actorNodeRid: string;
+        readonly actorNodeRidHex?: string;
+        readonly actorId: string;
+        readonly actorGeneration: string;
+        readonly reply?: string;
+    }>;
+    /**
+     * Canonical command 28 carries no stable type or bound-session coordinates.
+     * The raw-mesh dispatcher invokes this before its normal typed Spot admission
+     * so the canonical path resolves the S1 Location Store fence/type and factory
+     * registration without materializing or claiming the Actor. The Spot
+     * admission registry owns the temporary queue until command 40 restores the
+     * hidden Actor.
+     */
+    prepareCanonicalActorJoin(join: ZLinkCanonicalActorJoinAuthorityFence): Promise<{
+        readonly actorType: string;
+    }>;
+    private requireActorManager;
+    private requireSpotManager;
+    /**
+     * Spec 51 §9: the Authority row, not the legacy JSON actorType field, is
+     * the type source for receiver-side Actor Join admission.
+     */
+    private resolveStableType;
+}

package/dist/runtime/host/remote-actor-join-receiver.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkRemoteActorJoinReceiver = void 0;
+const runtime_message_1 = require("../backend/runtime-message");
+const actor_runtime_state_1 = require("../actors/actor-runtime-state");
+const actor_remote_wire_1 = require("../actors/actor-remote-wire");
+const authority_key_codec_1 = require("../locations/authority-key-codec");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+const routing_id_1 = require("../routing-id");
+class ZLinkRemoteActorJoinReceiver {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async receive(payload, routeContext) {
+        let join;
+        try {
+            join = (0, actor_remote_wire_1.decodeRemoteActorJoinPayload)(payload);
+        }
+        catch (error) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestProtocolError, 'Remote Actor Join payload is invalid.', error);
+        }
+        const actorManager = this.requireActorManager();
+        const stableType = hasAuthorityFence(join)
+            ? await this.resolveStableType(join)
+            : join.actorType;
+        if (hasAuthorityFence(join) && join.actorType !== stableType) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorTypeMismatch, `Actor '${join.actorId}' join stable type does not match its Authority row.`);
+        }
+        const actor = await actorManager.getOrCreateActor(join.actorId, stableType);
+        const state = actorManager.getState(join.actorId);
+        if (state === undefined) {
+            throw new Error(`Actor '${join.actorId}' state was not created.`);
+        }
+        const actorRef = {
+            nodeRid: join.actorNodeRid,
+            actorId: join.actorId,
+            generation: BigInt(join.actorGeneration)
+        };
+        state.setNativeActorRef(actorRef);
+        const refreshedTarget = (0, actor_runtime_state_1.mergeRemoteBoundSessionTarget)({
+            routerChannelId: join.boundSessionRouterChannelId ?? join.routerChannelId ?? routeContext.channelName ?? '',
+            targetNodeRid: join.boundSessionTargetNodeRid ?? (0, routing_id_1.normalizeRoutingId)(routeContext.sourceNodeRid),
+            spotId: join.boundSessionSpotId ?? join.sourceSpotId ?? (0, routing_id_1.normalizeRoutingId)(routeContext.sourceNodeRid)
+        }, (0, actor_runtime_state_1.preferredRemoteBoundSessionTarget)(state.remoteBoundSessionTarget, state.boundSessionTransferTarget));
+        state.setRemoteBoundSessionTarget(refreshedTarget);
+        const request = runtime_message_1.ZLinkBufferMessage.from(Buffer.from(join.request, 'base64'));
+        try {
+            const response = await this.requireSpotManager().admitActorJoin(join.spotId, actor, request, (spot) => {
+                state.setJoinedSpot(join.spotId, spot);
+                return () => state.clearJoinedSpot();
+            }, undefined, undefined, join.requestContentType);
+            const reply = response.reply;
+            return {
+                accepted: response.accepted,
+                actorNodeRid: String(join.actorNodeRid),
+                actorNodeRidHex: (0, routing_id_1.routingIdWireHex)(join.actorNodeRid),
+                actorId: join.actorId,
+                actorGeneration: join.actorGeneration,
+                reply: reply?.data().toString('base64')
+            };
+        }
+        finally {
+            request.close();
+        }
+    }
+    /**
+     * Canonical command 28 carries no stable type or bound-session coordinates.
+     * The raw-mesh dispatcher invokes this before its normal typed Spot admission
+     * so the canonical path resolves the S1 Location Store fence/type and factory
+     * registration without materializing or claiming the Actor. The Spot
+     * admission registry owns the temporary queue until command 40 restores the
+     * hidden Actor.
+     */
+    async prepareCanonicalActorJoin(join) {
+        const actorManager = this.requireActorManager();
+        const stableType = await this.resolveStableType(join);
+        actorManager.requireRelocationActorFactory(stableType);
+        return { actorType: stableType };
+    }
+    requireActorManager() {
+        const manager = this.options.actorManager();
+        if (manager === undefined) {
+            throw new Error('Actor manager runtime is not started.');
+        }
+        return manager;
+    }
+    requireSpotManager() {
+        const manager = this.options.spotManager();
+        if (manager === undefined) {
+            throw new Error('SPOT manager runtime is not started.');
+        }
+        return manager;
+    }
+    /**
+     * Spec 51 §9: the Authority row, not the legacy JSON actorType field, is
+     * the type source for receiver-side Actor Join admission.
+     */
+    async resolveStableType(join) {
+        const store = this.options.authorityStore();
+        if (store === undefined) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RelocationTargetUnavailable, `Actor '${join.actorId}' Join cannot read its Authority row because Location Store is unavailable.`);
+        }
+        let authority;
+        try {
+            authority = await store.readAuthority((0, authority_key_codec_1.encodeAuthorityKey)('actor', join.actorId));
+        }
+        catch (error) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RelocationTargetUnavailable, `Actor '${join.actorId}' Join could not read its Authority row.`, error);
+        }
+        if (authority.kind === 'missing') {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound, `Actor '${join.actorId}' has no Authority row for Join admission.`);
+        }
+        const fence = decodeJoinAuthorityFence(join);
+        if (authority.allocation.state !== 'active'
+            || authority.allocation.objectKind !== 'actor'
+            || authority.objectGeneration !== fence.objectGeneration
+            || !(0, routing_id_1.routingIdsEqual)(authority.allocation.descriptor.rid, join.actorNodeRid)
+            || authority.allocation.descriptorLifecycleGeneration !== fence.nodeGeneration
+            || authority.authorityOwnerGeneration !== fence.authorityOwnerGeneration
+            || authority.ownerLeaseGeneration !== fence.ownerLeaseGeneration) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestProtocolError, `Actor '${join.actorId}' Join Authority row does not exactly match its route fence.`);
+        }
+        return authority.allocation.stableType;
+    }
+}
+exports.ZLinkRemoteActorJoinReceiver = ZLinkRemoteActorJoinReceiver;
+function hasAuthorityFence(join) {
+    return join.actorNodeGeneration !== undefined
+        && join.expectedAuthorityOwnerGeneration !== undefined
+        && join.expectedOwnerLeaseGeneration !== undefined;
+}
+function decodeJoinAuthorityFence(join) {
+    let objectGeneration;
+    let nodeGeneration;
+    let authorityOwnerGeneration;
+    let ownerLeaseGeneration;
+    try {
+        objectGeneration = BigInt(join.actorGeneration);
+        nodeGeneration = BigInt(join.actorNodeGeneration);
+        authorityOwnerGeneration = BigInt(join.expectedAuthorityOwnerGeneration);
+        ownerLeaseGeneration = BigInt(join.expectedOwnerLeaseGeneration);
+    }
+    catch (error) {
+        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestProtocolError, `Actor '${join.actorId}' Join carries an invalid Authority fence.`, error);
+    }
+    // object/owner generations are bounded counters; the MeshNode lifecycle is
+    // an opaque full-range token, for which only zero denotes absence.
+    if (objectGeneration <= 0n
+        || nodeGeneration === 0n
+        || authorityOwnerGeneration <= 0n
+        || ownerLeaseGeneration <= 0n) {
+        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestProtocolError, `Actor '${join.actorId}' Join carries an incomplete Authority fence.`);
+    }
+    return {
+        objectGeneration,
+        nodeGeneration,
+        authorityOwnerGeneration,
+        ownerLeaseGeneration
+    };
+}

package/dist/runtime/host/remote-actor-packet-target-store.d.ts

@@ -0,0 +1,29 @@
+import type { ActorRef, RoutingId, ZLinkSessionActor } from '../../contracts';
+import type { DefaultZLinkActorManager, ZLinkRemoteActorPacketTarget } from '../actors';
+import type { ZLinkStreamActorLookupPort } from '../streams/stream-binding-runtime-ports';
+import type { MeshRouterResolver } from './mesh-router-resolver';
+export interface ZLinkRemoteActorPacketTargetStoreOptions {
+    readonly actorManager: () => DefaultZLinkActorManager | undefined;
+    readonly streamBindingRuntime: () => ZLinkStreamActorLookupPort;
+    readonly meshRouters: MeshRouterResolver;
+    readonly primaryNodeRid: () => RoutingId | undefined;
+    readonly spotRouterChannelIdForMesh: (meshName: string) => string;
+}
+export declare class ZLinkRemoteActorPacketTargetStore {
+    private readonly options;
+    private readonly sessionActorPacketTargets;
+    private readonly sessionActorPacketTargetsByActor;
+    private readonly sessionActorPacketTargetsByActorId;
+    private readonly sessionActorPacketTargetOwners;
+    constructor(options: ZLinkRemoteActorPacketTargetStoreOptions);
+    updateFromWire(actorId: string, value: unknown): Promise<void>;
+    decodeFromWire(value: unknown): ZLinkRemoteActorPacketTarget | undefined;
+    clear(actorId: string, expectedTenureKey?: string, expectedActor?: ZLinkSessionActor): void;
+    cachedTargetForActor(actor: ZLinkSessionActor): ZLinkRemoteActorPacketTarget | undefined;
+    targetForState(actorId: string, routerChannelIdHint?: string): ZLinkRemoteActorPacketTarget | undefined;
+    targetForActorRef(actorRef: ActorRef): ZLinkRemoteActorPacketTarget | undefined;
+    tenureKeyForActor(actor: ZLinkSessionActor): string;
+    tenureKeyForActorRef(actorId: string, actorRef: ActorRef): string;
+    rememberActorTarget(actor: ZLinkSessionActor, target: ZLinkRemoteActorPacketTarget, expectedTenureKey?: string): void;
+    private rememberSessionActorTarget;
+}

package/dist/runtime/host/remote-actor-packet-target-store.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkRemoteActorPacketTargetStore = void 0;
+const contracts_1 = require("../../contracts");
+const actor_packet_relay_wire_1 = require("../actors/actor-packet-relay-wire");
+const routing_id_1 = require("../routing-id");
+const routing_id_2 = require("../routing-id");
+class ZLinkRemoteActorPacketTargetStore {
+    options;
+    sessionActorPacketTargets = new WeakMap();
+    sessionActorPacketTargetsByActor = new Map();
+    sessionActorPacketTargetsByActorId = new Map();
+    sessionActorPacketTargetOwners = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async updateFromWire(actorId, value) {
+        const actorPacketTarget = this.decodeFromWire(value);
+        const state = this.options.actorManager()?.getState(actorId);
+        if (actorPacketTarget !== undefined) {
+            if (typeof state?.setRemoteActorPacketTarget === 'function') {
+                state.setRemoteActorPacketTarget(actorPacketTarget);
+            }
+            const sessionActor = await this.options.streamBindingRuntime().find(actorId);
+            if (sessionActor !== undefined) {
+                this.rememberSessionActorTarget(sessionActor, actorPacketTarget);
+            }
+            return;
+        }
+        this.clear(actorId);
+    }
+    decodeFromWire(value) {
+        return (0, actor_packet_relay_wire_1.decodeRemoteActorPacketTarget)(value);
+    }
+    clear(actorId, expectedTenureKey, expectedActor) {
+        if (expectedTenureKey !== undefined
+            && (expectedActor === undefined
+                || expectedActor.actorId !== actorId
+                || this.tenureKeyForActor(expectedActor) !== expectedTenureKey))
+            return;
+        const state = this.options.actorManager()?.getState(actorId);
+        if (typeof state?.setRemoteActorPacketTarget === 'function') {
+            state.setRemoteActorPacketTarget(undefined);
+        }
+        this.sessionActorPacketTargetsByActorId.delete(actorId);
+        const owner = this.sessionActorPacketTargetOwners.get(actorId);
+        if (owner !== undefined) {
+            for (const actor of owner.actors) {
+                this.sessionActorPacketTargets.delete(actor);
+            }
+            for (const key of owner.keys) {
+                this.sessionActorPacketTargetsByActor.delete(key);
+            }
+            this.sessionActorPacketTargetOwners.delete(actorId);
+        }
+    }
+    cachedTargetForActor(actor) {
+        const routeKey = sessionActorPacketTargetTenureKey(actor);
+        const actorEntry = this.sessionActorPacketTargets.get(actor);
+        const actorIdEntry = this.sessionActorPacketTargetsByActorId.get(actor.actorId);
+        return (actorEntry?.routeKey === routeKey ? actorEntry.target : undefined)
+            ?? this.sessionActorPacketTargetsByActor.get(routeKey)
+            ?? (actorIdEntry?.routeKey === routeKey ? actorIdEntry.target : undefined)
+            ?? this.targetForActorRef(actor.ref);
+    }
+    targetForState(actorId, routerChannelIdHint) {
+        const state = this.options.actorManager()?.getState(actorId);
+        if (state?.remoteActorPacketTarget !== undefined &&
+            (state.spotId === undefined
+                || (0, routing_id_2.routingIdsEqual)(state.remoteActorPacketTarget.spotId, state.spotId))) {
+            return state.remoteActorPacketTarget;
+        }
+        const spotId = state?.spotId;
+        if (spotId !== undefined && state?.remoteActorPacketTarget !== undefined) {
+            //  The cached packet target refers to a different Spot than the
+            //  actor's current membership (the actor just moved Entry -> User).
+            //  Combining the stale target's node with the new Spot id fabricates
+            //  a route with no complete Ready authority fence, and the next
+            //  direct request then fails the fence check instead of resolving
+            //  the current owner route (spec 12 §direct payload uses the
+            //  Location Store's current owner route; spec 32:87 — an unavailable
+            //  route is Unavailable, not a fabricated hit). Publish no hint so
+            //  the source clears its cache and re-resolves completely.
+            return undefined;
+        }
+        const actorRef = state?.nativeActorRef;
+        const targetNodeRid = actorRef?.nodeRid
+            ?? this.options.primaryNodeRid();
+        const routerChannelId = routerChannelIdHint
+            ?? this.options.meshRouters.defaultSpotRouterChannelId()
+            ?? this.options.meshRouters.defaultRouterChannelId();
+        const localNodeRid = this.options.primaryNodeRid();
+        if (spotId === undefined &&
+            targetNodeRid !== undefined &&
+            localNodeRid !== undefined &&
+            (0, routing_id_2.routingIdsEqual)(targetNodeRid, localNodeRid)) {
+            return undefined;
+        }
+        if (spotId === undefined || targetNodeRid === undefined || routerChannelId === undefined) {
+            return undefined;
+        }
+        return {
+            routerChannelId,
+            targetNodeRid: (0, routing_id_1.normalizeRoutingId)(targetNodeRid),
+            spotId: validateSpotId(spotId),
+            spotKind: contracts_1.ZLinkSpotKind.User,
+            ...(state?.spotGeneration === undefined
+                ? {}
+                : { targetSpotGeneration: state.spotGeneration })
+        };
+    }
+    targetForActorRef(actorRef) {
+        const targetNodeRid = actorRef.nodeRid;
+        const localNodeRid = this.options.primaryNodeRid();
+        if (localNodeRid !== undefined && (0, routing_id_2.routingIdsEqual)(localNodeRid, targetNodeRid)) {
+            return undefined;
+        }
+        const meshName = actorRef.meshName;
+        const routerChannelId = meshName.trim().length === 0
+            ? this.options.meshRouters.defaultSpotRouterChannelId()
+                ?? this.options.meshRouters.defaultRouterChannelId()
+            : this.options.spotRouterChannelIdForMesh(meshName);
+        if (routerChannelId === undefined) {
+            return undefined;
+        }
+        return {
+            routerChannelId,
+            targetNodeRid,
+            spotId: targetNodeRid,
+            spotKind: contracts_1.ZLinkSpotKind.Entry
+        };
+    }
+    tenureKeyForActor(actor) {
+        return sessionActorPacketTargetTenureKey(actor);
+    }
+    tenureKeyForActorRef(actorId, actorRef) {
+        return sessionActorPacketTargetTenureKeyForRef(actorId, actorRef);
+    }
+    rememberActorTarget(actor, target, expectedTenureKey) {
+        if (expectedTenureKey !== undefined
+            && this.tenureKeyForActor(actor) !== expectedTenureKey)
+            return;
+        const state = this.options.actorManager()?.getState(actor.actorId);
+        if (typeof state?.setRemoteActorPacketTarget === 'function') {
+            state.setRemoteActorPacketTarget(target);
+        }
+        this.rememberSessionActorTarget(actor, target);
+    }
+    rememberSessionActorTarget(actor, target) {
+        let owner = this.sessionActorPacketTargetOwners.get(actor.actorId);
+        if (owner === undefined) {
+            owner = { actors: new Set(), keys: new Set() };
+            this.sessionActorPacketTargetOwners.set(actor.actorId, owner);
+        }
+        const key = sessionActorPacketTargetTenureKey(actor);
+        const entry = { routeKey: key, target };
+        owner.actors.add(actor);
+        owner.keys.add(key);
+        this.sessionActorPacketTargets.set(actor, entry);
+        this.sessionActorPacketTargetsByActor.set(key, target);
+        this.sessionActorPacketTargetsByActorId.set(actor.actorId, entry);
+    }
+}
+exports.ZLinkRemoteActorPacketTargetStore = ZLinkRemoteActorPacketTargetStore;
+function sessionActorPacketTargetTenureKey(actor) {
+    return sessionActorPacketTargetTenureKeyForRef(actor.actorId, actor.ref);
+}
+function sessionActorPacketTargetTenureKeyForRef(actorId, actorRef) {
+    const ref = actorRef;
+    return [
+        String(ref.nodeRid),
+        actorId,
+        String(ref.objectGeneration),
+        ref.bindingGeneration?.toString() ?? '',
+        ref.ownershipGeneration?.toString() ?? '',
+        ref.ownerLeaseGeneration?.toString() ?? ''
+    ].join(':');
+}
+function validateSpotId(value) {
+    const byteLength = Buffer.byteLength(value, 'utf8');
+    if (byteLength < 1 || byteLength > 255) {
+        throw new TypeError('SpotId must contain between 1 and 255 UTF-8 bytes.');
+    }
+    return value;
+}

package/dist/runtime/host/remote-bound-session-relay.d.ts

@@ -0,0 +1,58 @@
+import type { ActorRef, RoutingId, ZLinkActor } from '../../contracts';
+import type { ZLinkBackendActorSessionNode } from '../backend';
+import { type ZLinkActorRoutedJoinTransport, type ZLinkRemoteActorPacketTarget, type ZLinkRemoteBoundSessionTarget } from '../actors';
+import type { DefaultZLinkActorManager } from '../actors';
+import type { ZLinkRemoteBoundSessionPort, ZLinkStreamActorLookupPort } from '../streams/stream-binding-runtime-ports';
+import type { DefaultZLinkBoundSession } from '../streams/session-context';
+import type { ZLinkActorResponseOptions } from '../spots/spot-actor-packet-dispatch';
+import type { MeshRouterResolver } from './mesh-router-resolver';
+import { type ServiceSessionRelocationRoute, type ServiceSessionRelocationSeal, type ServiceSessionRelocationSealed } from '../foundation/service-stateful-wire-codec';
+export interface ZLinkRemoteBoundSessionRelayOptions {
+    readonly requestTimeoutMs?: number;
+    readonly sessionRelocationSealTimeoutMs: number;
+    readonly routeTransport: ZLinkActorRoutedJoinTransport;
+    readonly streamBindingRuntime: () => ZLinkRemoteBoundSessionPort & ZLinkStreamActorLookupPort;
+    readonly actorManager: () => DefaultZLinkActorManager | undefined;
+    readonly meshRouters: MeshRouterResolver;
+    readonly actorSessionNode?: (actorId: string) => ZLinkBackendActorSessionNode | undefined;
+    readonly destroyedActorRefs: ReadonlyMap<string, ActorRef>;
+    readonly boundSessionFactory: (actorId: string) => DefaultZLinkBoundSession;
+    readonly updateRemoteActorPacketTarget: (actorId: string, value: unknown) => Promise<void>;
+    readonly actorPacketTargetForState: (actorId: string, routerChannelIdHint?: string) => ZLinkRemoteActorPacketTarget | undefined;
+    readonly reportOwnershipRefreshError?: (actorId: string, error: unknown) => void;
+}
+export declare class ZLinkRemoteBoundSessionRelay {
+    private readonly options;
+    private readonly actorOwnershipGenerations;
+    private readonly activeServiceWireRelocations;
+    private readonly terminalServiceWireRelocations;
+    constructor(options: ZLinkRemoteBoundSessionRelayOptions);
+    receiveRoutedBoundSession(actorId: string, message: unknown, packetName: string | undefined, metadata: ReadonlyMap<string, string>, actorRef?: ActorRef, actorPacketTarget?: unknown): Promise<void>;
+    receiveRoutedBoundSessionResponse(actorId: string, packetName: string, requestSeq: bigint, message: unknown, replyOptions: ZLinkActorResponseOptions, actorPacketTarget?: unknown): Promise<void>;
+    receiveRoutedBoundSessionError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>, actorPacketTarget?: unknown): Promise<void>;
+    receiveRemoteBoundSessionSend(payload: unknown): Promise<{
+        readonly ok: boolean;
+    }>;
+    private deliverRemoteBoundSessionSend;
+    receiveRemoteBoundSessionResponse(payload: unknown): Promise<{
+        readonly ok: boolean;
+    }>;
+    receiveRemoteBoundSessionError(payload: unknown): Promise<{
+        readonly ok: boolean;
+    }>;
+    receiveServiceWireSessionRelocationSeal(value: ServiceSessionRelocationSeal, signal?: AbortSignal): Promise<ServiceSessionRelocationSealed>;
+    receiveServiceWireSessionRelocationRoute(value: ServiceSessionRelocationRoute): Promise<void>;
+    clearServiceWireSessionRelocations(): void;
+    private warnLateSessionRouteUpdate;
+    private applyServiceWireSessionRelocationRoute;
+    private validateServiceWireSessionRoute;
+    rememberRemoteBoundSessionTarget(actorId: string, target: ZLinkRemoteBoundSessionTarget | undefined): void;
+    resolveRemoteBoundSessionTarget(sourceNodeRid: RoutingId, sourceSessionRid: RoutingId): ZLinkRemoteBoundSessionTarget | undefined;
+    actorPacketTargetForState(actorId: string, routerChannelIdHint?: string): ZLinkRemoteActorPacketTarget | undefined;
+    clearOwnership(actorId: string): void;
+    sendActorResponse(actor: ZLinkActor, packetName: string, requestSeq: bigint, response: unknown, replyOptions: ZLinkActorResponseOptions, fallbackBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, signal?: AbortSignal): Promise<void>;
+    sendActorError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>, fallbackBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, signal?: AbortSignal): Promise<void>;
+    private sendRemoteBoundSessionResponse;
+    private sendRemoteBoundSessionError;
+    private sendRemoteBoundSessionControl;
+}