@zlink-systems/framework 0.10.0

package/dist/runtime/host/channel-runtime-options-factory.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkChannelRuntimeOptionsFactory = void 0;
+const actors_1 = require("../actors");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+class ZLinkChannelRuntimeOptionsFactory {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    create() {
+        return {
+            monitoringAdapter: this.options.monitoringAdapter,
+            messageFlowModeCell: this.options.messageFlowModeCell,
+            applicationJobQueue: this.options.applicationJobQueue,
+            oneWayFailureSink: this.options.oneWayFailureSink,
+            internalRouteSendHandlers: this.internalRouteSendHandlers(),
+            internalRouteRequestHandlers: this.internalRouteRequestHandlers(),
+            localSpotRouteDispatcher: {
+                send: async (spotId, packetName, message, routeContext) => {
+                    await this.requireSpotManager().dispatchRoutedSpotSend(spotId, packetName, message, routeContext);
+                },
+                request: async (spotId, packetName, request, routeContext) => await this.requireSpotManager().dispatchRoutedSpotRequest(spotId, packetName, request, routeContext)
+            }
+        };
+    }
+    internalRouteSendHandlers() {
+        return new Map([
+            [actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET, {
+                    handle: async (payload) => {
+                        const { ok } = await this.options.boundSessionRelay.boundSessions
+                            .receiveRemoteBoundSessionSend(payload);
+                        if (!ok) {
+                            // A rejected relocation-fenced outbound must not read as a
+                            // completed flow: surface it so the dispatch pipeline records
+                            // an error terminal instead of silently dropping the notify.
+                            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RelocationFailed, `Bound-session send for '${actors_1.ZLINK_REMOTE_BOUND_SESSION_SEND_PACKET}' was rejected by the Session binding registry.`);
+                        }
+                    }
+                }],
+            [actors_1.ZLINK_REMOTE_BOUND_SESSION_RESPONSE_PACKET, {
+                    handle: async (payload) => {
+                        await this.options.boundSessionRelay.boundSessions.receiveRemoteBoundSessionResponse(payload);
+                    }
+                }],
+            [actors_1.ZLINK_REMOTE_BOUND_SESSION_ERROR_PACKET, {
+                    handle: async (payload) => {
+                        await this.options.boundSessionRelay.boundSessions.receiveRemoteBoundSessionError(payload);
+                    }
+                }],
+            [actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, {
+                    handle: async (payload, routeContext) => {
+                        await this.options.boundSessionRelay.actorPackets.receiveRemoteActorPacketRelay(payload, routeContext);
+                    }
+                }]
+        ]);
+    }
+    internalRouteRequestHandlers() {
+        return new Map([
+            [actors_1.ZLINK_REMOTE_ACTOR_JOIN_PACKET, {
+                    handle: (payload, routeContext) => this.options.boundSessionRelay.actorJoins.receive(payload, routeContext)
+                }],
+            [actors_1.ZLINK_REMOTE_ACTOR_PACKET_RELAY_PACKET, {
+                    handle: (payload, routeContext) => this.options.boundSessionRelay.actorPackets.receiveRemoteActorPacketRelay(payload, routeContext)
+                }]
+        ]);
+    }
+    requireSpotManager() {
+        const manager = this.options.spotManager();
+        if (manager === undefined) {
+            throw new Error('Local SPOT route dispatch requires ZLINK_SPOT_MANAGER.');
+        }
+        return manager;
+    }
+}
+exports.ZLinkChannelRuntimeOptionsFactory = ZLinkChannelRuntimeOptionsFactory;

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

@@ -0,0 +1,30 @@
+import type { ActorRef, ZLinkActor } from '../../contracts';
+import type { Message } from '../../contracts/Common/Message';
+import type { ZLinkBackendSpotNode } from '../backend';
+import type { DefaultZLinkActorManager, ZLinkRemoteBoundSessionTarget } from '../actors';
+import type { DefaultZLinkSpotManager, ZLinkSpotNodeRuntimeManager } from '../spots';
+import type { ZLinkEntryActorRuntime } from '../spots/spot-runtime-ports';
+import type { ZLinkStreamActorLifecyclePort } from '../streams/stream-binding-runtime-ports';
+import type { ZLinkBoundSessionRelay } from './bound-session-relay';
+export interface ZLinkEntryActorRuntimeOptions {
+    readonly actorManager: () => DefaultZLinkActorManager | undefined;
+    readonly spotManager: () => DefaultZLinkSpotManager | undefined;
+    readonly spotNodeRuntime: () => ZLinkSpotNodeRuntimeManager | undefined;
+    readonly streamBindingRuntime: Pick<ZLinkStreamActorLifecyclePort, 'refreshActor'>;
+    readonly boundSessionRelay: ZLinkBoundSessionRelay;
+    readonly reportPostCommitError?: (error: unknown) => void;
+    readonly shutdownSignal?: () => AbortSignal | undefined;
+}
+export declare class ZLinkEntryActorRuntimeService implements ZLinkEntryActorRuntime {
+    private readonly options;
+    private readonly binder;
+    constructor(options: ZLinkEntryActorRuntimeOptions);
+    resolveActor(actorId: string): ZLinkActor | undefined;
+    commitActorTransaction(actor: ZLinkActor, onJoined: () => Promise<void>): Promise<void>;
+    destroyActor(node: ZLinkBackendSpotNode, entryNodeRid: ActorRef['nodeRid'], actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
+    routePacket(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef): Promise<{
+        readonly handled: boolean;
+        readonly response?: unknown;
+    }>;
+    private requireActorManager;
+}

package/dist/runtime/host/entry-actor-runtime.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLinkEntryActorRuntimeService = void 0;
+const post_commit_actor_binder_1 = require("../actors/post-commit-actor-binder");
+class ZLinkEntryActorRuntimeService {
+    options;
+    binder;
+    constructor(options) {
+        this.options = options;
+        this.binder = new post_commit_actor_binder_1.ZLinkPostCommitActorBinder({
+            bind: (actorRef) => options.streamBindingRuntime.refreshActor(actorRef),
+            reportError: options.reportPostCommitError,
+            signal: options.shutdownSignal
+        });
+    }
+    resolveActor(actorId) {
+        return this.options.actorManager()?.getState(actorId)?.actor;
+    }
+    async commitActorTransaction(actor, onJoined) {
+        const state = this.options.actorManager()?.getState(actor.context.actorId);
+        const entryNode = this.options.spotNodeRuntime()?.primaryMeshNode;
+        if (state === undefined) {
+            throw new Error(`Entry Spot actor '${actor.context.actorId}' state is not available.`);
+        }
+        if (entryNode === undefined) {
+            throw new Error('Entry Spot actor commit requires a started SPOT node runtime.');
+        }
+        const actorRef = {
+            // Preserve Core's binary routing identity. Converting the binding value
+            // to its display string would make a later RoutingId.from(...) call
+            // interpret the hexadecimal display as different literal bytes.
+            nodeRid: entryNode.status().routingId,
+            actorId: actor.context.actorId,
+            generation: state.nativeActorRef?.generation ?? 0n
+        };
+        state.clearJoinedSpot();
+        state.setNativeActorRef(actorRef);
+        let callbackError;
+        try {
+            await onJoined();
+        }
+        catch (error) {
+            callbackError = error;
+        }
+        const committedState = this.options.actorManager()?.getState(actor.context.actorId);
+        if (committedState?.actor === actor) {
+            this.options.boundSessionRelay.clearRemoteActorPacketTarget(actor.context.actorId);
+            this.binder.bindEventually({
+                actorId: actorRef.actorId,
+                objectGeneration: actorRef.generation,
+                meshName: actor.context.meshName,
+                nodeRid: actorRef.nodeRid
+            });
+        }
+        if (callbackError !== undefined)
+            throw callbackError;
+    }
+    async destroyActor(node, entryNodeRid, actor, signal) {
+        await this.requireActorManager().destroyActor(node, entryNodeRid, actor, signal);
+    }
+    async routePacket(actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) {
+        const spotManager = this.options.spotManager();
+        const spotId = this.options.actorManager()?.getState(actorId)?.spotId;
+        if (spotId === undefined || spotManager === undefined) {
+            return { handled: false };
+        }
+        return {
+            handled: true,
+            response: await spotManager.dispatchRoutedActorPacket(spotId, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef)
+        };
+    }
+    requireActorManager() {
+        const manager = this.options.actorManager();
+        if (manager === undefined) {
+            throw new Error('Entry Spot actor destroy requires ZLINK_ACTOR_MANAGER.');
+        }
+        return manager;
+    }
+}
+exports.ZLinkEntryActorRuntimeService = ZLinkEntryActorRuntimeService;

package/dist/runtime/host/host-capacity-status.d.ts

@@ -0,0 +1,11 @@
+import { type CoreHwmBudgetSnapshot } from '@zlink-systems/zlink';
+import { type ZLinkHostCapacityStatus } from '../../contracts';
+import type { ZLinkCoreHwmOptions } from '../../contracts/Configuration/RegistrationTypes';
+import type { ApplicationJobQueue } from './application-job-queue';
+export declare class HostCapacityStatusProjection {
+    private readonly coreOptions;
+    private readonly applicationJobQueue;
+    constructor(coreOptions: ZLinkCoreHwmOptions | undefined, applicationJobQueue: ApplicationJobQueue);
+    snapshot(core: CoreHwmBudgetSnapshot | undefined): ZLinkHostCapacityStatus;
+    reset(resetCore: () => void): void;
+}

package/dist/runtime/host/host-capacity-status.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostCapacityStatusProjection = void 0;
+const zlink_1 = require("@zlink-systems/zlink");
+const contracts_1 = require("../../contracts");
+class HostCapacityStatusProjection {
+    coreOptions;
+    applicationJobQueue;
+    constructor(coreOptions, applicationJobQueue) {
+        this.coreOptions = coreOptions;
+        this.applicationJobQueue = applicationJobQueue;
+    }
+    snapshot(core) {
+        return Object.freeze({
+            measurementEpoch: core?.measurementEpoch ?? 0n,
+            coreHwm: projectCoreHwm(this.coreOptions, core),
+            applicationJobQueue: projectApplicationJobQueue(this.applicationJobQueue)
+        });
+    }
+    reset(resetCore) {
+        resetCore();
+        this.applicationJobQueue.resetMetrics();
+    }
+}
+exports.HostCapacityStatusProjection = HostCapacityStatusProjection;
+function projectApplicationJobQueue(queue) {
+    const snapshot = queue.snapshot();
+    return Object.freeze({
+        configuredProfile: snapshot.configuredProfile,
+        configuredManualMax: snapshot.configuredManualMax,
+        configuredPauseThresholdPercent: snapshot.configuredPauseThresholdPercent,
+        configuredResumeThresholdPercent: snapshot.configuredResumeThresholdPercent,
+        effectiveProcessorCount: snapshot.effectiveProcessorCount,
+        effectiveMaxQueuedApplicationJobs: snapshot.effectiveMaxQueuedApplicationJobs,
+        pausePermitCount: snapshot.pausePermitCount,
+        resumePermitCount: snapshot.resumePermitCount,
+        reservedSupplyPermits: snapshot.reservedSupplyPermits,
+        queuedApplicationJobs: snapshot.queuedApplicationJobs,
+        permitsInUse: snapshot.permitsInUse,
+        peakPermitsInUse: snapshot.peakPermitsInUse,
+        pressureState: snapshot.pressureState,
+        currentPauseDurationSeconds: snapshot.currentPauseDurationSeconds,
+        capacityWaiters: snapshot.capacityWaiters,
+        capacityWaitCount: snapshot.capacityWaitCount,
+        capacityWaitDurationSeconds: snapshot.capacityWaitDurationSeconds
+    });
+}
+function projectCoreHwm(options, snapshot) {
+    return Object.freeze({
+        configuredMemoryLimitBytes: options?.memoryLimitBytes,
+        configuredBudgetBytes: options?.budgetBytes,
+        configuredProfile: projectCoreProfile(options?.profile),
+        effectiveBudgetBytes: snapshot?.effectiveCoreBudgetBytes ?? 0n,
+        totalAppliedHwmBytes: snapshot?.totalAppliedHwmBytes ?? 0n,
+        coreQueueAccountedBytes: snapshot?.coreQueueAccountedBytes ?? 0n,
+        applicationAccountedBytes: snapshot?.applicationAccountedBytes ?? 0n,
+        currentAccountedBytes: snapshot?.currentAccountedBytes ?? 0n,
+        provisionalAccountedBytes: snapshot?.provisionalAccountedBytes ?? 0n,
+        peakAccountedBytes: snapshot?.peakAccountedBytes ?? 0n,
+        completionCurrentAccountedBytes: snapshot?.completionCurrentAccountedBytes ?? 0n,
+        completionPeakAccountedBytes: snapshot?.completionPeakAccountedBytes ?? 0n,
+        completionPendingMessageCount: snapshot?.completionPendingMessageCount ?? 0n,
+        totalMessagingAccountedBytes: snapshot?.totalMessagingAccountedBytes ?? 0n,
+        monitorQueueAppliedHwmBytes: snapshot?.monitorQueueAppliedHwmBytes ?? 0n,
+        monitorQueueAccountedBytes: snapshot?.monitorQueueAccountedBytes ?? 0n,
+        totalInstanceAppliedHwmBytes: snapshot?.totalInstanceAppliedHwmBytes ?? 0n,
+        totalInstanceAccountedBytes: snapshot?.totalInstanceAccountedBytes ?? 0n,
+        blockedRatioPpm: BigInt(Math.trunc(snapshot?.blockedRatioPpm ?? 0)),
+        activeDirectionalQueueCount: snapshot?.activeDirectionalQueueCount ?? 0n,
+        activeCompletionDirectionalQueueCount: snapshot?.activeCompletionDirectionalQueueCount ?? 0n,
+        activeSendQueueCount: snapshot?.activeSendQueueCount ?? 0n,
+        activeReceiveQueueCount: snapshot?.activeReceiveQueueCount ?? 0n,
+        outstandingApplicationLeaseCount: snapshot?.outstandingApplicationLeaseCount ?? 0n,
+        retiredQueueCount: snapshot?.retiredQueueCount ?? 0n,
+        deferredOriginCreditBytes: snapshot?.deferredOriginCreditBytes ?? 0n
+    });
+}
+function projectCoreProfile(value) {
+    switch (value ?? zlink_1.AutoHwmProfile.Balanced) {
+        case zlink_1.AutoHwmProfile.Compact: return contracts_1.ZLinkCoreHwmProfile.Compact;
+        case zlink_1.AutoHwmProfile.LowLatency: return contracts_1.ZLinkCoreHwmProfile.LowLatency;
+        case zlink_1.AutoHwmProfile.Throughput: return contracts_1.ZLinkCoreHwmProfile.Throughput;
+        default: return contracts_1.ZLinkCoreHwmProfile.Balanced;
+    }
+}

package/dist/runtime/host/index.d.ts

@@ -0,0 +1,188 @@
+import type { ZLinkBackendContext, ZLinkBackendMeshNode } from '../backend';
+import type { ZLinkFrameworkRegistration } from '../configuration';
+import type { ZLinkMeshNodeDescriptor, ZLinkClientServerRuntime, ZLinkFanoutRuntime, ZLinkFrameworkRuntime, ZLinkFrameworkLifecycleOptions, ZLinkFrameworkRelocationOptions, ZLinkFrameworkRelocationResult, ZLinkObservedStatus, ZLinkFrameworkRuntimeStatus, ZLinkFrameworkTerminationResult, ZLinkRouteMeshRuntime } from '../../contracts';
+import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
+import type { ZLinkRuntimeEventPublisher } from '../diagnostics';
+import type { ZLinkMessageFlowControl, ZLinkMessageFlowLogMode } from '../../contracts';
+import { DefaultZLinkChannelRuntimeOptions, ZLinkChannelRuntimeManager, ZLinkRuntimeRouteTransport } from '../channels';
+import { ZLinkFrameworkExecutionState } from '../execution';
+import { DefaultZLinkSpotManager, ZLinkRuntimeSpotPublisherTransport, type ZLinkSpotManagerOptions } from '../spots';
+import type { DefaultZLinkActorManager, ZLinkActorManagerOptions } from '../actors';
+import { DefaultZLinkActorClient } from '../actors';
+import { DefaultZLinkBoundSessionFactory, ZLinkStreamBindingRuntime } from '../streams';
+import { type ZLinkStoreLocationResolvers } from '../locations';
+import { type ZLinkLocationRuntimeQuery } from '../../contracts/Locations';
+import { ZLinkHostSpotAddressTransport } from './spot-address-transport';
+import { DefaultZLinkRouteMeshRuntimeOptions } from './route-mesh-runtime-options';
+export interface ZLinkFrameworkRuntimeLifecycle {
+    readonly isStarted: boolean;
+    readonly locationRuntimeQuery?: ZLinkLocationRuntimeQuery;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export interface ZLinkFrameworkRuntimeHostOptions {
+    readonly registration: ZLinkFrameworkRegistration;
+    readonly lifecycleSink?: string[];
+    readonly providerResolver?: ZLinkProviderResolver;
+    readonly runtimeEventPublisher?: ZLinkRuntimeEventPublisher;
+}
+export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeLifecycle, ZLinkFrameworkRuntime, ZLinkMessageFlowControl {
+    readonly options: ZLinkFrameworkRuntimeHostOptions;
+    private readonly backendAdapterFactory;
+    private readonly lifecycleSink?;
+    private executionState?;
+    private runtimeState;
+    private runtimeSequence;
+    private readonly runtimeObservationSource;
+    private runtimeDeadline?;
+    private runtimeRelocationResult?;
+    private runtimeTerminationResult?;
+    private relocationOperation?;
+    private relocationStopStarting?;
+    private relocationOperationKey?;
+    private relocationOperationStartedAt?;
+    private shutdownOperation?;
+    private shutdownOperationStartedAt?;
+    private relocationTargetApplicationVersion?;
+    private readonly runtimeObservers;
+    private channelRuntime?;
+    private spotNodeRuntime?;
+    private streamRuntime?;
+    private statefulAuthorityRoutes?;
+    private readonly locationOwner;
+    private readonly meshRouters;
+    private readonly boundSessionRelay;
+    private readonly actorHandoff;
+    private readonly actorTransferRegistry;
+    private readonly actorTransferRuntime;
+    private readonly actorTransferAuthorityRuntime;
+    private readonly serviceRelocation;
+    private readonly entryActorRuntime;
+    private actorManager?;
+    private actorPlacement?;
+    private spotManager?;
+    private ownerLeaseRecoveryRuntime?;
+    private ownerLeaseRecoveryHandler?;
+    private ownerLeaseFailureHandler?;
+    private registerUserSpotHandlers?;
+    private readonly destroyedActorRefs;
+    private readonly runtimeEventPublisher;
+    private readonly metrics;
+    private readonly applicationJobQueue;
+    private readonly capacityStatus;
+    private readonly metricRegistrations;
+    private readonly admission;
+    private cachedLocationSpotRouteResolver?;
+    private actorClientLocationResolver?;
+    private readonly messageFlowModeCell;
+    private readonly dispatchErrorReporters;
+    private readonly runtimeOrPreStartErrorSink;
+    private cachedDiagnosticsContext?;
+    private readonly preStartErrorSink;
+    readonly channelTransport: () => ZLinkChannelRuntimeManager | undefined;
+    readonly channelRuntimeOptions: DefaultZLinkChannelRuntimeOptions;
+    readonly routeMeshRuntimeOptions: DefaultZLinkRouteMeshRuntimeOptions;
+    readonly routeTransport: ZLinkRuntimeRouteTransport;
+    readonly spotAddressTransport: ZLinkHostSpotAddressTransport;
+    readonly spotPublisherTransport: ZLinkRuntimeSpotPublisherTransport;
+    readonly streamBindingRuntime: ZLinkStreamBindingRuntime;
+    readonly boundSessionFactory: DefaultZLinkBoundSessionFactory;
+    readonly spotRouterChannelIdForMesh: (meshName: string) => string;
+    readonly routeMeshRuntime: ZLinkRouteMeshRuntime;
+    readonly clientServerRuntime: ZLinkClientServerRuntime;
+    readonly fanoutRuntime: ZLinkFanoutRuntime;
+    private readonly routeMeshCoordinator;
+    constructor(options: ZLinkFrameworkRuntimeHostOptions, internalOptions?: unknown);
+    get isStarted(): boolean;
+    get status(): ZLinkFrameworkRuntimeStatus;
+    observe(signal?: AbortSignal): AsyncIterable<ZLinkObservedStatus<ZLinkFrameworkRuntimeStatus>>;
+    resetCapacityMetrics(): void;
+    relocate(options: ZLinkFrameworkRelocationOptions): Promise<ZLinkFrameworkRelocationResult>;
+    shutdown(options?: ZLinkFrameworkLifecycleOptions): Promise<ZLinkFrameworkTerminationResult>;
+    private runRelocation;
+    private runShutdown;
+    private resetBlockedRelocation;
+    private completeRelocation;
+    private recordRelocationResult;
+    private completeTermination;
+    private setRuntimeState;
+    private notifyTopologyHostStateChanged;
+    private stopTopologyObservers;
+    private publishActorHandoffEvent;
+    get locationRuntimeQuery(): ZLinkLocationRuntimeQuery | undefined;
+    /**
+     * Runtime toggle (ZLinkMessageFlowControl): flip the shared live-mode cell so every
+     * surface starts/stops tracing without a restart. Do not call this synchronous
+     * bridge from a framework execution context such as a handler or callback; use
+     * setMessageFlowModeAsync there.
+     */
+    setMessageFlowMode(mode: ZLinkMessageFlowLogMode): void;
+    setMessageFlowModeAsync(mode: ZLinkMessageFlowLogMode): Promise<void>;
+    messageFlowMode(): ZLinkMessageFlowLogMode;
+    get context(): ZLinkBackendContext | undefined;
+    get taskRunner(): ZLinkFrameworkExecutionState['taskRunner'] | undefined;
+    get errorSink(): ZLinkFrameworkExecutionState['errorSink'] | undefined;
+    start(): Promise<void>;
+    private startCore;
+    stop(): Promise<void>;
+    private runtimeMetricMeshSnapshots;
+    private stopCore;
+    private installOwnerLeaseRecoveryPublication;
+    private createStatefulAuthorityRoutes;
+    private requiresStatefulAuthorityRuntime;
+    private installLocationBackedAuthorities;
+    private removeOwnerLeaseRecoveryPublication;
+    onApplicationBootstrap(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    private performMeshDrain;
+    private performMeshShutdown;
+    private publishMeshRetiring;
+    private publishMeshServing;
+    private publishMeshDraining;
+    private preflightAutomaticPeerReadiness;
+    private hasLocalStatefulRelocationWork;
+    private hasExactAutomaticPeerReadiness;
+    private publishHostRelocated;
+    private publishHostDraining;
+    private cleanupOwnerForDrain;
+    private forceStopMesh;
+    private registerInstanceApplicationLifecycle;
+    setActorManager(actorManager: DefaultZLinkActorManager): void;
+    setSpotManager(spotManager: DefaultZLinkSpotManager): void;
+    createActorManagerOptions(): Pick<ZLinkActorManagerOptions, 'joinCoordinator' | 'actorMeshNameProvider' | 'actorLeaveSpot' | 'messageSerializers' | 'nativeActorNode' | 'nativeActorNodeProvider' | 'actorCreatedNodeRidProvider' | 'actorRefResolver' | 'actorCreatedNotifier' | 'actorDestroyedCleanup' | 'locationLifecycle' | 'boundSessionFactory' | 'shutdownSignal' | 'admission' | 'placementCreate'>;
+    createActorClientOptions(): ConstructorParameters<typeof DefaultZLinkActorClient>[0];
+    createLocationHandleResolver(): ZLinkStoreLocationResolvers | undefined;
+    createSpotManagerOptions(): Partial<ZLinkSpotManagerOptions>;
+    createPublicSpotManager(local: DefaultZLinkSpotManager): import('../../contracts').ZLinkSpotManager;
+    private actorRuntimeOptionsFactory;
+    private createChannelRuntimeOptions;
+    private createSpotNodeRuntimeOptions;
+    private dispatchMeshRecord;
+    private submitLocalMeshRoute;
+    private dispatchMeshSpotRecord;
+    private createDispatchErrorReporter;
+    private detachedTaskRunner;
+    private diagnosticsContext;
+    private flowCreationEnabled;
+    private runLifecycle;
+    requirePrimaryMeshNode(): ZLinkBackendMeshNode;
+    private ensureLocationRuntime;
+    private createLocationSpotRouteResolver;
+    private createActorLocationResolver;
+}
+export declare function hasUnsupportedManualTopology(registration: ZLinkFrameworkRegistration): boolean;
+export declare function hasExactPeerReadiness(descriptors: readonly ZLinkMeshNodeDescriptor[], local: {
+    readonly routingId: unknown;
+    readonly lifecycleGeneration: bigint;
+    readonly applicationVersion?: bigint;
+    readonly maintenanceWave?: string;
+}, peers: readonly {
+    readonly routingId: unknown | null;
+    readonly lifecycleGeneration: bigint;
+    readonly state: number;
+}[]): boolean;
+export { ZLinkActorTransferAuthorityRuntime, transferIdString } from './actor-transfer-authority-runtime';
+export { ZLinkRetiringRollbackError, ZLinkRouteMeshRuntimeCoordinator } from './route-mesh-runtime';
+export { ZLinkRelocationStateIncompatibleError } from './service-relocation-host-runtime';
+export { ZLinkHostSpotAddressTransport, type ZLinkHostSpotAddressTransportOptions } from './spot-address-transport';
+export { ZLinkUserSpotCreationCoordinator, type ZLinkUserSpotCreationCoordinatorOptions, type ZLinkUserSpotCreationRequest, type ZLinkUserSpotCreationResult } from './user-spot-creation-coordinator';