@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/host/application-job-queue.d.ts

@@ -51,6 +51,7 @@ export declare class ApplicationJobQueuePermit implements ApplicationJobPermitPo
     markApplicationQueued(): void;
     releaseBeforeHandler(): void;
     releaseAfterInternalProcessing(): void;
+    releaseUnqueued(): void;
     takeReleaseState(): 'reserved' | 'queued' | undefined;
 }
 /**
@@ -68,6 +69,7 @@ declare class ApplicationJobReceiveRotation implements ApplicationJobReceiveRota
     private consumed;
     constructor(owner: ApplicationJobQueue, capacity: number, origin: ApplicationJobOrigin);
     reserve(): void;
+    acquire(signal: AbortSignal): Promise<void>;
     take(): ApplicationJobQueuePermit | undefined;
     releaseUnused(): void;
     returnIdle(permit: ApplicationJobQueuePermit): void;
@@ -105,13 +107,13 @@ export declare class ApplicationJobQueue implements ApplicationJobQueuePort {
     private readonly receiveFlowController;
     constructor(configuration: ApplicationJobQueueConfiguration, nowMs?: () => number, handlerStartGate?: (() => boolean) | undefined, loggerFailureReporter?: ((error: unknown) => void) | undefined);
     shouldHoldPermitBeforeHandler(): boolean;
-    createReceiveRotation(capacity: number, origin: ApplicationJobOrigin): ApplicationJobReceiveRotationPort;
-    receiveRotationCapacity(capacity: number): number;
-    reserveReceiveRotation(count: number): void;
+    createReceiveRotation(capacity: number, origin: ApplicationJobOrigin): ApplicationJobReceiveRotation;
+    tryReserveCount(requested: number): number | undefined;
     registerReceiveFlowTarget(identity: object, applyState: (state: ApplicationJobQueuePressureState) => void, failureSink?: (error: unknown) => void): boolean;
     unregisterReceiveFlowTarget(identity: object): void;
     acquire(signal: AbortSignal | undefined, origin: ApplicationJobOrigin): Promise<ApplicationJobQueuePermit>;
     acquireOrResume(resume: (permit: ApplicationJobQueuePermit) => void, reject: (reason: unknown) => void, signal: AbortSignal | undefined, origin: ApplicationJobOrigin): ApplicationJobQueuePermit | undefined;
+    acquireCountOrResume(resume: (count: number) => void, reject: (reason: unknown) => void, signal: AbortSignal | undefined, origin: ApplicationJobOrigin, requested: number): number | undefined;
     snapshot(): ApplicationJobQueueSnapshot;
     resetMetrics(): void;
     pressureState(): ApplicationJobQueuePressureState;
@@ -125,13 +127,13 @@ export declare class ApplicationJobQueue implements ApplicationJobQueuePort {
     private limit;
     private permitsInUse;
     private reserveSupply;
-    private reserve;
+    private reserveCount;
     private drainWaiters;
     private cancel;
     private recordCompletedWait;
     private updateLocalWaiters;
     private logLocalBacklog;
-    private evaluatePressure;
+    evaluatePressure(): void;
     private pauseDurationAt;
     private cumulativePauseDurationAt;
 }

package/dist/runtime/host/application-job-queue.js

@@ -4,13 +4,14 @@ exports.ApplicationJobQueue = exports.ApplicationJobQueuePermit = void 0;
 exports.resolveApplicationJobQueueConfiguration = resolveApplicationJobQueueConfiguration;
 exports.nodeEffectiveProcessorCount = nodeEffectiveProcessorCount;
 const api_logs_1 = require("@opentelemetry/api-logs");
-const message_flow_1 = require("../diagnostics/message-flow");
+const message_flow_record_1 = require("../diagnostics/message-flow-record");
 const runtime_metrics_1 = require("../diagnostics/runtime-metrics");
 const Dispatch_1 = require("../../contracts/Dispatch");
 const Registration_1 = require("../../contracts/Configuration/Registration");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const receive_flow_controller_1 = require("../application-jobs/receive-flow-controller");
+const telemetryLogger = api_logs_1.logs.getLogger(message_flow_record_1.TELEMETRY_INSTRUMENTATION_NAME);
 const CGROUP_V2_CPU_MAX = '/sys/fs/cgroup/cpu.max';
 const CGROUP_V1_CPU_QUOTA = '/sys/fs/cgroup/cpu/cpu.cfs_quota_us';
 const CGROUP_V1_CPU_PERIOD = '/sys/fs/cgroup/cpu/cpu.cfs_period_us';
@@ -98,6 +99,10 @@ class ApplicationJobQueuePermit {
     releaseAfterInternalProcessing() {
         this.owner.releasePermit(this);
     }
+    releaseUnqueued() {
+        if (this.state === 'reserved')
+            this.owner.releasePermit(this);
+    }
     takeReleaseState() {
         if (this.state === 'released' || this.state === 'idle')
             return undefined;
@@ -127,11 +132,15 @@ class ApplicationJobReceiveRotation {
     }
     reserve() {
         this.releaseUnused();
-        const count = this.owner.receiveRotationCapacity(this.capacity);
-        if (count === 0)
-            return;
-        this.granted = count;
-        this.owner.reserveReceiveRotation(count);
+        this.granted = this.owner.tryReserveCount(this.capacity) ?? 0;
+    }
+    async acquire(signal) {
+        this.releaseUnused();
+        this.granted = await new Promise((resolve, reject) => {
+            const count = this.owner.acquireCountOrResume(resolve, reject, signal, this.origin, this.capacity);
+            if (count !== undefined)
+                resolve(count);
+        });
     }
     take() {
         if (this.consumed === this.granted)
@@ -201,13 +210,10 @@ class ApplicationJobQueue {
             throw new RangeError('Receive capacity must be positive.');
         return new ApplicationJobReceiveRotation(this, capacity, origin);
     }
-    receiveRotationCapacity(capacity) {
-        if (this.waiters.length !== 0)
-            return 0;
-        return Math.min(capacity, this.limitCount - this.permitsInUse());
-    }
-    reserveReceiveRotation(count) {
-        this.reserveSupply(count);
+    tryReserveCount(requested) {
+        if (this.waiters.length !== 0 || this.permitsInUse() === this.limitCount)
+            return undefined;
+        return this.reserveCount(requested);
     }
     registerReceiveFlowTarget(identity, applyState, failureSink) {
         this.unregisterReceiveFlowTarget(identity);
@@ -257,16 +263,21 @@ class ApplicationJobQueue {
         });
     }
     acquireOrResume(resume, reject, signal, origin) {
+        const count = this.acquireCountOrResume(() => resume(new ApplicationJobQueuePermit(this, origin)), reject, signal, origin, 1);
+        return count === undefined ? undefined : new ApplicationJobQueuePermit(this, origin);
+    }
+    acquireCountOrResume(resume, reject, signal, origin, requested) {
         if (signal?.aborted === true) {
             reject(abortReason(signal));
             return undefined;
         }
-        if (this.waiters.length === 0 && this.permitsInUse() < this.limitCount) {
-            return this.reserve(origin);
-        }
+        const count = this.tryReserveCount(requested);
+        if (count !== undefined)
+            return count;
         new Promise((resolve, reject) => {
             const waiter = {
                 origin,
+                requested,
                 resolve,
                 reject,
                 signal,
@@ -377,9 +388,10 @@ class ApplicationJobQueue {
         if (evaluatePressure)
             this.evaluatePressure();
     }
-    reserve(origin, evaluatePressure = true) {
-        this.reserveSupply(1, evaluatePressure);
-        return new ApplicationJobQueuePermit(this, origin);
+    reserveCount(requested, evaluatePressure = true) {
+        const count = Math.min(requested, this.limitCount - this.permitsInUse());
+        this.reserveSupply(count, evaluatePressure);
+        return count;
     }
     drainWaiters() {
         while (this.waiters.length > 0 && this.permitsInUse() < this.limitCount) {
@@ -389,7 +401,7 @@ class ApplicationJobQueue {
             waiter.active = false;
             waiter.signal?.removeEventListener('abort', waiter.abort);
             this.recordCompletedWait(waiter);
-            waiter.resolve(this.reserve(waiter.origin, false));
+            waiter.resolve(this.reserveCount(waiter.requested, false));
         }
     }
     cancel(waiter) {
@@ -425,7 +437,7 @@ class ApplicationJobQueue {
     }
     logLocalBacklog(localWaiters) {
         try {
-            message_flow_1.telemetryLogger.emit({
+            telemetryLogger.emit({
                 eventName: 'zlink.runtime.host.local_job_backlog_exceeded',
                 timestamp: new Date(),
                 severityNumber: api_logs_1.SeverityNumber.WARN,

package/dist/runtime/host/bound-session-relay.js

@@ -15,7 +15,6 @@ class ZLinkBoundSessionRelay {
             actorManager: options.actorManager,
             streamBindingRuntime: options.streamBindingRuntime,
             meshRouters: options.meshRouters,
-            spotManager: options.spotManager,
             spotNodeRuntime: options.spotNodeRuntime,
             detachedTaskRunner: options.detachedTaskRunner,
             errorSink: options.errorSink,

package/dist/runtime/host/channel-runtime-options-factory.d.ts

@@ -2,11 +2,13 @@ import type { ZLinkChannelRuntimeManagerOptions } from '../channels';
 import type { ZLinkMonitoringBackendAdapter } from '../backend';
 import type { DefaultZLinkSpotManager } from '../spots';
 import type { ZLinkMessageFlowModeCell } from '../diagnostics';
+import type { ZLinkTelemetryLease } from '../diagnostics/message-flow-delivery';
 import type { ZLinkBoundSessionRelay } from './bound-session-relay';
 import type { ApplicationJobQueue } from './application-job-queue';
 export interface ZLinkChannelRuntimeOptionsFactoryOptions {
     readonly monitoringAdapter: ZLinkMonitoringBackendAdapter;
     readonly messageFlowModeCell: ZLinkMessageFlowModeCell;
+    readonly telemetryLease?: ZLinkTelemetryLease;
     readonly boundSessionRelay: ZLinkBoundSessionRelay;
     readonly spotManager: () => DefaultZLinkSpotManager | undefined;
     readonly oneWayFailureSink: (error: unknown) => void;

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

@@ -12,6 +12,7 @@ class ZLinkChannelRuntimeOptionsFactory {
         return {
             monitoringAdapter: this.options.monitoringAdapter,
             messageFlowModeCell: this.options.messageFlowModeCell,
+            telemetryLease: this.options.telemetryLease,
             applicationJobQueue: this.options.applicationJobQueue,
             oneWayFailureSink: this.options.oneWayFailureSink,
             internalRouteSendHandlers: this.internalRouteSendHandlers(),

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

@@ -1,3 +1,6 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
+import type { ZLinkActorRequestTerminal } from '../spots/spot-actor-packet-dispatch';
+import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
 import type { ActorRef, ZLinkActor } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendSpotNode } from '../backend';
@@ -23,9 +26,9 @@ export declare class ZLinkEntryActorRuntimeService implements ZLinkEntryActorRun
     releaseMembers(meshName: string): Promise<void>;
     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<{
+    routePacket(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, origin?: ApplicationJobOrigin, requestTerminal?: ZLinkActorRequestTerminal, messageFollowOrigin?: ZLinkMessageFollowOrigin): {
         readonly handled: boolean;
         readonly response?: unknown;
-    }>;
+    };
     private requireActorManager;
 }

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

@@ -61,7 +61,7 @@ class ZLinkEntryActorRuntimeService {
     async destroyActor(node, entryNodeRid, actor, signal) {
         await this.requireActorManager().destroyActor(node, entryNodeRid, actor, signal);
     }
-    async routePacket(actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) {
+    routePacket(actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, origin = 'remote', requestTerminal, messageFollowOrigin) {
         const spotManager = this.options.spotManager();
         const spotId = this.options.actorManager()?.getState(actorId)?.spotId;
         if (spotId === undefined || spotManager === undefined) {
@@ -69,7 +69,7 @@ class ZLinkEntryActorRuntimeService {
         }
         return {
             handled: true,
-            response: await spotManager.dispatchRoutedActorPacket('remote', spotId, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef)
+            response: spotManager.dispatchRoutedActorPacket(origin, spotId, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin)
         };
     }
     requireActorManager() {

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

@@ -1,16 +1,33 @@
-import { type ZLinkClientServerRuntime, type ZLinkFanoutRuntime, type ZLinkFrameworkLifecycleOptions, type ZLinkFrameworkRelocationOptions, type ZLinkFrameworkRelocationResult, type ZLinkFrameworkRuntime, type ZLinkFrameworkRuntimeStatus, type ZLinkFrameworkTerminationResult, type ZLinkListenerKind, type ZLinkListenerStatus, type ZLinkMeshNodeDescriptor, type ZLinkMessageFlowControl, type ZLinkMessageFlowLogMode, type ZLinkObservedStatus, type ZLinkRouteMeshRuntime } from '../../contracts';
+import { RequestRuntime } from '../foundation/request-runtime';
+import { inspectRuntime } from '../internal-observation';
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
+import { type ZLinkClientServerRuntime, type ZLinkFanoutRuntime, type ZLinkFrameworkLifecycleOptions, type ZLinkFrameworkRelocationOptions, type ZLinkFrameworkRelocationResult, type ZLinkFrameworkRuntime, type ZLinkFrameworkRuntimeStatus, type ZLinkFrameworkTerminationResult, type ZLinkListenerKind, type ZLinkListenerStatus, type ZLinkMeshNodeDescriptor, type ZLinkMessageFlowControl, type ZLinkMessageFlowLogMode, type ZLinkObservedStatus, type ZLinkRouteMeshRuntime, ZLinkFrameworkRelocationReason, ZLinkFrameworkRuntimeState } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import { type ZLinkLocationRuntimeQuery } from '../../contracts/Locations';
 import { type DefaultZLinkActorManager, type ZLinkActorManagerOptions, DefaultZLinkActorClient } from '../actors';
-import { type ZLinkBackendContext, type ZLinkBackendMeshNode } from '../backend';
-import { DefaultZLinkChannelRuntimeOptions, ZLinkChannelRuntimeManager, ZLinkRuntimeRouteTransport } from '../channels';
+import { ZLinkRuntimeAdmissionGate, type ZLinkMeshDispatchAdmission } from '../admission';
+import { type ZLinkBackendAdapterFactory, type ZLinkBackendContext, type ZLinkBackendMeshNode } from '../backend';
+import { type ZLinkBackendMessageLike as MessageLike } from '../backend/runtime-values';
+import { DefaultZLinkChannelRuntimeOptions, ZLinkChannelRuntimeManager, ZLinkDispatchErrorReporter, ZLinkRuntimeRouteTransport, type ZLinkDispatchErrorSink } from '../channels';
 import type { ZLinkFrameworkRegistration } from '../configuration';
-import { type ZLinkRuntimeEventPublisher } from '../diagnostics';
+import { type ZLinkRuntimeEventPublisher, ZLinkRuntimeMetrics, type ZLinkRuntimeMetricMeshSnapshot } from '../diagnostics';
 import { ZLinkFrameworkExecutionState } from '../execution';
-import { type ZLinkStoreLocationResolvers } from '../locations';
-import { DefaultZLinkSpotManager, ZLinkRuntimeSpotPublisherTransport, type ZLinkDetachedTaskRunner, type ZLinkSpotManagerOptions } from '../spots';
+import { ZLinkListenerRecords } from '../foundation/listener-records';
+import { type ReadyRecord, type ReceiveRecord } from '../foundation/service-runtime-contracts';
+import type { ServiceMessageFollowRecord } from '../foundation/service-stateful-wire-codec';
+import { type ZLinkLocationRuntime, type ZLinkStoreLocationResolvers } from '../locations';
+import { ZLinkSubmitStatus } from '../messaging/submission-result';
+import { DefaultZLinkSpotManager, ZLinkRuntimeSpotPublisherTransport, ZLinkSpotNodeRuntimeManager, type ZLinkDetachedTaskRunner, type ZLinkSpotManagerOptions } from '../spots';
+import type { ZLinkSpotRouteResolver } from '../spots/spot-routing-internal';
 import { DefaultZLinkBoundSessionFactory, ZLinkStreamBindingRuntime } from '../streams';
+import { ZLinkActorPlacementCoordinator } from './actor-placement-coordinator';
+import { ApplicationJobQueue } from './application-job-queue';
+import { ZLinkBoundSessionRelay } from './bound-session-relay';
+import { ZLinkEntryActorRuntimeService } from './entry-actor-runtime';
+import { ZLinkLocationRuntimeOwner } from './location-runtime-owner';
+import { ZLinkRouteMeshRuntimeCoordinator } from './route-mesh-runtime';
 import { DefaultZLinkRouteMeshRuntimeOptions } from './route-mesh-runtime-options';
+import { ZLinkHostServiceRelocationRuntime } from './service-relocation-host-runtime';
 import { ZLinkHostSpotAddressTransport } from './spot-address-transport';
 export interface ZLinkFrameworkRuntimeLifecycle {
     readonly isStarted: boolean;
@@ -26,10 +43,23 @@ export interface ZLinkFrameworkRuntimeHostOptions {
 }
 export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeLifecycle, ZLinkFrameworkRuntime, ZLinkMessageFlowControl {
     readonly options: ZLinkFrameworkRuntimeHostOptions;
+    [inspectRuntime](): Readonly<{
+        ownerLeaseUsable: boolean | undefined;
+        ownerId: string | undefined;
+        hasOwnerToken: boolean;
+        ownerAdmissionOpen: boolean;
+        channelRuntimeStarted: boolean;
+        fanoutStoreIsLocationStore: boolean;
+        fanoutStoreMethods: Readonly<{
+            update: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            remove: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            list: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        }>;
+    }>;
     private readonly backendAdapterFactory;
     private readonly lifecycleSink?;
-    private executionState?;
-    private runtimeState;
+    executionState?: ZLinkFrameworkExecutionState;
+    runtimeState: ZLinkFrameworkRuntimeState;
     private runtimeStatus?;
     private readonly runtimeObservationSource;
     private runtimeDeadline?;
@@ -44,21 +74,21 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private shutdownOperationStartedAt?;
     private relocationTargetApplicationVersion?;
     private readonly runtimeObservers;
-    private channelRuntime?;
-    private spotNodeRuntime?;
+    channelRuntime?: ZLinkChannelRuntimeManager;
+    spotNodeRuntime?: ZLinkSpotNodeRuntimeManager;
     private streamRuntime?;
     private statefulAuthorityRoutes?;
-    private readonly locationOwner;
+    readonly locationOwner: ZLinkLocationRuntimeOwner;
     private readonly meshRouters;
-    private readonly boundSessionRelay;
+    readonly boundSessionRelay: ZLinkBoundSessionRelay;
     private readonly actorHandoff;
     private readonly actorTransferRegistry;
     private readonly actorTransferRuntime;
     private readonly actorTransferAuthorityRuntime;
-    private readonly serviceRelocation;
-    private readonly entryActorRuntime;
+    readonly serviceRelocation: ZLinkHostServiceRelocationRuntime;
+    readonly entryActorRuntime: ZLinkEntryActorRuntimeService;
     private actorManager?;
-    private actorPlacement?;
+    actorPlacement?: ZLinkActorPlacementCoordinator;
     private spotManager?;
     private userSpotCoordinator?;
     private ownerLeaseRecoveryRuntime?;
@@ -67,21 +97,23 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private readonly destroyedActorRefs;
     private readonly runtimeEventPublisher;
     private readonly metrics;
-    private readonly applicationJobQueue;
+    readonly applicationJobQueue: ApplicationJobQueue;
     private readonly capacityStatus;
     private readonly metricRegistrations;
-    private readonly admission;
+    readonly admission: ZLinkRuntimeAdmissionGate;
     private readonly activationAdmission;
     private cachedLocationSpotRouteResolver?;
     private actorClientLocationResolver?;
     private readonly messageFlowModeCell;
-    private readonly dispatchErrorReporters;
-    private readonly runtimeOrPreStartErrorSink;
+    private telemetryLease;
+    private dispatchErrorReporters;
+    readonly runtimeOrPreStartErrorSink: ZLinkDispatchErrorSink;
     private cachedDiagnosticsContext?;
     private readonly preStartErrorSink;
     readonly channelTransport: () => ZLinkChannelRuntimeManager | undefined;
     readonly channelRuntimeOptions: DefaultZLinkChannelRuntimeOptions;
     readonly routeMeshRuntimeOptions: DefaultZLinkRouteMeshRuntimeOptions;
+    private readonly requests;
     readonly routeTransport: ZLinkRuntimeRouteTransport;
     readonly spotAddressTransport: ZLinkHostSpotAddressTransport;
     readonly spotPublisherTransport: ZLinkRuntimeSpotPublisherTransport;
@@ -92,7 +124,7 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     readonly clientServerRuntime: ZLinkClientServerRuntime;
     readonly fanoutRuntime: ZLinkFanoutRuntime;
     private readonly relocationStore?;
-    private readonly routeMeshCoordinator;
+    readonly routeMeshCoordinator: ZLinkRouteMeshRuntimeCoordinator;
     constructor(options: ZLinkFrameworkRuntimeHostOptions, internalOptions?: unknown);
     get isStarted(): boolean;
     get status(): ZLinkFrameworkRuntimeStatus;
@@ -132,17 +164,17 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     start(): Promise<void>;
     private startCore;
     stop(): Promise<void>;
-    private runtimeMetricMeshSnapshots;
+    runtimeMetricMeshSnapshots(): readonly ZLinkRuntimeMetricMeshSnapshot[];
     private stopCore;
-    private installOwnerLeaseRecoveryPublication;
-    private resumeOwnerLeaseOwnedWork;
-    private enterServing;
+    installOwnerLeaseRecoveryPublication(runtime: ZLinkLocationRuntime, spotNodeRuntime: ZLinkSpotNodeRuntimeManager, channelRuntime: ZLinkChannelRuntimeManager): void;
+    resumeOwnerLeaseOwnedWork(runtime: ZLinkLocationRuntime, spotNodeRuntime: ZLinkSpotNodeRuntimeManager, channelRuntime: ZLinkChannelRuntimeManager): Promise<void>;
+    enterServing(spotNodeRuntime: ZLinkSpotNodeRuntimeManager, signal: AbortSignal | undefined): Promise<void>;
     private publishOrStayPreparing;
-    private startStatefulAuthority;
+    startStatefulAuthority(locationStore: import('../locations/domain-store-contract').ZLinkDomainLocationStore, spotNodeRuntime: ZLinkSpotNodeRuntimeManager, signal: AbortSignal | undefined): Promise<void>;
     private createStatefulAuthorityRoutes;
     private requiresStatefulAuthorityRuntime;
     private installLocationBackedAuthorities;
-    private removeOwnerLeaseRecoveryPublication;
+    removeOwnerLeaseRecoveryPublication(): void;
     private ownerAdmissionOpen;
     onApplicationBootstrap(): Promise<void>;
     onApplicationShutdown(): Promise<void>;
@@ -151,10 +183,10 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     private publishMeshRetiring;
     private publishMeshServing;
     private publishMeshDraining;
-    private preflightAutomaticPeerReadiness;
+    preflightAutomaticPeerReadiness(deadlineAt: number, targetApplicationVersion: bigint): Promise<ZLinkFrameworkRelocationReason | undefined>;
     private hasLocalStatefulRelocationWork;
     private hasExactAutomaticPeerReadiness;
-    private publishHostRelocated;
+    publishHostRelocated(): Promise<void>;
     private publishHostDraining;
     private cleanupOwnerForDrain;
     private registerInstanceApplicationLifecycle;
@@ -167,24 +199,61 @@ export declare class ZLinkFrameworkRuntimeHost implements ZLinkFrameworkRuntimeL
     createPublicSpotManager(local: DefaultZLinkSpotManager): import('../../contracts').ZLinkSpotManager;
     private actorRuntimeOptionsFactory;
     private createChannelRuntimeOptions;
-    private createSpotNodeRuntimeOptions;
+    createSpotNodeRuntimeOptions(context: ZLinkBackendContext, dispatchErrors: ZLinkDispatchErrorReporter): {
+        admission: ZLinkRuntimeAdmissionGate;
+        errorSink: ZLinkDispatchErrorSink;
+        peerAdmissionSealed: (meshName: string) => boolean;
+        messageFollowReceiver: (record: ServiceMessageFollowRecord) => void;
+        meshRecordDispatcher: (meshName: string, owner: ReadyRecord, record: ReceiveRecord) => void | Promise<void>;
+        activationConcurrency: (meshName: string) => import("../activation-admission").ZLinkActivationConcurrency;
+        context: ZLinkBackendContext;
+        applicationJobQueue?: ApplicationJobQueue;
+        registration: ZLinkFrameworkRegistration;
+        messageSerializers?: ReadonlyMap<string, import("../../contracts").ZLinkMessageSerializer>;
+        providerResolver?: ZLinkProviderResolver;
+        metrics?: import("../diagnostics").ZLinkRuntimeMetrics;
+        spotRouterChannelIdForMesh?: (meshName: string) => string;
+        runtimeEventPublisher?: ZLinkRuntimeEventPublisher;
+        actorHandoffRuntime?: import("../spots/spot-runtime-ports").ZLinkSpotActorHandoffRuntime;
+        actorTransferRuntime?: import("../spots/spot-runtime-ports").ZLinkSpotActorTransferRuntime;
+        boundSessionRuntime?: import("../spots/spot-runtime-ports").ZLinkSpotBoundSessionRuntime;
+        detachedTaskRunner: ZLinkDetachedTaskRunner;
+        dispatchErrors?: ZLinkDispatchErrorReporter;
+        channelClient?: import("../../contracts").ZLinkChannelClient;
+        fanoutClient?: import("../../contracts").ZLinkFanoutClient;
+        spotPublisherClient?: import("../../contracts").ZLinkSpotPublisherClient;
+        routedTransport?: import("../spots").ZLinkSpotRoutedTransport;
+        requests?: RequestRuntime;
+        listenerRecords?: ZLinkListenerRecords;
+        primaryMeshName?: string;
+        backendAdapterFactory: ZLinkBackendAdapterFactory;
+        spotRouteResolver?: ZLinkSpotRouteResolver;
+        entryActorRuntime?: import("../spots/spot-runtime-ports").ZLinkEntryActorRuntime;
+        applicationJobReceiveFlowFailureSink?: (error: unknown) => void;
+    };
     private dispatchMeshNodeRecord;
     private dispatchMeshNodePayload;
     private completeFormalSourceLeave;
-    private dispatchMeshRecord;
+    dispatchMeshRecord(applicationJobOrigin: () => ApplicationJobOrigin, meshName: string, owner: ReadyRecord, record: ReceiveRecord, signal?: AbortSignal): void | Promise<void>;
     private admitMeshDispatch;
-    private dispatchMeshActorBinding;
-    private submitLocalMeshRoute;
-    private dispatchMeshSpotRecord;
-    private createDispatchErrorReporter;
+    dispatchMeshActorBinding(meshName: string, record: ReceiveRecord, signal?: AbortSignal): Promise<void>;
+    submitLocalMeshRoute(meshName: string, sourceNodeRid: string, parts: readonly MessageLike[]): {
+        readonly status: ZLinkSubmitStatus.Shutdown;
+    } | {
+        readonly status: ZLinkSubmitStatus.TargetNotFound;
+    } | {
+        readonly status: ZLinkSubmitStatus.Submitted;
+    };
+    dispatchMeshSpotRecord(meshName: string, owner: ReadyRecord, record: ReceiveRecord, admit?: ZLinkMeshDispatchAdmission): Promise<void>;
+    createDispatchErrorReporter(errorSink: ZLinkDispatchErrorSink): ZLinkDispatchErrorReporter;
     detachedTaskRunner(): ZLinkDetachedTaskRunner;
     private diagnosticsContext;
-    private flowCreationEnabled;
+    flowCreationEnabled(): boolean;
     private runLifecycle;
     requirePrimaryMeshNode(): ZLinkBackendMeshNode;
     private ensureLocationRuntime;
-    private createLocationSpotRouteResolver;
-    private createActorLocationResolver;
+    createLocationSpotRouteResolver(): ZLinkSpotRouteResolver | undefined;
+    createActorLocationResolver(): ZLinkStoreLocationResolvers | undefined;
 }
 export declare function hasUnsupportedManualTopology(registration: ZLinkFrameworkRegistration): boolean;
 export declare function hasExactPeerReadiness(descriptors: readonly ZLinkMeshNodeDescriptor[], local: {